Replaced AbstractProvider with ProviderInterface + Updated tests

README.md

@@ -28,7 +28,7 @@ new ErrorHandler(
 ```
 
 1. The first argument to the constructor must be an instance of `Psr\Http\Message\ResponseFactoryInterface`;
-1. The second argument to the constructor must be the name of the handler provider class (which extends `\BitFrame\Whoops\Provider\AbstractProvider`)
+1. The second argument to the constructor must be an implementation of `\BitFrame\Whoops\Provider\ProviderInterface`;
 1. The third argument to the constructor is an optional array of options to specify the following:
     1. `catchGlobalErrors`: When set to `true` errors will be handled outside of current batch of middleware set.
     1. Other options are simply method names in `Whoops\Handler\*Handler.php` and `BitFrame\Whoops\Handler\*Handler.php`. For example, to set `Whoops\Handler\JsonResponseHandler::setJsonApi()` you would pass in: `['setJsonApi' => false]`, etc.

src/ErrorHandler.php

@@ -13,7 +13,7 @@
 use Psr\Http\Message\{ResponseFactoryInterface, ServerRequestInterface, ResponseInterface};
 use Psr\Http\Server\{RequestHandlerInterface, MiddlewareInterface};
 use Whoops\{Run, RunInterface};
-use BitFrame\Whoops\Provider\{AbstractProvider, HandlerProviderNegotiator};
+use BitFrame\Whoops\Provider\{HandlerProviderNegotiator, ProviderInterface};
 use Throwable;
 use InvalidArgumentException;
 
@@ -34,7 +34,8 @@ class ErrorHandler implements MiddlewareInterface
 
     private ResponseFactoryInterface $responseFactory;
 
-    private string $handlerProvider;
+    /** @var ProviderInterface|string */
+    private $handlerProvider;
 
     private array $options;
 
@@ -51,17 +52,22 @@ public static function fromNegotiator(
         );
     }
 
+    /**
+     * @param ResponseFactoryInterface $responseFactory
+     * @param string|ProviderInterface $handlerProvider
+     * @param array $options
+     */
     public function __construct(
         ResponseFactoryInterface $responseFactory,
-        string $handlerProvider = HandlerProviderNegotiator::class,
+        $handlerProvider = HandlerProviderNegotiator::class,
         array $options = []
     ) {
         $this->responseFactory = $responseFactory;
         $this->handlerProvider = $handlerProvider;
 
-        if (! is_a($this->handlerProvider, AbstractProvider::class, true)) {
+        if (! is_a($this->handlerProvider, ProviderInterface::class, true)) {
             throw new InvalidArgumentException(
-                'Handler provider must be instance of ' . AbstractProvider::class
+                'Handler provider must be instance of ' . ProviderInterface::class
             );
         }
 
@@ -79,8 +85,10 @@ public function process(
         ServerRequestInterface $request,
         RequestHandlerInterface $handler
     ): ResponseInterface {
-        $handlerProvider = new $this->handlerProvider($request);
-        $errorHandler = $handlerProvider->getHandler();
+        $handlerProvider = ($this->handlerProvider instanceof ProviderInterface)
+            ? $this->handlerProvider
+            : new $this->handlerProvider();
+        $errorHandler = $handlerProvider->getHandler($request);
 
         $this->applyOptions($errorHandler);
         $this->whoops->pushHandler($errorHandler);
@@ -98,7 +106,7 @@ public function process(
             $response = $handler->handle($request);
         } catch (Throwable $e) {
             $response = $this->handleException($e)
-                ->withHeader('Content-Type', $handlerProvider->getPreferredContentType());
+                ->withHeader('Content-Type', $handlerProvider->getPreferredContentType($request));
         }
 
         if (! $this->catchGlobalErrors) {

src/Provider/HandlerProviderNegotiator.php

@@ -23,7 +23,7 @@
  * Detect any of the supported preferred formats from an
  * HTTP request.
  */
-class HandlerProviderNegotiator extends AbstractProvider
+class HandlerProviderNegotiator implements ProviderInterface
 {
     /** @var string */
     public const HTML = 'html';
@@ -48,36 +48,35 @@ class HandlerProviderNegotiator extends AbstractProvider
         self::XML => XmlHandlerProvider::class,
     ];
 
-    private ?AbstractProvider $activeProvider = null;
+    private ?ProviderInterface $activeProvider = null;
 
     public function add(string $type, string $provider): void
     {
-        if (! is_a($provider, AbstractProvider::class, true)) {
+        if (! is_a($provider, ProviderInterface::class, true)) {
             throw new InvalidArgumentException(
-                'Handler provider must be instance of ' . AbstractProvider::class
+                'Handler provider must be instance of ' . ProviderInterface::class
             );
         }
 
         $this->handlerProviders[$type] = $provider;
     }
 
-    public function getHandler(): HandlerInterface
+    public function getHandler(ServerRequestInterface $request): HandlerInterface
     {
-        return $this->getPreferredProvider()->getHandler();
+        return $this->getPreferredProvider($request)->getHandler($request);
     }
 
-    public function getPreferredContentType(): string
+    public function getPreferredContentType(ServerRequestInterface $request): string
     {
-        return $this->getPreferredProvider()->getPreferredContentType();
+        return $this->getPreferredProvider($request)->getPreferredContentType($request);
     }
 
-    public function getPreferredProvider(): AbstractProvider
+    public function getPreferredProvider(ServerRequestInterface $request): ProviderInterface
     {
-        if ($this->activeProvider instanceof AbstractProvider) {
+        if ($this->activeProvider instanceof ProviderInterface) {
             return $this->activeProvider;
         }
 
-        $request = $this->getRequest();
         $acceptTypes = $request->getHeader('accept');
         $default = $this->handlerProviders[self::HTML];
 

src/Provider/HtmlHandlerProvider.php

@@ -10,19 +10,19 @@
 
 namespace BitFrame\Whoops\Provider;
 
+use Psr\Http\Message\ServerRequestInterface;
 use Whoops\Handler\{HandlerInterface, PrettyPageHandler};
 
-class HtmlHandlerProvider extends AbstractProvider
+class HtmlHandlerProvider implements ProviderInterface
 {
     /** @var string */
     public const DATA_TABLE_NAME = 'Request Data';
 
     /** @var string[] */
     public const MIMES = ['text/html', 'application/xhtml+xml'];
 
-    public function getHandler(): HandlerInterface
+    public function getHandler(ServerRequestInterface $request): HandlerInterface
     {
-        $request = $this->getRequest();
         $handler = new PrettyPageHandler();
 
         $handler->addDataTable(self::DATA_TABLE_NAME, [
@@ -39,7 +39,7 @@ public function getHandler(): HandlerInterface
         return $handler;
     }
 
-    public function getPreferredContentType(): string
+    public function getPreferredContentType(ServerRequestInterface $request): string
     {
         return self::MIMES[0];
     }

src/Provider/JsonHandlerProvider.php

@@ -10,19 +10,20 @@
 
 namespace BitFrame\Whoops\Provider;
 
+use Psr\Http\Message\ServerRequestInterface;
 use Whoops\Handler\{HandlerInterface, JsonResponseHandler};
 
-class JsonHandlerProvider extends AbstractProvider
+class JsonHandlerProvider implements ProviderInterface
 {
     /** @var string[] */
     public const MIMES = ['application/json', 'text/json', 'application/x-json'];
 
-    public function getHandler(): HandlerInterface
+    public function getHandler(ServerRequestInterface $request): HandlerInterface
     {
         return new JsonResponseHandler();
     }
 
-    public function getPreferredContentType(): string
+    public function getPreferredContentType(ServerRequestInterface $request): string
     {
         return self::MIMES[0];
     }

src/Provider/JsonpHandlerProvider.php

@@ -10,18 +10,18 @@
 
 namespace BitFrame\Whoops\Provider;
 
+use Psr\Http\Message\ServerRequestInterface;
 use Whoops\Handler\HandlerInterface;
 use BitFrame\Whoops\Handler\JsonpResponseHandler;
 use RuntimeException;
 
-class JsonpHandlerProvider extends AbstractProvider
+class JsonpHandlerProvider implements ProviderInterface
 {
     /** @var string[] */
     public const MIMES = ['application/javascript'];
 
-    public function getHandler(): HandlerInterface
+    public function getHandler(ServerRequestInterface $request): HandlerInterface
     {
-        $request = $this->getRequest();
         $queryParams = $request->getQueryParams();
         $method = $request->getMethod();
 
@@ -34,7 +34,7 @@ public function getHandler(): HandlerInterface
         return new JsonpResponseHandler($queryParams['callback']);
     }
 
-    public function getPreferredContentType(): string
+    public function getPreferredContentType(ServerRequestInterface $request): string
     {
         return self::MIMES[0];
     }

src/Provider/ProviderInterface.php

@@ -0,0 +1,25 @@
+<?php
+
+/**
+ * BitFrame Framework (https://www.bitframephp.com)
+ *
+ * @author    Daniyal Hamid
+ * @copyright Copyright (c) 2017-2020 Daniyal Hamid (https://designcise.com)
+ * @license   https://bitframephp.com/about/license MIT License
+ */
+
+namespace BitFrame\Whoops\Provider;
+
+use Psr\Http\Message\ServerRequestInterface;
+use Whoops\Handler\HandlerInterface;
+
+interface ProviderInterface
+{
+    public function getHandler(
+        ServerRequestInterface $request
+    ): HandlerInterface;
+
+    public function getPreferredContentType(
+        ServerRequestInterface $request
+    ): string;
+}

src/Provider/TextHandlerProvider.php

@@ -10,19 +10,20 @@
 
 namespace BitFrame\Whoops\Provider;
 
+use Psr\Http\Message\ServerRequestInterface;
 use Whoops\Handler\{HandlerInterface, PlainTextHandler};
 
-class TextHandlerProvider extends AbstractProvider
+class TextHandlerProvider implements ProviderInterface
 {
     /** @var string[] */
     public const MIMES = ['text/plain'];
 
-    public function getHandler(): HandlerInterface
+    public function getHandler(ServerRequestInterface $request): HandlerInterface
     {
         return new PlainTextHandler();
     }
 
-    public function getPreferredContentType(): string
+    public function getPreferredContentType(ServerRequestInterface $request): string
     {
         return self::MIMES[0];
     }

src/Provider/XmlHandlerProvider.php

@@ -10,19 +10,20 @@
 
 namespace BitFrame\Whoops\Provider;
 
+use Psr\Http\Message\ServerRequestInterface;
 use Whoops\Handler\{HandlerInterface, XmlResponseHandler};
 
-class XmlHandlerProvider extends AbstractProvider
+class XmlHandlerProvider implements ProviderInterface
 {
     /** @var string[] */
     public const MIMES = ['text/xml', 'application/xml', 'application/x-xml'];
 
-    public function getHandler(): HandlerInterface
+    public function getHandler(ServerRequestInterface $request): HandlerInterface
     {
         return new XmlResponseHandler();
     }
 
-    public function getPreferredContentType(): string
+    public function getPreferredContentType(ServerRequestInterface $request): string
     {
         return self::MIMES[0];
     }

test/ErrorHandlerTest.php

@@ -130,7 +130,7 @@ function ($args) use ($response, $phpunit, $expectedError) {
             );
 
         $middlewares = [
-            new ErrorHandler($responseFactory->reveal(), HandlerProviderNegotiator::class, [
+            new ErrorHandler($responseFactory->reveal(), new HandlerProviderNegotiator(), [
                 'setJsonApi' => false,
             ]),
             $middleware,