OwlCyberSecurity - MANAGER

Edit File: FileFinder.php

<?php

/**
 * Hoa
 *
 *
 * @license
 *
 * New BSD License
 *
 * Copyright © 2007-2017, Hoa community. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Hoa nor the names of its contributors may be
 *       used to endorse or promote products derived from this software without
 *       specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

namespace Psy\Readline\Hoa;

/**
 * Class \Hoa\File\Finder.
 *
 * This class allows to find files easily by using filters and flags.
 */
class FileFinder implements \IteratorAggregate
{
    /**
     * SplFileInfo classname.
     */
    protected $_splFileInfo = \SplFileInfo::class;

/**
     * Paths where to look for.
     */
    protected $_paths = [];

/**
     * Max depth in recursion.
     */
    protected $_maxDepth = -1;

/**
     * Filters.
     */
    protected $_filters = [];

/**
     * Flags.
     */
    protected $_flags = -1;

/**
     * Types of files to handle.
     */
    protected $_types = [];

/**
     * What comes first: parent or child?
     */
    protected $_first = -1;

/**
     * Sorts.
     */
    protected $_sorts = [];

/**
     * Initialize.
     */
    public function __construct()
    {
        $this->_flags = IteratorFileSystem::KEY_AS_PATHNAME
                        | IteratorFileSystem::CURRENT_AS_FILEINFO
                        | IteratorFileSystem::SKIP_DOTS;
        $this->_first = \RecursiveIteratorIterator::SELF_FIRST;

return;
    }

/**
     * Select a directory to scan.
     */
    public function in($paths): self
    {
        if (!\is_array($paths)) {
            $paths = [$paths];
        }

foreach ($paths as $path) {
            if (1 === \preg_match('/[\*\?\[\]]/', $path)) {
                $iterator = new \CallbackFilterIterator(
                    new \GlobIterator(\rtrim($path, \DIRECTORY_SEPARATOR)),
                    function ($current) {
                        return $current->isDir();
                    }
                );

foreach ($iterator as $fileInfo) {
                    $this->_paths[] = $fileInfo->getPathname();
                }
            } else {
                $this->_paths[] = $path;
            }
        }

return $this;
    }

/**
     * Set max depth for recursion.
     */
    public function maxDepth(int $depth): self
    {
        $this->_maxDepth = $depth;

return $this;
    }

/**
     * Include files in the result.
     */
    public function files(): self
    {
        $this->_types[] = 'file';

return $this;
    }

/**
     * Include directories in the result.
     */
    public function directories(): self
    {
        $this->_types[] = 'dir';

return $this;
    }

/**
     * Include links in the result.
     */
    public function links(): self
    {
        $this->_types[] = 'link';

return $this;
    }

/**
     * Follow symbolink links.
     */
    public function followSymlinks(bool $flag = true): self
    {
        if (true === $flag) {
            $this->_flags ^= IteratorFileSystem::FOLLOW_SYMLINKS;
        } else {
            $this->_flags |= IteratorFileSystem::FOLLOW_SYMLINKS;
        }

return $this;
    }

/**
     * Include files that match a regex.
     * Example:
     *     $this->name('#\.php$#');.
     */
    public function name(string $regex): self
    {
        $this->_filters[] = function (\SplFileInfo $current) use ($regex) {
            return 0 !== \preg_match($regex, $current->getBasename());
        };

return $this;
    }

/**
     * Exclude directories that match a regex.
     * Example:
     *      $this->notIn('#^\.(git|hg)$#');.
     */
    public function notIn(string $regex): self
    {
        $this->_filters[] = function (\SplFileInfo $current) use ($regex) {
            foreach (\explode(\DIRECTORY_SEPARATOR, $current->getPathname()) as $part) {
                if (0 !== \preg_match($regex, $part)) {
                    return false;
                }
            }

return true;
        };

return $this;
    }

/**
     * Include files that respect a certain size.
     * The size is a string of the form:
     *     operator number unit
     * where
     *     • operator could be: <, <=, >, >= or =;
     *     • number is a positive integer;
     *     • unit could be: b (default), Kb, Mb, Gb, Tb, Pb, Eb, Zb, Yb.
     * Example:
     *     $this->size('>= 12Kb');.
     */
    public function size(string $size): self
    {
        if (0 === \preg_match('#^(<|<=|>|>=|=)\s*(\d+)\s*((?:[KMGTPEZY])b)?$#', $size, $matches)) {
            return $this;
        }

$number = (float) ($matches[2]);
        $unit = $matches[3] ?? 'b';
        $operator = $matches[1];

switch ($unit) {
            case 'b':
                break;

// kilo
            case 'Kb':
                $number <<= 10;

break;

// mega.
            case 'Mb':
                $number <<= 20;

break;

// giga.
            case 'Gb':
                $number <<= 30;

break;

// tera.
            case 'Tb':
                $number *= 1099511627776;

break;

// peta.
            case 'Pb':
                $number *= 1024 ** 5;

break;

// exa.
            case 'Eb':
                $number *= 1024 ** 6;

break;

// zetta.
            case 'Zb':
                $number *= 1024 ** 7;

break;

// yota.
            case 'Yb':
                $number *= 1024 ** 8;

break;
        }

$filter = null;

switch ($operator) {
            case '<':
                $filter = function (\SplFileInfo $current) use ($number) {
                    return $current->getSize() < $number;
                };

break;

case '<=':
                $filter = function (\SplFileInfo $current) use ($number) {
                    return $current->getSize() <= $number;
                };

break;

case '>':
                $filter = function (\SplFileInfo $current) use ($number) {
                    return $current->getSize() > $number;
                };

break;

case '>=':
                $filter = function (\SplFileInfo $current) use ($number) {
                    return $current->getSize() >= $number;
                };

break;

case '=':
                $filter = function (\SplFileInfo $current) use ($number) {
                    return $current->getSize() === $number;
                };

break;
        }

$this->_filters[] = $filter;

return $this;
    }

/**
     * Whether we should include dots or not (respectively . and ..).
     */
    public function dots(bool $flag = true): self
    {
        if (true === $flag) {
            $this->_flags ^= IteratorFileSystem::SKIP_DOTS;
        } else {
            $this->_flags |= IteratorFileSystem::SKIP_DOTS;
        }

return $this;
    }

/**
     * Include files that are owned by a certain owner.
     */
    public function owner(int $owner): self
    {
        $this->_filters[] = function (\SplFileInfo $current) use ($owner) {
            return $current->getOwner() === $owner;
        };

return $this;
    }

/**
     * Format date.
     * Date can have the following syntax:
     *     date
     *     since date
     *     until date
     * If the date does not have the “ago” keyword, it will be added.
     * Example: “42 hours” is equivalent to “since 42 hours” which is equivalent
     * to “since 42 hours ago”.
     */
    protected function formatDate(string $date, &$operator): int
    {
        $operator = -1;

if (0 === \preg_match('#\bago\b#', $date)) {
            $date .= ' ago';
        }

if (0 !== \preg_match('#^(since|until)\b(.+)$#', $date, $matches)) {
            $time = \strtotime($matches[2]);

if ('until' === $matches[1]) {
                $operator = 1;
            }
        } else {
            $time = \strtotime($date);
        }

return $time;
    }

/**
     * Include files that have been changed from a certain date.
     * Example:
     *     $this->changed('since 13 days');.
     */
    public function changed(string $date): self
    {
        $time = $this->formatDate($date, $operator);

if (-1 === $operator) {
            $this->_filters[] = function (\SplFileInfo $current) use ($time) {
                return $current->getCTime() >= $time;
            };
        } else {
            $this->_filters[] = function (\SplFileInfo $current) use ($time) {
                return $current->getCTime() < $time;
            };
        }

return $this;
    }

/**
     * Include files that have been modified from a certain date.
     * Example:
     *     $this->modified('since 13 days');.
     */
    public function modified(string $date): self
    {
        $time = $this->formatDate($date, $operator);

if (-1 === $operator) {
            $this->_filters[] = function (\SplFileInfo $current) use ($time) {
                return $current->getMTime() >= $time;
            };
        } else {
            $this->_filters[] = function (\SplFileInfo $current) use ($time) {
                return $current->getMTime() < $time;
            };
        }

return $this;
    }

/**
     * Add your own filter.
     * The callback will receive 3 arguments: $current, $key and $iterator. It
     * must return a boolean: true to include the file, false to exclude it.
     * Example:
     *     // Include files that are readable
     *     $this->filter(function ($current) {
     *         return $current->isReadable();
     *     });.
     */
    public function filter($callback): self
    {
        $this->_filters[] = $callback;

return $this;
    }

/**
     * Sort result by name.
     * If \Collator exists (from ext/intl), the $locale argument will be used
     * for its constructor. Else, strcmp() will be used.
     * Example:
     *     $this->sortByName('fr_FR');.
     */
    public function sortByName(string $locale = 'root'): self
    {
        if (true === \class_exists('Collator', false)) {
            $collator = new \Collator($locale);

$this->_sorts[] = function (\SplFileInfo $a, \SplFileInfo $b) use ($collator) {
                return $collator->compare($a->getPathname(), $b->getPathname());
            };
        } else {
            $this->_sorts[] = function (\SplFileInfo $a, \SplFileInfo $b) {
                return \strcmp($a->getPathname(), $b->getPathname());
            };
        }

return $this;
    }

/**
     * Sort result by size.
     * Example:
     *     $this->sortBySize();.
     */
    public function sortBySize(): self
    {
        $this->_sorts[] = function (\SplFileInfo $a, \SplFileInfo $b) {
            return $a->getSize() < $b->getSize();
        };

return $this;
    }

/**
     * Add your own sort.
     * The callback will receive 2 arguments: $a and $b. Please see the uasort()
     * function.
     * Example:
     *     // Sort files by their modified time.
     *     $this->sort(function ($a, $b) {
     *         return $a->getMTime() < $b->getMTime();
     *     });.
     */
    public function sort($callable): self
    {
        $this->_sorts[] = $callable;

return $this;
    }

/**
     * Child comes first when iterating.
     */
    public function childFirst(): self
    {
        $this->_first = \RecursiveIteratorIterator::CHILD_FIRST;

return $this;
    }

/**
     * Get the iterator.
     */
    public function getIterator()
    {
        $_iterator = new \AppendIterator();
        $types = $this->getTypes();

if (!empty($types)) {
            $this->_filters[] = function (\SplFileInfo $current) use ($types) {
                return \in_array($current->getType(), $types);
            };
        }

$maxDepth = $this->getMaxDepth();
        $splFileInfo = $this->getSplFileInfo();

foreach ($this->getPaths() as $path) {
            if (1 === $maxDepth) {
                $iterator = new \IteratorIterator(
                    new IteratorRecursiveDirectory(
                        $path,
                        $this->getFlags(),
                        $splFileInfo
                    ),
                    $this->getFirst()
                );
            } else {
                $iterator = new \RecursiveIteratorIterator(
                    new IteratorRecursiveDirectory(
                        $path,
                        $this->getFlags(),
                        $splFileInfo
                    ),
                    $this->getFirst()
                );

if (1 < $maxDepth) {
                    $iterator->setMaxDepth($maxDepth - 1);
                }
            }

$_iterator->append($iterator);
        }

foreach ($this->getFilters() as $filter) {
            $_iterator = new \CallbackFilterIterator(
                $_iterator,
                $filter
            );
        }

$sorts = $this->getSorts();

if (empty($sorts)) {
            return $_iterator;
        }

$array = \iterator_to_array($_iterator);

foreach ($sorts as $sort) {
            \uasort($array, $sort);
        }

return new \ArrayIterator($array);
    }

/**
     * Set SplFileInfo classname.
     */
    public function setSplFileInfo(string $splFileInfo): string
    {
        $old = $this->_splFileInfo;
        $this->_splFileInfo = $splFileInfo;

return $old;
    }

/**
     * Get SplFileInfo classname.
     */
    public function getSplFileInfo(): string
    {
        return $this->_splFileInfo;
    }

/**
     * Get all paths.
     */
    protected function getPaths(): array
    {
        return $this->_paths;
    }

/**
     * Get max depth.
     */
    public function getMaxDepth(): int
    {
        return $this->_maxDepth;
    }

/**
     * Get types.
     */
    public function getTypes(): array
    {
        return $this->_types;
    }

/**
     * Get filters.
     */
    protected function getFilters(): array
    {
        return $this->_filters;
    }

/**
     * Get sorts.
     */
    protected function getSorts(): array
    {
        return $this->_sorts;
    }

/**
     * Get flags.
     */
    public function getFlags(): int
    {
        return $this->_flags;
    }

/**
     * Get first.
     */
    public function getFirst(): int
    {
        return $this->_first;
    }
}