Minor refactor + Add rector

.github/workflows/rector.yml

@@ -0,0 +1,24 @@
+on:
+  pull_request_target:
+    paths-ignore:
+      - 'docs/**'
+      - 'README.md'
+      - 'CHANGELOG.md'
+      - '.gitignore'
+      - '.gitattributes'
+      - 'infection.json.dist'
+      - 'psalm.xml'
+
+name: rector
+
+jobs:
+  rector:
+    uses: yiisoft/actions/.github/workflows/rector.yml@master
+    secrets:
+      token: ${{ secrets.YIISOFT_GITHUB_TOKEN }}
+    with:
+      repository: ${{ github.event.pull_request.head.repo.full_name }}
+      os: >-
+        ['ubuntu-latest']
+      php: >-
+        ['8.4']

CHANGELOG.md

@@ -7,6 +7,9 @@
 - Enh #44: Add psalm type `int<1, 2147483647>` to `depth` parameter in `JsonParser` constructor (@vjik)
 - Bug #44: Explicitly mark nullable parameters (@vjik)
 - Bug #46: Explicitly add transitive dependency `psr/http-factory` (@vjik)
+- Enh #47: Use promoted readonly properties in `JsonParser`, `BadRequestHandler` and `RequestBodyParser` classes (@vjik)
+- Enh #47: Minor refactor `RequestBodyParser`: use `str_contains()` function instead of `strpos()` and `::class` instead
+  of `get_class()` (@vjik)
 
 ## 1.1.1 June 03, 2024
 

composer.json

@@ -43,6 +43,7 @@
         "httpsoft/http-message": "^1.1.6",
         "maglnet/composer-require-checker": "^4.7.1",
         "phpunit/phpunit": "^10.5.55",
+        "rector/rector": "^2.1",
         "roave/infection-static-analysis-plugin": "^1.35",
         "spatie/phpunit-watcher": "^1.24",
         "vimeo/psalm": "^5.26.1 || ^6.13.1",

docs/internals.md

