Junty\TaskRunner\Runner\Runner

Complexity

Total Complexity

29

Size/Duplication

Total Lines	163
Duplicated Lines	18.4 %

Coupling/Cohesion

Components	1
Dependencies	2

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	group()	11	11	3
A	task()	11	11	3
A	__set()	0	4	1
A	order()	0	14	4
A	getTasks()	0	4	1
A	getGroups()	0	4	1
A	getOrder()	0	4	1
A	run()	0	17	4
B	runTask()	0	16	6
A	runGroup()	0	9	3
A	getFromOrderData()	8	8	1

<?php
/**
 * Junty
 *
 * @author Gabriel Jacinto aka. GabrielJMJ <gamjj74@hotmail.com>
 * @license MIT License
 */
 
namespace Junty\TaskRunner\Runner;

use Junty\TaskRunner\Runner\RunnerInterface;
use Junty\TaskRunner\Task\{
    Task,
    TaskInterface,
    Group,
    GroupInterface,
    TasksCollection,
    GroupsCollection
};

class Runner implements RunnerInterface
{
    private $tasks;

    private $groups = [];

    private $order;

    public function __construct()
    {
        $this->tasks = new TasksCollection();
        $this->groups = new GroupsCollection();

It seems like new \Junty\TaskRunner\Task\GroupsCollection() of type object<Junty\TaskRunner\Task\GroupsCollection> is incompatible with the declared type array of property $groups.

    }

    public function group($group, callable $tasks = null)

This method seems to be duplicated in your project.

    {
        $_name = $group instanceof GroupInterface ? $group->getName() : $group;

        if ($this->tasks->containsKey($_name)) {
            throw new \Exception('Is not possible to register a group and a task with the same name.');
        }

        $this->groups->set($group, $tasks);

The method set cannot be called on $this->groups (of type array).

        $this->order[] = 'group::' . $_name;
    }

    /**
     * Registres a task
     *
     * @param string|TaskInterface $task
     * @param callable             $callback
     */
    public function task($task, callable $callback = null)

This method seems to be duplicated in your project.

    {
        $_name = $task instanceof TaskInterface ? $task->getName() : $task;

        if ($this->groups->containsKey($_name)) {

The method containsKey cannot be called on $this->groups (of type array).

            throw new \Exception('Is not possible to register a group and a task with the same name.');
        }

        $this->tasks->set($task, $callback);

It seems like $callback defined by parameter $callback on line 53 can also be of type null; however, Junty\TaskRunner\Task\TasksCollection::set() does only seem to accept callable, maybe add an additional type check?

        $this->order[] = 'task::' . $_name;
    }

    /**
     * Allows create a task setting a property
     *
     * @param string|TaskInterface $task
     * @param callable             $callback
     */
    public function __set(string $task, callable $callback)
    {
        $this->task($task, $callback);
    }

    /**
     * Organize tasks and groups order
     * If this method is executed and a task and a group is not in this list, it won't be executed
     *
     * @param string-variadic $tasks

The doc-type string-variadic could not be parsed: Unknown type name "string-variadic" at position 0. (view supported doc-types)

There is no parameter named $tasks. Was it maybe removed?

     */
    public function order(string ...$names)
    {
        foreach ($names as $key => $name) {
            if ($this->tasks->containsKey($name)) {
                $names[$key] = 'task::' . $name;
            } elseif ($this->groups->containsKey($name)) {

The method containsKey cannot be called on $this->groups (of type array).

                $names[$key] = 'group::' . $name;
            } else {
                throw new \Exception('\'' . $name . '\' is not registred as task or group.');
            }
        }

        $this->order = $names;
    }

    /**
     * Returns all registred tasks
     *
     * @return TasksCollection
     */
    public function getTasks() : TasksCollection
    {
        return $this->tasks;
    }

    public function getGroups() : GroupsCollection
    {
        return $this->groups;
    }

    public function getOrder() : array
    {
        return $this->order;
    }

    /**
     * Runs all tasks
     */
    public function run()
    {
        $all = $this->order;

        foreach ($all as $el) {
            $data = $this->getFromOrderData($el);

            switch ($data['type']) {
                case 'group':
                    $this->runGroup($data['name']);
                    break;
                case 'task':
                    $this->runTask($data['name']);
                    break;
            }
        }
    }

    /**
     * Runs one single task
     *
     * @param string|TaskInterface $task
     */
    public function runTask($task)
    {
        if (!is_string($task) && !$task instanceof TaskInterface) {
            throw new \Exception('Invalid task type: ' + gettype($task));
        }

        if (is_string($task)) {
            if (!isset($this->tasks[$task])) {
                throw new \Exception('\'' . $task . '\' is not a registred task.');
            }
        }

        $task = $task instanceof TaskInterface ? $task : $this->tasks[$task];
        $cb = $task->getCallback();
        $cb();
    }

    /**
     * Runs a group of tasks
     *
     * @param string|GroupInterface $group
     */
    public function runGroup($group)
    {
        $group = $group instanceof GroupInterface ? $group : $this->groups[$group];
        $tasks = $group->getTasks();

        foreach ($tasks as $task) {
            $this->runTask($task);
        }
    }

    private function getFromOrderData($name)

This method seems to be duplicated in your project.

    {
        $parts = explode('::', $name);
        $type = $parts[0];
        unset($parts[0]);

        return ['type' => $type, 'name' => implode('::', $parts)];
    }
}