Dispatcher::requestWithRouteAttributes() - Code Metrics - Inspection of "Merge pull request #250 from delboy1978uk/master" - thephpleague/route - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a15d3a...1145d3 )

by Phil

created 2020-05-18 06:48 UTC

Dispatcher::requestWithRouteAttributes() A

↳ Parent: Dispatcher

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	10
ccs	5
cts	5
cp	1
rs	9.9332
c	0
b	0
f	0
cc	2
nc	2
nop	2
crap	2

<?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};
use Psr\Http\Message\{ResponseInterface, ServerRequestInterface};
use Psr\Http\Server\RequestHandlerInterface;

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

    /**
     * Dispatch the current route
     *
     * @param ServerRequestInterface $request
     *
     * @return ResponseInterface
     */
    public function dispatchRequest(ServerRequestInterface $request): ResponseInterface
    {
        $httpMethod = $request->getMethod();
        $uri        = $request->getUri()->getPath();
        $match      = $this->dispatch($httpMethod, $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], $httpMethod, $uri)->setVars($match[2]);
                $this->setFoundMiddleware($route);
                $request = $this->requestWithRouteAttributes($request, $route);
                break;
        }

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

    /**
     *  Adds routing variables as Request Attributes
     *
     * @param ServerRequestInterface $request
     * @param Route $route
     *
     * @return ServerRequestInterface
     */
    protected function requestWithRouteAttributes(ServerRequestInterface $request, Route $route): ServerRequestInterface
    {
        $routerParams = $route->getVars();

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

        return $request;
    }

    /**
     * Ensure handler is a Route, honoring the contract of dispatchRequest.
     *
     * @param Route|mixed $matchingHandler
     * @param string      $httpMethod
     * @param string      $uri
     *
     * @return Route
     *
     */
    private function ensureHandlerIsRoute($matchingHandler, $httpMethod, $uri): Route
    {
        if (is_a($matchingHandler, Route::class)) {
            return $matchingHandler;
        }
        return new Route($httpMethod, $uri, $matchingHandler);
    }

    /**
     * {@inheritdoc}
     */
    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        $middleware = $this->shiftMiddleware();

        return $middleware->process($request, $this);
    }

    /**
     * Set up middleware for a found route
     *
     * @param Route $route
     *
     * @return void
     */
    protected function setFoundMiddleware(Route $route): void
    {
        if ($route->getStrategy() === null) {
            $route->setStrategy($this->getStrategy());
        }

        $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->getExceptionHandler());

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

    /**
     * Set up middleware for a not found route
     *
     * @return void
     */
    protected function setNotFoundDecoratorMiddleware(): void
    {
        $middleware = $this->getStrategy()->getNotFoundDecorator(new NotFoundException);
        $this->prependMiddleware($middleware);
    }

    /**
     * Set up middleware for a not allowed route
     *
     * @param array $allowed
     *
     * @return void
     */
    protected function setMethodNotAllowedDecoratorMiddleware(array $allowed): void
    {
        $middleware = $this->getStrategy()->getMethodNotAllowedDecorator(
            new MethodNotAllowedException($allowed)
        );

        $this->prependMiddleware($middleware);
    }
}


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

thephpleague / route

Push — master ( a15d3a...1145d3 )

Dispatcher::requestWithRouteAttributes() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like