php-zip/src/Util/FilesUtil.php

<?php

namespace PhpZip\Util;

use PhpZip\Util\Iterator\IgnoreFilesFilterIterator;
use PhpZip\Util\Iterator\IgnoreFilesRecursiveFilterIterator;

/**
 * Files util.
 *
 * @author Ne-Lexa alexey@nelexa.ru
 * @license MIT
 *
 * @internal
 */
final class FilesUtil
{
    /**
     * Is empty directory.
     *
     * @param string $dir Directory
     *
     * @return bool
     */
    public static function isEmptyDir($dir)
    {
        if (!is_readable($dir)) {
            return false;
        }

        return \count(scandir($dir)) === 2;
    }

    /**
     * Remove recursive directory.
     *
     * @param string $dir directory path
     */
    public static function removeDir($dir)
    {
        $files = new \RecursiveIteratorIterator(
            new \RecursiveDirectoryIterator($dir, \RecursiveDirectoryIterator::SKIP_DOTS),
            \RecursiveIteratorIterator::CHILD_FIRST
        );

        foreach ($files as $fileInfo) {
            $function = ($fileInfo->isDir() ? 'rmdir' : 'unlink');
            $function($fileInfo->getRealPath());
        }
        rmdir($dir);
    }

    /**
     * Convert glob pattern to regex pattern.
     *
     * @param string $globPattern
     *
     * @return string
     */
    public static function convertGlobToRegEx($globPattern)
    {
        // Remove beginning and ending * globs because they're useless
        $globPattern = trim($globPattern, '*');
        $escaping = false;
        $inCurrent = 0;
        $chars = str_split($globPattern);
        $regexPattern = '';

        foreach ($chars as $currentChar) {
            switch ($currentChar) {
                case '*':
                    $regexPattern .= ($escaping ? '\\*' : '.*');
                    $escaping = false;
                    break;

                case '?':
                    $regexPattern .= ($escaping ? '\\?' : '.');
                    $escaping = false;
                    break;

                case '.':
                case '(':
                case ')':
                case '+':
                case '|':
                case '^':
                case '$':
                case '@':
                case '%':
                    $regexPattern .= '\\' . $currentChar;
                    $escaping = false;
                    break;

                case '\\':
                    if ($escaping) {
                        $regexPattern .= '\\\\';
                        $escaping = false;
                    } else {
                        $escaping = true;
                    }
                    break;

                case '{':
                    if ($escaping) {
                        $regexPattern .= '\\{';
                    } else {
                        $regexPattern = '(';
                        $inCurrent++;
                    }
                    $escaping = false;
                    break;

                case '}':
                    if ($inCurrent > 0 && !$escaping) {
                        $regexPattern .= ')';
                        $inCurrent--;
                    } elseif ($escaping) {
                        $regexPattern = '\\}';
                    } else {
                        $regexPattern = '}';
                    }
                    $escaping = false;
                    break;

                case ',':
                    if ($inCurrent > 0 && !$escaping) {
                        $regexPattern .= '|';
                    } elseif ($escaping) {
                        $regexPattern .= '\\,';
                    } else {
                        $regexPattern = ',';
                    }
                    break;
                default:
                    $escaping = false;
                    $regexPattern .= $currentChar;
            }
        }

        return $regexPattern;
    }

    /**
     * Search files.
     *
     * @param string $inputDir
     * @param bool   $recursive
     * @param array  $ignoreFiles
     *
     * @return array Searched file list
     */
    public static function fileSearchWithIgnore($inputDir, $recursive = true, array $ignoreFiles = [])
    {
        if ($recursive) {
            $directoryIterator = new \RecursiveDirectoryIterator($inputDir);

            if (!empty($ignoreFiles)) {
                $directoryIterator = new IgnoreFilesRecursiveFilterIterator($directoryIterator, $ignoreFiles);
            }
            $iterator = new \RecursiveIteratorIterator($directoryIterator);
        } else {
            $directoryIterator = new \DirectoryIterator($inputDir);

            if (!empty($ignoreFiles)) {
                $directoryIterator = new IgnoreFilesFilterIterator($directoryIterator, $ignoreFiles);
            }
            $iterator = new \IteratorIterator($directoryIterator);
        }

        $fileList = [];

        foreach ($iterator as $file) {
            if ($file instanceof \SplFileInfo) {
                $fileList[] = $file->getPathname();
            }
        }

        return $fileList;
    }

    /**
     * Search files from glob pattern.
     *
     * @param string $globPattern
     * @param int    $flags
     * @param bool   $recursive
     *
     * @return array Searched file list
     */
    public static function globFileSearch($globPattern, $flags = 0, $recursive = true)
    {
        $flags = (int) $flags;
        $recursive = (bool) $recursive;
        $files = glob($globPattern, $flags);

        if (!$recursive) {
            return $files;
        }

        foreach (glob(\dirname($globPattern) . '/*', \GLOB_ONLYDIR | \GLOB_NOSORT) as $dir) {
            // Unpacking the argument via ... is supported starting from php 5.6 only
            /** @noinspection SlowArrayOperationsInLoopInspection */
            $files = array_merge($files, self::globFileSearch($dir . '/' . basename($globPattern), $flags, $recursive));
        }

        return $files;
    }

    /**
     * Search files from regex pattern.
     *
     * @param string $folder
     * @param string $pattern
     * @param bool   $recursive
     *
     * @return array Searched file list
     */
    public static function regexFileSearch($folder, $pattern, $recursive = true)
    {
        if ($recursive) {
            $directoryIterator = new \RecursiveDirectoryIterator($folder);
            $iterator = new \RecursiveIteratorIterator($directoryIterator);
        } else {
            $directoryIterator = new \DirectoryIterator($folder);
            $iterator = new \IteratorIterator($directoryIterator);
        }

        $regexIterator = new \RegexIterator($iterator, $pattern, \RegexIterator::MATCH);
        $fileList = [];

        foreach ($regexIterator as $file) {
            if ($file instanceof \SplFileInfo) {
                $fileList[] = $file->getPathname();
            }
        }

        return $fileList;
    }

