allejo\stakx\System\Folder

Complexity

Total Complexity

13

Size/Duplication

Total Lines	139
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

62.96%

Importance

Changes	2
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__toString()	0	4	1
A	buildPath()	0	6	1
A	getCwd()	0	6	1
B	__construct()	0	28	4
A	setTargetDirectory()	0	11	3
A	copyFile()	0	10	1
A	writeFile()	0	23	2

<?php

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

namespace allejo\stakx\System;

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

/**
 * All folder paths stored inside of this class will **not** have the ending DIRECTORY_SEPARATOR.
 *
 * @internal
 */
class Folder
{
    protected $fs;

Avoid variables with short names like $fs. Configured minimum length is 3.

    protected $absolutePath;
    protected $targetDirectories;

    /**
     * @param string $folderPath
     */
    public function __construct($folderPath)
    {
        $this->fs = new Filesystem();
        $this->targetDirectories = array();

        // Setup the absolute path to the directory
        if (substr($folderPath, 0, 1) === DIRECTORY_SEPARATOR)
        {
            $this->absolutePath = $folderPath;
        }
        else
        {
            $this->absolutePath = $this->fs->absolutePath($folderPath);
        }

        // Ensure our directory paths will don't end with a '/'
        $this->absolutePath = rtrim($this->absolutePath, DIRECTORY_SEPARATOR);

        if (!$this->fs->isDir($this->absolutePath))
        {
            throw new \InvalidArgumentException();
        }

        if (!$this->fs->exists($this->absolutePath))
        {
            throw new FileNotFoundException();
        }
    }

    public function __toString()
    {
        return rtrim($this->absolutePath, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR;
    }

    /**
     * Set a base folder that will be prefixed before all file writes and copies.
     *
     * @param string $folderName
     *
     * @since 0.1.0
     */
    public function setTargetDirectory($folderName)
    {
        if (is_null($folderName) || empty($folderName))
        {
            $this->targetDirectories = array();
        }
        else
        {
            $this->targetDirectories[] = trim($folderName, DIRECTORY_SEPARATOR);
        }
    }

    /**
     * Copy a file from an absolute file to a path relative to the Folder's location.
     *
     * @param string $absolutePath The absolute path of the file
     * @param string $targetPath   The relative file path to the Folder's location
     *
     * @since 0.1.0
     */
    public function copyFile($absolutePath, $targetPath)
    {
        $targetPath = ltrim($targetPath, DIRECTORY_SEPARATOR);

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

        $this->fs->copy(
            $absolutePath,
            $this->buildPath($this->getCwd(), $targetPath),
            true
        );
    }

    /**
     * Write a file with the specified content.
     *
     * @param string $relativePath The file path relative to this Folder's location
     * @param string $content      The content that will be written to the file
     *
     * @since 0.1.0
     *
     * @return SplFileInfo
     */
    public function writeFile($relativePath, $content)
    {
        $outputFolder = $this->fs->getFolderPath($relativePath);
        $targetFileName = $this->fs->getFileName($outputFolder);

        $absoluteFolderPath = $this->buildPath($this->getCwd(), $outputFolder);

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

        file_put_contents(
            $this->buildPath($this->getCwd(), $relativePath),
            $content
        );

        return (new SplFileInfo(
            $targetFileName,
            $absoluteFolderPath,
            $this->buildPath($absoluteFolderPath, $targetFileName)
        ));
    }

    /**
     * @param string $pathFragments
     *
     * @return string
     */
    private function buildPath($pathFragments)

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

    {
        $paths = func_get_args();

        return implode(DIRECTORY_SEPARATOR, $paths);
    }

    /**
     * Returns the absolute path of where files will be placed.
     *
     * @return string
     */
    private function getCwd()
    {
        $location = array_merge(array($this->absolutePath), $this->targetDirectories);

        return implode(DIRECTORY_SEPARATOR, $location);
    }
}