refactor error-handler

CHANGELOG.md

@@ -1,5 +1,13 @@
 # Yii Error Handler Change Log
 
+## 5.0 under development
+
+- Chg #121: Make logger in ErrorHandler optional (@olegbaturin)
+- Chg #144: Mark ErrorException and UserException as final (@olegbaturin)
+- Chg #146: Remove deprecated `Yiisoft\ErrorHandler\Factory\ThrowableResponseFactory` (@olegbaturin)
+- Chg #157: Rename `Yiisoft\ErrorHandler\ThrowableResponseFactory` to `Yiisoft\ErrorHandler\ThrowableResponseAction` (@olegbaturin)
+- Chg #157: Change parameters order in `ThrowableResponseActionInterface` (@olegbaturin)
+
 ## 4.3.1 under development
 
 - no changes in this release.

config/di-web.php

@@ -2,16 +2,36 @@
 
 declare(strict_types=1);
 
-use Yiisoft\ErrorHandler\Factory\ThrowableResponseFactory;
+use Psr\Container\ContainerInterface;
+use Yiisoft\Definitions\DynamicReference;
+use Yiisoft\Definitions\Reference;
+use Yiisoft\ErrorHandler\Middleware\ErrorCatcher;
 use Yiisoft\ErrorHandler\Renderer\HtmlRenderer;
+use Yiisoft\ErrorHandler\RendererProvider\CompositeRendererProvider;
+use Yiisoft\ErrorHandler\RendererProvider\ContentTypeRendererProvider;
+use Yiisoft\ErrorHandler\RendererProvider\HeadRendererProvider;
 use Yiisoft\ErrorHandler\ThrowableRendererInterface;
-use Yiisoft\ErrorHandler\ThrowableResponseFactoryInterface;
+use Yiisoft\ErrorHandler\ThrowableResponseAction;
 
 /**
  * @var array $params
  */
 
 return [
     ThrowableRendererInterface::class => HtmlRenderer::class,
-    ThrowableResponseFactoryInterface::class => ThrowableResponseFactory::class,
+    ErrorCatcher::class => [
+        '__construct()' => [
+            'throwableResponseAction' => Reference::to(ThrowableResponseAction::class),
+        ],
+    ],
+    ThrowableResponseAction::class => [
+        '__construct()' => [
+            'rendererProvider' => DynamicReference::to(
+                static fn(ContainerInterface $container) => new CompositeRendererProvider(
+                    new HeadRendererProvider(),
+                    new ContentTypeRendererProvider($container),
+                )
+            ),
+        ],
+    ],
 ];

src/ErrorHandler.php

@@ -41,16 +41,16 @@
     private bool $initialized = false;
 
     /**
-     * @param LoggerInterface $logger Logger to write errors to.
      * @param ThrowableRendererInterface $defaultRenderer Default throwable renderer.
+     * @param LoggerInterface|null $logger Logger to write errors to.
      * @param EventDispatcherInterface|null $eventDispatcher Event dispatcher for error events.
      * @param int $exitShutdownHandlerDepth Depth of the exit() shutdown handler to ensure it's executed last.
      */
     public function __construct(
-        private readonly LoggerInterface $logger,
         private readonly ThrowableRendererInterface $defaultRenderer,
+        private readonly ?LoggerInterface $logger = null,
         private readonly ?EventDispatcherInterface $eventDispatcher = null,
         private readonly int $exitShutdownHandlerDepth = 2
     ) {
     }
 
@@ -68,7 +68,7 @@
         $renderer ??= $this->defaultRenderer;
 
         try {
-            $this->logger->error($t->getMessage(), ['throwable' => $t]);
+            $this->logger?->error($t->getMessage(), ['throwable' => $t]);
             return $this->debug ? $renderer->renderVerbose($t, $request) : $renderer->render($t, $request);
         } catch (Throwable $t) {
             return new ErrorData((string) $t);
@@ -108,14 +108,14 @@
             return;
         }
 
         if ($this->memoryReserveSize > 0) {
             $this->memoryReserve = str_repeat('x', $this->memoryReserveSize);
         }
 
         $this->initializeOnce();
 
         // Handles throwable that isn't caught otherwise, echo output and exit.
         set_exception_handler(function (Throwable $t): void {
             if (!$this->enabled) {
                 return;
             }
@@ -129,12 +129,12 @@
                 return false;
             }
 
             if (!(error_reporting() & $severity)) {
                 // This error code is not included in error_reporting.
                 return true;
             }
 
             $backtrace = debug_backtrace(0);
             array_shift($backtrace);
             throw new ErrorException($message, $severity, $severity, $file, $line, null, $backtrace);
         });

src/Exception/ErrorException.php

@@ -18,7 +18,7 @@
  *
  * @final
  */
