Implement an ErrorMiddlewarePipe

This patch implements an `ErrorMiddlewarePipe`. Unfortunately,
`MiddlewarePipe` implements `MiddlewareInterface`, which makes it impossible
to extend it and re-purpose it as error middleware. As such, this
implementation wraps the `MiddlewarePipe` instance, and consumes its
internal pipeline in order to dispatch a pipeline of error middleware.

Author: weierophinney

src/ErrorMiddlewarePipe.php

@@ -0,0 +1,87 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @see       https://github.com/zendframework/zend-expressive for the canonical source repository
+ * @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   https://github.com/zendframework/zend-expressive/blob/master/LICENSE.md New BSD License
+ */
+
+namespace Zend\Expressive;
+
+use Psr\Http\Message\ServerRequestInterface as Request;
+use Psr\Http\Message\ResponseInterface as Response;
+use Zend\Stratigility\FinalHandler;
+use Zend\Stratigility\MiddlewarePipe;
+use Zend\Stratigility\Next;
+
+/**
+ * MiddlewarePipe implementation that acts as error middleware.
+ *
+ * Normal MiddlewarePipe implementations implement Zend\Stratigility\MiddlewareInterface,
+ * which can be consumed as normal middleware, but not as error middleware, as
+ * the signature for error middleware differs.
+ *
+ * This class wraps a MiddlewarePipe, and consumes its internal pipeline
+ * within a functor signature that works for error middleware.
+ *
+ * It is not implemented as an extension of MiddlewarePipe, as that class
+ * implements the MiddlewareInterface, which prevents its use as error
+ * middleware.
+ */
+class ErrorMiddlewarePipe
+{
+    /**
+     * @var MiddlewarePipe
+     */
+    private $pipeline;
+
+    /**
+     * @param MiddlewarePipe $pipe
+     */
+    public function __construct(MiddlewarePipe $pipeline)
+    {
+        $this->pipeline = $pipeline;
+    }
+
+    /**
+     * Handle an error request.
+     *
+     * This is essentially a version of the MiddlewarePipe that acts as a pipeline
+     * for solely error middleware; it's primary use case is to allow configuring
+     * arrays of error middleware as a single pipeline.
+     *
+     * Operation is identical to MiddlewarePipe, with the single exception that
+     * $next is called with the $error argument.
+     *
+     * @param mixed $error
+     * @param Request $request
+     * @param Response $response
+     * @param callable $out
+     * @return Response
+     */
+    public function __invoke($error, Request $request, Response $response, callable $out = null)
+    {
+        $pipeline = $this->getInternalPipeline();
+        $done = $out ?: new FinalHandler([], $response);
+        $next = new Next($pipeline, $done);
+        $result = $next($request, $response, $error);
+
+        return ($result instanceof Response ? $result : $response);
+    }
+
+    /**
+     * Retrieve the internal pipeline from the composed MiddlewarePipe.
+     *
+     * Uses reflection to retrieve the internal pipeline from the composed
+     * MiddlewarePipe, in order to allow using it to create a Next instance.
+     *
+     * @return \SplQueue
+     */
+    private function getInternalPipeline()
+    {
+        $r = new ReflectionProperty($this->pipeline, 'pipeline');
+        $r->setAccessible();
+        return $r->getValue($this->pipeline);
+    }
+}

src/MarshalMiddlewareTrait.php

@@ -87,7 +87,7 @@ private function prepareMiddleware($middleware, ContainerInterface $container =
      * @param null|ContainerInterface $container
      * @param bool $forError Whether or not the middleware pipe generated is
      *     intended to be populated with error middleware; defaults to false.
-     * @return MiddlewarePipe
+     * @return MiddlewarePipe When $forError is true, returns an ErrorMiddlewarePipe.
      * @throws Exception\InvalidMiddlewareException for any invalid middleware items.
      */
     private function marshalMiddlewarePipe(array $middlewares, ContainerInterface $container = null, $forError = false)
@@ -100,6 +100,10 @@ private function marshalMiddlewarePipe(array $middlewares, ContainerInterface $c
             );
         }
 
+        if ($forError) {
+            return new ErrorMiddlewarePipe($middlewarePipe);
+        }
+
         return $middlewarePipe;
     }
 

test/Container/ApplicationFactoryTest.php

@@ -23,6 +23,7 @@
 use Zend\Expressive\Container\ApplicationFactory;
 use Zend\Expressive\Container\Exception as ContainerException;
 use Zend\Expressive\Emitter\EmitterStack;
+use Zend\Expressive\ErrorMiddlewarePipe;
 use Zend\Expressive\Exception\InvalidMiddlewareException;
 use Zend\Expressive\Router\FastRouteRouter;
 use Zend\Expressive\Router\Route;
@@ -1280,14 +1281,16 @@ public function testProperlyRegistersNestedErrorMiddlewareAsLazyErrorMiddleware(
 
         $nestedPipeline = $pipeline->dequeue()->handler;
 
-        $this->assertInstanceOf(MiddlewarePipe::class, $nestedPipeline);
-        $r = new ReflectionMethod($nestedPipeline, '__invoke');
-        $this->assertEquals(4, $r->getNumberOfParameters(), 'Error pipeline is not error middleware');
+        $this->assertInstanceOf(ErrorMiddlewarePipe::class, $nestedPipeline);
 
         $r = new ReflectionProperty($nestedPipeline, 'pipeline');
         $r->setAccessible(true);
-        $pipeline = $r->getValue($nestedPipeline);
-        $middleware = $pipeline->dequeue()->handler;
+        $internalPipeline = $r->getValue($nestedPipeline);
+        $this->assertInstanceOf(MiddlewarePipe::class, $internalPipeline);
+
+        $r = new ReflectionProperty($internalPipeline, 'pipeline');
+        $r->setAccessible(true);
+        $middleware = $r->getValue($internalPipeline)->dequeue()->handler;
 
         $this->assertInstanceOf(Closure::class, $middleware);
         $r = new ReflectionFunction($middleware);