Imanghafoori\HeyMan\ReactionFactory

Complexity

Total Complexity

10

Size/Duplication

Total Lines	79
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	methodsToCall()	0	12	3
A	make()	0	5	1
A	eventsToDispatch()	0	12	3
A	makeReaction()	0	16	2

<?php

namespace Imanghafoori\HeyMan;

class ReactionFactory
{
    /**
     * @var \Imanghafoori\HeyMan\Chain
     */
    private $chain;

    /**
     * ListenerFactory constructor.
     *
     * @param \Imanghafoori\HeyMan\Chain $chain
     */
    public function __construct(Chain $chain)
    {
        $this->chain = $chain;
    }

    /**
     * @return \Closure
     */
    public function make(): \Closure
    {
        $responder = app(ResponderFactory::class)->make();

        return $this->makeReaction($responder);
    }

    /**
     * @param $responder
     *
     * @return \Closure
     */
    private function makeReaction(callable $responder): \Closure
    {
        $dispatcher = $this->eventsToDispatch();
        $calls = $this->methodsToCall();

        $cb = $this->chain->predicate;
        $this->chain->reset();

        return function (...$f) use ($responder, $cb, $dispatcher, $calls) {
            if ($cb($f)) {
                return true;
            }

            $calls();
            $dispatcher();
            $responder();
        };
    }

    private function eventsToDispatch(): \Closure
    {
        $events = $this->chain->events;

        if (!$events) {

The expression $events of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return function () {
            };
        }

        return function () use ($events) {
            foreach ($events as $event) {
                app('events')->dispatch(...$event);

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

            }
        };
    }

    private function methodsToCall(): \Closure
    {
        $calls = $this->chain->afterCalls;

        if (!$calls) {
            return function () {
            };
        }

        return function () use ($calls) {
            foreach ($calls as $call) {
                app()->call(...$call);

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

            }
        };
    }
}