PSR-15 Middleware Support

README.md

@@ -46,8 +46,9 @@ use Slim\Psr7\Factory\StreamFactory;
 $responseFactory = new DecoratedResponseFactory(new ResponseFactory(), new StreamFactory());
 $app = new App($responseFactory);
 
-// Add middlweare (LIFO stack)
-$app->add(new ErrorMiddleware($app->getCallableResolver(), $responseFactory, true, true, true));
+// Add middleware (LIFO stack)
+$errorMiddleware = new ErrorMiddleware($app->getCallableResolver(), $responseFactory, true, true, true);
+$app->add($errorMiddleware);
 
 // Action
 $app->get('/hello/{name}', function ($request, $response, $args) {
@@ -80,14 +81,17 @@ $serverRequestFactory = new ServerRequestCreator(
 );
 
 /**
- * The App::__constructor() method takes 1 mandatory parameter and 2 optional parameters
+ * The App::__constructor() method takes 1 mandatory parameter and 4 optional parameters
  * @param ResponseFactoryInterface Any implementation of a ResponseFactory
  * @param ContainerInterface|null Any implementation of a Container
  * @param array Settings array
+ * @param CallableResolverInterface|null Any implementation of a CallableResolver
+ * @param RouterInterface|null Any implementation of a Router
  */
 $app = new Slim\App($psr17Factory);
 $app->get('/hello/{name}', function ($request, $response, $args) {
-    return $response->getBody()->write("Hello, " . $args['name']);
+    $response->getBody()->write("Hello, " . $args['name']);
+    return $response;
 });
 
 /**
@@ -111,14 +115,17 @@ $responseFactory = new ResponseFactory();
 $serverRequestFactory = new ServerRequestFactory();
 
 /**
- * The App::__constructor() method takes 1 mandatory parameter and 2 optional parameters
+ * The App::__constructor() method takes 1 mandatory parameter and 4 optional parameters
  * @param ResponseFactoryInterface Any implementation of a ResponseFactory
  * @param ContainerInterface|null Any implementation of a Container
  * @param array Settings array
+ * @param CallableResolverInterface|null Any implementation of a CallableResolver
+ * @param RouterInterface|null Any implementation of a Router
  */
 $app = new Slim\App($responseFactory);
 $app->get('/hello/{name}', function ($request, $response, $args) {
-    return $response->getBody()->write("Hello, " . $args['name']);
+    $response->getBody()->write("Hello, " . $args['name']);
+    return $response;
 });
 
 /**
@@ -155,12 +162,14 @@ $decoratedResponseFactory = new DecoratedResponseFactory($responseFactory, $stre
 $serverRequestFactory = new ServerRequestFactory();
 
 /**
- * The App::__constructor() method takes 1 mandatory parameter and 2 optional parameters
+ * The App::__constructor() method takes 1 mandatory parameter and 4 optional parameters
  * Note that we pass in the decorated response factory which will give us access to the Slim\Http
  * decorated Response methods like withJson()
  * @param ResponseFactoryInterface Any implementation of a ResponseFactory
  * @param ContainerInterface|null Any implementation of a Container
  * @param array Settings array
+ * @param CallableResolverInterface|null Any implementation of a CallableResolver
+ * @param RouterInterface|null Any implementation of a Router
  */
 $app = new Slim\App($decoratedResponseFactory);
 $app->get('/hello/{name}', function ($request, $response, $args) {
@@ -189,14 +198,17 @@ use Http\Factory\Guzzle\ResponseFactory;
 $responseFactory = new ResponseFactory();
 
 /**
- * The App::__constructor() method takes 1 mandatory parameter and 2 optional parameters
+ * The App::__constructor() method takes 1 mandatory parameter and 4 optional parameters
  * @param ResponseFactoryInterface Any implementation of a ResponseFactory
  * @param ContainerInterface|null Any implementation of a Container
  * @param array Settings array
+ * @param CallableResolverInterface|null Any implementation of a CallableResolver
+ * @param RouterInterface|null Any implementation of a Router
  */
 $app = new Slim\App($responseFactory);
 $app->get('/hello/{name}', function ($request, $response, $args) {
-    return $response->getBody()->write("Hello, " . $args['name']);
+    $response->getBody()->write("Hello, " . $args['name']);
+    return $response;
 });
 
 /**
@@ -220,7 +232,7 @@ For more information on how to configure your web server, see the [Documentation
 To execute the test suite, you'll need to install all development dependencies.
 
 ```bash
-$ git clone https://github.com/slimphp/Slim-Http
+$ git clone https://github.com/slimphp/Slim
 $ composer install
 $ composer test
 ```

Slim/App.php

@@ -11,19 +11,22 @@
 
 namespace Slim;
 
+use Closure;
 use Psr\Container\ContainerInterface;
 use Psr\Http\Message\ResponseFactoryInterface;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\UriInterface;
+use Psr\Http\Server\MiddlewareInterface;
 use Psr\Http\Server\RequestHandlerInterface;
-use Slim\Exception\HttpMethodNotAllowedException;
-use Slim\Exception\HttpNotFoundException;
+use RuntimeException;
 use Slim\Interfaces\CallableResolverInterface;
 use Slim\Interfaces\RouteGroupInterface;
 use Slim\Interfaces\RouteInterface;
 use Slim\Interfaces\RouterInterface;
-use Slim\Middleware\RoutingMiddleware;
+use Slim\Middleware\ClosureMiddleware;
+use Slim\Middleware\DeferredResolutionMiddleware;
+use Slim\Middleware\DispatchMiddleware;
 
 /**
  * App
@@ -34,8 +37,6 @@
  */
 class App implements RequestHandlerInterface
 {
-    use MiddlewareAwareTrait;
-
     /**
      * Current version
      *
@@ -55,6 +56,11 @@ class App implements RequestHandlerInterface
      */
     protected $callableResolver;
 
+    /**
+     * @var MiddlewareRunner
+     */
+    protected $middlewareRunner;
+
     /**
      * @var RouterInterface
      */
@@ -70,7 +76,7 @@ class App implements RequestHandlerInterface
      */
     protected $settings = [
         'httpVersion' => '1.1',
-        'routerCacheFile' => false,
+        'routerCacheFile' => null,
     ];
 
     /********************************************************************************
@@ -80,54 +86,60 @@ class App implements RequestHandlerInterface
     /**
      * Create new application
      *
-     * @param ResponseFactoryInterface $responseFactory
-     * @param ContainerInterface|null $container
-     * @param array $settings
+     * @param ResponseFactoryInterface  $responseFactory
+     * @param ContainerInterface|null   $container
+     * @param array                     $settings
+     * @param CallableResolverInterface $callableResolver
+     * @param RouterInterface           $router
      */
     public function __construct(
         ResponseFactoryInterface $responseFactory,
         ContainerInterface $container = null,
-        array $settings = []
+        array $settings = [],
+        CallableResolverInterface $callableResolver = null,
+        RouterInterface $router = null
     ) {
         $this->responseFactory = $responseFactory;
         $this->container = $container;
+        $this->callableResolver = $callableResolver ?? new CallableResolver($container);
         $this->addSettings($settings);
-    }
 
-    /**
-     * Get container
-     *
-     * @return ContainerInterface|null
-     */
-    public function getContainer()
-    {
-        return $this->container;
+        $this->router = $router ?? new Router($responseFactory, $this->callableResolver);
+        $routerCacheFile = $this->getSetting('routerCacheFile', null);
+        $this->router->setCacheFile($routerCacheFile);
+
+        $this->middlewareRunner = new MiddlewareRunner();
+        $this->addMiddleware(new DispatchMiddleware($this->router));
     }
 
     /**
-     * Set container
-     *
-     * @param ContainerInterface $container
+     * @param MiddlewareInterface|string|callable $middleware
+     * @return self
      */
-    public function setContainer(ContainerInterface $container)
+    public function add($middleware): self
     {
-        $this->container = $container;
+        if (is_string($middleware)) {
+            $middleware = new DeferredResolutionMiddleware($middleware, $this->container);
+        } elseif ($middleware instanceof Closure) {
+            $middleware = new ClosureMiddleware($middleware);
+        } elseif (!($middleware instanceof MiddlewareInterface)) {
+            throw new RuntimeException(
+                'Parameter 1 of `Slim\App::add()` must be a closure or an object/class name '.
+                'referencing an implementation of MiddlewareInterface.'
+            );
+        }
+
+        return $this->addMiddleware($middleware);
     }
 
     /**
-     * Add middleware
-     *
-     * This method prepends new middleware to the app's middleware stack.
-     *
-     * @param  callable|string    $callable The callback routine
-     *
-     * @return static
+     * @param MiddlewareInterface $middleware
+     * @return self
      */
-    public function add($callable)
+    public function addMiddleware(MiddlewareInterface $middleware): self
     {
-        return $this->addMiddleware(
-            new DeferredCallable($callable, $this->getCallableResolver())
-        );
+        $this->middlewareRunner->add($middleware);
+        return $this;
     }
 
     /********************************************************************************
@@ -189,17 +201,17 @@ public function addSetting(string $key, $value)
     }
 
     /********************************************************************************
-     * Setter and getter methods
+     * Getter methods
      *******************************************************************************/
 
     /**
-     * Set callable resolver
+     * Get container
      *
-     * @param CallableResolverInterface $resolver
+     * @return ContainerInterface|null
      */
-    public function setCallableResolver(CallableResolverInterface $resolver)
+    public function getContainer(): ?ContainerInterface
     {
-        $this->callableResolver = $resolver;
+        return $this->container;
     }
 
     /**
@@ -209,42 +221,16 @@ public function setCallableResolver(CallableResolverInterface $resolver)
      */
     public function getCallableResolver(): CallableResolverInterface
     {
-        if (! $this->callableResolver instanceof CallableResolverInterface) {
-            $this->callableResolver = new CallableResolver($this->container);
-        }
-
         return $this->callableResolver;
     }
 
-    /**
-     * Set router
-     *
-     * @param RouterInterface $router
-     */
-    public function setRouter(RouterInterface $router)
-    {
-        $this->router = $router;
-    }
-
     /**
      * Get router
      *
      * @return RouterInterface
      */
     public function getRouter(): RouterInterface
     {
-        if (! $this->router instanceof RouterInterface) {
-            $router = new Router();
-            $resolver = $this->getCallableResolver();
-            if ($resolver instanceof CallableResolverInterface) {
-                $router->setCallableResolver($resolver);
-            }
-            $routerCacheFile = $this->getSetting('routerCacheFile', false);
-            $router->setCacheFile($routerCacheFile);
-
-            $this->router = $router;
-        }
-
         return $this->router;
     }
 
@@ -377,7 +363,7 @@ public function map(array $methods, string $pattern, $callable): RouteInterface
      */
     public function redirect(string $from, $to, int $status = 302): RouteInterface
     {
-        $handler = function ($request, ResponseInterface $response) use ($to, $status) {
+        $handler = function (ServerRequestInterface $request, ResponseInterface $response) use ($to, $status) {
             return $response->withHeader('Location', (string)$to)->withStatus($status);
         };
 
@@ -398,17 +384,9 @@ public function redirect(string $from, $to, int $status = 302): RouteInterface
      */
     public function group(string $pattern, $callable): RouteGroupInterface
     {
-        $router = $this->getRouter();
-
-        /** @var RouteGroup $group */
-        $group = $router->pushGroup($pattern, $callable);
-        if ($this->callableResolver instanceof CallableResolverInterface) {
-            $group->setCallableResolver($this->callableResolver);
-        }
-
+        $group = $this->router->pushGroup($pattern, $callable);
         $group($this);
-        $router->popGroup();
-
+        $this->router->popGroup();
         return $group;
     }
 
@@ -442,13 +420,7 @@ public function run(ServerRequestInterface $request): void
      */
     public function handle(ServerRequestInterface $request): ResponseInterface
     {
-        $httpVersion = $this->getSetting('httpVersion');
-        $response = $this->responseFactory
-            ->createResponse(200, '')
-            ->withProtocolVersion($httpVersion)
-            ->withHeader('Content-Type', 'text/html; charset=UTF-8');
-
-        $response = $this->callMiddlewareStack($request, $response);
+        $response = $this->middlewareRunner->run($request);
 
         /**
          * This is to be in compliance with RFC 2616, Section 9.
@@ -465,36 +437,4 @@ public function handle(ServerRequestInterface $request): ResponseInterface
 
         return $response;
     }
-
-    /**
-     * Invoke application
-     *
-     * This method implements the middleware interface. It receives
-     * Request and Response objects, and it returns a Response object
-     * after compiling the routes registered in the Router and dispatching
-     * the Request object to the appropriate Route callback routine.
-     *
-     * @param  ServerRequestInterface $request  The most recent Request object
-     * @param  ResponseInterface      $response The most recent Response object
-     *
-     * @return ResponseInterface
-     *
-     * @throws HttpNotFoundException
-     * @throws HttpMethodNotAllowedException
-     */
-    public function __invoke(ServerRequestInterface $request, ResponseInterface $response): ResponseInterface
-    {
-        /** @var RoutingResults|null $routingResults */
-        $routingResults = $request->getAttribute('routingResults');
-
-        // If routing hasn't been done, then do it now so we can dispatch
-        if ($routingResults === null) {
-            $router = $this->getRouter();
-            $routingMiddleware = new RoutingMiddleware($router);
-            $request = $routingMiddleware->performRouting($request);
-        }
-
-        $route = $request->getAttribute('route');
-        return $route->run($request, $response);
-    }
 }