Route::requestHandler() - Code Metrics - Inspection of "Merge spiral/router component" - spiral/framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 035a69...ef3bdc )

by Kirill
created 2020-08-22 05:43 UTC
Route::requestHandler() B

↳ Parent: Route
Complexity

Conditions	9
Paths	12
Size

Total Lines	35
Code Lines	21
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	21
c	1
b	0
f	0
dl	0
loc	35
rs	8.0555
cc	9
nc	12
nop	0
<?php

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

declare(strict_types=1);

namespace Spiral\Router;

use Psr\Container\ContainerExceptionInterface;
use Psr\Container\ContainerInterface;
use Psr\Http\Message\ResponseFactoryInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Spiral\Http\CallableHandler;
use Spiral\Router\Exception\RouteException;
use Spiral\Router\Exception\TargetException;
use Spiral\Router\Traits\PipelineTrait;

/**
 * Default route provides ability to route request to a given callable handler.
 *
 * Examples:
 *
 * new Route("/login", function(){
 *   return "hello";
 * });
 * new Route("/login", new Handler());
 * new Route("/login", \App\Handlers\Handler::class);
 *
 * new Route("/login", new Action(\App\Controllers|HomeController::class, "login");
 * new Route("/<controller>/<action>/<id>", new Namespaced("\App\Controllers");
 * new Route("/signup/<action>", new Controller(\App\Controllers\SignupController::class);
 * new Route("://<domain>/info", new Action(\App\Controllers|ProfileController::class, "info");
 * new Route("/<controller>/<action>/<id>", new Group(["profile" =>
 * \App\Controllers|ProfileController::class]);
 */
final class Route extends AbstractRoute implements ContainerizedInterface
{
    use PipelineTrait;

    public const ROUTE_ATTRIBUTE = 'route';

    /** @var string|callable|RequestHandlerInterface|TargetInterface */
    private $target;

    /** @var RequestHandlerInterface */
    private $requestHandler;

    /**
     * @param string                                                  $pattern  Uri pattern.
     * @param string|callable|RequestHandlerInterface|TargetInterface $target   Callable route target.
     * @param array                                                   $defaults Default value set.
     */
    public function __construct(string $pattern, $target, array $defaults = [])
    {
        if ($target instanceof TargetInterface) {
            parent::__construct($pattern, array_merge($target->getDefaults(), $defaults));
        } else {
            parent::__construct($pattern, $defaults);
        }

        $this->target = $target;
    }

    /**
     * @param UriHandler $uriHandler
     * @return RouteInterface
     */
    public function withUriHandler(UriHandler $uriHandler): RouteInterface
    {
        /** @var self $route */
        $route = parent::withUriHandler($uriHandler);
        if ($this->target instanceof TargetInterface) {
            $route->uriHandler = $route->uriHandler->withConstrains(
                $this->target->getConstrains(),
                $this->defaults
            );
        }

        return $route;
    }

    /**
     * Associated route with given container.
     *
     * @param ContainerInterface $container
     * @return ContainerizedInterface|$this
     */
    public function withContainer(ContainerInterface $container): ContainerizedInterface
    {
        $route = clone $this;
        $route->container = $container;

        if ($route->target instanceof TargetInterface) {
            $route->target = clone $route->target;
        }

        $route->pipeline = $route->makePipeline();

        return $route;
    }

    /**
     * @param ServerRequestInterface $request
     * @return ResponseInterface
     *
     * @throws RouteException
     */
    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        if (empty($this->requestHandler)) {
            $this->requestHandler = $this->requestHandler();
        }

        return $this->pipeline->process(
            $request->withAttribute(self::ROUTE_ATTRIBUTE, $this),
            $this->requestHandler
        );
    }

    /**
     * @return RequestHandlerInterface
     *
     * @throws RouteException
     */
    protected function requestHandler(): RequestHandlerInterface
    {
        if (!$this->hasContainer()) {
            throw new RouteException('Unable to configure route pipeline without associated container');
        }

        if ($this->target instanceof TargetInterface) {
            try {
                return $this->target->getHandler($this->container, $this->matches);
                return $this->target->getHandler($this->container, /** @scrutinizer ignore-type */ $this->matches);
            } catch (TargetException $e) {
                throw new RouteException('Invalid target resolution', $e->getCode(), $e);
            }
        }

        if ($this->target instanceof RequestHandlerInterface) {
            return $this->target;
        }

        try {
            if (is_object($this->target) || is_array($this->target)) {
                $target = $this->target;
            } else {
                $target = $this->container->get($this->target);
                $target = $this->container->get(/** @scrutinizer ignore-type */ $this->target);
            }

            if ($target instanceof RequestHandlerInterface) {
                return $target;
            }

            return new CallableHandler(
                $target,
                /** @scrutinizer ignore-type */ $target,
                $this->container->get(ResponseFactoryInterface::class)
            );
        } catch (ContainerExceptionInterface $e) {
            throw new RouteException($e->getMessage(), $e->getCode(), $e);
            throw new RouteException($e->getMessage(), $e->/** @scrutinizer ignore-call */ getCode(), $e);
        }
    }
}

spiral / framework

Push — master ( 035a69...ef3bdc )

Route::requestHandler() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
