Yiisoft\Queue\Middleware\Push\MiddlewareFactoryPush

Complexity

Total Complexity

16

Size/Duplication

Total Lines	132
Duplicated Lines	0 %

Test Coverage

Coverage

91.67%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
	wrapCallable()	0	22	?
A	hp$0 ➔ tryGetFromCallable()	0	18	5
A	hp$0 ➔ processPush()	0	12	3
A	__construct()	0	4	1
A	hp$0 ➔ wrapCallable()	0	22	3
A	createPushMiddleware()	0	14	3
	tryGetFromArrayDefinition()	0	20	?
A	hp$0 ➔ __construct()	0	3	1
	tryGetFromCallable()	0	18	?
A	hp$0 ➔ tryGetFromArrayDefinition()	0	20	4
A	getFromContainer()	0	15	5

<?php

declare(strict_types=1);

namespace Yiisoft\Queue\Middleware\Push;

use Closure;
use Psr\Container\ContainerInterface;
use Yiisoft\Definitions\ArrayDefinition;
use Yiisoft\Definitions\Exception\InvalidConfigException;
use Yiisoft\Definitions\Helpers\DefinitionValidator;
use Yiisoft\Injector\Injector;
use Yiisoft\Queue\Middleware\CallableFactory;
use Yiisoft\Queue\Middleware\InvalidCallableConfigurationException;
use Yiisoft\Queue\Middleware\InvalidMiddlewareDefinitionException;

use function is_string;

/**
 * Creates a middleware based on the definition provided.
 */
final class MiddlewareFactoryPush implements MiddlewareFactoryPushInterface
{
    /**
     * @param ContainerInterface $container Container to use for resolving definitions.
     */
    public function __construct(
        private ContainerInterface $container,
        private CallableFactory $callableFactory,
    ) {
    }

    /**
     * @param array|callable|MiddlewarePushInterface|string $middlewareDefinition Middleware definition in one of the
     *     following formats:
     *
     * - A middleware object.
     * - A name of a middleware class. The middleware instance will be obtained from container and executed.
     * - A callable with `function(ServerRequestInterface $request, RequestHandlerInterface $handler):
     *     ResponseInterface` signature.
     * - A controller handler action in format `[TestController::class, 'index']`. `TestController` instance will
     *   be created and `index()` method will be executed.
     * - A function returning a middleware. The middleware returned will be executed.
     *
     * For handler action and callable
     * typed parameters are automatically injected using dependency injection container.
     * Current request and handler could be obtained by type-hinting for {@see ServerRequestInterface}
     * and {@see RequestHandlerInterface}.
     *
     * @throws InvalidMiddlewareDefinitionException
     *
     * @return MiddlewarePushInterface
     */
    public function createPushMiddleware(
        MiddlewarePushInterface|callable|array|string $middlewareDefinition
    ): MiddlewarePushInterface {
        if ($middlewareDefinition instanceof MiddlewarePushInterface) {

$middlewareDefinition is never a sub-type of Yiisoft\Queue\Middleware\Push\MiddlewarePushInterface.

            return $middlewareDefinition;
        }

        if (is_string($middlewareDefinition)) {

The condition is_string($middlewareDefinition) is always false.

            return $this->getFromContainer($middlewareDefinition);
        }

        return $this->tryGetFromCallable($middlewareDefinition)
            ?? $this->tryGetFromArrayDefinition($middlewareDefinition)
            ?? throw new InvalidMiddlewareDefinitionException($middlewareDefinition);
    }

    private function getFromContainer(string $middlewareDefinition): MiddlewarePushInterface
    {
        if (class_exists($middlewareDefinition)) {
            if (is_subclass_of($middlewareDefinition, MiddlewarePushInterface::class)) {
                /** @var MiddlewarePushInterface */
                return $this->container->get($middlewareDefinition);
            }
        } elseif ($this->container->has($middlewareDefinition)) {
            $middleware = $this->container->get($middlewareDefinition);
            if ($middleware instanceof MiddlewarePushInterface) {
                return $middleware;
            }
        }

        throw new InvalidMiddlewareDefinitionException($middlewareDefinition);
    }

    private function wrapCallable(callable $callback): MiddlewarePushInterface
    {
        return new class ($callback, $this->container) implements MiddlewarePushInterface {
            private $callback;

            public function __construct(callable $callback, private ContainerInterface $container)
            {
                $this->callback = $callback;
            }

            public function processPush(PushRequest $request, MessageHandlerPushInterface $handler): PushRequest
            {
                $response = (new Injector($this->container))->invoke($this->callback, [$request, $handler]);
                if ($response instanceof PushRequest) {
                    return $response;
                }

                if ($response instanceof MiddlewarePushInterface) {
                    return $response->processPush($request, $handler);
                }

                throw new InvalidMiddlewareDefinitionException($this->callback);
            }
        };
    }

    private function tryGetFromCallable(
        callable|MiddlewarePushInterface|array|string $definition
    ): ?MiddlewarePushInterface {
        if ($definition instanceof Closure) {

$definition is never a sub-type of Closure.

            return $this->wrapCallable($definition);
        }

        if (
            is_array($definition)
            && array_keys($definition) === [0, 1]
        ) {
            try {
                return $this->wrapCallable($this->callableFactory->create($definition));
            } catch (InvalidCallableConfigurationException $exception) {
                throw new InvalidMiddlewareDefinitionException($definition, previous: $exception);
            }
        } else {
            return null;
        }
    }

    private function tryGetFromArrayDefinition(
        callable|MiddlewarePushInterface|array|string $definition
    ): ?MiddlewarePushInterface {
        if (!is_array($definition)) {

The condition is_array($definition) is always true.

            return null;
        }

        try {
            DefinitionValidator::validateArrayDefinition($definition);

            $middleware = ArrayDefinition::fromConfig($definition)->resolve($this->container);
            if ($middleware instanceof MiddlewarePushInterface) {
                return $middleware;
            }

            throw new InvalidMiddlewareDefinitionException($definition);
        } catch (InvalidConfigException) {

Consider adding a comment why this CATCH block is empty.

        }

        throw new InvalidMiddlewareDefinitionException($definition);
    }
}