Churn\Managers\FileManager

Complexity

Total Complexity

10

Size/Duplication

Total Lines	108
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getPhpFiles()	0	9	2
A	getPhpFilesFromPath()	0	7	2
A	collectFile()	0	12	3
A	fileShouldBeIgnored()	0	12	1
A	patternToRegex()	0	5	1

<?php declare(strict_types = 1);

namespace Churn\Managers;

use Churn\Collections\FileCollection;
use Churn\Values\File;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use SplFileInfo;

class FileManager
{
    /**
     * Collection of File objects.
     * @var FileCollection;
     */
    private $files;

    /**
     * List of file extensions to look for.
     * @var array
     */
    private $fileExtensions;

    /**
     * List of files to ignore.
     * @var array
     */
    private $filesToIgnore;

    /**
     * FileManager constructor.
     * @param array $fileExtensions List of file extensions to look for.
     * @param array $filesToIgnore  List of files to ignore.
     */
    public function __construct(array $fileExtensions, array $filesToIgnore)
    {
        $this->fileExtensions = $fileExtensions;
        $this->filesToIgnore = $filesToIgnore;
    }

    /**
     * Recursively finds all files with the .php extension in the provided
     * $paths and returns list as array.
     * @param  array $paths Paths in which to look for .php files.
     * @return FileCollection
     */
    public function getPhpFiles(array $paths): FileCollection
    {
        $this->files = new FileCollection;
        foreach ($paths as $path) {
            $this->getPhpFilesFromPath($path);
        }

        return $this->files;
    }

    /**
     * Recursively finds all files with the .php extension in the provided
     * $path adds them to $this->files.
     * @param  string $path Path in which to look for .php files.
     * @return void
     */
    private function getPhpFilesFromPath(string $path): void
    {
        $directoryIterator = new RecursiveDirectoryIterator($path);
        foreach (new RecursiveIteratorIterator($directoryIterator) as $file) {
            $this->collectFile($file);
        }
    }

    /**
     * Collects file information unless it should be ignored.
     * @param SplFileInfo $file The file information.
     * @return void
     */
    private function collectFile(SplFileInfo $file): void
    {
        if (! in_array($file->getExtension(), $this->fileExtensions)) {
            return;
        }

        if ($this->fileShouldBeIgnored($file)) {
            return;
        }

        $this->files->push(new File(['displayPath' => $file->getPathName(), 'fullPath' => $file->getRealPath()]));
    }

    /**
     * Determines if a file should be ignored.
     * @param \SplFileInfo $file File.
     * @return boolean
     */
    private function fileShouldBeIgnored(SplFileInfo $file): bool
    {
        $path = $file->getPathname();

        $matchingFilesToIgnore = array_filter($this->filesToIgnore, function (string $fileToIgnore) use ($path): bool {
            $regex = $this->patternToRegex($fileToIgnore);

            return preg_match("#{$regex}#", $path) === 1;
        });

        return 0 < count($matchingFilesToIgnore);
    }

    /**
     * Translate file path pattern to regex string.
     * @param string $filePattern File pattern to be ignored.
     * @return string
     */
    private function patternToRegex(string $filePattern): string
    {
        $regex = preg_replace("#/(.*)\*([\w.]*)$#", "/$1.+$2$", $filePattern);
        return $regex;
    }
}