Router::process() - Code Metrics - Inspection of "Allow router to be used as middleware" - northwoods/router - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#1)

by Woody

created 2018-11-06 16:53 UTC

Router::process() A

↳ Parent: Router

Complexity

Conditions	4
Paths	4

Size

Total Lines	21
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	12
CRAP Score	4

Importance

Changes

Metric	Value
eloc	11
dl	0
loc	21
ccs	12
cts	12
cp	1
rs	9.9
c	0
b	0
f	0
cc	4
nc	4
nop	2
crap	4

<?php
declare(strict_types=1);

namespace Northwoods\Router;

use FastRoute\Dispatcher;
use FastRoute\RouteCollector;
use FastRoute\RouteParser;
use Fig\Http\Message\RequestMethodInterface;
use Fig\Http\Message\StatusCodeInterface;
use Http\Factory\Discovery\HttpFactory;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\ResponseFactoryInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;

use function FastRoute\simpleDispatcher;

class Router implements
    MiddlewareInterface,
    RequestHandlerInterface,
    RequestMethodInterface,
    StatusCodeInterface
{
    /** @var RouteCollection */
    private $routes;

    /** @var RouteParser */
    private $parser;

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

    public function __construct(
        ?RouteCollection $routes = null,
        ?RouteParser $parser = null,
        ?ResponseFactoryInterface $responseFactory = null
    ) {
        $this->routes = $routes ?? new RouteCollection();
        $this->parser = $parser ?? new RouteParser\Std();
        $this->responseFactory = $responseFactory ?? HttpFactory::responseFactory();
    }

    /**
     * Add a named route.
     */
    public function add(string $name, Route $route): void
    {
        $this->routes->set($name, $route);
    }

    /**
     * Add a named route for a GET request.
     */
    public function get(string $name, string $pattern, RequestHandlerInterface $handler): void
    {
        $this->add($name, new Route(self::METHOD_GET, $pattern, $handler));
    }

    /**
     * Add a named route for a POST request.
     */
    public function post(string $name, string $pattern, RequestHandlerInterface $handler): void
    {
        $this->add($name, new Route(self::METHOD_POST, $pattern, $handler));
    }

    /**
     * Add a named route for a PUT request.
     */
    public function put(string $name, string $pattern, RequestHandlerInterface $handler): void
    {
        $this->add($name, new Route(self::METHOD_PUT, $pattern, $handler));
    }

    /**
     * Add a named route for a PATCH request.
     */
    public function patch(string $name, string $pattern, RequestHandlerInterface $handler): void
    {
        $this->add($name, new Route(self::METHOD_PATCH, $pattern, $handler));
    }

    /**
     * Add a named route for a DELETE request.
     */
    public function delete(string $name, string $pattern, RequestHandlerInterface $handler): void
    {
        $this->add($name, new Route(self::METHOD_DELETE, $pattern, $handler));
    }

    /**
     * Add a named route for a HEAD request.
     */
    public function head(string $name, string $pattern, RequestHandlerInterface $handler): void
    {
        $this->add($name, new Route(self::METHOD_HEAD, $pattern, $handler));
    }

    /**
     * Add a named route for a OPTIONS request.
     */
    public function options(string $name, string $pattern, RequestHandlerInterface $handler): void
    {
        $this->add($name, new Route(self::METHOD_OPTIONS, $pattern, $handler));
    }

    /**
     * Get the route collection.
     */
    public function routes(): RouteCollection
    {
        return $this->routes;
    }

    /**
     * Generate a URI for a route.
     *
     * @throws Error\UriParameterInvalidException If a parameter has an invalid value.
     * @throws Error\UriParametersMissingException If required parameters are missing.
     */
    public function uri(string $name, array $params = []): string
    {
        // Use the route parser to generate a URI for a named route:
        // https://github.com/nikic/FastRoute/issues/66
        $routes = $this->parser->parse($this->routes->get($name)->pattern());
        $missing = [];

        foreach (array_reverse($routes) as $parts) {
            $missing = $this->findMissingParameters($parts, $params);

            // Try the next route
            if (count($missing) > 0) {
                continue;
            }

            $path = '';
            foreach ($parts as $part) {
                // Fixed segment
                if (is_string($part)) {
                    $path .= $part;
                    continue;
                }

                // Check if the parameter can be matched
                if (! preg_match("~^{$part[1]}$~", strval($params[$part[0]]))) {
                    throw Error\UriParameterInvalidException::from($part[0], $part[1]);
                }

                // Variable segment
                $path .= $params[$part[0]];
            }

            return $path;
        }

        throw Error\UriParametersMissingException::from($name, $missing, array_keys($params));
    }

    // MiddlewareInterface
    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
    {
        // https://github.com/nikic/FastRoute#usage
        $dispatcher = $this->makeDispatcher();
        $match = $dispatcher->dispatch($request->getMethod(), $request->getUri()->getPath());

        if ($match[0] === Dispatcher::NOT_FOUND) {
            return $handler->handle($request);
        }

        if ($match[0] === Dispatcher::METHOD_NOT_ALLOWED) {
            return $this->responseFactory
                        ->createResponse(self::STATUS_METHOD_NOT_ALLOWED)
                        ->withHeader('allow', implode(',', $match[1]));
        }

        foreach ($match[2] as $param => $value) {
            $request = $request->withAttribute($param, $value);
        }

        return $match[1]->handler()->handle($request);
    }

    // RequestHandlerInterface
    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        return $this->process($request, new NotFoundHandler($this->responseFactory));
    }

    /** @return string[] */
    private function findMissingParameters(array $parts, array $params): array
    {
        // Remove all fixed segments, get named parts
        $missing = array_column(array_filter($parts, 'is_array'), 0);

        return array_diff($missing, array_keys($params));
    }

    private function makeDispatcher(): Dispatcher
    {
        return simpleDispatcher(function (RouteCollector $collector): void {
            foreach ($this->routes as $route) {
                $collector->addRoute($route->method(), $route->pattern(), $route);
            }
        });
    }
}


