Router::fetchOptions() - Code Metrics - Inspection of "Add test for SimpleRouteCompiler class" - divineniiquaye/flight-routing - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Push — master ( 00affb...1204ff )

by Divine Niiquaye
created 2020-07-31 00:20 UTC
Router::fetchOptions() A

↳ Parent: Project
Complexity

Conditions	6
Paths	5
Size

Total Lines	21
Code Lines	9
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	6
eloc	9
c	1
b	0
f	0
nc	5
nop	2
dl	0
loc	21
rs	9.2222
<?php

declare(strict_types=1);

/*
 * This file is part of Flight Routing.
 *
 * PHP version 7.1 and above required
 *
 * @author    Divine Niiquaye Ibok <[email protected]>
 * @copyright 2019 Biurad Group (https://biurad.com/)
 * @license   https://opensource.org/licenses/BSD-3-Clause License
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Flight\Routing;

use BiuradPHP\Support\BoundMethod;
use Closure;
use Flight\Routing\Exceptions\DuplicateRouteException;
use Flight\Routing\Exceptions\MethodNotAllowedException;
use Flight\Routing\Exceptions\RouteNotFoundException;
use Flight\Routing\Exceptions\UriHandlerException;
use Flight\Routing\Exceptions\UrlGenerationException;
use Flight\Routing\Interfaces\CallableResolverInterface;
use Flight\Routing\Interfaces\RouteInterface;
use Flight\Routing\Interfaces\RouteMatcherInterface;
use Flight\Routing\Middlewares\MiddlewareDispatcher;
use Psr\Container\ContainerInterface;
use Psr\Http\Message\ResponseFactoryInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;

/**
 * Router
 */
class Router implements RequestHandlerInterface
{
    use RouteValidation;

    public const TYPE_REQUIREMENT = 1;

    public const TYPE_DEFAULT = 0;

    /** @var RouteMatcherInterface */
    private $matcher;

    /** @var CallableResolverInterface */
    private $resolver;

    /** @var MiddlewareDispatcher */
    private $pipeline;

    /** @var ContainerInterface */
    private $container;

    /** @var callable */
    private $response;

    /** @var string */
    private $namespace;

    /** @var RouteInterface[] */
    private $routes = [];

    /** @var MiddlewareInterface[] */
    private $middlewares = [];

    /** @var array<int,array<string,mixed>> */
    private $attributes = [];

    public function __construct(
        ResponseFactoryInterface $responseFactory,
        ?RouteMatcherInterface $matcher = null,
        ?CallableResolverInterface $resolver = null,
        ?ContainerInterface $container = null
    ) {
        $this->container = $container;
        $this->pipeline  = new MiddlewareDispatcher($container);
        $this->resolver  = $resolver ?? new CallableResolver($container);
        $this->matcher   = $matcher ?? new Services\SimpleRouteMatcher();

        $this->response = [$responseFactory, 'createResponse'];
    }

    /**
     * Gets the router routes
     *
     * @return RouteInterface[]
     */
    public function getRoutes(): array
    {
        return \array_values($this->routes);
    }

    /**
     * Gets the router middlewares
     *
     * @return MiddlewareInterface[]
     */
    public function getMiddlewares(): array
    {
        return \array_values($this->middlewares);
    }

    public function setNamespace(string $namespace): void
    {
        $this->namespace = $namespace;
    }

    /**
     * Adds the given route(s) to the router
     *
     * @param RouteInterface ...$routes
     *
     * @throws DuplicateRouteException
     */
    public function addRoute(RouteInterface ...$routes): void
    {
        foreach ($routes as $route) {
            $name = $route->getName();

            if (isset($this->routes[$name])) {
                throw new DuplicateRouteException(
                    \sprintf('A route with the name "%s" already exists.', $name)
                );
            }

            $this->routes[$name] = $route;
        }
    }

    /**
     * Adds the given middleware(s) to the router
     *
     * @param array<string,mixed>|MiddlewareInterface|string ...$middlewares
filter:
    dependency_paths: ["lib/*"]
     *
     * @throws DuplicateRouteException
     */
    public function addMiddleware(...$middlewares): void
    {
        foreach ($middlewares as $middleware) {
            if (\is_array($middleware)) {
                $this->pipeline->add($middleware);

                continue;
            }
            $hash = \spl_object_hash($middleware);
            $hash = \spl_object_hash(/** @scrutinizer ignore-type */ $middleware);

            if (isset($this->middlewares[$hash])) {
                throw new DuplicateRouteException(\sprintf('A middleware with the hash "%s" already exists.', $hash));
            }

            $this->middlewares[$hash] = $middleware;
        }
    }

