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

Completed
Push — master ( c1a557...09df77 )

by Pol
created 2019-04-18 09:07 UTC
Runner::createConfiguration() A

↳ Parent: Runner
Complexity

Conditions	1
Paths	1
Size

Total Lines	15
Code Lines	6
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2
Importance

Changes
Metric	Value
eloc	6
dl	0
loc	15
ccs	0
cts	9
cp	0
rs	10
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\Services\Composer;
use phptaskman\core as Taskman;
.
|-- OtherDir
|   |-- Bar.php
|   `-- Foo.php
`-- SomeDir
    `-- Foo.php
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;

/**
 * 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()
    {
        // Create a default configuration.
        $config = Robo::createConfiguration([]);

        // Set the variable working_dir.
        $config->set('taskman.working_dir', \realpath($this->workingDir));

        // Load the configuration.
        Robo::loadConfiguration(
            Taskman\Config\Config::findFilesToIncludeInConfiguration($this->workingDir),
            $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;
    }

    /**
     * @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 ( c1a557...09df77 )

Runner::createConfiguration() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
