allejo\stakx\System\Filesystem

Complexity

Total Complexity

24

Size/Duplication

Total Lines	237
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	6

Test Coverage

Coverage

40%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	absolutePath()	0	17	3
A	appendPath()	0	4	1
B	copy()	0	29	6
A	createFileObject()	0	4	1
A	getRelativePath()	0	4	1
A	getBaseName()	0	4	1
A	getFileName()	0	4	1
A	getFolderPath()	0	4	1
A	getExtension()	0	4	1
A	isDir()	0	4	1
A	isFile()	0	4	1
A	isSymlink()	0	4	1
A	safeReadFile()	0	22	3
A	removeExtension()	0	7	1
A	path()	0	4	1

<?php

/**
 * @copyright 2017 Vladimir Jimenez
 * @license   https://github.com/allejo/stakx/blob/master/LICENSE.md MIT
 */

namespace allejo\stakx\System;

use allejo\stakx\Exception\FileAccessDeniedException;
use allejo\stakx\Filesystem\File;
use allejo\stakx\Filesystem\FilesystemPath;
use allejo\stakx\Service;
use Symfony\Component\Filesystem\Exception\FileNotFoundException;
use Symfony\Component\Filesystem\Exception\IOException;

/**
 * Class Filesystem.
 *
 * This class extends Symfony's Filesystem to provide convenience functions
 */
class Filesystem extends \Symfony\Component\Filesystem\Filesystem
{
    /**
     * Build an absolute file or directory path separated by the OS specific directory separator.
     *
     * @param string ...$pathFragments
     *
     * @return string
     */
    public function absolutePath($pathFragments)
    {
        if ($pathFragments instanceof FilesystemPath)
        {
            $pathFragments = (string)$pathFragments;

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

        }

        if ($this->isAbsolutePath($pathFragments))
        {
            return $pathFragments;
        }

        $args = func_get_args();
        array_unshift($args, Service::getWorkingDirectory());

        return implode(DIRECTORY_SEPARATOR, $args);
    }

    /**
     * Build a file or directory path separated by the OS specific directory separator.
     *
     * @param string ...$pathFragments
     *
     * @return string
     */
    public function appendPath($pathFragments)

The parameter $pathFragments is not used and could be removed.

    {
        return implode(DIRECTORY_SEPARATOR, func_get_args());
    }

    /**
     * Copy a file or folder recursively.
     *
     * @param string $originFile          The original filename
     * @param string $targetFile          The target filename
     * @param bool   $overwriteNewerFiles If true, target files newer than origin files are overwritten
     *
     * @throws FileNotFoundException When originFile doesn't exist
     * @throws IOException           When copy fails
     */
    public function copy($originFile, $targetFile, $overwriteNewerFiles = false)
    {
        if ($this->isDir($originFile))
        {
            if (!$this->isDir($targetFile))
            {
                mkdir($targetFile, 0755, true);
            }

            $dir = dir($originFile);

            while (false !== $entry = $dir->read())
            {
                // Skip pointers
                if ($entry == '.' || $entry == '..')
                {
                    continue;
                }

                $this->copy("$originFile/$entry", "$targetFile/$entry", true);
            }

            $dir->close();
        }
        else
        {
            parent::copy($originFile, $targetFile, $overwriteNewerFiles);
        }
    }

    /**
     * Create an instance of stakx's File object with relative path information.
     *
     * @param string $filePath
     *
     * @return File
     */
    public function createFileObject($filePath)
    {
        return new File($this->absolutePath($filePath));
    }

    /**
     * Strip the current working directory from an absolute path.
     *
     * @param string $path An absolute path
     *
     * @return string
     */
    public function getRelativePath($path)
    {
        return str_replace(Service::getWorkingDirectory() . DIRECTORY_SEPARATOR, '', $path);
    }

    /**
     * Get the name of a given file without the extension.
     *
     * @param string $filePath A file path
     *
     * @return string
     */
    public function getBaseName($filePath)
    {
        return pathinfo($filePath, PATHINFO_FILENAME);
    }

    /**
     * Get the name of a given file.
     *
     * @param string $filePath A file path
     *
     * @return string
     */
    public function getFileName($filePath)
    {
        return pathinfo($filePath, PATHINFO_BASENAME);
    }

    /**
     * Get the parent directory of a given file.
     *
     * @param string $filePath A file path
     *
     * @return string
     */
    public function getFolderPath($filePath)
    {
        return pathinfo($filePath, PATHINFO_DIRNAME);
    }

    /**
     * Get the extension of a given file.
     *
     * @param string $filename A file path
     *
     * @return string The extension of the file
     */
    public function getExtension($filename)
    {
        return pathinfo($filename, PATHINFO_EXTENSION);
    }

    /**
     * Check whether or not if a given path is a directory.
     *
     * @param string $folderPath
     *
     * @return bool
     */
    public function isDir($folderPath)
    {
        return is_dir($folderPath);
    }

    /**
     * Check whether or not a given path is a file.
     *
     * @param string $filePath
     *
     * @return bool
     */
    public function isFile($filePath)
    {
        return is_file($filePath);
    }

    /**
     * Check whether a given file path is a symlink
     *
     * @param  string $filePath
     *
     * @return bool
     */
    public function isSymlink($filePath)
    {
        return is_link($filePath);
    }

    /**
     * Only read a file's contents if it's within the current working directory
     *
     * @param  string $filePath
     *
     * @return bool|string
     */
    public function safeReadFile($filePath)
    {
        $absPath = File::realpath($this->absolutePath($filePath));

        if (!$this->exists($absPath))
        {
            throw new FileNotFoundException(sprintf(
                "The '%s' file could not be found or is outside the website working directory",
                $filePath
            ));
        }

        if (strpos($absPath, Service::getWorkingDirectory()) !== 0)
        {
            throw new FileAccessDeniedException(sprintf(
                "The '%s' file is outside the website working directory",
                $filePath
            ));
        }

        return file_get_contents($absPath);
    }

    /**
     * Get the full path to the file without the extension.
     *
     * @param string $filename A file path
     *
     * @return string
     */
    public function removeExtension($filename)
    {
        return $this->appendPath(
            $this->getFolderPath($filename),
            $this->getBaseName($filename)
        );
    }

    public function path($path)
    {
        return (new FilesystemPath($path));
    }
}