allejo\stakx\Filesystem\FilesystemPath

Complexity

Total Complexity

19

Size/Duplication

Total Lines	158
Duplicated Lines	8.86 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

97.44%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	14	3
A	__toString()	0	4	1
A	appendToPath()	0	11	2
A	generatePath()	0	4	1
A	getAbsolutePath()	0	9	2
A	isDir()	0	11	3
A	isFile()	0	11	3
A	buildPath()	14	14	3
A	unixifyPath()	0	4	1

<?php

/**
 * @copyright 2018 Vladimir Jimenez
 * @license   https://github.com/stakx-io/stakx/blob/master/LICENSE.md MIT
 */

namespace allejo\stakx\Filesystem;

use allejo\stakx\Filesystem\FilesystemLoader as fs;

/**
 * A cross-platform filesystem path wrapper.
 *
 * This class is a wrapper for handling file paths in stakx in a cross-platform way. Give it a Windows path and append
 * a Unix style path and it'll just work.
 */
final class FilesystemPath
{
    /** @var string */
    private $absolutePath;
    /** @var string */
    private $originalPath;
    /** @var bool */
    private $isWindows;

    /**
     * @param FilesystemPath|string $filePath
     * @param string                $dirSep
     */
    public function __construct($filePath, $dirSep = DIRECTORY_SEPARATOR)
    {
        $filePath = (string)$filePath;

Consider using a different name than the parameter $filePath. This often makes code more readable.

        $this->originalPath = $filePath;
        $this->isWindows = ($dirSep === '\\');

        if ($this->isWindows)
        {
            $filePath = $this->unixifyPath($filePath);

Consider using a different name than the parameter $filePath. This often makes code more readable.

        }

        $this->absolutePath = (fs::isAbsolutePath($filePath)) ? $filePath : fs::absolutePath($filePath);

The method isAbsolutePath() does not exist on allejo\stakx\Filesystem\FilesystemLoader. Did you maybe mean absolutePath()?

$filePath is of type string, but the function expects a object<string>.

It seems like \allejo\stakx\Filesystem\FilesystemLoader::isAbsolutePath($filePath) ? $filePath : \allejo\stakx\Filesystem\FilesystemLoader::absolutePath($filePath) can also be of type object<string>. However, the property $absolutePath is declared as type string. Maybe add an additional type check?

    }

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

    /**
     * Append a path to a directory path.
     *
     * @param string $append The path to append
     *
     * @return self
     */
    public function appendToPath($append)
    {
        if ($this->isFile(false))
        {
            throw new \InvalidArgumentException("Appending to a file's path is not possible");
        }

        $this->absolutePath = $this->buildPath($this->absolutePath, $this->unixifyPath($append));

        return $this;
    }

    /**
     * Generate a path based off this file path.
     *
     * This method will not modify the existing file path of this instance, use FilesystemPath::appendToPath() for that.
     *
     * @param string $append
     *
     * @return string
     */
    public function generatePath($append)
    {
        return $this->buildPath($this->absolutePath, $this->unixifyPath($append));
    }

    /**
     * Get the absolute path of the file path.
     *
     * @return string
     */
    public function getAbsolutePath()
    {
        if ($this->isWindows)
        {
            return str_replace('/', '\\', $this->absolutePath);
        }

        return $this->absolutePath;
    }

    /**
     * Check whether the given path is a directory.
     *
     * @param bool $checkExistence When set to true, it will check the filesystem for the existence of the directory.
     *                             When set to false, this function will guess based on the path ending in a directory
     *                             separator.
     *
     * @return bool
     */
    public function isDir($checkExistence = true)
    {
        $absPath = $this->absolutePath;

        if ($checkExistence)
        {
            return file_exists($absPath) && is_dir($absPath);
        }

        return substr($absPath, -1, 1) == '/';
    }

    /**
     * Check whether the given path is a file.
     *
     * @param bool $checkExistence When set to true, it will check the filesystem for the existence of the file. When
     *                             set to false, this function will guess based on the path ending in a directory
     *                             separator.
     *
     * @return bool
     */
    public function isFile($checkExistence = true)
    {
        $absPath = $this->absolutePath;

        if ($checkExistence)
        {
            return file_exists($absPath) && is_file($absPath);
        }

        return !$this->isDir($checkExistence);
    }

    /**
     * Build a path from multiple strings.
     *
     * This function will _always_ use the '/' as the directory separator, because internal that's all stakx will use.
     * The FilesystemPath::getAbsolutePath() function will worry about Windows paths when necessary.
     *
     * @return string
     */
    private function buildPath()

This method seems to be duplicated in your project.

    {
        $paths = [];

        foreach (func_get_args() as $arg)
        {
            if ($arg !== '')
            {
                $paths[] = $arg;
            }
        }

        return preg_replace('#(?<!:)/+#', '/', join('/', $paths));
    }

    /**
     * Convert a Windows path into a blasphemous Unix path.
     *
     * @param string $filePath
     *
     * @return string
     */
    private function unixifyPath($filePath)
    {
        return str_replace('\\', '/', $filePath);
    }
}