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

  Coverage
  Classes Functions / Methods Lines
Total
0.00% 0 / 1
80.00% 8 / 10 CRAP
97.22% 70 / 72
XmlOutputter
0.00% 0 / 1
80.00% 8 / 10 25
97.22% 70 / 72
 get_ext()
0.00% 0 / 1 2
0.00% 0 / 1
 get_mimetype()
0.00% 0 / 1 2
0.00% 0 / 1
 output($parser_items, Config $config)
100.00% 1 / 1 4
100.00% 13 / 13
 process_file($item)
100.00% 1 / 1 3
100.00% 11 / 11
 process_function($parent_node, $item)
100.00% 1 / 1 6
100.00% 15 / 15
 process_argument($parent_node, $item)
100.00% 1 / 1 1
100.00% 8 / 8
 process_return($parent_node, $item)
100.00% 1 / 1 1
100.00% 7 / 7
 process_class($parent_node, $item)
100.00% 1 / 1 6
100.00% 10 / 10
 process_document($item)
100.00% 1 / 1 1
100.00% 1 / 1
 create_description_node($node, $description)
100.00% 1 / 1 1
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                 :  * This file contains the {@link MetadataOutputter} class                                           
      24                 :  *                                                                                                  
      25                 :  * @package Outputters                                                                              
      26                 :  * @author Josh                                                                                     
      27                 :  * @since 0.3                                                                                       
      28                 :  **/                                                                                                
      29                 :                                                                                                     
      30                 : /**                                                                                                 
      31                 :  * Outputs the tree to an xml file                                                                  
      32                 :  *                                                                                                  
      33                 :  * @author Josh, 2009-08-03                                                                         
      34                 :  **/                                                                                                
      35                 : class XmlOutputter extends MetadataOutputter {                                                      
      36                 :     private $dom;                                                                                   
      37                 :     private $root;                                                                                  
      38                 :                                                                                                     
      39                 :                                                                                                     
      40                 :     /**                                                                                             
      41                 :      * Returns the file extension of the outputted file (e.g. 'xml')                                
      42                 :      **/                                                                                            
      43                 :     public function get_ext()                                                                       
      44                 :     {                                                                                               
      45               0 :         return 'xml';                                                                               
      46                 :     }                                                                                               
      47                 :                                                                                                     
      48                 :                                                                                                     
      49                 :     /**                                                                                             
      50                 :      * Returns the mimetype of the outputted file (e.g. 'text/xml')                                 
      51                 :      **/                                                                                            
      52                 :     public function get_mimetype()                                                                  
      53                 :     {                                                                                               
      54               0 :         return 'text/xml';                                                                          
      55                 :     }                                                                                               
      56                 :                                                                                                     
      57                 :                                                                                                     
      58                 :     /**                                                                                             
      59                 :      * Does the actual outputting of the file objects (and their sub-objects)                       
      60                 :      *                                                                                              
      61                 :      * @param array $parser_items The ParserItem(s) to save                                         
      62                 :      * @return boolean True on success, false on failure                                            
      63                 :      **/                                                                                            
      64                 :     public function output($parser_items, Config $config)                                           
      65                 :     {                                                                                               
      66               1 :         $this->dom = new DOMDocument('1.0', 'UTF-8');                                               
      67               1 :         $this->dom->formatOutput = true;                                                            
      68                 :                                                                                                     
      69               1 :         $this->root = $this->dom->createElement('documentation');                                   
      70               1 :         $this->dom->appendChild($this->root);                                                       
      71                 :                                                                                                     
      72               1 :         foreach ($parser_items as $item) {                                                          
      73               1 :             if ($item instanceof ParserFile) {                                                      
      74               1 :                 $this->process_file($item);                                                         
      75                 :                                                                                                     
      76               1 :             } else if ($item instanceof ParserDocument) {                                           
      77               1 :                 $this->process_document($item);                                                     
      78                 :                                                                                                     
      79               1 :             }                                                                                       
      80               1 :         }                                                                                           
      81                 :                                                                                                     
      82               1 :         $this->dom->save($this->filename);                                                          
      83                 :                                                                                                     
      84               1 :         return true;                                                                                
      85                 :     }                                                                                               
      86                 :                                                                                                     
      87                 :                                                                                                     
      88                 :     /**                                                                                             
      89                 :      * Processes a file                                                                             
      90                 :      **/                                                                                            
      91                 :     private function process_file($item)                                                            
      92                 :     {                                                                                               
      93               1 :         $node = $this->dom->createElement('file');                                                  
      94               1 :         $this->root->appendChild($node);                                                            
      95                 :                                                                                                     
      96               1 :         $node->setAttribute('name', $item->name);                                                   
      97                 :                                                                                                     
      98               1 :         $this->create_description_node($node, $item->description);                                  
      99                 :                                                                                                     
     100                 :         // sub-items                                                                                
     101               1 :         foreach ($item->functions as $child) {                                                      
     102               1 :             $this->process_function ($node, $child);                                                
     103               1 :         }                                                                                           
     104                 :                                                                                                     
     105               1 :         foreach ($item->classes as $child) {                                                        
     106               1 :             $this->process_class ($node, $child);                                                   
     107               1 :         }                                                                                           
     108               1 :     }                                                                                               
     109                 :                                                                                                     
     110                 :                                                                                                     
     111                 :     /**                                                                                             
     112                 :      * Processes a function                                                                         
     113                 :      **/                                                                                            
     114                 :     private function process_function($parent_node, $item)                                          
     115                 :     {                                                                                               
     116               1 :         $node = $this->dom->createElement('function');                                              
     117               1 :         $parent_node->appendChild($node);                                                           
     118                 :                                                                                                     
     119               1 :         $node->setAttribute('name', $item->name);                                                   
     120               1 :         $node->setAttribute('visibility', $item->visibility);                                       
     121               1 :         if ($item->abstract) $node->setAttribute('abstract', 'abstract');                           
     122               1 :         if ($item->static) $node->setAttribute('static', 'static');                                 
     123               1 :         if ($item->final) $node->setAttribute('final', 'final');                                    
     124                 :                                                                                                     
     125               1 :         $this->create_description_node($node, $item->description);                                  
     126                 :                                                                                                     
     127               1 :         foreach ($item->args as $child) {                                                           
     128               1 :             $this->process_argument($node, $child);                                                 
     129               1 :         }                                                                                           
     130                 :                                                                                                     
     131               1 :         foreach ($item->returns as $child) {                                                        
     132               1 :             $this->process_return($node, $child);                                                   
     133               1 :         }                                                                                           
     134               1 :     }                                                                                               
     135                 :                                                                                                     
     136                 :                                                                                                     
     137                 :     /**                                                                                             
     138                 :      * Processes a function argument                                                                
     139                 :      **/                                                                                            
     140                 :     private function process_argument($parent_node, $item)                                          
     141                 :     {                                                                                               
     142               1 :         $node = $this->dom->createElement('argument');                                              
     143               1 :         $parent_node->appendChild($node);                                                           
     144                 :                                                                                                     
     145               1 :         $node->setAttribute('name', $item->name);                                                   
     146               1 :         $node->setAttribute('type', $item->type);                                                   
     147               1 :         $node->appendChild($this->dom->createTextNode(                                              
     148               1 :             trim(strip_tags($item->description))                                                    
     149               1 :         ));                                                                                         
     150               1 :     }                                                                                               
     151                 :                                                                                                     
     152                 :                                                                                                     
     153                 :     /**                                                                                             
     154                 :      * Processes a function argument                                                                
     155                 :      **/                                                                                            
     156                 :     private function process_return($parent_node, $item)                                            
     157                 :     {                                                                                               
     158               1 :         $node = $this->dom->createElement('return');                                                
     159               1 :         $parent_node->appendChild($node);                                                           
     160                 :                                                                                                     
     161               1 :         $node->setAttribute('type', $item->type);                                                   
     162               1 :         $node->appendChild($this->dom->createTextNode(                                              
     163               1 :             trim(strip_tags($item->description))                                                    
     164               1 :         ));                                                                                         
     165               1 :     }                                                                                               
     166                 :                                                                                                     
     167                 :                                                                                                     
     168                 :     /**                                                                                             
     169                 :      * Processes a class                                                                            
     170                 :      **/                                                                                            
     171                 :     private function process_class($parent_node, $item)                                             
     172                 :     {                                                                                               
     173               1 :         $node = $this->dom->createElement('class');                                                 
     174               1 :         $parent_node->appendChild($node);                                                           
     175                 :                                                                                                     
     176               1 :         $node->setAttribute('name', $item->name);                                                   
     177               1 :         if (isset($item->abstract) and $item->abstract) $node->setAttribute('abstract', 'abstract');
     178               1 :         if (isset($item->final) and $item->final) $node->setAttribute('final', 'final');            
     179                 :                                                                                                     
     180               1 :         $this->create_description_node($node, $item->description);                                  
     181                 :                                                                                                     
     182                 :         // sub-items                                                                                
     183               1 :         foreach ($item->functions as $child) {                                                      
     184               1 :             $this->process_function ($node, $child);                                                
     185               1 :         }                                                                                           
     186               1 :     }                                                                                               
     187                 :                                                                                                     
     188                 :                                                                                                     
     189                 :     /**                                                                                             
     190                 :      * Processes a document                                                                         
     191                 :      **/                                                                                            
     192                 :     private function process_document($item)                                                        
     193                 :     {                                                                                               
     194                 :                                                                                                     
     195               1 :     }                                                                                               
     196                 :                                                                                                     
     197                 :                                                                                                     
     198                 :     /**                                                                                             
     199                 :      * Creates a description node, and appends it to the specified node                             
     200                 :      **/                                                                                            
     201                 :     private function create_description_node($node, $description)                                   
     202                 :     {                                                                                               
     203               1 :         $description = trim(strip_tags($description));                                              
     204                 :                                                                                                     
     205               1 :         $desc = $this->dom->createElement('description');                                           
     206               1 :         $desc->appendChild ($this->dom->createTextNode ($description));                             
     207                 :                                                                                                     
     208               1 :         $node->appendChild ($desc);                                                                 
     209               1 :     }                                                                                               
     210                 :                                                                                                     
     211                 : }                                                                                                   

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.