Yiisoft\Queue\Middleware\FailureHandling\MiddlewareFailureStack

Complexity

Total Complexity

5

Size/Duplication

Total Lines	63
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	hp$0 ➔ wrap()	0	18	2
A	handleFailure()	0	8	2
A	__construct()	0	4	1
A	hp$0 ➔ __construct()	0	4	1
A	hp$0 ➔ handleFailure()	0	7	2
	wrap()	0	18	?
A	build()	0	9	2

<?php

declare(strict_types=1);

namespace Yiisoft\Queue\Middleware\FailureHandling;

use Closure;

final class MiddlewareFailureStack implements MessageFailureHandlerInterface
{
    /**
     * Contains a stack of middleware wrapped in handlers.
     * Each handler points to the handler of middleware that will be processed next.
     *
     * @var MessageFailureHandlerInterface|null stack of middleware
     */
    private ?MessageFailureHandlerInterface $stack = null;

    /**
     * @param Closure[] $middlewares Middlewares.
     * @param MessageFailureHandlerInterface $finishHandler Fallback handler
     * events.
     */
    public function __construct(
        private array $middlewares,
        private MessageFailureHandlerInterface $finishHandler,
    ) {
    }

    public function handleFailure(FailureHandlingRequest $request): FailureHandlingRequest
    {
        if ($this->stack === null) {
            $this->build();
        }

        /** @psalm-suppress PossiblyNullReference */
        return $this->stack->handleFailure($request);

The method handleFailure() does not exist on null.

    }

    private function build(): void
    {
        $handler = $this->finishHandler;

        foreach ($this->middlewares as $middleware) {
            $handler = $this->wrap($middleware, $handler);
        }

        $this->stack = $handler;
    }

    /**
     * Wrap handler by middlewares.
     */
    private function wrap(Closure $middlewareFactory, MessageFailureHandlerInterface $handler): MessageFailureHandlerInterface
    {
        return new class ($middlewareFactory, $handler) implements MessageFailureHandlerInterface {
            private ?MiddlewareFailureInterface $middleware = null;

            public function __construct(
                private Closure $middlewareFactory,
                private MessageFailureHandlerInterface $handler,
            ) {
            }

            public function handleFailure(FailureHandlingRequest $request): FailureHandlingRequest
            {
                if ($this->middleware === null) {
                    $this->middleware = ($this->middlewareFactory)();
                }

                return $this->middleware->processFailure($request, $this->handler);

The method processFailure() does not exist on null.

            }
        };
    }
}