kalanis\kw_files\Processing\Volume\ProcessDir

Complexity

Total Complexity

23

Size/Duplication

Total Lines	173
Duplicated Lines	0 %

Test Coverage

Coverage

85.29%

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	filterFilesAndDirsOnly()	0	3	1
A	filterDots()	0	3	1
A	fullPath()	0	3	1
A	copyDir()	0	9	2
A	noDirectoryDelimiterSet()	0	3	1
A	createDir()	0	8	2
A	__construct()	0	4	1
A	intoNode()	0	7	1
A	deleteDir()	0	12	3
A	addRootNode()	0	3	1
A	moveDir()	0	16	3
A	readDir()	0	25	4
A	setPath()	0	6	2

<?php

namespace kalanis\kw_files\Processing\Volume;


use FilesystemIterator;
use kalanis\kw_files\FilesException;
use kalanis\kw_files\Interfaces\IFLTranslations;
use kalanis\kw_files\Interfaces\IProcessDirs;
use kalanis\kw_files\Interfaces\ITypes;
use kalanis\kw_files\Node;
use kalanis\kw_files\Processing\TPath;
use kalanis\kw_files\Translations;
use kalanis\kw_paths\Extras\TPathTransform;
use kalanis\kw_paths\PathsException;
use kalanis\kw_storage\Extras\TRemoveCycle;
use kalanis\kw_storage\Extras\TVolumeCopy;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use SplFileInfo;
use Throwable;


/**
 * Class ProcessDir
 * @package kalanis\kw_files\Processing\Volume
 * Process dirs in basic ways
 */
class ProcessDir implements IProcessDirs
{
    use TPath;
    use TPathTransform;
    use TRemoveCycle;
    use TVolumeCopy;

    /** @var IFLTranslations */
    protected $lang = null;
    /** @var int */
    protected $sliceStartParts = 0;

    /**
     * @param string $path
     * @param IFLTranslations|null $lang
     * @throws PathsException
     */
    public function __construct(string $path = '', ?IFLTranslations $lang = null)
    {
        $this->lang = $lang ?? new Translations();
        $this->setPath($path);
    }

    /**
     * @param string $path
     * @throws PathsException
     */
    public function setPath(string $path = ''): void
    {
        $used = realpath($path);
        if (false !== $used) {
            $this->path = $used;
            $this->sliceStartParts = count($this->expandName($used));
        }
    }

    public function createDir(array $entry, bool $deep = false): bool
    {
        $path = $this->fullPath($entry);
        try {
            return @mkdir($path, 0777, $deep);
            // @codeCoverageIgnoreStart
        } catch (Throwable $ex) {
            throw new FilesException($this->lang->flCannotCreateDir($path), $ex->getCode(), $ex);
        }
        // @codeCoverageIgnoreEnd
    }

    public function readDir(array $entry, bool $loadRecursive = false, bool $wantSize = false): array
    {
        $path = $this->fullPath($entry);
        try {
            $iter = $loadRecursive
                ? new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path))
                : new FilesystemIterator($path, 0)
            ;
            return array_values(
                array_map(
                    [$this, 'intoNode'],
                    array_filter(
                        array_filter(
                            array_filter(
                                ($loadRecursive ? [] : [$this->addRootNode($path)]) + iterator_to_array($iter)
                            ),
                            [$this, 'filterFilesAndDirsOnly']
                        ),
                        [$this, 'filterDots']
                    )
                )
            );
            // @codeCoverageIgnoreStart
        } catch (Throwable $ex) {
            throw new FilesException($this->lang->flCannotReadDir($path), $ex->getCode(), $ex);
        }
        // @codeCoverageIgnoreEnd
    }

    protected function addRootNode(string $path): SplFileInfo
    {
        return new SplFileInfo($path);
    }

    public function filterFilesAndDirsOnly(SplFileInfo $file): bool
    {
        return in_array($file->getType(), [ITypes::TYPE_DIR, ITypes::TYPE_FILE]);
    }

    public function filterDots(SplFileInfo $file): bool
    {
        return '..' !== $file->getFilename();
    }

    /**
     * @param SplFileInfo $file
     * @throws PathsException
     * @return Node
     */
    public function intoNode(SplFileInfo $file): Node
    {
        $node = new Node();
        return $node->setData(
            array_slice($this->expandName($file->getRealPath()), $this->sliceStartParts),
            $file->getSize(),
            $file->getType()
        );
    }

    public function copyDir(array $source, array $dest): bool
    {
        $src = $this->fullPath($source);
        $dst = $this->fullPath($dest);
        try {
            return $this->xcopy($src, $dst);
            // @codeCoverageIgnoreStart
        } catch (Throwable $ex) {
            throw new FilesException($this->lang->flCannotCopyDir($src, $dst), $ex->getCode(), $ex);
        }
        // @codeCoverageIgnoreEnd
    }

    public function moveDir(array $source, array $dest): bool
    {
        $src = $this->fullPath($source);
        $dst = $this->fullPath($dest);
        try {
            // original call with doomed sub-calls chmod and chown - see
            // @link https://www.php.net/manual/en/function.rename.php#117590
            // return @rename($src, $dst);

            // to avoid that internal bug...
            $v1 = $this->copyDir($source, $dest);
            $v2 = $this->deleteDir($source, true);
            return $v1 && $v2;
            // @codeCoverageIgnoreStart
        } catch (Throwable $ex) {
            throw new FilesException($this->lang->flCannotMoveDir($src, $dst), $ex->getCode(), $ex);
        }
        // @codeCoverageIgnoreEnd
    }

    public function deleteDir(array $entry, bool $deep = false): bool
    {
        $path = $this->fullPath($entry);
        try {
            if ($deep) {
                return $this->removeCycle($path);
            } else {
                return @rmdir($path);
            }
            // @codeCoverageIgnoreStart
        } catch (Throwable $ex) {
            throw new FilesException($this->lang->flCannotRemoveDir($path), $ex->getCode(), $ex);
        }
        // @codeCoverageIgnoreEnd
    }

    /**
     * @param array<string> $path
     * @throws PathsException
     * @return string
     */
    protected function fullPath(array $path): string
    {
        return $this->getPath() . DIRECTORY_SEPARATOR . $this->compactName($path);
    }

    /**
     * @return string
     * @codeCoverageIgnore only when path fails
     */
    protected function noDirectoryDelimiterSet(): string
    {
        return $this->lang->flNoDirectoryDelimiterSet();
    }
}