Spiral\Router\Route

Complexity

Total Complexity

17

Size/Duplication

Total Lines	124
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
B	requestHandler()	0	35	9
A	handle()	0	9	2
A	withUriHandler()	0	12	2
A	__construct()	0	9	2
A	withContainer()	0	12	2

<?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);

It seems like $this->matches can also be of type null; however, parameter $matches of Spiral\Router\TargetInterface::getHandler() does only seem to accept array, maybe add an additional type check?

            } 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);

It seems like $this->target can also be of type callable; however, parameter $id of Psr\Container\ContainerInterface::get() does only seem to accept string, maybe add an additional type check?

            }

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

            return new CallableHandler(
                $target,

It seems like $target can also be of type object; however, parameter $callable of Spiral\Http\CallableHandler::__construct() does only seem to accept callable, maybe add an additional type check?

                $this->container->get(ResponseFactoryInterface::class)
            );
        } catch (ContainerExceptionInterface $e) {
            throw new RouteException($e->getMessage(), $e->getCode(), $e);

The method getMessage() does not exist on Psr\Container\ContainerExceptionInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Psr\Container\NotFoundExceptionInterface. Are you sure you never get one of those?

The method getCode() does not exist on Psr\Container\ContainerExceptionInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Psr\Container\NotFoundExceptionInterface. Are you sure you never get one of those?

        }
    }
}