Source for file Language.class.php

Documentation is available at Language.class.php

  1. <?php
  2. /**
  3.  * Gumbo Library Framework
  4.  *
  5.  * LICENSE
  6.  * This library is being released under the terms of the New BSD License.  A
  7.  * copy of the license is packaged with the software (LICENSE.txt).  If no
  8.  * copy is found, a copy of the license template can be found at:
  9.  * http://www.opensource.org/licenses/bsd-license.php
  10.  * 
  11.  * @category Gumbo
  12.  * @package Filter
  13.  * @copyright Copyright (c) 2007, iBayou, Michael Luster
  14.  * @license http://www.opensource.org/licenses/bsd-license.php New BSD License
  15.  * @author Michael Luster <mluster79@yahoo.com>
  16.  * @link http://sourceforge.net/projects/phpgumbo
  17.  * @version 0.0.1
  18.  */
  19.  
  20. /**
  21.  * Language Filter Class
  22.  *
  23.  * @category Gumbo
  24.  * @package Filter
  25.  * @copyright Copyright (c) 2007, iBayou, Michael Luster
  26.  * @license http://www.opensource.org/licenses/bsd-license.php New BSD License
  27.  * @author Michael Luster <mluster79@yahoo.com>
  28.  * @link http://sourceforge.net/projects/phpgumbo
  29.  * @desc Language Filter Class
  30.  * @version 0.0.1
  31.  */
  32.  
  33. gumbo_load ("Filter_Preg");
  34.  
  35. class Gumbo_Filter_Language extends Gumbo_Filter_Preg {
  36.     
  37.     /** @var array $_words words (or word patterns) to filter */
  38.     private $_words = array ();
  39.     
  40.     
  41.     
  42.     /**
  43.      * Constructor
  44.      * @param string $char replacement character
  45.      */
  46.     public function __construct ($char=null) {
  47.         parent::__construct (null, $char, null);
  48.         $this->resetWords ();
  49.     }
  50.     
  51.     
  52.     
  53.     /** ACTION METHODS **/
  54.     /**
  55.      * Runs the Filter process, returning the results
  56.      * @param string $data data to filter
  57.      * @return string 
  58.      */
  59.     public function run ($data) {
  60.         $this->setPattern ($this->getWords (true));
  61.         return parent::run ($data);
  62.     }
  63.     
  64.     /**
  65.      * Adds a Word (or Word Pattern) to the list
  66.      * @param string $word 
  67.      * @throws Gumbo_Exception
  68.      */
  69.     public function addWord ($word) {
  70.         try {
  71.             // verify precondition
  72.             if (!is_string ($word)) {
  73.                 throw new Gumbo_Exception ("Invalid Argument 'word:str' => {$word}:" . gettype ($word));
  74.             }
  75.             if ($this->isWord ($word)) {
  76.                 throw new Gumbo_Exception ("Word (Pattern) Exists: {$word}");
  77.             }
  78.             
  79.             $this->_words [] = $word;
  80.         } catch (Gumbo_Exception $e) {
  81.             $e->setFunction (__METHOD__);
  82.             gumbo_trigger ($e);
  83.         }
  84.     }
  85.     
  86.     /**
  87.      * Removes a Word (or Word Pattern) from the list
  88.      * @param string $word 
  89.      * @throws Gumbo_Exception
  90.      */
  91.     public function removeWord ($word) {
  92.         try {
  93.             // verify precondition
  94.             if (!is_string ($word)) {
  95.                 throw new Gumbo_Exception ("Invalid Argument 'word:str' => {$word}:" . gettype ($word));
  96.             }
  97.             
  98.             if (!$this->isWord ($word)) {
  99.                 throw new Gumbo_Exception ("Word (Pattern) Undefined: {$word}");
  100.             }
  101.             
  102.             foreach ($this->getWords () as $key=>$val) {
  103.                 if ($tag === $val) {
  104.                     unset ($this->_words [$key]);
  105.                     break;
  106.                 }
  107.             }
  108.         } catch (Gumbo_Exception $e) {
  109.             $e->setFunction (__METHOD__);
  110.             gumbo_trigger ($e);
  111.         }
  112.     }
  113.     
  114.     /**
  115.      * Resets ALL the Words
  116.      * @postcondition words to default
  117.      */
  118.     public function resetWords () {
  119.         $this->_words = array ();
  120.         $this->_words [] = "\b([\w\d]*)?[fF][uU\W][cC\W][kK\W]([\w\d]*)?\b";
  121.         $this->_words [] = "\b([\w\d]*)?[sS$][hH\W][iI\W][tT\W]([\w\d]*)?\b";
  122.         $this->_words [] = "\b[aA@][sS\$]{2}([\w\d]*)?\b";
  123.         $this->_words [] = "\b[cC][oO0\W][cC\W][kK]([sS][uU][cC][kK]([\w\d]*)?)?\b";
  124.         $this->_words [] = "\b([gG][oO][dD])?[dD][aA@\W][mM][nN]([\w\d]*)?\b";
  125.         $this->_words [] = "\b([\w\d]*)?[bB][iI][tT][cC][hH]([\w\d]*)?\b";
  126.         $this->_words [] = "\b[cC][uU][nN][tT]([\w\d]*)\b";
  127.     }
  128.     
  129.     
  130.     
  131.     /** MUTATOR METHODS **/
  132.     /**
  133.      * Sets the Words (or Word Patterns) to Filter
  134.      * @param string $words 
  135.      * @throws Gumbo_Exception
  136.      */
  137.     public function setWords ($words=null) {
  138.         if (is_null ($words)) { return; }
  139.         try {
  140.             // verify precondition
  141.             if (!is_string ($words) && !is_array ($words)) {
  142.                 throw new Gumbo_Exception ("Invalid Argument 'tag:str|arr' => {$words}:" . gettype ($words));
  143.             }
  144.             
  145.             // check for multiple arguments
  146.             if (func_num_args () > 1) {
  147.                 $words = func_get_args ();
  148.             }
  149.             
  150.             // check if an array
  151.             if (is_array ($words)) {
  152.                 foreach ($words as $val) {
  153.                     $this->setTags ($val);
  154.                 }
  155.                 return;
  156.             }
  157.             
  158.             $this->addWord($words);
  159.         } catch (Gumbo_Exception $e) {
  160.             $e->setFunction (__METHOD__);
  161.             gumbo_trigger ($e);
  162.         }
  163.     }
  164.     
  165.     
  166.     
  167.     /** ACCESSOR METHODS **/
  168.     /**
  169.      * Returns ALL the Filter Words
  170.      * @param bool $as_string formats as a string pattern
  171.      * @return array|string
  172.      */
  173.     public function getWords ($as_string=false) {
  174.         try {
  175.             // verify precondition
  176.             if (!is_bool ($as_string)) {
  177.                 throw new Gumbo_Exception ("Invalid Argument 'as_string:bool' => {$as_string}:" . gettype ($as_string));
  178.             }
  179.         } catch (Gumbo_Exception $e) {
  180.             $e->setFunction (__METHOD__);
  181.             gumbo_trigger ($e);
  182.             $as_string = false;
  183.         }
  184.         
  185.         if ($as_string) {
  186.             $pattern = "(";
  187.             foreach ($this->getWords () as $val) {
  188.                 $pattern .= $val . "|";
  189.             }
  190.             return substr ($pattern, 0, strlen ($pattern) - 1) . ")";
  191.         }
  192.         
  193.         return $this->_words;
  194.     }
  195.     
  196.     /**
  197.      * Returns if the Word (Pattern) Exists
  198.      * @param string $word 
  199.      * @return bool 
  200.      */
  201.     public function isWord ($word) {
  202.         $found = false;
  203.         try {
  204.             // verify precondition
  205.             if (!is_string ($word)) {
  206.                 throw new Gumbo_Exception ("Invalid Argument 'word:str' => {$word}:" . gettype ($word));
  207.             }
  208.             
  209.             foreach ($this->getWords () as $val) {
  210.                 if ($word === $val) {
  211.                     $found = true;
  212.                     break;
  213.                 }
  214.             }
  215.         } catch (Gumbo_Exception $e) {
  216.             $e->setFunction (__METHOD__);
  217.             gumbo_trigger ($e);
  218.         }
  219.         return $found;
  220.     }
  221.     
  222. }
  223.  
  224. ?>