allejo\stakx\System\Filesystem

Complexity

Total Complexity

25

Size/Duplication

Total Lines	221
Duplicated Lines	8.14 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

18.75%

Importance

Changes	3
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	appendPath()	0	4	1
A	getRelativePath()	0	4	1
B	copy()	0	26	6
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	removeExtension()	0	7	1
A	writeFile()	18	18	2
A	absolutePath()	0	12	2
C	getFinder()	0	38	7

<?php

/**
 * This file contains an extended Filesystem class.
 *
 * This file is part of the Stakx project.
 *
 * @copyright 2016 Vladimir Jimenez
 * @license   https://github.com/allejo/stakx/blob/master/LICENSE.md
 */

namespace allejo\stakx\System;

use Symfony\Component\Filesystem\Exception\IOException;
use Symfony\Component\Filesystem\Exception\FileNotFoundException;
use Symfony\Component\Finder\Finder;
use Symfony\Component\Finder\SplFileInfo;

/**
 * Class Filesystem
 *
 * This class extends Symfony's Filesystem to provide convenience functions
 *
 * @package allejo\stakx\Environment
 */
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 ($this->isAbsolutePath($pathFragments))
        {
            return $pathFragments;
        }

        $args = func_get_args();
        array_unshift($args, getcwd());

        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);
        }
    }

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

    public function getFinder ($explicitIncludes = array(), $explicitIgnores = array(), $searchIn = "")
    {
        $finder = new Finder();
        $finder->files()
               ->ignoreVCS(true)
               ->ignoreDotFiles(true)
               ->ignoreUnreadableDirs();

        $finder->in(
            empty(trim($searchIn)) ? getcwd() : $searchIn
        );

        foreach ($explicitIgnores as $ignoreRule)
        {
            $isRegex = @preg_match($ignoreRule, null);

            if (substr($ignoreRule, -1, 1) === '/' || $isRegex !== false)
            {
                $finder->notPath($ignoreRule);
            }
            else
            {
                $finder->notName($ignoreRule);
            }
        }

        if (count($explicitIncludes) > 0)
        {
            foreach ($explicitIncludes as &$include)
            {
                $include = new SplFileInfo($include, $this->getFolderPath($include), $include);
            }

            $finder->append($explicitIncludes);
        }

        return $finder;
    }

    /**
     * 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);
    }

    /**
     * @param string $folderPath
     */
    public function isDir ($folderPath)
    {
        return is_dir($folderPath);
    }

    /**
     * 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)
               );
    }

    /**
     * Write a file
     *
     * @param string $targetDir The directory of where the file will be created; the file name is a separate variable
     * @param string $fileName  The name of the file
     * @param string $content   The content that belongs in the file
     *
     * @return SplFileInfo A reference to the newly created file
     */
    public function writeFile ($targetDir, $fileName, $content)

This method seems to be duplicated in your project.

    {
        $outputFolder = $this->getFolderPath($this->absolutePath($targetDir, $fileName));
        $targetFile   = $this->getFileName($fileName);

        if (!file_exists($outputFolder))
        {
            mkdir($outputFolder, 0755, true);
        }

        file_put_contents($this->appendPath($outputFolder, $targetFile), $content, LOCK_EX);

        return (new SplFileInfo(
            $fileName,
            $this->absolutePath($targetDir),
            $this->absolutePath($targetDir, $fileName))
        );
    }
}