Bldr\Block\Core\Service\Builder

Complexity

Total Complexity

15

Size/Duplication

Total Lines	143
Duplicated Lines	0 %

Coupling/Cohesion

Dependencies

13

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	runJobs()	0	10	2
B	runJob()	0	50	6
B	prepareServiceForTask()	0	26	6

<?php

/**
 * This file is part of Bldr.io
 *
 * (c) Aaron Scherer <aequasi@gmail.com>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE
 */

namespace Bldr\Block\Core\Service;

use Bldr\Block\Core\Task\AbstractTask;
use Bldr\Definition\JobDefinition;
use Bldr\Definition\TaskDefinition;
use Bldr\Event;
use Bldr\Event\PreTaskEvent;
use Bldr\Exception\TaskRuntimeException;
use Bldr\Registry\JobRegistry;
use Bldr\Registry\TaskRegistry;
use Bldr\Task\TaskInterface;
use Symfony\Component\Console\Helper\HelperSet;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Helper\FormatterHelper;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;

/**
 * @author Aaron Scherer <aequasi@gmail.com>
 */
class Builder
{
    /**
     * @var EventDispatcherInterface $dispatcher
     */
    private $dispatcher;

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

    /**
     * @type HelperSet
     */
    private $helperSet;

    /**
     * @type TaskRegistry $taskRegistry
     */
    private $taskRegistry;

    /**
     * @param EventDispatcherInterface $dispatcher
     * @param OutputInterface          $output
     * @param HelperSet                $helperSet
     * @param TaskRegistry             $taskRegistry
     */
    public function __construct(
        EventDispatcherInterface $dispatcher,
        OutputInterface $output,
        HelperSet $helperSet,
        TaskRegistry $taskRegistry
    ) {
        $this->dispatcher   = $dispatcher;
        $this->output       = $output;
        $this->helperSet    = $helperSet;
        $this->taskRegistry = $taskRegistry;
    }

    /**
     * @param JobRegistry $registry
     */
    public function runJobs(JobRegistry $registry)
    {
        while ($registry->count() > 0) {
            $job = $registry->getNewJob();

            $this->runJob($job);

It seems like $job defined by $registry->getNewJob() on line 77 can also be of type false; however, Bldr\Block\Core\Service\Builder::runJob() does only seem to accept object<Bldr\Definition\JobDefinition>, did you maybe forget to handle an error condition?

            $registry->markJobComplete($job);

The call to JobRegistry::markJobComplete() has too many arguments starting with $job.

        }
    }

    /**
     * @param JobDefinition $job
     *
     * @throws \Exception
     */
    public function runJob(JobDefinition $job)
    {
        $this->output->writeln(
            [
                "\n",
                sprintf(
                    '<info>Running the %s job</info><comment>%s</comment>',
                    $job->getName(),
                    $job->getDescription() !== '' ? " > ".$job->getDescription() : ''
                )
            ]
        );

        foreach ($job->getTasks() as $task) {
            $preTaskEvent = new PreTaskEvent($job, $task);
            $this->dispatcher->dispatch(Event::PRE_TASK, $preTaskEvent);

            if ($preTaskEvent->isPropagationStopped()) {
                continue;
            }

            $service = $this->taskRegistry->findTaskByType($task->getType());
            $this->prepareServiceForTask($service, $task);

            try {
                $service->run($this->output);
            } catch (TaskRuntimeException $e) {
                if (!$task->continueOnError()) {
                    throw $e;
                }

                /** @var FormatterHelper $formatter */
                $formatter = $this->helperSet->get('formatter');
                $this->output->writeln(
                    [
                        '',
                        $formatter->formatBlock(
                            [
                                sprintf('[Warning] Task: %s', $task->getType()),
                                sprintf('%s', $e->getMessage())
                            ],
                            'bg=yellow;fg=black',
                            true
                        ),
                        ''
                    ]
                );
            }
        }
    }

    /**
     * @param TaskInterface  $service
     * @param TaskDefinition $task
     *
     * @return TaskInterface
     */
    private function prepareServiceForTask(TaskInterface $service, TaskDefinition $task)
    {
        $this->dispatcher->dispatch(Event::PRE_INITIALIZE_TASK, new Event\PreInitializeTaskEvent($service));

        if ($service instanceof AbstractTask) {
            $service->configure();
        }

        if (method_exists($service, 'setEventDispatcher')) {
            $service->setEventDispatcher($this->dispatcher);
        }

        if (method_exists($service, 'setHelperSet')) {
            $service->setHelperSet($this->helperSet);
        }

        foreach ($task->getParameters() as $name => $value) {
            $service->setParameter($name, $value);
        }

        if (method_exists($service, 'validate')) {
            $service->validate();
        }

        return $service;
    }
}