1		<?php
2		declare(strict_types=1);
3
4		namespace Northwoods\Router;
5
6		use FastRoute\Dispatcher;
7		use FastRoute\RouteCollector;
8		use FastRoute\RouteParser;
9		use Fig\Http\Message\RequestMethodInterface;
10		use Fig\Http\Message\StatusCodeInterface;
11		use Http\Factory\Discovery\HttpFactory;
12		use Psr\Http\Message\ServerRequestInterface;
13		use Psr\Http\Message\ResponseFactoryInterface;
14		use Psr\Http\Message\ResponseInterface;
15		use Psr\Http\Server\MiddlewareInterface;
16		use Psr\Http\Server\RequestHandlerInterface;
17
18		use function FastRoute\simpleDispatcher;
19
20		class Router implements
21		MiddlewareInterface,
22		RequestHandlerInterface,
23		RequestMethodInterface,
24		StatusCodeInterface
25		{
26		/** @var RouteCollection */
27		private $routes;
28
29		/** @var RouteParser */
30		private $parser;
31
32		/** @var ResponseFactoryInterface */
33		private $responseFactory;
34
35	13	public function __construct(
36		?RouteCollection $routes = null,
37		?RouteParser $parser = null,
38		?ResponseFactoryInterface $responseFactory = null
39		) {
40	13	$this->routes = $routes ?? new RouteCollection();
41	13	$this->parser = $parser ?? new RouteParser\Std();
42	13	$this->responseFactory = $responseFactory ?? HttpFactory::responseFactory();
43	13	}
44
45		/**
46		* Add a named route.
47		*/
48	11	public function add(string $name, Route $route): void
49		{
50	11	$this->routes->set($name, $route);
51	11	}
52
53		/**
54		* Add a named route for a GET request.
55		*/
56	2	public function get(string $name, string $pattern, RequestHandlerInterface $handler): void
57		{
58	2	$this->add($name, new Route(self::METHOD_GET, $pattern, $handler));
59	2	}
60
61		/**
62		* Add a named route for a POST request.
63		*/
64	3	public function post(string $name, string $pattern, RequestHandlerInterface $handler): void
65		{
66	3	$this->add($name, new Route(self::METHOD_POST, $pattern, $handler));
67	3	}
68
69		/**
70		* Add a named route for a PUT request.
71		*/
72	1	public function put(string $name, string $pattern, RequestHandlerInterface $handler): void
73		{
74	1	$this->add($name, new Route(self::METHOD_PUT, $pattern, $handler));
75	1	}
76
77		/**
78		* Add a named route for a PATCH request.
79		*/
80	3	public function patch(string $name, string $pattern, RequestHandlerInterface $handler): void
81		{
82	3	$this->add($name, new Route(self::METHOD_PATCH, $pattern, $handler));
83	3	}
84
85		/**
86		* Add a named route for a DELETE request.
87		*/
88	1	public function delete(string $name, string $pattern, RequestHandlerInterface $handler): void
89		{
90	1	$this->add($name, new Route(self::METHOD_DELETE, $pattern, $handler));
91	1	}
92
93		/**
94		* Add a named route for a HEAD request.
95		*/
96	1	public function head(string $name, string $pattern, RequestHandlerInterface $handler): void
97		{
98	1	$this->add($name, new Route(self::METHOD_HEAD, $pattern, $handler));
99	1	}
100
101		/**
102		* Add a named route for a OPTIONS request.
103		*/
104	1	public function options(string $name, string $pattern, RequestHandlerInterface $handler): void
105		{
106	1	$this->add($name, new Route(self::METHOD_OPTIONS, $pattern, $handler));
107	1	}
108
109		/**
110		* Get the route collection.
111		*/
112	1	public function routes(): RouteCollection
113		{
114	1	return $this->routes;
115		}
116
117		/**
118		* Generate a URI for a route.
119		*
120		* @throws Error\UriParameterInvalidException If a parameter has an invalid value.
121		* @throws Error\UriParametersMissingException If required parameters are missing.
122		*/
123	3	public function uri(string $name, array $params = []): string
124		{
125		// Use the route parser to generate a URI for a named route:
126		// https://github.com/nikic/FastRoute/issues/66
127	3	$routes = $this->parser->parse($this->routes->get($name)->pattern());
128	3	$missing = [];
129
130	3	foreach (array_reverse($routes) as $parts) {
131	3	$missing = $this->findMissingParameters($parts, $params);
132
133		// Try the next route
134	3	if (count($missing) > 0) {
135	1	continue;
136		}
137
138	2	$path = '';
139	2	foreach ($parts as $part) {
140		// Fixed segment
141	2	if (is_string($part)) {
142	2	$path .= $part;
143	2	continue;
144		}
145
146		// Check if the parameter can be matched
147	2	if (! preg_match("~^{$part[1]}$~", strval($params[$part[0]]))) {
148	1	throw Error\UriParameterInvalidException::from($part[0], $part[1]);
149		}
150
151		// Variable segment
152	1	$path .= $params[$part[0]];
153		}
154
155	1	return $path;
156		}
157
158	1	throw Error\UriParametersMissingException::from($name, $missing, array_keys($params));
159		}
160
161		// MiddlewareInterface
162	9	public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
163		{
164		// https://github.com/nikic/FastRoute#usage
165	9	$dispatcher = $this->makeDispatcher();
166	9	$match = $dispatcher->dispatch($request->getMethod(), $request->getUri()->getPath());
167
168	9	if ($match[0] === Dispatcher::NOT_FOUND) {
169	1	return $handler->handle($request);
170		}
171
172	8	if ($match[0] === Dispatcher::METHOD_NOT_ALLOWED) {
173	1	return $this->responseFactory
174	1	->createResponse(self::STATUS_METHOD_NOT_ALLOWED)
175	1	->withHeader('allow', implode(',', $match[1]));
176		}
177
178	7	foreach ($match[2] as $param => $value) {
179	2	$request = $request->withAttribute($param, $value);
180		}
181
182	7	return $match[1]->handler()->handle($request);
183		}
184
185		// RequestHandlerInterface
186	9	public function handle(ServerRequestInterface $request): ResponseInterface
187		{
188	9	return $this->process($request, new NotFoundHandler($this->responseFactory));
189		}
190
191		/** @return string[] */
192	3	private function findMissingParameters(array $parts, array $params): array
193		{
194		// Remove all fixed segments, get named parts
195	3	$missing = array_column(array_filter($parts, 'is_array'), 0);
196
197	3	return array_diff($missing, array_keys($params));
198		}
199
200	9	private function makeDispatcher(): Dispatcher
201		{
202		return simpleDispatcher(function (RouteCollector $collector): void {
203	9	foreach ($this->routes as $route) {
204	8	$collector->addRoute($route->method(), $route->pattern(), $route);
205		}
206	9	});
207		}
208		}
209

northwoods / router

Pull Request — master (#1)

Router::process() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like