Ticket #46280: hotfix.46280.2.diff

trunk/hotfix.php

@@ -2 +2 @@
 /*
 Plugin Name: Hotfix
 Description: Provides "hotfixes" for selected WordPress bugs, so you don't have to wait for the next WordPress core release. Keep the plugin updated!
-Version: 1.1
+Version: 1.2
 Author: Mark Jaquith
 Author URI: http://coveredwebservices.com/
 */
@@ -34 +34 @@
         $hotfixes = array();
 
         switch ( $wp_version ) {
+                case '5.1' :
+                        $hotfixes = array( '510_comment_reply_js' );
+                        break;
                 case '3.5' :
                         $hotfixes = array( '350_twentytwelve', '350_iis_http_failure' );
                         break;
@@ -238 +241 @@
                 return $temp;
         return false;
 }
+
+function wp_hotfix_510_comment_reply_js() {
+        add_action( 'wp_enqueue_scripts', 'wp_hotfix_510_enqueue_comment_reply_js', 99 );
+}
+
+function wp_hotfix_510_enqueue_comment_reply_js() {
+        global $wp_scripts;
+
+        $suffix = SCRIPT_DEBUG ? '' : '.min';
+
+        $wp_scripts->registered['comment-reply']->src = plugins_url( "js/comment-reply$suffix.js", __FILE__ );
+        $wp_scripts->registered['comment-reply']->ver = 'wp46280';
+}

trunk/js/comment-reply.js

