ACIL FM

Nama	Ukuran	Aksi
ArrayHash.php	2.18 MB	View DL Edit
ArrayList.php	3.08 MB	View DL Edit
Arrays.php	16.38 MB	View DL Edit
Callback.php	4.18 MB	View DL Edit
DateTime.php	3.26 MB	View DL Edit
exceptions.php	784 B	View DL Edit
FileInfo.php	1.44 MB	View DL Edit
FileSystem.php	10.3 MB	View DL Edit
Finder.php	16.15 MB	View DL Edit
Floats.php	2.36 MB	View DL Edit
Helpers.php	3.33 MB	View DL Edit
Html.php	21.89 MB	View DL Edit
Image.php	27.78 MB	View DL Edit
ImageColor.php	2.03 MB	View DL Edit
ImageType.php	415 B	View DL Edit
Iterables.php	7.05 MB	View DL Edit
Json.php	2.5 MB	View DL Edit
ObjectHelpers.php	7.9 MB	View DL Edit
Paginator.php	4.98 MB	View DL Edit
Random.php	1.38 MB	View DL Edit
Reflection.php	10.49 MB	View DL Edit
ReflectionMethod.php	968 B	View DL Edit
Strings.php	25.85 MB	View DL Edit
Type.php	7.46 MB	View DL Edit
Validators.php	12.23 MB	View DL Edit

Edit file: /opt/cpanel/ea-wappspector/vendor/rector/rector/vendor/nette/utils/src/Utils/Finder.php

<?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' : '');
    }
}

Batal