    /**
     * Adds parameters.
     *
     * This method implements a fluent interface.
     *
     * @param array<string,mixed> $parameters The parameters
     * @param int                 $type
     */
    public function addParameters(array $parameters, int $type = self::TYPE_REQUIREMENT): void
    {
        foreach ($parameters as $key => $regex) {
            if (self::TYPE_DEFAULT === $type) {
                $this->attributes[self::TYPE_DEFAULT] = [$key => $regex];

                continue;
            }

            $this->attributes[self::TYPE_REQUIREMENT] = [$key => $regex];
        }
    }

    /**
     * Gets allowed methods
     *
     * @return string[]
     */
    public function getAllowedMethods(): array
    {
        $methods = [];

        foreach ($this->routes as $route) {
            foreach ($route->getMethods() as $method) {
                $methods[$method] = true;
            }
        }

        return \array_keys($methods);
    }

    /**
     * Gets a route for the given name
     *
     * @param string $name
     *
     * @throws RouteNotFoundException
     *
     * @return RouteInterface
     */
    public function getRoute(string $name): RouteInterface
    {
        if (!isset($this->routes[$name])) {
            throw new RouteNotFoundException(\sprintf('No route found for the name "%s".', $name));
        }

        return $this->routes[$name];
    }

    /**
     * Generate a URI from the named route.
     *
     * Takes the named route and any parameters, and attempts to generate a
     * URI from it. Additional router-dependent query may be passed.
     *
     * Once there are no missing parameters in the URI we will encode
     * the URI and prepare it for returning to the user. If the URI is supposed to
     * be absolute, we will return it as-is. Otherwise we will remove the URL's root.
     *
     * @param string                       $routeName   route name
     * @param array<string,string>         $parameters  key => value option pairs to pass to the
     *                                                  router for purposes of generating a URI; takes precedence over options
     *                                                  present in route used to generate URI
     * @param array<int|string,int|string> $queryParams Optional query string parameters
     *
     * @throws UrlGenerationException if the route name is not known
     *                                or a parameter value does not match its regex
     *
     * @return string of fully qualified URL for named route
     */
    public function generateUri(string $routeName, array $parameters = [], array $queryParams = []): string
    {
        try {
            $route = $this->getRoute($routeName);
        } catch (RouteNotFoundException $e) {
            throw new UrlGenerationException(
                \sprintf(
                    'Unable to generate a URL for the named route "%s" as such route does not exist.',
                    $routeName
                ),
                404
            );
        }

        $prefix     = '.'; // Append missing "." at the beginning of the $uri.
        $createdUri = $this->matcher->buildPath($route, $parameters);


        // Making routing on sub-folders easier
        if (\strpos($createdUri = $this->matcher->buildPath($route, $parameters), '/') !== 0) {
            $prefix .= '/';
        }

        // Incase query is added to uri.
        if (!empty($queryParams)) {
            $createdUri .= '?' . \http_build_query($queryParams);
        }

        return \rtrim(\strpos($createdUri, '://') !== false ? $createdUri : $prefix . $createdUri, '/');
    }

    /**
     * Looks for a route that matches the given request
     *
     * @param ServerRequestInterface $request
     *
     * @throws MethodNotAllowedException
     * @throws UriHandlerException
     * @throws RouteNotFoundException
     *
     * @return RouteHandler
     */
    public function match(ServerRequestInterface &$request): RouteHandler
    {
        $requestUri  = $request->getUri();
        $basePath    = \dirname($request->getServerParams()['SCRIPT_NAME'] ?? '');
        $requestPath = \substr($requestUri->getPath(), \strlen($basePath)) ?? '/';

        // Get the request matching format.
        $route = $this->marshalMatchedRoute(
            [
                $request->getMethod(),
                $requestUri->getScheme(),
                $requestUri->getHost(),
                \rawurldecode($requestPath),
            ]
        );
        $request = $request->withAttribute(Route::class, $route);

        return new RouteHandler($this->generateResponse($route), ($this->response)());
    }

