Lazy definition

composer-require-checker.json

@@ -0,0 +1,17 @@
+{
+    "symbol-whitelist": [
+        "ProxyManager\\Factory\\LazyLoadingValueHolderFactory",
+        "ProxyManager\\Proxy\\VirtualProxyInterface"
+    ],
+    "php-core-extensions": [
+        "Core",
+        "date",
+        "json",
+        "pcre",
+        "Phar",
+        "Reflection",
+        "SPL",
+        "standard"
+    ],
+    "scan-files": []
+}

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": "^1.0.0",
         "roave/infection-static-analysis-plugin": "^1.18",
         "spatie/phpunit-watcher": "^1.23",
         "vimeo/psalm": "^4.30|^5.21",
         "yiisoft/test-support": "^1.4"
     },
+    "suggest": {
+        "friendsofphp/proxy-manager-lts": "Allows use lazy definitions"
+    },
     "autoload": {
         "psr-4": {
             "Yiisoft\\Definitions\\": "src"

src/ArrayDefinition.php

@@ -60,7 +60,7 @@ public function withReferenceContainer(?ContainerInterface $referenceContainer):
     }
 
     /**
-     * Create ArrayDefinition from array config.
+     * Create `ArrayDefinition` from array config.
      *
      * @psalm-param ArrayDefinitionConfig $config
      */
@@ -69,7 +69,7 @@ public static function fromConfig(array $config): self
         return new self(
             $config[self::CLASS_NAME],
             $config[self::CONSTRUCTOR] ?? [],
-            self::getMethodsAndPropertiesFromConfig($config)
+            self::getMethodsAndPropertiesFromConfig($config),
         );
     }
 

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

@@ -12,7 +12,6 @@
 use Yiisoft\Definitions\Reference;
 use Yiisoft\Definitions\ValueDefinition;
 
-use function array_key_exists;
 use function is_array;
 use function is_callable;
 use function is_object;
