Ticket #174: 174.patch

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

@@ -81 +81 @@
 require __DIR__ . '/inc/search.php';
 
 /**
+ * Title keywords algorithm for related posts
+ */
+require __DIR__ . '/inc/title-keywords.php';
+
+/**
+ * PHP5 Implementation of the Porter Stemmer algorithm
+ */
+require __DIR__ . '/inc/porterstemmer.php';
+
+/**
  * Set the content width based on the theme's design and stylesheet.
  */
 if ( ! isset( $content_width ) ) {

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

@@ +1 @@
+<?php
+namespace DevHub;
+
+
+/**
+ * Copyright (c) 2005 Richard Heyes (http://www.phpguru.org/)
+ *
+ * All rights reserved.
+ *
+ * This script is free software.
+ */
+
+/**
+ * PHP5 Implementation of the Porter Stemmer algorithm. Certain elements
+ * were borrowed from the (broken) implementation by Jon Abernathy.
+ *
+ * Usage:
+ *
+ *  $stem = PorterStemmer::Stem($word);
+ *
+ * How easy is that?
+ */
+
+class PorterStemmer {
+    /**
+     * Regex for matching a consonant
+     *
+     * @var string
+     */
+    private static $regex_consonant = '(?:[bcdfghjklmnpqrstvwxz]|(?<=[aeiou])y|^y)';
+
+
+    /**
+     * Regex for matching a vowel
+     *
+     * @var string
+     */
+    private static $regex_vowel = '(?:[aeiou]|(?<![aeiou])y)';
+
+
+    /**
+     * Stems a word. Simple huh?
+     *
+     * @param string  $word Word to stem
+     * @return string       Stemmed word
+     */
+    public static function Stem( $word ) {
+        if ( strlen( $word ) <= 2 ) {
+            return $word;
+        }
+
+        $word = self::step1ab( $word );
+        $word = self::step1c( $word );
+        $word = self::step2( $word );
+        $word = self::step3( $word );
+        $word = self::step4( $word );
+        $word = self::step5( $word );
+
+        return $word;
+    }
+
+
+    /**
+     * Step 1
+     */
+    private static function step1ab( $word ) {
+        // Part a
+        if ( substr( $word, -1 ) == 's' ) {
+
+            self::replace( $word, 'sses', 'ss' )
+                or self::replace( $word, 'ies', 'i' )
+                or self::replace( $word, 'ss', 'ss' )
+                or self::replace( $word, 's', '' );
+        }
+
+        // Part b
+        if ( substr( $word, -2, 1 ) != 'e' or !self::replace( $word, 'eed', 'ee', 0 ) ) { // First rule
+            $v = self::$regex_vowel;
+
+            // ing and ed
+            if (   preg_match( "#$v+#", substr( $word, 0, -3 ) ) && self::replace( $word, 'ing', '' )
+                or preg_match( "#$v+#", substr( $word, 0, -2 ) ) && self::replace( $word, 'ed', '' ) ) { // Note use of && and OR, for precedence reasons
+
+                // If one of above two test successful
+                if (    !self::replace( $word, 'at', 'ate' )
+                    and !self::replace( $word, 'bl', 'ble' )
+                    and !self::replace( $word, 'iz', 'ize' ) ) {
+
+                    // Double consonant ending
+                    if (    self::doubleConsonant( $word )
+                        and substr( $word, -2 ) != 'll'
+                        and substr( $word, -2 ) != 'ss'
+                        and substr( $word, -2 ) != 'zz' ) {
+
+                        $word = substr( $word, 0, -1 );
+
+                    } else if ( self::m( $word ) == 1 and self::cvc( $word ) ) {
+                            $word .= 'e';
+                        }
+                }
+            }
+        }
+
+        return $word;
+    }
+
+
+    /**
+     * Step 1c
+     *
+     * @param string  $word Word to stem
+     */
+    private static function step1c( $word ) {
+        $v = self::$regex_vowel;
+
+        if ( substr( $word, -1 ) == 'y' && preg_match( "#$v+#", substr( $word, 0, -1 ) ) ) {
+            self::replace( $word, 'y', 'i' );
+        }
+
+        return $word;
+    }
+
+
+    /**
+     * Step 2
+     *
+     * @param string  $word Word to stem
+     */
+    private static function step2( $word ) {
+        switch ( substr( $word, -2, 1 ) ) {
+        case 'a':
+            self::replace( $word, 'ational', 'ate', 0 )
+                or self::replace( $word, 'tional', 'tion', 0 );
+            break;
+
+        case 'c':
+            self::replace( $word, 'enci', 'ence', 0 )
+                or self::replace( $word, 'anci', 'ance', 0 );
+            break;
+
+        case 'e':
+            self::replace( $word, 'izer', 'ize', 0 );
+            break;
+
+        case 'g':
+            self::replace( $word, 'logi', 'log', 0 );
+            break;
+
+        case 'l':
+            self::replace( $word, 'entli', 'ent', 0 )
+                or self::replace( $word, 'ousli', 'ous', 0 )
+                or self::replace( $word, 'alli', 'al', 0 )
+                or self::replace( $word, 'bli', 'ble', 0 )
+                or self::replace( $word, 'eli', 'e', 0 );
+            break;
+
+        case 'o':
+            self::replace( $word, 'ization', 'ize', 0 )
+                or self::replace( $word, 'ation', 'ate', 0 )
+                or self::replace( $word, 'ator', 'ate', 0 );
+            break;
+
+        case 's':
+            self::replace( $word, 'iveness', 'ive', 0 )
+                or self::replace( $word, 'fulness', 'ful', 0 )
+                or self::replace( $word, 'ousness', 'ous', 0 )
+                or self::replace( $word, 'alism', 'al', 0 );
+            break;
+
+        case 't':
+            self::replace( $word, 'biliti', 'ble', 0 )
+                or self::replace( $word, 'aliti', 'al', 0 )
+                or self::replace( $word, 'iviti', 'ive', 0 );
+            break;
+        }
+
+        return $word;
+    }
+
+
+    /**
+     * Step 3
+     *
+     * @param string  $word String to stem
+     */
+    private static function step3( $word ) {
+        switch ( substr( $word, -2, 1 ) ) {
+        case 'a':
+            self::replace( $word, 'ical', 'ic', 0 );
+            break;
+
+        case 's':
+            self::replace( $word, 'ness', '', 0 );
+            break;
+
+        case 't':
+            self::replace( $word, 'icate', 'ic', 0 )
+                or self::replace( $word, 'iciti', 'ic', 0 );
+            break;
+
+        case 'u':
+            self::replace( $word, 'ful', '', 0 );
+            break;
+
+        case 'v':
+            self::replace( $word, 'ative', '', 0 );
+            break;
+
+        case 'z':
+            self::replace( $word, 'alize', 'al', 0 );
+            break;
+        }
+
+        return $word;
+    }
+
+
+    /**
+     * Step 4
+     *
+     * @param string  $word Word to stem
+     */
+    private static function step4( $word ) {
+        switch ( substr( $word, -2, 1 ) ) {
+        case 'a':
+            self::replace( $word, 'al', '', 1 );
+            break;
+
+        case 'c':
+            self::replace( $word, 'ance', '', 1 )
+                or self::replace( $word, 'ence', '', 1 );
+            break;
+
+        case 'e':
+            self::replace( $word, 'er', '', 1 );
+            break;
+
+        case 'i':
+            self::replace( $word, 'ic', '', 1 );
+            break;
+
+        case 'l':
+            self::replace( $word, 'able', '', 1 )
+                or self::replace( $word, 'ible', '', 1 );
+            break;
+
+        case 'n':
+            self::replace( $word, 'ant', '', 1 )
+                or self::replace( $word, 'ement', '', 1 )
+                or self::replace( $word, 'ment', '', 1 )
+                or self::replace( $word, 'ent', '', 1 );
+            break;
+
+        case 'o':
+            if ( substr( $word, -4 ) == 'tion' or substr( $word, -4 ) == 'sion' ) {
+                self::replace( $word, 'ion', '', 1 );
+            } else {
+                self::replace( $word, 'ou', '', 1 );
+            }
+            break;
+
+        case 's':
+            self::replace( $word, 'ism', '', 1 );
+            break;
+
+        case 't':
+            self::replace( $word, 'ate', '', 1 )
+                or self::replace( $word, 'iti', '', 1 );
+            break;
+
+        case 'u':
+            self::replace( $word, 'ous', '', 1 );
+            break;
+
+        case 'v':
+            self::replace( $word, 'ive', '', 1 );
+            break;
+
+        case 'z':
+            self::replace( $word, 'ize', '', 1 );
+            break;
+        }
+
+        return $word;
+    }
+
+
+    /**
+     * Step 5
+     *
+     * @param string  $word Word to stem
+     */
+    private static function step5( $word ) {
+        // Part a
+        if ( substr( $word, -1 ) == 'e' ) {
+            if ( self::m( substr( $word, 0, -1 ) ) > 1 ) {
+                self::replace( $word, 'e', '' );
+
+            } else if ( self::m( substr( $word, 0, -1 ) ) == 1 ) {
+
+                    if ( !self::cvc( substr( $word, 0, -1 ) ) ) {
+                        self::replace( $word, 'e', '' );
+                    }
+                }
+        }
+
+        // Part b
+        if ( self::m( $word ) > 1 and self::doubleConsonant( $word ) and substr( $word, -1 ) == 'l' ) {
+            $word = substr( $word, 0, -1 );
+        }
+
+        return $word;
+    }
+
+
+    /**
+     * Replaces the first string with the second, at the end of the string. If third
+     * arg is given, then the preceding string must match that m count at least.
+     *
+     * @param string  $str   String to check
+     * @param string  $check Ending to check for
+     * @param string  $repl  Replacement string
+     * @param int     $m     Optional minimum number of m() to meet
+     * @return bool          Whether the $check string was at the end
+     *                       of the $str string. True does not necessarily mean
+     *                       that it was replaced.
+     */
+    private static function replace( &$str, $check, $repl, $m = null ) {
+        $len = 0 - strlen( $check );
+
+        if ( substr( $str, $len ) == $check ) {
+            $substr = substr( $str, 0, $len );
+            if ( is_null( $m ) or self::m( $substr ) > $m ) {
+                $str = $substr . $repl;
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+
+    /**
+     * What, you mean it's not obvious from the name?
+     *
+     * m() measures the number of consonant sequences in $str. if c is
+     * a consonant sequence and v a vowel sequence, and <..> indicates arbitrary
+     * presence,
+     *
+     * <c><v>       gives 0
+     * <c>vc<v>     gives 1
+     * <c>vcvc<v>   gives 2
+     * <c>vcvcvc<v> gives 3
+     *
+     * @param string  $str The string to return the m count for
+     * @return int         The m count
+     */
+    private static function m( $str ) {
+        $c = self::$regex_consonant;
+        $v = self::$regex_vowel;
+
+        $str = preg_replace( "#^$c+#", '', $str );
+        $str = preg_replace( "#$v+$#", '', $str );
+
+        preg_match_all( "#($v+$c+)#", $str, $matches );
+
+        return count( $matches[1] );
+    }
+
+
+    /**
+     * Returns true/false as to whether the given string contains two
+     * of the same consonant next to each other at the end of the string.
+     *
+     * @param string  $str String to check
+     * @return bool        Result
+     */
+    private static function doubleConsonant( $str ) {
+        $c = self::$regex_consonant;
+
+        return preg_match( "#$c{2}$#", $str, $matches ) and $matches[0]{0} == $matches[0]{1};
+    }
+
+
+    /**
+     * Checks for ending CVC sequence where second C is not W, X or Y
+     *
+     * @param string  $str String to check
+     * @return bool        Result
+     */
+    private static function cvc( $str ) {
+        $c = self::$regex_consonant;
+        $v = self::$regex_vowel;
+
+        return     preg_match( "#($c$v$c)$#", $str, $matches )
+            and strlen( $matches[1] ) == 3
+            and $matches[1]{2} != 'w'
+            and $matches[1]{2} != 'x'
+            and $matches[1]{2} != 'y';
+    }
+}

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

@@ -1437 +1437 @@
                 // Order dictates order of display.
                 $templates = array(
                         'description',
+                        'title-keywords',
                         'params',
                         'return',
                         'source',

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

@@ +1 @@
+<?php
+namespace DevHub;
+
+/**
+ * Returns array with restricted title words.
+ *
+ * @return array Array with restricted title words
+ */
+function get_restricted_words() {
+        return apply_filters( 'devhub_restricted_words', array(
+                        'a', 'an', 'are', 'as', 'at', 'be', 'by', 'for', 'from',
+                        'get', 'how', 'in', 'is', 'it', 'of', 'on', 'or', 'that', 'the',
+                        'this', 'to', 'with', 'wp'
+                ) );
+}
+
+
+/**
+ * Returns array with allowed first words in a title.
+ *
+ * @return array Array with restricted words
+ */
+function get_allowed_first_words() {
+        return apply_filters( 'devhub_allowed_first_words', array(
+                        'is',  // is_* functions
+                        'get', // get_* functions
+                ) );
+}
+
+/**
+ * Returns allowed keywords and their stems from a title.
+ * Restricted words are excluded. See get_restricted_words()
+ *
+ * @param string  $title Title to get words from.
+ * @return array Array with Words and word stems.
+ */
+function get_title_keywords( $title ) {
+        $words = $stemmed_words = array();
+
+        if ( empty( $title ) ) {
+                return array();
+        }
+
+        // Allow 'wp' as a single title word.
+        if ( 'wp' === strtolower( $title ) ) {
+                return array( 'wp' );
+        }
+
+        $restricted    = get_restricted_words();
+        $allowed_first = get_allowed_first_words();
+        $words         = get_words( $title );
+
+        // Get all wp-words and their stems.
+        $wp_words = get_wp_words( $words );
+
+        // Remove 'wp' from the words array.
+        $words = array_values( array_diff( $words, array( 'wp' ) ) );
+
+        foreach ( $words as $key => $word ) {
+
+                // Keep allowed first words
+                if ( !$key && in_array( $word, $allowed_first ) ) {
+                        continue;
+                }
+
+                // Remove restricted words.
+                if ( in_array( $word, $restricted ) ) {
+                        unset( $words[ $key ] );
+                }
+        }
+
+        // Stem words
+        $stemmed_words = array_map( 'DevHub\PorterStemmer::Stem', $words );
+
+        // Merge all words
+        $words = array_merge( $words, $wp_words, $stemmed_words );
+
+        return array_values( array_unique( array_filter( $words ) ) );
+}
+
+/**
+ * Returns all words from a title.
+ *
+ * @param string  $title Title.
+ * @return string Array with words.
+ */
+function get_words( $title ) {
+        $title = strtolower( $title );
+        // remove all non letter characters to underscores
+        $title = preg_replace( '/[^a-z0-9]/', '_', $title );
+        // replace multiple underscores with a single underscore
+        $title = preg_replace( '/_+/', '_', $title );
+
+        return explode( '_', trim( $title, '_' ) );
+}
+
+/**
+ * Returns wp-words if 'wp' is found as a word in the title.
+ * wp-words are: wp-{second_word}, second word and second word stem.
+ * e.g. wp-words for the function wp_create_term() are: wp-create, create and creat.
+ *
+ * @param string  $title Title to get wp words from.
+ * @return array wp words
+ */
+function get_wp_words( $words ) {
+        $wp_words = array();
+
+        if ( empty( $words ) || !is_array( $words ) ) {
+                return array();
+        }
+
+        foreach ( $words as $key => $word ) {
+
+                // Check if word is 'wp'
+                if ( 'wp' !== $word ) {
+                        continue;
+                }
+
+                // Check if there is a next word
+                if ( !isset( $words[ $key+1 ] ) ) {
+                        continue;
+                }
+
+                // Create wp-words
+                $wp_words[] = 'wp-' . $words[ $key + 1 ];
+                $wp_words[] = $words[ $key+1 ];
+                $wp_words[] = PorterStemmer::Stem( $words[ $key + 1 ] );
+        }
+
+        return array_values( array_unique( $wp_words ) );
+}

sites/trunk/wordpress.org/public_html/wp-content/themes/pub/wporg-developer/reference/template-title-keywords.php

@@ +1 @@
+<?php
+/**
+ * Reference Template: Title Keywords
+ *
+ * @package wporg-developer
+ * @subpackage Reference
+ */
+
+namespace DevHub;
+?>
+
+<hr />
+<section class="description">
+        <h2><?php _e( 'Title keywords', 'wporg' ); ?></h2>
+        <?php
+                $title = get_the_title();
+                if ( $title ) {
+                        echo implode( ', ' , get_title_keywords( $title ) );
+                }
+        ?>
+</section>