Source for file porter_en.php

Documentation is available at porter_en.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Administrator
  4.  * @subpackage  com_finder
  5.  *
  6.  * @copyright   Copyright (C) 2005 - 2013 Open Source Matters, Inc. All rights reserved.
  7.  * @license     GNU General Public License version 2 or later; see LICENSE
  8.  */
  9.  
  10. defined('_JEXEC') or die;
  11.  
  12. JLoader::register('FinderIndexerStemmer', dirname(__DIR__) . '/stemmer.php');
  13.  
  14. /**
  15.  * Porter English stemmer class for the Finder indexer package.
  16.  *
  17.  * This class was adapted from one written by Richard Heyes.
  18.  * See copyright and link information above.
  19.  *
  20.  * @package     Joomla.Administrator
  21.  * @subpackage  com_finder
  22.  * @since       2.5
  23.  */
  24. class FinderIndexerStemmerPorter_En extends FinderIndexerStemmer
  25. {
  26.     /**
  27.      * Regex for matching a consonant.
  28.      *
  29.      * @var    string 
  30.      * @since  2.5
  31.      */
  32.     private static $_regex_consonant = '(?:[bcdfghjklmnpqrstvwxz]|(?<=[aeiou])y|^y)';
  33.  
  34.     /**
  35.      * Regex for matching a vowel
  36.      *
  37.      * @var    string 
  38.      * @since  2.5
  39.      */
  40.     private static $_regex_vowel = '(?:[aeiou]|(?<![aeiou])y)';
  41.  
  42.     /**
  43.      * Method to stem a token and return the root.
  44.      *
  45.      * @param   string  $token  The token to stem.
  46.      * @param   string  $lang   The language of the token.
  47.      *
  48.      * @return  string  The root token.
  49.      *
  50.      * @since   2.5
  51.      */
  52.     public function stem($token, $lang)
  53.     {
  54.         // Check if the token is long enough to merit stemming.
  55.         if (strlen($token) <= 2)
  56.         {
  57.             return $token;
  58.         }
  59.  
  60.         // Check if the language is English or All.
  61.         if ($lang !== 'en' && $lang != '*')
  62.         {
  63.             return $token;
  64.         }
  65.  
  66.         // Stem the token if it is not in the cache.
  67.         if (!isset($this->cache[$lang][$token]))
  68.         {
  69.             // Stem the token.
  70.             $result = $token;
  71.             $result = self::_step1ab($result);
  72.             $result = self::_step1c($result);
  73.             $result = self::_step2($result);
  74.             $result = self::_step3($result);
  75.             $result = self::_step4($result);
  76.             $result = self::_step5($result);
  77.  
  78.             // Add the token to the cache.
  79.             $this->cache[$lang][$token] = $result;
  80.         }
  81.  
  82.         return $this->cache[$lang][$token];
  83.     }
  84.  
  85.     /**
  86.      * Step 1
  87.      *
  88.      * @param   string  $word  The token to stem.
  89.      *
  90.      * @return  string 
  91.      *
  92.      * @since   2.5
  93.      */
  94.     private static function _step1ab($word)
  95.     {
  96.         // Part a
  97.         if (substr($word, -1) == 's')
  98.         {
  99.             self::_replace($word, 'sses', 'ss')
  100.             or self::_replace($word, 'ies', 'i')
  101.             or self::_replace($word, 'ss', 'ss')
  102.             or self::_replace($word, 's', '');
  103.         }
  104.  
  105.         // Part b
  106.         if (substr($word, -2, 1) != 'e' or !self::_replace($word, 'eed', 'ee', 0))
  107.         {
  108.             // First rule
  109.             $v = self::$_regex_vowel;
  110.  
  111.             // Words ending with ing and ed
  112.             // Note use of && and OR, for precedence reasons
  113.             if (preg_match("#$v+#", substr($word, 0, -3)) && self::_replace($word, 'ing', '')
  114.                 or preg_match("#$v+#", substr($word, 0, -2)) && self::_replace($word, 'ed', ''))
  115.             {
  116.                 // If one of above two test successful
  117.                 if (!self::_replace($word, 'at', 'ate') and !self::_replace($word, 'bl', 'ble') and !self::_replace($word, 'iz', 'ize'))
  118.                 {
  119.                     // Double consonant ending
  120.                     if (self::_doubleConsonant($word) and substr($word, -2) != 'll' and substr($word, -2) != 'ss' and substr($word, -2) != 'zz')
  121.                     {
  122.                         $word = substr($word, 0, -1);
  123.                     }
  124.                     elseif (self::_m($word) == 1 and self::_cvc($word))
  125.                     {
  126.                         $word .= 'e';
  127.                     }
  128.                 }
  129.             }
  130.         }
  131.  
  132.         return $word;
  133.     }
  134.  
  135.     /**
  136.      * Step 1c
  137.      *
  138.      * @param   string  $word  The token to stem.
  139.      *
  140.      * @return  string 
  141.      *
  142.      * @since   2.5
  143.      */
  144.     private static function _step1c($word)
  145.     {
  146.         $v = self::$_regex_vowel;
  147.  
  148.         if (substr($word, -1) == 'y' && preg_match("#$v+#", substr($word, 0, -1)))
  149.         {
  150.             self::_replace($word, 'y', 'i');
  151.         }
  152.  
  153.         return $word;
  154.     }
  155.  
  156.     /**
  157.      * Step 2
  158.      *
  159.      * @param   string  $word  The token to stem.
  160.      *
  161.      * @return  string 
  162.      *
  163.      * @since   2.5
  164.      */
  165.     private static function _step2($word)
  166.     {
  167.         switch (substr($word, -2, 1))
  168.         {
  169.             case 'a':
  170.                 self::_replace($word, 'ational', 'ate', 0)
  171.                 or self::_replace($word, 'tional', 'tion', 0);
  172.                 break;
  173.             case 'c':
  174.                 self::_replace($word, 'enci', 'ence', 0)
  175.                 or self::_replace($word, 'anci', 'ance', 0);
  176.                 break;
  177.             case 'e':
  178.                 self::_replace($word, 'izer', 'ize', 0);
  179.                 break;
  180.             case 'g':
  181.                 self::_replace($word, 'logi', 'log', 0);
  182.                 break;
  183.             case 'l':
  184.                 self::_replace($word, 'entli', 'ent', 0)
  185.                 or self::_replace($word, 'ousli', 'ous', 0)
  186.                 or self::_replace($word, 'alli', 'al', 0)
  187.                 or self::_replace($word, 'bli', 'ble', 0)
  188.                 or self::_replace($word, 'eli', 'e', 0);
  189.                 break;
  190.             case 'o':
  191.                 self::_replace($word, 'ization', 'ize', 0)
  192.                 or self::_replace($word, 'ation', 'ate', 0)
  193.                 or self::_replace($word, 'ator', 'ate', 0);
  194.                 break;
  195.             case 's':
  196.                 self::_replace($word, 'iveness', 'ive', 0)
  197.                 or self::_replace($word, 'fulness', 'ful', 0)
  198.                 or self::_replace($word, 'ousness', 'ous', 0)
  199.                 or self::_replace($word, 'alism', 'al', 0);
  200.                 break;
  201.             case 't':
  202.                 self::_replace($word, 'biliti', 'ble', 0)
  203.                 or self::_replace($word, 'aliti', 'al', 0)
  204.                 or self::_replace($word, 'iviti', 'ive', 0);
  205.                 break;
  206.         }
  207.  
  208.         return $word;
  209.     }
  210.  
  211.     /**
  212.      * Step 3
  213.      *
  214.      * @param   string  $word  The token to stem.
  215.      *
  216.      * @return  string 
  217.      *
  218.      * @since   2.5
  219.      */
  220.     private static function _step3($word)
  221.     {
  222.         switch (substr($word, -2, 1))
  223.         {
  224.             case 'a':
  225.                 self::_replace($word, 'ical', 'ic', 0);
  226.                 break;
  227.             case 's':
  228.                 self::_replace($word, 'ness', '', 0);
  229.                 break;
  230.             case 't':
  231.                 self::_replace($word, 'icate', 'ic', 0)
  232.                 or self::_replace($word, 'iciti', 'ic', 0);
  233.                 break;
  234.             case 'u':
  235.                 self::_replace($word, 'ful', '', 0);
  236.                 break;
  237.             case 'v':
  238.                 self::_replace($word, 'ative', '', 0);
  239.                 break;
  240.             case 'z':
  241.                 self::_replace($word, 'alize', 'al', 0);
  242.                 break;
  243.         }
  244.  
  245.         return $word;
  246.     }
  247.  
  248.     /**
  249.      * Step 4
  250.      *
  251.      * @param   string  $word  The token to stem.
  252.      *
  253.      * @return  string 
  254.      *
  255.      * @since   2.5
  256.      */
  257.     private static function _step4($word)
  258.     {
  259.         switch (substr($word, -2, 1))
  260.         {
  261.             case 'a':
  262.                 self::_replace($word, 'al', '', 1);
  263.                 break;
  264.             case 'c':
  265.                     self::_replace($word, 'ance', '', 1)
  266.                 or self::_replace($word, 'ence', '', 1);
  267.                 break;
  268.             case 'e':
  269.                 self::_replace($word, 'er', '', 1);
  270.                 break;
  271.             case 'i':
  272.                 self::_replace($word, 'ic', '', 1);
  273.                 break;
  274.             case 'l':
  275.                 self::_replace($word, 'able', '', 1)
  276.                 or self::_replace($word, 'ible', '', 1);
  277.                 break;
  278.             case 'n':
  279.                 self::_replace($word, 'ant', '', 1)
  280.                 or self::_replace($word, 'ement', '', 1)
  281.                 or self::_replace($word, 'ment', '', 1)
  282.                 or self::_replace($word, 'ent', '', 1);
  283.                 break;
  284.             case 'o':
  285.                 if (substr($word, -4) == 'tion' or substr($word, -4) == 'sion')
  286.                 {
  287.                     self::_replace($word, 'ion', '', 1);
  288.                 }
  289.                 else
  290.                 {
  291.                     self::_replace($word, 'ou', '', 1);
  292.                 }
  293.                 break;
  294.             case 's':
  295.                 self::_replace($word, 'ism', '', 1);
  296.                 break;
  297.             case 't':
  298.                     self::_replace($word, 'ate', '', 1)
  299.                 or self::_replace($word, 'iti', '', 1);
  300.                 break;
  301.             case 'u':
  302.                 self::_replace($word, 'ous', '', 1);
  303.                 break;
  304.             case 'v':
  305.                 self::_replace($word, 'ive', '', 1);
  306.                 break;
  307.             case 'z':
  308.                 self::_replace($word, 'ize', '', 1);
  309.                 break;
  310.         }
  311.  
  312.         return $word;
  313.     }
  314.  
  315.     /**
  316.      * Step 5
  317.      *
  318.      * @param   string  $word  The token to stem.
  319.      *
  320.      * @return  string 
  321.      *
  322.      * @since   2.5
  323.      */
  324.     private static function _step5($word)
  325.     {
  326.         // Part a
  327.         if (substr($word, -1) == 'e')
  328.         {
  329.             if (self::_m(substr($word, 0, -1)) > 1)
  330.             {
  331.                 self::_replace($word, 'e', '');
  332.             }
  333.             elseif (self::_m(substr($word, 0, -1)) == 1)
  334.             {
  335.                 if (!self::_cvc(substr($word, 0, -1)))
  336.                 {
  337.                     self::_replace($word, 'e', '');
  338.                 }
  339.             }
  340.         }
  341.  
  342.         // Part b
  343.         if (self::_m($word) > 1 and self::_doubleConsonant($word) and substr($word, -1) == 'l')
  344.         {
  345.             $word = substr($word, 0, -1);
  346.         }
  347.  
  348.         return $word;
  349.     }
  350.  
  351.     /**
  352.      * Replaces the first string with the second, at the end of the string. If third
  353.      * arg is given, then the preceding string must match that m count at least.
  354.      *
  355.      * @param   string   &$str   String to check
  356.      * @param   string   $check  Ending to check for
  357.      * @param   string   $repl   Replacement string
  358.      * @param   integer  $m      Optional minimum number of m() to meet
  359.      *
  360.      * @return  boolean  Whether the $check string was at the end
  361.      *                    of the $str string. True does not necessarily mean
  362.      *                    that it was replaced.
  363.      *
  364.      * @since   2.5
  365.      */
  366.     private static function _replace(&$str, $check, $repl, $m = null)
  367.     {
  368.         $len = 0 - strlen($check);
  369.  
  370.         if (substr($str, $len) == $check)
  371.         {
  372.             $substr = substr($str, 0, $len);
  373.  
  374.             if (is_null($m) or self::_m($substr) > $m)
  375.             {
  376.                 $str = $substr . $repl;
  377.             }
  378.  
  379.             return true;
  380.         }
  381.  
  382.         return false;
  383.     }
  384.  
  385.     /**
  386.      * m() measures the number of consonant sequences in $str. if c is
  387.      * a consonant sequence and v a vowel sequence, and <..> indicates arbitrary
  388.      * presence,
  389.      *
  390.      * <c><v>       gives 0
  391.      * <c>vc<v>     gives 1
  392.      * <c>vcvc<v>   gives 2
  393.      * <c>vcvcvc<v> gives 3
  394.      *
  395.      * @param   string  $str  The string to return the m count for
  396.      *
  397.      * @return  integer  The m count
  398.      *
  399.      * @since   2.5
  400.      */
  401.     private static function _m($str)
  402.     {
  403.         $c = self::$_regex_consonant;
  404.         $v = self::$_regex_vowel;
  405.  
  406.         $str = preg_replace("#^$c+#", '', $str);
  407.         $str = preg_replace("#$v+$#", '', $str);
  408.  
  409.         preg_match_all("#($v+$c+)#", $str, $matches);
  410.  
  411.         return count($matches[1]);
  412.     }
  413.  
  414.     /**
  415.      * Returns true/false as to whether the given string contains two
  416.      * of the same consonant next to each other at the end of the string.
  417.      *
  418.      * @param   string  $str  String to check
  419.      *
  420.      * @return  boolean  Result
  421.      *
  422.      * @since   2.5
  423.      */
  424.     private static function _doubleConsonant($str)
  425.     {
  426.         $c = self::$_regex_consonant;
  427.  
  428.         return preg_match("#$c{2}$#", $str, $matches) and $matches[0]{0} == $matches[0]{1};
  429.     }
  430.  
  431.     /**
  432.      * Checks for ending CVC sequence where second C is not W, X or Y
  433.      *
  434.      * @param   string  $str  String to check
  435.      *
  436.      * @return  boolean  Result
  437.      *
  438.      * @since   2.5
  439.      */
  440.     private static function _cvc($str)
  441.     {
  442.         $c = self::$_regex_consonant;
  443.         $v = self::$_regex_vowel;
  444.  
  445.         return preg_match("#($c$v$c)$#", $str, $matches) and strlen($matches[1]) == 3 and $matches[1]{2} != 'w' and $matches[1]{2} != 'x'
  446.             and $matches[1]{2} != 'y';
  447.     }
  448. }

Documentation generated on Tue, 19 Nov 2013 15:10:58 +0100 by phpDocumentor 1.4.3