Source for file search.php

Documentation is available at search.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Administrator
  4.  * @subpackage  com_search
  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.txt
  8.  */
  9.  
  10. defined('_JEXEC') or die;
  11.  
  12. /**
  13.  * Search component helper.
  14.  *
  15.  * @package     Joomla.Administrator
  16.  * @subpackage  com_search
  17.  * @since       1.5
  18.  */
  19. class SearchHelper
  20. {
  21.     /**
  22.      * Configure the Linkbar.
  23.      *
  24.      * @param   string    The name of the active view.
  25.      * @since   1.6
  26.      */
  27.     public static function addSubmenu($vName)
  28.     {
  29.         // Not required.
  30.     }
  31.  
  32.     /**
  33.      * Gets a list of the actions that can be performed.
  34.      *
  35.      * @return  JObject 
  36.      */
  37.     public static function getActions()
  38.     {
  39.         $user       = JFactory::getUser();
  40.         $result       = new JObject;
  41.         $assetName = 'com_search';
  42.  
  43.         $actions = JAccess::getActions($assetName);
  44.  
  45.         foreach ($actions as $action)
  46.         {
  47.             $result->set($action->name,    $user->authorise($action->name, $assetName));
  48.         }
  49.  
  50.         return $result;
  51.     }
  52.  
  53.     public static function santiseSearchWord(&$searchword, $searchphrase)
  54.     {
  55.         $ignored = false;
  56.  
  57.         $lang          = JFactory::getLanguage();
  58.         $tag           = $lang->getTag();
  59.         $search_ignore = $lang->getIgnoredSearchWords();
  60.  
  61.         // Deprecated in 1.6 use $lang->getIgnoredSearchWords instead
  62.         $ignoreFile = $lang->getLanguagePath() . '/' . $tag . '/' . $tag . '.ignore.php';
  63.  
  64.         if (file_exists($ignoreFile))
  65.         {
  66.             include $ignoreFile;
  67.         }
  68.  
  69.         // Check for words to ignore
  70.         $aterms = explode(' ', JString::strtolower($searchword));
  71.  
  72.         // First case is single ignored word
  73.         if (count($aterms) == 1 && in_array(JString::strtolower($searchword), $search_ignore))
  74.         {
  75.             $ignored = true;
  76.         }
  77.  
  78.         // Filter out search terms that are too small
  79.         $lower_limit = $lang->getLowerLimitSearchWord();
  80.  
  81.         foreach ($aterms as $aterm)
  82.         {
  83.             if (JString::strlen($aterm) < $lower_limit)
  84.             {
  85.                 $search_ignore[] = $aterm;
  86.             }
  87.         }
  88.  
  89.         // Next is to remove ignored words from type 'all' or 'any' (not exact) searches with multiple words
  90.         if (count($aterms) > 1 && $searchphrase != 'exact')
  91.         {
  92.             $pruned     = array_diff($aterms, $search_ignore);
  93.             $searchword = implode(' ', $pruned);
  94.         }
  95.  
  96.         return $ignored;
  97.     }
  98.  
  99.     /**
  100.      * @since  1.5
  101.      */
  102.     public static function limitSearchWord(&$searchword)
  103.     {
  104.         $restriction = false;
  105.  
  106.         $lang = JFactory::getLanguage();
  107.  
  108.         // Limit searchword to a maximum of characters
  109.         $upper_limit = $lang->getUpperLimitSearchWord();
  110.  
  111.         if (JString::strlen($searchword) > $upper_limit)
  112.         {
  113.             $searchword  = JString::substr($searchword, 0, $upper_limit - 1);
  114.             $restriction = true;
  115.         }
  116.  
  117.         // Searchword must contain a minimum of characters
  118.         if ($searchword && JString::strlen($searchword) < $lang->getLowerLimitSearchWord())
  119.         {
  120.             $searchword  = '';
  121.             $restriction = true;
  122.         }
  123.  
  124.         return $restriction;
  125.     }
  126.  
  127.     /**
  128.      * Logs a search term
  129.      *
  130.      * @param   string  $search_term  The term being searched
  131.      *
  132.      * @return  void 
  133.      *
  134.      * @since   1.5
  135.      * @deprecated  4.0  Use JSearchHelper::logSearch() instead
  136.      */
  137.     public static function logSearch($search_term)
  138.     {
  139.         JLog::add(__METHOD__ . '() is deprecated, use JSearchHelper::logSearch() instead.', JLog::WARNING, 'deprecated');
  140.  
  141.         JSearchHelper::logSearch($search_term, 'com_search');
  142.     }
  143.  
  144.     /**
  145.      * Prepares results from search for display
  146.      *
  147.      * @param   string  $text        The source string
  148.      * @param   string  $searchword  The searchword to select around
  149.      *
  150.      * @return  string 
  151.      *
  152.      * @since   1.5
  153.      */
  154.     public static function prepareSearchContent($text, $searchword)
  155.     {
  156.         // Strips tags won't remove the actual jscript
  157.         $text = preg_replace("'<script[^>]*>.*?</script>'si", "", $text);
  158.         $text = preg_replace('/{.+?}/', '', $text);
  159.  
  160.         // $text = preg_replace('/<a\s+.*?href="([^"]+)"[^>]*>([^<]+)<\/a>/is','\2', $text);
  161.  
  162.         // Replace line breaking tags with whitespace
  163.         $text = preg_replace("'<(br[^/>]*?/|hr[^/>]*?/|/(div|h[1-6]|li|p|td))>'si", ' ', $text);
  164.  
  165.         return self::_smartSubstr(strip_tags($text), $searchword);
  166.     }
  167.  
  168.     /**
  169.      * Checks an object for search terms (after stripping fields of HTML)
  170.      *
  171.      * @param   object  $object      The object to check
  172.      * @param   string  $searchTerm  Search words to check for
  173.      * @param   array   $fields      List of object variables to check against
  174.      *
  175.      * @return  boolean True if searchTerm is in object, false otherwise
  176.      */
  177.     public static function checkNoHtml($object, $searchTerm, $fields)
  178.     {
  179.         $searchRegex = array(
  180.             '#<script[^>]*>.*?</script>#si',
  181.             '#<style[^>]*>.*?</style>#si',
  182.             '#<!.*?(--|]])>#si',
  183.             '#<[^>]*>#i'
  184.         );
  185.         $terms = explode(' ', $searchTerm);
  186.  
  187.         if (empty($fields))
  188.         {
  189.             return false;
  190.         }
  191.  
  192.         foreach ($fields as $field)
  193.         {
  194.             if (!isset($object->$field))
  195.             {
  196.                 continue;
  197.             }
  198.  
  199.             $text = self::remove_accents($object->$field);
  200.  
  201.             foreach ($searchRegex as $regex)
  202.             {
  203.                 $text = preg_replace($regex, '', $text);
  204.             }
  205.  
  206.             foreach ($terms as $term)
  207.             {
  208.                 $term = self::remove_accents($term);
  209.  
  210.                 if (JString::stristr($text, $term) !== false)
  211.                 {
  212.                     return true;
  213.                 }
  214.             }
  215.         }
  216.  
  217.         return false;
  218.     }
  219.  
  220.     /**
  221.      * Transliterates given text to ASCII//TRANSLIT.
  222.      * Simulates glibc transliteration style even if libiconv is used by PHP
  223.      *
  224.      * @param   string  $str  String to remove accents from
  225.      *
  226.      * @return  string 
  227.      *
  228.      * @since   3.2
  229.      */
  230.     public static function remove_accents($str)
  231.     {
  232.         setlocale(LC_ALL, "en_GB.UTF-8");
  233.         $str = iconv("UTF-8", "ASCII//TRANSLIT//IGNORE", $str);
  234.         //TODO: remove other prefixes as well?
  235.         return preg_replace("/[\"'^]([a-z])/ui", '\1', $str);
  236.     }
  237.  
  238.     /**
  239.      * returns substring of characters around a searchword
  240.      *
  241.      * @param   string   $text        The source string
  242.      * @param   integer  $searchword  Number of chars to return
  243.      *
  244.      * @return  string 
  245.      *
  246.      * @since   1.5
  247.      */
  248.     public static function _smartSubstr($text, $searchword)
  249.     {
  250.         $lang        = JFactory::getLanguage();
  251.         $length      = $lang->getSearchDisplayedCharactersNumber();
  252.         $ltext       = self::remove_accents($text);
  253.         $textlen     = JString::strlen($ltext);
  254.         $lsearchword = JString::strtolower(self::remove_accents($searchword));
  255.         $wordfound   = false;
  256.         $pos         = 0;
  257.  
  258.         while ($wordfound === false && $pos < $textlen)
  259.         {
  260.             if (($wordpos = @JString::strpos($ltext, ' ', $pos + $length)) !== false)
  261.             {
  262.                 $chunk_size = $wordpos - $pos;
  263.             }
  264.             else
  265.             {
  266.                 $chunk_size = $length;
  267.             }
  268.  
  269.             $chunk     = JString::substr($ltext, $pos, $chunk_size);
  270.             $wordfound = JString::strpos(JString::strtolower($chunk), $lsearchword);
  271.  
  272.             if ($wordfound === false)
  273.             {
  274.                 $pos += $chunk_size + 1;
  275.             }
  276.         }
  277.  
  278.         if ($wordfound !== false)
  279.         {
  280.             return (($pos > 0) ? '...&#160;' : '') . JString::substr($text, $pos, $chunk_size) . '&#160;...';
  281.         }
  282.         else
  283.         {
  284.             if (($wordpos = @JString::strpos($text, ' ', $length)) !== false)
  285.             {
  286.                 return JString::substr($text, 0, $wordpos) . '&#160;...';
  287.             }
  288.             else
  289.             {
  290.                 return JString::substr($text, 0, $length);
  291.             }
  292.         }
  293.     }
  294. }

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