PhpTaskman\Core\Config\Config

Complexity

Total Complexity

11

Size/Duplication

Total Lines	117
Duplicated Lines	0 %

Test Coverage

Coverage

78.56%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	getLocalConfigurationFilepath()	0	15	4
B	findFilesToIncludeInConfiguration()	0	62	6
A	resolveImports()	0	4	1

<?php

declare(strict_types = 1);

namespace PhpTaskman\Core\Config;

use PhpTaskman\Core\Taskman;
use Symfony\Component\Finder\Finder;
use Symfony\Component\Finder\SplFileInfo;

final class Config
{
    /**
     * Find the files to include in the configuration.
     *
     * @param string $cwd
     *   The current working directory.
     *
     * @return string[]
     *   The list of all the YAML files to include.
     */
    public static function findFilesToIncludeInConfiguration($cwd)
    {
        // Get the vendor-bin property from the composer.json.
        $composer = Taskman::getComposerFromDirectory($cwd);
        $vendorDir = $composer->getConfig('vendor-dir') ?? $cwd . '/vendor';

        // Keep a reference of the default filename that we need to load from
        // each packages.
        $filesToLoad = [
            'taskman.yml.dist',
            'taskman.yml',
        ];

        // Load default paths.
        $filesystemPaths = [
            __DIR__ . '/../config/default.yml',
            __DIR__ . '/../default.yml',
            static::getLocalConfigurationFilepath(),
        ];

        // Find all the composer.json to parse.
        $finder = (new Finder())
            ->files()
            ->exclude('tests')
            ->in([\dirname(\realpath($vendorDir)), $cwd])
            ->name('composer.json');

        // Loop over each composer.json, deduct the package directory and probe for files to include.
        /** @var SplFileInfo $file */
        foreach ($finder as $file) {
            $composerPackageDirectory = \dirname($file->getPathname());

            foreach ($filesToLoad as $taskmanFile) {
                foreach ([$composerPackageDirectory, $cwd] as $directory) {
                    $candidateFile = $directory . '/' . $taskmanFile;
                    $filesystemPaths[$candidateFile] = $candidateFile;
                }
            }

            $composer = Taskman::getComposerFromDirectory(
                $composerPackageDirectory
            );

            $extra = $composer->getExtra();

            if (empty($extra)) {
                continue;
            }

            $extra += ['taskman' => []];
            $extra['taskman'] += ['files' => []];

            foreach ($extra['taskman']['files'] as $commandFile) {
                $filesystemPaths[$commandFile] = $commandFile;
                $commandFile = $composerPackageDirectory . '/' . $commandFile;
                $filesystemPaths[$commandFile] = $commandFile;
            }
        }

        return \array_filter(
            static::resolveImports(...\array_values($filesystemPaths)),
            'file_exists'
        );
    }

    /**
     * Get the local configuration filepath.
     *
     * @param string $configuration_file
     *   The default filepath.
     *
     * @return null|string
     *   The local configuration file path, or null if it doesn't exist.
     */
    public static function getLocalConfigurationFilepath($configuration_file = 'phptaskman/taskman.yml')
    {
        if ($config = \getenv('PHPTASKMAN_CONFIG')) {
            return $config;
        }

        if ($config = \getenv('XDG_CONFIG_HOME')) {
            return $config . '/' . $configuration_file;
        }

        if ($home = \getenv('HOME')) {

The assignment to $home is dead and can be removed.

            return \getenv('HOME') . '/.config/' . $configuration_file;
        }

        return null;
    }

    /**
     * Resolve YAML configurations files containing imports.
     *
     * Handles circular dependencies by ignoring them.
     *
     * @param string[] ...$filepaths
     *   A list of YML filepath to parse.
     *
     * @return string[]
     *   The list of all the YAML files to include.
     */
    public static function resolveImports(...$filepaths)
    {
        return (new YamlRecursivePathsFinder($filepaths))
            ->getAllPaths();
    }
}