@@ +1 @@
+/**
+ * Handles the addition of the comment form.
+ *
+ * @since 2.7.0
+ * @output wp-includes/js/comment-reply.js
+ *
+ * @namespace addComment
+ *
+ * @type {Object}
+ */
+window.addComment = ( function( window ) {
+        // Avoid scope lookups on commonly used variables.
+        var document = window.document;
+
+        // Settings.
+        var config = {
+                commentReplyClass : 'comment-reply-link',
+                cancelReplyId     : 'cancel-comment-reply-link',
+                commentFormId     : 'commentform',
+                temporaryFormId   : 'wp-temp-form-div',
+                parentIdFieldId   : 'comment_parent',
+                postIdFieldId     : 'comment_post_ID'
+        };
+
+        // Cross browser MutationObserver.
+        var MutationObserver = window.MutationObserver || window.WebKitMutationObserver || window.MozMutationObserver;
+
+        // Check browser cuts the mustard.
+        var cutsTheMustard = 'querySelector' in document && 'addEventListener' in window;
+
+        /*
+         * Check browser supports dataset.
+         * !! sets the variable to true if the property exists.
+         */
+        var supportsDataset = !! document.documentElement.dataset;
+
+        // For holding the cancel element.
+        var cancelElement;
+
+        // For holding the comment form element.
+        var commentFormElement;
+
+        // The respond element.
+        var respondElement;
+
+        // The mutation observer.
+        var observer;
+
+        if ( cutsTheMustard && document.readyState !== 'loading' ) {
+                ready();
+        } else if ( cutsTheMustard ) {
+                window.addEventListener( 'DOMContentLoaded', ready, false );
+        }
+
+        /**
+         * Sets up object variables after the DOM is ready.
+         *
+         * @since 5.1.0
+         */
+        function ready() {
+                // Initialise the events.
+                init();
+
+                // Set up a MutationObserver to check for comments loaded late.
+                observeChanges();
+        }
+
+        /**
+         * Add events to links classed .comment-reply-link.
+         *
+         * Searches the context for reply links and adds the JavaScript events
+         * required to move the comment form. To allow for lazy loading of
+         * comments this method is exposed as window.commentReply.init().
+         *
+         * @since 5.1.0
+         *
+         * @memberOf addComment
+         *
+         * @param {HTMLElement} context The parent DOM element to search for links.
+         */
+        function init( context ) {
+                if ( ! cutsTheMustard ) {
+                        return;
+                }
+
+                // Get required elements.
+                cancelElement = getElementById( config.cancelReplyId );
+                commentFormElement = getElementById( config.commentFormId );
+
+                // No cancel element, no replies.
+                if ( ! cancelElement ) {
+                        return;
+                }
+
+                cancelElement.addEventListener( 'touchstart', cancelEvent );
+                cancelElement.addEventListener( 'click',      cancelEvent );
+
+                var links = replyLinks( context );
+                var element;
+
+                for ( var i = 0, l = links.length; i < l; i++ ) {
+                        element = links[i];
+
+                        element.addEventListener( 'touchstart', clickEvent );
+                        element.addEventListener( 'click',      clickEvent );
+                }
+        }
+
+        /**
+         * Return all links classed .comment-reply-link.
+         *
+         * @since 5.1.0
+         *
+         * @param {HTMLElement} context The parent DOM element to search for links.
+         *
+         * @return {HTMLCollection|NodeList|Array}
+         */
+        function replyLinks( context ) {
+                var selectorClass = config.commentReplyClass;
+                var allReplyLinks;
+
+                // childNodes is a handy check to ensure the context is a HTMLElement.
+                if ( ! context || ! context.childNodes ) {
+                        context = document;
+                }
+
+                if ( document.getElementsByClassName ) {
+                        // Fastest.
+                        allReplyLinks = context.getElementsByClassName( selectorClass );
+                }
+                else {
+                        // Fast.
+                        allReplyLinks = context.querySelectorAll( '.' + selectorClass );
+                }
+
+                return allReplyLinks;
+        }
+
+        /**
+         * Cancel event handler.
+         *
+         * @since 5.1.0
+         *
+         * @param {Event} event The calling event.
+         */
+        function cancelEvent( event ) {
+                var cancelLink = this;
+                var temporaryFormId  = config.temporaryFormId;
+                var temporaryElement = getElementById( temporaryFormId );
+
+                if ( ! temporaryElement || ! respondElement ) {
+                        // Conditions for cancel link fail.
+                        return;
+                }
+
+                getElementById( config.parentIdFieldId ).value = '0';
+
+                // Move the respond form back in place of the temporary element.
+                temporaryElement.parentNode.replaceChild( respondElement ,temporaryElement );
+                cancelLink.style.display = 'none';
+                event.preventDefault();
+        }
+
+        /**
+         * Click event handler.
+         *
+         * @since 5.1.0
+         *
+         * @param {Event} event The calling event.
+         */
+        function clickEvent( event ) {
+                var replyLink = this,
+                        commId    = getDataAttribute( replyLink, 'belowelement'),
+                        parentId  = getDataAttribute( replyLink, 'commentid' ),
+                        respondId = getDataAttribute( replyLink, 'respondelement'),
+                        postId    = getDataAttribute( replyLink, 'postid'),
+                        follow;
+
+                if ( ! commId || ! parentId || ! respondId || ! postId ) {
+                        /*
+                         * Theme or plugin defines own link via custom `wp_list_comments()` callback
+                         * and calls `moveForm()` either directly or via a custom event hook.
+                         */
+                        return;
+                }
+
+                /*
+                 * Third party comments systems can hook into this function via the global scope,
+                 * therefore the click event needs to reference the global scope.
+                 */
+                follow = window.addComment.moveForm(commId, parentId, respondId, postId);
+                if ( false === follow ) {
+                        event.preventDefault();
+                }
+        }
+
+        /**
+         * Creates a mutation observer to check for newly inserted comments.
+         *
+         * @since 5.1.0
+         */
+        function observeChanges() {
+                if ( ! MutationObserver ) {
+                        return;
+                }
+
+                var observerOptions = {
+                        childList: true,
+                        subTree: true
+                };
+
+                observer = new MutationObserver( handleChanges );
+                observer.observe( document.body, observerOptions );
+        }
+
+        /**
+         * Handles DOM changes, calling init() if any new nodes are added.
+         *
+         * @since 5.1.0
+         *
+         * @param {Array} mutationRecords Array of MutationRecord objects.
+         */
+        function handleChanges( mutationRecords ) {
+                var i = mutationRecords.length;
+
+                while ( i-- ) {
+                        // Call init() once if any record in this set adds nodes.
+                        if ( mutationRecords[ i ].addedNodes.length ) {
+                                init();
+                                return;
+                        }
+                }
+        }
+
+        /**
+         * Backward compatible getter of data-* attribute.
+         *
+         * Uses element.dataset if it exists, otherwise uses getAttribute.
+         *
+         * @since 5.1.0
+         *
+         * @param {HTMLElement} Element DOM element with the attribute.
+         * @param {String}      Attribute the attribute to get.
+         *
+         * @return {String}
+         */
+        function getDataAttribute( element, attribute ) {
+                if ( supportsDataset ) {
+                        return element.dataset[attribute];
+                }
+                else {
+                        return element.getAttribute( 'data-' + attribute );
+                }
+        }
+
+        /**
+         * Get element by ID.
+         *
+         * Local alias for document.getElementById.
+         *
+         * @since 5.1.0
+         *
+         * @param {HTMLElement} The requested element.
+         */
+        function getElementById( elementId ) {
+                return document.getElementById( elementId );
+        }
+
+        /**
+         * Moves the reply form from its current position to the reply location.
+         *
+         * @since 2.7.0
+         *
+         * @memberOf addComment
+         *
+         * @param {String} addBelowId HTML ID of element the form follows.
+         * @param {String} commentId  Database ID of comment being replied to.
+         * @param {String} respondId  HTML ID of 'respond' element.
+         * @param {String} postId     Database ID of the post.
+         */
+        function moveForm( addBelowId, commentId, respondId, postId ) {
+                // Get elements based on their IDs.
+                var addBelowElement = getElementById( addBelowId );
+                respondElement  = getElementById( respondId );
+
+                // Get the hidden fields.
+                var parentIdField   = getElementById( config.parentIdFieldId );
+                var postIdField     = getElementById( config.postIdFieldId );
+                var element, cssHidden, style;
+
+                if ( ! addBelowElement || ! respondElement || ! parentIdField ) {
+                        // Missing key elements, fail.
+                        return;
+                }
+
+                addPlaceHolder( respondElement );
+
+                // Set the value of the post.
+                if ( postId && postIdField ) {
+                        postIdField.value = postId;
+                }
+
+                parentIdField.value = commentId;
+
+                cancelElement.style.display = '';
+                addBelowElement.parentNode.insertBefore( respondElement, addBelowElement.nextSibling );
+
+                /*
+                 * This is for backward compatibility with third party commenting systems
+                 * hooking into the event using older techniques.
+                 */
+                cancelElement.onclick = function(){
+                        return false;
+                };
+
+                // Focus on the first field in the comment form.
+                try {
+                        for ( var i = 0; i < commentFormElement.elements.length; i++ ) {
+                                element = commentFormElement.elements[i];
+                                cssHidden = false;
+
+                                // Get elements computed style.
+                                if ( 'getComputedStyle' in window ) {
+                                        // Modern browsers.
+                                        style = window.getComputedStyle( element );
+                                } else if ( document.documentElement.currentStyle ) {
+                                        // IE 8.
+                                        style = element.currentStyle;
+                                }
+
+                                /*
+                                 * For display none, do the same thing jQuery does. For visibility,
+                                 * check the element computed style since browsers are already doing
+                                 * the job for us. In fact, the visibility computed style is the actual
+                                 * computed value and already takes into account the element ancestors.
+                                 */
+                                if ( ( element.offsetWidth <= 0 && element.offsetHeight <= 0 ) || style.visibility === 'hidden' ) {
+                                        cssHidden = true;
+                                }
+
+                                // Skip form elements that are hidden or disabled.
+                                if ( 'hidden' === element.type || element.disabled || cssHidden ) {
+                                        continue;
+                                }
+
+                                element.focus();
+                                // Stop after the first focusable element.
+                                break;
+                        }
+                }
+                catch(e) {
+
+                }
+
+                /*
+                 * false is returned for backward compatibility with third party commenting systems
+                 * hooking into this function.
+                 */
+                return false;
+        }
+
+        /**
+         * Add placeholder element.
+         *
+         * Places a place holder element above the #respond element for
+         * the form to be returned to if needs be.
+         *
+         * @since 2.7.0
+         *
+         * @param {HTMLelement} respondElement the #respond element holding comment form.
+         */
+        function addPlaceHolder( respondElement ) {
+                var temporaryFormId  = config.temporaryFormId;
+                var temporaryElement = getElementById( temporaryFormId );
+
+                if ( temporaryElement ) {
+                        // The element already exists, no need to recreate.
+                        return;
+                }
+
+                temporaryElement = document.createElement( 'div' );
+                temporaryElement.id = temporaryFormId;
+                temporaryElement.style.display = 'none';
+                respondElement.parentNode.insertBefore( temporaryElement, respondElement );
+        }
+
+        return {
+                init: init,
+                moveForm: moveForm
+        };
+})( window );

