diff options
| -rw-r--r-- | web/html/pkgsubmit.php | 4 | ||||
| -rw-r--r-- | web/lib/Find.php | 485 |
2 files changed, 487 insertions, 2 deletions
diff --git a/web/html/pkgsubmit.php b/web/html/pkgsubmit.php index 4d15ebe..abd6614 100644 --- a/web/html/pkgsubmit.php +++ b/web/html/pkgsubmit.php @@ -1,10 +1,10 @@ <?php +set_include_path(get_include_path() . PATH_SEPARATOR . '../lib' . PATH_SEPARATOR . '../lang'); include("config.inc"); -set_include_path(get_include_path() . PATH_SEPARATOR . '../lib' . PATH_SEPARATOR . '../lang'); require('Archive/Tar.php'); -require('File/Find.php'); +require('Find.php'); include("aur.inc"); # access AUR common functions include("submit_po.inc"); # use some form of this for i18n support diff --git a/web/lib/Find.php b/web/lib/Find.php new file mode 100644 index 0000000..62fc33f --- /dev/null +++ b/web/lib/Find.php @@ -0,0 +1,485 @@ +<?php +// +// +----------------------------------------------------------------------+ +// | PHP Version 4 | +// +----------------------------------------------------------------------+ +// | Copyright (c) 1997-2005 The PHP Group | +// +----------------------------------------------------------------------+ +// | This source file is subject to version 2.02 of the PHP license, | +// | that is bundled with this package in the file LICENSE, and is | +// | available at through the world-wide-web at | +// | http://www.php.net/license/2_02.txt. | +// | If you did not receive a copy of the PHP license and are unable to | +// | obtain it through the world-wide-web, please send a note to | +// | license@php.net so we can mail you a copy immediately. | +// +----------------------------------------------------------------------+ +// | Author: Sterling Hughes <sterling@php.net> | +// +----------------------------------------------------------------------+ +// +// $Id: Find.php,v 1.27 2006/06/30 14:06:16 techtonik Exp $ +// + +require_once 'PEAR.php'; + +define('FILE_FIND_VERSION', '@package_version@'); + +// to debug uncomment this string +// define('FILE_FIND_DEBUG', ''); + +/** +* Commonly needed functions searching directory trees +* +* @access public +* @version $Id: Find.php,v 1.27 2006/06/30 14:06:16 techtonik Exp $ +* @package File +* @author Sterling Hughes <sterling@php.net> +*/ +class File_Find +{ + /** + * internal dir-list + * @var array + */ + var $_dirs = array(); + + /** + * directory separator + * @var string + */ + var $dirsep = "/"; + + /** + * found files + * @var array + */ + var $files = array(); + + /** + * found dirs + * @var array + */ + var $directories = array(); + + /** + * Search specified directory to find matches for specified pattern + * + * @param string $pattern a string containing the pattern to search + * the directory for. + * + * @param string $dirpath a string containing the directory path + * to search. + * + * @param string $pattern_type a string containing the type of + * pattern matching functions to use (can either be 'php', + * 'perl' or 'shell'). + * + * @return array containing all of the files and directories + * matching the pattern or null if no matches + * + * @author Sterling Hughes <sterling@php.net> + * @access public + * @static + */ + function &glob($pattern, $dirpath, $pattern_type = 'php') + { + $dh = @opendir($dirpath); + + if (!$dh) { + $pe = PEAR::raiseError("Cannot open directory $dirpath"); + return $pe; + } + + $match_function = File_Find::_determineRegex($pattern, $pattern_type); + $matches = array(); + + // empty string cannot be specified for 'php' and 'perl' pattern + if ($pattern || ($pattern_type != 'php' && $pattern_type != 'perl')) { + while (false !== ($entry = @readdir($dh))) { + if ($match_function($pattern, $entry) && + $entry != '.' && $entry != '..') { + $matches[] = $entry; + } + } + } + + @closedir($dh); + + if (0 == count($matches)) { + $matches = null; + } + + return $matches ; + } + + /** + * Map the directory tree given by the directory_path parameter. + * + * @param string $directory contains the directory path that you + * want to map. + * + * @return array a two element array, the first element containing a list + * of all the directories, the second element containing a list of all the + * files. + * + * @author Sterling Hughes <sterling@php.net> + * @access public + */ + function &maptree($directory) + { + + /* if called statically */ + if (!isset($this) || !is_a($this, "File_Find")) { + $obj = &new File_Find(); + return $obj->maptree($directory); + } + + /* clear the results just in case */ + $this->files = array(); + $this->directories = array(); + + /* strip out trailing slashes */ + $directory = preg_replace('![\\\\/]+$!', '', $directory); + + $this->_dirs = array($directory); + + while (count($this->_dirs)) { + $dir = array_pop($this->_dirs); + File_Find::_build($dir, $this->dirsep); + array_push($this->directories, $dir); + } + + $retval = array($this->directories, $this->files); + return $retval; + + } + + /** + * Map the directory tree given by the directory parameter. + * + * @param string $directory contains the directory path that you + * want to map. + * @param integer $maxrecursion maximun number of folders to recursive + * map + * + * @return array a multidimensional array containing all subdirectories + * and their files. For example: + * + * Array + * ( + * [0] => file_1.php + * [1] => file_2.php + * [subdirname] => Array + * ( + * [0] => file_1.php + * ) + * ) + * + * @author Mika Tuupola <tuupola@appelsiini.net> + * @access public + * @static + */ + function &mapTreeMultiple($directory, $maxrecursion = 0, $count = 0) + { + $retval = array(); + + $count++; + + /* strip trailing slashes */ + $directory = preg_replace('![\\\\/]+$!', '', $directory); + + if (is_readable($directory)) { + $dh = opendir($directory); + while (false !== ($entry = @readdir($dh))) { + if ($entry != '.' && $entry != '..') { + array_push($retval, $entry); + } + } + closedir($dh); + } + + while (list($key, $val) = each($retval)) { + $path = $directory . "/" . $val; + + if (!is_array($val) && is_dir($path)) { + unset($retval[$key]); + if ($maxrecursion == 0 || $count < $maxrecursion) { + $retval[$val] = &File_Find::mapTreeMultiple($path, + $maxrecursion, $count); + } + } + } + + return $retval; + } + + /** + * Search the specified directory tree with the specified pattern. Return + * an array containing all matching files (no directories included). + * + * @param string $pattern the pattern to match every file with. + * + * @param string $directory the directory tree to search in. + * + * @param string $type the type of regular expression support to use, either + * 'php', 'perl' or 'shell'. + * + * @param bool $fullpath whether the regex should be matched against the + * full path or only against the filename + * + * @param string $match can be either 'files', 'dirs' or 'both' to specify + * the kind of list to return + * + * @return array a list of files matching the pattern parameter in the the + * directory path specified by the directory parameter + * + * @author Sterling Hughes <sterling@php.net> + * @access public + * @static + */ + function &search($pattern, $directory, $type = 'php', $fullpath = true, $match = 'files') + { + + $matches = array(); + list ($directories,$files) = File_Find::maptree($directory); + switch($match) { + case 'directories': + $data = $directories; + break; + case 'both': + $data = array_merge($directories, $files); + break; + case 'files': + default: + $data = $files; + } + unset($files, $directories); + + $match_function = File_Find::_determineRegex($pattern, $type); + + reset($data); + // check if empty string given (ok for 'shell' method, but bad for others) + if ($pattern || ($type != 'php' && $type != 'perl')) { + while (list(,$entry) = each($data)) { + if ($match_function($pattern, + $fullpath ? $entry : basename($entry))) { + $matches[] = $entry; + } + } + } + + return $matches; + } + + /** + * Determine whether or not a variable is a PEAR error + * + * @param object PEAR_Error $var the variable to test. + * + * @return boolean returns true if the variable is a PEAR error, otherwise + * it returns false. + * @access public + */ + function isError(&$var) + { + return PEAR::isError($var); + } + + /** + * internal function to build singular directory trees, used by + * File_Find::maptree() + * + * @param string $directory name of the directory to read + * @param string $separator directory separator + * @return void + */ + function _build($directory, $separator = "/") + { + + $dh = @opendir($directory); + + if (!$dh) { + $pe = PEAR::raiseError("Cannot open directory"); + return $pe; + } + + while (false !== ($entry = @readdir($dh))) { + if ($entry != '.' && $entry != '..') { + + $entry = $directory.$separator.$entry; + + if (is_dir($entry)) { + array_push($this->_dirs, $entry); + } else { + array_push($this->files, $entry); + } + } + } + + @closedir($dh); + } + + /** + * internal function to determine the type of regular expression to + * use, implemented by File_Find::glob() and File_Find::search() + * + * @param string $type given RegExp type + * @return string kind of function ( "eregi", "ereg" or "preg_match") ; + * + */ + function _determineRegex($pattern, $type) + { + if (!strcasecmp($type, 'shell')) { + $match_function = 'File_Find_match_shell'; + } else if (!strcasecmp($type, 'perl')) { + $match_function = 'preg_match'; + } else if (!strcasecmp(substr($pattern, -2), '/i')) { + $match_function = 'eregi'; + } else { + $match_function = 'ereg'; + } + return $match_function; + } + +} + +/** +* Package method to match via 'shell' pattern. Provided in global +* scope, because it should be called like 'preg_match' and 'eregi' +* and can be easily copied into other packages +* +* @author techtonik <techtonik@php.net> +* @return mixed bool on success and PEAR_Error on failure +*/ +function File_Find_match_shell($pattern, $filename) +{ + // {{{ convert pattern to positive and negative regexps + $positive = $pattern; + $negation = substr_count($pattern, "|"); + + if ($negation > 1) { + PEAR::raiseError("Mask string contains errors!"); + return FALSE; + } elseif ($negation) { + list($positive, $negative) = explode("|", $pattern); + if (strlen($negative) == 0) { + PEAR::raiseError("File-mask string contains errors!"); + return FALSE; + } + } + + $positive = _File_Find_match_shell_get_pattern($positive); + if ($negation) { + $negative = _File_Find_match_shell_get_pattern($negative); + } + // }}} convert end + + + if (defined("FILE_FIND_DEBUG")) { + print("Method: $type\nPattern: $pattern\n Converted pattern:"); + print_r($positive); + if (isset($negative)) print_r($negative); + } + + if (!preg_match($positive, $filename)) { + return FALSE; + } else { + if (isset($negative) + && preg_match($negative, $filename)) { + return FALSE; + } else { + return TRUE; + } + } +} + +/** +* function used by File_Find_match_shell to convert 'shell' mask +* into pcre regexp. Some of the rules (see testcases for more): +* escaping all special chars and replacing +* . with \. +* * with .* +* ? with .{1} +* also adding ^ and $ as the pattern matches whole filename +* +* @author techtonik <techtonik@php.net> +* @return string pcre regexp for preg_match +*/ +function _File_Find_match_shell_get_pattern($mask) { + // get array of several masks (if any) delimited by comma + // do not touch commas in char class + $premasks = preg_split("|(\[[^\]]+\])|", $mask, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY ); + if (defined("FILE_FIND_DEBUG")) { + print("\nPremask: "); + print_r($premasks); + } + $pi = 0; + foreach($premasks as $pm) { + if (!isset($masks[$pi])) $masks[$pi] = ""; + if ($pm{0} == '[' && $pm{strlen($pm)-1} == ']') { + // strip commas from character class + $masks[$pi] .= str_replace(",", "", $pm); + } else { + $tarr = explode(",", $pm); + if (sizeof($tarr) == 1) { + $masks[$pi] .= $pm; + } else { + foreach ($tarr as $te) { + $masks[$pi++] .= $te; + $masks[$pi] = ""; + } + unset($masks[$pi--]); + } + } + } + + // if empty string given return *.* pattern + if (strlen($mask) == 0) return "!^.*$!"; + + // convert to preg regexp + $regexmask = implode("|", $masks); + if (defined("FILE_FIND_DEBUG")) { + print("regexMask step one(implode): $regexmask"); + } + $regexmask = addcslashes($regexmask, '^$}!{)(\/.+'); + if (defined("FILE_FIND_DEBUG")) { + print("\nregexMask step two(addcslashes): $regexmask"); + } + $regexmask = preg_replace("!(\*|\?)!", ".$1", $regexmask); + if (defined("FILE_FIND_DEBUG")) { + print("\nregexMask step three(* ? -> .* .?): $regexmask"); + } + // a special case '*.' at the end means that there is no extension + $regexmask = preg_replace("!\.\*\\\.(\||$)!", "[^\.]*$1", $regexmask); + // it is impossible to have dot at the end of filename + $regexmask = preg_replace("!\\\.(\||$)!", "$1", $regexmask); + // and .* at the end also means that there could be nothing at all + // (i.e. no dot at the end also) + $regexmask = preg_replace("!\\\.\.\*(\||$)!", "(\\\\..*)?$1", $regexmask); + if (defined("FILE_FIND_DEBUG")) { + print("\nregexMask step two and half(*.$ \\..*$ .$ -> [^.]*$ .?.* $): $regexmask"); + } + // if no extension supplied - add .* to match partially from filename start + if (strpos($regexmask, "\\.") === FALSE) $regexmask .= ".*"; + + // file mask match whole name - adding restrictions + $regexmask = preg_replace("!(\|)!", '^'."$1".'$', $regexmask); + $regexmask = '^'.$regexmask.'$'; + if (defined("FILE_FIND_DEBUG")) { + print("\nregexMask step three(^ and $ to match whole name): $regexmask"); + } + // wrap regex into ! since all ! are already escaped + $regexmask = "!$regexmask!i"; + if (defined("FILE_FIND_DEBUG")) { + print("\nWrapped regex: $regexmask\n"); + } + return $regexmask; +} + +/* + * Local variables: + * tab-width: 4 + * c-basic-offset: 4 + * End: + */ + +?> |