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

  Coverage
  Classes Functions / Methods Lines
Total
100.00% 1 / 1
100.00% 4 / 4 CRAP
100.00% 84 / 84
ParserFunction
100.00% 1 / 1
100.00% 4 / 4 28
100.00% 84 / 84
 __construct()
100.00% 1 / 1 1
100.00% 8 / 8
 processSpecificDocblockTags($docblock_tags)
100.00% 1 / 1 1
100.00% 2 / 2
 post_load()
100.00% 1 / 1 19
100.00% 61 / 61
 dump()
100.00% 1 / 1 7
100.00% 13 / 13


       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                 :  * Contains the {@link ParserFunction} class                                     
      23                 :  *                                                                               
      24                 :  * @package Parser model                                                         
      25                 :  * @author Josh Heidenreich                                                      
      26                 :  * @since 0.1                                                                    
      27                 :  **/                                                                             
      28                 :                                                                                  
      29                 : /**                                                                              
      30                 :  * Represents a function                                                         
      31                 :  **/                                                                             
      32                 : class ParserFunction extends CodeParserItem {                                    
      33                 :     public $name;                                                                
      34                 :     public $args;                                                                
      35                 :     public $throws;                                                              
      36                 :     public $visibility;                                                          
      37                 :     public $abstract;                                                            
      38                 :     public $description;                                                         
      39                 :     public $returns;                                                             
      40                 :     public $static;                                                              
      41                 :     public $final;                                                               
      42                 :                                                                                  
      43                 :                                                                                  
      44                 :     public function __construct()                                                
      45                 :     {                                                                            
      46              70 :         parent::__construct();                                                   
      47                 :                                                                                  
      48              70 :         $this->args = array();                                                   
      49              70 :         $this->throws = array();                                                 
      50              70 :         $this->returns = array();                                                
      51              70 :         $this->visibility = 'public';                                            
      52              70 :         $this->static = false;                                                   
      53              70 :         $this->final = false;                                                    
      54              70 :     }                                                                            
      55                 :                                                                                  
      56                 :                                                                                  
      57                 :     /**                                                                          
      58                 :      * Processes Javadoc tags that are specific to this PaserItem                
      59                 :      **/                                                                         
      60                 :     protected function processSpecificDocblockTags($docblock_tags)               
      61                 :     {                                                                            
      62              70 :         $this->description = htmlify_text(@$docblock_tags['@summary']);          
      63              70 :     }                                                                            
      64                 :                                                                                  
      65                 :                                                                                  
      66                 :     /**                                                                          
      67                 :      * Does post-pasing processing of this ParserFunction.                       
      68                 :      * Specifically, loads types for the function arguments                      
      69                 :      **/                                                                         
      70                 :     public function post_load()                                                  
      71                 :     {                                                                            
      72              70 :         $args = array();                                                         
      73              70 :         foreach ($this->args as $arg) {                                          
      74              24 :             $args[$arg->name] = $arg;                                            
      75              70 :         }                                                                        
      76                 :                                                                                  
      77                 :         // Do arguments                                                          
      78              70 :         $params = @$this->docblock_tags['@param'];                               
      79              70 :         if ($params != null) {                                                   
      80               9 :             foreach ($params as $idx => $param_tag) {                            
      81               9 :                 $parts = preg_split('/\s+/', $param_tag, 3);                     
      82                 :                                                                                  
      83               9 :                 if (isset($args[$parts[0]])) {                                   
      84                 :                     // name type desc                                            
      85               5 :                     $arg = $args[$parts[0]];                                     
      86               5 :                     if (!$arg->type) $arg->type = $parts[1];                     
      87               5 :                     unset($parts[0], $parts[1]);                                 
      88                 :                                                                                                      
      89               9 :                 } else if (isset($args[$parts[1]])) {                            
      90                 :                     // type name desc                                            
      91               2 :                     $arg = $args[$parts[1]];                                     
      92               2 :                     if (!$arg->type) $arg->type = $parts[0];                     
      93               2 :                     unset($parts[0], $parts[1]);                                 
      94                 :                                                                                                      
      95               2 :                 } else {                                                         
      96                 :                     // type desc                                                 
      97               2 :                     $arg = @$this->args[$idx];                                   
      98               2 :                     if (!$arg) continue;                                         
      99               2 :                     if (!$arg->type) $arg->type = $parts[0];                     
     100               2 :                     unset($parts[0]);                                            
     101                 :                 }                                                                
     102                 :                                                                                                  
     103               9 :                 $arg->description = htmlify_text(implode(' ', $parts));          
     104               9 :             }                                                                    
     105               9 :         }                                                                        
     106                 :                                                                                  
     107                 :         // Combine @throw and @throws docblock tags                              
     108              70 :         $throws = array();                                                       
     109              70 :         if (isset($this->docblock_tags['@throw'])) {                             
     110               4 :             $throws = $this->docblock_tags['@throw'];                            
     111               4 :         }                                                                        
     112              70 :         if (isset($this->docblock_tags['@throws'])) {                            
     113               4 :             $throws = array_merge($throws, $this->docblock_tags['@throws']);     
     114               4 :         }                                                                        
     115                 :                                                                                  
     116                 :         // Process throws                                                        
     117              70 :         foreach ($throws as $throws_tag) {                                       
     118               7 :             if ($throws_tag == '') $throws_tag = 'Exception';                    
     119               7 :             $parts = preg_split('/\s+/', $throws_tag, 2);                        
     120               7 :             $throw = new ParserThrow();                                          
     121               7 :             $throw->exception = $parts[0];                                       
     122               7 :             $throw->description = htmlify_text(@$parts[1]);                      
     123               7 :             $this->throws[] = $throw;                                            
     124              70 :         }                                                                        
     125                 :                                                                                  
     126                 :         // Do return value                                                       
     127              70 :         if (isset($this->docblock_tags['@return'])) {                            
     128              10 :             $this->returns = array();                                            
     129              10 :             foreach ($this->docblock_tags['@return'] as $return_tag) {           
     130              10 :                 $parts = preg_split('/\s+/', $return_tag, 2);                    
     131              10 :                 $types = explode('|', $parts[0]);                                
     132              10 :                 foreach ($types as $t) {                                         
     133              10 :                     $return = new ParserReturn();                                
     134              10 :                     $return->type = trim($t);                                    
     135              10 :                     $return->description = htmlify_text(@$parts[1]);             
     136              10 :                     $this->returns[] = $return;                                  
     137              10 :                 }                                                                
     138              10 :             }                                                                    
     139              10 :         }                                                                        
     140                 :                                                                                  
     141                 :         // If there is only one return tag, and the type ends in ?               
     142                 :         // Nuke the ? and create a new return tag called "null"                  
     143              70 :         if (count($this->returns) == 1) {                                        
     144               9 :             if (substr($this->returns[0]->type, -1) == '?') {                    
     145               1 :                 $this->returns[0]->type = substr($this->returns[0]->type, 0, -1);
     146               1 :                 $null_return = new ParserReturn();                               
     147               1 :                 $null_return->type = 'null';                                     
     148               1 :                 $this->returns[] = $null_return;                                 
     149               1 :             }                                                                    
     150               9 :         }                                                                        
     151              70 :     }                                                                            
     152                 :                                                                                  
     153                 :                                                                                  
     154                 :     /**                                                                          
     155                 :      * Debugging use only                                                        
     156                 :      **/                                                                         
     157                 :     public function dump()                                                       
     158                 :     {                                                                            
     159               4 :         echo '<div style="border: 1px red solid;">';                             
     160               4 :         echo $this->visibility . ' ';                                            
     161               4 :         echo $this->name;                                                        
     162               4 :         if ($this->abstract) echo '<br>abstract';                                
     163               4 :         if ($this->static) echo '<br>static';                                    
     164               4 :         if ($this->final) echo '<br>static';                                     
     165               4 :         echo '<br>' . $this->description;                                        
     166                 :                                                                                  
     167               4 :         foreach ($this->args as $a) $a->dump();                                  
     168               4 :         foreach ($this->throws as $t) $t->dump();                                
     169               4 :         foreach ($this->returns as $r) $r->dump();                               
     170                 :                                                                                  
     171               4 :         parent::dump();                                                          
     172               4 :         echo '</div>';                                                           
     173               4 :     }                                                                            
     174                 :                                                                                  
     175                 :                                                                                  
     176                 : }                                                                                
     177                 :                                                                                  
     178                 :                                                                                  
     179                 : ?>                                                                               

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.