Lazy definition

.github/workflows/build.yml

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

.github/workflows/mutation.yml

@@ -26,6 +26,6 @@ jobs:
       os: >-
         ['ubuntu-latest']
       php: >-
-        ['8.1']
+        ['8.1', '8.2']
     secrets:
       STRYKER_DASHBOARD_API_KEY: ${{ secrets.STRYKER_DASHBOARD_API_KEY }}

.github/workflows/static.yml

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

composer.json

@@ -31,13 +31,17 @@
     },
     "require-dev": {
         "maglnet/composer-require-checker": "^4.2",
+        "friendsofphp/proxy-manager-lts": "^1.0",
         "phpunit/phpunit": "^9.5",
         "rector/rector": "^0.17.0",
         "roave/infection-static-analysis-plugin": "^1.18",
         "spatie/phpunit-watcher": "^1.23",
         "vimeo/psalm": "^4.30|^5.6",
         "yiisoft/test-support": "^1.4"
     },
+    "suggest": {
+        "friendsofphp/proxy-manager-lts": "Allows create proxy classes"
+    },
     "autoload": {
         "psr-4": {
             "Yiisoft\\Definitions\\": "src"

src/CallableDefinition.php

@@ -25,6 +25,7 @@ final class CallableDefinition implements DefinitionInterface
 {
     /**
      * @var array|callable
+     *
      * @psalm-var callable|array{0:class-string,1:string}
      */
     private $callable;

src/Helpers/DefinitionExtractor.php

@@ -32,6 +32,7 @@ final class DefinitionExtractor
      * @throws NotInstantiableException
      *
      * @return ParameterDefinition[]
+     *
      * @psalm-return array<string, ParameterDefinition>
      */
     public static function fromClassName(string $class): array
@@ -61,6 +62,7 @@ public static function fromClassName(string $class): array
      * Extract dependency definitions from type hints of a function.
      *
      * @return ParameterDefinition[]
+     *
      * @psalm-return array<string, ParameterDefinition>
      */
     public static function fromFunction(ReflectionFunctionAbstract $reflectionFunction): array

src/Helpers/Normalizer.php

@@ -87,8 +87,12 @@
             return ArrayDefinition::fromConfig($config);
         }
 
+        if ($definition instanceof DefinitionInterface) {
+            return $definition;
+        }
+
         // Ready object
-        if (is_object($definition) && !($definition instanceof DefinitionInterface)) {
+        if (is_object($definition)) {
             return new ValueDefinition($definition);
         }
 

src/LazyDefinition.php

@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Definitions;
+
+use ProxyManager\Factory\LazyLoadingValueHolderFactory;
+use Psr\Container\ContainerInterface;
+use Yiisoft\Definitions\Contract\DefinitionInterface;
+use Yiisoft\Definitions\Helpers\Normalizer;
+
+final class LazyDefinition implements DefinitionInterface
+{
+    public function __construct(
+        private mixed $definition,
+        /**
+         * @var class-string
+         */
+        private string $objectClass,
+    ) {
+    }
+
+    /**
+     * @psalm-suppress MixedArgumentTypeCoercion
+     */
+    public function resolve(ContainerInterface $container): mixed
+    {
+        /** @var LazyLoadingValueHolderFactory $factory */
+        $factory = $container->get(LazyLoadingValueHolderFactory::class);
+        /**
+         * @var mixed $definition
+         */
+        $definition = $this->definition;
+        $objectClass = $this->objectClass;
+
+        /** @psalm-suppress InvalidArgument */
+        return $factory->createProxy(
+            $objectClass,
+            function (mixed &$wrappedObject) use ($container, $objectClass, $definition) {
+                $definition = Normalizer::normalize($definition, $objectClass);
+                /**
+                 * @var mixed $wrappedObject
+                 */
+                $wrappedObject = $definition->resolve($container);
+            }
+        );
+    }
+}

src/ReferencesArray.php

@@ -67,6 +67,7 @@ final class ReferencesArray
      * @throws InvalidConfigException
      *
      * @return Reference[]
+     *
      * @psalm-suppress DocblockTypeContradiction
      */
     public static function from(array $ids): array

tests/Support/NotFinalClass.php

@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Definitions\Tests\Support;
+
+class NotFinalClass
+{
+    private array $arguments;
+
+    public function __construct(...$arguments)
+    {
+        $this->arguments = $arguments;
+    }
+
+    public function getArguments(): array
+    {
+        return $this->arguments;
+    }
+}

tests/Unit/ArrayDefinitionTest.php

@@ -6,6 +6,7 @@
 
 use InvalidArgumentException;
 use PHPUnit\Framework\TestCase;
+use TypeError;
 use Yiisoft\Definitions\ArrayDefinition;
 use Yiisoft\Definitions\Exception\InvalidConfigException;
 use Yiisoft\Definitions\Reference;
@@ -523,4 +524,19 @@ public function testMagicMethods(): void
             $object->getEvents()
         );
     }
+
+    public function testNonArrayArguments(): void
+    {
+        $definition = ArrayDefinition::fromConfig([
+            ArrayDefinition::CLASS_NAME => Mouse::class,
+            'setNameAndEngine()' => 'kitty',
+        ]);
+        $container = new SimpleContainer();
+
+        $this->expectException(TypeError::class);
+        $this->expectExceptionMessage(
+            'Yiisoft\Definitions\ArrayDefinition::resolveFunctionArguments(): Argument #3 ($arguments) must be of type array, string given'
+        );
+        $definition->resolve($container);
+    }
 }