trunk/js/comment-reply.min.js

@@ +1 @@
+window.addComment=function(a){function b(){c(),g()}function c(a){if(t&&(m=j(r.cancelReplyId),n=j(r.commentFormId),m)){m.addEventListener("touchstart",e),m.addEventListener("click",e);for(var b,c=d(a),g=0,h=c.length;g<h;g++)b=c[g],b.addEventListener("touchstart",f),b.addEventListener("click",f)}}function d(a){var b,c=r.commentReplyClass;return a&&a.childNodes||(a=q),b=q.getElementsByClassName?a.getElementsByClassName(c):a.querySelectorAll("."+c)}function e(a){var b=this,c=r.temporaryFormId,d=j(c);d&&o&&(j(r.parentIdFieldId).value="0",d.parentNode.replaceChild(o,d),b.style.display="none",a.preventDefault())}function f(b){var c,d=this,e=i(d,"belowelement"),f=i(d,"commentid"),g=i(d,"respondelement"),h=i(d,"postid");e&&f&&g&&h&&(c=a.addComment.moveForm(e,f,g,h),!1===c&&b.preventDefault())}function g(){if(s){var a={childList:!0,subTree:!0};p=new s(h),p.observe(q.body,a)}}function h(a){for(var b=a.length;b--;)if(a[b].addedNodes.length)return void c()}function i(a,b){return u?a.dataset[b]:a.getAttribute("data-"+b)}function j(a){return q.getElementById(a)}function k(b,c,d,e){var f=j(b);o=j(d);var g,h,i,k=j(r.parentIdFieldId),p=j(r.postIdFieldId);if(f&&o&&k){l(o),e&&p&&(p.value=e),k.value=c,m.style.display="",f.parentNode.insertBefore(o,f.nextSibling),m.onclick=function(){return!1};try{for(var s=0;s<n.elements.length;s++)if(g=n.elements[s],h=!1,"getComputedStyle"in a?i=a.getComputedStyle(g):q.documentElement.currentStyle&&(i=g.currentStyle),(g.offsetWidth<=0&&g.offsetHeight<=0||"hidden"===i.visibility)&&(h=!0),"hidden"!==g.type&&!g.disabled&&!h){g.focus();break}}catch(t){}return!1}}function l(a){var b=r.temporaryFormId,c=j(b);c||(c=q.createElement("div"),c.id=b,c.style.display="none",a.parentNode.insertBefore(c,a))}var m,n,o,p,q=a.document,r={commentReplyClass:"comment-reply-link",cancelReplyId:"cancel-comment-reply-link",commentFormId:"commentform",temporaryFormId:"wp-temp-form-div",parentIdFieldId:"comment_parent",postIdFieldId:"comment_post_ID"},s=a.MutationObserver||a.WebKitMutationObserver||a.MozMutationObserver,t="querySelector"in q&&"addEventListener"in a,u=!!q.documentElement.dataset;return t&&"loading"!==q.readyState?b():t&&a.addEventListener("DOMContentLoaded",b,!1),{init:c,moveForm:k}}(window);

