CoreHandler::withVerbActions() - Code Metrics - Inspection of "New interceptors" - spiral/framework - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Pull Request — master (#1095)

by Aleksei
created 2024-04-29 16:48 UTC
CoreHandler::withVerbActions() A

↳ Parent: CoreHandler
Complexity

Conditions	1
Paths	1
Size

Total Lines	6
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	1
CRAP Score	1
Importance

Changes
Metric	Value
cc	1
eloc	3
nc	1
nop	1
dl	0
loc	6
ccs	1
cts	1
cp	1
crap	1
rs	10
c	0
b	0
f	0
<?php

declare(strict_types=1);

namespace Spiral\Router;

use Psr\Http\Message\ResponseFactoryInterface;
use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Psr\Http\Server\RequestHandlerInterface;
use Spiral\Core\CoreInterface;
use Spiral\Core\ScopeInterface;
use Spiral\Http\Exception\ClientException;
use Spiral\Http\Exception\ClientException\BadRequestException;
use Spiral\Http\Exception\ClientException\ForbiddenException;
use Spiral\Http\Exception\ClientException\NotFoundException;
use Spiral\Http\Exception\ClientException\ServerErrorException;
use Spiral\Http\Exception\ClientException\UnauthorizedException;
use Spiral\Http\Stream\GeneratorStream;
use Spiral\Http\Traits\JsonTrait;
use Spiral\Interceptors\Context\CallContext;
use Spiral\Interceptors\Context\Target;
use Spiral\Interceptors\Exception\TargetCallException;
use Spiral\Interceptors\HandlerInterface;
use Spiral\Router\Exception\HandlerException;
use Spiral\Telemetry\NullTracer;
use Spiral\Telemetry\TracerInterface;

final class CoreHandler implements RequestHandlerInterface
{
    use JsonTrait;

    private readonly TracerInterface $tracer;

    /** @readonly */
    private ?string $controller = null;
    /** @readonly */
    private ?string $action = null;
    /** @readonly */
    private ?bool $verbActions = null;
    /** @readonly */
    private ?array $parameters = null;

    private bool $isLegacyPipeline;

    public function __construct(
        private readonly HandlerInterface|CoreInterface $core,
        private readonly ScopeInterface $scope,
        private readonly ResponseFactoryInterface $responseFactory,
        ?TracerInterface $tracer = null
    ) {
        $this->tracer = $tracer ?? new NullTracer($scope);

        $this->isLegacyPipeline = !$core instanceof HandlerInterface;
    }

    /**
     * @mutation-free
     */
    public function withContext(string $controller, string $action, array $parameters): CoreHandler
    {
        $handler = clone $this;
        $handler->controller = $controller;
        $handler->action = $action;
        $handler->parameters = $parameters;

        return $handler;
    }

    /**
     * Disable or enable HTTP prefix for actions.
     *
     * @mutation-free
     */
    public function withVerbActions(bool $verbActions): CoreHandler
    {
        $handler = clone $this;
        $handler->verbActions = $verbActions;

        return $handler;
    }

    /**
     * @psalm-suppress UnusedVariable
     * @throws \Throwable
     */
    public function handle(Request $request): Response
    {
        $this->checkValues();
        $controller = $this->controller;
        $parameters = $this->parameters;

        $outputLevel = \ob_get_level();
        \ob_start();

        $result = null;
        $output = '';

        $response = $this->responseFactory->createResponse(200);
        try {
            $action = $this->verbActions
                ? \strtolower($request->getMethod()) . \ucfirst($this->action)
                ? \strtolower($request->getMethod()) . \ucfirst(/** @scrutinizer ignore-type */ $this->action)
                : $this->action;

            // run the core withing PSR-7 Request/Response scope
            $result = $this->scope->runScope(
                [
                    Request::class  => $request,
                    Response::class => $response,
                ],
                fn (): mixed => $this->tracer->trace(
                    name: 'Controller [' . $controller . ':' . $action . ']',
                    callback: $this->isLegacyPipeline
                        ? fn (): mixed => $this->core->callAction(
                        ? fn (): mixed => $this->core->/** @scrutinizer ignore-call */ callAction(
                            controller: $controller,
                            /** @scrutinizer ignore-type */ controller: $controller,
                            action: $action,
                            /** @scrutinizer ignore-type */ action: $action,
                            parameters: $parameters,
                            /** @scrutinizer ignore-type */ parameters: $parameters,
                        )
                        : fn (): mixed => $this->core->handle(
                        : fn (): mixed => $this->core->/** @scrutinizer ignore-call */ handle(
                            new CallContext(
                                Target::fromPair($controller, $action),
                                Target::fromPair(/** @scrutinizer ignore-type */ $controller, $action),
                                $parameters,
                                /** @scrutinizer ignore-type */ $parameters,
                            ),
                        ),
                    attributes: [
                        'route.controller' => $this->controller,
                        'route.action' => $action,
                        'route.parameters' => \array_keys($parameters),
                        'route.parameters' => \array_keys(/** @scrutinizer ignore-type */ $parameters),
                    ]
                )
            );
        } catch (TargetCallException $e) {
            \ob_get_clean();
            throw $this->mapException($e);
        } catch (\Throwable $e) {
            \ob_get_clean();
            throw $e;
        } finally {
            while (\ob_get_level() > $outputLevel + 1) {
                $output = \ob_get_clean() . $output;
            }
        }

        return $this->wrapResponse(
            $response,
            $result,
            \ob_get_clean() . $output,
        );
    }

    /**
     * Convert endpoint result into valid response.
     *
     * @param Response $response Initial pipeline response.
     * @param mixed    $result   Generated endpoint output.
     * @param string   $output   Buffer output.
     */
    private function wrapResponse(Response $response, mixed $result = null, string $output = ''): Response
    {
        if ($result instanceof Response) {
            if ($output !== '' && $result->getBody()->isWritable()) {
                $result->getBody()->write($output);
            }

            return $result;
        }

        if ($result instanceof \Generator) {
            return $response->withBody(new GeneratorStream($result));
        }

        if (\is_array($result) || $result instanceof \JsonSerializable) {
            $response = $this->writeJson($response, $result);
        } else {
            $response->getBody()->write((string)$result);
        }

        //Always glue buffered output
        $response->getBody()->write($output);

        return $response;
    }

    /**
     * Converts core specific ControllerException into HTTP ClientException.
     */
    private function mapException(TargetCallException $exception): ClientException
    {
        return match ($exception->getCode()) {
            TargetCallException::BAD_ACTION,
            TargetCallException::NOT_FOUND => new NotFoundException('Not found', $exception),
            TargetCallException::FORBIDDEN => new ForbiddenException('Forbidden', $exception),
            TargetCallException::UNAUTHORIZED => new UnauthorizedException('Unauthorized', $exception),
            TargetCallException::INVALID_CONTROLLER => new ServerErrorException('Server error', $exception),
            default => new BadRequestException('Bad request', $exception),
        };
    }

    /**
     * @psalm-assert !null $this->controller
     * @psalm-assert !null $this->action
     * @psalm-assert !null $this->parameters
     * @mutation-free
     */
    private function checkValues(): void
    {
        if ($this->controller === null) {
            throw new HandlerException('Controller and action pair are not set.');
        }
    }
}

spiral / framework

Pull Request — master (#1095)

CoreHandler::withVerbActions() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
