kalanis\kw_tree\DataSources\Volume

Complexity

Total Complexity

24

Size/Duplication

Total Lines	147
Duplicated Lines	0 %

Test Coverage

Coverage

93.85%

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	fillNode()	0	9	1
A	getFlat()	0	3	1
A	cutPathStart()	0	10	2
A	toType()	0	12	4
A	__construct()	0	4	1
A	filterDoubleDot()	0	3	1
B	process()	0	43	11
A	orderUp()	0	5	1
A	getRecursive()	0	3	1
A	orderDown()	0	5	1

<?php

namespace kalanis\kw_tree\DataSources;


use CallbackFilterIterator;
use FilesystemIterator;
use Iterator;
use kalanis\kw_files\Interfaces\ITypes;
use kalanis\kw_paths\ArrayPath;
use kalanis\kw_paths\PathsException;
use kalanis\kw_tree\Essentials\FileNode;
use kalanis\kw_tree\Interfaces\ITree;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use SplFileInfo;


/**
 * Class Volume
 * @package kalanis\kw_tree\DataSources
 * The source is local volume
 */
class Volume extends ASources
{
    protected string $systemDir = '';
    protected ArrayPath $libPath;

    public function __construct(string $systemDir)
    {
        $this->systemDir = $systemDir;
        $this->libPath = new ArrayPath();
    }

    /**
     * @throws PathsException
     * @return $this
     */
    public function process(): ITree
    {
        $path = realpath($this->systemDir . DIRECTORY_SEPARATOR . $this->libPath->setArray($this->startPath)->getString());
        if (false === $path) {
            return $this;
        }

        $iter = $this->recursive ? $this->getRecursive($path) : $this->getFlat($path) ;
        $iter = new CallbackFilterIterator($iter, [$this, 'filterDoubleDot']);
        if ($this->filterCallback) {
            $iter = new CallbackFilterIterator($iter, $this->filterCallback);
        }

        /** @var FileNode[] $nodes */
        $nodes = [];
        // sometimes the root node is filtered out - put it there for each situation
        $initNode = new SplFileInfo($path);
        $nodes[''] = $this->fillNode($initNode, '');

        foreach ($iter as $item) {
            /** @var SplFileInfo $item */
            $cutPath = $this->cutPathStart($path, $item->getRealPath());
            if (!is_null($cutPath)) {
                $nodes[$cutPath] = $this->fillNode($item, $cutPath);
            }
        }

        if (ITree::ORDER_NONE != $this->ordering) {
            uasort(
                $nodes,
                (ITree::ORDER_ASC == $this->ordering ? [$this, 'orderUp'] : [$this, 'orderDown'])
            );
        }

        foreach ($nodes as $node) {
            $parentPath = $this->libPath->setArray($node->getPath())->getStringDirectory();
            if (!empty($node->getPath()) && isset($nodes[$parentPath])) {
                $nodes[$parentPath]->addSubNode($node);
            }
        }

        $this->startNode = $nodes[''];
        return $this;
    }

    protected function getFlat(string $path): Iterator
    {
        return new FilesystemIterator($path);
    }

    protected function getRecursive(string $path): Iterator
    {
        return new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path));
    }

    public function filterDoubleDot(SplFileInfo $info): bool
    {
        return ( ITree::PARENT_DIR != $info->getFilename() ) ;
    }

    /**
     * @param FileNode $file1
     * @param FileNode $file2
     * @throws PathsException
     * @return int
     */
    public function orderUp(FileNode $file1, FileNode $file2): int
    {
        return strcasecmp(
            $this->libPath->setArray($file1->getPath())->getString(),
            $this->libPath->setArray($file2->getPath())->getString()
        );
    }

    /**
     * @param FileNode $file1
     * @param FileNode $file2
     * @throws PathsException
     * @return int
     */
    public function orderDown(FileNode $file1, FileNode $file2): int
    {
        return strcasecmp(
            $this->libPath->setArray($file2->getPath())->getString(),
            $this->libPath->setArray($file1->getPath())->getString()
        );
    }

    /**
     * @param SplFileInfo $file
     * @param string $path
     * @throws PathsException
     * @return FileNode
     */
    protected function fillNode(SplFileInfo $file, string $path): FileNode
    {
        $node = new FileNode();
        return $node->setData(
            $this->libPath->setString($path)->getArray(),
            $file->getSize(),
            $this->toType($file),
            $file->isReadable(),
            $file->isWritable()
        );
    }

    protected function cutPathStart(string $start, string $what): ?string
    {
        $isKnown = mb_strpos($what, $start);
        if (0 === $isKnown) {
            return mb_substr($what, mb_strlen($start) + 1);
        } else {
            // @codeCoverageIgnoreStart
            // false for unknown or higher number for elsewhere
            // this node will be kicked out of results later
            return null;
        }
        // @codeCoverageIgnoreEnd
    }

    protected function toType(SplFileInfo $file): string
    {
        switch ($file->getType()) {
            case 'dir':
                return ITypes::TYPE_DIR;
            case 'file':
                return ITypes::TYPE_FILE;
            // @codeCoverageIgnoreStart
            case 'link':
                return ITypes::TYPE_LINK;
            default:
                return ITypes::TYPE_UNKNOWN;
            // @codeCoverageIgnoreEnd
        }
    }
}