@@ -24,3 +24,21 @@ The code is statically analyzed with [Psalm](https://psalm.dev/). To run static
 ```shell
 ./vendor/bin/psalm
 ```
+
+## Code style
+
+Use [Rector](https://github.com/rectorphp/rector) to make codebase follow some specific rules or
+use either newest or any specific version of PHP:
+
+```shell
+./vendor/bin/rector
+```
+
+## Dependencies
+
+Use [ComposerRequireChecker](https://github.com/maglnet/ComposerRequireChecker) to detect transitive
+[Composer](https://getcomposer.org) dependencies:
+
+```shell
+./vendor/bin/composer-require-checker
+```

rector.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+use Rector\CodeQuality\Rector\Class_\InlineConstructorDefaultToPropertyRector;
+use Rector\Config\RectorConfig;
+use Rector\Php74\Rector\Closure\ClosureToArrowFunctionRector;
+use Rector\Php81\Rector\Property\ReadOnlyPropertyRector;
+use Rector\Php81\Rector\FuncCall\NullToStrictStringFuncCallArgRector;
+
+return RectorConfig::configure()
+    ->withPaths([
+        __DIR__ . '/src',
+        __DIR__ . '/tests',
+    ])
+    ->withPhpSets(php81: true)
+    ->withRules([
+        InlineConstructorDefaultToPropertyRector::class,
+    ])
+    ->withSkip([
+        ClosureToArrowFunctionRector::class,
+        ReadOnlyPropertyRector::class,
+        NullToStrictStringFuncCallArgRector::class,
+    ]);

src/BadRequestHandler.php

@@ -14,12 +14,11 @@
  */
 final class BadRequestHandler implements BadRequestHandlerInterface
 {
-    private ResponseFactoryInterface $responseFactory;
     private ?ParserException $parserException = null;
 
-    public function __construct(ResponseFactoryInterface $responseFactory)
-    {
-        $this->responseFactory = $responseFactory;
+    public function __construct(
+        private readonly ResponseFactoryInterface $responseFactory,
+    ) {
     }
 
     public function handle(ServerRequestInterface $request): ResponseInterface
@@ -40,7 +39,7 @@
 
     public function withParserException(ParserException $e): BadRequestHandlerInterface
     {
         $new = clone $this;
         $new->parserException = $e;
         return $new;
     }

src/Parser/JsonParser.php

@@ -17,11 +17,6 @@
  */
 final class JsonParser implements ParserInterface
 {
-    private bool $convertToAssociativeArray;
-    /** @psalm-var int<1, 2147483647>  */
-    private int $depth;
-    private int $options;
-
     /**
      * @param bool $convertToAssociativeArray Whether objects should be converted to associative array during parsing.
      * @param int $depth Maximum JSON recursion depth.
@@ -30,13 +25,10 @@
      * @psalm-param int<1, 2147483647> $depth
      */
     public function __construct(
-        bool $convertToAssociativeArray = true,
-        int $depth = 512,
-        int $options = JSON_THROW_ON_ERROR | JSON_INVALID_UTF8_IGNORE
+        private readonly bool $convertToAssociativeArray = true,
+        private readonly int $depth = 512,
+        private readonly int $options = JSON_THROW_ON_ERROR | JSON_INVALID_UTF8_IGNORE,
     ) {
-        $this->convertToAssociativeArray = $convertToAssociativeArray;
-        $this->depth = $depth;
-        $this->options = $options;
     }
 
     public function parse(string $rawBody)

src/RequestBodyParser.php

@@ -16,7 +16,6 @@
 use Yiisoft\Request\Body\Parser\JsonParser;
 
 use function array_key_exists;
-use function get_class;
 use function is_array;
 use function is_object;
 
@@ -29,7 +28,6 @@
  */
 final class RequestBodyParser implements MiddlewareInterface
 {
-    private ContainerInterface $container;
     private BadRequestHandlerInterface $badRequestHandler;
 
     /**
@@ -43,10 +41,9 @@
 
     public function __construct(
         ResponseFactoryInterface $responseFactory,
-        ContainerInterface $container,
+        private readonly ContainerInterface $container,
         BadRequestHandlerInterface|null $badRequestHandler = null
     ) {
-        $this->container = $container;
         $this->badRequestHandler = $badRequestHandler ?? new BadRequestHandler($responseFactory);
     }
 
@@ -89,7 +86,7 @@
             return $new;
         }
         foreach ($mimeTypes as $mimeType) {
             $this->validateMimeType($mimeType);
             unset($new->parsers[$this->normalizeMimeType($mimeType)]);
         }
         return $new;
@@ -115,7 +112,7 @@
                 /** @var mixed $parsed */
                 $parsed = $parser->parse((string)$request->getBody());
                 if ($parsed !== null && !is_object($parsed) && !is_array($parsed)) {
-                    $parserClass = get_class($parser);
+                    $parserClass = $parser::class;
                     throw new RuntimeException(
                         "$parserClass::parse() return value must be an array, an object, or null."
                     );
@@ -147,12 +144,12 @@
     private function getContentType(ServerRequestInterface $request): ?string
     {
         $contentType = $request->getHeaderLine(Header::CONTENT_TYPE);
         if (trim($contentType) !== '') {
             if (str_contains($contentType, ';')) {
                 $contentTypeParts = explode(';', $contentType, 2);
                 return strtolower(trim($contentTypeParts[0]));
             }
             return strtolower(trim($contentType));
         }
         return null;
     }
@@ -162,7 +159,7 @@
      */
     private function validateMimeType(string $mimeType): void
     {
-        if (strpos($mimeType, '/') === false) {
+        if (!str_contains($mimeType, '/')) {
             throw new InvalidArgumentException('Invalid mime type.');
         }
     }

tests/MockParser.php

@@ -9,13 +9,10 @@
 
 final class MockParser implements ParserInterface
 {
-    private $response;
-    private bool $throwException;
-
-    public function __construct($response, bool $throwException)
-    {
-        $this->response = $response;
-        $this->throwException = $throwException;
+    public function __construct(
+        private readonly array|object|null $response,
+        private readonly bool $throwException,
+    ) {
     }
 
     public function parse(string $rawBody)

tests/RequestBodyParsersTest.php

@@ -45,7 +45,7 @@ public function testWithParser(): void
     public function testWithParserWithEmptyParserClass(): void
     {
         $containerId = 'testParser';
-        $container = $this->getContainerWithParser($containerId, '');
+        $container = $this->getContainerWithParser($containerId);
 
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('The parser class cannot be an empty string.');
@@ -101,7 +101,7 @@ public function testWithBadRequestResponse(): void
     public function testWithoutBadRequestResponse(): void
     {
         $containerId = 'test';
-        $container = $this->getContainerWithParser($containerId, '', true);
+        $container = $this->getContainerWithParser($containerId, throwException: true);
         $mimeType = 'test/test';
         $bodyParser = $this
             ->getRequestBodyParser($container)
@@ -144,7 +144,7 @@ public function testThrownExceptionWithNotExistsParser(): void
     public function testThrownExceptionWithInvalidMimeType(): void
     {
         $containerId = 'testParser';
-        $container = $this->getContainerWithParser($containerId, '');
+        $container = $this->getContainerWithParser($containerId);
 
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid mime type.');
@@ -222,8 +222,11 @@ private function getContainerWithResponseFactory(): SimpleContainer
         );
     }
 
-    private function getContainerWithParser(string $id, $expectedOutput, bool $throwException = false): SimpleContainer
-    {
+    private function getContainerWithParser(
+        string $id,
+        array|object|null $expectedOutput = null,
+        bool $throwException = false,
+    ): SimpleContainer {
         return new SimpleContainer(
             [
                 ResponseFactoryInterface::class => $this->createMock(ResponseFactoryInterface::class),
@@ -250,12 +253,11 @@ private function createHandler(): BadRequestHandlerInterface
             ->willReturn(Status::OK);
 
         return new class ($mockResponse) implements BadRequestHandlerInterface {
-            private $requestParsedBody;
-            private ResponseInterface $mockResponse;
+            private array|object|null $requestParsedBody;
 
-            public function __construct(ResponseInterface $mockResponse)
-            {
-                $this->mockResponse = $mockResponse;
+            public function __construct(
+                private readonly ResponseInterface $mockResponse,
+            ) {
             }
 
             public function handle(ServerRequestInterface $request): ResponseInterface
@@ -264,10 +266,7 @@ public function handle(ServerRequestInterface $request): ResponseInterface
                 return $this->mockResponse;
             }
 
-            /**
-             * @return array|object|null
-             */
-            public function getRequestParsedBody()
+            public function getRequestParsedBody(): array|object|null
             {
                 return $this->requestParsedBody;
             }
@@ -290,21 +289,16 @@ private function getRequestBodyParser(
     private function createCustomBadResponseHandler(string $body): BadRequestHandlerInterface
     {
         return new class ($body, new ResponseFactory()) implements BadRequestHandlerInterface {
-            private string $body;
-            private ResponseFactoryInterface $responseFactory;
-
-            public function __construct(string $body, ResponseFactoryInterface $responseFactory)
-            {
-                $this->body = $body;
-                $this->responseFactory = $responseFactory;
+            public function __construct(
+                private readonly string $body,
+                private readonly ResponseFactoryInterface $responseFactory
+            ) {
             }
 
             public function handle(ServerRequestInterface $request): ResponseInterface
             {
                 $response = $this->responseFactory->createResponse(Status::BAD_REQUEST);
-                $response
-                    ->getBody()
-                    ->write($this->body);
+                $response->getBody()->write($this->body);
                 return $response;
             }