ajgarlag · ajgarlag · Apr 12, 2023
diff --git a/.github/workflows/tests.yaml b/.github/workflows/tests.yaml
@@ -11,7 +11,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        php: ['7.4', '8.0', '8.1']
+        php: ['7.4', '8.0', '8.1', '8.2']
         stability: ['prefer-lowest', 'prefer-stable']
         allow_failure: [false]
         include:

diff --git a/composer.json b/composer.json
@@ -17,12 +17,14 @@
         "psr/http-server-middleware": "^1.0"
     },
     "require-dev": {
-        "phpspec/phpspec": "^7.2",
-        "friendsofphp/php-cs-fixer": "^3.8",
-        "nyholm/psr7": "^1.5",
-        "phpstan/phpstan": "^1.6",
-        "phpstan/extension-installer": "^1.1",
-        "phpstan/phpstan-deprecation-rules": "^1.0"
+        "phpspec/phpspec": "^7.3",
+        "friendsofphp/php-cs-fixer": "^3.16",
+        "nyholm/psr7": "^1.6",
+        "phpspec/prophecy": "^1.17",
+        "phpstan/phpstan": "^1.10.13",
+        "phpstan/extension-installer": "^1.2",
+        "phpstan/phpstan-deprecation-rules": "^1.1.3",
+        "rector/rector": "^0.15.24"
     },
     "autoload": {
         "psr-4": {
@@ -36,9 +38,12 @@
     },
     "scripts": {
         "lint": "@php -d xdebug.mode=off vendor/bin/php-cs-fixer fix --dry-run --ansi -v",
-        "fix-cs": "@php -d xdebug.mode=off vendor/bin/php-cs-fixer fix --ansi",
+        "fix-cs": [
+            "@php -d xdebug.mode=off vendor/bin/rector --ansi",
+            "@php -d xdebug.mode=off vendor/bin/php-cs-fixer fix --ansi"
+        ],
         "test": [
-            "@php -d xdebug.mode=off vendor/bin/phpstan analyse --ansi -l 9 src ",
+            "@php -d xdebug.mode=off vendor/bin/phpstan analyse --ansi -l 9 src",
             "@php -d xdebug.mode=off vendor/bin/phpspec run --ansi"
         ]
     },

diff --git a/rector.php b/rector.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+use Rector\CodeQuality\Rector\Class_\InlineConstructorDefaultToPropertyRector;
+use Rector\Config\RectorConfig;
+use Rector\Set\ValueObject\LevelSetList;
+use Rector\Set\ValueObject\SetList;
+
+return static function (RectorConfig $rectorConfig): void {
+    $rectorConfig->paths([
+        __DIR__ . '/spec',
+        __DIR__ . '/src',
+    ]);
+
+    // define sets of rules
+    $rectorConfig->sets([
+        LevelSetList::UP_TO_PHP_74,
+        SetList::CODE_QUALITY,
+        SetList::CODING_STYLE,
+        SetList::DEAD_CODE,
+        SetList::EARLY_RETURN,
+        SetList::NAMING,
+        SetList::TYPE_DECLARATION,
+    ]);
+};
diff --git a/spec/PipeSpec.php b/spec/PipeSpec.php
@@ -22,22 +22,22 @@ class PipeSpec extends ObjectBehavior
 {
     use Psr7FactoryTrait;
 
-    public function let()
+    public function let(): void
     {
         $this->beConstructedThrough('create');
     }
 
-    public function it_is_initializable()
+    public function it_is_initializable(): void
     {
         $this->shouldHaveType(Pipe::class);
     }
 
-    public function it_is_a_middleware()
+    public function it_is_a_middleware(): void
     {
         $this->shouldImplement(MiddlewareInterface::class);
     }
 
-    public function it_delegates_to_passed_request_handler(RequestHandlerInterface $requestHandler)
+    public function it_delegates_to_passed_request_handler(RequestHandlerInterface $requestHandler): void
     {
         $response = $this->fakeAResponse();
 
@@ -46,26 +46,24 @@ public function it_delegates_to_passed_request_handler(RequestHandlerInterface $
         $this->process($this->fakeAServerRequest(), $requestHandler)->shouldReturn($response);
     }
 
-    public function it_creates_a_new_pipeline_when_a_middleware_is_connected(MiddlewareInterface $middleware)
+    public function it_creates_a_new_pipeline_when_a_middleware_is_connected(MiddlewareInterface $middleware): void
     {
         $pipe = $this->withConnectedMiddleware($middleware);
 
         $pipe->shouldBeAnInstanceOf(Pipe::class);
         $pipe->shouldNotBe($this);
     }
 
-    public function it_can_create_a_new_pipeline_with_middlewares_connected(MiddlewareInterface $firstMiddleware, MiddlewareInterface $lastMiddleware, RequestHandlerInterface $requestHandler)
+    public function it_can_create_a_new_pipeline_with_middlewares_connected(MiddlewareInterface $firstMiddleware, MiddlewareInterface $lastMiddleware, RequestHandlerInterface $requestHandler): void
     {
         $response = $this->fakeAResponse();
 
         $requestHandler->handle(Argument::type(ServerRequestInterface::class))->willReturn($response)->shouldBeCalledTimes(2);
 
         $firstMiddleware->process(Argument::type(ServerRequestInterface::class), Argument::type(RequestHandlerInterface::class))->will(
-            function ($args) use ($lastMiddleware) {
+            static function ($args) use ($lastMiddleware) {
                 $lastMiddleware->process(Argument::type(ServerRequestInterface::class), Argument::type(RequestHandlerInterface::class))->will(
-                    function ($args) {
-                        return $args[1]->handle($args[0]);
-                    }
+                    static fn ($args) => $args[1]->handle($args[0])
                 )
                         ->shouldBeCalledTimes(2)
                 ;
@@ -82,18 +80,16 @@ function ($args) {
         $this->process($this->fakeAServerRequest(), $requestHandler)->shouldReturn($response);
     }
 
-    public function it_processes_requests_through_piped_middlewares_in_order(MiddlewareInterface $firstMiddleware, MiddlewareInterface $lastMiddleware, RequestHandlerInterface $requestHandler)
+    public function it_processes_requests_through_piped_middlewares_in_order(MiddlewareInterface $firstMiddleware, MiddlewareInterface $lastMiddleware, RequestHandlerInterface $requestHandler): void
     {
         $response = $this->fakeAResponse();
 
         $requestHandler->handle(Argument::type(ServerRequestInterface::class))->willReturn($response)->shouldBeCalledTimes(2);
 
         $firstMiddleware->process(Argument::type(ServerRequestInterface::class), Argument::type(RequestHandlerInterface::class))->will(
-            function ($args) use ($lastMiddleware) {
+            static function ($args) use ($lastMiddleware) {
                 $lastMiddleware->process(Argument::type(ServerRequestInterface::class), Argument::type(RequestHandlerInterface::class))->will(
-                    function ($args) {
-                        return $args[1]->handle($args[0]);
-                    }
+                    static fn ($args) => $args[1]->handle($args[0])
                 )
                         ->shouldBeCalledTimes(2)
                 ;

diff --git a/spec/Psr7FactoryTrait.php b/spec/Psr7FactoryTrait.php
@@ -17,31 +17,17 @@
 
 trait Psr7FactoryTrait
 {
-    /**
-     * @param array  $server
-     * @param string $method
-     * @param string $uri
-     *
-     * @return ServerRequestInterface
-     */
-    protected function fakeAServerRequest($server = [], $method = 'GET', $uri = 'http://example.org')
+    protected function fakeAServerRequest(array $server = [], string $method = 'GET', string $uri = 'http://example.org'): ServerRequestInterface
     {
-        $requestFactory = new Psr17Factory();
-        $request = $requestFactory->createServerRequest($method, $uri, $server);
+        $psr17Factory = new Psr17Factory();
 
-        return $request;
+        return $psr17Factory->createServerRequest($method, $uri, $server);
     }
 
-    /**
-     * @param int $code
-     *
-     * @return ResponseInterface
-     */
-    protected function fakeAResponse($code = 200)
+    protected function fakeAResponse(int $code = 200): ResponseInterface
     {
-        $factory = new Psr17Factory();
-        $response = $factory->createResponse($code);
+        $psr17Factory = new Psr17Factory();
 
-        return $response;
+        return $psr17Factory->createResponse($code);
     }
 }
diff --git a/spec/StackSpec.php b/spec/StackSpec.php
@@ -23,22 +23,22 @@ class StackSpec extends ObjectBehavior
 {
     use Psr7FactoryTrait;
 
-    public function let(RequestHandlerInterface $requestHandler)
+    public function let(RequestHandlerInterface $requestHandler): void
     {
         $this->beConstructedThrough('create', [$requestHandler]);
     }
 
-    public function it_is_initializable()
+    public function it_is_initializable(): void
     {
         $this->shouldHaveType(Stack::class);
     }
 
-    public function it_is_a_request_handler()
+    public function it_is_a_request_handler(): void
     {
         $this->shouldImplement(RequestHandlerInterface::class);
     }
 
-    public function it_delegates_to_given_request_handler(RequestHandlerInterface $requestHandler)
+    public function it_delegates_to_given_request_handler(RequestHandlerInterface $requestHandler): void
     {
         $response = $this->fakeAResponse();
 
@@ -47,26 +47,24 @@ public function it_delegates_to_given_request_handler(RequestHandlerInterface $r
         $this->handle($this->fakeAServerRequest())->shouldReturn($response);
     }
 
-    public function it_creates_a_new_stack_when_a_middleware_is_pushed(MiddlewareInterface $middleware)
+    public function it_creates_a_new_stack_when_a_middleware_is_pushed(MiddlewareInterface $middleware): void
     {
         $stack = $this->withPushedMiddleware($middleware);
 
         $stack->shouldBeAnInstanceOf(Stack::class);
         $stack->shouldNotBe($this);
     }
 
-    public function it_can_create_a_new_stack_with_middlewares_pushed(MiddlewareInterface $innerMiddleware, MiddlewareInterface $outerMiddleware, RequestHandlerInterface $requestHandler)
+    public function it_can_create_a_new_stack_with_middlewares_pushed(MiddlewareInterface $innerMiddleware, MiddlewareInterface $outerMiddleware, RequestHandlerInterface $requestHandler): void
     {
         $response = $this->fakeAResponse();
 
         $requestHandler->handle(Argument::type(RequestInterface::class))->willReturn($response)->shouldBeCalledTimes(2);
 
         $outerMiddleware->process(Argument::type(ServerRequestInterface::class), Argument::type(RequestHandlerInterface::class))->will(
-            function ($args) use ($innerMiddleware) {
+            static function ($args) use ($innerMiddleware) {
                 $innerMiddleware->process(Argument::type(ServerRequestInterface::class), Argument::type(RequestHandlerInterface::class))->will(
-                    function ($args) {
-                        return $args[1]->handle($args[0]);
-                    }
+                    static fn ($args) => $args[1]->handle($args[0])
                 )
                         ->shouldBeCalledTimes(2)
                 ;
@@ -83,18 +81,16 @@ function ($args) {
         $this->handle($this->fakeAServerRequest())->shouldReturn($response);
     }
 
-    public function it_processes_requests_through_pushed_middlewares_in_order(MiddlewareInterface $innerMiddleware, MiddlewareInterface $outerMiddleware, RequestHandlerInterface $requestHandler)
+    public function it_processes_requests_through_pushed_middlewares_in_order(MiddlewareInterface $innerMiddleware, MiddlewareInterface $outerMiddleware, RequestHandlerInterface $requestHandler): void
     {
         $response = $this->fakeAResponse();
 
         $requestHandler->handle(Argument::type(RequestInterface::class))->willReturn($response)->shouldBeCalledTimes(2);
 
         $outerMiddleware->process(Argument::type(ServerRequestInterface::class), Argument::type(RequestHandlerInterface::class))->will(
-            function ($args) use ($innerMiddleware) {
+            static function ($args) use ($innerMiddleware) {
                 $innerMiddleware->process(Argument::type(ServerRequestInterface::class), Argument::type(RequestHandlerInterface::class))->will(
-                    function ($args) {
-                        return $args[1]->handle($args[0]);
-                    }
+                    static fn ($args) => $args[1]->handle($args[0])
                 )
                         ->shouldBeCalledTimes(2)
                 ;

diff --git a/src/Pipe.php b/src/Pipe.php
@@ -40,21 +40,21 @@ public static function create(array $middlewares = []): self
         return $pipe;
     }
 
-    public function process(ServerRequestInterface $request, RequestHandlerInterface $requestHandler): ResponseInterface
+    public function process(ServerRequestInterface $serverRequest, RequestHandlerInterface $requestHandler): ResponseInterface
     {
-        if (empty($this->middlewares)) {
-            return $requestHandler->handle($request);
+        if ([] === $this->middlewares) {
+            return $requestHandler->handle($serverRequest);
         }
 
         $stack = Stack::create($requestHandler, array_reverse($this->middlewares));
 
-        return $stack->handle($request);
+        return $stack->handle($serverRequest);
     }
 
     public function withConnectedMiddleware(MiddlewareInterface $middleware): self
     {
         $pipe = clone $this;
-        array_push($pipe->middlewares, $middleware);
+        $pipe->middlewares[] = $middleware;
 
         return $pipe;
     }

diff --git a/src/Stack.php b/src/Stack.php
@@ -43,13 +43,13 @@ public static function create(RequestHandlerInterface $requestHandler, array $mi
         return $stack;
     }
 
-    public function handle(ServerRequestInterface $request): ResponseInterface
+    public function handle(ServerRequestInterface $serverRequest): ResponseInterface
     {
-        if (null === $next = $this->peek()) {
-            return $this->requestHandler->handle($request);
+        if (!($middleware = $this->peek()) instanceof \Psr\Http\Server\MiddlewareInterface) {
+            return $this->requestHandler->handle($serverRequest);
         }
 
-        return $next->process($request, $this->pop());
+        return $middleware->process($serverRequest, $this->pop());
     }
 
     public function withPushedMiddleware(MiddlewareInterface $middleware): self