Current file: D:\data\micmap\cgi-bin\tools\pear\pear\File\Iterator\Factory.php
Legend: executed not executed dead code

  Coverage
  Classes Functions / Methods Lines
Total
0.00%0.00%
0.00% 0 / 1
0.00%0.00%
0.00% 0 / 2 CRAP
0.00%0.00%
0.00% 0 / 50
 
File_Iterator_Factory
0.00%0.00%
0.00% 0 / 1
0.00%0.00%
0.00% 0 / 2
0.00%0.00%
0.00% 0 / 50
 getFileIterator($paths, $suffixes = '', $prefixes = '', array $exclude = array()
0.00%0.00%
0.00% 0 / 1 110
0.00%0.00%
0.00% 0 / 36
 getFilesAsArray($paths, $suffixes = '', $prefixes = '', array $exclude = array()
0.00%0.00%
0.00% 0 / 1 30
0.00%0.00%
0.00% 0 / 14


       1                 : <?php                                                                                                       
       2                 : /**                                                                                                         
       3                 :  * php-file-iterator                                                                                        
       4                 :  *                                                                                                          
       5                 :  * Copyright (c) 2009-2010, Sebastian Bergmann <sb@sebastian-bergmann.de>.                                  
       6                 :  * All rights reserved.                                                                                     
       7                 :  *                                                                                                          
       8                 :  * Redistribution and use in source and binary forms, with or without                                       
       9                 :  * modification, are permitted provided that the following conditions                                       
      10                 :  * are met:                                                                                                 
      11                 :  *                                                                                                          
      12                 :  *   * Redistributions of source code must retain the above copyright                                       
      13                 :  *     notice, this list of conditions and the following disclaimer.                                        
      14                 :  *                                                                                                          
      15                 :  *   * Redistributions in binary form must reproduce the above copyright                                    
      16                 :  *     notice, this list of conditions and the following disclaimer in                                      
      17                 :  *     the documentation and/or other materials provided with the                                           
      18                 :  *     distribution.                                                                                        
      19                 :  *                                                                                                          
      20                 :  *   * Neither the name of Sebastian Bergmann nor the names of his                                          
      21                 :  *     contributors may be used to endorse or promote products derived                                      
      22                 :  *     from this software without specific prior written permission.                                        
      23                 :  *                                                                                                          
      24                 :  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS                                      
      25                 :  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT                                        
      26                 :  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS                                        
      27                 :  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE                                           
      28                 :  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,                                      
      29                 :  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,                                     
      30                 :  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;                                         
      31                 :  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER                                         
      32                 :  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT                                       
      33                 :  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN                                        
      34                 :  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE                                          
      35                 :  * POSSIBILITY OF SUCH DAMAGE.                                                                              
      36                 :  *                                                                                                          
      37                 :  * @package   File                                                                                          
      38                 :  * @author    Sebastian Bergmann <sb@sebastian-bergmann.de>                                                 
      39                 :  * @copyright 2009-2010 Sebastian Bergmann <sb@sebastian-bergmann.de>                                       
      40                 :  * @license   http://www.opensource.org/licenses/bsd-license.php  BSD License                               
      41                 :  * @since     File available since Release 1.1.0                                                            
      42                 :  */                                                                                                         
      43                 :                                                                                                             
      44                 : require_once 'File/Iterator.php';                                                                           
      45                 :                                                                                                             
      46                 : /**                                                                                                         
      47                 :  * Factory Method implementation that creates a File_Iterator that operates on                              
      48                 :  * an AppendIterator that contains an RecursiveDirectoryIterator for each given                             
      49                 :  * path.                                                                                                    
      50                 :  *                                                                                                          
      51                 :  * @author    Sebastian Bergmann <sb@sebastian-bergmann.de>                                                 
      52                 :  * @copyright 2009-2010 Sebastian Bergmann <sb@sebastian-bergmann.de>                                       
      53                 :  * @license   http://www.opensource.org/licenses/bsd-license.php  BSD License                               
      54                 :  * @version   Release: 1.2.3                                                                                
      55                 :  * @link      http://github.com/sebastianbergmann/php-file-iterator/tree                                    
      56                 :  * @since     Class available since Release 1.1.0                                                           
      57                 :  */                                                                                                         
      58                 : class File_Iterator_Factory                                                                                 
      59                 : {                                                                                                           
      60                 :     /**                                                                                                     
      61                 :      * @param  array|string $paths                                                                          
      62                 :      * @param  array|string $suffixes                                                                       
      63                 :      * @param  array|string $prefixes                                                                       
      64                 :      * @param  array        $exclude                                                                        
      65                 :      * @return AppendIterator                                                                               
      66                 :      */                                                                                                     
      67                 :     public static function getFileIterator($paths, $suffixes = '', $prefixes = '', array $exclude = array())
      68                 :     {                                                                                                       
      69               0 :         if (is_string($paths)) {                                                                            
      70               0 :             $paths = array($paths);                                                                         
      71                 :         }                                                                                                   
      72                 :                                                                                                             
      73               0 :         $_paths = array();                                                                                  
      74                 :                                                                                                             
      75               0 :         foreach ($paths as $path) {                                                                         
      76               0 :             if ($locals = glob($path, GLOB_ONLYDIR)) {                                                      
      77               0 :                 $_paths = array_merge($_paths, $locals);                                                    
      78               0 :             } else {                                                                                        
      79               0 :                 $_paths[] = $path;                                                                          
      80                 :             }                                                                                               
      81               0 :         }                                                                                                   
      82                 :                                                                                                             
      83               0 :         $paths = $_paths;                                                                                   
      84               0 :         unset($_paths);                                                                                     
      85                 :                                                                                                             
      86               0 :         if (is_string($prefixes)) {                                                                         
      87               0 :             if ($prefixes != '') {                                                                          
      88               0 :                 $prefixes = array($prefixes);                                                               
      89               0 :             } else {                                                                                        
      90               0 :                 $prefixes = array();                                                                        
      91                 :             }                                                                                               
      92                 :         }                                                                                                   
      93                 :                                                                                                             
      94               0 :         if (is_string($suffixes)) {                                                                         
      95               0 :             if ($suffixes != '') {                                                                          
      96               0 :                 $suffixes = array($suffixes);                                                               
      97               0 :             } else {                                                                                        
      98               0 :                 $suffixes = array();                                                                        
      99                 :             }                                                                                               
     100                 :         }                                                                                                   
     101                 :                                                                                                             
     102               0 :         $iterator = new AppendIterator;                                                                     
     103                 :                                                                                                             
     104               0 :         foreach ($paths as $path) {                                                                         
     105               0 :             if (is_dir($path)) {                                                                            
     106               0 :                 $iterator->append(                                                                          
     107               0 :                   new File_Iterator(                                                                        
     108               0 :                     new RecursiveIteratorIterator(                                                          
     109               0 :                       new RecursiveDirectoryIterator($path)                                                 
     110               0 :                     ),                                                                                      
     111               0 :                     $suffixes,                                                                              
     112               0 :                     $prefixes,                                                                              
     113               0 :                     $exclude,                                                                               
     114                 :                     $path                                                                                   
     115               0 :                   )                                                                                         
     116               0 :                 );                                                                                          
     117                 :             }                                                                                               
     118               0 :         }                                                                                                   
     119                 :                                                                                                             
     120               0 :         return $iterator;                                                                                   
     121                 :     }                                                                                                       
     122                 :                                                                                                             
     123                 :     /**                                                                                                     
     124                 :      * @param  array|string $paths                                                                          
     125                 :      * @param  array|string $suffixes                                                                       
     126                 :      * @param  array|string $prefixes                                                                       
     127                 :      * @param  array        $exclude                                                                        
     128                 :      * @return array                                                                                        
     129                 :      */                                                                                                     
     130                 :     public static function getFilesAsArray($paths, $suffixes = '', $prefixes = '', array $exclude = array())
     131                 :     {                                                                                                       
     132               0 :         if (is_string($paths)) {                                                                            
     133               0 :             $paths = array($paths);                                                                         
     134                 :         }                                                                                                   
     135                 :                                                                                                             
     136               0 :         $result = array();                                                                                  
     137                 :                                                                                                             
     138               0 :         $iterator = self::getFileIterator(                                                                  
     139               0 :           $paths, $suffixes, $prefixes, $exclude                                                            
     140               0 :         );                                                                                                  
     141                 :                                                                                                             
     142               0 :         foreach ($iterator as $file) {                                                                      
     143               0 :             $result[] = $file->getRealPath();                                                               
     144               0 :         }                                                                                                   
     145                 :                                                                                                             
     146               0 :         foreach ($paths as $path) {                                                                         
     147               0 :             if (is_file($path)) {                                                                           
     148               0 :                 $result[] = realpath($path);                                                                
     149                 :             }                                                                                               
     150               0 :         }                                                                                                   
     151                 :                                                                                                             
     152               0 :         return $result;                                                                                     
     153                 :     }                                                                                                       
     154                 : }                                                                                                           
     155                 : ?>                                                                                                          

Generated by PHP_CodeCoverage 1.0.0 using PHP 5.3.3 and PHPUnit 3.5.0 at Wed Jan 4 16:32:24 UTC 2012.