4.x - Split RouterInterface into RouteCollectorInterface and RouteResolverInterface

Slim/App.php

@@ -9,6 +9,7 @@
 
 namespace Slim;
 
+use Closure;
 use Psr\Container\ContainerInterface;
 use Psr\Http\Message\ResponseFactoryInterface;
 use Psr\Http\Message\ResponseInterface;
@@ -17,9 +18,13 @@
 use Psr\Http\Server\MiddlewareInterface;
 use Psr\Http\Server\RequestHandlerInterface;
 use Slim\Interfaces\CallableResolverInterface;
+use Slim\Interfaces\RouteCollectorInterface;
 use Slim\Interfaces\RouteGroupInterface;
 use Slim\Interfaces\RouteInterface;
-use Slim\Interfaces\RouterInterface;
+use Slim\Interfaces\RouteResolverInterface;
+use Slim\Routing\RouteCollector;
+use Slim\Routing\RouteResolver;
+use Slim\Routing\RouteRunner;
 
 /**
  * App
@@ -55,9 +60,14 @@ class App implements RequestHandlerInterface
     protected $middlewareDispatcher;
 
     /**
-     * @var RouterInterface
+     * @var RouteCollectorInterface
      */
-    protected $router;
+    protected $routeCollector;
+
+    /**
+     * @var RouteResolverInterface
+     */
+    protected $routeResolver;
 
     /**
      * @var ResponseFactoryInterface
@@ -74,19 +84,28 @@ class App implements RequestHandlerInterface
      * @param ResponseFactoryInterface  $responseFactory
      * @param ContainerInterface|null   $container
      * @param CallableResolverInterface $callableResolver
-     * @param RouterInterface           $router
+     * @param RouteCollectorInterface   $routeCollector
+     * @param RouteResolverInterface    $routeResolver
      */
     public function __construct(
         ResponseFactoryInterface $responseFactory,
         ContainerInterface $container = null,
         CallableResolverInterface $callableResolver = null,
-        RouterInterface $router = null
+        RouteCollectorInterface $routeCollector = null,
+        RouteResolverInterface $routeResolver = null
     ) {
         $this->responseFactory = $responseFactory;
         $this->container = $container;
         $this->callableResolver = $callableResolver ?? new CallableResolver($container);
-        $this->router = $router ?? new Router($responseFactory, $this->callableResolver, $this->container);
-        $this->middlewareDispatcher = new MiddlewareDispatcher(new RouteDispatcher($this->router), $container);
+        $this->routeCollector = $routeCollector ?? new RouteCollector(
+            $responseFactory,
+            $this->callableResolver,
+            $container
+        );
+        $this->routeResolver = $routeResolver ?? new RouteResolver($this->routeCollector);
+
+        $routeRunner = new RouteRunner($this->routeResolver);
+        $this->middlewareDispatcher = new MiddlewareDispatcher($routeRunner, $container);
     }
 
     /**
@@ -134,13 +153,23 @@ public function getCallableResolver(): CallableResolverInterface
     }
 
     /**
-     * Get router
+     * Get route collector
+     *
+     * @return RouteCollectorInterface
+     */
+    public function getRouteCollector(): RouteCollectorInterface
+    {
+        return $this->routeCollector;
+    }
+
+    /**
+     * Get route resolver
      *
-     * @return RouterInterface
+     * @return RouteResolverInterface
      */
-    public function getRouter(): RouterInterface
+    public function getRouteResolver(): RouteResolverInterface
     {
-        return $this->router;
+        return $this->routeResolver;
     }
 
     /********************************************************************************
@@ -250,15 +279,11 @@ public function any(string $pattern, $callable): RouteInterface
     public function map(array $methods, string $pattern, $callable): RouteInterface
     {
         // Bind route callable to container, if present
-        if ($this->container instanceof ContainerInterface && $callable instanceof \Closure) {
+        if ($this->container instanceof ContainerInterface && $callable instanceof Closure) {
             $callable = $callable->bindTo($this->container);
         }
 
-        /** @var Router $router */
-        $router = $this->getRouter();
-        $route = $router->map($methods, $pattern, $callable);
-
-        return $route;
+        return $this->routeCollector->map($methods, $pattern, $callable);
     }
 
     /**
@@ -294,9 +319,9 @@ public function redirect(string $from, $to, int $status = 302): RouteInterface
      */
     public function group(string $pattern, $callable): RouteGroupInterface
     {
-        $group = $this->router->pushGroup($pattern, $callable);
+        $group = $this->routeCollector->pushGroup($pattern, $callable);
         $group($this);
-        $this->router->popGroup();
+        $this->routeCollector->popGroup();
         return $group;
     }
 

Slim/Interfaces/RouterInterface.php → Slim/Interfaces/RouteCollectorInterface.php

@@ -10,56 +10,64 @@
 namespace Slim\Interfaces;
 
 use InvalidArgumentException;
-use Psr\Http\Message\ServerRequestInterface;
 use RuntimeException;
