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

Passed
Push — master ( 9e0b2c...e0b23c )

by Pol
created 2019-04-18 10:50 UTC
CollectionFactory::simulate() A

↳ Parent: CollectionFactory
Complexity

Conditions	3
Paths	3
Size

Total Lines	8
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	12
Importance

Changes
Metric	Value
cc	3
eloc	4
nc	3
nop	1
dl	0
loc	8
ccs	0
cts	7
cp	0
crap	12
rs	10
c	0
b	0
f	0
<?php

declare(strict_types = 1);

namespace PhpTaskman\Core\Robo\Task\CollectionFactory;

use PhpTaskman\Core\Contract\ConfigurationTokensAwareInterface;
use PhpTaskman\Core\Robo\Task\Filesystem\LoadFilesystemTasks;
use PhpTaskman\Core\Robo\Task\ProcessConfigFile\LoadProcessConfigFileTasks;
use PhpTaskman\Core\Traits\ConfigurationTokensTrait;
use Robo\Contract\BuilderAwareInterface;
use Robo\Contract\SimulatedInterface;
use Robo\Exception\TaskException;
use Robo\LoadAllTasks;
use Robo\Robo;
use Robo\Task\BaseTask;
use Symfony\Component\Yaml\Yaml;

/**
 * Class CollectionFactory.
 *
 * Return a task collection given its array representation.
 */
final class CollectionFactory extends BaseTask implements
    BuilderAwareInterface,
    SimulatedInterface,
    ConfigurationTokensAwareInterface
{
    use ConfigurationTokensTrait;
    use LoadAllTasks;
    use LoadFilesystemTasks;
    use LoadProcessConfigFileTasks;

    /**
     * @var array
     */
    protected $options;

    /**
     * @var array
     */
    protected $tasks;

    /**
     * CollectionFactory constructor.
     *
     * @param array $tasks
     * @param array $options
     */
    public function __construct(array $tasks = [], array $options = [])
    {
        $this->tasks = $tasks;
        $this->options = $options;
    }

    /**
     * @return string
     */
    public function getHelp()
    {
        return $this->tasks['help'] ?? 'Yaml command defined in tasks.yml';
    }

    /**
     * @return array
     */
    public function getTasks()
    {
        return $this->tasks['tasks'] ?? $this->tasks;
    }

    /**
     * {@inheritdoc}
     */
    public function run()
    {
        $collection = $this->collectionBuilder();

        foreach ($this->getTasks() as $task) {
            if (\is_string($task)) {
                $collection->addTask($this->taskExec($task));

                continue;
            }

            if (!\is_array($task)) {
                // Todo: Error.
                continue;
            }

            if (!isset($task['task'])) {
                // Todo: Error.
                continue;
            }

            if (!\is_string($task['task'])) {
                // Todo: Error.
                continue;
            }

            $collection->addTask($this->taskFactory($task));
        }

        return $collection->run();
    }

    /**
     * {@inheritdoc}
     */
    public function simulate($context)
    {
        foreach ($this->getTasks() as $task) {
            if (\is_array($task)) {
                $task = Yaml::dump($task, 0);
            }

            $this->printTaskInfo($task, $context);
        }
    }

    /**
     * Secure option value.
     *
     * @param array  $task
     * @param string $name
     * @param mixed  $default
     */
    protected function secureOption(array &$task, $name, $default)
    {
        $task[$name] = $task[$name] ?? $default;
    }

    /**
     * @param array|string $task
     *
     * @throws \Robo\Exception\TaskException
     *
     * @return \Robo\Contract\TaskInterface
     *
     * @SuppressWarnings(PHPMD)
     */
    protected function taskFactory($task)
    {
        $this->secureOption($task, 'force', false);
        $this->secureOption(/** @scrutinizer ignore-type */ $task, 'force', false);
        $this->secureOption($task, 'umask', 0000);
        $this->secureOption($task, 'recursive', false);
        $this->secureOption($task, 'time', \time());
        $this->secureOption($task, 'atime', \time());
        $this->secureOption($task, 'mode', 0777);

        $taskMap = [
            'mkdir' => [
                'factory' => 'taskFilesystemFactory',
                'command' => 'mkdir',
                'parameters' => [
                    'dir',
                    'mode',
                ],
            ],
            'touch' => [
                'factory' => 'taskFilesystemFactory',
                'command' => 'touch',
                'parameters' => [
                    'file',
                    'time',
                    'atime',
                ],
            ],
            'copy' => [
                'factory' => 'taskFilesystemFactory',
                'command' => 'copy',
                'parameters' => [
                    'from',
                    'to',
                    'force',
                ],
            ],
            'chmod' => [
                'factory' => 'taskFilesystemFactory',
                'command' => 'chmod',
                'parameters' => [
                    'file',
                    'permissions',
                    'umask',
                    'recursive',
                ],
            ],
            'chgrp' => [
                'factory' => 'taskFilesystemFactory',
                'command' => 'chgrp',
                'parameters' => [
                    'file',
                    'group',
                    'recursive',
                ],
            ],
            'chown' => [
                'factory' => 'taskFilesystemFactory',
                'command' => 'chown',
                'parameters' => [
                    'file',
                    'user',
                    'recursive',
                ],
            ],
            'remove' => [
                'factory' => 'taskFilesystemFactory',
                'command' => 'remove',
                'parameters' => [
                    'file',
                ],
            ],
            'rename' => [
                'factory' => 'taskFilesystemFactory',
                'command' => 'rename',
                'parameters' => [
                    'from',
                    'to',
                    'force',
                ],
            ],
            'symlink' => [
                'factory' => 'taskFilesystemFactory',
                'command' => 'symlink',
                'parameters' => [
                    'from',
                    'to',
                ],
            ],
            'mirror' => [
                'factory' => 'taskFilesystemFactory',
                'command' => 'mirror',
                'parameters' => [
                    'from',
                    'to',
                ],
            ],
            'process' => [
                'factory' => 'taskProcessConfigFile',
                'command' => 'process',
                'parameters' => [
                    'source',
                    'destination',
                ],
            ],
        ];

        if (isset($taskMap[$task['task']])) {
            $parameters = [];

            foreach ($taskMap[$task['task']]['parameters'] as $key) {
                if (isset($task[$key])) {
                    $parameters[$key] = $task[$key];
                }
            }

            return $this->{$taskMap[$task['task']]['factory']}($task['task'], $parameters);
        }

        switch ($task['task']) {
            case 'append':
                return $this->collectionBuilder()->addTaskList([
                    $this->taskWriteToFile($task['file'])->append()->text($task['text']),
                    $this->taskProcessConfigFile($task['file'], $task['file']),
                ]);

            case 'run':
                $taskExec = $this->taskExec(
                    $this->getConfig()->get('taskman.bin_dir') . '/taskman'
                )->arg($task['command']);

                $container = Robo::getContainer();

                /** @var \Robo\Application $app */
                $app = $container->get('application');

                /** @var \Consolidation\AnnotatedCommand\AnnotatedCommand $command */
                $command = $app->get($task['command']);
                $commandOptions = $command->getDefinition()->getOptions();

                // Propagate any input option passed to the child command.
                foreach ($this->options as $name => $values) {
                    if (!isset($commandOptions[$name])) {
                        continue;
                    }

                    // But only if the called command has this option.
                    foreach ((array) $values as $value) {
                        $taskExec->option($name, $value);
                    }
                }

                return $taskExec;
            default:
                throw new TaskException($this, "Task '{$task['task']}' not supported.");
        }
    }
}

php-taskman / core

Push — master ( 9e0b2c...e0b23c )

CollectionFactory::simulate() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
