From eecd68f85f98e0b76a60b8cfa68c414ca4ebe2a7 Mon Sep 17 00:00:00 2001 From: X! Date: Thu, 23 Dec 2010 18:22:10 +0000 Subject: [PATCH] Followup to r78903: Forgot to svn add --- includes/libs/sfFinder.php | 824 +++++++++++++++++++++++++++++++++++++ 1 file changed, 824 insertions(+) create mode 100644 includes/libs/sfFinder.php diff --git a/includes/libs/sfFinder.php b/includes/libs/sfFinder.php new file mode 100644 index 0000000000..ad710fc056 --- /dev/null +++ b/includes/libs/sfFinder.php @@ -0,0 +1,824 @@ + + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + + +/** + * + * 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. + * + * @license http://www.opensource.org/licenses/mit-license.php MIT License + * @author Fabien Potencier + * @version SVN: $Id$ + */ +class sfFinder +{ + protected $type = 'file'; + protected $names = array(); + protected $prunes = array(); + protected $discards = array(); + protected $execs = array(); + protected $mindepth = 0; + protected $sizes = array(); + protected $maxdepth = 1000000; + protected $relative = false; + protected $follow_link = false; + protected $sort = false; + protected $ignore_version_control = true; + + /** + * Sets maximum directory depth. + * + * Finder will descend at most $level levels of directories below the starting point. + * + * @param int $level + * @return sfFinder current sfFinder object + */ + public function maxdepth($level) + { + $this->maxdepth = $level; + + return $this; + } + + /** + * Sets minimum directory depth. + * + * Finder will start applying tests at level $level. + * + * @param int $level + * @return sfFinder current sfFinder object + */ + public function mindepth($level) + { + $this->mindepth = $level; + + return $this; + } + + public function get_type() + { + return $this->type; + } + + /** + * Sets the type of elements to returns. + * + * @param string $name directory or file or any (for both file and directory) + * @return sfFinder new sfFinder object + */ + public static function type($name) + { + $finder = new self(); + return $finder->setType($name); + } + /** + * Sets the type of elements to returns. + * + * @param string $name directory or file or any (for both file and directory) + * @return sfFinder Current object + */ + public function setType($name) + { + $name = strtolower($name); + + if (substr($name, 0, 3) === 'dir') + { + $this->type = 'directory'; + + return $this; + } + if ($name === 'any') + { + $this->type = 'any'; + + return $this; + } + + $this->type = 'file'; + + return $this; + } + + /* + * glob, patterns (must be //) or strings + */ + protected function to_regex($str) + { + if (preg_match('/^(!)?([^a-zA-Z0-9\\\\]).+?\\2[ims]?$/', $str)) + { + return $str; + } + + return sfGlobToRegex::glob_to_regex($str); + } + + protected function args_to_array($arg_list, $not = false) + { + $list = array(); + $nbArgList = count($arg_list); + for ($i = 0; $i < $nbArgList; $i++) + { + if (is_array($arg_list[$i])) + { + foreach ($arg_list[$i] as $arg) + { + $list[] = array($not, $this->to_regex($arg)); + } + } + else + { + $list[] = array($not, $this->to_regex($arg_list[$i])); + } + } + + return $list; + } + + /** + * Adds rules that files must match. + * + * You can use patterns (delimited with / sign), globs or simple strings. + * + * $finder->name('*.php') + * $finder->name('/\.php$/') // same as above + * $finder->name('test.php') + * + * @param list a list of patterns, globs or strings + * @return sfFinder Current object + */ + public function name() + { + $args = func_get_args(); + $this->names = array_merge($this->names, $this->args_to_array($args)); + + return $this; + } + + /** + * Adds rules that files must not match. + * + * @see ->name() + * @param list a list of patterns, globs or strings + * @return sfFinder Current object + */ + public function not_name() + { + $args = func_get_args(); + $this->names = array_merge($this->names, $this->args_to_array($args, true)); + + return $this; + } + + public function notName() { + $args = func_get_args(); + return call_user_func_array( array( $this, 'not_name' ), $args ); + } + + /** + * Adds tests for file sizes. + * + * $finder->size('> 10K'); + * $finder->size('<= 1Ki'); + * $finder->size(4); + * + * @param list a list of comparison strings + * @return sfFinder Current object + */ + public function size() + { + $args = func_get_args(); + $numargs = count($args); + for ($i = 0; $i < $numargs; $i++) + { + $this->sizes[] = new sfNumberCompare($args[$i]); + } + + return $this; + } + + /** + * Traverses no further. + * + * @param list a list of patterns, globs to match + * @return sfFinder Current object + */ + public function prune() + { + $args = func_get_args(); + $this->prunes = array_merge($this->prunes, $this->args_to_array($args)); + + return $this; + } + + /** + * Discards elements that matches. + * + * @param list a list of patterns, globs to match + * @return sfFinder Current object + */ + public function discard() + { + $args = func_get_args(); + $this->discards = array_merge($this->discards, $this->args_to_array($args)); + + return $this; + } + + /** + * Ignores version control directories. + * + * Currently supports Subversion, CVS, DARCS, Gnu Arch, Monotone, Bazaar-NG, GIT, Mercurial + * + * @param bool $ignore falase when version control directories shall be included (default is true) + * + * @return sfFinder Current object + */ + public function ignore_version_control($ignore = true) + { + $this->ignore_version_control = $ignore; + + return $this; + } + + public function ignoreVersionControl($ignore = true) + { + return $this->ignore_version_control($ignore); + } + + public function ignoreVC($ignore = true) + { + return $this->ignore_version_control($ignore); + } + + /** + * Returns files and directories ordered by name + * + * @return sfFinder Current object + */ + public function sort_by_name() + { + $this->sort = 'name'; + + return $this; + } + + public function sortByName() + { + return $this->sort_by_name(); + } + + /** + * Returns files and directories ordered by type (directories before files), then by name + * + * @return sfFinder Current object + */ + public function sort_by_type() + { + $this->sort = 'type'; + + return $this; + } + + public function sortByType() + { + return $this->sort_by_type(); + } + + /** + * Executes function or method for each element. + * + * Element match if functino or method returns true. + * + * $finder->exec('myfunction'); + * $finder->exec(array($object, 'mymethod')); + * + * @param mixed function or method to call + * @return sfFinder Current object + */ + public function exec() + { + $args = func_get_args(); + $numargs = count($args); + for ($i = 0; $i < $numargs; $i++) + { + if (is_array($args[$i]) && !method_exists($args[$i][0], $args[$i][1])) + { + throw new MWException(sprintf('method "%s" does not exist for object "%s".', $args[$i][1], $args[$i][0])); + } + if (!is_array($args[$i]) && !function_exists($args[$i])) + { + throw new MWException(sprintf('function "%s" does not exist.', $args[$i])); + } + + $this->execs[] = $args[$i]; + } + + return $this; + } + + /** + * Returns relative paths for all files and directories. + * + * @return sfFinder Current object + */ + public function relative() + { + $this->relative = true; + + return $this; + } + + /** + * Symlink following. + * + * @return sfFinder Current object + */ + public function follow_link() + { + $this->follow_link = true; + + return $this; + } + + public function followLink() { + return $this->follow_link(); + } + + /** + * Searches files and directories which match defined rules. + * + * @return array list of files and directories + */ + public function in() + { + $files = array(); + $here_dir = getcwd(); + + $finder = clone $this; + + if ($this->ignore_version_control) + { + $ignores = array('.svn', '_svn', 'CVS', '_darcs', '.arch-params', '.monotone', '.bzr', '.git', '.hg'); + + $finder->discard($ignores)->prune($ignores); + } + + // first argument is an array? + $numargs = func_num_args(); + $arg_list = func_get_args(); + if ($numargs === 1 && is_array($arg_list[0])) + { + $arg_list = $arg_list[0]; + $numargs = count($arg_list); + } + + for ($i = 0; $i < $numargs; $i++) + { + $dir = realpath($arg_list[$i]); + + if (!is_dir($dir)) + { + continue; + } + + $dir = str_replace('\\', '/', $dir); + + // absolute path? + if (!self::isPathAbsolute($dir)) + { + $dir = $here_dir.'/'.$dir; + } + + $new_files = str_replace('\\', '/', $finder->search_in($dir)); + + if ($this->relative) + { + $new_files = str_replace(rtrim($dir, '/').'/', '', $new_files); + } + + $files = array_merge($files, $new_files); + } + + if ($this->sort === 'name') + { + sort($files); + } + + return array_unique($files); + } + + protected function search_in($dir, $depth = 0) + { + if ($depth > $this->maxdepth) + { + return array(); + } + + $dir = realpath($dir); + + if ((!$this->follow_link) && is_link($dir)) + { + return array(); + } + + $files = array(); + $temp_files = array(); + $temp_folders = array(); + if (is_dir($dir) && is_readable($dir)) + { + $current_dir = opendir($dir); + while (false !== $entryname = readdir($current_dir)) + { + if ($entryname == '.' || $entryname == '..') continue; + + $current_entry = $dir.DIRECTORY_SEPARATOR.$entryname; + if ((!$this->follow_link) && is_link($current_entry)) + { + continue; + } + + if (is_dir($current_entry)) + { + if ($this->sort === 'type') + { + $temp_folders[$entryname] = $current_entry; + } + else + { + 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)) + { + $files[] = $current_entry; + } + + if (!$this->is_pruned($dir, $entryname)) + { + $files = array_merge($files, $this->search_in($current_entry, $depth + 1)); + } + } + } + else + { + 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)) + { + if ($this->sort === 'type') + { + $temp_files[] = $current_entry; + } + else + { + $files[] = $current_entry; + } + } + } + } + + if ($this->sort === 'type') + { + ksort($temp_folders); + foreach($temp_folders as $entryname => $current_entry) + { + 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)) + { + $files[] = $current_entry; + } + + if (!$this->is_pruned($dir, $entryname)) + { + $files = array_merge($files, $this->search_in($current_entry, $depth + 1)); + } + } + + sort($temp_files); + $files = array_merge($files, $temp_files); + } + + closedir($current_dir); + } + + return $files; + } + + protected function match_names($dir, $entry) + { + if (!count($this->names)) return true; + + // Flags indicating that there was attempts to match + // at least one "not_name" or "name" rule respectively + // to following variables: + $one_not_name_rule = false; + $one_name_rule = false; + + foreach ($this->names as $args) + { + list($not, $regex) = $args; + $not ? $one_not_name_rule = true : $one_name_rule = true; + if (preg_match($regex, $entry)) + { + // We must match ONLY ONE "not_name" or "name" rule: + // if "not_name" rule matched then we return "false" + // if "name" rule matched then we return "true" + return $not ? false : true; + } + } + + if ($one_not_name_rule && $one_name_rule) + { + return false; + } + else if ($one_not_name_rule) + { + return true; + } + else if ($one_name_rule) + { + return false; + } + return true; + } + + protected function size_ok($dir, $entry) + { + if (0 === count($this->sizes)) return true; + + if (!is_file($dir.DIRECTORY_SEPARATOR.$entry)) return true; + + $filesize = filesize($dir.DIRECTORY_SEPARATOR.$entry); + foreach ($this->sizes as $number_compare) + { + if (!$number_compare->test($filesize)) return false; + } + + return true; + } + + protected function is_pruned($dir, $entry) + { + if (0 === count($this->prunes)) return false; + + foreach ($this->prunes as $args) + { + $regex = $args[1]; + if (preg_match($regex, $entry)) return true; + } + + return false; + } + + protected function is_discarded($dir, $entry) + { + if (0 === count($this->discards)) return false; + + foreach ($this->discards as $args) + { + $regex = $args[1]; + if (preg_match($regex, $entry)) return true; + } + + return false; + } + + protected function exec_ok($dir, $entry) + { + if (0 === count($this->execs)) return true; + + foreach ($this->execs as $exec) + { + if (!call_user_func_array($exec, array($dir, $entry))) return false; + } + + return true; + } + + public static function isPathAbsolute($path) + { + if ($path{0} === '/' || $path{0} === '\\' || + (strlen($path) > 3 && ctype_alpha($path{0}) && + $path{1} === ':' && + ($path{2} === '\\' || $path{2} === '/') + ) + ) + { + return true; + } + + return false; + } +} + +/** + * Match globbing patterns against text. + * + * if match_glob("foo.*", "foo.bar") echo "matched\n"; + * + * // prints foo.bar and foo.baz + * $regex = glob_to_regex("foo.*"); + * for (array('foo.bar', 'foo.baz', 'foo', 'bar') as $t) + * { + * if (/$regex/) echo "matched: $car\n"; + * } + * + * sfGlobToRegex implements glob(3) style matching that can be used to match + * against text, rather than fetching names from a filesystem. + * + * based on perl Text::Glob module. + * + * @package symfony + * @subpackage util + * @author Fabien Potencier php port + * @author Richard Clamp perl version + * @copyright 2004-2005 Fabien Potencier + * @copyright 2002 Richard Clamp + * @version SVN: $Id$ + */ +class sfGlobToRegex +{ + protected static $strict_leading_dot = true; + protected static $strict_wildcard_slash = true; + + public static function setStrictLeadingDot($boolean) + { + self::$strict_leading_dot = $boolean; + } + + public static function setStrictWildcardSlash($boolean) + { + self::$strict_wildcard_slash = $boolean; + } + + /** + * Returns a compiled regex which is the equiavlent of the globbing pattern. + * + * @param string $glob pattern + * @return string regex + */ + public static function glob_to_regex($glob) + { + $first_byte = true; + $escaping = false; + $in_curlies = 0; + $regex = ''; + $sizeGlob = strlen($glob); + for ($i = 0; $i < $sizeGlob; $i++) + { + $car = $glob[$i]; + if ($first_byte) + { + if (self::$strict_leading_dot && $car !== '.') + { + $regex .= '(?=[^\.])'; + } + + $first_byte = false; + } + + if ($car === '/') + { + $first_byte = true; + } + + if ($car === '.' || $car === '(' || $car === ')' || $car === '|' || $car === '+' || $car === '^' || $car === '$') + { + $regex .= "\\$car"; + } + elseif ($car === '*') + { + $regex .= ($escaping ? '\\*' : (self::$strict_wildcard_slash ? '[^/]*' : '.*')); + } + elseif ($car === '?') + { + $regex .= ($escaping ? '\\?' : (self::$strict_wildcard_slash ? '[^/]' : '.')); + } + elseif ($car === '{') + { + $regex .= ($escaping ? '\\{' : '('); + if (!$escaping) ++$in_curlies; + } + elseif ($car === '}' && $in_curlies) + { + $regex .= ($escaping ? '}' : ')'); + if (!$escaping) --$in_curlies; + } + elseif ($car === ',' && $in_curlies) + { + $regex .= ($escaping ? ',' : '|'); + } + elseif ($car === '\\') + { + if ($escaping) + { + $regex .= '\\\\'; + $escaping = false; + } + else + { + $escaping = true; + } + + continue; + } + else + { + $regex .= $car; + } + $escaping = false; + } + + return '#^'.$regex.'$#'; + } + + public static function globToRegex($glob) { + return self::glob_to_regex($glob); + } + +} + +/** + * Numeric comparisons. + * + * sfNumberCompare compiles a simple comparison to an anonymous + * subroutine, which you can call with a value to be tested again. + + * Now this would be very pointless, if sfNumberCompare didn't understand + * magnitudes. + + * The target value may use magnitudes of kilobytes (k, ki), + * megabytes (m, mi), or gigabytes (g, gi). Those suffixed + * with an i use the appropriate 2**n version in accordance with the + * IEC standard: http://physics.nist.gov/cuu/Units/binary.html + * + * based on perl Number::Compare module. + * + * @author Fabien Potencier php port + * @author Richard Clamp perl version + * @copyright 2004-2005 Fabien Potencier + * @copyright 2002 Richard Clamp + * @see http://physics.nist.gov/cuu/Units/binary.html + * @version SVN: $Id$ + */ +class sfNumberCompare +{ + protected $test = ''; + + public function __construct($test) + { + $this->test = $test; + } + + public function test($number) + { + if (!preg_match('{^([<>]=?)?(.*?)([kmg]i?)?$}i', $this->test, $matches)) + { + throw new MWException(sprintf('don\'t understand "%s" as a test.', $this->test)); + } + + $target = array_key_exists(2, $matches) ? $matches[2] : ''; + $magnitude = array_key_exists(3, $matches) ? $matches[3] : ''; + if (strtolower($magnitude) === 'k') $target *= 1000; + if (strtolower($magnitude) === 'ki') $target *= 1024; + if (strtolower($magnitude) === 'm') $target *= 1000000; + if (strtolower($magnitude) === 'mi') $target *= 1024*1024; + if (strtolower($magnitude) === 'g') $target *= 1000000000; + if (strtolower($magnitude) === 'gi') $target *= 1024*1024*1024; + + $comparison = array_key_exists(1, $matches) ? $matches[1] : '=='; + if ($comparison === '==' || $comparison == '') + { + return ($number == $target); + } + if ($comparison === '>') + { + return ($number > $target); + } + if ($comparison === '>=') + { + return ($number >= $target); + } + if ($comparison === '<') + { + return ($number < $target); + } + if ($comparison === '<=') + { + return ($number <= $target); + } + + return false; + } +} -- 2.20.1