%PDF-
%PDF-
Mini Shell
Mini Shell
<?php
/**
* This file is part of the Nette Framework (https://nette.org)
* Copyright (c) 2004 David Grudl (https://davidgrudl.com)
*/
declare (strict_types=1);
namespace RectorPrefix202411\Nette\Utils;
use RectorPrefix202411\Nette;
/**
* Finder allows searching through directory trees using iterator.
*
* Finder::findFiles('*.php')
* ->size('> 10kB')
* ->from('.')
* ->exclude('temp');
*
* @implements \IteratorAggregate<string, FileInfo>
*/
class Finder implements \IteratorAggregate
{
use Nette\SmartObject;
/** @var array<array{string, string}> */
private $find = [];
/** @var string[] */
private $in = [];
/** @var \Closure[] */
private $filters = [];
/** @var \Closure[] */
private $descentFilters = [];
/** @var array<string|self> */
private $appends = [];
/**
* @var bool
*/
private $childFirst = \false;
/** @var ?callable */
private $sort;
/**
* @var int
*/
private $maxDepth = -1;
/**
* @var bool
*/
private $ignoreUnreadableDirs = \true;
/**
* Begins search for files and directories matching mask.
* @param string|mixed[] $masks
* @return static
*/
public static function find($masks = ['*'])
{
$masks = \is_array($masks) ? $masks : \func_get_args();
// compatibility with variadic
return (new static())->addMask($masks, 'dir')->addMask($masks, 'file');
}
/**
* Begins search for files matching mask.
* @param string|mixed[] $masks
* @return static
*/
public static function findFiles($masks = ['*'])
{
$masks = \is_array($masks) ? $masks : \func_get_args();
// compatibility with variadic
return (new static())->addMask($masks, 'file');
}
/**
* Begins search for directories matching mask.
* @param string|mixed[] $masks
* @return static
*/
public static function findDirectories($masks = ['*'])
{
$masks = \is_array($masks) ? $masks : \func_get_args();
// compatibility with variadic
return (new static())->addMask($masks, 'dir');
}
/**
* Finds files matching the specified masks.
* @param string|mixed[] $masks
* @return static
*/
public function files($masks = ['*'])
{
return $this->addMask((array) $masks, 'file');
}
/**
* Finds directories matching the specified masks.
* @param string|mixed[] $masks
* @return static
*/
public function directories($masks = ['*'])
{
return $this->addMask((array) $masks, 'dir');
}
/**
* @return static
*/
private function addMask(array $masks, string $mode)
{
foreach ($masks as $mask) {
$mask = FileSystem::unixSlashes($mask);
if ($mode === 'dir') {
$mask = \rtrim($mask, '/');
}
if ($mask === '' || $mode === 'file' && \substr_compare($mask, '/', -\strlen('/')) === 0) {
throw new Nette\InvalidArgumentException("Invalid mask '{$mask}'");
}
if (\strncmp($mask, '**/', \strlen('**/')) === 0) {
$mask = \substr($mask, 3);
}
$this->find[] = [$mask, $mode];
}
return $this;
}
/**
* Searches in the given directories. Wildcards are allowed.
* @param string|mixed[] $paths
* @return static
*/
public function in($paths)
{
$paths = \is_array($paths) ? $paths : \func_get_args();
// compatibility with variadic
$this->addLocation($paths, '');
return $this;
}
/**
* Searches recursively from the given directories. Wildcards are allowed.
* @param string|mixed[] $paths
* @return static
*/
public function from($paths)
{
$paths = \is_array($paths) ? $paths : \func_get_args();
// compatibility with variadic
$this->addLocation($paths, '/**');
return $this;
}
private function addLocation(array $paths, string $ext) : void
{
foreach ($paths as $path) {
if ($path === '') {
throw new Nette\InvalidArgumentException("Invalid directory '{$path}'");
}
$path = \rtrim(FileSystem::unixSlashes($path), '/');
$this->in[] = $path . $ext;
}
}
/**
* Lists directory's contents before the directory itself. By default, this is disabled.
* @return static
*/
public function childFirst(bool $state = \true)
{
$this->childFirst = $state;
return $this;
}
/**
* Ignores unreadable directories. By default, this is enabled.
* @return static
*/
public function ignoreUnreadableDirs(bool $state = \true)
{
$this->ignoreUnreadableDirs = $state;
return $this;
}
/**
* Set a compare function for sorting directory entries. The function will be called to sort entries from the same directory.
* @param callable(FileInfo, FileInfo): int $callback
* @return static
*/
public function sortBy(callable $callback)
{
$this->sort = $callback;
return $this;
}
/**
* Sorts files in each directory naturally by name.
* @return static
*/
public function sortByName()
{
$this->sort = function (FileInfo $a, FileInfo $b) : int {
return \strnatcmp($a->getBasename(), $b->getBasename());
};
return $this;
}
/**
* Adds the specified paths or appends a new finder that returns.
* @param string|mixed[]|null $paths
* @return static
*/
public function append($paths = null)
{
if ($paths === null) {
return $this->appends[] = new static();
}
$this->appends = \array_merge($this->appends, (array) $paths);
return $this;
}
/********************* filtering ****************d*g**/
/**
* Skips entries that matches the given masks relative to the ones defined with the in() or from() methods.
* @param string|mixed[] $masks
* @return static
*/
public function exclude($masks)
{
$masks = \is_array($masks) ? $masks : \func_get_args();
// compatibility with variadic
foreach ($masks as $mask) {
$mask = FileSystem::unixSlashes($mask);
if (!\preg_match('~^/?(\\*\\*/)?(.+)(/\\*\\*|/\\*|/|)$~D', $mask, $m)) {
throw new Nette\InvalidArgumentException("Invalid mask '{$mask}'");
}
$end = $m[3];
$re = $this->buildPattern($m[2]);
$filter = function (FileInfo $file) use($end, $re) : bool {
return $end && !$file->isDir() || !\preg_match($re, FileSystem::unixSlashes($file->getRelativePathname()));
};
$this->descentFilter($filter);
if ($end !== '/*') {
$this->filter($filter);
}
}
return $this;
}
/**
* Yields only entries which satisfy the given filter.
* @param callable(FileInfo): bool $callback
* @return static
*/
public function filter(callable $callback)
{
$this->filters[] = \Closure::fromCallable($callback);
return $this;
}
/**
* It descends only to directories that match the specified filter.
* @param callable(FileInfo): bool $callback
* @return static
*/
public function descentFilter(callable $callback)
{
$this->descentFilters[] = \Closure::fromCallable($callback);
return $this;
}
/**
* Sets the maximum depth of entries.
* @return static
*/
public function limitDepth(?int $depth)
{
$this->maxDepth = $depth ?? -1;
return $this;
}
/**
* Restricts the search by size. $operator accepts "[operator] [size] [unit]" example: >=10kB
* @return static
*/
public function size(string $operator, ?int $size = null)
{
if (\func_num_args() === 1) {
// in $operator is predicate
if (!\preg_match('#^(?:([=<>!]=?|<>)\\s*)?((?:\\d*\\.)?\\d+)\\s*(K|M|G|)B?$#Di', $operator, $matches)) {
throw new Nette\InvalidArgumentException('Invalid size predicate format.');
}
[, $operator, $size, $unit] = $matches;
$units = ['' => 1, 'k' => 1000.0, 'm' => 1000000.0, 'g' => 1000000000.0];
$size *= $units[\strtolower($unit)];
$operator = $operator ?: '=';
}
return $this->filter(function (FileInfo $file) use($operator, $size) : bool {
return !$file->isFile() || Helpers::compare($file->getSize(), $operator, $size);
});
}
/**
* Restricts the search by modified time. $operator accepts "[operator] [date]" example: >1978-01-23
* @param string|int|\DateTimeInterface|null $date
* @return static
*/
public function date(string $operator, $date = null)
{
if (\func_num_args() === 1) {
// in $operator is predicate
if (!\preg_match('#^(?:([=<>!]=?|<>)\\s*)?(.+)$#Di', $operator, $matches)) {
throw new Nette\InvalidArgumentException('Invalid date predicate format.');
}
[, $operator, $date] = $matches;
$operator = $operator ?: '=';
}
$date = DateTime::from($date)->format('U');
return $this->filter(function (FileInfo $file) use($operator, $date) : bool {
return !$file->isFile() || Helpers::compare($file->getMTime(), $operator, $date);
});
}
/********************* iterator generator ****************d*g**/
/**
* Returns an array with all found files and directories.
* @return list<FileInfo>
*/
public function collect() : array
{
return \iterator_to_array($this->getIterator(), \false);
}
/** @return \Generator<string, FileInfo> */
public function getIterator() : \Generator
{
$plan = $this->buildPlan();
foreach ($plan as $dir => $searches) {
yield from $this->traverseDir($dir, $searches);
}
foreach ($this->appends as $item) {
if ($item instanceof self) {
yield from $item->getIterator();
} else {
$item = FileSystem::platformSlashes($item);
(yield $item => new FileInfo($item));
}
}
}
/**
* @param array<object{pattern: string, mode: string, recursive: bool}> $searches
* @param string[] $subdirs
* @return \Generator<string, FileInfo>
*/
private function traverseDir(string $dir, array $searches, array $subdirs = []) : \Generator
{
if ($this->maxDepth >= 0 && \count($subdirs) > $this->maxDepth) {
return;
} elseif (!\is_dir($dir)) {
throw new Nette\InvalidStateException(\sprintf("Directory '%s' does not exist.", \rtrim($dir, '/\\')));
}
try {
$pathNames = new \FilesystemIterator($dir, \FilesystemIterator::FOLLOW_SYMLINKS | \FilesystemIterator::SKIP_DOTS | \FilesystemIterator::CURRENT_AS_PATHNAME | \FilesystemIterator::UNIX_PATHS);
} catch (\UnexpectedValueException $e) {
if ($this->ignoreUnreadableDirs) {
return;
} else {
throw new Nette\InvalidStateException($e->getMessage());
}
}
$files = $this->convertToFiles($pathNames, \implode('/', $subdirs), FileSystem::isAbsolute($dir));
if ($this->sort) {
$files = \iterator_to_array($files);
\usort($files, $this->sort);
}
foreach ($files as $file) {
$pathName = $file->getPathname();
$cache = $subSearch = [];
if ($file->isDir()) {
foreach ($searches as $search) {
if ($search->recursive && $this->proveFilters($this->descentFilters, $file, $cache)) {
$subSearch[] = $search;
}
}
}
if ($this->childFirst && $subSearch) {
yield from $this->traverseDir($pathName, $subSearch, \array_merge($subdirs, [$file->getBasename()]));
}
$relativePathname = FileSystem::unixSlashes($file->getRelativePathname());
foreach ($searches as $search) {
if ($file->{'is' . $search->mode}() && \preg_match($search->pattern, $relativePathname) && $this->proveFilters($this->filters, $file, $cache)) {
(yield $pathName => $file);
break;
}
}
if (!$this->childFirst && $subSearch) {
yield from $this->traverseDir($pathName, $subSearch, \array_merge($subdirs, [$file->getBasename()]));
}
}
}
private function convertToFiles(iterable $pathNames, string $relativePath, bool $absolute) : \Generator
{
foreach ($pathNames as $pathName) {
if (!$absolute) {
$pathName = \preg_replace('~\\.?/~A', '', $pathName);
}
$pathName = FileSystem::platformSlashes($pathName);
(yield new FileInfo($pathName, $relativePath));
}
}
private function proveFilters(array $filters, FileInfo $file, array &$cache) : bool
{
foreach ($filters as $filter) {
$res =& $cache[\spl_object_id($filter)];
$res = $res ?? $filter($file);
if (!$res) {
return \false;
}
}
return \true;
}
/** @return array<string, array<object{pattern: string, mode: string, recursive: bool}>> */
private function buildPlan() : array
{
$plan = $dirCache = [];
foreach ($this->find as [$mask, $mode]) {
$splits = [];
if (FileSystem::isAbsolute($mask)) {
if ($this->in) {
throw new Nette\InvalidStateException("You cannot combine the absolute path in the mask '{$mask}' and the directory to search '{$this->in[0]}'.");
}
$splits[] = self::splitRecursivePart($mask);
} else {
foreach ($this->in ?: ['.'] as $in) {
$in = \strtr($in, ['[' => '[[]', ']' => '[]]']);
// in path, do not treat [ and ] as a pattern by glob()
$splits[] = self::splitRecursivePart($in . '/' . $mask);
}
}
foreach ($splits as [$base, $rest, $recursive]) {
$base = $base === '' ? '.' : $base;
$dirs = $dirCache[$base] = $dirCache[$base] ?? (\strpbrk($base, '*?[') ? \glob($base, \GLOB_NOSORT | \GLOB_ONLYDIR | \GLOB_NOESCAPE) : [\strtr($base, ['[[]' => '[', '[]]' => ']'])]);
// unescape [ and ]
if (!$dirs) {
throw new Nette\InvalidStateException(\sprintf("Directory '%s' does not exist.", \rtrim($base, '/\\')));
}
$search = (object) ['pattern' => $this->buildPattern($rest), 'mode' => $mode, 'recursive' => $recursive];
foreach ($dirs as $dir) {
$plan[$dir][] = $search;
}
}
}
return $plan;
}
/**
* Since glob() does not know ** wildcard, we divide the path into a part for glob and a part for manual traversal.
*/
private static function splitRecursivePart(string $path) : array
{
$a = \strrpos($path, '/');
$parts = \preg_split('~(?<=^|/)\\*\\*($|/)~', \substr($path, 0, $a + 1), 2);
return isset($parts[1]) ? [$parts[0], $parts[1] . \substr($path, $a + 1), \true] : [$parts[0], \substr($path, $a + 1), \false];
}
/**
* Converts wildcards to regular expression.
*/
private function buildPattern(string $mask) : string
{
if ($mask === '*') {
return '##';
} elseif (\strncmp($mask, './', \strlen('./')) === 0) {
$anchor = '^';
$mask = \substr($mask, 2);
} else {
$anchor = '(?:^|/)';
}
$pattern = \strtr(\preg_quote($mask, '#'), ['\\*\\*/' => '(.+/)?', '\\*' => '[^/]*', '\\?' => '[^/]', '\\[\\!' => '[^', '\\[' => '[', '\\]' => ']', '\\-' => '-']);
return '#' . $anchor . $pattern . '$#D' . (\defined('PHP_WINDOWS_VERSION_BUILD') ? 'i' : '');
}
}
Zerion Mini Shell 1.0