Slick\FsWatch\Directory

Complexity

Total Complexity

13

Size/Duplication

Total Lines	76
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	snapshot()	0	3	1
A	path()	0	3	1
A	__construct()	0	10	3
A	hasChanged()	0	3	1
A	sizeMap()	0	3	1
A	map()	0	18	6

<?php

/**
 * This file is part of fswatch
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Slick\FsWatch;

use Slick\FsWatch\Directory\Snapshot;
use Slick\FsWatch\Exception\DirectoryNotAccecible;
use Slick\FsWatch\Exception\DirectoryNotFound;

/**
 * Directory
 *
 * @package Slick\FsWatch
 */
class Directory
{
    private FileTools $fileTools;
    /**
     * Creates a Directory
     *
     * @param string $path
     * @throws DirectoryNotFound|DirectoryNotAccecible When directory is not accessible
     */
    public function __construct(private string $path)
    {
        $this->fileTools = new FileTools();
        $this->path = $this->fileTools->normalizePath($this->path);
        if (!is_dir($this->path)) {
            throw new DirectoryNotFound("Directory $this->path does not exist.");
        }

        if (!is_readable($this->path)) {
            throw new DirectoryNotAccecible("Directory $this->path is not readable.");
        }
    }

    /**
     * Returns the directory path.
     *
     * @return string The path.
     */
    public function path(): string
    {
        return rtrim($this->path, '/');
    }

    /**
     * Creates a size map of all directories and files within the specified directory.
     *
     * @return array<string, mixed> Array containing the size information of directories and files
     */
    public function sizeMap(): array
    {
        return $this->map($this->path);
    }

    /**
     * Recursively maps a directory and its content sizes.
     *
     * @param string $path The path to the directory.
     * @return array<string, mixed> The mapped directory with its contents.
     */
    private function map(string $path): array
    {
        $result = [];
        $path = $this->fileTools->normalizePath($path);
        $handle = opendir($path);
        while ($handle && false !== ($file = readdir($handle))) {
            if ($file === '.' || $file === '..') {
                continue;
            }

            if (is_dir($path . $file) === true) {
                $result[$file] = $this->map($path . $file);
                continue;
            }
            $result[$file] = $this->fileTools->calculateSize($path . $file);
        }
        unset($handle);
        return $result;
    }

    public function snapshot(): Snapshot
    {
        return new Snapshot($this);
    }

    public function hasChanged(Snapshot $snapshot): bool
    {
        return $this->snapshot()->hash() !== $snapshot->hash();
    }
}