-use Slim\RoutingResults;
 
-/**
- * Router Interface
- *
- * @package Slim
- * @since   3.0.0
- */
-interface RouterInterface
+interface RouteCollectorInterface
 {
     /**
-     * Add route
+     * Get default route invocation strategy
      *
-     * @param string[] $methods Array of HTTP methods
-     * @param string   $pattern The route pattern
-     * @param callable $handler The route callable
+     * @return InvocationStrategyInterface
+     */
+    public function getDefaultInvocationStrategy(): InvocationStrategyInterface;
+
+    /**
+     * Set default route invocation strategy
      *
-     * @return RouteInterface
+     * @param InvocationStrategyInterface $strategy
+     * @return RouteCollectorInterface
      */
-    public function map(array $methods, string $pattern, $handler): RouteInterface;
+    public function setDefaultInvocationStrategy(InvocationStrategyInterface $strategy): RouteCollectorInterface;
 
     /**
-     * Dispatch router for HTTP request
+     * Get path to FastRoute cache file
      *
-     * @param  ServerRequestInterface $request The current HTTP request object
+     * @return null|string
+     */
+    public function getCacheFile(): ?string;
+
+    /**
+     * Set path to FastRoute cache file
      *
-     * @return RoutingResults
+     * @param string $cacheFile
+     * @return RouteCollectorInterface
      *
-     * @link   https://github.com/nikic/FastRoute/blob/master/src/Dispatcher.php
+     * @throws InvalidArgumentException
+     * @throws RuntimeException
      */
-    public function dispatch(ServerRequestInterface $request): RoutingResults;
+    public function setCacheFile(string $cacheFile): RouteCollectorInterface;
 
     /**
-     * Add a route group to the array
+     * Get the base path used in pathFor()
      *
-     * @param string   $pattern The group pattern
-     * @param callable $callable A group callable
+     * @return string
+     */
+    public function getBasePath(): string;
+
+    /**
+     * Set the base path used in pathFor()
      *
-     * @return RouteGroupInterface
+     * @param string $basePath
+     * @return RouteCollectorInterface
      */
-    public function pushGroup(string $pattern, $callable): RouteGroupInterface;
+    public function setBasePath(string $basePath): RouteCollectorInterface;
 
     /**
-     * Removes the last route group from the array
+     * Get route objects
      *
-     * @return RouteGroupInterface|null
+     * @return RouteInterface[]
      */
-    public function popGroup();
+    public function getRoutes(): array;
 
     /**
      * Get named route object
@@ -72,13 +80,53 @@ public function popGroup();
      */
     public function getNamedRoute(string $name): RouteInterface;
 
+    /**
+     * Remove named route
+     *
+     * @param string $name        Route name
+     * @return RouteCollectorInterface
+     *
+     * @throws RuntimeException   If named route does not exist
+     */
+    public function removeNamedRoute(string $name): RouteCollectorInterface;
+
     /**
      * @param string $identifier
      *
      * @return RouteInterface
+     *
+     * @throws RuntimeException
      */
     public function lookupRoute(string $identifier): RouteInterface;
 
+    /**
+     * Add a route group to the array
+     *
+     * @param string   $pattern The group pattern
+     * @param callable $callable A group callable
+     *
+     * @return RouteGroupInterface
+     */
+    public function pushGroup(string $pattern, $callable): RouteGroupInterface;
+
+    /**
+     * Removes the last route group from the array
+     *
+     * @return RouteGroupInterface|null
+     */
+    public function popGroup();
+
+    /**
+     * Add route
+     *
+     * @param string[] $methods Array of HTTP methods
+     * @param string   $pattern The route pattern
+     * @param callable|string $handler The route callable
+     *
+     * @return RouteInterface
+     */
+    public function map(array $methods, string $pattern, $handler): RouteInterface;
+
     /**
      * Build the path for a named route excluding the base path
      *
@@ -108,16 +156,18 @@ public function relativePathFor(string $name, array $data = [], array $queryPara
     public function pathFor(string $name, array $data = [], array $queryParams = []): string;
 
     /**
-     * @param string|null $cacheFile
-     * @return RouterInterface
-     */
-    public function setCacheFile(?string $cacheFile): RouterInterface;
-
-    /**
-     * Set default route invocation strategy
+     * Build the path for a named route.
      *
-     * @param InvocationStrategyInterface $strategy
-     * @return RouterInterface
+     * This method is deprecated. Use pathFor() from now on.
+     *
+     * @param string $name        Route name
+     * @param array  $data        Named argument replacement data
+     * @param array  $queryParams Optional query string parameters
+     *
+     * @return string
+     *
+     * @throws RuntimeException         If named route does not exist
+     * @throws InvalidArgumentException If required data not provided
      */
-    public function setDefaultInvocationStrategy(InvocationStrategyInterface $strategy): RouterInterface;
+    public function urlFor(string $name, array $data = [], array $queryParams = []): string;
 }