tests/Unit/Helpers/DefinitionResolverTest.php

@@ -45,7 +45,7 @@ public function testEnsureResolvableDefinition(): void
         $this->expectException(InvalidConfigException::class);
         $this->expectExceptionMessage(
             'Only references are allowed in constructor arguments, a definition object was provided: ' .
-            ValueDefinition::class
+            var_export(new ValueDefinition(7), true)
         );
         DefinitionResolver::ensureResolvable(new ValueDefinition(7));
     }

tests/Unit/Helpers/DefinitionValidatorTest.php

@@ -311,7 +311,7 @@ public function testDefinitionInArguments(): void
         $this->expectException(InvalidConfigException::class);
         $this->expectExceptionMessage(
             'Only references are allowed in constructor arguments, a definition object was provided: ' .
-            ValueDefinition::class
+            var_export(new ValueDefinition(56), true)
         );
         DefinitionValidator::validate([
             'class' => GearBox::class,

tests/Unit/LazyDefinitionDecoratorTest.php

@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Definitions\Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+use ProxyManager\Exception\InvalidProxiedClassException;
+use ProxyManager\Factory\LazyLoadingValueHolderFactory;
+use ProxyManager\Proxy\LazyLoadingInterface;
+use Yiisoft\Definitions\ArrayDefinition;
+use Yiisoft\Definitions\LazyDefinition;
+use Yiisoft\Definitions\Tests\Support\EngineInterface;
+use Yiisoft\Definitions\Tests\Support\NotFinalClass;
+use Yiisoft\Definitions\Tests\Support\Phone;
+use Yiisoft\Test\Support\Container\SimpleContainer;
+
+final class LazyDefinitionDecoratorTest extends TestCase
+{
+    public function testDecorateFinalClass(): void
+    {
+        $container = new SimpleContainer([
+            LazyLoadingValueHolderFactory::class => new LazyLoadingValueHolderFactory(),
+        ]);
+
+        $class = Phone::class;
+
+        $definition = ArrayDefinition::fromConfig([
+            ArrayDefinition::CLASS_NAME => $class,
+        ]);
+        $definition = new LazyDefinition($definition, $class);
+
+        $this->expectException(InvalidProxiedClassException::class);
+        $definition->resolve($container);
+    }
+
+    public function testDecorateNotFinalClass(): void
+    {
+        $container = new SimpleContainer([
+            LazyLoadingValueHolderFactory::class => new LazyLoadingValueHolderFactory(),
+        ]);
+
+        $class = NotFinalClass::class;
+
+        $definition = ArrayDefinition::fromConfig([
+            ArrayDefinition::CLASS_NAME => $class,
+        ]);
+        $definition = new LazyDefinition($definition, $class);
+
+        $phone = $definition->resolve($container);
+
+        self::assertInstanceOf(LazyLoadingInterface::class, $phone);
+    }
+
+    public function testDecorateInterface(): void
+    {
+        $container = new SimpleContainer([
+            LazyLoadingValueHolderFactory::class => new LazyLoadingValueHolderFactory(),
+        ]);
+
+        $class = EngineInterface::class;
+
+        $definition = ArrayDefinition::fromConfig([
+            ArrayDefinition::CLASS_NAME => $class,
+        ]);
+        $definition = new LazyDefinition($definition, $class);
+
+        $phone = $definition->resolve($container);
+
+        self::assertInstanceOf(LazyLoadingInterface::class, $phone);
+    }
+}