code_parser_item.php
Current file: src/processor/code_parser_item.php
Legend: executed not executed dead code

  Coverage
  Classes Functions / Methods Lines
Total
100.00% 1 / 1
100.00% 9 / 9 CRAP
100.00% 85 / 85
CodeParserItem
100.00% 1 / 1
100.00% 10 / 10 28
100.00% 85 / 85
 processSpecificDocblockTags($docblock_tags)
100.00% 1 / 1 1
100.00% 0 / 0
 treeWalk($function_name, ParserItem $parent_item = null)
100.00% 1 / 1 1
100.00% 3 / 3
 __construct()
100.00% 1 / 1 1
100.00% 8 / 8
 applyComment($comment)
100.00% 1 / 1 1
100.00% 2 / 2
 processTags()
100.00% 1 / 1 1
100.00% 3 / 3
 cascadeTags($child)
100.00% 1 / 1 3
100.00% 9 / 9
 getDocblockTags()
100.00% 1 / 1 1
100.00% 1 / 1
 setDocblockTags($tags)
100.00% 1 / 1 1
100.00% 2 / 2
 processGenericDocblockTags($docblock_tags)
100.00% 1 / 1 15
100.00% 48 / 48
 dump()
100.00% 1 / 1 3
100.00% 4 / 4


       1                 : <?php                                                                                                            
       2                 : /*                                                                                                               
       3                 : Copyright 2008 Josh Heidenreich                                                                                  
       4                 :                                                                                                                  
       5                 : This file is part of Pelzini.                                                                                    
       6                 :                                                                                                                  
       7                 : Pelzini is free software: you can redistribute it and/or modify                                                  
       8                 : it under the terms of the GNU General Public License as published by                                             
       9                 : the Free Software Foundation, either version 3 of the License, or                                                
      10                 : (at your option) any later version.                                                                              
      11                 :                                                                                                                  
      12                 : Pelzini is distributed in the hope that it will be useful,                                                       
      13                 : but WITHOUT ANY WARRANTY; without even the implied warranty of                                                   
      14                 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                                    
      15                 : GNU General Public License for more details.                                                                     
      16                 :                                                                                                                  
      17                 : You should have received a copy of the GNU General Public License                                                
      18                 : along with Pelzini.  If not, see <http://www.gnu.org/licenses/>.                                                 
      19                 : */                                                                                                               
      20                 :                                                                                                                  
      21                 :                                                                                                                  
      22                 : /**                                                                                                              
      23                 :  * Contains the {@link CodeParserItem} class                                                                     
      24                 :  *                                                                                                               
      25                 :  * @package Parser model                                                                                         
      26                 :  * @author Josh Heidenreich                                                                                      
      27                 :  * @since 0.1                                                                                                    
      28                 :  **/                                                                                                             
      29                 :                                                                                                                  
      30                 : /**                                                                                                              
      31                 :  * Stores information about parser items that are actual source code.                                            
      32                 :  * Typically these parser items have authors and versions, so all of that information                            
      33                 :  * is stored in this class.                                                                                      
      34                 :  *                                                                                                               
      35                 :  * @todo Add get/set methods instead of using public variables                                                   
      36                 :  **/                                                                                                             
      37                 : abstract class CodeParserItem extends ParserItem {                                                               
      38                 :     public $authors;                                                                                             
      39                 :     public $since;                                                                                               
      40                 :     public $tables;                                                                                              
      41                 :     public $see;                                                                                                 
      42                 :     public $info_tags;                                                                                           
      43                 :     public $linenum = 0;                                                                                         
      44                 :                                                                                                                  
      45                 :     protected $docblock_tags;                                                                                    
      46                 :                                                                                                                  
      47                 :                                                                                                                  
      48                 :     /**                                                                                                          
      49                 :      * Processes the docblock tags for a specific item                                                           
      50                 :      **/                                                                                                         
      51                 :     abstract protected function processSpecificDocblockTags($docblock_tags);                                     
      52               2 :                                                                                                                  
      53                 :                                                                                                                  
      54               7 :     /**                                                                                                          
      55               7 :      * Executes a function for this ParserItem, and all of its children ParserItems                              
      56                 :      *                                                                                                           
      57                 :      * The function will be called with a two arguments, the ParserItem that it should operate on, and the parent
      58                 :      * of the parser item                                                                                        
      59                 :      **/                                                                                                         
      60                 :     public function treeWalk($function_name, ParserItem $parent_item = null)                                     
      61             100 :     {                                                                                                            
      62              78 :         call_user_func($function_name, $this, $parent_item);                                                     
      63              78 :     }                                                                                                            
      64                 :                                                                                                                  
      65                 :                                                                                                                  
      66              38 :     /**                                                                                                          
      67                 :      * This constructor must be called by extending classes                                                      
      68                 :      **/                                                                                                         
      69                 :     protected function __construct()                                                                             
      70                 :     {                                                                                                            
      71             103 :         parent::__construct();                                                                                   
      72                 :                                                                                                                  
      73             103 :         $this->docblock_tags = array();                                                                          
      74             103 :         $this->authors = array();                                                                                
      75             103 :         $this->since = null;                                                                                     
      76             103 :         $this->tables = array();                                                                                 
      77             103 :         $this->see = array();                                                                                    
      78             103 :         $this->info_tags = array();                                                                              
      79             103 :     }                                                                                                            
      80                 :                                                                                                                  
      81                 :                                                                                                                  
      82                 :     /**                                                                                                          
      83                 :      * This parses a comment for a specific item                                                                 
      84                 :      **/                                                                                                         
      85                 :     public function applyComment($comment)                                                                       
      86                 :     {                                                                                                            
      87              46 :         $this->docblock_tags = parse_doc_comment ($comment);                                                     
      88              46 :     }                                                                                                            
      89                 :                                                                                                                  
      90               1 :                                                                                                                  
      91                 :     /**                                                                                                          
      92                 :      * Processes the tags for a specific item                                                                    
      93                 :      **/                                                                                                         
      94                 :     public function processTags()                                                                                
      95                 :     {                                                                                                            
      96             103 :         $this->processGenericDocblockTags($this->docblock_tags);                                                 
      97             103 :         $this->processSpecificDocblockTags($this->docblock_tags);                                                
      98             103 :     }                                                                                                            
      99                 :                                                                                                                  
     100                 :                                                                                                                  
     101                 :     /**                                                                                                          
     102                 :      * Cascades parent Docblock tags into a child item                                                           
     103                 :      * Only cascades the tags specified in the config                                                            
     104                 :      *                                                                                                           
     105                 :      * @param ParserItem $child The child item to cascade the tags into                                          
     106                 :      **/                                                                                                         
     107                 :     public function cascadeTags($child)                                                                          
     108                 :     {                                                                                                            
     109             102 :         $cascaseDocblockTags = array('@author', '@since');                                                       
     110                 :                                                                                                                  
     111             102 :         $child_tags = $child->getDocblockTags();                                                                 
     112                 :                                                                                                                  
     113             102 :         foreach ($cascaseDocblockTags as $cascade_tag) {                                                         
     114             102 :             if (! in_array($cascade_tag, array_keys($child_tags))) {                                             
     115             102 :                 $child_tags[$cascade_tag] = @$this->docblock_tags[$cascade_tag];                                 
     116             102 :             }                                                                                                    
     117             102 :         }                                                                                                        
     118                 :                                                                                                                  
     119             102 :         $child->setDocblockTags($child_tags);                                                                    
     120             102 :     }                                                                                                            
     121                 :                                                                                                                  
     122                 :                                                                                                                  
     123                 :     /**                                                                                                          
     124                 :      * Gets the Docblock tags of this item                                                                       
     125                 :      **/                                                                                                         
     126                 :     public function getDocblockTags()                                                                            
     127                 :     {                                                                                                            
     128             103 :         return $this->docblock_tags;                                                                             
     129                 :     }                                                                                                            
     130                 :                                                                                                                  
     131                 :                                                                                                                  
     132                 :     /**                                                                                                          
     133                 :      * Sets the Docblock tags for this item                                                                      
     134                 :      *                                                                                                           
     135                 :      * @param array $tags The new docblock tags.                                                                 
     136                 :      **/                                                                                                         
     137                 :     public function setDocblockTags($tags)                                                                       
     138                 :     {                                                                                                            
     139             102 :         $this->docblock_tags = $tags;                                                                            
     140             102 :     }                                                                                                            
     141                 :                                                                                                                  
     142                 :                                                                                                                  
     143                 :     /**                                                                                                          
     144                 :      * Processes general DocBlock tags that should apply to everything                                           
     145                 :      **/                                                                                                         
     146                 :     protected function processGenericDocblockTags($docblock_tags)                                                
     147                 :     {                                                                                                            
     148                 :         // @author                                                                                               
     149             103 :         if (@count($docblock_tags['@author']) > 0) {                                                             
     150                 :             // This regex is for taking an author string, and getting the name (required),                       
     151                 :             // email address (optional) and description (optional).                                              
     152                 :             // The format, simply put, is:                                                                       
     153                 :             //    {Name} (<{Email}>)? ({Description})?                                                           
     154                 :             // There is also some extra cleverness, such as you can use a comma, colon or semi-colon             
     155                 :             // to seperate the name part and the description part                                                
     156                 :             //                                                                                                   
     157                 :             //               | name part  || email address part         || desc part         |                   
     158               5 :             $expression = '/^((?:[a-z] ?)+)(?:\s*<([-a-z._]+@[-a-z.]+)>)?(?:\s*[,:;]?\s*(.*))?$/si';             
     159                 :                                                                                                                  
     160               5 :             foreach ($docblock_tags['@author'] as $author) {                                                     
     161               5 :                 if (preg_match($expression, $author, $matches)) {                                                
     162               5 :                     $author = new ParserAuthor();                                                                
     163               5 :                     $author->name = $matches[1];                                                                 
     164               5 :                     $author->email = $matches[2];                                                                
     165               5 :                     $author->description = $matches[3];                                                          
     166                 :                                                                                                                  
     167               5 :                     $this->authors[] = $author;                                                                  
     168               5 :                 }                                                                                                
     169               5 :             }                                                                                                    
     170               5 :         }                                                                                                        
     171                 :                                                                                                                  
     172                 :         // @since                                                                                                
     173             103 :         if (@count($docblock_tags['@since']) > 0) {                                                              
     174               6 :             $this->since = $docblock_tags['@since'][0];                                                          
     175               6 :         }                                                                                                        
     176                 :                                                                                                                  
     177                 :         // @table                                                                                                
     178             103 :         if (@count($docblock_tags['@table']) > 0) {                                                              
     179               5 :             $valid_actions = array('select', 'insert', 'update', 'delete');                                      
     180                 :                                                                                                                  
     181               5 :             foreach ($docblock_tags['@table'] as $table_def) {                                                   
     182               5 :                 if ($table_def == '') continue;                                                                  
     183                 :                                                                                                                  
     184               5 :                 $parts = explode(' ', $table_def, 3);                                                            
     185                 :                                                                                                                  
     186               5 :                 $found_action = false;                                                                           
     187               5 :                 foreach ($valid_actions as $action) {                                                            
     188               5 :                     if (strcasecmp($parts[0], $action) == 0) {                                                   
     189               4 :                         $found_action = true;                                                                    
     190               4 :                         break;                                                                                   
     191                 :                     }                                                                                            
     192               5 :                 }                                                                                                
     193                 :                                                                                                                  
     194                 :                                                                                                                  
     195               5 :                 $table = new ParserTable();                                                                      
     196                 :                                                                                                                  
     197               5 :                 if ($found_action) {                                                                             
     198               4 :                     $table->action = strtoupper($parts[0]);                                                      
     199               4 :                     $table->name = $parts[1];                                                                    
     200               4 :                     $table->description = $parts[2];                                                             
     201                 :                                                                                                                  
     202               4 :                 } else {                                                                                         
     203               1 :                     $table->name = $parts[0];                                                                    
     204               1 :                     $table->description = $parts[1] . ' ' . $parts[2];                                           
     205                 :                 }                                                                                                
     206                 :                                                                                                                  
     207               5 :                 $this->tables[] = $table;                                                                        
     208               5 :             }                                                                                                    
     209               5 :         }                                                                                                        
     210                 :                                                                                                                  
     211                 :         // @see                                                                                                  
     212             103 :         if (@count($docblock_tags['@see']) > 0) {                                                                
     213               1 :             foreach ($docblock_tags['@see'] as $see) {                                                           
     214               1 :                 $this->see[] = $see;                                                                             
     215               1 :             }                                                                                                    
     216               1 :         }                                                                                                        
     217                 :                                                                                                                  
     218                 :         // @tag                                                                                                  
     219             103 :         if (@count($docblock_tags['@tag']) > 0) {                                                                
     220               3 :             foreach ($docblock_tags['@tag'] as $info_tag) {                                                      
     221               3 :                 $this->info_tags[] = $info_tag;                                                                  
     222               3 :             }                                                                                                    
     223               3 :         }                                                                                                        
     224             103 :     }                                                                                                            
     225                 :                                                                                                                  
     226                 :                                                                                                                  
     227                 :     /**                                                                                                          
     228                 :      * Debugging use only                                                                                        
     229                 :      **/                                                                                                         
     230                 :     protected function dump()                                                                                    
     231                 :     {                                                                                                            
     232               7 :         echo '<br>Authors: '; foreach ($this->authors as $a) $a->dump();                                         
     233               7 :         echo '<br>Tables: '; foreach ($this->tables as $a) $a->dump();                                           
     234               7 :         echo '<br>Since: ', $this->since;                                                                        
     235                 :                                                                                                                  
     236                 :         //parent::dump();                                                                                        
     237               7 :     }                                                                                                            
     238                 :                                                                                                                  
     239                 :                                                                                                                  
     240                 : }                                                                                                                
     241                 :                                                                                                                  
     242                 :                                                                                                                  
     243                 : ?>                                                                                                               

Generated by PHP_CodeCoverage 1.1.2 using PHP 5.4.39-0+deb7u2 and PHPUnit 3.6.10 at Fri Sep 11 11:35:19 WIT 2015.