Dispatcher::setFoundMiddleware()   B
last analyzed

Complexity

Conditions 7
Paths 40

Size

Total Lines 30

Duplication

Lines 0
Ratio 0 %

Code Coverage

Tests 15
CRAP Score 7

Importance

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