Hyde\Foundation\Filesystem

Complexity

Total Complexity

27

Size/Duplication

Total Lines	181
Duplicated Lines	0 %

Importance

Changes	8
Bugs	0	Features	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	getMarkdownPagePath()	0	3	1
A	getModelSourcePath()	0	9	2
A	unlink()	0	11	3
A	pathToAbsolute()	0	3	1
A	copy()	0	3	1
A	getDocumentationPagePath()	0	3	1
A	implode()	0	3	1
A	qualifyPossiblePathArray()	0	7	2
A	touch()	0	11	3
A	sitePath()	0	9	2
A	getBasePath()	0	3	1
A	getBladePagePath()	0	3	1
A	smartGlob()	0	4	1
A	path()	0	9	2
A	__construct()	0	3	1
A	vendorPath()	0	3	1
A	getMarkdownPostPath()	0	3	1
A	pathToRelative()	0	5	2

<?php

declare(strict_types=1);

namespace Hyde\Foundation;

use function collect;
use function copy;
use Hyde\Facades\Site;
use Hyde\Framework\Services\DiscoveryService;
use Hyde\Hyde;
use Hyde\Pages\BladePage;
use Hyde\Pages\DocumentationPage;
use Hyde\Pages\MarkdownPage;
use Hyde\Pages\MarkdownPost;
use Illuminate\Support\Collection;
use function is_string;
use function str_replace;
use function touch;
use function unlink;
use function unslash;

/**
 * File helper methods, bound to the HydeKernel instance, and is an integral part of the framework.
 *
 * All paths are relative to the root of the application.
 *
 * @see \Hyde\Framework\Testing\Feature\Foundation\FilesystemTest
 */
class Filesystem
{
    protected HydeKernel $kernel;

    public function __construct(HydeKernel $kernel)
    {
        $this->kernel = $kernel;
    }

    public function getBasePath(): string
    {
        return $this->kernel->getBasePath();
    }

    /**
     * Get an absolute file path from a supplied relative path.
     *
     * The function returns the fully qualified path to your site's root directory.
     *
     * You may also use the function to generate a fully qualified path to a given file
     * relative to the project root directory when supplying the path argument.
     *
     * @param  string  $path
     * @return string
     */
    public function path(string $path = ''): string
    {
        if (empty($path)) {
            return $this->getBasePath();
        }

        $path = unslash($path);

        return $this->implode($this->getBasePath(), $path);
    }

    /**
     * Get an absolute file path from a supplied relative path.
     */
    public function pathToAbsolute(string $path): string
    {
        return $this->path($path);
    }

    /**
     * Decode an absolute path created with a Hyde::path() helper into its relative counterpart.
     */
    public function pathToRelative(string $path): string
    {
        return str_starts_with($path, $this->path())
            ? unslash(str_replace($this->path(), '', $path))
            : $path;
    }

    /**
     * Get the absolute path to the compiled site directory, or a file within it.
     */
    public function sitePath(string $path = ''): string
    {
        if (empty($path)) {
            return Hyde::path(Site::$outputPath);
        }

        $path = unslash($path);

        return Hyde::path(Site::$outputPath.DIRECTORY_SEPARATOR.$path);
    }

    /**
     * Works similarly to the path() function, but returns a file in the Framework package.
     *
     * @param  string  $path
     * @return string
     */
    public function vendorPath(string $path = ''): string
    {
        return $this->path('vendor/hyde/framework/'.unslash($path));
    }

    /**
     * Wrapper for the copy function, but using project relative paths.
     */
    public function copy(string $from, string $to): bool
    {
        return copy($this->path($from), $this->path($to));
    }

    /**
     * Touch one or more files in the project's directory.
     */
    public function touch(string|array $path): bool
    {
        if (is_string($path)) {

The condition is_string($path) is always false.

            return touch($this->path($path));
        }

        foreach ($path as $p) {
            touch($this->path($p));
        }

        return true;
    }

    /**
     * Unlink one or more files in the project's directory.
     */
    public function unlink(string|array $path): bool
    {
        if (is_string($path)) {

The condition is_string($path) is always false.

            return unlink($this->path($path));
        }

        foreach ($path as $p) {
            unlink($this->path($p));
        }

        return true;
    }

    /**
     * Fluent file helper methods.
     *
     * Provides a more fluent way of getting either the absolute path
     * to a model's source directory, or an absolute path to a file within it.
     *
     * These are intended to be used as a dynamic alternative to legacy code
     * Hyde::path('_pages/foo') becomes Hyde::getBladePagePath('foo')
     */
    public function getModelSourcePath(string $model, string $path = ''): string
    {
        if (empty($path)) {
            return $this->path(DiscoveryService::getModelSourceDirectory($model));
        }

        $path = unslash($path);

        return $this->path($this->implode(DiscoveryService::getModelSourceDirectory($model), $path));
    }

    public function getBladePagePath(string $path = ''): string
    {
        return $this->getModelSourcePath(BladePage::class, $path);
    }

    public function getMarkdownPagePath(string $path = ''): string
    {
        return $this->getModelSourcePath(MarkdownPage::class, $path);
    }

    public function getMarkdownPostPath(string $path = ''): string
    {
        return $this->getModelSourcePath(MarkdownPost::class, $path);
    }

    public function getDocumentationPagePath(string $path = ''): string
    {
        return $this->getModelSourcePath(DocumentationPage::class, $path);
    }

    public function smartGlob(string $pattern, int $flags = 0): Collection
    {
        return collect(\Hyde\Facades\Filesystem::glob($pattern, $flags))

Hyde\Facades\Filesystem::glob($pattern, $flags) of type array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

            ->map(fn (string $path): string => $this->pathToRelative($path));
    }

    /** @internal */
    public function qualifyPossiblePathArray(array|string $paths): array|string
    {
        if (is_array($paths)) {

The condition is_array($paths) is always true.

            return array_map(fn ($path) => $this->pathToAbsolute($path), $paths);
        }

        return $this->pathToAbsolute($paths);
    }

    /**
     * Implode path components into a string with directory separators.
     */
    public static function implode(string $base, string ...$paths): string
    {
        return implode(DIRECTORY_SEPARATOR, array_merge([$base], $paths));
    }
}