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

  Coverage
  Classes Functions / Methods Lines
Total
0.00% 0 / 1
50.00% 1 / 2 CRAP
92.42% 61 / 66
JavascriptAnalyser
0.00% 0 / 1
50.00% 1 / 2 17.13
92.42% 61 / 66
 resetState()
100.00% 1 / 1 1
100.00% 2 / 2
 process($tokens, $parser_file)
0.00% 0 / 1 16.12
92.19% 59 / 64


       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 JavascriptAnalyser} class                                                              
      24                 :  *                                                                                                            
      25                 :  * @package Parsers                                                                                           
      26                 :  * @author Josh                                                                                               
      27                 :  * @since 0.2                                                                                                 
      28                 :  **/                                                                                                          
      29                 :                                                                                                               
      30                 : /**                                                                                                           
      31                 :  * Analyses the javascript tokens, and creates a set of ParserItem objects.                                   
      32                 :  **/                                                                                                          
      33                 : class JavascriptAnalyser extends Analyser {                                                                   
      34                 :     /**                                                                                                       
      35                 :      * Resets any state variables used by this class back to their initial state                              
      36                 :      **/                                                                                                      
      37                 :     public function resetState()                                                                              
      38                 :     {                                                                                                         
      39               3 :         parent::resetState();                                                                                 
      40               3 :     }                                                                                                         
      41                 :                                                                                                               
      42                 :                                                                                                               
      43                 :     /**                                                                                                       
      44                 :      * Should create ParserItem objects that represent the provided tokens                                    
      45                 :      * and apply those objects to the ParserFile specified.                                                   
      46                 :      * @return boolean True on success, false on failure                                                      
      47                 :      **/                                                                                                      
      48                 :     public function process($tokens, $parser_file)                                                            
      49                 :     {                                                                                                         
      50               3 :         $this->setTokens($tokens);                                                                            
      51                 :                                                                                                               
      52                 :         // File docblock                                                                                      
      53               3 :         $this->setPos(0);                                                                                     
      54               3 :         while ($token = $this->getToken()) {                                                                  
      55               3 :             switch ($token->getType()) {                                                                      
      56               3 :             case TOKEN_COMMENT:                                                                               
      57               1 :                 break;                                                                                        
      58                 :                                                                                                               
      59               3 :             case TOKEN_DOCBLOCK:                                                                              
      60               2 :                 $parser_file->applyComment($token->getValue());                                               
      61               2 :                 break 2;                                                                                      
      62                 :                                                                                                               
      63               1 :             default:                                                                                          
      64               1 :                 break 2;                                                                                      
      65               2 :             }                                                                                                 
      66               1 :             $this->movePosForward();                                                                          
      67               1 :         }                                                                                                     
      68                 :                                                                                                               
      69                 :         // Process functions                                                                                  
      70               3 :         $this->setPos(0);                                                                                     
      71               3 :         while ($function = $this->findTokenForwards(TOKEN_FUNCTION)) {                                        
      72               3 :             $this->setPos($this->getTokenPos());                                                              
      73                 :                                                                                                               
      74               3 :             $parser_function = new ParserFunction();                                                          
      75               3 :             $parser_file->functions[] = $parser_function;                                                     
      76                 :                                                                                                               
      77                 :             // Find the name                                                                                  
      78               3 :             $name = $this->findTokenForwards(TOKEN_IDENTIFIER);                                               
      79               3 :             if ($name == null) return false;                                                                  
      80               3 :             $parser_function->name = $name->getValue();                                                       
      81               3 :             $parser_function->linenum = $name->getLineNum();                                                  
      82                 :                                                                                                               
      83                 :             // Look for a docblock                                                                            
      84               3 :             $docblock = $this->findTokenBackwards(TOKEN_DOCBLOCK, array(TOKEN_CLOSE_CURLY_BRACKET));          
      85               3 :             if ($docblock != null) {                                                                          
      86               2 :                 $parser_function->applyComment($docblock->getValue());                                        
      87               2 :             }                                                                                                 
      88                 :                                                                                                               
      89                 :             // Find the end of the arguments by counting regular brackets                                     
      90               3 :             $depth = 0;                                                                                       
      91                 :             $find_types = array(                                                                              
      92               3 :                 TOKEN_OPEN_NORMAL_BRACKET,                                                                    
      93               3 :                 TOKEN_CLOSE_NORMAL_BRACKET,                                                                   
      94                 :                 TOKEN_IDENTIFIER                                                                              
      95               3 :             );                                                                                                
      96               3 :             $token = $this->findTokenForwards(TOKEN_OPEN_NORMAL_BRACKET);                                     
      97               3 :             $this->setPos($this->getTokenPos());                                                              
      98               3 :             while ($token) {                                                                                  
      99               3 :                 switch ($token->getType()) {                                                                  
     100               3 :                 case TOKEN_OPEN_NORMAL_BRACKET:                                                               
     101               3 :                     $depth++;                                                                                 
     102               3 :                     break;                                                                                    
     103                 :                                                                                                               
     104               3 :                 case TOKEN_CLOSE_NORMAL_BRACKET:                                                              
     105               3 :                     $depth--;                                                                                 
     106               3 :                     break;                                                                                    
     107                 :                                                                                                               
     108               0 :                 case TOKEN_IDENTIFIER:                                                                        
     109               0 :                     $arg = new ParserArgument();                                                              
     110               0 :                     $arg->name = $token->getValue();                                                          
     111               0 :                     $parser_function->args[] = $arg;                                                          
     112               0 :                     break;                                                                                    
     113                 :                                                                                                               
     114               3 :                 }                                                                                             
     115                 :                                                                                                               
     116               3 :                 if ($depth == 0) break;                                                                       
     117                 :                                                                                                               
     118               3 :                 $token = $this->findTokenForwards($find_types);                                               
     119               3 :                 $this->setPos($this->getTokenPos());                                                          
     120               3 :             }                                                                                                 
     121                 :                                                                                                               
     122                 :             // Find the end of the function by counting curly brackets                                        
     123               3 :             $depth = 0;                                                                                       
     124               3 :             $token = $this->findTokenForwards(TOKEN_OPEN_CURLY_BRACKET);                                      
     125               3 :             $this->setPos($this->getTokenPos());                                                              
     126               3 :             while ($token) {                                                                                  
     127               3 :                 if ($token->getType() == TOKEN_OPEN_CURLY_BRACKET) $depth++;                                  
     128               3 :                 if ($token->getType() == TOKEN_CLOSE_CURLY_BRACKET) $depth--;                                 
     129                 :                                                                                                               
     130               3 :                 if ($depth == 0) break;                                                                       
     131                 :                                                                                                               
     132               3 :                 $token = $this->findTokenForwards(array(TOKEN_OPEN_CURLY_BRACKET, TOKEN_CLOSE_CURLY_BRACKET));
     133               3 :                 $this->setPos($this->getTokenPos());                                                          
     134               3 :             }                                                                                                 
     135                 :                                                                                                               
     136               3 :             $parser_function->post_load();                                                                    
     137               3 :         }                                                                                                     
     138                 :         // End of function processing                                                                         
     139                 :                                                                                                               
     140               3 :     }                                                                                                         
     141                 :                                                                                                               
     142                 :                                                                                                               
     143                 : }                                                                                                             
     144                 :                                                                                                               
     145                 :                                                                                                               
     146                 : ?>                                                                                                            

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.