Source for file token.php

Documentation is available at token.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. /**
  13.  * Token class for the Finder indexer package.
  14.  *
  15.  * @package     Joomla.Administrator
  16.  * @subpackage  com_finder
  17.  * @since       2.5
  18.  */
  19. class FinderIndexerToken
  20. {
  21.     /**
  22.      * This is the term that will be referenced in the terms table and the
  23.      * mapping tables.
  24.      *
  25.      * @var    string 
  26.      * @since  2.5
  27.      */
  28.     public $term;
  29.  
  30.     /**
  31.      * The stem is used to match the root term and produce more potential
  32.      * matches when searching the index.
  33.      *
  34.      * @var    string 
  35.      * @since  2.5
  36.      */
  37.     public $stem;
  38.  
  39.     /**
  40.      * If the token is numeric, it is likely to be short and uncommon so the
  41.      * weight is adjusted to compensate for that situation.
  42.      *
  43.      * @var    boolean 
  44.      * @since  2.5
  45.      */
  46.     public $numeric;
  47.  
  48.     /**
  49.      * If the token is a common term, the weight is adjusted to compensate for
  50.      * the higher frequency of the term in relation to other terms.
  51.      *
  52.      * @var    boolean 
  53.      * @since  2.5
  54.      */
  55.     public $common;
  56.  
  57.     /**
  58.      * Flag for phrase tokens.
  59.      *
  60.      * @var    boolean 
  61.      * @since  2.5
  62.      */
  63.     public $phrase;
  64.  
  65.     /**
  66.      * The length is used to calculate the weight of the token.
  67.      *
  68.      * @var    integer 
  69.      * @since  2.5
  70.      */
  71.     public $length;
  72.  
  73.     /**
  74.      * The weight is calculated based on token size and whether the token is
  75.      * considered a common term.
  76.      *
  77.      * @var    integer 
  78.      * @since  2.5
  79.      */
  80.     public $weight;
  81.  
  82.     /**
  83.      * The simple language identifier for the token.
  84.      *
  85.      * @var    string 
  86.      * @since  2.5
  87.      */
  88.     public $language;
  89.  
  90.     /**
  91.      * Method to construct the token object.
  92.      *
  93.      * @param   mixed   $term    The term as a string for words or an array for phrases.
  94.      * @param   string  $lang    The simple language identifier.
  95.      * @param   string  $spacer  The space separator for phrases. [optional]
  96.      *
  97.      * @since   2.5
  98.      */
  99.     public function __construct($term, $lang, $spacer = ' ')
  100.     {
  101.         $this->language = $lang;
  102.  
  103.         // Tokens can be a single word or an array of words representing a phrase.
  104.         if (is_array($term))
  105.         {
  106.             // Populate the token instance.
  107.             $this->term = implode($spacer, $term);
  108.             $this->stem = implode($spacer, array_map(array('FinderIndexerHelper', 'stem'), $term, array($lang)));
  109.             $this->numeric = false;
  110.             $this->common = false;
  111.             $this->phrase = true;
  112.             $this->length = JString::strlen($this->term);
  113.  
  114.             /*
  115.              * Calculate the weight of the token.
  116.              *
  117.              * 1. Length of the token up to 30 and divide by 30, add 1.
  118.              * 2. Round weight to 4 decimal points.
  119.              */
  120.             $this->weight = (($this->length >= 30 ? 30 : $this->length) / 30) + 1;
  121.             $this->weight = round($this->weight, 4);
  122.         }
  123.         else
  124.         {
  125.             // Populate the token instance.
  126.             $this->term = $term;
  127.             $this->stem = FinderIndexerHelper::stem($this->term, $lang);
  128.             $this->numeric = (is_numeric($this->term) || (bool) preg_match('#^[0-9,.\-\+]+$#', $this->term));
  129.             $this->common = $this->numeric ? false : FinderIndexerHelper::isCommon($this->term, $lang);
  130.             $this->phrase = false;
  131.             $this->length = JString::strlen($this->term);
  132.  
  133.             /*
  134.              * Calculate the weight of the token.
  135.              *
  136.              * 1. Length of the token up to 15 and divide by 15.
  137.              * 2. If common term, divide weight by 8.
  138.              * 3. If numeric, multiply weight by 1.5.
  139.              * 4. Round weight to 4 decimal points.
  140.              */
  141.             $this->weight = (($this->length >= 15 ? 15 : $this->length) / 15);
  142.             $this->weight = ($this->common == true ? $this->weight / 8 : $this->weight);
  143.             $this->weight = ($this->numeric == true ? $this->weight * 1.5 : $this->weight);
  144.             $this->weight = round($this->weight, 4);
  145.         }
  146.     }
  147. }

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