PhpTaskman\Core\Config\Config

Complexity

Total Complexity

12

Size/Duplication

Total Lines	129
Duplicated Lines	0 %

Test Coverage

Coverage

83.33%

Importance

Changes

0

3 Methods

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

<?php

declare(strict_types = 1);

namespace PhpTaskman\Core\Config;

use PhpTaskman\Core\Taskman;
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);

        if (false === $composer) {

The condition false === $composer is always false.

            return [];
        }

        $vendorDir = $composer->get('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(),
        ];

        $composerLock = \json_decode(
            \file_get_contents($cwd . '/composer.lock'),
            true
        ) + ['packages' => [], 'packages-dev' => []];

        $packageDirectories = \array_filter(
            \array_map(
                static function ($package) use ($cwd, $vendorDir) {

The import $cwd is not used and could be removed.

                    return \realpath($vendorDir . '/' . $package['name']);
                },
                \array_merge(
                    $composerLock['packages'],
                    $composerLock['packages-dev']
                )
            )
        );

        $packageDirectories[] = $cwd;

        // Loop over each composer.json, deduct the package directory and probe for files to include.
        // @var SplFileInfo $file
        foreach ($packageDirectories as $packageDirectory) {
            foreach ($filesToLoad as $taskmanFile) {
                foreach ([$packageDirectory, $cwd] as $directory) {
                    $candidateFile = $directory . '/' . $taskmanFile;
                    $filesystemPaths[$candidateFile] = $candidateFile;
                }
            }

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

            $extraFiles = $composer->get('extra.taskman.files', []);

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

            foreach ($extraFiles as $commandFile) {
                $filesystemPaths[$commandFile] = $commandFile;
                $commandFile = $packageDirectory . '/' . $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();
    }
}