Removes concept of "default handler"

Because the `MiddlewarePipe` does not compose a "default handler", and
because the `MiddlewarePipe` is what the request handler runner
dispatches, there is no longer a concept of a "default delegate" (v2) or
"default handler" (v3); there is only middleware.

As such, this patch merges the `NotFoundHandler` into the `NotFoundMiddleware`.

A key is kept for the `DefaultDelegate` service, but it will now resolve
to the `NotFoundMiddleware`.

Fixes #441.

Author: weierophinney

src/ConfigProvider.php

@@ -34,7 +34,7 @@ public function getDependencies() : array
         // @codingStandardsIgnoreStart
         return [
             'aliases' => [
-                Handler\DefaultHandler::class        => Handler\NotFoundHandler::class,
+                Delegate\DefaultDelegate::class      => Middleware\NotFoundMiddleware::class,
                 Middleware\DispatchMiddleware::class => Router\DispatchMiddleware::class,
                 Middleware\RouteMiddleware::class    => Router\PathBasedRoutingMiddleware::class,
             ],
@@ -45,7 +45,6 @@ public function getDependencies() : array
                 ErrorHandler::class                        => Container\ErrorHandlerFactory::class,
                 // Change the following in development to the WhoopsErrorResponseGeneratorFactory:
                 ErrorResponseGenerator::class              => Container\ErrorResponseGeneratorFactory::class,
-                Handler\NotFoundHandler::class             => Handler\NotFoundHandlerFactory::class,
                 MiddlewareContainer::class                 => Container\MiddlewareContainerFactory::class,
                 MiddlewareFactory::class                   => Container\MiddlewareFactoryFactory::class,
                 Middleware\NotFoundMiddleware::class       => Container\NotFoundMiddlewareFactory::class,

src/Container/NotFoundHandlerFactory.php

@@ -10,13 +10,28 @@
 namespace Zend\Expressive\Container;
 
 use Psr\Container\ContainerInterface;
-use Zend\Expressive\Handler\NotFoundHandler;
+use Psr\Http\Message\ResponseInterface;
 use Zend\Expressive\Middleware\NotFoundMiddleware;
+use Zend\Expressive\Template\TemplateRendererInterface;
 
 class NotFoundMiddlewareFactory
 {
     public function __invoke(ContainerInterface $container) : NotFoundMiddleware
     {
-        return new NotFoundMiddleware($container->get(NotFoundHandler::class));
+        $config   = $container->has('config') ? $container->get('config') : [];
+        $renderer = $container->has(TemplateRendererInterface::class)
+            ? $container->get(TemplateRendererInterface::class)
+            : null;
+        $template = $config['zend-expressive']['error_handler']['template_404']
+            ?? NotFoundMiddleware::TEMPLATE_DEFAULT;
+        $layout = $config['zend-expressive']['error_handler']['layout']
+            ?? NotFoundMiddleware::LAYOUT_DEFAULT;
+
+        return new NotFoundMiddleware(
+            $container->get(ResponseInterface::class),
+            $renderer,
+            $template,
+            $layout
+        );
     }
 }

src/Container/NotFoundMiddlewareFactory.php

@@ -1,33 +1,59 @@
 <?php
 /**
  * @see       https://github.com/zendframework/zend-expressive for the canonical source repository
- * @copyright Copyright (c) 2016-2017 Zend Technologies USA Inc. (https://www.zend.com)
+ * @copyright Copyright (c) 2016-2018 Zend Technologies USA Inc. (https://www.zend.com)
  * @license   https://github.com/zendframework/zend-expressive/blob/master/LICENSE.md New BSD License
  */
 
 declare(strict_types=1);
 
 namespace Zend\Expressive\Middleware;
 
+use Fig\Http\Message\StatusCodeInterface;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Server\MiddlewareInterface;
 use Psr\Http\Server\RequestHandlerInterface;
-use Zend\Expressive\Handler\NotFoundHandler;
+use Zend\Expressive\Template\TemplateRendererInterface;
 
 class NotFoundMiddleware implements MiddlewareInterface
 {
+    const TEMPLATE_DEFAULT = 'error::404';
+    const LAYOUT_DEFAULT = 'layout::default';
+
     /**
-     * @var NotFoundHandler
+     * @var TemplateRendererInterface
      */
-    private $internalHandler;
+    private $renderer;
 
     /**
-     * @param NotFoundHandler $internalHandler
+     * This duplicates the property in StratigilityNotFoundHandler, but is done
+     * to ensure that we have access to the value in the methods we override.
+     *
+     * @var ResponseInterface
      */
-    public function __construct(NotFoundHandler $internalHandler)
-    {
-        $this->internalHandler = $internalHandler;
+    protected $responsePrototype;
+
+    /**
+     * @var string
+     */
+    private $template;
+
+    /**
+     * @var string
+     */
+    private $layout;
+
+    public function __construct(
+        ResponseInterface $responsePrototype,
+        TemplateRendererInterface $renderer = null,
+        string $template = self::TEMPLATE_DEFAULT,
+        string $layout = self::LAYOUT_DEFAULT
+    ) {
+        $this->responsePrototype = $responsePrototype;
+        $this->renderer = $renderer;
+        $this->template = $template;
+        $this->layout = $layout;
     }
 
     /**
@@ -38,6 +64,41 @@ public function __construct(NotFoundHandler $internalHandler)
      */
     public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
     {
-        return $this->internalHandler->handle($request);
+        if (! $this->renderer) {
+            return $this->generatePlainTextResponse($request);
+        }
+
+        return $this->generateTemplatedResponse($request);
+    }
+
+    /**
+     * Generates a plain text response indicating the request method and URI.
+     */
+    private function generatePlainTextResponse(ServerRequestInterface $request) : ResponseInterface
+    {
+        $response = $this->responsePrototype->withStatus(StatusCodeInterface::STATUS_NOT_FOUND);
+        $response->getBody()
+            ->write(sprintf(
+                'Cannot %s %s',
+                $request->getMethod(),
+                (string) $request->getUri()
+            ));
+
+        return $response;
+    }
+
+    /**
+     * Generates a response using a template.
+     *
+     * Template will receive the current request via the "request" variable.
+     */
+    private function generateTemplatedResponse(ServerRequestInterface $request) : ResponseInterface
+    {
+        $response = $this->responsePrototype->withStatus(StatusCodeInterface::STATUS_NOT_FOUND);
+        $response->getBody()->write(
+            $this->renderer->render($this->template, ['request' => $request, 'layout' => $this->layout])
+        );
+
+        return $response;
     }
 }

src/Handler/NotFoundHandler.php

@@ -14,7 +14,6 @@
 use Zend\Expressive\Application;
 use Zend\Expressive\ApplicationPipeline;
 use Zend\Expressive\ConfigProvider;
-use Zend\Expressive\Handler;
 use Zend\Expressive\Middleware;
 use Zend\Expressive\MiddlewareContainer;
 use Zend\Expressive\MiddlewareFactory;
@@ -38,7 +37,7 @@ public function testProviderDefinesExpectedAliases()
     {
         $config = $this->provider->getDependencies();
         $aliases = $config['aliases'];
-        $this->assertArrayHasKey(Handler\DefaultHandler::class, $aliases);
+        $this->assertArrayHasKey('Zend\Expressive\Delegate\DefaultDelegate', $aliases);
         $this->assertArrayHasKey(Middleware\DispatchMiddleware::class, $aliases);
         $this->assertArrayHasKey(Middleware\RouteMiddleware::class, $aliases);
     }
@@ -53,7 +52,6 @@ public function testProviderDefinesExpectedFactoryServices()
         $this->assertArrayHasKey(EmitterInterface::class, $factories);
         $this->assertArrayHasKey(ErrorHandler::class, $factories);
         $this->assertArrayHasKey(ErrorResponseGenerator::class, $factories);
-        $this->assertArrayHasKey(Handler\NotFoundHandler::class, $factories);
         $this->assertArrayHasKey(MiddlewareContainer::class, $factories);
         $this->assertArrayHasKey(MiddlewareFactory::class, $factories);
         $this->assertArrayHasKey(DispatchMiddleware::class, $factories);