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

  Coverage
  Classes Functions / Methods Lines
Total
0.00% 0 / 1
50.00% 1 / 2 CRAP
95.00% 19 / 20
JavascriptParser
0.00% 0 / 1
50.00% 1 / 2 6
95.00% 19 / 20
 __construct()
100.00% 1 / 1 1
100.00% 3 / 3
 parseFile($base_dir, $filename)
0.00% 0 / 1 5.01
94.12% 16 / 17


       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 JavascriptParser} class                                                           
      24                 :  *                                                                                                       
      25                 :  * @package Parsers                                                                                      
      26                 :  * @author Josh                                                                                          
      27                 :  * @since 0.2                                                                                            
      28                 :  **/                                                                                                     
      29                 :                                                                                                          
      30                 : /**                                                                                                      
      31                 :  * Does the complete parsing of a javascript file.                                                       
      32                 :  **/                                                                                                     
      33                 : class JavascriptParser                                                                                   
      34                 : {                                                                                                        
      35                 :     private $lexer;                                                                                      
      36                 :     private $analyser;                                                                                   
      37                 :                                                                                                          
      38                 :     public function __construct()                                                                        
      39                 :     {                                                                                                    
      40               3 :         $this->lexer = new JavascriptLexer();                                                            
      41               3 :         $this->analyser = new JavascriptAnalyser();                                                      
      42               3 :     }                                                                                                    
      43                 :                                                                                                          
      44                 :                                                                                                          
      45                 :     /**                                                                                                  
      46                 :      * Parses a file                                                                                     
      47                 :      *                                                                                                   
      48                 :      * @param string $filename The file to parse                                                         
      49                 :      * @return A ParserFile object, or null if there was an error                                        
      50                 :      **/                                                                                                 
      51                 :     public function parseFile($base_dir, $filename)                                                      
      52                 :     {                                                                                                    
      53               3 :         $this->lexer->resetState();                                                                      
      54               3 :         $this->analyser->resetState();                                                                   
      55                 :                                                                                                          
      56               3 :         $source = @file_get_contents($base_dir . $filename);                                             
      57               3 :         if ($source == null) return null;                                                                
      58                 :                                                                                                          
      59                 :         // Simple "minified" detection                                                                   
      60                 :         // These don't have useful comments, and sometimes crash the parser as well                      
      61               3 :         $num_lines = substr_count($source, "\n") + 1;                                                    
      62               3 :         $num_chars = strlen($source);                                                                    
      63               3 :         $avg_line_length = $num_chars / $num_lines;                                                      
      64               3 :         if ($avg_line_length > 200) {                                                                    
      65               0 :             return null;                                                                                 
      66                 :         }                                                                                                
      67                 :                                                                                                                  
      68               3 :         $tokens = $this->lexer->process($source);                                                        
      69               3 :         if ($tokens === null) return null;                                                               
      70                 :                                                                                                          
      71                 :         //echo "<style>i {color: #777;}</style>";                                                        
      72                 :         //echo '<pre>Tokens for file ', $filename, "\n";                                                 
      73                 :         //foreach ($tokens as $i => $t) echo "<b>{$i}</b> {$t->getTypeName()} <i>{$t->getValue()}</i>\n";
      74                 :         //echo '</pre>';                                                                                 
      75                 :                                                                                                          
      76               3 :         $file = new ParserFile();                                                                        
      77               3 :         $file->name = $filename;                                                                         
      78               3 :         $file->source = $source;                                                                         
      79                 :                                                                                                          
      80               3 :         $result = $this->analyser->process($tokens, $file);                                              
      81               3 :         if ($result === false) return null;                                                              
      82                 :                                                                                                          
      83               3 :         return $file;                                                                                    
      84                 :     }                                                                                                    
      85                 :                                                                                                          
      86                 :                                                                                                          
      87                 : }                                                                                                        
      88                 :                                                                                                          
      89                 :                                                                                                          
      90                 : ?>                                                                                                       

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.