Yiisoft\Yii\Event\ListenerConfigurationChecker

Complexity

Total Complexity

22

Size/Duplication

Total Lines	93
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
B	isCallable()	0	36	11
B	check()	0	31	10

<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Event;

use Psr\Container\ContainerExceptionInterface;
use Psr\Container\ContainerInterface;
use ReflectionException;
use ReflectionMethod;
use function is_array;
use function is_callable;
use function is_string;

final class ListenerConfigurationChecker
{
    private ContainerInterface $container;

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

    /**
     * Checks the given event configuration and throws an exception in some cases:
     * - incorrect configuration format
     * - incorrect listener format
     * - listener is not a callable
     * - listener is meant to be a method of an object which can't be instantiated
     *
     * @param array $configuration An array in format of [eventClassName => [listeners]]
     *
     * @psalm-suppress InvalidCatch
     */
    public function check(array $configuration): void
    {
        foreach ($configuration as $eventName => $listeners) {
            if (!is_string($eventName) || !class_exists($eventName)) {
                throw new InvalidEventConfigurationFormatException(
                    'Incorrect event listener format. Format with event name must be used.'
                );
            }

            if (!is_iterable($listeners)) {
                $type = is_object($listeners) ? get_class($listeners) : gettype($listeners);

                throw new InvalidEventConfigurationFormatException(
                    "Event listeners for $eventName must be an iterable, $type given."
                );
            }

            foreach ($listeners as $listener) {
                try {
                    if (!$this->isCallable($listener)) {
                        $type = is_object($listener) ? get_class($listener) : gettype($listener);

                        throw new InvalidListenerConfigurationException(
                            "Listener must be a callable, $type given."
                        );
                    }
                } catch (ContainerExceptionInterface $exception) {
                    throw new InvalidListenerConfigurationException(
                        'Could not instantiate event listener or listener class has invalid configuration.',
                        0,
                        $exception
                    );
                }
            }
        }
    }

    private function isCallable($definition): bool
    {
        if (
            is_array($definition)
            && array_keys($definition) === [0, 1]
            && is_string($definition[0])
        ) {
            if (class_exists($definition[0])) {
                try {
                    $method = new ReflectionMethod($definition[0], $definition[1]);
                    if ($method->isStatic()) {
                        return true;
                    }
                } catch (ReflectionException $exception) {
                    return false;
                }
            }

            if ($this->container->has($definition[0])) {
                $object = $this->container->get($definition[0]);

                return method_exists($object, $definition[1]);
            }

            return false;
        }

        if (is_callable($definition)) {
            return true;
        }

        if (is_string($definition) && $this->container->has($definition)) {
            return is_callable($this->container->get($definition));
        }

        return false;
    }
}