Moved array middleware piping logic to Application::routeMiddleware

Author: michaelmoussa

src/Application.php

@@ -343,7 +343,19 @@ public function routeMiddleware(ServerRequestInterface $request, ResponseInterfa
             return $middleware($request, $response, $next);
         }
 
-        if (! is_string($middleware)) {
+        if (is_array($middleware)) {
+            $middlewarePipe = new MiddlewarePipe();
+
+            foreach ($middleware as $middlewareItem) {
+                $middlewarePipe->pipe(
+                    is_callable($middlewareItem) ? $middlewareItem : $this->marshalMiddleware($middlewareItem)
+                );
+            }
+
+            return $middlewarePipe;
+        }
+
+        if (!is_string($middleware)) {
             throw new Exception\InvalidMiddlewareException(
                 'The middleware specified is not callable'
             );
@@ -377,7 +389,7 @@ public function routeMiddleware(ServerRequestInterface $request, ResponseInterfa
      * pipeline.
      *
      * @param string|Router\Route $path
-     * @param callable|string $middleware Middleware (or middleware service name) to associate with route.
+     * @param callable|string|array $middleware Middleware (or middleware service name) to associate with route.
      * @param null|array $methods HTTP method to accept; null indicates any.
      * @param null|string $name the name of the route
      * @return Router\Route
@@ -531,6 +543,36 @@ private function checkForDuplicateRoute($path, $methods = null)
         }
     }
 
+    /**
+     * Attempts to retrieve middleware from the container, or instantiate it directly.
+     *
+     * @param string $middleware
+     *
+     * @return array
+     * @throws Exception\InvalidMiddlewareException If unable to obtain callable middleware
+     */
+    private function marshalMiddleware($middleware)
+    {
+        $callable = $this->marshalMiddlewareFromContainer($middleware);
+
+        if (is_callable($callable)) {
+            return $callable;
+        }
+
+        $callable = $this->marshalInvokableMiddleware($middleware);
+
+        if (is_callable($callable)) {
+            return $callable;
+        } else {
+            throw new Exception\InvalidMiddlewareException(
+                sprintf(
+                    'Unable to resolve middleware "%s" to a callable',
+                    $middleware
+                )
+            );
+        }
+    }
+
     /**
      * Attempt to retrieve the given middleware from the container.
      *

src/Container/ApplicationFactory.php

@@ -179,16 +179,6 @@ private function injectRoutes(Application $app, ContainerInterface $container)
 
             $name = isset($spec['name']) ? $spec['name'] : null;
 
-            if (!is_callable($spec['middleware']) && is_array($spec['middleware'])) {
-                $middlewarePipe = new MiddlewarePipe();
-
-                foreach ($spec['middleware'] as $middleware) {
-                    $middlewarePipe->pipe(is_callable($middleware) ? $middleware : $container->get($middleware));
-                }
-
-                $spec['middleware'] = $middlewarePipe;
-            }
-
             $route = new Route($spec['path'], $spec['middleware'], $methods, $name);
 
             if (isset($spec['options'])) {

src/Router/Route.php

@@ -71,7 +71,7 @@ public function __construct($path, $middleware, $methods = self::HTTP_METHOD_ANY
             throw new Exception\InvalidArgumentException('Invalid path; must be a string');
         }
 
-        if (! is_callable($middleware) && ! is_string($middleware)) {
+        if (! is_callable($middleware) && ! is_string($middleware) && ! is_array($middleware)) {
             throw new Exception\InvalidArgumentException('Invalid middleware; must be callable or a service name');
         }
 
@@ -121,7 +121,7 @@ public function getName()
     }
 
     /**
-     * @return string|callable
+     * @return string|callable|array
      */
     public function getMiddleware()
     {

src/Router/RouteResult.php

@@ -127,7 +127,7 @@ public function getMatchedRouteName()
     /**
      * Retrieve the matched middleware, if possible.
      *
-     * @return false|callable|string Returns false if the result represents a
+     * @return false|callable|string|array Returns false if the result represents a
      *     failure; otherwise, a callable or a string service name.
      */
     public function getMatchedMiddleware()

test/ApplicationTest.php

@@ -12,13 +12,16 @@
 use PHPUnit_Framework_TestCase as TestCase;
 use Prophecy\Argument;
 use ReflectionProperty;
+use Zend\Diactoros\Response;
 use Zend\Diactoros\Response\SapiEmitter;
 use Zend\Diactoros\ServerRequest as Request;
+use Zend\Diactoros\ServerRequest;
 use Zend\Expressive\Application;
 use Zend\Expressive\Emitter\EmitterStack;
 use Zend\Expressive\Router\Route;
 use Zend\Expressive\Router\RouteResult;
 use Zend\Stratigility\Route as StratigilityRoute;
+use ZendTest\Expressive\TestAsset\InvokableMiddleware;
 
 /**
  * @covers Zend\Expressive\Application
@@ -228,6 +231,51 @@ public function testRouteMiddlewareIsPipedAtFirstCallToRoute()
         $this->assertSame($routeMiddleware, $test);
     }
 
+    public function testRouteMiddlewareCanRouteArrayOfMiddlewareAsMiddlewarePipe()
+    {
+        $middleware = [
+            function () {
+            },
+            'FooBar',
+            [InvokableMiddleware::class, 'staticallyCallableMiddleware'],
+            InvokableMiddleware::class,
+        ];
+
+        $request = new ServerRequest([], [], '/', 'GET');
+        $routeResult = RouteResult::fromRouteMatch(__METHOD__, $middleware, []);
+        $this->router->match($request)->willReturn($routeResult);
+
+        $container = $this->mockContainerInterface();
+        $this->injectServiceInContainer($container, 'FooBar', function () {
+        });
+
+        $app = new Application($this->router->reveal(), $container->reveal());
+        $app->routeMiddleware($request, new Response(), function () {
+        });
+    }
+
+    public function uncallableMiddleware()
+    {
+        return [
+            ['foo'],
+            [['foo']]
+        ];
+    }
+
+    /**
+     * @dataProvider uncallableMiddleware
+     * @expectedException \Zend\Expressive\Exception\InvalidMiddlewareException
+     */
+    public function testThrowsExceptionWhenRoutingUncallableMiddleware($middleware)
+    {
+        $request = new ServerRequest([], [], '/', 'GET');
+        $routeResult = RouteResult::fromRouteMatch(__METHOD__, $middleware, []);
+        $this->router->match($request)->willReturn($routeResult);
+
+        $this->getApp()->routeMiddleware($request, new Response(), function () {
+        });
+    }
+
     public function testCannotPipeRouteMiddlewareMoreThanOnce()
     {
         $app             = $this->getApp();

test/Container/ApplicationFactoryTest.php

@@ -621,46 +621,25 @@ public function testExceptionIsRaisedInCaseOfInvalidRouteMethodsConfiguration()
         $this->factory->__invoke($this->container->reveal());
     }
 
-    public function testCanPipeRouteSpecificMiddlewareViaConfiguration()
+    public function testExceptionIsRaisedInCaseOfInvalidRouteOptionsConfiguration()
     {
-        $expectedRouteOptions = [
-            'values' => [
-                'foo' => 'bar'
-            ],
-            'tokens' => [
-                'bar' => 'foo'
-            ]
-        ];
-
         $config = [
             'routes' => [
                 [
                     'path' => '/',
-                    'middleware' => [
-                        'Hello',
-                        function () {
-                            return 'World';
-                        }
-                    ],
-                    'name' => 'home',
-                    'allowed_methods' => ['GET'],
-                    'options' => $expectedRouteOptions
+                    'middleware' => 'HelloWorld',
+                    'options' => 'invalid',
                 ],
             ],
         ];
 
         $this->injectServiceInContainer($this->container, 'config', $config);
-        $this->injectServiceInContainer($this->container, 'Hello', function() {});
 
-        $app = $this->factory->__invoke($this->container->reveal());
-
-        $r = new ReflectionProperty($app, 'routes');
-        $r->setAccessible(true);
-        $routes = $r->getValue($app);
-        $route  = array_shift($routes);
-
-        $this->assertInstanceOf(Route::class, $route);
-        $this->assertEquals($expectedRouteOptions, $route->getOptions());
+        $this->setExpectedException(
+            InvalidArgumentException::class,
+            'options must be an array; received "string"'
+        );
+        $this->factory->__invoke($this->container->reveal());
     }
 
     public function testExceptionIsRaisedInCaseOfInvalidPreRoutingMiddlewarePipeline()