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

  Coverage
  Classes Functions / Methods Lines
Total
100.00% 1 / 1
100.00% 6 / 6 CRAP
100.00% 106 / 106
QualityCheckTransformer
100.00% 1 / 1
100.00% 6 / 6 39
100.00% 106 / 106
 __construct(array $required_tags = null)
100.00% 1 / 1 2
100.00% 5 / 5
 transform(&$parser_model)
100.00% 1 / 1 5
100.00% 20 / 20
 check_files($item)
100.00% 1 / 1 10
100.00% 25 / 25
 check_class($item)
100.00% 1 / 1 7
100.00% 18 / 18
 check_interface($item)
100.00% 1 / 1 7
100.00% 18 / 18
 check_function($item, $from = null)
100.00% 1 / 1 8
100.00% 20 / 20


       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 QualityCheckTransformer} class                                                                                                     
      24                 :  *                                                                                                                                                        
      25                 :  * @package Transformers                                                                                                                                  
      26                 :  * @author Josh                                                                                                                                           
      27                 :  * @since 0.2                                                                                                                                             
      28                 :  **/                                                                                                                                                      
      29                 :                                                                                                                                                           
      30                 : /**                                                                                                                                                       
      31                 :  * This is a transformer that does quality checks on the codebase                                                                                         
      32                 :  *                                                                                                                                                        
      33                 :  * It checks that the documentation has the required tags. Currently the 'required tags' are only the summary                                             
      34                 :  *                                                                                                                                                        
      35                 :  * The documentation is created in a report called the {@link Quality check report}.                                                                      
      36                 :  **/                                                                                                                                                      
      37                 : class QualityCheckTransformer extends Transformer {                                                                                                       
      38                 :     private $offending_items;                                                                                                                             
      39                 :     private $required_tags;                                                                                                                               
      40                 :                                                                                                                                                           
      41                 :                                                                                                                                                           
      42                 :     /**                                                                                                                                                   
      43                 :     * Set up the quality check transformer                                                                                                                
      44                 :     *                                                                                                                                                     
      45                 :     * @param array $required_tags Docblock tags which will be reported if missing                                                                         
      46                 :     **/                                                                                                                                                   
      47                 :     public function __construct(array $required_tags = null)                                                                                              
      48                 :     {                                                                                                                                                     
      49              20 :         $this->required_tags = $required_tags;                                                                                                            
      50              20 :         if (empty($this->required_tags)) {                                                                                                                
      51              14 :             $this->required_tags = array('@summary');                                                                                                     
      52              14 :         }                                                                                                                                                 
      53              20 :     }                                                                                                                                                     
      54                 :                                                                                                                                                           
      55                 :                                                                                                                                                           
      56                 :     /**                                                                                                                                                   
      57                 :      * Transforms the data model before outputting.                                                                                                       
      58                 :      *                                                                                                                                                    
      59                 :      * This transformer generates a report of objects that do not have good enough documentation                                                          
      60                 :      *                                                                                                                                                    
      61                 :      * @param array $parser_model The data model to transform                                                                                             
      62                 :      * @return array The new data model, or null if there was an error                                                                                    
      63                 :      **/                                                                                                                                                  
      64                 :     public function transform(&$parser_model)                                                                                                             
      65                 :     {                                                                                                                                                     
      66              20 :         $this->offending_items = array();                                                                                                                 
      67                 :                                                                                                                                                           
      68              20 :         foreach ($parser_model as $item) {                                                                                                                
      69              20 :             if ($item instanceof CodeParserItem) {                                                                                                        
      70              20 :                 $this->check_files($item);                                                                                                                
      71              20 :             }                                                                                                                                             
      72              20 :         }                                                                                                                                                 
      73                 :                                                                                                                                                           
      74              20 :         if (count($this->offending_items) == 0) {                                                                                                         
      75               1 :             return null;                                                                                                                                  
      76                 :         }                                                                                                                                                 
      77              19 :         ksort($this->offending_items);                                                                                                                    
      78                 :                                                                                                                                                           
      79              19 :         $report = "The following items have insufficent documentation:";                                                                                  
      80              19 :         foreach ($this->offending_items as $type => $items) {                                                                                             
      81              19 :             natcasesort($items);                                                                                                                          
      82                 :                                                                                                                                                           
      83              19 :             $report .= "\n\n<b>{$type}:</b>\n - ";                                                                                                        
      84              19 :             $report .= implode("\n - ", $items);                                                                                                          
      85              19 :         }                                                                                                                                                 
      86                 :                                                                                                                                                           
      87              19 :         $document = new ParserDocument();                                                                                                                 
      88              19 :         $document->name = "Quality check report";                                                                                                         
      89              19 :         $document->description = htmlify_text($report);                                                                                                   
      90              19 :         $parser_model[] = $document;                                                                                                                      
      91                 :                                                                                                                                                           
      92              19 :         return $parser_model;                                                                                                                             
      93                 :     }                                                                                                                                                     
      94                 :                                                                                                                                                           
      95                 :                                                                                                                                                           
      96                 :     /**                                                                                                                                                   
      97                 :      * Checks that a file has high-enough quality documentation                                                                                           
      98                 :      **/                                                                                                                                                  
      99                 :     private function check_files($item)                                                                                                                   
     100                 :     {                                                                                                                                                     
     101              20 :         $tags = $item->getDocblockTags();                                                                                                                 
     102              20 :         $problems = array();                                                                                                                              
     103                 :                                                                                                                                                           
     104                 :         // classes and interfaces                                                                                                                         
     105              20 :         foreach ($item->classes as $sub) {                                                                                                                
     106              13 :             if ($sub instanceof ParserClass) {                                                                                                            
     107               8 :                 $this->check_class($sub);                                                                                                                 
     108                 :                                                                                                                                                           
     109              13 :             } else if ($sub instanceof ParserInterface) {                                                                                                 
     110               5 :                 $this->check_interface($sub);                                                                                                             
     111               5 :             }                                                                                                                                             
     112              20 :         }                                                                                                                                                 
     113                 :                                                                                                                                                           
     114                 :         // functions                                                                                                                                      
     115              20 :         foreach ($item->functions as $sub) {                                                                                                              
     116               6 :             $this->check_function($sub);                                                                                                                  
     117              20 :         }                                                                                                                                                 
     118                 :                                                                                                                                                           
     119                 :         // the files                                                                                                                                      
     120              20 :         foreach ($this->required_tags as $tag_name) {                                                                                                     
     121              20 :             if (!isset($tags[$tag_name]) or $tags[$tag_name] == '') {                                                                                     
     122              19 :                 if ($tag_name == '@summary') {                                                                                                            
     123              13 :                     $tag_name = 'summary';                                                                                                                
     124              13 :                 } else {                                                                                                                                  
     125               6 :                     $tag_name .= ' tag';                                                                                                                  
     126                 :                 }                                                                                                                                         
     127                 :                                                                                                                                                           
     128              19 :                 $problems[] = "No {$tag_name}";                                                                                                           
     129              19 :             }                                                                                                                                             
     130              20 :         }                                                                                                                                                 
     131                 :                                                                                                                                                           
     132              20 :         if (count($problems)) {                                                                                                                           
     133              19 :             $this->offending_items['Files'][] = '{@link ' . $item->name . '}: <i>' . implode(', ', $problems) . '</i>';                                   
     134              19 :         }                                                                                                                                                 
     135              20 :     }                                                                                                                                                     
     136                 :                                                                                                                                                           
     137                 :                                                                                                                                                           
     138                 :     /**                                                                                                                                                   
     139                 :      * Checks that a class has high-enough quality documentation                                                                                          
     140                 :      **/                                                                                                                                                  
     141                 :     private function check_class($item)                                                                                                                   
     142                 :     {                                                                                                                                                     
     143               8 :         $tags = $item->getDocblockTags();                                                                                                                 
     144               8 :         $problems = array();                                                                                                                              
     145                 :                                                                                                                                                           
     146               8 :         foreach ($this->required_tags as $tag_name) {                                                                                                     
     147               8 :             if (!isset($tags[$tag_name]) or $tags[$tag_name] == '') {                                                                                     
     148               4 :                 if ($tag_name == '@summary') {                                                                                                            
     149               3 :                     $tag_name = 'summary';                                                                                                                
     150               3 :                 } else {                                                                                                                                  
     151               1 :                     $tag_name .= ' tag';                                                                                                                  
     152                 :                 }                                                                                                                                         
     153                 :                                                                                                                                                           
     154               4 :                 $problems[] = "No {$tag_name}";                                                                                                           
     155               4 :             }                                                                                                                                             
     156               8 :         }                                                                                                                                                 
     157                 :                                                                                                                                                           
     158               8 :         if (count($problems)) {                                                                                                                           
     159               4 :             $this->offending_items['Classes'][] = '{@link ' . $item->name . '}: <i>' . implode(', ', $problems) . '</i>';                                 
     160               4 :         }                                                                                                                                                 
     161                 :                                                                                                                                                           
     162               8 :         foreach ($item->functions as $sub) {                                                                                                              
     163               4 :             $this->check_function($sub, ' from class {@link ' . $item->name . '}');                                                                       
     164               8 :         }                                                                                                                                                 
     165               8 :     }                                                                                                                                                     
     166                 :                                                                                                                                                           
     167                 :                                                                                                                                                           
     168                 :     /**                                                                                                                                                   
     169                 :      * Checks that an interface has high-enough quality documentation                                                                                     
     170                 :      **/                                                                                                                                                  
     171                 :     private function check_interface($item)                                                                                                               
     172                 :     {                                                                                                                                                     
     173               5 :         $tags = $item->getDocblockTags();                                                                                                                 
     174               5 :         $problems = array();                                                                                                                              
     175                 :                                                                                                                                                           
     176               5 :         foreach ($this->required_tags as $tag_name) {                                                                                                     
     177               5 :             if (!isset($tags[$tag_name]) or $tags[$tag_name] == '') {                                                                                     
     178               3 :                 if ($tag_name == '@summary') {                                                                                                            
     179               2 :                     $tag_name = 'summary';                                                                                                                
     180               2 :                 } else {                                                                                                                                  
     181               1 :                     $tag_name .= ' tag';                                                                                                                  
     182                 :                 }                                                                                                                                         
     183                 :                                                                                                                                                           
     184               3 :                 $problems[] = "No {$tag_name}";                                                                                                           
     185               3 :             }                                                                                                                                             
     186               5 :         }                                                                                                                                                 
     187                 :                                                                                                                                                           
     188               5 :         if (count($problems)) {                                                                                                                           
     189               3 :             $this->offending_items['Interfaces'][] = '{@link ' . $item->name . '}: <i>' . implode(', ', $problems) . '</i>';                              
     190               3 :         }                                                                                                                                                 
     191                 :                                                                                                                                                           
     192               5 :         foreach ($item->functions as $sub) {                                                                                                              
     193               1 :             $this->check_function($sub, ' from interface {@link ' . $item->name . '}');                                                                   
     194               5 :         }                                                                                                                                                 
     195               5 :     }                                                                                                                                                     
     196                 :                                                                                                                                                           
     197                 :                                                                                                                                                           
     198                 :     /**                                                                                                                                                   
     199                 :      * Checks that a function has high-enough quality documentation                                                                                       
     200                 :      **/                                                                                                                                                  
     201                 :     private function check_function($item, $from = null)                                                                                                  
     202                 :     {                                                                                                                                                     
     203              11 :         $tags = $item->getDocblockTags();                                                                                                                 
     204              11 :         $problems = array();                                                                                                                              
     205                 :                                                                                                                                                           
     206              11 :         foreach ($this->required_tags as $tag_name) {                                                                                                     
     207              11 :             if (!isset($tags[$tag_name]) or $tags[$tag_name] == '') {                                                                                     
     208               5 :                 if ($tag_name == '@summary') {                                                                                                            
     209               4 :                     $tag_name = 'summary';                                                                                                                
     210               4 :                 } else {                                                                                                                                  
     211               1 :                     $tag_name .= ' tag';                                                                                                                  
     212                 :                 }                                                                                                                                         
     213                 :                                                                                                                                                           
     214               5 :                 $problems[] = "No {$tag_name}";                                                                                                           
     215               5 :             }                                                                                                                                             
     216              11 :         }                                                                                                                                                 
     217                 :                                                                                                                                                           
     218              11 :         if (count($problems)) {                                                                                                                           
     219               5 :             $this->offending_items['Functions'][] = '{@link ' . $item->name . '}' . $from . ': <i>' . implode(', ', $problems) . '</i>';                  
     220               5 :         }                                                                                                                                                 
     221                 :                                                                                                                                                           
     222              11 :         foreach ($item->args as $arg) {                                                                                                                   
     223               2 :             if ($arg->description == '') {                                                                                                                
     224               1 :                 $this->offending_items['Function arguments'][] = '{@link ' . $item->name . '}' . $from . ': <i>No description for ' . $arg->name . '</i>';
     225               1 :             }                                                                                                                                             
     226              11 :         }                                                                                                                                                 
     227              11 :     }                                                                                                                                                     
     228                 :                                                                                                                                                           
     229                 :                                                                                                                                                           
     230                 : }                                                                                                                                                         
     231                 :                                                                                                                                                           
     232                 :                                                                                                                                                           
     233                 : ?>                                                                                                                                                        

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.