1. sfFinder.class.php
  2. /**
 *
 * Allow to build rules to find files and directories.
 *
 * All rules may be invoked several times, except for ->in() method.
 * Some rules are cumulative (->name() for example) whereas others are destructive
 * (most recent value is used, ->maxdepth() method for example).
 *
 * All methods return the current sfFinder object to allow easy chaining:
 *
 * $files = sfFinder::type('file')->name('*.php')->in(.);
 *
 * Interface loosely based on perl File::Find::Rule module.
 *
 * @package    symfony
 * @subpackage util
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfFinder.class.php 23744 2009-11-10 00:52:39Z FabianLange $
 */
  3. class sfFinder
  4. {
  5.   protected $type                   = 'file';
  6.   protected $names                  = array();
  7.   protected $prunes                 = array();
  8.   protected $discards               = array();
  9.   protected $execs                  = array();
  10.   protected $mindepth               = 0;
  11.   protected $sizes                  = array();
  12.   protected $maxdepth               = 1000000;
  13.   protected $relative               = false;
  14.   protected $follow_link            = false;
  15.   protected $sort                   = false;
  16.   protected $ignore_version_control = true;
  18.   /**
  19.    * Sets maximum directory depth.
  20.    *
  21.    * Finder will descend at most $level levels of directories below the starting point.
  22.    *
  23.    * @param  int $level
  24.    * @return object current sfFinder object
  25.    */
  26.   public function maxdepth($level)
  27.   {
  28.     $this->maxdepth = $level;
  30.     return $this;
  31.   }
  33.   /**
  34.    * Sets minimum directory depth.
  35.    *
  36.    * Finder will start applying tests at level $level.
  37.    *
  38.    * @param  int $level
  39.    * @return object current sfFinder object
  40.    */
  41.   public function mindepth($level)
  42.   {
  43.     $this->mindepth = $level;
  45.     return $this;
  46.   }
  48.   public function get_type()
  49.   {
  50.     return $this->type;
  51.   }
  53.   /**
  54.    * Sets the type of elements to returns.
  55.    *
  56.    * @param  string $name  directory or file or any (for both file and directory)
  57.    * @return object new sfFinder object
  58.    */
  59.   public static function type($name)
  60.   {
  61.     $finder = new self();
  62.     return $finder->setType($name);
  63.   }
  64.   /**
  65.    * Sets the type of elements to returns.
  66.    *
  67.    * @param  string $name  directory or file or any (for both file and directory)
  68.    * @return sfFinder Current object
  69.    */
  70.   public function setType($name)
  71.   {
  72.     $name = strtolower($name);
  74.     if (substr($name, 0, 3) === 'dir')
  75.     {
  76.       $this->type = 'directory';
  78.       return $this;
  79.     }
  80.     if ($name === 'any')
  81.     {
  82.       $this->type = 'any';
  84.       return $this;
  85.     }
  87.       $this->type = 'file';
  89.     return $this;
  90.   }
  92.   /*
  93.    * glob, patterns (must be //) or strings
  94.    */
  95.   protected function to_regex($str)
  96.   {
  97.     if (preg_match('/^(!)?([^a-zA-Z0-9\\\\]).+?\\2[ims]?$/', $str))
  98.     {
  99.       return $str;
  100.     }
  102.     return sfGlobToRegex::glob_to_regex($str);
  103.   }
  105.   protected function args_to_array($arg_list, $not = false)
  106.   {
  107.     $list = array();
  108.     $nbArgList = count($arg_list);
  109.     for ($i = 0; $i < $nbArgList; $i++)
  110.     {
  111.       if (is_array($arg_list[$i]))
  112.       {
  113.         foreach ($arg_list[$i] as $arg)
  114.         {
  115.           $list[] = array($not, $this->to_regex($arg));
  116.         }
  117.       }
  118.       else
  119.       {
  120.         $list[] = array($not, $this->to_regex($arg_list[$i]));
  121.       }
  122.     }
  124.     return $list;
  125.   }
  127.   /**
  128.    * Adds rules that files must match.
  129.    *
  130.    * You can use patterns (delimited with / sign), globs or simple strings.
  131.    *
  132.    * $finder->name('*.php')
  133.    * $finder->name('/\.php$/') // same as above
  134.    * $finder->name('test.php')
  135.    *
  136.    * @param  list   a list of patterns, globs or strings
  137.    * @return sfFinder Current object
  138.    */
  139.   public function name()
  140.   {
  141.     $args = func_get_args();
  142.     $this->names = array_merge($this->names, $this->args_to_array($args));
  144.     return $this;
  145.   }
  147.   /**
  148.    * Adds rules that files must not match.
  149.    *
  150.    * @see    ->name()
  151.    * @param  list   a list of patterns, globs or strings
  152.    * @return sfFinder Current object
  153.    */
  154.   public function not_name()
  155.   {
  156.     $args = func_get_args();
  157.     $this->names = array_merge($this->names, $this->args_to_array($args, true));
  159.     return $this;
  160.   }
  162.   /**
  163.    * Adds tests for file sizes.
  164.    *
  165.    * $finder->size('> 10K');
  166.    * $finder->size('<= 1Ki');
  167.    * $finder->size(4);
  168.    *
  169.    * @param  list   a list of comparison strings
  170.    * @return sfFinder Current object
  171.    */
  172.   public function size()
  173.   {
  174.     $args = func_get_args();
  175.     $numargs = count($args);
  176.     for ($i = 0; $i < $numargs; $i++)
  177.     {
  178.       $this->sizes[] = new sfNumberCompare($args[$i]);
  179.     }
  181.     return $this;
  182.   }
  184.   /**
  185.    * Traverses no further.
  186.    *
  187.    * @param  list   a list of patterns, globs to match
  188.    * @return sfFinder Current object
  189.    */
  190.   public function prune()
  191.   {
  192.     $args = func_get_args();
  193.     $this->prunes = array_merge($this->prunes, $this->args_to_array($args));
  195.     return $this;
  196.   }
  198.   /**
  199.    * Discards elements that matches.
  200.    *
  201.    * @param  list   a list of patterns, globs to match
  202.    * @return sfFinder Current object
  203.    */
  204.   public function discard()
  205.   {
  206.     $args = func_get_args();
  207.     $this->discards = array_merge($this->discards, $this->args_to_array($args));
  209.     return $this;
  210.   }
  212.   /**
  213.    * Ignores version control directories.
  214.    *
  215.    * Currently supports Subversion, CVS, DARCS, Gnu Arch, Monotone, Bazaar-NG, GIT, Mercurial
  216.    *
  217.    * @param  bool   $ignore  falase when version control directories shall be included (default is true)
  218.    *
  219.    * @return sfFinder Current object
  220.    */
  221.   public function ignore_version_control($ignore = true)
  222.   {
  223.     $this->ignore_version_control = $ignore;
  225.     return $this;
  226.   }
  228.   /**
  229.    * Returns files and directories ordered by name
  230.    *
  231.    * @return sfFinder Current object
  232.    */
  233.   public function sort_by_name()
  234.   {
  235.     $this->sort = 'name';
  237.     return $this;
  238.   }
  240.   /**
  241.    * Returns files and directories ordered by type (directories before files), then by name
  242.    *
  243.    * @return sfFinder Current object
  244.    */
  245.   public function sort_by_type()
  246.   {
  247.     $this->sort = 'type';
  249.     return $this;
  250.   }
  252.   /**
  253.    * Executes function or method for each element.
  254.    *
  255.    * Element match if functino or method returns true.
  256.    *
  257.    * $finder->exec('myfunction');
  258.    * $finder->exec(array($object, 'mymethod'));
  259.    *
  260.    * @param  mixed  function or method to call
  261.    * @return sfFinder Current object
  262.    */
  263.   public function exec()
  264.   {
  265.     $args = func_get_args();
  266.     $numargs = count($args);
  267.     for ($i = 0; $i < $numargs; $i++)
  268.     {
  269.       if (is_array($args[$i]) && !method_exists($args[$i][0], $args[$i][1]))
  270.       {
  271.         throw new sfException(sprintf('method "%s" does not exist for object "%s".', $args[$i][1], $args[$i][0]));
  272.       }
  273.       if (!is_array($args[$i]) && !function_exists($args[$i]))
  274.       {
  275.         throw new sfException(sprintf('function "%s" does not exist.', $args[$i]));
  276.       }
  278.       $this->execs[] = $args[$i];
  279.     }
  281.     return $this;
  282.   }
  284.   /**
  285.    * Returns relative paths for all files and directories.
  286.    *
  287.    * @return sfFinder Current object
  288.    */
  289.   public function relative()
  290.   {
  291.     $this->relative = true;
  293.     return $this;
  294.   }
  296.   /**
  297.    * Symlink following.
  298.    *
  299.    * @return sfFinder Current object
  300.    */
  301.   public function follow_link()
  302.   {
  303.     $this->follow_link = true;
  305.     return $this;
  306.   }
  308.   /**
  309.    * Searches files and directories which match defined rules.
  310.    *
  311.    * @return array list of files and directories
  312.    */
  313.   public function in()
  314.   {
  315.     $files    = array();
  316.     $here_dir = getcwd();
  318.     $finder = clone $this;
  320.     if ($this->ignore_version_control)
  321.     {
  322.       $ignores = array('.svn', '_svn', 'CVS', '_darcs', '.arch-params', '.monotone', '.bzr', '.git', '.hg');
  324.       $finder->discard($ignores)->prune($ignores);
  325.     }
  327.     // first argument is an array?
  328.     $numargs  = func_num_args();
  329.     $arg_list = func_get_args();
  330.     if ($numargs === 1 && is_array($arg_list[0]))
  331.     {
  332.       $arg_list = $arg_list[0];
  333.       $numargs  = count($arg_list);
  334.     }
  336.     for ($i = 0; $i < $numargs; $i++)
  337.     {
  338.       $dir = realpath($arg_list[$i]);
  340.       if (!is_dir($dir))
  341.       {
  342.         continue;
  343.       }
  345.       $dir = str_replace('\\', '/', $dir);
  347.       // absolute path?
  348.       if (!self::isPathAbsolute($dir))
  349.       {
  350.         $dir = $here_dir.'/'.$dir;
  351.       }
  353.       $new_files = str_replace('\\', '/', $finder->search_in($dir));
  355.       if ($this->relative)
  356.       {
  357.         $new_files = str_replace(rtrim($dir, '/').'/', '', $new_files);
  358.       }
  360.       $files = array_merge($files, $new_files);
  361.     }
  363.     if ($this->sort === 'name')
  364.     {
  365.       sort($files);
  366.     }
  368.     return array_unique($files);
  369.   }
  371.   protected function search_in($dir, $depth = 0)
  372.   {
  373.     if ($depth > $this->maxdepth)
  374.     {
  375.       return array();
  376.     }
  378.     $dir = realpath($dir);
  380.     if ((!$this->follow_link) && is_link($dir))
  381.     {
  382.       return array();
  383.     }
  385.     $files = array();
  386.     $temp_files = array();
  387.     $temp_folders = array();
  388.     if (is_dir($dir))
  389.     {
  390.       $current_dir = opendir($dir);
  391.       while (false !== $entryname = readdir($current_dir))
  392.       {
  393.         if ($entryname == '.' || $entryname == '..') continue;
  395.         $current_entry = $dir.DIRECTORY_SEPARATOR.$entryname;
  396.         if ((!$this->follow_link) && is_link($current_entry))
  397.         {
  398.           continue;
  399.         }
  401.         if (is_dir($current_entry))
  402.         {
  403.           if ($this->sort === 'type')
  404.           {
  405.             $temp_folders[$entryname] = $current_entry;
  406.           }
  407.           else
  408.           {
  409.             if (($this->type === 'directory' || $this->type === 'any') && ($depth >= $this->mindepth) && !$this->is_discarded($dir, $entryname) && $this->match_names($dir, $entryname) && $this->exec_ok($dir, $entryname))
  410.             {
  411.               $files[] = $current_entry;
  412.             }
  414.             if (!$this->is_pruned($dir, $entryname))
  415.             {
  416.               $files = array_merge($files, $this->search_in($current_entry, $depth + 1));
  417.             }
  418.           }
  419.         }
  420.         else
  421.         {
  422.           if (($this->type !== 'directory' || $this->type === 'any') && ($depth >= $this->mindepth) && !$this->is_discarded($dir, $entryname) && $this->match_names($dir, $entryname) && $this->size_ok($dir, $entryname) && $this->exec_ok($dir, $entryname))
  423.           {
  424.             if ($this->sort === 'type')
  425.             {
  426.               $temp_files[] = $current_entry;
  427.             }
  428.             else
  429.             {
  430.               $files[] = $current_entry;
  431.             }
  432.           }
  433.         }
  434.       }
  436.       if ($this->sort === 'type')
  437.       {
  438.         ksort($temp_folders);
  439.         foreach($temp_folders as $entryname => $current_entry)
  440.         {
  441.           if (($this->type === 'directory' || $this->type === 'any') && ($depth >= $this->mindepth) && !$this->is_discarded($dir, $entryname) && $this->match_names($dir, $entryname) && $this->exec_ok($dir, $entryname))
  442.           {
  443.             $files[] = $current_entry;
  444.           }
  446.           if (!$this->is_pruned($dir, $entryname))
  447.           {
  448.             $files = array_merge($files, $this->search_in($current_entry, $depth + 1));
  449.           }
  450.         }
  452.         sort($temp_files);
  453.         $files = array_merge($files, $temp_files);
  454.       }
  456.       closedir($current_dir);
  457.     }
  459.     return $files;
  460.   }
  462.   protected function match_names($dir, $entry)
  463.   {
  464.     if (!count($this->names)) return true;
  466.     // Flags indicating that there was attempts to match
  467.     // at least one "not_name" or "name" rule respectively
  468.     // to following variables:
  469.     $one_not_name_rule = false;
  470.     $one_name_rule = false;
  472.     foreach ($this->names as $args)
  473.     {
  474.       list($not, $regex) = $args;
  475.       $not ? $one_not_name_rule = true : $one_name_rule = true;
  476.       if (preg_match($regex, $entry))
  477.       {
  478.         // We must match ONLY ONE "not_name" or "name" rule:
  479.         // if "not_name" rule matched then we return "false"
  480.         // if "name" rule matched then we return "true"
  481.         return $not ? false : true;
  482.       }
  483.     }
  485.     if ($one_not_name_rule && $one_name_rule)
  486.     {
  487.       return false;
  488.     }
  489.     else if ($one_not_name_rule)
  490.     {
  491.       return true;
  492.     }
  493.     else if ($one_name_rule)
  494.     {
  495.       return false;
  496.     }
  497.     return true;
  498.   }
  500.   protected function size_ok($dir, $entry)
  501.   {
  502.     if (0 === count($this->sizes)) return true;
  504.     if (!is_file($dir.DIRECTORY_SEPARATOR.$entry)) return true;
  506.     $filesize = filesize($dir.DIRECTORY_SEPARATOR.$entry);
  507.     foreach ($this->sizes as $number_compare)
  508.     {
  509.       if (!$number_compare->test($filesize)) return false;
  510.     }
  512.     return true;
  513.   }
  515.   protected function is_pruned($dir, $entry)
  516.   {
  517.     if (0 === count($this->prunes)) return false;
  519.     foreach ($this->prunes as $args)
  520.     {
  521.       $regex = $args[1];
  522.       if (preg_match($regex, $entry)) return true;
  523.     }
  525.     return false;
  526.   }
  528.   protected function is_discarded($dir, $entry)
  529.   {
  530.     if (0 === count($this->discards)) return false;
  532.     foreach ($this->discards as $args)
  533.     {
  534.       $regex = $args[1];
  535.       if (preg_match($regex, $entry)) return true;
  536.     }
  538.     return false;
  539.   }
  541.   protected function exec_ok($dir, $entry)
  542.   {
  543.     if (0 === count($this->execs)) return true;
  545.     foreach ($this->execs as $exec)
  546.     {
  547.       if (!call_user_func_array($exec, array($dir, $entry))) return false;
  548.     }
  550.     return true;
  551.   }
  553.   public static function isPathAbsolute($path)
  554.   {
  555.     if ($path{0} === '/' || $path{0} === '\\' ||
  556.         (strlen($path) > 3 && ctype_alpha($path{0}) &&
  557.          $path{1} === ':' &&
  558.          ($path{2} === '\\' || $path{2} === '/')
  559.         )
  560.        )
  561.     {
  562.       return true;
  563.     }
  565.     return false;
  566.   }
  567. }
Debug toolbar