feat: new runner class

.github/workflows/php.yml

@@ -40,4 +40,4 @@ jobs:
         run:  ./vendor/bin/phpunit tests --testdox
 
       - name: Run static analysis
-        run: ./vendor/bin/phpstan analyse src --level 6 --no-progress --no-interaction
+        run: ./vendor/bin/phpstan analyse src --no-progress --no-interaction

composer.json

@@ -20,12 +20,12 @@
   },
   "autoload": {
     "psr-4": {
-      "Borsch\\": "src/"
+      "Borsch\\RequestHandler\\": "src/"
     }
   },
   "autoload-dev": {
     "psr-4": {
       "BorschTest\\": "tests/"
     }
   }
-}
+}

phpstan.neon

@@ -0,0 +1,3 @@
+parameters:
+    level: 6
+    treatPhpDocTypesAsCertain: false

src/Emitter.php

@@ -0,0 +1,62 @@
+<?php declare(strict_types=1);
+
+namespace Borsch\RequestHandler;
+
+use Psr\Http\Message\{ResponseInterface, StreamInterface};
+use function header, sprintf, ucwords;
+
+class Emitter implements EmitterInterface
+{
+
+    /**
+     * @link https://github.com/http-interop/response-sender/blob/master/src/functions.php
+     */
+    public function emit(ResponseInterface $response): void
+    {
+        $this->emitHeaders($response);
+        $this->emitStatusLine($response);
+        $this->emitBody($response->getBody());
+    }
+
+    private function emitHeaders(ResponseInterface $response): void
+    {
+        foreach ($response->getHeaders() as $name => $values) {
+            foreach ($values as $value) {
+                header(sprintf(
+                    '%s: %s',
+                    ucwords($name, '-'), $value),
+                    false
+                );
+            }
+        }
+    }
+
+    private function emitStatusLine(ResponseInterface $response): void
+    {
+        $http_line = sprintf(
+            'HTTP/%s %s %s',
+            $response->getProtocolVersion(),
+            $response->getStatusCode(),
+            $response->getReasonPhrase()
+        );
+
+        header($http_line, true, $response->getStatusCode());
+    }
+
+    private function emitBody(StreamInterface $stream): void
+    {
+        if ($stream->isSeekable()) {
+            $stream->rewind();
+        }
+
+        if (!$stream->isReadable()) {
+            echo $stream;
+            return;
+        }
+
+        $length = 1024 * 8;
+        while (!$stream->eof()) {
+            echo $stream->read($length);
+        }
+    }
+}

src/EmitterInterface.php

@@ -0,0 +1,16 @@
+<?php declare(strict_types=1);
+
+namespace Borsch\RequestHandler;
+
+use Psr\Http\Message\ResponseInterface;
+
+interface EmitterInterface
+{
+
+    /**
+     * Emits the given response.
+     *
+     * @param ResponseInterface $response The response to emit.
+     */
+    public function emit(ResponseInterface $response): void;
+}

src/RequestHandler/RequestHandler.php → src/RequestHandler.php

@@ -1,11 +1,11 @@
-<?php
+<?php declare(strict_types=1);
 
 namespace Borsch\RequestHandler;
 
-use Borsch\RequestHandler\Exception\RequestHandlerRuntimeException;
 use Psr\Http\Message\{ResponseInterface, ServerRequestInterface};
 use Psr\Http\Server\MiddlewareInterface;
 use SplStack;
+use function get_class, gettype, is_object;
 
 class RequestHandler implements RequestHandlerInterface
 {
@@ -44,6 +44,13 @@ public function handle(ServerRequestInterface $request): ResponseInterface
             throw RequestHandlerRuntimeException::emptyStack();
         }
 
-        return $this->stack->shift()->process($request, $this);
+        $middleware = $this->stack->shift();
+        if (!$middleware instanceof MiddlewareInterface) {
+            throw RequestHandlerRuntimeException::invalidMiddleware(
+                (string)(is_object($middleware) ? get_class($middleware) : gettype($middleware))
+            );
+        }
+
+        return $middleware->process($request, $this);
     }
 }

src/RequestHandler/RequestHandlerInterface.php → src/RequestHandlerInterface.php

@@ -1,4 +1,4 @@
-<?php
+<?php declare(strict_types=1);
 
 namespace Borsch\RequestHandler;
 
@@ -11,8 +11,8 @@ interface RequestHandlerInterface extends PsrRequestHandlerInterface
 {
 
     /**
-     * Add a middleware to the request handler.
+     * Add middleware to the request handler.
      * Must return itself to allow method chaining (if desired).
      */
     public function middleware(MiddlewareInterface $middleware): RequestHandlerInterface;
-}
+}

src/RequestHandlerRunner.php

@@ -0,0 +1,51 @@
+<?php declare(strict_types=1);
+
+namespace Borsch\RequestHandler;
+
+use Psr\Http\Message\{ResponseInterface, ServerRequestInterface};
+use Psr\Http\Server\RequestHandlerInterface;
+use Throwable;
+
+final class RequestHandlerRunner implements RequestHandlerRunnerInterface
+{
+
+    /** @var callable(): ServerRequestInterface */
+    private $server_request_factory;
+
+    /** @var callable(Throwable $e): ResponseInterface */
+    private $error_response_factory;
+
+    /**
+     * @param callable(): ServerRequestInterface $server_request_factory
+     * @param callable(Throwable $e): ResponseInterface $error_response_factory
+     */
+    public function __construct(
+        private readonly RequestHandlerInterface $handler,
+        private readonly EmitterInterface $emitter,
+        callable $server_request_factory,
+        callable $error_response_factory,
+    ) {
+        $this->server_request_factory = $server_request_factory;
+        $this->error_response_factory = $error_response_factory;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function run(): void
+    {
+        try {
+            $request = ($this->server_request_factory)();
+        } catch (Throwable $e) {
+            $this->emitter->emit(
+                ($this->error_response_factory)($e)
+            );
+
+            return;
+        }
+
+        $this->emitter->emit(
+            $this->handler->handle($request)
+        );
+    }
+}

src/RequestHandlerRunnerInterface.php

@@ -0,0 +1,13 @@
+<?php declare(strict_types=1);
+
+namespace Borsch\RequestHandler;
+
+interface RequestHandlerRunnerInterface
+{
+
+    /**
+     * Run the request handler.
+     * This method should handle the request and send the response.
+     */
+    public function run(): void;
+}

src/RequestHandlerRuntimeException.php

@@ -0,0 +1,29 @@
+<?php declare(strict_types=1);
+
+namespace Borsch\RequestHandler;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Server\MiddlewareInterface;
+use RuntimeException;
+use function sprintf;
+
+class RequestHandlerRuntimeException extends RuntimeException
+{
+
+    public static function emptyStack(): self
+    {
+        return new self(sprintf(
+            'The middleware stack is empty and no %s has been returned',
+            ResponseInterface::class
+        ));
+    }
+
+    public static function invalidMiddleware(string $middleware): self
+    {
+        return new self(sprintf(
+            'The middleware "%s" must implement %s',
+            $middleware,
+            MiddlewareInterface::class
+        ));
+    }
+}