4.x New Dispatcher & Routing Results

Slim/App.php

@@ -13,6 +13,8 @@
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\UriInterface;
+use Slim\Exception\HttpMethodNotAllowedException;
+use Slim\Exception\HttpNotFoundException;
 use Slim\Http\Headers;
 use Slim\Http\Request;
 use Slim\Http\Response;
@@ -502,23 +504,25 @@ public function respond(ResponseInterface $response)
      * @param  ResponseInterface      $response The most recent Response object
      *
      * @return ResponseInterface
+     *
+     * @throws HttpNotFoundException
+     * @throws HttpMethodNotAllowedException
      */
     public function __invoke(ServerRequestInterface $request, ResponseInterface $response)
     {
-        // Get the route info
-        $routeInfo = $request->getAttribute('routeInfo');
-
-        /** @var \Slim\Interfaces\RouterInterface $router */
-        $router = $this->getRouter();
+        /**
+         * @var DispatcherResults $dispatcherResults
+         */
+        $dispatcherResults = $request->getAttribute('dispatcherResults');
 
         // If routing hasn't been done, then do it now so we can dispatch
-        if ($routeInfo === null) {
+        if ($dispatcherResults === null) {
+            $router = $this->getRouter();
             $routingMiddleware = new RoutingMiddleware($router);
             $request = $routingMiddleware->performRouting($request);
-            $routeInfo = $request->getAttribute('routeInfo');
         }
 
-        $route = $router->lookupRoute($routeInfo[1]);
+        $route = $request->getAttribute('route');
         return $route->run($request, $response);
     }
 

Slim/Dispatcher.php

@@ -0,0 +1,132 @@
+<?php
+/**
+ * Slim Framework (https://slimframework.com)
+ *
+ * @link      https://github.com/slimphp/Slim
+ * @copyright Copyright (c) 2011-2018 Josh Lockhart
+ * @license   https://github.com/slimphp/Slim/blob/4.x/LICENSE.md (MIT License)
+ */
+namespace Slim;
+
+use FastRoute\Dispatcher\GroupCountBased;
+
+class Dispatcher extends GroupCountBased
+{
+    /**
+     * @var string
+     */
+    private $httpMethod;
+
+    /**
+     * @var string
+     */
+    private $uri;
+
+    /**
+     * @var array|null
+     */
+    private $allowedMethods;
+
+    /**
+     * @param string $httpMethod
+     * @param string $uri
+     * @return DispatcherResults
+     */
+    public function dispatch($httpMethod, $uri)
+    {
+        $this->httpMethod = $httpMethod;
+        $this->uri = $uri;
+
+        if (isset($this->staticRouteMap[$httpMethod][$uri])) {
+            return $this->dispatcherResults(self::FOUND, $this->staticRouteMap[$httpMethod][$uri]);
+        }
+
+        $varRouteData = $this->variableRouteData;
+        if (isset($varRouteData[$httpMethod])) {
+            $result = $this->dispatchVariableRoute($varRouteData[$httpMethod], $uri);
+            $dispatcherResults = $this->dispatcherResultsFromVariableRouteResults($result);
+            if ($dispatcherResults->getRouteStatus() === Dispatcher::FOUND) {
+                return $dispatcherResults;
+            }
+        }
+
+        // For HEAD requests, attempt fallback to GET
+        if ($httpMethod === 'HEAD') {
+            if (isset($this->staticRouteMap['GET'][$uri])) {
+                return $this->dispatcherResults(self::FOUND, $this->staticRouteMap['GET'][$uri]);
+            }
+            if (isset($varRouteData['GET'])) {
+                $result = $this->dispatchVariableRoute($varRouteData['GET'], $uri);
+                return $this->dispatcherResultsFromVariableRouteResults($result);
+            }
+        }
+
+        // If nothing else matches, try fallback routes
+        if (isset($this->staticRouteMap['*'][$uri])) {
+            return $this->dispatcherResults(self::FOUND, $this->staticRouteMap['*'][$uri]);
+        }
+        if (isset($varRouteData['*'])) {
+            $result = $this->dispatchVariableRoute($varRouteData['*'], $uri);
+            return $this->dispatcherResultsFromVariableRouteResults($result);
+        }
+
+        $this->allowedMethods = $this->getAllowedMethods($httpMethod, $uri);
+        if (count($this->allowedMethods)) {
+            return $this->dispatcherResults(self::METHOD_NOT_ALLOWED);
+        }
+
+        return $this->dispatcherResults(self::NOT_FOUND);
+    }
+
+    /**
+     * @param $status
+     * @param null $handler
+     * @param array $arguments
+     * @return DispatcherResults
+     */
+    protected function dispatcherResults($status, $handler = null, $arguments = [])
+    {
+        return new DispatcherResults($this, $this->httpMethod, $this->uri, $status, $handler, $arguments);
+    }
+
+    /**
+     * @param array $result
+     * @return DispatcherResults
+     */
+    protected function dispatcherResultsFromVariableRouteResults($result)
+    {
+        if ($result[0] === self::FOUND) {
+            return $this->dispatcherResults(self::FOUND, $result[1], $result[2]);
+        }
+        return $this->dispatcherResults(self::NOT_FOUND);
+    }
+
+    /**
+     * @param string $httpMethod
+     * @param string $uri
+     * @return array
+     */
+    public function getAllowedMethods($httpMethod, $uri)
+    {
+        if ($this->allowedMethods !== null) {
+            return $this->allowedMethods;
+        }
+
+        $this->allowedMethods = [];
+        foreach ($this->staticRouteMap as $method => $uriMap) {
+            if ($method !== $httpMethod && isset($uriMap[$uri])) {
+                $this->allowedMethods[] = $method;
+            }
+        }
+
+        $varRouteData = $this->variableRouteData;
+        foreach ($varRouteData as $method => $routeData) {
+            $result = $this->dispatchVariableRoute($routeData, $uri);
+            if ($result[0] === self::FOUND) {
+                $this->allowedMethods[] = $method;
+            }
+        }
+
+        return $this->allowedMethods;
+    }
+}

Slim/DispatcherResults.php

@@ -0,0 +1,139 @@
+<?php
+/**
+ * Slim Framework (https://slimframework.com)
+ *
+ * @link      https://github.com/slimphp/Slim
+ * @copyright Copyright (c) 2011-2018 Josh Lockhart
+ * @license   https://github.com/slimphp/Slim/blob/4.x/LICENSE.md (MIT License)
+ */
+namespace Slim;
+
+class DispatcherResults
+{
+    /**
+     * @var Dispatcher
+     */
+    protected $dispatcher;
+
+    /**
+     * @var string
+     */
+    protected $httpMethod;
+
+    /**
+     * @var string
+     */
+    protected $uri;
+
+    /**
+     * @var int
+     * The following statuses are constants from Slim\Dispatcher
+     * Slim\Dispatcher extends FastRoute\Dispatcher\GroupCountBased
+     * Which implements the interface FastRoute\Dispatcher where the original constants are located
+     * Slim\Dispatcher::NOT_FOUND = 0
+     * Slim\Dispatcher::FOUND = 1
+     * Slim\Dispatcher::NOT_ALLOWED = 2
+     */
+    protected $routeStatus;
+
+    /**
+     * @var callable|null
+     */
+    protected $routeHandler;
+
+    /**
+     * @var array
+     */
+    protected $routeArguments;
+
+    /**
+     * DispatcherResults constructor.
+     * @param Dispatcher $dispatcher
+     * @param $httpMethod
+     * @param $uri
+     * @param int $routeStatus
+     * @param callable|null $routeHandler
+     * @param array $routeArguments
+     */
+    public function __construct(
+        Dispatcher $dispatcher,
+        $httpMethod,
+        $uri,
+        $routeStatus,
+        $routeHandler = null,
+        $routeArguments = []
+    ) {
+        $this->dispatcher = $dispatcher;
+        $this->httpMethod = $httpMethod;
+        $this->uri = $uri;
+        $this->routeStatus = $routeStatus;
+        $this->routeHandler = $routeHandler;
+        $this->routeArguments = $routeArguments;
+    }
+
+    /**
+     * @return mixed
+     */
+    public function getDispatcher()
+    {
+        return $this->dispatcher;
+    }
+
+    /**
+     * @return string
+     */
+    public function getHttpMethod()
+    {
+        return $this->httpMethod;
+    }
+
+    /**
+     * @return string
+     */
+    public function getUri()
+    {
+        return $this->uri;
+    }
+
+    /**
+     * @return int
+     */
+    public function getRouteStatus()
+    {
+        return $this->routeStatus;
+    }
+
+    /**
+     * @return callable|null
+     */
+    public function getRouteHandler()
+    {
+        return $this->routeHandler;
+    }
+
+    /**
+     * @param bool $urlDecode
+     * @return array
+     */
+    public function getRouteArguments($urlDecode = true)
+    {
+        if (!$urlDecode) {
+            return $this->routeArguments;
+        }
+
+        $routeArguments = [];
+        foreach ($this->routeArguments as $key => $value) {
+            $routeArguments[$key] = urldecode($value);
+        }
+
+        return $routeArguments;
+    }
+
+    /**
+     * @return array
+     */
+    public function getAllowedMethods()
+    {
+        return $this->dispatcher->getAllowedMethods($this->httpMethod, $this->uri);
+    }
+}

Slim/Exception/HttpMethodNotAllowedException.php

@@ -21,7 +21,7 @@ class HttpMethodNotAllowedException extends HttpSpecializedException
     protected $description = 'The request method is not supported for the requested resource.';
 
     /**
-     * @return string
+     * @return array
      */
     public function getAllowedMethods()
     {

Slim/Interfaces/RouterInterface.php

@@ -11,6 +11,7 @@
 use RuntimeException;
 use InvalidArgumentException;
 use Psr\Http\Message\ServerRequestInterface;
+use Slim\DispatcherResults;
 
 /**
  * Router Interface
@@ -40,7 +41,7 @@ public function map($methods, $pattern, $handler);
      *
      * @param  ServerRequestInterface $request The current HTTP request object
      *
-     * @return array
+     * @return DispatcherResults
      *
      * @link   https://github.com/nikic/FastRoute/blob/master/src/Dispatcher.php
      */