Gears\Event\Symfony\Dispatcher

Complexity

Total Complexity

17

Size/Duplication

Total Lines	97
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	4

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	4
A	addSubscriber()	0	16	5
A	addListener()	0	12	3
A	dispatch()	0	18	3
A	dispatchEvent()	0	8	2

<?php

/*
 * event-symfony-event-dispatcher (https://github.com/phpgears/event-symfony-event-dispatcher).
 * Event bus with Symfony Event Dispatcher.
 *
 * @license MIT
 * @link https://github.com/phpgears/event-symfony-event-dispatcher
 * @author Julián Gutiérrez <juliangut@gmail.com>
 */

declare(strict_types=1);

namespace Gears\Event\Symfony\Dispatcher;

use Gears\Event\EventHandler;
use Symfony\Component\EventDispatcher\Event as SymfonyEvent;
use Symfony\Component\EventDispatcher\EventDispatcher as SymfonyEventDispatcher;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;

class Dispatcher extends SymfonyEventDispatcher implements EventDispatcher
{
    /**
     * ContainerAwareEventDispatcher constructor.
     *
     * @param array<string, mixed> $listenersMap
     */
    public function __construct(array $listenersMap = [])
    {
        foreach ($listenersMap as $eventName => $listeners) {
            if (!\is_array($listeners)) {
                $listeners = [$listeners];
            }

            foreach ($listeners as $listener) {
                $this->addListener($eventName, $listener);
            }
        }
    }

    /**
     * {@inheritdoc}
     */
    public function addSubscriber(EventSubscriberInterface $subscriber): void
    {
        foreach ($subscriber::getSubscribedEvents() as $eventName => $params) {
            if (!\is_array($params)) {
                $params = [$params];
            }

            foreach ($params as $listener) {
                if (!\is_array($listener)) {
                    $this->addListener($eventName, $listener);
                } else {
                    $this->addListener($eventName, $listener[0], $listener[1] ?? 0);
                }
            }
        }
    }

    /**
     * Adds an event listener that listens on the specified events.
     *
     * @param string $eventName
     * @param mixed  $listener
     * @param mixed  $priority

Consider making the type for parameter $priority a bit more specific; maybe use integer.

     */
    public function addListener($eventName, $listener, $priority = 0): void
    {
        if (!$listener instanceof EventHandler) {
            throw new \InvalidArgumentException(\sprintf(
                'Event handler must be an instance of %s, %s given',
                EventHandler::class,
                \is_object($listener) ? \get_class($listener) : \gettype($listener)
            ));
        }

        parent::addListener($eventName, $listener, (int) $priority);

$listener is of type object<Gears\Event\EventHandler>, but the function expects a callable.

    }

    /**
     * {@inheritdoc}
     */
    public function dispatch($eventName, SymfonyEvent $event = null): SymfonyEvent
    {
        if ($event === null) {
            throw new \InvalidArgumentException('Dispatched event cannot be empty');
        }

        if (!$event instanceof EventEnvelope) {
            throw new \InvalidArgumentException(\sprintf(
                'Dispatched event must implement %s, %s given',
                EventEnvelope::class,
                \get_class($event)
            ));
        }

        $this->dispatchEvent($this->getListeners($eventName), $event);

        return $event;
    }

    /**
     * Dispatch event to registered listeners.
     *
     * @param EventHandler[] $listeners
     * @param EventEnvelope  $event
     */
    private function dispatchEvent(array $listeners, EventEnvelope $event): void
    {
        $dispatchEvent = $event->getWrappedEvent();

        foreach ($listeners as $handler) {
            $handler->handle($dispatchEvent);
        }
    }
}