Changeset 2814 for sites/trunk/wordpress.org/public_html/wp-content/themes/pub/wporg-developer/inc/formatting.php

Timestamp:

03/25/2016 06:22:12 PM (9 years ago)

Author:

coffee2code

Message:

developer.wordpress.org: Auto-link plaintext references to classes, functions, and methods.

• Ignores references made in <code> blocks.
• Does not attempt to recognize references to hooks. Such references must use {@see 'hook_name'} syntax.

Fixes #1483.

File:

• sites/trunk/wordpress.org/public_html/wp-content/themes/pub/wporg-developer/inc/formatting.php (modified) (2 diffs)

sites/trunk/wordpress.org/public_html/wp-content/themes/pub/wporg-developer/inc/formatting.php

@@ -27 +27 @@
         add_filter( 'the_excerpt', array( __CLASS__, 'remove_inline_internal' ) );
         add_filter( 'the_content', array( __CLASS__, 'remove_inline_internal' ) );
+
+        add_filter( 'the_excerpt', array( __CLASS__, 'autolink_references' ), 11 );
+        add_filter( 'the_content', array( __CLASS__, 'autolink_references' ), 11 );
 
         add_action( 'the_content', array( __CLASS__, 'fix_unintended_markdown' ) );
@@ -237 +240 @@
     }
 
+    /**
+     * Automatically detects inline references to parsed resources and links to them.
+     *
+     * Examples:
+     * - Functions: get_the_ID()
+     * - Classes:   WP_Query
+     * - Methods:   WP_Query::is_single()
+     *
+     * Note: currently there is not a reliable way to infer references to hooks. Recommend
+     * using the {@}see 'hook_name'} notation as used in the inline docs.
+     *
+     * @param  string $text The text.
+     * @return string
+     */
+    public function autolink_references( $text ) {
+        $r = '';
+        $textarr = preg_split( '/(<[^<>]+>)/', $text, -1, PREG_SPLIT_DELIM_CAPTURE ); // split out HTML tags
+        $nested_code_pre = 0; // Keep track of how many levels link is nested inside <pre> or <code>
+        foreach ( $textarr as $piece ) {
+
+            if ( preg_match( '|^<code[\s>]|i', $piece ) || preg_match( '|^<pre[\s>]|i', $piece ) || preg_match( '|^<script[\s>]|i', $piece ) || preg_match( '|^<style[\s>]|i', $piece ) )
+                $nested_code_pre++;
+            elseif ( $nested_code_pre && ( '</code>' === strtolower( $piece ) || '</pre>' === strtolower( $piece ) || '</script>' === strtolower( $piece ) || '</style>' === strtolower( $piece ) ) )
+                $nested_code_pre--;
+
+            if ( $nested_code_pre || empty( $piece ) || ( $piece[0] === '<' && ! preg_match( '|^<\s*[\w]{1,20}+://|', $piece ) ) ) {
+                $r .= $piece;
+                continue;
+            }
+
+            // Long strings might contain expensive edge cases ...
+            if ( 10000 < strlen( $piece ) ) {
+                // ... break it up
+                foreach ( _split_str_by_whitespace( $piece, 2100 ) as $chunk ) { // 2100: Extra room for scheme and leading and trailing paretheses
+                    if ( 2101 < strlen( $chunk ) ) {
+                        $r .= $chunk; // Too big, no whitespace: bail.
+                    } else {
+                        $r .= make_clickable( $chunk );
+                    }
+                }
+            } else {
+                /*
+                 * Everthing outside of this conditional block was copied from core's
+                 *`make_clickable()`.
+                 */
+
+                $content = " $piece "; // Pad with whitespace to simplify the regexes
+
+                // Only if the text contains something that might be a function.
+                if ( false !== strpos( $content, '()' ) ) {
+
+                    // Detect references to class methods, e.g. WP_Query::query()
+                    // or functions, e.g. register_post_type().
+                    $content = preg_replace_callback(
+                        '~
+                            (?!<.*?)       # Non-capturing check to ensure not matching what looks like the inside of an HTML tag.
+                            (              # 1: The full method or function name.
+                                ((\w+)::)? # 2: The class prefix, if a method reference.
+                                (\w+)      # 3: The method or function name.
+                            )
+                            \(\)           # The () that signifies either a method or function.
+                            (?![^<>]*?>)   # Non-capturing check to ensure not matching what looks like the inside of an HTML tag.
+                        ~x',
+                        function ( $matches ) {
+                            // Reference to a class method.
+                            if ( $matches[2] ) {
+                                // Only link actually parsed methods.
+                                if ( $post = get_page_by_title( $matches[1], OBJECT, 'wp-parser-method' ) ) {
+                                    return sprintf(
+                                        '<a href="%s">%s</a>',
+                                        get_permalink( $post->ID ),
+                                        $matches[0]
+                                    );
+                                }
+
+                            // Reference to a function.
+                            } else {
+                                // Only link actually parsed functions.
+                                if ( $post = get_page_by_title( $matches[1], OBJECT, 'wp-parser-function' ) ) {
+                                    return sprintf(
+                                        '<a href="%s">%s</a>',
+                                        get_permalink( $post->ID ),
+                                        $matches[0]
+                                    );
+                                }
+                            }
+
+                            // It's not a reference to an actual thing, so restore original text.
+                            return $matches[0];
+                        },
+                        $content
+                    );
+
+                }
+
+                // Detect references to classes, e.g. WP_Query
+                $content = preg_replace_callback(
+                    // Most class names start with an uppercase letter and have an underscore.
+                    // The exceptions are explicitly listed since future classes likely won't violate previous statement.
+                    '~'
+                        . '(?<!/)'
+                        . '\b'                // Word boundary
+                        . '('                 // Primary match grouping
+                            . 'wpdb|wp_atom_server|wp_xmlrpc_server extends IXR_Server'               // Exceptions that start with lowercase letter
+                            . '|AtomFeed|AtomEntry|AtomParser|MagpieRSS|RSSCache|Translations|Walker' // Exceptions that lack an underscore
+                            . '|[A-Z][a-zA-Z]+_\w+'                                                   // Most start with uppercase, has underscore
+                        . ')'                 // End primary match grouping
+                        . '\b'                // Word boundary
+                        . '(?!([<:]|"|\'>))'  // Does not appear within a tag
+                    . '~',
+                    function ( $matches ) {
+                        // If match is all caps, it's not a possible class name.
+                        // We'll chalk the sole exception, WP, as merely being an abbreviation (the regex won't match it anyhow).
+                        if ( strtoupper( $matches[0] ) === $matches[0] ) {
+                            return $matches[0];
+                        }
+
+                        // Only link actually parsed classes.
+                        if ( $post = get_page_by_title( $matches[0], OBJECT, 'wp-parser-class' ) ) {
+                            return sprintf(
+                                '<a href="%s">%s</a>',
+                                get_permalink( $post->ID ),
+                                $matches[0]
+                            );
+                        }
+
+                        // Not a class reference, so put the original reference back in.
+                        return $matches[0];
+                    },
+                    $content
+                );
+
+                // Maybelater: Detect references to hooks, Currently not deemed reliably possible.
+
+                $content = substr( $content, 1, -1 ); // Remove our whitespace padding.
+                $r .= $content;
+
+            } // end else
+
+        } // end foreach
+
+        // Cleanup of accidental links within links
+        return preg_replace( '#(<a([ \r\n\t]+[^>]+?>|>))<a [^>]+?>([^>]+?)</a></a>#i', "$1$3</a>", $r );
+    }
+
 } // DevHub_Formatting