@@ -49,7 +48,7 @@ final class Normalizer
     public static function normalize(mixed $definition, ?string $class = null): DefinitionInterface
     {
         // Reference
-        if ($definition instanceof ReferenceInterface) {
+        if ($definition instanceof DefinitionInterface) {
             return $definition;
         }
 
@@ -75,7 +74,7 @@ public static function normalize(mixed $definition, ?string $class = null): Defi
         // Array definition
         if (is_array($definition)) {
             $config = $definition;
-            if (!array_key_exists(ArrayDefinition::CLASS_NAME, $config)) {
+            if (!isset($config[ArrayDefinition::CLASS_NAME])) {
                 if ($class === null) {
                     throw new InvalidConfigException(
                         'Array definition should contain the key "class": ' . var_export($definition, true)
@@ -88,7 +87,7 @@ public static function normalize(mixed $definition, ?string $class = null): Defi
         }
 
         // Ready object
-        if (is_object($definition) && !($definition instanceof DefinitionInterface)) {
+        if (is_object($definition)) {
             return new ValueDefinition($definition);
         }
 

src/LazyDefinition.php

@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Definitions;
+
+use ProxyManager\Factory\LazyLoadingValueHolderFactory;
+use ProxyManager\Proxy\VirtualProxyInterface;
+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,
+        /**
+         * @psalm-var class-string
+         */
+        private string $class,
+    ) {
+    }
+
+    public function resolve(ContainerInterface $container): VirtualProxyInterface
+    {
+        /** @var LazyLoadingValueHolderFactory $factory */
+        $factory = $container->get(LazyLoadingValueHolderFactory::class);
+        $definition = $this->definition;
+
+        return $factory->createProxy(
+            $this->class,
+            static function (mixed &$wrappedObject) use ($container, $definition) {
+                $definition = Normalizer::normalize($definition);
+                $wrappedObject = $definition->resolve($container);
+                return true;
+            }
+        );
+    }
+}

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;
@@ -524,6 +525,21 @@ public function testMagicMethods(): void
         );
     }
 
+    public function testNonArrayMethodArguments(): 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);
+    }
+
     public function testMultipleCall()
     {
         $definition = ArrayDefinition::fromConfig([

tests/Unit/Helpers/DefinitionResolverTest.php

@@ -43,10 +43,9 @@ public function testEnsureResolvableScalar(): void
     public function testEnsureResolvableDefinition(): void
     {
         $this->expectException(InvalidConfigException::class);
-        $this->expectExceptionMessageMatches(
-            '/^Only references are allowed in constructor arguments, a definition object was provided: (\\\\|)' .
-            preg_quote(ValueDefinition::class) .
-            '.*/'
+        $this->expectExceptionMessage(
+            'Only references are allowed in constructor arguments, a definition object was provided: ' .
+            var_export(new ValueDefinition(7), true)
         );
         DefinitionResolver::ensureResolvable(new ValueDefinition(7));
     }

tests/Unit/Helpers/DefinitionValidatorTest.php

@@ -342,10 +342,9 @@ public function testInteger(): void
     public function testDefinitionInArguments(): void
     {
         $this->expectException(InvalidConfigException::class);
-        $this->expectExceptionMessageMatches(
-            '/^Only references are allowed in constructor arguments, a definition object was provided: (\\\\|)' .
-            preg_quote(ValueDefinition::class) .
-            '.*/'
+        $this->expectExceptionMessage(
+            'Only references are allowed in constructor arguments, a definition object was provided: ' .
+            var_export(new ValueDefinition(56), true)
         );
         DefinitionValidator::validate([
             'class' => GearBox::class,

tests/Unit/Helpers/NormalizerTest.php

@@ -51,6 +51,23 @@ public function testArray(): void
         $this->assertSame([], $definition->getMethodsAndProperties());
     }
 
+    public function testNullClass(): void
+    {
+        /** @var ArrayDefinition $definition */
+        $definition = Normalizer::normalize(
+            [
+                'class' => null,
+                '__construct()' => [42],
+            ],
+            GearBox::class
+        );
+
+        $this->assertInstanceOf(ArrayDefinition::class, $definition);
+        $this->assertSame(GearBox::class, $definition->getClass());
+        $this->assertSame([42], $definition->getConstructorArguments());
+        $this->assertSame([], $definition->getMethodsAndProperties());
+    }
+
     public function testReadyObject(): void
     {
         $container = new SimpleContainer();

tests/Unit/LazyDefinitionTest.php

@@ -0,0 +1,65 @@
+<?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 LazyDefinitionTest extends TestCase
+{
+    public function testFinalClass(): void
+    {
+        $container = new SimpleContainer([
+            LazyLoadingValueHolderFactory::class => new LazyLoadingValueHolderFactory(),
+        ]);
+
+        $class = Phone::class;
+
+        $definition = new LazyDefinition([ArrayDefinition::CLASS_NAME => $class], $class);
+
+        $this->expectException(InvalidProxiedClassException::class);
+        $definition->resolve($container);
+    }
+
+    public function testNotFinalClass(): void
+    {
+        $container = new SimpleContainer([
+            LazyLoadingValueHolderFactory::class => new LazyLoadingValueHolderFactory(),
+        ]);
+
+        $class = NotFinalClass::class;
+
+        $definition = new LazyDefinition([ArrayDefinition::CLASS_NAME => $class], $class);
+
+        $object = $definition->resolve($container);
+
+        self::assertInstanceOf($class, $object);
+        self::assertInstanceOf(LazyLoadingInterface::class, $object);
+    }
+
+    public function testInterface(): void
+    {
+        $container = new SimpleContainer([
+            LazyLoadingValueHolderFactory::class => new LazyLoadingValueHolderFactory(),
+        ]);
+
+        $class = EngineInterface::class;
+
+        $definition = new LazyDefinition([ArrayDefinition::CLASS_NAME => $class], $class);
+
+        $engine = $definition->resolve($container);
+
+        self::assertInstanceOf($class, $engine);
+        self::assertInstanceOf(LazyLoadingInterface::class, $engine);
+    }
+}