|
0
|
1 <?php
|
|
|
2 /**
|
|
|
3 * File/Directory manipulation
|
|
|
4 *
|
|
|
5 * PHP versions 4 and 5
|
|
|
6 *
|
|
|
7 * @category pear
|
|
|
8 * @package System
|
|
|
9 * @author Tomas V.V.Cox <cox@idecnet.com>
|
|
|
10 * @copyright 1997-2009 The Authors
|
|
|
11 * @license http://opensource.org/licenses/bsd-license.php New BSD License
|
|
|
12 * @link http://pear.php.net/package/PEAR
|
|
|
13 * @since File available since Release 0.1
|
|
|
14 */
|
|
|
15
|
|
|
16 /**
|
|
|
17 * base class
|
|
|
18 */
|
|
|
19 require_once 'PEAR.php';
|
|
|
20 require_once 'Console/Getopt.php';
|
|
|
21
|
|
|
22 $GLOBALS['_System_temp_files'] = array();
|
|
|
23
|
|
|
24 /**
|
|
|
25 * System offers cross platform compatible system functions
|
|
|
26 *
|
|
|
27 * Static functions for different operations. Should work under
|
|
|
28 * Unix and Windows. The names and usage has been taken from its respectively
|
|
|
29 * GNU commands. The functions will return (bool) false on error and will
|
|
|
30 * trigger the error with the PHP trigger_error() function (you can silence
|
|
|
31 * the error by prefixing a '@' sign after the function call, but this
|
|
|
32 * is not recommended practice. Instead use an error handler with
|
|
|
33 * {@link set_error_handler()}).
|
|
|
34 *
|
|
|
35 * Documentation on this class you can find in:
|
|
|
36 * http://pear.php.net/manual/
|
|
|
37 *
|
|
|
38 * Example usage:
|
|
|
39 * if (!@System::rm('-r file1 dir1')) {
|
|
|
40 * print "could not delete file1 or dir1";
|
|
|
41 * }
|
|
|
42 *
|
|
|
43 * In case you need to to pass file names with spaces,
|
|
|
44 * pass the params as an array:
|
|
|
45 *
|
|
|
46 * System::rm(array('-r', $file1, $dir1));
|
|
|
47 *
|
|
|
48 * @category pear
|
|
|
49 * @package System
|
|
|
50 * @author Tomas V.V. Cox <cox@idecnet.com>
|
|
|
51 * @copyright 1997-2006 The PHP Group
|
|
|
52 * @license http://opensource.org/licenses/bsd-license.php New BSD License
|
|
|
53 * @version Release: @package_version@
|
|
|
54 * @link http://pear.php.net/package/PEAR
|
|
|
55 * @since Class available since Release 0.1
|
|
|
56 * @static
|
|
|
57 */
|
|
|
58 class System
|
|
|
59 {
|
|
|
60 /**
|
|
|
61 * returns the commandline arguments of a function
|
|
|
62 *
|
|
|
63 * @param string $argv the commandline
|
|
|
64 * @param string $short_options the allowed option short-tags
|
|
|
65 * @param string $long_options the allowed option long-tags
|
|
|
66 * @return array the given options and there values
|
|
|
67 */
|
|
|
68 public static function _parseArgs($argv, $short_options, $long_options = null)
|
|
|
69 {
|
|
|
70 if (!is_array($argv) && $argv !== null) {
|
|
|
71 /*
|
|
|
72 // Quote all items that are a short option
|
|
|
73 $av = preg_split('/(\A| )--?[a-z0-9]+[ =]?((?<!\\\\)((,\s*)|((?<!,)\s+))?)/i', $argv, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_OFFSET_CAPTURE);
|
|
|
74 $offset = 0;
|
|
|
75 foreach ($av as $a) {
|
|
|
76 $b = trim($a[0]);
|
|
|
77 if ($b{0} == '"' || $b{0} == "'") {
|
|
|
78 continue;
|
|
|
79 }
|
|
|
80
|
|
|
81 $escape = escapeshellarg($b);
|
|
|
82 $pos = $a[1] + $offset;
|
|
|
83 $argv = substr_replace($argv, $escape, $pos, strlen($b));
|
|
|
84 $offset += 2;
|
|
|
85 }
|
|
|
86 */
|
|
|
87
|
|
|
88 // Find all items, quoted or otherwise
|
|
|
89 preg_match_all("/(?:[\"'])(.*?)(?:['\"])|([^\s]+)/", $argv, $av);
|
|
|
90 $argv = $av[1];
|
|
|
91 foreach ($av[2] as $k => $a) {
|
|
|
92 if (empty($a)) {
|
|
|
93 continue;
|
|
|
94 }
|
|
|
95 $argv[$k] = trim($a) ;
|
|
|
96 }
|
|
|
97 }
|
|
|
98
|
|
|
99 return Console_Getopt::getopt2($argv, $short_options, $long_options);
|
|
|
100 }
|
|
|
101
|
|
|
102 /**
|
|
|
103 * Output errors with PHP trigger_error(). You can silence the errors
|
|
|
104 * with prefixing a "@" sign to the function call: @System::mkdir(..);
|
|
|
105 *
|
|
|
106 * @param mixed $error a PEAR error or a string with the error message
|
|
|
107 * @return bool false
|
|
|
108 */
|
|
|
109 protected static function raiseError($error)
|
|
|
110 {
|
|
|
111 if (PEAR::isError($error)) {
|
|
|
112 $error = $error->getMessage();
|
|
|
113 }
|
|
|
114 trigger_error($error, E_USER_WARNING);
|
|
|
115 return false;
|
|
|
116 }
|
|
|
117
|
|
|
118 /**
|
|
|
119 * Creates a nested array representing the structure of a directory
|
|
|
120 *
|
|
|
121 * System::_dirToStruct('dir1', 0) =>
|
|
|
122 * Array
|
|
|
123 * (
|
|
|
124 * [dirs] => Array
|
|
|
125 * (
|
|
|
126 * [0] => dir1
|
|
|
127 * )
|
|
|
128 *
|
|
|
129 * [files] => Array
|
|
|
130 * (
|
|
|
131 * [0] => dir1/file2
|
|
|
132 * [1] => dir1/file3
|
|
|
133 * )
|
|
|
134 * )
|
|
|
135 * @param string $sPath Name of the directory
|
|
|
136 * @param integer $maxinst max. deep of the lookup
|
|
|
137 * @param integer $aktinst starting deep of the lookup
|
|
|
138 * @param bool $silent if true, do not emit errors.
|
|
|
139 * @return array the structure of the dir
|
|
|
140 */
|
|
|
141 protected static function _dirToStruct($sPath, $maxinst, $aktinst = 0, $silent = false)
|
|
|
142 {
|
|
|
143 $struct = array('dirs' => array(), 'files' => array());
|
|
|
144 if (($dir = @opendir($sPath)) === false) {
|
|
|
145 if (!$silent) {
|
|
|
146 System::raiseError("Could not open dir $sPath");
|
|
|
147 }
|
|
|
148 return $struct; // XXX could not open error
|
|
|
149 }
|
|
|
150
|
|
|
151 $struct['dirs'][] = $sPath = realpath($sPath); // XXX don't add if '.' or '..' ?
|
|
|
152 $list = array();
|
|
|
153 while (false !== ($file = readdir($dir))) {
|
|
|
154 if ($file != '.' && $file != '..') {
|
|
|
155 $list[] = $file;
|
|
|
156 }
|
|
|
157 }
|
|
|
158
|
|
|
159 closedir($dir);
|
|
|
160 natsort($list);
|
|
|
161 if ($aktinst < $maxinst || $maxinst == 0) {
|
|
|
162 foreach ($list as $val) {
|
|
|
163 $path = $sPath . DIRECTORY_SEPARATOR . $val;
|
|
|
164 if (is_dir($path) && !is_link($path)) {
|
|
|
165 $tmp = System::_dirToStruct($path, $maxinst, $aktinst+1, $silent);
|
|
|
166 $struct = array_merge_recursive($struct, $tmp);
|
|
|
167 } else {
|
|
|
168 $struct['files'][] = $path;
|
|
|
169 }
|
|
|
170 }
|
|
|
171 }
|
|
|
172
|
|
|
173 return $struct;
|
|
|
174 }
|
|
|
175
|
|
|
176 /**
|
|
|
177 * Creates a nested array representing the structure of a directory and files
|
|
|
178 *
|
|
|
179 * @param array $files Array listing files and dirs
|
|
|
180 * @return array
|
|
|
181 * @static
|
|
|
182 * @see System::_dirToStruct()
|
|
|
183 */
|
|
|
184 protected static function _multipleToStruct($files)
|
|
|
185 {
|
|
|
186 $struct = array('dirs' => array(), 'files' => array());
|
|
|
187 settype($files, 'array');
|
|
|
188 foreach ($files as $file) {
|
|
|
189 if (is_dir($file) && !is_link($file)) {
|
|
|
190 $tmp = System::_dirToStruct($file, 0);
|
|
|
191 $struct = array_merge_recursive($tmp, $struct);
|
|
|
192 } else {
|
|
|
193 if (!in_array($file, $struct['files'])) {
|
|
|
194 $struct['files'][] = $file;
|
|
|
195 }
|
|
|
196 }
|
|
|
197 }
|
|
|
198 return $struct;
|
|
|
199 }
|
|
|
200
|
|
|
201 /**
|
|
|
202 * The rm command for removing files.
|
|
|
203 * Supports multiple files and dirs and also recursive deletes
|
|
|
204 *
|
|
|
205 * @param string $args the arguments for rm
|
|
|
206 * @return mixed PEAR_Error or true for success
|
|
|
207 * @static
|
|
|
208 * @access public
|
|
|
209 */
|
|
|
210 public static function rm($args)
|
|
|
211 {
|
|
|
212 $opts = System::_parseArgs($args, 'rf'); // "f" does nothing but I like it :-)
|
|
|
213 if (PEAR::isError($opts)) {
|
|
|
214 return System::raiseError($opts);
|
|
|
215 }
|
|
|
216 foreach ($opts[0] as $opt) {
|
|
|
217 if ($opt[0] == 'r') {
|
|
|
218 $do_recursive = true;
|
|
|
219 }
|
|
|
220 }
|
|
|
221 $ret = true;
|
|
|
222 if (isset($do_recursive)) {
|
|
|
223 $struct = System::_multipleToStruct($opts[1]);
|
|
|
224 foreach ($struct['files'] as $file) {
|
|
|
225 if (!@unlink($file)) {
|
|
|
226 $ret = false;
|
|
|
227 }
|
|
|
228 }
|
|
|
229
|
|
|
230 rsort($struct['dirs']);
|
|
|
231 foreach ($struct['dirs'] as $dir) {
|
|
|
232 if (!@rmdir($dir)) {
|
|
|
233 $ret = false;
|
|
|
234 }
|
|
|
235 }
|
|
|
236 } else {
|
|
|
237 foreach ($opts[1] as $file) {
|
|
|
238 $delete = (is_dir($file)) ? 'rmdir' : 'unlink';
|
|
|
239 if (!@$delete($file)) {
|
|
|
240 $ret = false;
|
|
|
241 }
|
|
|
242 }
|
|
|
243 }
|
|
|
244 return $ret;
|
|
|
245 }
|
|
|
246
|
|
|
247 /**
|
|
|
248 * Make directories.
|
|
|
249 *
|
|
|
250 * The -p option will create parent directories
|
|
|
251 * @param string $args the name of the director(y|ies) to create
|
|
|
252 * @return bool True for success
|
|
|
253 */
|
|
|
254 public static function mkDir($args)
|
|
|
255 {
|
|
|
256 $opts = System::_parseArgs($args, 'pm:');
|
|
|
257 if (PEAR::isError($opts)) {
|
|
|
258 return System::raiseError($opts);
|
|
|
259 }
|
|
|
260
|
|
|
261 $mode = 0777; // default mode
|
|
|
262 foreach ($opts[0] as $opt) {
|
|
|
263 if ($opt[0] == 'p') {
|
|
|
264 $create_parents = true;
|
|
|
265 } elseif ($opt[0] == 'm') {
|
|
|
266 // if the mode is clearly an octal number (starts with 0)
|
|
|
267 // convert it to decimal
|
|
|
268 if (strlen($opt[1]) && $opt[1]{0} == '0') {
|
|
|
269 $opt[1] = octdec($opt[1]);
|
|
|
270 } else {
|
|
|
271 // convert to int
|
|
|
272 $opt[1] += 0;
|
|
|
273 }
|
|
|
274 $mode = $opt[1];
|
|
|
275 }
|
|
|
276 }
|
|
|
277
|
|
|
278 $ret = true;
|
|
|
279 if (isset($create_parents)) {
|
|
|
280 foreach ($opts[1] as $dir) {
|
|
|
281 $dirstack = array();
|
|
|
282 while ((!file_exists($dir) || !is_dir($dir)) &&
|
|
|
283 $dir != DIRECTORY_SEPARATOR) {
|
|
|
284 array_unshift($dirstack, $dir);
|
|
|
285 $dir = dirname($dir);
|
|
|
286 }
|
|
|
287
|
|
|
288 while ($newdir = array_shift($dirstack)) {
|
|
|
289 if (!is_writeable(dirname($newdir))) {
|
|
|
290 $ret = false;
|
|
|
291 break;
|
|
|
292 }
|
|
|
293
|
|
|
294 if (!mkdir($newdir, $mode)) {
|
|
|
295 $ret = false;
|
|
|
296 }
|
|
|
297 }
|
|
|
298 }
|
|
|
299 } else {
|
|
|
300 foreach($opts[1] as $dir) {
|
|
|
301 if ((@file_exists($dir) || !is_dir($dir)) && !mkdir($dir, $mode)) {
|
|
|
302 $ret = false;
|
|
|
303 }
|
|
|
304 }
|
|
|
305 }
|
|
|
306
|
|
|
307 return $ret;
|
|
|
308 }
|
|
|
309
|
|
|
310 /**
|
|
|
311 * Concatenate files
|
|
|
312 *
|
|
|
313 * Usage:
|
|
|
314 * 1) $var = System::cat('sample.txt test.txt');
|
|
|
315 * 2) System::cat('sample.txt test.txt > final.txt');
|
|
|
316 * 3) System::cat('sample.txt test.txt >> final.txt');
|
|
|
317 *
|
|
|
318 * Note: as the class use fopen, urls should work also (test that)
|
|
|
319 *
|
|
|
320 * @param string $args the arguments
|
|
|
321 * @return boolean true on success
|
|
|
322 */
|
|
|
323 public static function &cat($args)
|
|
|
324 {
|
|
|
325 $ret = null;
|
|
|
326 $files = array();
|
|
|
327 if (!is_array($args)) {
|
|
|
328 $args = preg_split('/\s+/', $args, -1, PREG_SPLIT_NO_EMPTY);
|
|
|
329 }
|
|
|
330
|
|
|
331 $count_args = count($args);
|
|
|
332 for ($i = 0; $i < $count_args; $i++) {
|
|
|
333 if ($args[$i] == '>') {
|
|
|
334 $mode = 'wb';
|
|
|
335 $outputfile = $args[$i+1];
|
|
|
336 break;
|
|
|
337 } elseif ($args[$i] == '>>') {
|
|
|
338 $mode = 'ab+';
|
|
|
339 $outputfile = $args[$i+1];
|
|
|
340 break;
|
|
|
341 } else {
|
|
|
342 $files[] = $args[$i];
|
|
|
343 }
|
|
|
344 }
|
|
|
345 $outputfd = false;
|
|
|
346 if (isset($mode)) {
|
|
|
347 if (!$outputfd = fopen($outputfile, $mode)) {
|
|
|
348 $err = System::raiseError("Could not open $outputfile");
|
|
|
349 return $err;
|
|
|
350 }
|
|
|
351 $ret = true;
|
|
|
352 }
|
|
|
353 foreach ($files as $file) {
|
|
|
354 if (!$fd = fopen($file, 'r')) {
|
|
|
355 System::raiseError("Could not open $file");
|
|
|
356 continue;
|
|
|
357 }
|
|
|
358 while ($cont = fread($fd, 2048)) {
|
|
|
359 if (is_resource($outputfd)) {
|
|
|
360 fwrite($outputfd, $cont);
|
|
|
361 } else {
|
|
|
362 $ret .= $cont;
|
|
|
363 }
|
|
|
364 }
|
|
|
365 fclose($fd);
|
|
|
366 }
|
|
|
367 if (is_resource($outputfd)) {
|
|
|
368 fclose($outputfd);
|
|
|
369 }
|
|
|
370 return $ret;
|
|
|
371 }
|
|
|
372
|
|
|
373 /**
|
|
|
374 * Creates temporary files or directories. This function will remove
|
|
|
375 * the created files when the scripts finish its execution.
|
|
|
376 *
|
|
|
377 * Usage:
|
|
|
378 * 1) $tempfile = System::mktemp("prefix");
|
|
|
379 * 2) $tempdir = System::mktemp("-d prefix");
|
|
|
380 * 3) $tempfile = System::mktemp();
|
|
|
381 * 4) $tempfile = System::mktemp("-t /var/tmp prefix");
|
|
|
382 *
|
|
|
383 * prefix -> The string that will be prepended to the temp name
|
|
|
384 * (defaults to "tmp").
|
|
|
385 * -d -> A temporary dir will be created instead of a file.
|
|
|
386 * -t -> The target dir where the temporary (file|dir) will be created. If
|
|
|
387 * this param is missing by default the env vars TMP on Windows or
|
|
|
388 * TMPDIR in Unix will be used. If these vars are also missing
|
|
|
389 * c:\windows\temp or /tmp will be used.
|
|
|
390 *
|
|
|
391 * @param string $args The arguments
|
|
|
392 * @return mixed the full path of the created (file|dir) or false
|
|
|
393 * @see System::tmpdir()
|
|
|
394 */
|
|
|
395 public static function mktemp($args = null)
|
|
|
396 {
|
|
|
397 static $first_time = true;
|
|
|
398 $opts = System::_parseArgs($args, 't:d');
|
|
|
399 if (PEAR::isError($opts)) {
|
|
|
400 return System::raiseError($opts);
|
|
|
401 }
|
|
|
402
|
|
|
403 foreach ($opts[0] as $opt) {
|
|
|
404 if ($opt[0] == 'd') {
|
|
|
405 $tmp_is_dir = true;
|
|
|
406 } elseif ($opt[0] == 't') {
|
|
|
407 $tmpdir = $opt[1];
|
|
|
408 }
|
|
|
409 }
|
|
|
410
|
|
|
411 $prefix = (isset($opts[1][0])) ? $opts[1][0] : 'tmp';
|
|
|
412 if (!isset($tmpdir)) {
|
|
|
413 $tmpdir = System::tmpdir();
|
|
|
414 }
|
|
|
415
|
|
|
416 if (!System::mkDir(array('-p', $tmpdir))) {
|
|
|
417 return false;
|
|
|
418 }
|
|
|
419
|
|
|
420 $tmp = tempnam($tmpdir, $prefix);
|
|
|
421 if (isset($tmp_is_dir)) {
|
|
|
422 unlink($tmp); // be careful possible race condition here
|
|
|
423 if (!mkdir($tmp, 0700)) {
|
|
|
424 return System::raiseError("Unable to create temporary directory $tmpdir");
|
|
|
425 }
|
|
|
426 }
|
|
|
427
|
|
|
428 $GLOBALS['_System_temp_files'][] = $tmp;
|
|
|
429 if (isset($tmp_is_dir)) {
|
|
|
430 //$GLOBALS['_System_temp_files'][] = dirname($tmp);
|
|
|
431 }
|
|
|
432
|
|
|
433 if ($first_time) {
|
|
|
434 PEAR::registerShutdownFunc(array('System', '_removeTmpFiles'));
|
|
|
435 $first_time = false;
|
|
|
436 }
|
|
|
437
|
|
|
438 return $tmp;
|
|
|
439 }
|
|
|
440
|
|
|
441 /**
|
|
|
442 * Remove temporary files created my mkTemp. This function is executed
|
|
|
443 * at script shutdown time
|
|
|
444 */
|
|
|
445 public static function _removeTmpFiles()
|
|
|
446 {
|
|
|
447 if (count($GLOBALS['_System_temp_files'])) {
|
|
|
448 $delete = $GLOBALS['_System_temp_files'];
|
|
|
449 array_unshift($delete, '-r');
|
|
|
450 System::rm($delete);
|
|
|
451 $GLOBALS['_System_temp_files'] = array();
|
|
|
452 }
|
|
|
453 }
|
|
|
454
|
|
|
455 /**
|
|
|
456 * Get the path of the temporal directory set in the system
|
|
|
457 * by looking in its environments variables.
|
|
|
458 * Note: php.ini-recommended removes the "E" from the variables_order setting,
|
|
|
459 * making unavaible the $_ENV array, that s why we do tests with _ENV
|
|
|
460 *
|
|
|
461 * @return string The temporary directory on the system
|
|
|
462 */
|
|
|
463 public static function tmpdir()
|
|
|
464 {
|
|
|
465 if (OS_WINDOWS) {
|
|
|
466 if ($var = isset($_ENV['TMP']) ? $_ENV['TMP'] : getenv('TMP')) {
|
|
|
467 return $var;
|
|
|
468 }
|
|
|
469 if ($var = isset($_ENV['TEMP']) ? $_ENV['TEMP'] : getenv('TEMP')) {
|
|
|
470 return $var;
|
|
|
471 }
|
|
|
472 if ($var = isset($_ENV['USERPROFILE']) ? $_ENV['USERPROFILE'] : getenv('USERPROFILE')) {
|
|
|
473 return $var;
|
|
|
474 }
|
|
|
475 if ($var = isset($_ENV['windir']) ? $_ENV['windir'] : getenv('windir')) {
|
|
|
476 return $var;
|
|
|
477 }
|
|
|
478 return getenv('SystemRoot') . '\temp';
|
|
|
479 }
|
|
|
480 if ($var = isset($_ENV['TMPDIR']) ? $_ENV['TMPDIR'] : getenv('TMPDIR')) {
|
|
|
481 return $var;
|
|
|
482 }
|
|
|
483 return realpath('/tmp');
|
|
|
484 }
|
|
|
485
|
|
|
486 /**
|
|
|
487 * The "which" command (show the full path of a command)
|
|
|
488 *
|
|
|
489 * @param string $program The command to search for
|
|
|
490 * @param mixed $fallback Value to return if $program is not found
|
|
|
491 *
|
|
|
492 * @return mixed A string with the full path or false if not found
|
|
|
493 * @author Stig Bakken <ssb@php.net>
|
|
|
494 */
|
|
|
495 public static function which($program, $fallback = false)
|
|
|
496 {
|
|
|
497 // enforce API
|
|
|
498 if (!is_string($program) || '' == $program) {
|
|
|
499 return $fallback;
|
|
|
500 }
|
|
|
501
|
|
|
502 // full path given
|
|
|
503 if (basename($program) != $program) {
|
|
|
504 $path_elements[] = dirname($program);
|
|
|
505 $program = basename($program);
|
|
|
506 } else {
|
|
|
507 $path = getenv('PATH');
|
|
|
508 if (!$path) {
|
|
|
509 $path = getenv('Path'); // some OSes are just stupid enough to do this
|
|
|
510 }
|
|
|
511
|
|
|
512 $path_elements = explode(PATH_SEPARATOR, $path);
|
|
|
513 }
|
|
|
514
|
|
|
515 if (OS_WINDOWS) {
|
|
|
516 $exe_suffixes = getenv('PATHEXT')
|
|
|
517 ? explode(PATH_SEPARATOR, getenv('PATHEXT'))
|
|
|
518 : array('.exe','.bat','.cmd','.com');
|
|
|
519 // allow passing a command.exe param
|
|
|
520 if (strpos($program, '.') !== false) {
|
|
|
521 array_unshift($exe_suffixes, '');
|
|
|
522 }
|
|
|
523 } else {
|
|
|
524 $exe_suffixes = array('');
|
|
|
525 }
|
|
|
526
|
|
|
527 foreach ($exe_suffixes as $suff) {
|
|
|
528 foreach ($path_elements as $dir) {
|
|
|
529 $file = $dir . DIRECTORY_SEPARATOR . $program . $suff;
|
|
|
530 if (is_executable($file)) {
|
|
|
531 return $file;
|
|
|
532 }
|
|
|
533 }
|
|
|
534 }
|
|
|
535 return $fallback;
|
|
|
536 }
|
|
|
537
|
|
|
538 /**
|
|
|
539 * The "find" command
|
|
|
540 *
|
|
|
541 * Usage:
|
|
|
542 *
|
|
|
543 * System::find($dir);
|
|
|
544 * System::find("$dir -type d");
|
|
|
545 * System::find("$dir -type f");
|
|
|
546 * System::find("$dir -name *.php");
|
|
|
547 * System::find("$dir -name *.php -name *.htm*");
|
|
|
548 * System::find("$dir -maxdepth 1");
|
|
|
549 *
|
|
|
550 * Params implemented:
|
|
|
551 * $dir -> Start the search at this directory
|
|
|
552 * -type d -> return only directories
|
|
|
553 * -type f -> return only files
|
|
|
554 * -maxdepth <n> -> max depth of recursion
|
|
|
555 * -name <pattern> -> search pattern (bash style). Multiple -name param allowed
|
|
|
556 *
|
|
|
557 * @param mixed Either array or string with the command line
|
|
|
558 * @return array Array of found files
|
|
|
559 */
|
|
|
560 public static function find($args)
|
|
|
561 {
|
|
|
562 if (!is_array($args)) {
|
|
|
563 $args = preg_split('/\s+/', $args, -1, PREG_SPLIT_NO_EMPTY);
|
|
|
564 }
|
|
|
565 $dir = realpath(array_shift($args));
|
|
|
566 if (!$dir) {
|
|
|
567 return array();
|
|
|
568 }
|
|
|
569 $patterns = array();
|
|
|
570 $depth = 0;
|
|
|
571 $do_files = $do_dirs = true;
|
|
|
572 $args_count = count($args);
|
|
|
573 for ($i = 0; $i < $args_count; $i++) {
|
|
|
574 switch ($args[$i]) {
|
|
|
575 case '-type':
|
|
|
576 if (in_array($args[$i+1], array('d', 'f'))) {
|
|
|
577 if ($args[$i+1] == 'd') {
|
|
|
578 $do_files = false;
|
|
|
579 } else {
|
|
|
580 $do_dirs = false;
|
|
|
581 }
|
|
|
582 }
|
|
|
583 $i++;
|
|
|
584 break;
|
|
|
585 case '-name':
|
|
|
586 $name = preg_quote($args[$i+1], '#');
|
|
|
587 // our magic characters ? and * have just been escaped,
|
|
|
588 // so now we change the escaped versions to PCRE operators
|
|
|
589 $name = strtr($name, array('\?' => '.', '\*' => '.*'));
|
|
|
590 $patterns[] = '('.$name.')';
|
|
|
591 $i++;
|
|
|
592 break;
|
|
|
593 case '-maxdepth':
|
|
|
594 $depth = $args[$i+1];
|
|
|
595 break;
|
|
|
596 }
|
|
|
597 }
|
|
|
598 $path = System::_dirToStruct($dir, $depth, 0, true);
|
|
|
599 if ($do_files && $do_dirs) {
|
|
|
600 $files = array_merge($path['files'], $path['dirs']);
|
|
|
601 } elseif ($do_dirs) {
|
|
|
602 $files = $path['dirs'];
|
|
|
603 } else {
|
|
|
604 $files = $path['files'];
|
|
|
605 }
|
|
|
606 if (count($patterns)) {
|
|
|
607 $dsq = preg_quote(DIRECTORY_SEPARATOR, '#');
|
|
|
608 $pattern = '#(^|'.$dsq.')'.implode('|', $patterns).'($|'.$dsq.')#';
|
|
|
609 $ret = array();
|
|
|
610 $files_count = count($files);
|
|
|
611 for ($i = 0; $i < $files_count; $i++) {
|
|
|
612 // only search in the part of the file below the current directory
|
|
|
613 $filepart = basename($files[$i]);
|
|
|
614 if (preg_match($pattern, $filepart)) {
|
|
|
615 $ret[] = $files[$i];
|
|
|
616 }
|
|
|
617 }
|
|
|
618 return $ret;
|
|
|
619 }
|
|
|
620 return $files;
|
|
|
621 }
|
|
|
622 } |
