Runner::createApplication() - Code Metrics - Inspection of "Initial commit." - php-taskman/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 13fa34...dc56c0 )

by Pol
created 2019-04-17 17:26 UTC
Runner::createApplication() A

↳ Parent: Runner
Complexity

Conditions	1
Paths	1
Size

Total Lines	17
Code Lines	11
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2
Importance

Changes
Metric	Value
eloc	11
dl	0
loc	17
ccs	0
cts	15
cp	0
rs	9.9
c	0
b	0
f	0
cc	1
nc	1
nop	0
crap	2
<?php

declare(strict_types = 1);

namespace phptaskman\core;

use Composer\Autoload\ClassLoader;
use Consolidation\AnnotatedCommand\AnnotatedCommand;
use phptaskman\core\Contract\ComposerAwareInterface;
use phptaskman\core\Robo\Plugin\Commands\YamlCommands;
use phptaskman\core\Config\YamlRecursivePathsFinder;
use phptaskman\core\Services\Composer;
use League\Container\ContainerAwareTrait;
use Robo\Application;
use Robo\Common\ConfigAwareTrait;
use Robo\Config\Config;
use Robo\Robo;
use Symfony\Component\Console\Input\ArgvInput;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\ConsoleOutput;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Finder\Finder;

/**
 * Class Runner.
 */
final class Runner
{
    use ConfigAwareTrait;
    use ContainerAwareTrait;

    public const APPLICATION_NAME = 'Taskman';

    /**
     * @var Application
     */
    private $application;

    /**
     * @var \Composer\Autoload\ClassLoader
     */
    private $classLoader;

    /**
     * @var array
     */
    private $defaultCommandClasses = [
        YamlCommands::class,
    ];

    /**
     * @var InputInterface
     */
    private $input;

    /**
     * @var OutputInterface
     */
    private $output;

    /**
     * @var \Robo\Runner
     */
    private $runner;

    /**
     * @var string
     */
    private $workingDir;

    /**
     * Runner constructor.
     *
     * @param InputInterface $input
     * @param OutputInterface $output
     * @param ClassLoader $classLoader
     */
    public function __construct(
        InputInterface $input = null,
        OutputInterface $output = null,
        ClassLoader $classLoader = null
    ) {
        $this->input = $input ?? new ArgvInput();
        $this->output = $output ?? new ConsoleOutput();
        $this->classLoader = $classLoader ?? new ClassLoader();

        $this->workingDir = $this->getWorkingDir($this->input);
        \chdir($this->workingDir);

        $this->config = $this->createConfiguration();

        $this->application = $this->createApplication();
        $this->application->setAutoExit(false);

        $this->container = $this->createContainer(
            $this->input,
            $this->output,
            $this->application,
            $this->config,
            $this->classLoader
        );

        $this->runner = (new \Robo\Runner())
            ->setRelativePluginNamespace('Robo\Plugin')
            ->setContainer($this->container);
    }

    /**
     * @param mixed $args
     *
     * @return int
     */
    public function run($args)
    public function run(/** @scrutinizer ignore-unused */ $args)
    {
        // Register command classes.
        $this->runner->registerCommandClasses($this->application, $this->defaultCommandClasses);

        // Register commands defined in task.yml file.
        $this->registerDynamicCommands($this->application);

        // Run command.
        return $this->runner->run($this->input, $this->output, $this->application);
    }

    /**
     * @param \Consolidation\AnnotatedCommand\AnnotatedCommand $command
     * @param array $commandDefinition
     */
    private function addOptions(AnnotatedCommand $command, array $commandDefinition)
    {
        // This command doesn't define any option.
        if (empty($commandDefinition['options'])) {
            return;
        }

        $defaults = \array_fill_keys(['shortcut', 'mode', 'description', 'default'], null);
        foreach ($commandDefinition['options'] as $optionName => $optionDefinition) {
            $optionDefinition += $defaults;
            $command->addOption(
                '--' . $optionName,
                $optionDefinition['shortcut'],
                $optionDefinition['mode'],
                $optionDefinition['description'],
                $optionDefinition['default']
            );
        }
    }

    /**
     * Create application.
     *
     * @return \Robo\Application
     */
    private function createApplication()
    {
        $application = new Application(self::APPLICATION_NAME, 'UNKNOWN');

        $application
            ->getDefinition()
            ->addOption(
                new InputOption(
                    '--working-dir',
                    null,
                    InputOption::VALUE_REQUIRED,
                    'Working directory, defaults to current working directory.',
                    $this->workingDir
                )
            );

        return $application;
    }