    /**
     * Convert bytes to human size.
     *
     * @param int         $size Size bytes
     * @param string|null $unit Unit support 'GB', 'MB', 'KB'
     *
     * @return string
     */
    public static function humanSize($size, $unit = null)
    {
        if (($unit === null && $size >= 1 << 30) || $unit === 'GB') {
            return number_format($size / (1 << 30), 2) . 'GB';
        }

        if (($unit === null && $size >= 1 << 20) || $unit === 'MB') {
            return number_format($size / (1 << 20), 2) . 'MB';
        }

        if (($unit === null && $size >= 1 << 10) || $unit === 'KB') {
            return number_format($size / (1 << 10), 2) . 'KB';
        }

        return number_format($size) . ' bytes';
    }

    /**
     * Normalizes zip path.
     *
     * @param string $path Zip path
     *
     * @return string
     */
    public static function normalizeZipPath($path)
    {
        return implode(
            '/',
            array_filter(
                explode('/', (string) $path),
                static function ($part) {
                    return $part !== '.' && $part !== '..';
                }
            )
        );
    }

    /**
     * Returns whether the file path is an absolute path.
     *
     * @param string $file A file path
     *
     * @return bool
     *
     * @see source symfony filesystem component
     */
    public static function isAbsolutePath($file)
    {
        return strspn($file, '/\\', 0, 1)
            || (
                \strlen($file) > 3 && ctype_alpha($file[0])
                && $file[1] === ':'
                && strspn($file, '/\\', 2, 1)
            )
            || parse_url($file, \PHP_URL_SCHEME) !== null;
    }

    /**
     * @param string $linkPath
     * @param string $target
     *
     * @return bool
     */
    public static function symlink($target, $linkPath)
    {
        if (\DIRECTORY_SEPARATOR === '\\') {
            $linkPath = str_replace('/', '\\', $linkPath);
            $target = str_replace('/', '\\', $target);
            $abs = null;

            if (!self::isAbsolutePath($target)) {
                $abs = realpath(\dirname($linkPath) . \DIRECTORY_SEPARATOR . $target);

                if (\is_string($abs)) {
                    $target = $abs;
                }
            }
        }

        if (!symlink($target, $linkPath)) {
            if (\DIRECTORY_SEPARATOR === '\\' && is_file($target)) {
                return copy($target, $linkPath);
            }

            return false;
        }

        return true;
    }

    /**
     * @param string $file
     *
     * @return bool
     */
    public static function isBadCompressionFile($file)
    {
        $badCompressFileExt = [
            'dic',
            'dng',
            'f4v',
            'flipchart',
            'h264',
            'lrf',
            'mobi',
            'mts',
            'nef',
            'pspimage',
        ];

        $ext = strtolower(pathinfo($file, \PATHINFO_EXTENSION));

        if (\in_array($ext, $badCompressFileExt, true)) {
            return true;
        }

        $mimeType = self::getMimeTypeFromFile($file);

        return self::isBadCompressionMimeType($mimeType);
    }

    /**
     * @param string $mimeType
     *
     * @return bool
     */
    public static function isBadCompressionMimeType($mimeType)
    {
        static $badDeflateCompMimeTypes = [
            'application/epub+zip',
            'application/gzip',
            'application/vnd.debian.binary-package',
            'application/vnd.oasis.opendocument.graphics',
            'application/vnd.oasis.opendocument.presentation',
            'application/vnd.oasis.opendocument.text',
            'application/vnd.oasis.opendocument.text-master',
            'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
            'application/vnd.rn-realmedia',
            'application/x-7z-compressed',
            'application/x-arj',
            'application/x-bzip2',
            'application/x-hwp',
            'application/x-lzip',
            'application/x-lzma',
            'application/x-ms-reader',
            'application/x-rar',
            'application/x-rpm',
            'application/x-stuffit',
            'application/x-tar',
            'application/x-xz',
            'application/zip',
            'application/zlib',
            'audio/flac',
            'audio/mpeg',
            'audio/ogg',
            'audio/vnd.dolby.dd-raw',
            'audio/webm',
            'audio/x-ape',
            'audio/x-hx-aac-adts',
            'audio/x-m4a',
            'audio/x-m4a',
            'audio/x-wav',
            'image/gif',
            'image/heic',
            'image/jp2',
            'image/jpeg',
            'image/png',
            'image/vnd.djvu',
            'image/webp',
            'image/x-canon-cr2',
            'video/ogg',
            'video/webm',
            'video/x-matroska',
            'video/x-ms-asf',
            'x-epoc/x-sisx-app',
        ];

        if (\in_array($mimeType, $badDeflateCompMimeTypes, true)) {
            return true;
        }

        return false;
    }

    /**
     * @param string $file
     *
     * @return string
     *
     * @noinspection PhpComposerExtensionStubsInspection
     */
    public static function getMimeTypeFromFile($file)
    {
        if (\function_exists('mime_content_type')) {
            return mime_content_type($file);
        }

        return 'application/octet-stream';
    }

    /**
     * @param string $contents
     *
     * @return string
     * @noinspection PhpComposerExtensionStubsInspection
     */
    public static function getMimeTypeFromString($contents)
    {
        $contents = (string) $contents;
        $finfo = new \finfo(\FILEINFO_MIME);
        $mimeType = $finfo->buffer($contents);

        if ($mimeType === false) {
            $mimeType = 'application/octet-stream';
        }

        return explode(';', $mimeType)[0];
    }
}