    /**
     * {@inheritDoc}
     */
    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        $routingResults = $this->match($request);
        $route          = $request->getAttribute(Route::class);

        // Get all available middlewares
        $middlewares = $route instanceof Route ? $route->getMiddlewares() : [];

        if (\count($middlewares = $this->mergeMiddlewares($middlewares)) > 0) {
            $middleware = $this->pipeline->pipeline(...$middlewares);

            // This middleware is in the priority map; but, this is the first middleware we have
            // encountered from the map thus far. We'll save its current index plus its index
            // from the priority map so we can compare against them on the next iterations.
            return $middleware->process($request, $routingResults);
        }

        return $routingResults->handle($request);
    }

    /**
     * Merge route middlewares with Router Middlewares.
     *
     * @param mixed[] $middlewares
     *
     * @return MiddlewareInterface[]|mixed[]
     */
    private function mergeMiddlewares(array $middlewares): array
    {
        $this->pipeline->add(...$this->getMiddlewares());

        return \array_merge($middlewares, $this->pipeline->getMiddlewareStack());
    }

    /**
     * Merge Router attributes in route default and patterns.
     *
     * @param RouteInterface $route
     *
     * @return RouteInterface
     */
    private function mergeAttributes(RouteInterface $route): RouteInterface
    {
        foreach ($this->attributes as $type => $attributes) {
            if (self::TYPE_DEFAULT === $type) {
                $route->setDefaults($attributes);

                continue;
            }

            $route->setPatterns($attributes);
        }

        return $route;
    }

    /**
     * Generate the response so it can be served
     *
     * @param RouteInterface $route
     *
     * @return callable
     */
    private function generateResponse(RouteInterface $route): callable
    {
        return function (ServerRequestInterface $request, ResponseInterface $response) use ($route) {
            $handler   = $this->resolver->resolve($route->getController(), $this->namespace);
            $arguments = \array_merge(
                $route->getArguments(),
                $this->container ? [$request] : [$request, $response]
            );

            // If controller is instance of RequestHandlerInterface
            if (!$handler instanceof Closure && $handler[0] instanceof RequestHandlerInterface) {
                return $handler($request);
            }

            return BoundMethod::call($this->container, $handler, $arguments);
        };
    }

    /**
     * Marshals a route result based on the results of matching URL from set of routes.
     *
     * @param string[] $process
     *
     * @throws MethodNotAllowedException
     * @throws UriHandlerException
     * @throws RouteNotFoundException
     *
     * @return RouteInterface
     */
    private function marshalMatchedRoute(array $process): RouteInterface
    {
        [, , $host, $path] = $process;

        foreach ($this->routes as $route) {
            // Let's match the routes
            $match      = $this->matcher->compileRoute($this->mergeAttributes($route));
            $parameters = $hostParameters = [];

            // https://tools.ietf.org/html/rfc7231#section-6.5.5
            if (!$this->compareUri($match->getRegex(), $path, $parameters)) {
                continue;
            }

            if (!$this->compareDomain($match->getRegex(true), $host, $hostParameters)) {
                throw new UriHandlerException(
                    \sprintf('Unfortunately current domain "%s" is not allowed on requested uri [%s]', $host, $path),
                    400
                );
            }

            $this->assertRoute($route, $process);

            return $route->setArguments($this->mergeDefaults(
                \array_replace($parameters, $hostParameters) ?? $match->getVariables(),
                $route->getDefaults()
            ));
        }

        throw new  RouteNotFoundException(
            \sprintf(
                'Unable to find the controller for path "%s". The route is wrongly configured.',
                $path
            )
        );
    }

    /**
     * Asserts the Route's method and domain scheme.
     *
     * @param RouteInterface $route
     * @param string[]       $attributes
     */
    private function assertRoute(RouteInterface $route, array $attributes): void
    {
        [$method, $scheme, , $path] = $attributes;

        if (!$this->compareMethod($route->getMethods(), $method)) {
            throw new MethodNotAllowedException($route->getMethods(), $path, $method);
        }

        if (!$this->compareScheme($route->getSchemes(), $scheme)) {
            throw new UriHandlerException(
                \sprintf('Unfortunately current scheme "%s" is not allowed on requested uri [%s]', $scheme, $path),
                400
            );
        }
    }
}

divineniiquaye / flight-routing

Push — master ( 00affb...1204ff )

Router::fetchOptions() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
