Imanghafoori\HeyMan\Reactions\ReactionFactory

Complexity

Total Complexity

10

Size/Duplication

Total Lines	77
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	make()	0	8	2
A	convertToClosures()	0	17	4
A	makeReaction()	0	18	2
A	makePreResponseActions()	0	10	2

<?php

namespace Imanghafoori\HeyMan\Reactions;

use Imanghafoori\HeyMan\ChainManager;

final class ReactionFactory
{
    /**
     * @return \Closure
     */
    public function make(): \Closure
    {
        $reaction = $this->makeReaction();
        $condition = resolve(ChainManager::class)->get('condition');

        return function (...$f) use ($condition, $reaction) {
            if (!$condition($f)) {
                $reaction();
            }
        };
    }

    private function makeReaction(): \Closure
    {
        $chain = resolve(ChainManager::class);

        $beforeReaction = $this->makePreResponseActions($chain);

        $debug = $chain->get('debugInfo');
        $termination = $chain->get('termination');

        $responder = resolve(ResponderFactory::class)->make();

        return function () use ($beforeReaction, $responder, $debug, $termination) {
            if ($termination) {
                app()->terminating($termination);

The method terminating() does not exist on Illuminate\Container\Container. Are you sure you never get this type here, but always one of the subclasses?

            }
            event('heyman_reaction_is_happening', $debug);
            $beforeReaction();
            $responder();
        };
    }

    /**
     * @param $chain
     *
     * @return \Closure
     */
    private function makePreResponseActions($chain): \Closure
    {
        $tasks = $this->convertToClosures($chain);
        $beforeReaction = function () use ($tasks) {
            foreach ($tasks as $task) {
                $task();
            }
        };

        return $beforeReaction;
    }

    /**
     * @param $chain
     *
     * @return array
     */
    private function convertToClosures($chain): array
    {
        $tasks = $chain->get('beforeReaction');
        $r = [];
        foreach ($tasks as $task) {
            if ($task[1] == 'event') {
                $r[] = function () use ($task) {
                    resolve('events')->dispatch(...$task[0]);

$task[0] is expanded, but the parameter $event of Illuminate\Events\Dispatcher::dispatch() does not expect variable arguments.

                };
            } elseif ($task[1] == 'cb') {
                $r[] = function () use ($task) {
                    app()->call(...$task[0]);

$task[0] is expanded, but the parameter $callback of Illuminate\Container\Container::call() does not expect variable arguments.

                };
            }
        }

        return $r;
    }
}