yiisoft /
yii2
Complex classes like BaseFileHelper 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. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
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 BaseFileHelper, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 24 | class BaseFileHelper |
||
| 25 | { |
||
| 26 | const PATTERN_NODIR = 1; |
||
| 27 | const PATTERN_ENDSWITH = 4; |
||
| 28 | const PATTERN_MUSTBEDIR = 8; |
||
| 29 | const PATTERN_NEGATIVE = 16; |
||
| 30 | const PATTERN_CASE_INSENSITIVE = 32; |
||
| 31 | |||
| 32 | /** |
||
| 33 | * @var string the path (or alias) of a PHP file containing MIME type information. |
||
| 34 | */ |
||
| 35 | public static $mimeMagicFile = '@yii/helpers/mimeTypes.php'; |
||
| 36 | /** |
||
| 37 | * @var string the path (or alias) of a PHP file containing MIME aliases. |
||
| 38 | * @since 2.0.14 |
||
| 39 | */ |
||
| 40 | public static $mimeAliasesFile = '@yii/helpers/mimeAliases.php'; |
||
| 41 | |||
| 42 | |||
| 43 | /** |
||
| 44 | * Normalizes a file/directory path. |
||
| 45 | * |
||
| 46 | * The normalization does the following work: |
||
| 47 | * |
||
| 48 | * - Convert all directory separators into `DIRECTORY_SEPARATOR` (e.g. "\a/b\c" becomes "/a/b/c") |
||
| 49 | * - Remove trailing directory separators (e.g. "/a/b/c/" becomes "/a/b/c") |
||
| 50 | * - Turn multiple consecutive slashes into a single one (e.g. "/a///b/c" becomes "/a/b/c") |
||
| 51 | * - Remove ".." and "." based on their meanings (e.g. "/a/./b/../c" becomes "/a/c") |
||
| 52 | * |
||
| 53 | * @param string $path the file/directory path to be normalized |
||
| 54 | * @param string $ds the directory separator to be used in the normalized result. Defaults to `DIRECTORY_SEPARATOR`. |
||
| 55 | * @return string the normalized file/directory path |
||
| 56 | */ |
||
| 57 | 34 | public static function normalizePath($path, $ds = DIRECTORY_SEPARATOR) |
|
| 81 | |||
| 82 | /** |
||
| 83 | * Returns the localized version of a specified file. |
||
| 84 | * |
||
| 85 | * The searching is based on the specified language code. In particular, |
||
| 86 | * a file with the same name will be looked for under the subdirectory |
||
| 87 | * whose name is the same as the language code. For example, given the file "path/to/view.php" |
||
| 88 | * and language code "zh-CN", the localized file will be looked for as |
||
| 89 | * "path/to/zh-CN/view.php". If the file is not found, it will try a fallback with just a language code that is |
||
| 90 | * "zh" i.e. "path/to/zh/view.php". If it is not found as well the original file will be returned. |
||
| 91 | * |
||
| 92 | * If the target and the source language codes are the same, |
||
| 93 | * the original file will be returned. |
||
| 94 | * |
||
| 95 | * @param string $file the original file |
||
| 96 | * @param string $language the target language that the file should be localized to. |
||
| 97 | * If not set, the value of [[\yii\base\Application::language]] will be used. |
||
| 98 | * @param string $sourceLanguage the language that the original file is in. |
||
| 99 | * If not set, the value of [[\yii\base\Application::sourceLanguage]] will be used. |
||
| 100 | * @return string the matching localized file, or the original file if the localized version is not found. |
||
| 101 | * If the target and the source language codes are the same, the original file will be returned. |
||
| 102 | */ |
||
| 103 | 75 | public static function localize($file, $language = null, $sourceLanguage = null) |
|
| 127 | |||
| 128 | /** |
||
| 129 | * Determines the MIME type of the specified file. |
||
| 130 | * This method will first try to determine the MIME type based on |
||
| 131 | * [finfo_open](http://php.net/manual/en/function.finfo-open.php). If the `fileinfo` extension is not installed, |
||
| 132 | * it will fall back to [[getMimeTypeByExtension()]] when `$checkExtension` is true. |
||
| 133 | * @param string $file the file name. |
||
| 134 | * @param string $magicFile name of the optional magic database file (or alias), usually something like `/path/to/magic.mime`. |
||
| 135 | * This will be passed as the second parameter to [finfo_open()](http://php.net/manual/en/function.finfo-open.php) |
||
| 136 | * when the `fileinfo` extension is installed. If the MIME type is being determined based via [[getMimeTypeByExtension()]] |
||
| 137 | * and this is null, it will use the file specified by [[mimeMagicFile]]. |
||
| 138 | * @param bool $checkExtension whether to use the file extension to determine the MIME type in case |
||
| 139 | * `finfo_open()` cannot determine it. |
||
| 140 | * @return string the MIME type (e.g. `text/plain`). Null is returned if the MIME type cannot be determined. |
||
| 141 | * @throws InvalidConfigException when the `fileinfo` PHP extension is not installed and `$checkExtension` is `false`. |
||
| 142 | */ |
||
| 143 | 25 | public static function getMimeType($file, $magicFile = null, $checkExtension = true) |
|
| 168 | |||
| 169 | /** |
||
| 170 | * Determines the MIME type based on the extension name of the specified file. |
||
| 171 | * This method will use a local map between extension names and MIME types. |
||
| 172 | * @param string $file the file name. |
||
| 173 | * @param string $magicFile the path (or alias) of the file that contains all available MIME type information. |
||
| 174 | * If this is not set, the file specified by [[mimeMagicFile]] will be used. |
||
| 175 | * @return string|null the MIME type. Null is returned if the MIME type cannot be determined. |
||
| 176 | */ |
||
| 177 | 8 | public static function getMimeTypeByExtension($file, $magicFile = null) |
|
| 190 | |||
| 191 | /** |
||
| 192 | * Determines the extensions by given MIME type. |
||
| 193 | * This method will use a local map between extension names and MIME types. |
||
| 194 | * @param string $mimeType file MIME type. |
||
| 195 | * @param string $magicFile the path (or alias) of the file that contains all available MIME type information. |
||
| 196 | * If this is not set, the file specified by [[mimeMagicFile]] will be used. |
||
| 197 | * @return array the extensions corresponding to the specified MIME type |
||
| 198 | */ |
||
| 199 | 12 | public static function getExtensionsByMimeType($mimeType, $magicFile = null) |
|
| 209 | |||
| 210 | private static $_mimeTypes = []; |
||
| 211 | |||
| 212 | /** |
||
| 213 | * Loads MIME types from the specified file. |
||
| 214 | * @param string $magicFile the path (or alias) of the file that contains all available MIME type information. |
||
| 215 | * If this is not set, the file specified by [[mimeMagicFile]] will be used. |
||
| 216 | * @return array the mapping from file extensions to MIME types |
||
| 217 | */ |
||
| 218 | 20 | protected static function loadMimeTypes($magicFile) |
|
| 230 | |||
| 231 | private static $_mimeAliases = []; |
||
| 232 | |||
| 233 | /** |
||
| 234 | * Loads MIME aliases from the specified file. |
||
| 235 | * @param string $aliasesFile the path (or alias) of the file that contains MIME type aliases. |
||
| 236 | * If this is not set, the file specified by [[mimeAliasesFile]] will be used. |
||
| 237 | * @return array the mapping from file extensions to MIME types |
||
| 238 | * @since 2.0.14 |
||
| 239 | */ |
||
| 240 | 12 | protected static function loadMimeAliases($aliasesFile) |
|
| 252 | |||
| 253 | /** |
||
| 254 | * Copies a whole directory as another one. |
||
| 255 | * The files and sub-directories will also be copied over. |
||
| 256 | * @param string $src the source directory |
||
| 257 | * @param string $dst the destination directory |
||
| 258 | * @param array $options options for directory copy. Valid options are: |
||
| 259 | * |
||
| 260 | * - dirMode: integer, the permission to be set for newly copied directories. Defaults to 0775. |
||
| 261 | * - fileMode: integer, the permission to be set for newly copied files. Defaults to the current environment setting. |
||
| 262 | * - filter: callback, a PHP callback that is called for each directory or file. |
||
| 263 | * The signature of the callback should be: `function ($path)`, where `$path` refers the full path to be filtered. |
||
| 264 | * The callback can return one of the following values: |
||
| 265 | * |
||
| 266 | * * true: the directory or file will be copied (the "only" and "except" options will be ignored) |
||
| 267 | * * false: the directory or file will NOT be copied (the "only" and "except" options will be ignored) |
||
| 268 | * * null: the "only" and "except" options will determine whether the directory or file should be copied |
||
| 269 | * |
||
| 270 | * - only: array, list of patterns that the file paths should match if they want to be copied. |
||
| 271 | * A path matches a pattern if it contains the pattern string at its end. |
||
| 272 | * For example, '.php' matches all file paths ending with '.php'. |
||
| 273 | * Note, the '/' characters in a pattern matches both '/' and '\' in the paths. |
||
| 274 | * If a file path matches a pattern in both "only" and "except", it will NOT be copied. |
||
| 275 | * - except: array, list of patterns that the files or directories should match if they want to be excluded from being copied. |
||
| 276 | * A path matches a pattern if it contains the pattern string at its end. |
||
| 277 | * Patterns ending with '/' apply to directory paths only, and patterns not ending with '/' |
||
| 278 | * apply to file paths only. For example, '/a/b' matches all file paths ending with '/a/b'; |
||
| 279 | * and '.svn/' matches directory paths ending with '.svn'. Note, the '/' characters in a pattern matches |
||
| 280 | * both '/' and '\' in the paths. |
||
| 281 | * - caseSensitive: boolean, whether patterns specified at "only" or "except" should be case sensitive. Defaults to true. |
||
| 282 | * - recursive: boolean, whether the files under the subdirectories should also be copied. Defaults to true. |
||
| 283 | * - beforeCopy: callback, a PHP callback that is called before copying each sub-directory or file. |
||
| 284 | * If the callback returns false, the copy operation for the sub-directory or file will be cancelled. |
||
| 285 | * The signature of the callback should be: `function ($from, $to)`, where `$from` is the sub-directory or |
||
| 286 | * file to be copied from, while `$to` is the copy target. |
||
| 287 | * - afterCopy: callback, a PHP callback that is called after each sub-directory or file is successfully copied. |
||
| 288 | * The signature of the callback should be: `function ($from, $to)`, where `$from` is the sub-directory or |
||
| 289 | * file copied from, while `$to` is the copy target. |
||
| 290 | * - copyEmptyDirectories: boolean, whether to copy empty directories. Set this to false to avoid creating directories |
||
| 291 | * that do not contain files. This affects directories that do not contain files initially as well as directories that |
||
| 292 | * do not contain files at the target destination because files have been filtered via `only` or `except`. |
||
| 293 | * Defaults to true. This option is available since version 2.0.12. Before 2.0.12 empty directories are always copied. |
||
| 294 | * @throws InvalidArgumentException if unable to open directory |
||
| 295 | */ |
||
| 296 | 17 | public static function copyDirectory($src, $dst, $options = []) |
|
| 352 | |||
| 353 | /** |
||
| 354 | * Removes a directory (and all its content) recursively. |
||
| 355 | * |
||
| 356 | * @param string $dir the directory to be deleted recursively. |
||
| 357 | * @param array $options options for directory remove. Valid options are: |
||
| 358 | * |
||
| 359 | * - traverseSymlinks: boolean, whether symlinks to the directories should be traversed too. |
||
| 360 | * Defaults to `false`, meaning the content of the symlinked directory would not be deleted. |
||
| 361 | * Only symlink would be removed in that default case. |
||
| 362 | * |
||
| 363 | * @throws ErrorException in case of failure |
||
| 364 | */ |
||
| 365 | 122 | public static function removeDirectory($dir, $options = []) |
|
| 366 | { |
||
| 367 | 122 | if (!is_dir($dir)) { |
|
| 368 | 31 | return; |
|
| 369 | } |
||
| 370 | 120 | if (!empty($options['traverseSymlinks']) || !is_link($dir)) { |
|
| 371 | 120 | if (!($handle = opendir($dir))) { |
|
| 372 | return; |
||
| 373 | } |
||
| 374 | 120 | while (($file = readdir($handle)) !== false) { |
|
| 375 | 120 | if ($file === '.' || $file === '..') { |
|
| 376 | 120 | continue; |
|
| 377 | } |
||
| 378 | 102 | $path = $dir . DIRECTORY_SEPARATOR . $file; |
|
| 379 | 102 | if (is_dir($path)) { |
|
| 380 | 57 | static::removeDirectory($path, $options); |
|
| 381 | } else { |
||
| 382 | 83 | static::unlink($path); |
|
| 383 | } |
||
| 384 | } |
||
| 385 | 120 | closedir($handle); |
|
| 386 | } |
||
| 387 | 120 | if (is_link($dir)) { |
|
| 388 | 2 | static::unlink($dir); |
|
| 389 | } else { |
||
| 390 | 120 | rmdir($dir); |
|
| 391 | } |
||
| 392 | 120 | } |
|
| 393 | |||
| 394 | /** |
||
| 395 | * Removes a file or symlink in a cross-platform way |
||
| 396 | * |
||
| 397 | * @param string $path |
||
| 398 | * @return bool |
||
| 399 | * |
||
| 400 | * @since 2.0.14 |
||
| 401 | */ |
||
| 402 | 84 | public static function unlink($path) |
|
| 423 | |||
| 424 | /** |
||
| 425 | * Returns the files found under the specified directory and subdirectories. |
||
| 426 | * @param string $dir the directory under which the files will be looked for. |
||
| 427 | * @param array $options options for file searching. Valid options are: |
||
| 428 | * |
||
| 429 | * - `filter`: callback, a PHP callback that is called for each directory or file. |
||
| 430 | * The signature of the callback should be: `function ($path)`, where `$path` refers the full path to be filtered. |
||
| 431 | * The callback can return one of the following values: |
||
| 432 | * |
||
| 433 | * * `true`: the directory or file will be returned (the `only` and `except` options will be ignored) |
||
| 434 | * * `false`: the directory or file will NOT be returned (the `only` and `except` options will be ignored) |
||
| 435 | * * `null`: the `only` and `except` options will determine whether the directory or file should be returned |
||
| 436 | * |
||
| 437 | * - `except`: array, list of patterns excluding from the results matching file or directory paths. |
||
| 438 | * Patterns ending with slash ('/') apply to directory paths only, and patterns not ending with '/' |
||
| 439 | * apply to file paths only. For example, '/a/b' matches all file paths ending with '/a/b'; |
||
| 440 | * and `.svn/` matches directory paths ending with `.svn`. |
||
| 441 | * If the pattern does not contain a slash (`/`), it is treated as a shell glob pattern |
||
| 442 | * and checked for a match against the pathname relative to `$dir`. |
||
| 443 | * Otherwise, the pattern is treated as a shell glob suitable for consumption by `fnmatch(3)` |
||
| 444 | * with the `FNM_PATHNAME` flag: wildcards in the pattern will not match a `/` in the pathname. |
||
| 445 | * For example, `views/*.php` matches `views/index.php` but not `views/controller/index.php`. |
||
| 446 | * A leading slash matches the beginning of the pathname. For example, `/*.php` matches `index.php` but not `views/start/index.php`. |
||
| 447 | * An optional prefix `!` which negates the pattern; any matching file excluded by a previous pattern will become included again. |
||
| 448 | * If a negated pattern matches, this will override lower precedence patterns sources. Put a backslash (`\`) in front of the first `!` |
||
| 449 | * for patterns that begin with a literal `!`, for example, `\!important!.txt`. |
||
| 450 | * Note, the '/' characters in a pattern matches both '/' and '\' in the paths. |
||
| 451 | * - `only`: array, list of patterns that the file paths should match if they are to be returned. Directory paths |
||
| 452 | * are not checked against them. Same pattern matching rules as in the `except` option are used. |
||
| 453 | * If a file path matches a pattern in both `only` and `except`, it will NOT be returned. |
||
| 454 | * - `caseSensitive`: boolean, whether patterns specified at `only` or `except` should be case sensitive. Defaults to `true`. |
||
| 455 | * - `recursive`: boolean, whether the files under the subdirectories should also be looked for. Defaults to `true`. |
||
| 456 | * @return array files found under the directory, in no particular order. Ordering depends on the files system used. |
||
| 457 | * @throws InvalidArgumentException if the dir is invalid. |
||
| 458 | */ |
||
| 459 | 71 | public static function findFiles($dir, $options = []) |
|
| 482 | |||
| 483 | /** |
||
| 484 | * Returns the directories found under the specified directory and subdirectories. |
||
| 485 | * @param string $dir the directory under which the files will be looked for. |
||
| 486 | * @param array $options options for directory searching. Valid options are: |
||
| 487 | * |
||
| 488 | * - `filter`: callback, a PHP callback that is called for each directory or file. |
||
| 489 | * The signature of the callback should be: `function ($path)`, where `$path` refers the full path to be filtered. |
||
| 490 | * The callback can return one of the following values: |
||
| 491 | * |
||
| 492 | * * `true`: the directory will be returned |
||
| 493 | * * `false`: the directory will NOT be returned |
||
| 494 | * |
||
| 495 | * - `recursive`: boolean, whether the files under the subdirectories should also be looked for. Defaults to `true`. |
||
| 496 | * @return array directories found under the directory, in no particular order. Ordering depends on the files system used. |
||
| 497 | * @throws InvalidArgumentException if the dir is invalid. |
||
| 498 | * @since 2.0.14 |
||
| 499 | */ |
||
| 500 | 1 | public static function findDirectories($dir, $options = []) |
|
| 522 | |||
| 523 | /* |
||
| 524 | * @param string $dir |
||
| 525 | */ |
||
| 526 | 72 | private static function setBasePath($dir, $options) |
|
| 536 | |||
| 537 | /* |
||
| 538 | * @param string $dir |
||
| 539 | */ |
||
| 540 | 72 | private static function openDir($dir) |
|
| 548 | |||
| 549 | /* |
||
| 550 | * @param string $dir |
||
| 551 | */ |
||
| 552 | 72 | private static function clearDir($dir) |
|
| 559 | |||
| 560 | /** |
||
| 561 | * Checks if the given file path satisfies the filtering options. |
||
| 562 | * @param string $path the path of the file or directory to be checked |
||
| 563 | * @param array $options the filtering options. See [[findFiles()]] for explanations of |
||
| 564 | * the supported options. |
||
| 565 | * @return bool whether the file or directory satisfies the filtering options. |
||
| 566 | */ |
||
| 567 | 81 | public static function filterPath($path, $options) |
|
| 599 | |||
| 600 | /** |
||
| 601 | * Creates a new directory. |
||
| 602 | * |
||
| 603 | * This method is similar to the PHP `mkdir()` function except that |
||
| 604 | * it uses `chmod()` to set the permission of the created directory |
||
| 605 | * in order to avoid the impact of the `umask` setting. |
||
| 606 | * |
||
| 607 | * @param string $path path of the directory to be created. |
||
| 608 | * @param int $mode the permission to be set for the created directory. |
||
| 609 | * @param bool $recursive whether to create parent directories if they do not exist. |
||
| 610 | * @return bool whether the directory is created successfully |
||
| 611 | * @throws \yii\base\Exception if the directory could not be created (i.e. php error due to parallel changes) |
||
| 612 | */ |
||
| 613 | 169 | public static function createDirectory($path, $mode = 0775, $recursive = true) |
|
| 638 | |||
| 639 | /** |
||
| 640 | * Performs a simple comparison of file or directory names. |
||
| 641 | * |
||
| 642 | * Based on match_basename() from dir.c of git 1.8.5.3 sources. |
||
| 643 | * |
||
| 644 | * @param string $baseName file or directory name to compare with the pattern |
||
| 645 | * @param string $pattern the pattern that $baseName will be compared against |
||
| 646 | * @param int|bool $firstWildcard location of first wildcard character in the $pattern |
||
| 647 | * @param int $flags pattern flags |
||
| 648 | * @return bool whether the name matches against pattern |
||
| 649 | */ |
||
| 650 | 60 | private static function matchBasename($baseName, $pattern, $firstWildcard, $flags) |
|
| 671 | |||
| 672 | /** |
||
| 673 | * Compares a path part against a pattern with optional wildcards. |
||
| 674 | * |
||
| 675 | * Based on match_pathname() from dir.c of git 1.8.5.3 sources. |
||
| 676 | * |
||
| 677 | * @param string $path full path to compare |
||
| 678 | * @param string $basePath base of path that will not be compared |
||
| 679 | * @param string $pattern the pattern that path part will be compared against |
||
| 680 | * @param int|bool $firstWildcard location of first wildcard character in the $pattern |
||
| 681 | * @param int $flags pattern flags |
||
| 682 | * @return bool whether the path part matches against pattern |
||
| 683 | */ |
||
| 684 | 43 | private static function matchPathname($path, $basePath, $pattern, $firstWildcard, $flags) |
|
| 727 | |||
| 728 | /** |
||
| 729 | * Scan the given exclude list in reverse to see whether pathname |
||
| 730 | * should be ignored. The first match (i.e. the last on the list), if |
||
| 731 | * any, determines the fate. Returns the element which |
||
| 732 | * matched, or null for undecided. |
||
| 733 | * |
||
| 734 | * Based on last_exclude_matching_from_list() from dir.c of git 1.8.5.3 sources. |
||
| 735 | * |
||
| 736 | * @param string $basePath |
||
| 737 | * @param string $path |
||
| 738 | * @param array $excludes list of patterns to match $path against |
||
| 739 | * @return array|null null or one of $excludes item as an array with keys: 'pattern', 'flags' |
||
| 740 | * @throws InvalidArgumentException if any of the exclude patterns is not a string or an array with keys: pattern, flags, firstWildcard. |
||
| 741 | */ |
||
| 742 | 61 | private static function lastExcludeMatchingFromList($basePath, $path, $excludes) |
|
| 769 | |||
| 770 | /** |
||
| 771 | * Processes the pattern, stripping special characters like / and ! from the beginning and settings flags instead. |
||
| 772 | * @param string $pattern |
||
| 773 | * @param bool $caseSensitive |
||
| 774 | * @throws InvalidArgumentException |
||
| 775 | * @return array with keys: (string) pattern, (int) flags, (int|bool) firstWildcard |
||
| 776 | */ |
||
| 777 | 61 | private static function parseExcludePattern($pattern, $caseSensitive) |
|
| 816 | |||
| 817 | /** |
||
| 818 | * Searches for the first wildcard character in the pattern. |
||
| 819 | * @param string $pattern the pattern to search in |
||
| 820 | * @return int|bool position of first wildcard character or false if not found |
||
| 821 | */ |
||
| 822 | 61 | private static function firstWildcardInPattern($pattern) |
|
| 833 | |||
| 834 | /** |
||
| 835 | * @param array $options raw options |
||
| 836 | * @return array normalized options |
||
| 837 | * @since 2.0.12 |
||
| 838 | */ |
||
| 839 | 83 | protected static function normalizeOptions(array $options) |
|
| 861 | } |
||
| 862 |
Loading history...
If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check:
If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue.