ntentan\utils\filesystem\Directory

Complexity

Total Complexity

18

Size/Duplication

Total Lines	170
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

30.19%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	directoryOperation()	0	13	3
A	copyTo()	0	4	1
A	getSize()	0	4	1
A	moveTo()	0	6	1
A	create()	0	21	4
A	delete()	0	5	1
A	getPath()	0	4	1
A	getFiles()	0	14	4
A	__toString()	0	4	1

<?php

namespace ntentan\utils\filesystem;

use ntentan\utils\exceptions\FileNotFoundException;
use ntentan\utils\Filesystem;
use ntentan\utils\exceptions\FilesystemException;

/**
 * A directory on the filesystem.
 *
 * @package ntentan\utils\filesystem
 */
class Directory implements FileInterface
{

    /**
     * Full path to the directory.
     *
     * @var string
     */
    private $path;

    /**
     * Create a new instance with a path.
     *
     * @param string $path Optional path pointed to by new instance. Path does not have to exist.
     */
    public function __construct(string $path = null)
    {
        $this->path = $path;
    }

    /**
     * Used to perform copies and moves.
     *
     * @param string $operation
     * @param string $destination
     * @throws FileNotFoundException
     * @throws FilesystemException
     * @throws \ntentan\utils\exceptions\FileAlreadyExistsException
     * @throws \ntentan\utils\exceptions\FileNotReadableException
     * @throws \ntentan\utils\exceptions\FileNotWriteableException
     */
    private function directoryOperation(string $operation, string $destination):void
    {
        try {
            Filesystem::checkExists($destination);
            $destination = $destination . DIRECTORY_SEPARATOR . basename($this);
        } catch (FileNotFoundException $e) {
            Filesystem::directory($destination)->create(true);
        }

        foreach ($this->getFiles() as $file) {
            $file->$operation($destination . DIRECTORY_SEPARATOR . basename($file));
        }
    }

    /**
     * Recursively copies directory and its contents to destination.
     *
     * @param string $destination
     * @throws FileNotFoundException
     * @throws FilesystemException
     * @throws \ntentan\utils\exceptions\FileAlreadyExistsException
     * @throws \ntentan\utils\exceptions\FileNotReadableException
     * @throws \ntentan\utils\exceptions\FileNotWriteableException
     */
    public function copyTo(string $destination): void
    {
        $this->directoryOperation('copyTo', $destination);
    }

    /**
     * Recursively get the size of all contents in the directory.
     *
     * @return integer
     * @throws FileNotFoundException
     * @throws FilesystemException
     * @throws \ntentan\utils\exceptions\FileNotReadableException
     */
    public function getSize() : int
    {
        return $this->getFiles()->getSize();
    }

    /**
     * Recursively move a directory and its contents to another location.
     *
     * @param string $destination
     * @throws FileNotFoundException
     * @throws FilesystemException
     * @throws \ntentan\utils\exceptions\FileAlreadyExistsException
     * @throws \ntentan\utils\exceptions\FileNotReadableException
     * @throws \ntentan\utils\exceptions\FileNotWriteableException
     */
    public function moveTo(string $destination) : void
    {
        $this->directoryOperation('moveTo', $destination);
        $this->delete();
        $this->path = $destination;
    }

    /**
     * Create the directory pointed to by path.
     *
     * @param int $permissions
     * @throws \ntentan\utils\exceptions\FileAlreadyExistsException
     * @throws \ntentan\utils\exceptions\FileNotWriteableException
     */
    public function create($recursive=false, $permissions = 0755)
    {
        Filesystem::checkNotExists($this->path);
        if($recursive) {
            $segments = explode(DIRECTORY_SEPARATOR, $this->path);
            $accumulator = "";
            $parent = "";
            foreach($segments as $segment) {
                $accumulator .= $segment . DIRECTORY_SEPARATOR;
                if(is_dir($accumulator)) {
                    $parent = $accumulator;
                } else {
                    break;
                }
            }
        } else {
            $parent = dirname($this->path);
        }
        Filesystem::checkWritable($parent);
        mkdir($this->path, $permissions, true);
    }

    /**
     * Recursively delete the directory and all its contents.
     *
     * @throws FileNotFoundException
     * @throws FilesystemException
     * @throws \ntentan\utils\exceptions\FileNotReadableException
     */
    public function delete() : void
    {
        $this->getFiles()->delete();
        rmdir($this->path);
    }

    /**
     * Get the path of the directory.
     *
     * @return string
     */
    public function getPath() : string
    {
        return $this->path;
    }

    /**
     * Get the files in the directory.
     *
     * @throws FilesystemException
     * @throws \ntentan\utils\exceptions\FileNotFoundException
     * @throws \ntentan\utils\exceptions\FileNotReadableException
     * @return array<FileInterface>

Should the return type not be FileCollection?

     */
    public function getFiles() : FileCollection
    {
        Filesystem::checkExists($this->path);
        Filesystem::checkReadable($this->path);
        $contents = [];

        $files = scandir($this->path);
        foreach ($files as $file) {
            if($file != '.' && $file != '..') {
                $contents[] = "$this->path/$file";
            }
        }
        return new FileCollection($contents);
    }

    public function __toString()
    {
        return $this->path;
    }
}