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

  Coverage
  Classes Functions / Methods Lines
Total
100.00%  
100.00%   CRAP
77.06% 84 / 109
processor_autoload($class)
100.00% 1 / 1 0
100.00% 4 / 4
parse_doc_comment($comment)
100.00% 1 / 1 0
100.00% 31 / 31
parse_tag(&$output, $tag, $buffer)
100.00% 1 / 1 0
100.00% 8 / 8
output_status($message)
0.00% 0 / 1 0
0.00% 0 / 7
get_filenames($base_dir, $directory, array $exclude_dirs)
0.00% 0 / 1 0
0.00% 0 / 17
htmlify_text($text)
0.00% 0 / 1 0
95.45% 21 / 22
anonymous function(array $matches)
100.00% 1 / 1 0
100.00% 3 / 3
htmlify_check_tag($full_match, $tag_name)
100.00% 1 / 1 0
100.00% 6 / 6
process_javadoc_tags(CodeParserItem $parser_item, $parent)
100.00% 1 / 1 0
100.00% 5 / 5


       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                 :  * Useful functions                                                                                               
      24                 :  *                                                                                                                
      25                 :  * @package Processor                                                                                             
      26                 :  * @author Josh                                                                                                   
      27                 :  * @since 0.1                                                                                                     
      28                 :  **/                                                                                                              
      29                 :                                                                                                                   
      30                 : /**                                                                                                               
      31                 :  * Automatically loads the classes that are needed                                                                
      32                 :  **/                                                                                                              
      33                 : function processor_autoload($class)                                                                               
      34                 : {                                                                                                                 
      35               6 :     $filename = preg_replace('/([A-Z])/', '_$1', $class);                                                         
      36               6 :     $filename = __DIR__ . '/' . strtolower(substr($filename, 1)) . '.php';                                        
      37               6 :     if (file_exists($filename)) require_once $filename;                                                           
      38               6 : }                                                                                                                 
      39                 :                                                                                                                   
      40                 : spl_autoload_register('processor_autoload');                                                                      
      41                 :                                                                                                                   
      42                 : require_once __DIR__ . '/constants.php';                                                                          
      43                 :                                                                                                                   
      44                 :                                                                                                                   
      45                 : /**                                                                                                               
      46                 :  * Parses a DocBlock comment tag                                                                                  
      47                 :  * Accepts the raw comment text of the comment straight from the file, including all the stars in the middle      
      48                 :  * Returns an array of tags. Each paremeter will contain an array of the tags that existed, one for each tag      
      49                 :  * The summary is returned in a 'summary' tag.                                                                    
      50                 :  *                                                                                                                
      51                 :  * The output for a function with two param tags, a return tag and a summary will be something like the following:
      52                 :  * array {                                                                                                        
      53                 :  *   ['@summary'] = '...',                                                                                        
      54                 :  *   ['@param'] {                                                                                                 
      55                 :  *     [0] = '...',                                                                                               
      56                 :  *     [1] = '...'                                                                                                
      57                 :  *   },                                                                                                           
      58                 :  *   ['@return'] {                                                                                                
      59                 :  *     [0] = '...',                                                                                               
      60                 :  *   }                                                                                                            
      61                 :  * }                                                                                                              
      62                 :  *                                                                                                                
      63                 :  * @param string $comment The raw comment text                                                                    
      64                 :  * @return array The parsed comments, as per the example provided above                                           
      65                 :  **/                                                                                                              
      66                 : function parse_doc_comment($comment)                                                                              
      67                 : {                                                                                                                 
      68              46 :     $comment = preg_replace('/^\/\*\*/', '', $comment);                                                           
      69              46 :     $comment = preg_replace('/\*\/$/m', '', $comment);                                                            
      70              46 :     $comment = preg_replace('/^\s*\**/m', '', $comment);                                                          
      71                 :                                                                                                                   
      72                 :                                                                                                                   
      73                 :     // split into lines                                                                                           
      74              46 :     $lines = explode("\n", $comment);                                                                             
      75                 :                                                                                                                   
      76                 :     // process one line at a time                                                                                 
      77              46 :     $output = array();                                                                                            
      78              46 :     $buffer = null;                                                                                               
      79              46 :     $current = null;                                                                                              
      80              46 :     foreach ($lines as $line) {                                                                                   
      81                 :                                                                                                                   
      82              46 :         $line = preg_replace('/^\s/', '', $line);                                                                 
      83              46 :         $line = rtrim($line);                                                                                     
      84              46 :         $trimline = ltrim($line);                                                                                 
      85                 :                                                                                                                   
      86              46 :         if ($current != null and $current != '@summary' and $trimline == '') continue;                            
      87                 :                                                                                                                   
      88                 :         // process special words                                                                                  
      89              46 :         if ($trimline != '' and $trimline[0] == '@') {                                                            
      90              32 :             @list($word, $value) = preg_split('/\s+/', $trimline, 2);                                             
      91                 :                                                                                                                   
      92                 :             // tags                                                                                               
      93              32 :             if ($current != null) {                                                                               
      94              11 :                 parse_tag ($output, $current, $buffer);                                                           
      95              11 :                 $buffer = null;                                                                                   
      96              11 :             }                                                                                                     
      97              32 :             $current = $word;                                                                                     
      98              32 :             $buffer = $value;                                                                                     
      99                 :                                                                                                                   
     100                 :             // non tag - could be part of the summary, or could be a continuation of a tag                        
     101              32 :         } else {                                                                                                  
     102              20 :             if ($current != null) {                                                                               
     103               4 :                 $buffer .= "\n" . $line;                                                                          
     104                 :                                                                                                                   
     105               4 :             } else {                                                                                              
     106              20 :                 $current = '@summary';                                                                            
     107              20 :                 $buffer = $line;                                                                                  
     108                 :             }                                                                                                     
     109                 :         }                                                                                                         
     110                 :                                                                                                                   
     111              46 :     }                                                                                                             
     112                 :                                                                                                                   
     113              46 :     if ($current != null) {                                                                                       
     114              46 :         parse_tag ($output, $current, $buffer);                                                                   
     115             103 :     }                                                                                                             
     116                 :                                                                                                                   
     117              46 :     return $output;                                                                                               
     118                 : }                                                                                                                 
     119                 :                                                                                                                   
     120                 :                                                                                                                   
     121                 : /**                                                                                                               
     122                 :  * Processes the parsing of an individual tag                                                                     
     123                 :  **/                                                                                                              
     124                 : function parse_tag(&$output, $tag, $buffer)                                                                       
     125                 : {                                                                                                                 
     126              46 :     if ($tag == '@summary') {                                                                                     
     127              20 :         $output[$tag] = $buffer;                                                                                  
     128                 :                                                                                                                   
     129              20 :     } else {                                                                                                      
     130              32 :         if (! isset($output[$tag])) {                                                                             
     131              32 :             $output[$tag] = array();                                                                              
     132              32 :         }                                                                                                         
     133              32 :         $output[$tag][] = $buffer;                                                                                
     134                 :     }                                                                                                             
     135              46 : }                                                                                                                 
     136                 :                                                                                                                   
     137                 :                                                                                                                   
     138                 : /**                                                                                                               
     139                 :  * Outputs a status message                                                                                       
     140                 :  *                                                                                                                
     141                 :  * @param string $message The message to output                                                                   
     142                 :  **/                                                                                                              
     143                 : function output_status($message)                                                                                  
     144                 : {                                                                                                                 
     145               0 :     if (PHP_SAPI == 'cli') {                                                                                      
     146               0 :         $message = preg_replace('/<a[^>]* href=[\'"](.+?)[\'"][^>]*>(.*?)<\/a>/i', '$2 [LINK: $1]', $message);    
     147               0 :         echo strip_tags($message) . "\n";                                                                         
     148                 :                                                                                                                   
     149               0 :     } else {                                                                                                      
     150               0 :         echo $message . "<br>";                                                                                   
     151                 :     }                                                                                                             
     152               0 :     flush();                                                                                                      
     153               0 : }                                                                                                                 
     154                 :                                                                                                                   
     155                 :                                                                                                                   
     156                 : /**                                                                                                               
     157                 :  * Gets all the filenames in a directory and in the subdirectories                                                
     158                 :  **/                                                                                                              
     159                 : function get_filenames($base_dir, $directory, array $exclude_dirs)                                                
     160                 : {                                                                                                                 
     161               0 :     $exclude_dir = preg_replace('!^/!', '', $directory);                                                          
     162               0 :     if (in_array($exclude_dir, $exclude_dirs)) return null;                                                       
     163                 :                                                                                                                   
     164               0 :     $handle = opendir($base_dir . $directory);                                                                    
     165               0 :     if ($handle === false) return null;                                                                           
     166                 :                                                                                                                   
     167               0 :     $files = array();                                                                                             
     168               0 :     while (($file = readdir($handle)) !== false) {                                                                
     169               0 :         if ($file[0] == '.') continue;                                                                            
     170                 :                                                                                                                   
     171               0 :         if (is_dir($base_dir . $directory . '/'. $file)) {                                                        
     172                 :             // If its a directory, get the files in it                                                            
     173               0 :             $files2 = get_filenames($base_dir, $directory . '/'. $file, $exclude_dirs);                           
     174               0 :             if (is_array($files2)) {                                                                              
     175               0 :                 $files = array_merge($files, $files2);                                                            
     176               0 :             }                                                                                                     
     177                 :                                                                                                                   
     178               0 :         } else {                                                                                                  
     179                 :             // Otherwise just add the file to our list                                                            
     180               0 :             $files[] = $directory . '/'. $file;                                                                   
     181                 :         }                                                                                                         
     182               0 :     }                                                                                                             
     183                 :                                                                                                                   
     184               0 :     closedir($handle);                                                                                            
     185                 :                                                                                                                   
     186               0 :     return $files;                                                                                                
     187                 : }                                                                                                                 
     188                 :                                                                                                                   
     189                 :                                                                                                                   
     190                 : /**                                                                                                               
     191                 :  * This will take the provided text, and turn it into HTML                                                        
     192                 :  * If it contains HTML, it will validate it, otherwise it                                                         
     193                 :  * will wrap everything in a PRE                                                                                  
     194                 :  *                                                                                                                
     195                 :  * This function also removes extra spaces from the beginning of lines                                            
     196                 :  * but will do so in a manner that indenting is preserved                                                         
     197                 :  **/                                                                                                              
     198                 : function htmlify_text($text)                                                                                      
     199                 : {                                                                                                                 
     200             113 :     if ($text == '') return null;                                                                                 
     201                 :                                                                                                                   
     202                 :     // if the code contains block level HTML, output it as is                                                     
     203                 :     // todo: come up with a smarter solution                                                                      
     204              52 :     $has_block_html = preg_match('/<(p|div|pre|table)( .*)?>/i', $text);                                          
     205              52 :     if ($has_block_html) {                                                                                        
     206               0 :         return $text;                                                                                             
     207                 :     }                                                                                                             
     208                 :                                                                                                                   
     209                 :     // otherwise, we do clever indenting                                                                          
     210              52 :     $lines = explode("\n", $text);                                                                                
     211              52 :     $min_num_spaces = 1000;                                                                                       
     212              52 :     foreach ($lines as $line) {                                                                                   
     213              52 :         if (trim($line) == '') continue;                                                                          
     214              52 :         $num_spaces = 0;                                                                                          
     215              52 :         for ($i = 0; $i < strlen($line); $i++) {                                                                  
     216              52 :             if ($line[$i] != ' ') break;                                                                          
     217              21 :             ++$num_spaces;                                                                                        
     218              21 :         }                                                                                                         
     219              52 :         $min_num_spaces = min($min_num_spaces, $num_spaces);                                                      
     220              52 :     }                                                                                                             
     221                 :                                                                                                                   
     222                 :     // remove trailing whitespace                                                                                 
     223              52 :     $text = '';                                                                                                   
     224              52 :     $j = 0;                                                                                                       
     225              52 :     foreach ($lines as $line) {                                                                                   
     226              52 :         if ($j++ > 0) $text .= "\n";                                                                              
     227              52 :         $text .= substr($line, $min_num_spaces);                                                                  
     228              52 :     }                                                                                                             
     229                 :                                                                                                                   
     230                 :     // remove invalid HTML tags                                                                                   
     231              52 :     $text = str_replace('&', '&amp;', $text);                                                                     
     232              52 :     $replacer = function(array $matches) {                                                                        
     233              22 :         return htmlify_check_tag(stripslashes($matches[0]), stripslashes($matches[1]));                           
     234              52 :     };                                                                                                            
     235              52 :     $text = preg_replace_callback('/<\/?([a-z]+)(?>\s|"[^"]*"|\'[^\']*\'|[^\'">])*>/i', $replacer, $text);        
     236              52 :     $text = preg_replace('/<([^\/a-z])/i', '&lt;$1', $text);                                                      
     237              52 :     $text = preg_replace('/([^"\'a-z])>/i', '$1&gt;', $text);                                                     
     238              52 :     $text = str_replace('"', '&quot;', $text);                                                                    
     239                 :                                                                                                                   
     240                 :     // wrap it all in a PRE                                                                                       
     241              52 :     $text = "<pre>\n{$text}</pre>";                                                                               
     242                 :                                                                                                                   
     243              52 :     return $text;                                                                                                 
     244                 : }                                                                                                                 
     245                 :                                                                                                                   
     246                 :                                                                                                                   
     247                 : /**                                                                                                               
     248                 :  * Does processing on a single HTML tag, as provided by a regex in {@link htmlify_text}                           
     249                 :  *                                                                                                                
     250                 :  * @param string $full_match The full tag that was found (e.g. '<select name="blah">')                            
     251                 :  * @param string $tag_name The name of the tag that was found (e.g. 'select')                                     
     252                 :  * @return string What the tag should be replaced with                                                            
     253                 :  **/                                                                                                              
     254                 : function htmlify_check_tag($full_match, $tag_name)                                                                
     255                 :     {;                                                                                                            
     256                 :     // valid tags get used as-is                                                                                  
     257              22 :     $valid_tags = array ('b', 'i', 'em', 'strong');                                                               
     258              22 :     if (in_array($tag_name, $valid_tags)) {                                                                       
     259              21 :         return $full_match;                                                                                       
     260                 :     }                                                                                                             
     261                 :                                                                                                                   
     262                 :     // everything else gets encoded                                                                               
     263               1 :     $full_match = str_replace('<', '&lt;', $full_match);                                                          
     264               1 :     $full_match = str_replace('>', '&gt;', $full_match);                                                          
     265               1 :     return $full_match;                                                                                           
     266                 : }                                                                                                                 
     267                 :                                                                                                                   
     268                 :                                                                                                                   
     269                 : /**                                                                                                               
     270                 :  * Processes the javadoc tags for a specific parser item                                                          
     271                 :  **/                                                                                                              
     272                 : function process_javadoc_tags(CodeParserItem $parser_item, $parent)                                               
     273                 : {                                                                                                                 
     274             103 :     if ($parent != null) {                                                                                        
     275             102 :         $parent->cascadeTags($parser_item);                                                                       
     276             102 :     }                                                                                                             
     277                 :                                                                                                                   
     278             103 :     $parser_item->processTags();                                                                                  
     279             103 : }                                                                                                                 
     280                 :                                                                                                                   
     281                 :                                                                                                                   
     282                 : ?>                                                                                                                

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.