TMV\Messenger\Handler\ContainerHandlersLocator

Complexity

Total Complexity

13

Size/Duplication

Total Lines	76
Duplicated Lines	0 %

Test Coverage

Coverage

97.22%

Importance

Changes	2
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
B	getHandlers()	0	25	8
A	listTypes()	0	9	1
A	shouldHandle()	0	13	3

<?php

declare(strict_types=1);

namespace TMV\Messenger\Handler;

use function class_implements;
use function class_parents;
use function get_class;
use function in_array;
use function is_callable;
use function is_string;
use Psr\Container\ContainerInterface;
use Symfony\Component\Messenger\Envelope;
use Symfony\Component\Messenger\Handler\HandlerDescriptor;
use Symfony\Component\Messenger\Handler\HandlersLocatorInterface;
use Symfony\Component\Messenger\Stamp\ReceivedStamp;
use TMV\Messenger\Exception\InvalidArgumentException;

final class ContainerHandlersLocator implements HandlersLocatorInterface
{
    /** @var ContainerInterface */
    private $container;

    /** @var string[][]|array<string, array<string|callable>>> */
    private $handlers;

    /**
     * @param ContainerInterface $container
     * @param string[][]|array<string, array<string|callable>> $handlers
     */
    public function __construct(ContainerInterface $container, array $handlers)
    {
        $this->container = $container;
        $this->handlers = $handlers;
    }

    public function getHandlers(Envelope $envelope): iterable
    {
        $seen = [];
        foreach (self::listTypes($envelope) as $type) {
            foreach ($this->handlers[$type] ?? [] as $handlerDescriptor) {
                if (is_callable($handlerDescriptor)) {
                    /** @psalm-suppress PossiblyInvalidArgument */
                    $handlerDescriptor = new HandlerDescriptor($handlerDescriptor);
                } elseif (is_string($handlerDescriptor)) {
                    $handlerDescriptor = new HandlerDescriptor($this->container->get($handlerDescriptor));
                }

                if (! $handlerDescriptor instanceof HandlerDescriptor) {
                    throw new InvalidArgumentException('Invalid handler descriptor provided');
                }

                if (! $this->shouldHandle($envelope, $handlerDescriptor)) {
                    continue;
                }
                $name = $handlerDescriptor->getName();
                if (in_array($name, $seen, true)) {
                    continue;
                }
                $seen[] = $name;
                yield $handlerDescriptor;
            }
        }
    }

    /**
     * @param Envelope $envelope
     *
     * @return array<string, string>
     */
    private static function listTypes(Envelope $envelope): array
    {
        /** @var string $class */
        $class = get_class($envelope->getMessage());

        return [$class => $class]
            + class_parents($class)
            + class_implements($class)
            + ['*' => '*'];
    }

    private function shouldHandle(Envelope $envelope, HandlerDescriptor $handlerDescriptor): bool
    {
        /** @var ReceivedStamp|null $received */
        $received = $envelope->last(ReceivedStamp::class);
        if ($received === null) {
            return true;
        }
        $expectedTransport = $handlerDescriptor->getOption('from_transport');
        if ($expectedTransport === null) {
            return true;
        }

        return $received->getTransportName() === $expectedTransport;
    }
}