trunk/readme.txt

@@ -3 +3 @@
 Tags: hotfix, bugs, wordpress, update
 Requires at least: 3.0
 Tested up to: 3.5
-Stable tag: 1.0
+Stable tag: 1.2
 
 Provides unofficial fixes for selected WordPress bugs, so you don't have to wait for the next WordPress core release.
 
@@ -13 +13 @@
 
 Recent fixes:
 
-* **WordPress 3.5**
-        * Lets you update Twenty Twelve if it is shown as "broken" after installing 3.5
-        * Lets you update WordPress and install or update plugins and themes. (Only some Windows servers running IIS were affected.) You'll need to [install this plugin manually](http://codex.wordpress.org/Managing_Plugins#Manual_Plugin_Installation).
+* **WordPress 5.0**
+        * Lets themes enqueue `comment-reply.js` in the HTML header without JavaScript errors, see [WP#46280](https://core.trac.wordpress.org/ticket/46280).
 
-* **WordPress 3.4.2**
-        * Fix adding and updating Custom Fields
-
 Fixes are specific to your version of WordPress. It may be that your version of WordPress has no fixes. That's fine. Keep the plugin activated and updated, in case you need it for a subsequent version of WordPress!
 
 == Installation ==
@@ -37 +33 @@
 Read the "Complete Hotfix List" section in the description. A later version of the plugin may list the hotfixes in a special WordPress admin page.
 
 == Changelog ==
+= 1.2 =
+* Lets themes enqueue `comment-reply.js` in the HTML header without JavaScript errors.
+
 = 1.1 =
 * Lets you update WordPress and install or update plugins and themes. (Only some Windows servers running IIS were affected.) You'll need to [install this plugin manually](http://codex.wordpress.org/Managing_Plugins#Manual_Plugin_Installation).