    /**
     * Create default configuration.
     *
     * @return Config
     */
    private function createConfiguration()
    {
        // Load default paths.
        $filesystemPaths = [
            __DIR__ . '/../config/default.yml',
            __DIR__ . '/../default.yml',
            'taskman.yml.dist',
            'taskman.yml',
            \getcwd() . '/taskman.yml.dist',
            \getcwd() . '/taskman.yml',
            $this->getLocalConfigurationFilepath(),
        ];

        // Get the vendor-bin property from the composer.json.
        $composer = Taskman::getComposerFromDirectory(getcwd());
        $vendorDir = $composer->getConfig('vendor-dir') ?? \getcwd() . '/vendor';

        // Load extra section from original composer.json file.
        // Sometimes the vendor-dir can on a complete different location.
        $extra = $composer->getExtra() + ['taskman' => []];
        $extra['taskman'] += ['files' => []];

        foreach ($extra['taskman']['files'] as $file) {
            $filesystemPaths[$file] = $file;
        }

        // Load files listed in extra section of each composer.json files.
        $finder = (new Finder())
            ->files()
            ->in(\dirname(\realpath($vendorDir)))
            ->name('composer.json');

        foreach ($finder as $file) {
            $composer = Taskman::getComposerFromDirectory(
                \dirname($file->getRealPath())
            );

            $extra = $composer->getExtra();

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

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

            foreach ($extra['taskman']['files'] as $commandFile) {
                if (file_exists($commandFile)) {
                    $filesystemPaths[] = $commandFile;
                    continue;
                }

                $commandFile = \dirname($file->getRealPath()) . '/' . $commandFile;

                if (file_exists($commandFile)) {
                    $filesystemPaths[] = $commandFile;
                    continue;
                }
            }
        }

        // Resolve imports if any.
        $paths = (new YamlRecursivePathsFinder($filesystemPaths))
            ->getAllPaths();

        $config = new Config();
        $config->set('taskman.working_dir', \realpath($this->workingDir));

        Robo::loadConfiguration($paths, $config);

        return $config;
    }

    /**
     * Create and configure container.
     *
     * @param \Symfony\Component\Console\Input\InputInterface $input
     * @param \Symfony\Component\Console\Output\OutputInterface $output
     * @param \Robo\Application $application
     * @param \Robo\Config\Config $config
     * @param \Composer\Autoload\ClassLoader $classLoader
     *
     * @return \League\Container\Container|\League\Container\ContainerInterface
     */
    private function createContainer(
        InputInterface $input,
        OutputInterface $output,
        Application $application,
        Config $config,
        ClassLoader $classLoader
    ) {
        $container = Robo::createDefaultContainer($input, $output, $application, $config, $classLoader);
        $container->get('commandFactory')->setIncludeAllPublicMethods(false);
        $container->share('taskman.composer', Composer::class)->withArgument($this->workingDir);

        // Add service inflectors.
        if (null !== $service = $container->inflector(ComposerAwareInterface::class)) {
            $service->invokeMethod('setComposer', ['taskman.composer']);
        }

        return $container;
    }

    /**
     * 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.
     */
    private 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')) {

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

        return null;
    }
    /**
     * @param string $command
     *
     * @throws \InvalidArgumentException
     *
     * @return array
     */
    private function getTasks($command)
    {
        $commands = $this->getConfig()->get('commands', []);

        if (!isset($commands[$command])) {
            throw new \InvalidArgumentException("Custom command '${command}' not defined.");
        }

        return !empty($commands[$command]['tasks']) ? $commands[$command]['tasks'] : $commands[$command];
    }

    /**
     * @param \Symfony\Component\Console\Input\InputInterface $input
     *
     * @return mixed
     */
    private function getWorkingDir(InputInterface $input)
    {
        return $input->getParameterOption('--working-dir', \getcwd());
    }

    /**
     * @param \Robo\Application $application
     */
    private function registerDynamicCommands(Application $application)
    {
        $customCommands = $this->getConfig()->get('commands', []);
        foreach ($customCommands as $name => $commandDefinition) {
            /** @var \Consolidation\AnnotatedCommand\AnnotatedCommandFactory $commandFactory */
            $commandFileName = YamlCommands::class . 'Commands';
            $commandClass = $this->container->get($commandFileName);
            $commandFactory = $this->container->get('commandFactory');
            $commandInfo = $commandFactory->createCommandInfo($commandClass, 'runTasks');
            $command = $commandFactory->createCommand($commandInfo, $commandClass)->setName($name);

            // Dynamic commands may define their own options.
            $this->addOptions($command, $commandDefinition);

            // Append also options of subsequent tasks.
            foreach ($this->getTasks($name) as $taskEntry) {
                if (!\is_array($taskEntry)) {
                    continue;
                }

                if (!isset($taskEntry['task'])) {
                    continue;
                }

                if ('run' !== $taskEntry['task']) {
                    continue;
                }

                if (empty($taskEntry['command'])) {
                    continue;
                }

                // This is a 'run' task.
                if (!empty($customCommands[$taskEntry['command']])) {
                    // Add the options of another custom command.
                    $this->addOptions($command, $customCommands[$taskEntry['command']]);
                } else {
                    // Add the options of an already registered command.
                    if ($this->application->has($taskEntry['command'])) {
                        $subCommand = $this->application->get($taskEntry['command']);
                        $command->addOptions($subCommand->getDefinition()->getOptions());
                    }
                }
            }

            $application->add($command);
        }
    }
}

php-taskman / core

Push — master ( 13fa34...dc56c0 )

Runner::createApplication() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
