Wandu\Event\Dispatcher

Complexity

Total Complexity

15

Size/Duplication

Total Lines	84
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

79.49%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	on()	0	7	2
A	off()	0	8	2
A	trigger()	0	18	4
B	executeListeners()	0	21	6

<?php
namespace Wandu\Event;

use Psr\Container\ContainerInterface;
use Wandu\Q\Queue;
use RuntimeException;

class Dispatcher implements DispatcherInterface
{
    /** @var \Psr\Container\ContainerInterface */
    protected $container;

    /** @var array|\Wandu\Event\ListenerInterface[][]|callable[][] */
    protected $listeners = [];

    public function __construct(ContainerInterface $container)
    {
        $this->container = $container;
    }
    
    /**
     * {@inheritdoc}
     */
    public function on(string $event, $listener)
    {
        if (!array_key_exists($event, $this->listeners)) {
            $this->listeners[$event] = [];
        }
        $this->listeners[$event][] = $listener;
    }

    /**
     * {@inheritdoc}
     */
    public function off(string $event, $listener = null)
    {
        if ($listener) {

This if statement is empty and can be removed.

            // @todo
        } else {
            $this->listeners[$event] = [];
        }
    }

    /**
     * {@inheritdoc}
     */
    public function trigger(EventInterface $event)
    {
        if (!count($this->listeners)) {
            return;
        }
        if ($event instanceof ViaQueue) {
            if (!$this->container->has(Queue::class)) {
                // @todo fix error message
                throw new RuntimeException('cannot load queue.');
            }
            $this->container->get(Queue::class)->enqueue([
                'method' => 'event:execute',
                'event' => $event,
            ]);
        } else {
            $this->executeListeners($event);
        }
    }

    /**
     * @param \Wandu\Event\EventInterface $event
     * @return array
     */
    public function executeListeners(EventInterface $event)
    {
        $executedListeners = [];
        $eventName = get_class($event);
        if (!isset($this->listeners[$eventName])) {
            return [];
        }
        foreach ($this->listeners[$eventName] as $listener) {
            if (is_callable($listener)) {
                call_user_func($listener, $event);
                $executedListeners[] = 'callable';
            } elseif (is_string($listener)) {
                $this->container->get($listener)->call($event);
                $executedListeners[] = $listener;
            } elseif ($listener instanceof ListenerInterface) {
                $listener->call($event);
                $executedListeners[] = get_class($listener);
            }
        }
        return $executedListeners;
    }
}