-class ErrorException extends \ErrorException implements FriendlyExceptionInterface
+final class ErrorException extends \ErrorException implements FriendlyExceptionInterface
 {
     /** @psalm-suppress MissingClassConstType Private constants never change. */
     private const ERROR_NAMES = [

src/Exception/UserException.php

@@ -23,7 +23,7 @@
  * @final
  */
 #[Attribute(Attribute::TARGET_CLASS)]
-class UserException extends Exception
+final class UserException extends Exception
 {
     public static function isUserException(Throwable $throwable): bool
     {

src/Middleware/ErrorCatcher.php

@@ -12,16 +12,16 @@
 use Psr\Http\Server\RequestHandlerInterface;
 use Yiisoft\ErrorHandler\CompositeException;
 use Yiisoft\ErrorHandler\Event\ApplicationError;
-use Yiisoft\ErrorHandler\ThrowableResponseFactoryInterface;
+use Yiisoft\ErrorHandler\ThrowableResponseActionInterface;
 
 /**
  * `ErrorCatcher` catches all throwables from the next middlewares
- * and renders it with a handler that implements the `ThrowableResponseFactoryInterface`.
+ * and renders it with a handler that implements the `ThrowableResponseActionInterface`.
  */
 final class ErrorCatcher implements MiddlewareInterface
 {
     public function __construct(
-        private readonly ThrowableResponseFactoryInterface $throwableResponseFactory,
+        private readonly ThrowableResponseActionInterface $throwableResponseAction,
         private readonly ?EventDispatcherInterface $eventDispatcher = null,
     ) {
     }
@@ -37,7 +37,7 @@ public function process(ServerRequestInterface $request, RequestHandlerInterface
                 $t = new CompositeException($e, $t);
             }
 
-            return $this->throwableResponseFactory->create($t, $request);
+            return $this->throwableResponseAction->handle($request, $t);
         }
     }
 }

src/ThrowableResponseFactory.php → src/ThrowableResponseAction.php

@@ -12,22 +12,19 @@
 use Yiisoft\Http\Status;
 
 /**
- * `ThrowableResponseFactory` produces a response with rendered `Throwable` object.
+ * `ThrowableResponseAction` produces a response with rendered `Throwable` object.
  */
-final class ThrowableResponseFactory implements ThrowableResponseFactoryInterface
+final class ThrowableResponseAction implements ThrowableResponseActionInterface
 {
-    private readonly HeadersProvider $headersProvider;
-
     public function __construct(
         private readonly ResponseFactoryInterface $responseFactory,
         private readonly ErrorHandler $errorHandler,
         private readonly RendererProviderInterface $rendererProvider,
-        ?HeadersProvider $headersProvider = null,
+        private readonly HeadersProvider $headersProvider = new HeadersProvider(),
     ) {
-        $this->headersProvider = $headersProvider ?? new HeadersProvider();
     }
 
-    public function create(Throwable $throwable, ServerRequestInterface $request): ResponseInterface
+    public function handle(ServerRequestInterface $request, Throwable $throwable): ResponseInterface
     {
         $renderer = $this->rendererProvider->get($request);
 

src/ThrowableResponseFactoryInterface.php → src/ThrowableResponseActionInterface.php

@@ -9,12 +9,12 @@
 use Psr\Http\Message\ServerRequestInterface;
 
 /**
- * `ThrowableResponseFactoryInterface` produces a response for `Throwable` object.
+ * `ThrowableResponseActionInterface` produces a response for `Throwable` object.
  */
-interface ThrowableResponseFactoryInterface
+interface ThrowableResponseActionInterface
 {
     /**
      * Handles a `Throwable` object and produces a response.
      */
-    public function create(Throwable $throwable, ServerRequestInterface $request): ResponseInterface;
+    public function handle(ServerRequestInterface $request, Throwable $throwable): ResponseInterface;
 }

tests/ErrorHandlerTest.php

@@ -6,7 +6,6 @@
 
 use PHPUnit\Framework\Attributes\WithoutErrorHandler;
 use PHPUnit\Framework\TestCase;
-use Psr\Log\LoggerInterface;
 use RuntimeException;
 use Throwable;
 use Yiisoft\ErrorHandler\ErrorHandler;
@@ -16,14 +15,12 @@
 final class ErrorHandlerTest extends TestCase
 {
     private ErrorHandler $errorHandler;
-    private LoggerInterface $loggerMock;
     private ThrowableRendererInterface $throwableRendererMock;
 
     protected function setUp(): void
     {
-        $this->loggerMock = $this->createMock(LoggerInterface::class);
         $this->throwableRendererMock = $this->createMock(ThrowableRendererInterface::class);
-        $this->errorHandler = new ErrorHandler($this->loggerMock, $this->throwableRendererMock);
+        $this->errorHandler = new ErrorHandler($this->throwableRendererMock);
         $this->errorHandler->memoryReserveSize(0);
     }