CoreHandler::wrapResponse() - Code Metrics - Inspection of "Support for generators in controllers (#625)" - spiral/framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 3d26ac...b47a92 )

by Aleksei
created 2022-03-30 20:25 UTC
CoreHandler::wrapResponse() B

↳ Parent: CoreHandler
Complexity

Conditions	7
Paths	5
Size

Total Lines	24
Code Lines	12
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	7
eloc	12
c	1
b	0
f	0
nc	5
nop	3
dl	0
loc	24
rs	8.8333
<?php

/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */

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\Exception\ControllerException;
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\UnauthorizedException;
use Spiral\Http\Stream\GeneratorStream;
use Spiral\Http\Traits\JsonTrait;
use Spiral\Router\Exception\HandlerException;

final class CoreHandler implements RequestHandlerInterface
{
    use JsonTrait;

    /** @var CoreInterface */
    private $core;

    /** @var ScopeInterface */
    private $scope;

    /** @var string|null */
    private $controller;

    /** @var string|null */
    private $action;

    /** @var bool */
    private $verbActions;

    /** @var array|null */
    private $parameters;

    /** @var ResponseFactoryInterface */
    private $responseFactory;

    public function __construct(
        CoreInterface $core,
        ScopeInterface $scope,
        ResponseFactoryInterface $responseFactory
    ) {
        $this->core = $core;
        $this->scope = $scope;
        $this->responseFactory = $responseFactory;
    }

    /**
     * @param string|null $action
     */
    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.
     */
    public function withVerbActions(bool $verbActions): CoreHandler
    {
        $handler = clone $this;
        $handler->verbActions = $verbActions;

        return $handler;
    }

    /**
     * @inheritdoc
     *
     * @psalm-suppress UnusedVariable
     * @throws \Throwable
     */
    public function handle(Request $request): Response
    {
        if ($this->controller === null) {
            throw new HandlerException('Controller and action pair is not set');
        }

        $outputLevel = ob_get_level();
        ob_start();

        $output = $result = null;


        $response = $this->responseFactory->createResponse(200);
        try {
            // run the core withing PSR-7 Request/Response scope
            $result = $this->scope->runScope(
                [
                    Request::class  => $request,
                    Response::class => $response,
                ],
                function () use ($request) {
                    return $this->core->callAction(
                        $this->controller,
                        /** @scrutinizer ignore-type */ $this->controller,
                        $this->getAction($request),
                        $this->parameters
                        /** @scrutinizer ignore-type */ $this->parameters
                    );
                }
            );
        } catch (ControllerException $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
        );
    }

    private function getAction(Request $request): string
    {
        if ($this->verbActions) {
            return strtolower($request->getMethod()) . ucfirst($this->action);
            return strtolower($request->getMethod()) . ucfirst(/** @scrutinizer ignore-type */ $this->action);
        }

        return $this->action;
    }

    /**
     * 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, $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(ControllerException $exception): ClientException
    {
        switch ($exception->getCode()) {
            case ControllerException::BAD_ACTION:
            case ControllerException::NOT_FOUND:
                return new NotFoundException($exception->getMessage());
            case ControllerException::FORBIDDEN:
                return new ForbiddenException($exception->getMessage());
            case ControllerException::UNAUTHORIZED:
                return new UnauthorizedException($exception->getMessage());
            default:
                return new BadRequestException($exception->getMessage());
        }
    }
}

spiral / framework

Push — master ( 3d26ac...b47a92 )

CoreHandler::wrapResponse() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
