PHPIDS
Current file: /home/mario/workspace/php-ids.org/trunk/lib/IDS/vendors/htmlpurifier/HTMLPurifier/TokenFactory.php
Legend: executed not executed dead code

  Coverage
  Classes Methods Lines
Total
100.00 %100.00%
100.00% 1 / 1
83.33 %83.33%
83.33% 5 / 6
86.36 %86.36%
86.36% 19 / 22
 
HTMLPurifier_TokenFactory
100.00 %100.00%
100.00% 1 / 1
83.33 %83.33%
83.33% 5 / 6
86.36 %86.36%
86.36% 19 / 22
 public function __construct()
100.00 %100.00%
100.00% 1 / 1
100.00 %100.00%
100.00% 6 / 6
 public function createStart($name, $attr = array ( ))
100.00 %100.00%
100.00% 1 / 1
100.00 %100.00%
100.00% 3 / 3
 public function createEnd($name)
100.00 %100.00%
100.00% 1 / 1
100.00 %100.00%
100.00% 3 / 3
 public function createEmpty($name, $attr = array ( ))
100.00 %100.00%
100.00% 1 / 1
100.00 %100.00%
100.00% 3 / 3
 public function createText($data)
100.00 %100.00%
100.00% 1 / 1
100.00 %100.00%
100.00% 3 / 3
 public function createComment($data)
0.00 %0.00%
0.00% 0 / 1
0.00 %0.00%
0.00% 0 / 3


       1                 : <?php                                                                         
       2                 :                                                                               
       3                 : /**                                                                           
       4                 :  * Factory for token generation.                                              
       5                 :  *                                                                            
       6                 :  * @note Doing some benchmarking indicates that the new operator is much      
       7                 :  *       slower than the clone operator (even discounting the cost of the     
       8                 :  *       constructor).  This class is for that optimization.                  
       9                 :  *       Other then that, there's not much point as we don't                  
      10                 :  *       maintain parallel HTMLPurifier_Token hierarchies (the main reason why
      11                 :  *       you'd want to use an abstract factory).                              
      12                 :  * @todo Port DirectLex to use this                                           
      13                 :  */                                                                           
      14                 : class HTMLPurifier_TokenFactory                                               
      15               1 : {                                                                             
      16                 :                                                                               
      17                 :     /**                                                                       
      18                 :      * Prototypes that will be cloned.                                        
      19                 :      * @private                                                               
      20                 :      */                                                                       
      21                 :     // p stands for prototype                                                 
      22                 :     private $p_start, $p_end, $p_empty, $p_text, $p_comment;                  
      23                 :                                                                               
      24                 :     /**                                                                       
      25                 :      * Generates blank prototypes for cloning.                                
      26                 :      */                                                                       
      27                 :     public function __construct() {                                           
      28               2 :         $this->p_start  = new HTMLPurifier_Token_Start('', array());          
      29               2 :         $this->p_end    = new HTMLPurifier_Token_End('');                     
      30               2 :         $this->p_empty  = new HTMLPurifier_Token_Empty('', array());          
      31               2 :         $this->p_text   = new HTMLPurifier_Token_Text('');                    
      32               2 :         $this->p_comment= new HTMLPurifier_Token_Comment('');                 
      33               2 :     }                                                                         
      34                 :                                                                               
      35                 :     /**                                                                       
      36                 :      * Creates a HTMLPurifier_Token_Start.                                    
      37                 :      * @param $name Tag name                                                  
      38                 :      * @param $attr Associative array of attributes                           
      39                 :      * @return Generated HTMLPurifier_Token_Start                             
      40                 :      */                                                                       
      41                 :     public function createStart($name, $attr = array()) {                     
      42               2 :         $p = clone $this->p_start;                                            
      43               2 :         $p->__construct($name, $attr);                                        
      44               2 :         return $p;                                                            
      45                 :     }                                                                         
      46                 :                                                                               
      47                 :     /**                                                                       
      48                 :      * Creates a HTMLPurifier_Token_End.                                      
      49                 :      * @param $name Tag name                                                  
      50                 :      * @return Generated HTMLPurifier_Token_End                               
      51                 :      */                                                                       
      52                 :     public function createEnd($name) {                                        
      53               2 :         $p = clone $this->p_end;                                              
      54               2 :         $p->__construct($name);                                               
      55               2 :         return $p;                                                            
      56                 :     }                                                                         
      57                 :                                                                               
      58                 :     /**                                                                       
      59                 :      * Creates a HTMLPurifier_Token_Empty.                                    
      60                 :      * @param $name Tag name                                                  
      61                 :      * @param $attr Associative array of attributes                           
      62                 :      * @return Generated HTMLPurifier_Token_Empty                             
      63                 :      */                                                                       
      64                 :     public function createEmpty($name, $attr = array()) {                     
      65               2 :         $p = clone $this->p_empty;                                            
      66               2 :         $p->__construct($name, $attr);                                        
      67               2 :         return $p;                                                            
      68                 :     }                                                                         
      69                 :                                                                               
      70                 :     /**                                                                       
      71                 :      * Creates a HTMLPurifier_Token_Text.                                     
      72                 :      * @param $data Data of text token                                        
      73                 :      * @return Generated HTMLPurifier_Token_Text                              
      74                 :      */                                                                       
      75                 :     public function createText($data) {                                       
      76               2 :         $p = clone $this->p_text;                                             
      77               2 :         $p->__construct($data);                                               
      78               2 :         return $p;                                                            
      79                 :     }                                                                         
      80                 :                                                                               
      81                 :     /**                                                                       
      82                 :      * Creates a HTMLPurifier_Token_Comment.                                  
      83                 :      * @param $data Data of comment token                                     
      84                 :      * @return Generated HTMLPurifier_Token_Comment                           
      85                 :      */                                                                       
      86                 :     public function createComment($data) {                                    
      87               0 :         $p = clone $this->p_comment;                                          
      88               0 :         $p->__construct($data);                                               
      89               0 :         return $p;                                                            
      90                 :     }                                                                         
      91                 :                                                                               
      92                 : }                                                                             
      93                 :                                                                               

Generated by PHPUnit 3.3.1 and Xdebug 2.0.2 at Thu Sep 25 18:42:10 CEST 2008.