Added support for route-specific middleware pipe via configuration

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

@@ -17,6 +17,7 @@
 use Zend\Expressive\Router\FastRouteRouter;
 use Zend\Expressive\Router\Route;
 use Zend\Expressive\Router\RouterInterface;
+use Zend\Stratigility\MiddlewarePipe;
 
 /**
  * Factory to use with an IoC container in order to return an Application instance.
@@ -175,8 +176,10 @@ private function injectRoutes(Application $app, ContainerInterface $container)
             } else {
                 $methods = Route::HTTP_METHOD_ANY;
             }
-            $name    = isset($spec['name']) ? $spec['name'] : null;
-            $route   = new Route($spec['path'], $spec['middleware'], $methods, $name);
+
+            $name = isset($spec['name']) ? $spec['name'] : null;
+
+            $route = new Route($spec['path'], $spec['middleware'], $methods, $name);
 
             if (isset($spec['options'])) {
                 $options = $spec['options'];
@@ -209,12 +212,17 @@ private function injectMiddleware(array $collection, Application $app, Container
                 continue;
             }
 
-            $path       = isset($spec['path']) ? $spec['path'] : '/';
-            $middleware = $spec['middleware'];
-            $error      = array_key_exists('error', $spec) ? (bool) $spec['error'] : false;
-            $pipe       = $error ? 'pipeErrorHandler' : 'pipe';
+            $path  = isset($spec['path']) ? $spec['path'] : '/';
+            $error = array_key_exists('error', $spec) ? (bool) $spec['error'] : false;
+            $pipe  = $error ? 'pipeErrorHandler' : 'pipe';
 
-            $app->{$pipe}($path, $middleware);
+            if (is_array($spec['middleware'])) {
+                foreach ($spec['middleware'] as $middleware) {
+                    $app->{$pipe}($path, $middleware);
+                }
+            } else {
+                $app->{$pipe}($path, $spec['middleware']);
+            }
         }
     }
 

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

@@ -16,10 +16,12 @@
 use Zend\Diactoros\Response\EmitterInterface;
 use Zend\Expressive\Application;
 use Zend\Expressive\Container\ApplicationFactory;
+use Zend\Expressive\FinalHandler;
 use Zend\Expressive\Router\Route;
 use Zend\Expressive\Router\RouterInterface;
 use ZendTest\Expressive\ContainerTrait;
 use Zend\Expressive\Container\Exception\InvalidArgumentException;
+use ZendTest\Expressive\TestAsset\InvokableMiddleware;
 
 /**
  * @covers Zend\Expressive\Container\ApplicationFactory
@@ -104,13 +106,28 @@ public function testFactoryWillPullAllReplaceableDependenciesFromContainerWhenPr
         $this->assertSame($this->finalHandler, $app->getFinalHandler());
     }
 
-    public function testFactorySetsUpRoutesFromConfig()
+    public function callableMiddlewares()
+    {
+        return [
+           ['HelloWorld'],
+           [
+                function () {
+                }
+           ],
+           [[InvokableMiddleware::class, 'staticallyCallableMiddleware']],
+        ];
+    }
+
+    /**
+     * @dataProvider callableMiddlewares
+     */
+    public function testFactorySetsUpRoutesFromConfig($middleware)
     {
         $config = [
             'routes' => [
                 [
                     'path' => '/',
-                    'middleware' => 'HelloWorld',
+                    'middleware' => $middleware,
                     'allowed_methods' => [ 'GET' ],
                 ],
                 [
@@ -339,6 +356,58 @@ public function testRaisesExceptionForNonCallableNonServiceMiddleware($middlewar
         $app = $this->factory->__invoke($this->container->reveal());
     }
 
+    /**
+     * @group piping
+     */
+    public function testCanPipePreRoutingMiddlewareAsArray()
+    {
+        $config = [
+            'middleware_pipeline' => [
+                'pre_routing' => [
+                    [
+                        'middleware' => [
+                            'Hello',
+                            function () {
+                            },
+                        ],
+                    ],
+                ],
+            ],
+        ];
+
+        $this->injectServiceInContainer($this->container, 'config', $config);
+        $this->injectServiceInContainer($this->container, 'Hello', function () {
+        });
+
+        $this->factory->__invoke($this->container->reveal());
+    }
+
+    /**
+     * @group piping
+     */
+    public function testCanPipePostRoutingMiddlewareAsArray()
+    {
+        $config = [
+            'middleware_pipeline' => [
+                'post_routing' => [
+                    [
+                        'middleware' => [
+                            'Hello',
+                            function () {
+                            },
+                        ],
+                    ],
+                ],
+            ],
+        ];
+
+        $this->injectServiceInContainer($this->container, 'config', $config);
+        $this->injectServiceInContainer($this->container, 'Hello', function () {
+        });
+
+        $this->factory->__invoke($this->container->reveal());
+    }
+
     /**
      * @group piping
      */

test/TestAsset/InvokableMiddleware.php

@@ -12,6 +12,11 @@
 class InvokableMiddleware
 {
     public function __invoke($request, $response, $next)
+    {
+        return self::staticallyCallableMiddleware($request, $response, $next);
+    }
+
+    public static function staticallyCallableMiddleware($request, $response, $next)
     {
         return $response->withHeader('X-Invoked', __CLASS__);
     }