Dispatcher::dispatchRequest() - Code Metrics - Inspection of "Add routing params to request query params for mid..." - thephpleague/route - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#250)

by Derek Stephen

created 2020-02-21 10:48 UTC

Dispatcher::dispatchRequest() A

↳ Parent: Dispatcher

Complexity

Conditions	4
Paths	4

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	17
CRAP Score	4

Importance

Changes

Metric	Value
dl	0
loc	23
ccs	17
cts	17
cp	1
rs	9.552
c	0
b	0
f	0
cc	4
nc	4
nop	1
crap	4

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

    /**
     * @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		break;
47		}
48	48
49		return $this->handle($request);
50		}
51
52		/**
53		* @param ServerRequestInterface $request
54		* @param Route $route
55		* @return ServerRequestInterface
56		*/
57		protected function requestWithRouteAttributes(ServerRequestInterface $request, Route $route): ServerRequestInterface
58		{
59		$routerParams = $route->getVars();
60
61	24	foreach ($routerParams as $key => $value) {
62		$request = $request->withAttribute($key, $value);
63	24	}
64	21
65		return $request;
66	3	}
67
68		/**
69		* Ensure handler is a Route, honoring the contract of dispatchRequest.
70		*
71		* @param Route\|mixed $matchingHandler
72	48	* @param string $httpMethod
73		* @param string $uri
74	48	*
75		* @return Route
76	48	*
77		*/
78		private function ensureHandlerIsRoute($matchingHandler, $httpMethod, $uri): Route
79		{
80		if (is_a($matchingHandler, Route::class)) {
81		return $matchingHandler;
82		}
83		return new Route($httpMethod, $uri, $matchingHandler);
84		}
85
86	24	/**
87		* {@inheritdoc}
88	24	*/
89	3	public function handle(ServerRequestInterface $request): ResponseInterface
90		{
91		$middleware = $this->shiftMiddleware();
92	24
93	24	return $middleware->process($request, $this);
94		}
95	24
96	3	/**
97		* Set up middleware for a found route
98		*
99		* @param Route $route
100	24	*
101		* @return void
102		*/
103	24	protected function setFoundMiddleware(Route $route): void
104	6	{
105	3	if ($route->getStrategy() === null) {
106		$route->setStrategy($this->getStrategy());
107		}
108
109	24	$strategy = $route->getStrategy();
110	3	$container = $strategy instanceof ContainerAwareInterface ? $strategy->getContainer() : null;
111
112		foreach ($this->getMiddlewareStack() as $key => $middleware) {
113		$this->middleware[$key] = $this->resolveMiddleware($middleware, $container);
114	24	}
115	24
116		// wrap entire dispatch process in exception handler
117		$this->prependMiddleware($strategy->getExceptionHandler());
118
119		// add group and route specific middleware
120		if ($group = $route->getParentGroup()) {
121		foreach ($group->getMiddlewareStack() as $middleware) {
122	18	$this->middleware($this->resolveMiddleware($middleware, $container));
123		}
124	18	}
125	18
126	18	foreach ($route->getMiddlewareStack() as $middleware) {
127		$this->middleware($this->resolveMiddleware($middleware, $container));
128		}
129
130		// add actual route to end of stack
131		$this->middleware($route);
132		}
133
134		/**
135	6	* Set up middleware for a not found route
136		*
137	6	* @return void
138	6	*/
139		protected function setNotFoundDecoratorMiddleware(): void
140		{
141	6	$middleware = $this->getStrategy()->getNotFoundDecorator(new NotFoundException);
142	6	$this->prependMiddleware($middleware);
143		}
144
145		/**
146		* Set up middleware for a not allowed route
147		*
148		* @param array $allowed
149		*
150		* @return void
151		*/
152		protected function setMethodNotAllowedDecoratorMiddleware(array $allowed): void
153		{
154		$middleware = $this->getStrategy()->getMethodNotAllowedDecorator(
155		new MethodNotAllowedException($allowed)
156		);
157
158		$this->prependMiddleware($middleware);
159		}
160		}
161

thephpleague / route

Pull Request — master (#250)

Dispatcher::dispatchRequest() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like