: <?php                                                                                                     
                 : /*                                                                                                        
                 : Copyright 2008 Josh Heidenreich                                                                           
                 :                                                                                                           
                 : This file is part of Pelzini.                                                                             
                 :                                                                                                           
                 : Pelzini is free software: you can redistribute it and/or modify                                           
                 : it under the terms of the GNU General Public License as published by                                      
                 : the Free Software Foundation, either version 3 of the License, or                                         
                 : (at your option) any later version.                                                                       
                 :                                                                                                           
                 : Pelzini is distributed in the hope that it will be useful,                                                
                 : but WITHOUT ANY WARRANTY; without even the implied warranty of                                            
                 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                             
                 : GNU General Public License for more details.                                                              
                 :                                                                                                           
                 : You should have received a copy of the GNU General Public License                                         
                 : along with Pelzini.  If not, see <http://www.gnu.org/licenses/>.                                          
                 : */                                                                                                        
                 :                                                                                                           
                 :                                                                                                           
                 : /**                                                                                                       
                 :  * Contains the {@link VirtualEnumerationsTransformer} class                                              
                 :  *                                                                                                        
                 :  * @package Transformers                                                                                  
                 :  * @author Josh                                                                                           
                 :  * @since 0.3                                                                                             
                 :  **/                                                                                                      
                 :                                                                                                           
                 : /**                                                                                                       
                 :  * This transformer converts constants that start with the same name into an enumeration of that name.    
                 :  *                                                                                                        
                 :  * So if a file has the following constants:                                                              
                 :  *   APP_VERSION                                                                                          
                 :  *   ITEM_TYPE_APPLE                                                                                      
                 :  *   ITEM_TYPE_ORANGE                                                                                     
                 :  *                                                                                                        
                 :  * The APPLE and ORANGE constants will become a part of the virtual enumeration ITEM_TYPE.                
                 :  **/                                                                                                      
                 : class VirtualEnumerationsTransformer extends Transformer {                                                
                 :     public function __construct()                                                                         
                 :     {                                                                                                     
                 :                                                                                                           
               0 :     }                                                                                                     
                 :                                                                                                           
                 :                                                                                                           
                 :     /**                                                                                                   
                 :      * Transforms the data model before outputting.                                                       
                 :      *                                                                                                    
                 :      * This transformer converts constants that start with the same name into an enumeration of that name.
                 :      *                                                                                                    
                 :      * @param array $parser_model The data model to transform                                             
                 :      * @return array The new data model, or null if there was an error                                    
                 :      **/                                                                                                  
                 :     public function transform(&$parser_model)                                                             
                 :     {                                                                                                     
               0 :         foreach ($parser_model as $item) {                                                                
               0 :             if ($item instanceof ParserFile) {                                                            
               0 :                 $this->processConstants ($item);                                                          
               0 :             }                                                                                             
               0 :         }                                                                                                 
                 :                                                                                                           
               0 :         return $parser_model;                                                                             
                 :     }                                                                                                     
                 :                                                                                                           
                 :                                                                                                           
                 :     /**                                                                                                   
                 :      * Processes constants for a specified file                                                           
                 :      **/                                                                                                  
                 :     private function processConstants(ParserFile $file)                                                   
                 :     {                                                                                                     
               0 :         usort($file->constants, 'constant_name_sorter');                                                  
                 :                                                                                                           
               0 :         reset($file->constants);                                                                          
               0 :         list ($last_const_id, $last_const) = each($file->constants);                                      
                 :                                                                                                           
               0 :         $enum = null;                                                                                     
               0 :         while (list ($constant_id, $constant) = each($file->constants)) {                                 
               0 :             if ($enum) {                                                                                  
                 :                 // If the constant starts with the same stuff as the current enum, add it                 
               0 :                 if (strncmp($enum->name, $constant->name, strlen($enum->name)) == 0) {                    
               0 :                     $enum->constants[] = $constant;                                                       
               0 :                     unset ($file->constants[$constant_id]);                                               
                 :                                                                                                           
               0 :                 } else {                                                                                  
                 :                     // It doesn't match, so do a check that the constand begins with mostly               
                 :                     // the same stuff - it can have the last two chars wrong.                             
                 :                     // If it is close, the enum is shrunk to what matches                                 
               0 :                     $num = $this->numSimilarChars($enum->name, $constant->name);                          
               0 :                     if ($num >= 3 and $num >= (strlen($enum->name) - 2)) {                                
               0 :                         if ($constant->name[$num - 1] == '_') $num--;                                     
               0 :                         $enum->name = substr($constant->name, 0, $num);                                   
               0 :                         $enum->constants[] = $constant;                                                   
               0 :                         unset ($file->constants[$constant_id]);                                           
                 :                                                                                                           
                 :                         // Of course if there is no match, we cannot force a match.                       
               0 :                     } else {                                                                              
               0 :                         $enum = null;                                                                     
                 :                     }                                                                                     
                 :                 }                                                                                         
                 :                                                                                                           
               0 :             } else {                                                                                      
                 :                 // There is no current enum, so check if one can be created by looking at the             
                 :                 // last constant and the current constant                                                 
               0 :                 $num = $this->numSimilarChars($last_const->name, $constant->name);                        
               0 :                 if ($num >= 3) {                                                                          
               0 :                     if ($constant->name[$num - 1] == '_') $num--;                                         
               0 :                     $enum = $this->createVirtualEnum (substr($constant->name, 0, $num));                  
               0 :                     $file->enumerations[] = $enum;                                                        
               0 :                     $enum->constants[] = $last_const;                                                     
               0 :                     $enum->constants[] = $constant;                                                       
               0 :                     unset ($file->constants[$last_const_id]);                                             
               0 :                     unset ($file->constants[$constant_id]);                                               
               0 :                 }                                                                                         
                 :             }                                                                                             
                 :                                                                                                           
               0 :             $last_const = $constant;                                                                      
               0 :             $last_const_id = $constant_id;                                                                
               0 :         }                                                                                                 
               0 :     }                                                                                                     
                 :                                                                                                           
                 :                                                                                                           
                 :     /**                                                                                                   
                 :      * Creates an enum                                                                                    
                 :      **/                                                                                                  
                 :     private function createVirtualEnum($name)                                                             
                 :     {                                                                                                     
               0 :         $enum = new ParserEnumeration();                                                                  
               0 :         $enum->name = $name;                                                                              
               0 :         $enum->virtual = 1;                                                                               
               0 :         return $enum;                                                                                     
                 :     }                                                                                                     
                 :                                                                                                           
                 :                                                                                                           
                 :     /**                                                                                                   
                 :      * Returns the number of chars in $a that are the same as the chars in $b                             
                 :      **/                                                                                                  
                 :     private function numSimilarChars($a, $b)                                                              
                 :     {                                                                                                     
               0 :         $i = 0;                                                                                           
                 :                                                                                                           
               0 :         while ($a[$i] == $b[$i]) $i++;                                                                    
                 :                                                                                                           
               0 :         return $i;                                                                                        
                 :     }                                                                                                     
                 :                                                                                                           
                 :                                                                                                           
                 : }                                                                                                         
                 :                                                                                                           
                 :                                                                                                           
               0 : function constant_name_sorter($a, $b)                                                                     
                 : {                                                                                                         
               0 :     return strcasecmp($a->name, $b->name);                                                                
                 : }                                                                                                         
                 :                                                                                                           
                 :                                                                                                           
                 : ?>