mambax7 /
extgallery
| Total Complexity | 118 |
| Total Lines | 563 |
| Duplicated Lines | 0 % |
| Changes | 2 | ||
| Bugs | 0 | Features | 0 |
Complex classes like System often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use System, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 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 <[email protected]> |
||
| 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 | } |
||
| 623 |
Loading history...
The PSR-1: Basic Coding Standard recommends that a file should either introduce new symbols, that is classes, functions, constants or similar, or have side effects. Side effects are anything that executes logic, like for example printing output, changing ini settings or writing to a file.
The idea behind this recommendation is that merely auto-loading a class should not change the state of an application. It also promotes a cleaner style of programming and makes your code less prone to errors, because the logic is not spread out all over the place.
To learn more about the PSR-1, please see the PHP-FIG site on the PSR-1.