Source for file fr.php

Documentation is available at fr.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.  * French stemmer class for Smart Search indexer.
  16.  *
  17.  * First contributed by Eric Sanou (bobotche@hotmail.fr)
  18.  * This class is inspired in  Alexis Ulrich's French stemmer code (http://alx2002.free.fr)
  19.  *
  20.  * @package     Joomla.Administrator
  21.  * @subpackage  com_finder
  22.  * @since       3.0
  23.  */
  24. class FinderIndexerStemmerFr extends FinderIndexerStemmer
  25. {
  26.     /**
  27.      * Stemming rules.
  28.      *
  29.      * @var    array 
  30.      * @since  3.0
  31.      */
  32.     private static $_stemRules = null;
  33.  
  34.     /**
  35.      * Method to stem a token and return the root.
  36.      *
  37.      * @param   string  $token  The token to stem.
  38.      * @param   string  $lang   The language of the token.
  39.      *
  40.      * @return  string  The root token.
  41.      *
  42.      * @since   3.0
  43.      */
  44.     public function stem($token, $lang)
  45.     {
  46.         // Check if the token is long enough to merit stemming.
  47.         if (strlen($token) <= 2)
  48.         {
  49.             return $token;
  50.         }
  51.  
  52.         // Check if the language is French or All.
  53.         if ($lang !== 'fr' && $lang != '*')
  54.         {
  55.             return $token;
  56.         }
  57.  
  58.         // Stem the token if it is not in the cache.
  59.         if (!isset($this->cache[$lang][$token]))
  60.         {
  61.             // Stem the token.
  62.             $result = static::_getStem($token);
  63.  
  64.             // Add the token to the cache.
  65.             $this->cache[$lang][$token] = $result;
  66.         }
  67.  
  68.         return $this->cache[$lang][$token];
  69.     }
  70.  
  71.     /**
  72.      * French stemmer rules variables.
  73.      *
  74.      * @return  array  The rules
  75.      *
  76.      * @since   3.0
  77.      */
  78.     protected static function getStemRules()
  79.     {
  80.         if (static::$_stemRules)
  81.         {
  82.             return static::$_stemRules;
  83.         }
  84.  
  85.         $vars = array();
  86.  
  87.         // French accented letters in ISO-8859-1 encoding
  88.         $vars['accents'] = chr(224) . chr(226) . chr(232) . chr(233) . chr(234) . chr(235) . chr(238) . chr(239) . chr(244) . chr(251) . chr(249) . chr(231);
  89.  
  90.         // The rule patterns include all accented words for french language
  91.         $vars['rule_pattern'] = "/^([a-z" . $vars['accents'] . "]*)(\*){0,1}(\d)([a-z" . $vars['accents'] . "]*)([.|>])/";
  92.  
  93.         // French vowels (including y) in ISO-8859-1 encoding
  94.         $vars['vowels'] = chr(97) . chr(224) . chr(226) . chr(101) . chr(232) . chr(233) . chr(234) . chr(235) . chr(105) . chr(238) . chr(239) . chr(111) . chr(244) . chr(117) . chr(251) . chr(249) . chr(121);
  95.  
  96.         // The French rules in ISO-8859-1 encoding
  97.         $vars['rules'] = array(
  98.             'esre1>', 'esio1>', 'siol1.', 'siof0.', 'sioe0.', 'sio3>', 'st1>', 'sf1>', 'sle1>', 'slo1>', 's' . chr(233) . '1>', chr(233) . 'tuae5.',
  99.             chr(233) . 'tuae2.', 'tnia0.', 'tniv1.', 'tni3>', 'suor1.', 'suo0.', 'sdrail5.', 'sdrai4.', 'er' . chr(232) . 'i1>', 'sesue3x>',
  100.             'esuey5i.', 'esue2x>', 'se1>', 'er' . chr(232) . 'g3.', 'eca1>', 'esiah0.', 'esi1>', 'siss2.', 'sir2>', 'sit2>', 'egan' . chr(233) . '1.',
  101.             'egalli6>', 'egass1.', 'egas0.', 'egat3.', 'ega3>', 'ette4>', 'ett2>', 'etio1.', 'tio' . chr(231) . '4c.', 'tio0.', 'et1>', 'eb1>',
  102.             'snia1>', 'eniatnau8>', 'eniatn4.', 'enia1>', 'niatnio3.', 'niatg3.', 'e' . chr(233) . '1>', chr(233) . 'hcat1.', chr(233) . 'hca4.',
  103.             chr(233) . 'tila5>', chr(233) . 'tici5.', chr(233) . 'tir1.', chr(233) . 'ti3>', chr(233) . 'gan1.', chr(233) . 'ga3>',
  104.             chr(233) . 'tehc1.', chr(233) . 'te3>', chr(233) . 'it0.', chr(233) . '1>', 'eire4.', 'eirue5.', 'eio1.', 'eia1.', 'ei1>', 'eng1.',
  105.             'xuaessi7.', 'xuae1>', 'uaes0.', 'uae3.', 'xuave2l.', 'xuav2li>', 'xua3la>', 'ela1>', 'lart2.', 'lani2>', 'la' . chr(233) . '2>',
  106.             'siay4i.', 'siassia7.', 'siarv1*.', 'sia1>', 'tneiayo6i.', 'tneiay6i.', 'tneiassia9.', 'tneiareio7.', 'tneia5>', 'tneia4>', 'tiario4.',
  107.             'tiarim3.', 'tiaria3.', 'tiaris3.', 'tiari5.', 'tiarve6>', 'tiare5>', 'iare4>', 'are3>', 'tiay4i.', 'tia3>', 'tnay4i.',
  108.             'em' . chr(232) . 'iu5>', 'em' . chr(232) . 'i4>', 'tnaun3.', 'tnauqo3.', 'tnau4>', 'tnaf0.', 'tnat' . chr(233) . '2>', 'tna3>', 'tno3>',
  109.             'zeiy4i.', 'zey3i.', 'zeire5>', 'zeird4.', 'zeirio4.', 'ze2>', 'ssiab0.', 'ssia4.', 'ssi3.', 'tnemma6>', 'tnemesuey9i.', 'tnemesue8>',
  110.             'tnemevi7.', 'tnemessia5.', 'tnemessi8.', 'tneme5>', 'tnemia4.', 'tnem' . chr(233) . '5>', 'el2l>', 'lle3le>', 'let' . chr(244) . '0.',
  111.             'lepp0.', 'le2>', 'srei1>', 'reit3.', 'reila2.', 'rei3>', 'ert' . chr(226) . 'e5.', 'ert' . chr(226) . chr(233) . '1.',
  112.             'ert' . chr(226) . '4.', 'drai4.', 'erdro0.', 'erute5.', 'ruta0.', 'eruta1.', 'erutiov1.', 'erub3.', 'eruh3.', 'erul3.', 'er2r>', 'nn1>',
  113.             'r' . chr(232) . 'i3.', 'srev0.', 'sr1>', 'rid2>', 're2>', 'xuei4.', 'esuei5.', 'lbati3.', 'lba3>', 'rueis0.', 'ruehcn4.', 'ecirta6.',
  114.             'ruetai6.', 'rueta5.', 'rueir0.', 'rue3>', 'esseti6.', 'essere6>', 'esserd1.', 'esse4>', 'essiab1.', 'essia5.', 'essio1.', 'essi4.',
  115.             'essal4.', 'essa1>', 'ssab1.', 'essurp1.', 'essu4.', 'essi1.', 'ssor1.', 'essor2.', 'esso1>', 'ess2>', 'tio3.', 'r' . chr(232) . 's2re.',
  116.             'r' . chr(232) . '0e.', 'esn1.', 'eu1>', 'sua0.', 'su1>', 'utt1>', 'tu' . chr(231) . '3c.', 'u' . chr(231) . '2c.', 'ur1.', 'ehcn2>',
  117.             'ehcu1>', 'snorr3.', 'snoru3.', 'snorua3.', 'snorv3.', 'snorio4.', 'snori5.', 'snore5>', 'snortt4>', 'snort' . chr(238) . 'a7.', 'snort3.',
  118.             'snor4.', 'snossi6.', 'snoire6.', 'snoird5.', 'snoitai7.', 'snoita6.', 'snoits1>', 'noits0.', 'snoi4>', 'noitaci7>', 'noitai6.', 'noita5.',
  119.             'noitu4.', 'noi3>', 'snoya0.', 'snoy4i.', 'sno' . chr(231) . 'a1.', 'sno' . chr(231) . 'r1.', 'snoe4.', 'snosiar1>', 'snola1.', 'sno3>',
  120.             'sno1>', 'noll2.', 'tnennei4.', 'ennei2>', 'snei1>', 'sne' . chr(233) . '1>', 'enne' . chr(233) . '5e.', 'ne' . chr(233) . '3e.', 'neic0.',
  121.             'neiv0.', 'nei3.', 'sc1.', 'sd1.', 'sg1.', 'sni1.', 'tiu0.', 'ti2.', 'sp1>', 'sna1>', 'sue1.', 'enn2>', 'nong2.', 'noss2.', 'rioe4.',
  122.             'riot0.', 'riorc1.', 'riovec5.', 'rio3.', 'ric2.', 'ril2.', 'tnerim3.', 'tneris3>', 'tneri5.', 't' . chr(238) . 'a3.', 'riss2.',
  123.             't' . chr(238) . '2.', 't' . chr(226) . '2>', 'ario2.', 'arim1.', 'ara1.', 'aris1.', 'ari3.', 'art1>', 'ardn2.', 'arr1.', 'arua1.',
  124.             'aro1.', 'arv1.', 'aru1.', 'ar2.', 'rd1.', 'ud1.', 'ul1.', 'ini1.', 'rin2.', 'tnessiab3.', 'tnessia7.', 'tnessi6.', 'tnessni4.', 'sini2.',
  125.             'sl1.', 'iard3.', 'iario3.', 'ia2>', 'io0.', 'iule2.', 'i1>', 'sid2.', 'sic2.', 'esoi4.', 'ed1.', 'ai2>', 'a1>', 'adr1.',
  126.             'tner' . chr(232) . '5>', 'evir1.', 'evio4>', 'evi3.', 'fita4.', 'fi2>', 'enie1.', 'sare4>', 'sari4>', 'sard3.', 'sart2>', 'sa2.',
  127.             'tnessa6>', 'tnessu6>', 'tnegna3.', 'tnegi3.', 'tneg0.', 'tneru5>', 'tnemg0.', 'tnerni4.', 'tneiv1.', 'tne3>', 'une1.', 'en1>', 'nitn2.',
  128.             'ecnay5i.', 'ecnal1.', 'ecna4.', 'ec1>', 'nn1.', 'rit2>', 'rut2>', 'rud2.', 'ugn1>', 'eg1>', 'tuo0.', 'tul2>', 't' . chr(251) . '2>',
  129.             'ev1>', 'v' . chr(232) . '2ve>', 'rtt1>', 'emissi6.', 'em1.', 'ehc1.', 'c' . chr(233) . 'i2c' . chr(232) . '.', 'libi2l.', 'llie1.',
  130.             'liei4i.', 'xuev1.', 'xuey4i.', 'xueni5>', 'xuell4.', 'xuere5.', 'xue3>', 'rb' . chr(233) . '3rb' . chr(232) . '.', 'tur2.',
  131.             'rir' . chr(233) . '4re.', 'rir2.', 'c' . chr(226) . '2ca.', 'snu1.', 'rt' . chr(238) . 'a4.', 'long2.', 'vec2.', chr(231) . '1c>',
  132.             'ssilp3.', 'silp2.', 't' . chr(232) . 'hc2te.', 'n' . chr(232) . 'm2ne.', 'llepp1.', 'tan2.', 'rv' . chr(232) . '3rve.',
  133.             'rv' . chr(233) . '3rve.', 'r' . chr(232) . '2re.', 'r' . chr(233) . '2re.', 't' . chr(232) . '2te.', 't' . chr(233) . '2te.', 'epp1.',
  134.             'eya2i.', 'ya1i.', 'yo1i.', 'esu1.', 'ugi1.', 'tt1.', 'end0.'
  135.         );
  136.  
  137.         static::$_stemRules = $vars;
  138.  
  139.         return static::$_stemRules;
  140.     }
  141.  
  142.     /**
  143.      * Returns the number of the first rule from the rule number
  144.      * that can be applied to the given reversed input.
  145.      * returns -1 if no rule can be applied, ie the stem has been found
  146.      *
  147.      * @param   string   $reversed_input  The input to check in reversed order
  148.      * @param   integer  $rule_number     The rule number to check
  149.      *
  150.      * @return  integer  Number of the first rule
  151.      *
  152.      * @since   3.0
  153.      */
  154.     private static function _getFirstRule($reversed_input, $rule_number)
  155.     {
  156.         $vars = static::getStemRules();
  157.  
  158.         $nb_rules = count($vars['rules']);
  159.  
  160.         for ($i = $rule_number; $i < $nb_rules; $i++)
  161.         {
  162.             // Gets the letters from the current rule
  163.             $rule = $vars['rules'][$i];
  164.             $rule = preg_replace($vars['rule_pattern'], "\\1", $rule);
  165.  
  166.             if (strncasecmp(utf8_decode($rule), $reversed_input, strlen(utf8_decode($rule))) == 0)
  167.             {
  168.                 return $i;
  169.             }
  170.         }
  171.  
  172.         return -1;
  173.     }
  174.  
  175.     /**
  176.      * Check the acceptability of a stem for French language
  177.      *
  178.      * @param   string  $reversed_stem  The stem to check in reverse form
  179.      *
  180.      * @return  boolean  True if stem is acceptable
  181.      *
  182.      * @since   3.0
  183.      */
  184.     private static function _check($reversed_stem)
  185.     {
  186.         $vars = static::getStemRules();
  187.  
  188.         if (preg_match('/[' . $vars['vowels'] . ']$/', utf8_encode($reversed_stem)))
  189.         {
  190.             // If the form starts with a vowel then at least two letters must remain after stemming (e.g.: "etaient" --> "et")
  191.             return (strlen($reversed_stem) > 2);
  192.         }
  193.         else
  194.         {
  195.             // If the reversed stem starts with a consonant then at least two letters must remain after stemming
  196.             if (strlen($reversed_stem) <= 2)
  197.             {
  198.                 return false;
  199.             }
  200.  
  201.             // And at least one of these must be a vowel or "y"
  202.             return (preg_match('/[' . $vars['vowels'] . ']/', utf8_encode($reversed_stem)));
  203.         }
  204.     }
  205.  
  206.     /**
  207.      * Paice/Husk stemmer which returns a stem for the given $input
  208.      *
  209.      * @param   string  $input  The word for which we want the stem in UTF-8
  210.      *
  211.      * @return  string  The stem
  212.      *
  213.      * @since   3.0
  214.      */
  215.     private static function _getStem($input)
  216.     {
  217.         $vars = static::getStemRules();
  218.  
  219.         $intact = true;
  220.         $reversed_input = strrev(utf8_decode($input));
  221.         $rule_number = 0;
  222.  
  223.         // This loop goes through the rules' array until it finds an ending one (ending by '.') or the last one ('end0.')
  224.         while (true)
  225.         {
  226.             $rule_number = static::_getFirstRule($reversed_input, $rule_number);
  227.  
  228.             if ($rule_number == -1)
  229.             {
  230.                 // No other rule can be applied => the stem has been found
  231.                 break;
  232.             }
  233.             $rule = $vars['rules'][$rule_number];
  234.             preg_match($vars['rule_pattern'], $rule, $matches);
  235.  
  236.             if (($matches[2] != '*') || ($intact))
  237.             {
  238.                 $reversed_stem = utf8_decode($matches[4]) . substr($reversed_input, $matches[3], strlen($reversed_input) - $matches[3]);
  239.  
  240.                 if (self::_check($reversed_stem))
  241.                 {
  242.                     $reversed_input = $reversed_stem;
  243.  
  244.                     if ($matches[5] == '.')
  245.                     {
  246.                         break;
  247.                     }
  248.                 }
  249.                 else
  250.                 {
  251.                     // Go to another rule
  252.                     $rule_number++;
  253.                 }
  254.             }
  255.             else
  256.             {
  257.                 // Go to another rule
  258.                 $rule_number++;
  259.             }
  260.         }
  261.  
  262.         return utf8_encode(strrev($reversed_input));
  263.     }
  264. }

Documentation generated on Tue, 19 Nov 2013 15:03:46 +0100 by phpDocumentor 1.4.3