Dispatcher::setNotFoundDecoratorMiddleware() - Code Metrics - Inspection of "Initial 5.x" - thephpleague/route - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#283)

by Phil

created 2020-06-25 07:28 UTC

Dispatcher::setNotFoundDecoratorMiddleware() A

↳ Parent: Dispatcher

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	2.0116

Importance

Changes

Metric	Value
dl	0
loc	11
ccs	6
cts	7
cp	0.8571
rs	9.9
c	0
b	0
f	0
cc	2
nc	2
nop	0
crap	2.0116

<?php

declare(strict_types=1);

namespace League\Route;

use FastRoute\Dispatcher as FastRoute;
use FastRoute\Dispatcher\GroupCountBased as GroupCountBasedDispatcher;
use League\Route\Http\Exception\{MethodNotAllowedException, NotFoundException};
use League\Route\Middleware\{MiddlewareAwareInterface, MiddlewareAwareTrait};
use League\Route\Strategy\{StrategyAwareInterface, StrategyAwareTrait, StrategyInterface};
use Psr\Http\Message\{ResponseInterface, ServerRequestInterface};
use Psr\Http\Server\RequestHandlerInterface;
use RuntimeException;

class Dispatcher extends GroupCountBasedDispatcher implements
    MiddlewareAwareInterface,
    RequestHandlerInterface,
    StrategyAwareInterface
{
    use MiddlewareAwareTrait;
    use StrategyAwareTrait;

    public function dispatchRequest(ServerRequestInterface $request): ResponseInterface
    {
        $method = $request->getMethod();
        $uri    = $request->getUri()->getPath();
        $match  = $this->dispatch($method, $uri);

        switch ($match[0]) {
            case FastRoute::NOT_FOUND:
                $this->setNotFoundDecoratorMiddleware();
                break;
            case FastRoute::METHOD_NOT_ALLOWED:
                $allowed = (array) $match[1];
                $this->setMethodNotAllowedDecoratorMiddleware($allowed);
                break;
            case FastRoute::FOUND:
                $route = $this->ensureHandlerIsRoute($match[1], $method, $uri)->setVars($match[2]);

                if ($this->isExtraConditionMatch($route, $request)) {
                    $this->setFoundMiddleware($route);
                    $request = $this->requestWithRouteAttributes($request, $route);
                    break;
                }

                $this->setNotFoundDecoratorMiddleware();
                break;
        }

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

    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        $middleware = $this->shiftMiddleware();
        return $middleware->process($request, $this);
    }

    protected function ensureHandlerIsRoute($matchingHandler, $httpMethod, $uri): Route
    {
        if ($matchingHandler instanceof Route) {
            return $matchingHandler;
        }

        return new Route($httpMethod, $uri, $matchingHandler);
    }

    protected function isExtraConditionMatch(Route $route, ServerRequestInterface $request): bool
    {
        // check for scheme condition
        $scheme = $route->getScheme();
        if ($scheme !== null && $scheme !== $request->getUri()->getScheme()) {
            return false;
        }

        // check for domain condition
        $host = $route->getHost();
        if ($host !== null && $host !== $request->getUri()->getHost()) {
            return false;
        }

        // check for port condition
        $port = $route->getPort();
        if ($port !== null && $port !== $request->getUri()->getPort()) {
            return false;
        }

        return true;
    }

    protected function requestWithRouteAttributes(ServerRequestInterface $request, Route $route): ServerRequestInterface
    {
        $routerParams = $route->getVars();

        foreach ($routerParams as $key => $value) {
            $request = $request->withAttribute($key, $value);
        }

        return $request;
    }

    protected function setFoundMiddleware(Route $route): void
    {
        if ($route->getStrategy() === null) {
            $strategy = $this->getStrategy();

            if (!($strategy instanceof StrategyInterface)) {
                throw new RuntimeException('Cannot determine strategy to use for dispatch of found route');
            }

            $route->setStrategy($strategy);
        }

        $strategy  = $route->getStrategy();
        $container = $strategy instanceof ContainerAwareInterface ? $strategy->getContainer() : null;

        foreach ($this->getMiddlewareStack() as $key => $middleware) {
            $this->middleware[$key] = $this->resolveMiddleware($middleware, $container);
        }

        // wrap entire dispatch process in exception handler
        $this->prependMiddleware($strategy->getThrowableHandler());

        // add group and route specific middleware
        if ($group = $route->getParentGroup()) {
            foreach ($group->getMiddlewareStack() as $middleware) {
                $this->middleware($this->resolveMiddleware($middleware, $container));
            }
        }

        foreach ($route->getMiddlewareStack() as $middleware) {
            $this->middleware($this->resolveMiddleware($middleware, $container));
        }

        // add actual route to end of stack
        $this->middleware($route);
    }

    protected function setMethodNotAllowedDecoratorMiddleware(array $allowed): void
    {
        $strategy = $this->getStrategy();

        if (!($strategy instanceof StrategyInterface)) {
            throw new RuntimeException('Cannot determine strategy to use for dispatch of method not allowed route');
        }

        $middleware = $strategy->getMethodNotAllowedDecorator(new MethodNotAllowedException($allowed));
        $this->prependMiddleware($middleware);
    }

    protected function setNotFoundDecoratorMiddleware(): void
    {
        $strategy = $this->getStrategy();

        if (!($strategy instanceof StrategyInterface)) {
            throw new RuntimeException('Cannot determine strategy to use for dispatch of not found route');
        }

        $middleware = $strategy->getNotFoundDecorator(new NotFoundException());
        $this->prependMiddleware($middleware);
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace League\Route;
6
7		use FastRoute\Dispatcher as FastRoute;
8		use FastRoute\Dispatcher\GroupCountBased as GroupCountBasedDispatcher;
9		use League\Route\Http\Exception\{MethodNotAllowedException, NotFoundException};
10		use League\Route\Middleware\{MiddlewareAwareInterface, MiddlewareAwareTrait};
11		use League\Route\Strategy\{StrategyAwareInterface, StrategyAwareTrait, StrategyInterface};
12		use Psr\Http\Message\{ResponseInterface, ServerRequestInterface};
13		use Psr\Http\Server\RequestHandlerInterface;
14		use RuntimeException;
15
16		class Dispatcher extends GroupCountBasedDispatcher implements
17		MiddlewareAwareInterface,
18		RequestHandlerInterface,
19		StrategyAwareInterface
20		{
21		use MiddlewareAwareTrait;
22		use StrategyAwareTrait;
23
24	51	public function dispatchRequest(ServerRequestInterface $request): ResponseInterface
25		{
26	51	$method = $request->getMethod();
27	51	$uri = $request->getUri()->getPath();
28	51	$match = $this->dispatch($method, $uri);
29
30	51	switch ($match[0]) {
31	51	case FastRoute::NOT_FOUND:
32	9	$this->setNotFoundDecoratorMiddleware();
33	9	break;
34	42	case FastRoute::METHOD_NOT_ALLOWED:
35	6	$allowed = (array) $match[1];
36	6	$this->setMethodNotAllowedDecoratorMiddleware($allowed);
37	6	break;
38	36	case FastRoute::FOUND:
39	36	$route = $this->ensureHandlerIsRoute($match[1], $method, $uri)->setVars($match[2]);
40
41	36	if ($this->isExtraConditionMatch($route, $request)) {
42	27	$this->setFoundMiddleware($route);
43	27	$request = $this->requestWithRouteAttributes($request, $route);
44	27	break;
45		}
46
47	9	$this->setNotFoundDecoratorMiddleware();
48	9	break;
49		}
50
51	51	return $this->handle($request);
52		}
53
54	51	public function handle(ServerRequestInterface $request): ResponseInterface
55		{
56	51	$middleware = $this->shiftMiddleware();
57	51	return $middleware->process($request, $this);
58		}
59
60	36	protected function ensureHandlerIsRoute($matchingHandler, $httpMethod, $uri): Route
61		{
62	36	if ($matchingHandler instanceof Route) {
63	36	return $matchingHandler;
64		}
65
66		return new Route($httpMethod, $uri, $matchingHandler);
67		}
68
69	36	protected function isExtraConditionMatch(Route $route, ServerRequestInterface $request): bool
70		{
71		// check for scheme condition
72	36	$scheme = $route->getScheme();
73	36	if ($scheme !== null && $scheme !== $request->getUri()->getScheme()) {
74	3	return false;
75		}
76
77		// check for domain condition
78	33	$host = $route->getHost();
79	33	if ($host !== null && $host !== $request->getUri()->getHost()) {
80	3	return false;
81		}
82
83		// check for port condition
84	30	$port = $route->getPort();
85	30	if ($port !== null && $port !== $request->getUri()->getPort()) {
86	3	return false;
87		}
88
89	27	return true;
90		}
91
92	27	protected function requestWithRouteAttributes(ServerRequestInterface $request, Route $route): ServerRequestInterface
93		{
94	27	$routerParams = $route->getVars();
95
96	27	foreach ($routerParams as $key => $value) {
97	9	$request = $request->withAttribute($key, $value);
98		}
99
100	27	return $request;
101		}
102
103	27	protected function setFoundMiddleware(Route $route): void
104		{
105	27	if ($route->getStrategy() === null) {
106		$strategy = $this->getStrategy();
107
108		if (!($strategy instanceof StrategyInterface)) {
109		throw new RuntimeException('Cannot determine strategy to use for dispatch of found route');
110		}
111
112		$route->setStrategy($strategy);
113		}
114
115	27	$strategy = $route->getStrategy();
116	27	$container = $strategy instanceof ContainerAwareInterface ? $strategy->getContainer() : null;
117
118	27	foreach ($this->getMiddlewareStack() as $key => $middleware) {
119	3	$this->middleware[$key] = $this->resolveMiddleware($middleware, $container);
120		}
121
122		// wrap entire dispatch process in exception handler
123	27	$this->prependMiddleware($strategy->getThrowableHandler());
124
125		// add group and route specific middleware
126	27	if ($group = $route->getParentGroup()) {
127	6	foreach ($group->getMiddlewareStack() as $middleware) {
128	3	$this->middleware($this->resolveMiddleware($middleware, $container));
129		}
130		}
131
132	27	foreach ($route->getMiddlewareStack() as $middleware) {
133	3	$this->middleware($this->resolveMiddleware($middleware, $container));
134		}
135
136		// add actual route to end of stack
137	27	$this->middleware($route);
138	27	}
139
140	6	protected function setMethodNotAllowedDecoratorMiddleware(array $allowed): void
141		{
142	6	$strategy = $this->getStrategy();
143
144	6	if (!($strategy instanceof StrategyInterface)) {
145		throw new RuntimeException('Cannot determine strategy to use for dispatch of method not allowed route');
146		}
147
148	6	$middleware = $strategy->getMethodNotAllowedDecorator(new MethodNotAllowedException($allowed));
149	6	$this->prependMiddleware($middleware);
150	6	}
151
152	18	protected function setNotFoundDecoratorMiddleware(): void
153		{
154	18	$strategy = $this->getStrategy();
155
156	18	if (!($strategy instanceof StrategyInterface)) {
157		throw new RuntimeException('Cannot determine strategy to use for dispatch of not found route');
158		}
159
160	18	$middleware = $strategy->getNotFoundDecorator(new NotFoundException());
161	18	$this->prependMiddleware($middleware);
162	18	}
163		}
164

thephpleague / route

Pull Request — master (#283)

Dispatcher::setNotFoundDecoratorMiddleware() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like