Add rector, raise PHP to ^8.0, minor refactoring (#41)

Co-authored-by: Sergei Predvoditelev <sergei@predvoditelev.ru>

.editorconfig

@@ -13,5 +13,9 @@ trim_trailing_whitespace = true
 [*.md]
 trim_trailing_whitespace = false
 
+[*.php]
+ij_php_space_before_short_closure_left_parenthesis = true
+ij_php_space_after_type_cast = true
+
 [*.yml]
 indent_size = 2

.github/workflows/build.yml

@@ -28,4 +28,4 @@ jobs:
       os: >-
         ['ubuntu-latest', 'windows-latest']
       php: >-
-        ['7.4', '8.0', '8.1']
+        ['8.0', '8.1']

.github/workflows/rector.yml

@@ -0,0 +1,21 @@
+on:
+  pull_request:
+    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
+    with:
+      os: >-
+        ['ubuntu-latest']
+      php: >-
+        ['8.0']

.github/workflows/static.yml

@@ -28,4 +28,4 @@ jobs:
       os: >-
         ['ubuntu-latest']
       php: >-
-        ['7.4', '8.0', '8.1']
+        ['8.0', '8.1']

CHANGELOG.md

@@ -2,7 +2,8 @@
 
 ## 2.1.1 under development
 
-- Enh #44: In methods of array definitions add autowiring and improve variadic arguments support (@vjik) 
+- Enh #44: In methods of array definitions add autowiring and improve variadic arguments support (@vjik)
+- Enh #41: Raise minimum PHP version to 8.0 and refactor code (@xepozz, @vjik)
 
 ## 2.1.0 October 25, 2022
 

README.md

@@ -26,14 +26,14 @@ The following are provided:
 
 ## Requirements
 
-- PHP 7.4 or higher.
+- PHP 8.0 or higher.
 
 ## Installation
 
 The package could be installed with composer:
 
 ```shell
-composer require yiisoft/definitions --prefer-dist
+composer require yiisoft/definitions
 ```
 
 ## General usage

composer.json

@@ -26,11 +26,12 @@
         }
     ],
     "require": {
-        "php": "^7.4|^8.0",
+        "php": "^8.0",
         "psr/container": "^1.0|^2.0"
     },
     "require-dev": {
         "phpunit/phpunit": "^9.5",
+        "rector/rector": "^0.14.3",
         "roave/infection-static-analysis-plugin": "^1.18",
         "spatie/phpunit-watcher": "^1.23",
         "vimeo/psalm": "^4.22",

phpunit.xml.dist

@@ -18,7 +18,6 @@
     <testsuites>
         <testsuite name="Yii Definitions tests">
             <directory>./tests/Unit</directory>
-            <directory phpVersion="8" phpVersionOperator=">=">./tests/Php8</directory>
             <directory phpVersion="8.1" phpVersionOperator=">=">./tests/Php8_1</directory>
         </testsuite>
     </testsuites>

rector.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+use Rector\CodeQuality\Rector\Class_\InlineConstructorDefaultToPropertyRector;
+use Rector\Config\RectorConfig;
+use Rector\Set\ValueObject\LevelSetList;
+
+return static function (RectorConfig $rectorConfig): void {
+    $rectorConfig->paths([
+        __DIR__ . '/src',
+        __DIR__ . '/tests',
+    ]);
+
+    // register a single rule
+    $rectorConfig->rule(InlineConstructorDefaultToPropertyRector::class);
+
+    // define sets of rules
+    $rectorConfig->sets([
+        LevelSetList::UP_TO_PHP_80,
+    ]);
+};

src/ArrayDefinition.php

@@ -33,29 +33,19 @@ final class ArrayDefinition implements DefinitionInterface
     public const TYPE_METHOD = 'method';
 
     /**
-     * @psalm-var class-string
+     * Container used to resolve references.
      */
-    private string $class;
-    private array $constructorArguments;
-    /**
-      * Container used to resolve references.
-      */
     private ?ContainerInterface $referenceContainer = null;
 
-    /**
-     * @psalm-var array<string, MethodOrPropertyItem>
-     */
-    private array $methodsAndProperties;
-
     /**
      * @psalm-param class-string $class
      * @psalm-param array<string, MethodOrPropertyItem> $methodsAndProperties
      */
-    private function __construct(string $class, array $constructorArguments, array $methodsAndProperties)
-    {
-        $this->class = $class;
-        $this->constructorArguments = $constructorArguments;
-        $this->methodsAndProperties = $methodsAndProperties;
+    private function __construct(
+        private string $class,
+        private array $constructorArguments,
+        private array $methodsAndProperties
+    ) {
     }
 
     /**

src/CallableDefinition.php

@@ -36,18 +36,18 @@ final class CallableDefinition implements DefinitionInterface
      *
      * @psalm-param callable|array{0:class-string,1:string} $callable
      */
-    public function __construct($callable)
+    public function __construct(array|callable $callable)
     {
         $this->callable = $callable;
     }
 
-    public function resolve(ContainerInterface $container)
+    public function resolve(ContainerInterface $container): mixed
     {
         try {
             $reflection = new ReflectionFunction(
                 $this->prepareClosure($this->callable, $container)
             );
-        } catch (ReflectionException $e) {
+        } catch (ReflectionException) {
             throw new NotInstantiableException(
                 'Can not instantiate callable definition. Got ' . var_export($this->callable, true)
             );
@@ -60,11 +60,9 @@ public function resolve(ContainerInterface $container)
     }
 
     /**
-     * @param array|callable $callable
-     *
      * @psalm-param callable|array{0:class-string,1:string} $callable
      */
-    private function prepareClosure($callable, ContainerInterface $container): Closure
+    private function prepareClosure(array|callable $callable, ContainerInterface $container): Closure
     {
         if (is_array($callable) && !is_object($callable[0])) {
             $reflection = new ReflectionMethod($callable[0], $callable[1]);

src/Contract/DefinitionInterface.php

@@ -19,14 +19,11 @@ interface DefinitionInterface
      * Resolve this definition.
      *
      * @throws InvalidConfigException If an object of incorrect type was created.
-     * @throws CircularReferenceException If there is a circular reference detected
-     * when resolving the definition.
-     * @throws NotFoundExceptionInterface If container does not know how to resolve
-     * the definition.
+     * @throws CircularReferenceException If there is a circular reference detected when resolving the definition.
+     * @throws NotFoundExceptionInterface If container does not know how to resolve the definition.
      * @throws NotInstantiableException If an object can not be instantiated.
      *
-     * @return mixed|null Ready to use object or null if definition can
-     * not be resolved and is marked as optional.
+     * @return mixed|null Ready to use object or null if definition can not be resolved and is marked as optional.
      */
-    public function resolve(ContainerInterface $container);
+    public function resolve(ContainerInterface $container): mixed;
 }

src/Contract/ReferenceInterface.php

@@ -7,8 +7,8 @@
 use Yiisoft\Definitions\Exception\InvalidConfigException;
 
 /**
- * Reference points to another named definition. Usually it is another service in the container
- * or another object definition in the factory.
+ * Reference points to another named definition. Usually it is another service in the container or another object
+ * definition in the factory.
  */
 interface ReferenceInterface extends DefinitionInterface
 {
@@ -19,5 +19,5 @@ interface ReferenceInterface extends DefinitionInterface
      *
      * @throws InvalidConfigException When definition configuration is not valid.
      */
-    public static function to($id): self;
+    public static function to(mixed $id): self;
 }

src/DefinitionStorage.php

@@ -17,20 +17,18 @@
  */
 final class DefinitionStorage
 {
-    private array $definitions;
     private array $buildStack = [];
-    /** @psalm-suppress  PropertyNotSetInConstructor */
+
     private ?ContainerInterface $delegateContainer = null;
-    private bool $useStrictMode;
 
     /**
      * @param array $definitions Definitions to store.
      * @param bool $useStrictMode If every dependency should be defined explicitly including classes.
      */
-    public function __construct(array $definitions = [], bool $useStrictMode = false)
-    {
-        $this->definitions = $definitions;
-        $this->useStrictMode = $useStrictMode;
+    public function __construct(
+        private array $definitions = [],
+        private bool $useStrictMode = false
+    ) {
     }
 
     /**
@@ -70,7 +68,7 @@ public function getBuildStack(): array
      *
      * @return mixed|object Definition with a given ID.
      */
-    public function get(string $id)
+    public function get(string $id): mixed
     {
         if (!$this->has($id)) {
             throw new RuntimeException("Service $id doesn't exist in DefinitionStorage.");
@@ -82,13 +80,16 @@ public function get(string $id)
      * Set a definition.
      *
      * @param string $id ID to set definition for.
-     * @param mixed|object $definition Definition to set.
+     * @param mixed $definition Definition to set.
      */
-    public function set(string $id, $definition): void
+    public function set(string $id, mixed $definition): void
     {
         $this->definitions[$id] = $definition;
     }
 
+    /**
+     * @throws CircularReferenceException
+     */
     private function isResolvable(string $id, array $building): bool
     {
         if (isset($this->definitions[$id])) {
@@ -110,7 +111,7 @@ private function isResolvable(string $id, array $building): bool
 
         try {
             $dependencies = DefinitionExtractor::fromClassName($id);
-        } catch (Throwable $e) {
+        } catch (Throwable) {
             $this->buildStack += $building + [$id => 1];
             return false;
         }
@@ -132,29 +133,28 @@ private function isResolvable(string $id, array $building): bool
                     break;
                 }
 
-                /**
-                 * @var ReflectionNamedType|ReflectionUnionType|null $type
-                 * @psalm-suppress RedundantConditionGivenDocblockType
-                 * @psalm-suppress UndefinedClass
-                 */
-                if ($type === null || (!$type instanceof ReflectionUnionType && $type->isBuiltin())) {
+                if (
+                    ($type instanceof ReflectionNamedType && $type->isBuiltin())
+                    || (!$type instanceof ReflectionNamedType && !$type instanceof ReflectionUnionType)
+                ) {
                     $isResolvable = false;
                     break;
                 }
 
-                // PHP 8 union type is used as type hint
-                /** @psalm-suppress UndefinedClass, TypeDoesNotContainType */
+                /** @var ReflectionNamedType|ReflectionUnionType $type */
+
+                // Union type is used as type hint
                 if ($type instanceof ReflectionUnionType) {
                     $isUnionTypeResolvable = false;
                     $unionTypes = [];
-                    /**
-                     * @psalm-suppress UnnecessaryVarAnnotation Annotation below is needed in PHP 7.4
-                     *
-                     * @var ReflectionNamedType $unionType
-                     */
                     foreach ($type->getTypes() as $unionType) {
                         if (!$unionType->isBuiltin()) {
                             $typeName = $unionType->getName();
+                            /**
+                             * @psalm-suppress TypeDoesNotContainType
+                             *
+                             * @link https://github.com/vimeo/psalm/issues/6756
+                             */
                             if ($typeName === 'self') {
                                 continue;
                             }
@@ -166,7 +166,6 @@ private function isResolvable(string $id, array $building): bool
                         }
                     }
 
-
                     if (!$isUnionTypeResolvable) {
                         foreach ($unionTypes as $typeName) {
                             if ($this->delegateContainer !== null && $this->delegateContainer->has($typeName)) {
@@ -183,25 +182,28 @@ private function isResolvable(string $id, array $building): bool
                     continue;
                 }
 
-                /** @var ReflectionNamedType|null $type */
                 // Our parameter has a class type hint
-                if ($type !== null && !$type->isBuiltin()) {
+                if (!$type->isBuiltin()) {
                     $typeName = $type->getName();
                     /**
                      * @psalm-suppress TypeDoesNotContainType
                      *
                      * @link https://github.com/vimeo/psalm/issues/6756
                      */
                     if ($typeName === 'self') {
-                        throw new CircularReferenceException(sprintf(
-                            'Circular reference to "%s" detected while building: %s.',
-                            $id,
-                            implode(', ', array_keys($building))
-                        ));
+                        throw new CircularReferenceException(
+                            sprintf(
+                                'Circular reference to "%s" detected while building: %s.',
+                                $id,
+                                implode(', ', array_keys($building))
+                            )
+                        );
                     }
 
-                    /** @psalm-suppress RedundantPropertyInitializationCheck */
-                    if (!$this->isResolvable($typeName, $building) && ($this->delegateContainer === null || !$this->delegateContainer->has($typeName))) {
+                    if (
+                        !$this->isResolvable($typeName, $building)
+                        && ($this->delegateContainer === null || !$this->delegateContainer->has($typeName))
+                    ) {
                         $isResolvable = false;
                         break;
                     }