Yiisoft\Yii\Console\Config\EventConfigurator

Complexity

Total Complexity

13

Size/Duplication

Total Lines	48
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	3
Bugs	0	Features	2

3 Methods

Rating	Name	Duplication	Size	Complexity
B	registerListeners()	0	24	9
A	__construct()	0	4	1
A	isCallable()	0	7	3

<?php

namespace Yiisoft\Yii\Console\Config;

use Psr\Container\ContainerInterface;
use Yiisoft\EventDispatcher\Provider\AbstractProviderConfigurator;

The type Yiisoft\EventDispatcher\Provider\AbstractProviderConfigurator was not found. Maybe you did not declare it correctly or list all dependencies?

use Yiisoft\EventDispatcher\Provider\Provider;

The type Yiisoft\EventDispatcher\Provider\Provider was not found. Maybe you did not declare it correctly or list all dependencies?

use Yiisoft\Injector\Injector;

The type Yiisoft\Injector\Injector was not found. Maybe you did not declare it correctly or list all dependencies?

class EventConfigurator extends AbstractProviderConfigurator
{
    private Provider $listenerProvider;

    private ContainerInterface $container;

    public function __construct(Provider $listenerProvider, ContainerInterface $container)
    {
        $this->listenerProvider = $listenerProvider;
        $this->container = $container;
    }

    public function registerListeners(array $eventsListeners): void
    {
        foreach ($eventsListeners as $eventName => $listeners) {
            if (!is_string($eventName)) {
                throw new \RuntimeException('Incorrect event listener format. Format with event name must be used.');
            }

            if (!is_array($listeners)) {
                $type = $this->isCallable($listeners) ? 'callable' : gettype($listeners);
                throw new \RuntimeException("Event listeners for $eventName must be an array, $type given.");
            }
            foreach ($listeners as $callable) {
                if (!$this->isCallable($callable)) {
                    $type = gettype($listeners);
                    throw new \RuntimeException("Listener must be a callable. $type given.");
                }
                if (is_array($callable) && !is_object($callable[0])) {
                    $callable = [$this->container->get($callable[0]), $callable[1]];
                }

                $this->listenerProvider
                    ->attach(
                        fn ($event) => (new Injector($this->container))->invoke($callable, [$event]),
                        $eventName
                    );
            }
        }
    }

    private function isCallable($definition): bool
    {
        if (is_callable($definition)) {
            return true;
        }

        return count($definition) === 2 && in_array($definition[1], get_class_methods($definition[0]) ?? [], true);
    }
}