Allow recursive container calls from factory functions for classes

Author: clue

src/Container.php

@@ -245,12 +245,17 @@ private function loadObject(string $name, int $depth = 64) /*: object (PHP 7.2+)
 
                 $this->container[$name] = $value;
             } elseif ($this->container[$name] instanceof \Closure) {
-                // build list of factory parameters based on parameter types
-                $closure = new \ReflectionFunction($this->container[$name]);
-                $params = $this->loadFunctionParams($closure, $depth, true, \explode("\0", $name)[0]);
+                $factory = $this->container[$name];
+                $closure = new \ReflectionFunction($factory);
 
                 // invoke factory with list of parameters
-                $value = $params === [] ? ($this->container[$name])() : ($this->container[$name])(...$params);
+                // temporarily unset factory reference to allow loading recursive variables from environment
+                try {
+                    unset($this->container[$name]);
+                    $value = $factory(...$this->loadFunctionParams($closure, $depth, true, \explode("\0", $name)[0]));
+                } finally {
+                    $this->container[$name] = $factory;
+                }
 
                 if (\is_string($value)) {
                     if ($depth < 1) {

tests/ContainerTest.php

@@ -1305,7 +1305,7 @@ public function __construct(\stdClass $data)
         $callable = $container->callable(get_class($controller));
 
         $this->expectException(\Error::class);
-        $this->expectExceptionMessage('Argument #1 ($stdClass) of {closure:' . __FILE__ . ':' . $line .'}() for $stdClass requires container config with type string, none given');
+        $this->expectExceptionMessage('Argument #1 ($stdClass) of {closure:' . __FILE__ . ':' . $line .'}() for stdClass requires container config with type string, none given');
         $callable($request);
     }
 
@@ -1820,22 +1820,6 @@ public function testCallableReturnsCallableThatThrowsWhenFactoryRequiresUndefine
         $callable($request);
     }
 
-    public function testCallableReturnsCallableThatThrowsWhenFactoryRequiresRecursiveClass(): void
-    {
-        $request = new ServerRequest('GET', 'http://example.com/');
-
-        $line = __LINE__ + 2;
-        $container = new Container([
-            \stdClass::class => function (\stdClass $data) { return $data; }
-        ]);
-
-        $callable = $container->callable(\stdClass::class);
-
-        $this->expectException(\Error::class);
-        $this->expectExceptionMessage('Argument #1 ($data) of {closure:' . __FILE__ . ':' . $line .'}() for stdClass is recursive');
-        $callable($request);
-    }
-
     public function testCallableReturnsCallableThatThrowsWhenFactoryIsRecursive(): void
     {
         $request = new ServerRequest('GET', 'http://example.com/');
@@ -2614,6 +2598,45 @@ public function testGetObjectReturnsAccessLogHandlerInstanceFromConfig(): void
         $this->assertSame($accessLogHandler, $ret);
     }
 
+    public function testGetObjectReturnsAccessLogHandlerInstanceFromFactoryFunction(): void
+    {
+        $accessLogHandler = new AccessLogHandler();
+
+        $container = new Container([
+            AccessLogHandler::class => function () use ($accessLogHandler) {
+                return $accessLogHandler;
+            }
+        ]);
+
+        $ret = $container->getObject(AccessLogHandler::class);
+
+        $this->assertSame($accessLogHandler, $ret);
+    }
+
+    public function testGetObjectReturnDefaultStdclassInstanceWhenFactoryFunctionHasRecursiveArgument(): void
+    {
+        $container = new Container([
+            \stdClass::class => function (\stdClass $object) { return $object; }
+        ]);
+
+        $ret = $container->getObject(\stdClass::class);
+
+        $this->assertInstanceOf(\stdClass::class, $ret);
+    }
+
+    public function testGetObjectReturnDefaultStdclassInstanceWhenFactoryFunctionUsesRecursiveGetObject(): void
+    {
+        $container = new Container([
+            \stdClass::class => function (Container $container) {
+                return $container->getObject(\stdClass::class);
+            }
+        ]);
+
+        $ret = $container->getObject(\stdClass::class);
+
+        $this->assertInstanceOf(\stdClass::class, $ret);
+    }
+
     public function testGetObjectReturnsSelfContainerByDefault(): void
     {
         $container = new Container([]);
@@ -2623,6 +2646,32 @@ public function testGetObjectReturnsSelfContainerByDefault(): void
         $this->assertSame($container, $ret);
     }
 
+    public function testGetObjectReturnsSelfContainerIfFactoryFunctionHasRecursiveContainerArgument(): void
+    {
+        $container = new Container([
+            Container::class => function (Container $container): Container {
+                return $container;
+            }
+        ]);
+
+        $ret = $container->getObject(Container::class);
+
+        $this->assertSame($container, $ret);
+    }
+
+    public function testGetObjectReturnsSelfContainerIfFactoryFunctionUsesRecursiveGetObject(): void
+    {
+        $container = new Container([
+            Container::class => function (Container $container): Container {
+                return $container->getObject(Container::class);
+            }
+        ]);
+
+        $ret = $container->getObject(Container::class);
+
+        $this->assertSame($container, $ret);
+    }
+
     public function testGetObjectReturnsOtherContainerFromConfig(): void
     {
         $other = new Container();
@@ -2785,18 +2834,26 @@ public function testGetObjectThrowsIfFactoryFunctionIsRecursive(): void
         $container->getObject(AccessLogHandler::class);
     }
 
-    public function testGetObjectThrowsIfFactoryFunctionHasRecursiveContainerArgument(): void
+    public function testGetObjectThrowsIfConstructorRequiresContainerConfig(): void
+    {
+        $container = new Container([]);
+
+        $this->expectException(\Error::class);
+        $this->expectExceptionMessage('Argument #1 ($path) of ' . LogStreamHandler::class . '::__construct() requires container config with type string, none given');
+        $container->getObject(LogStreamHandler::class);
+    }
+
+    public function testGetObjectThrowsIfFactoryFunctionHasClassArgumentWithConstructorThatRequiresContainerConfig(): void
     {
-        $line = __LINE__ + 2;
         $container = new Container([
-            Container::class => function (Container $container): Container {
-                return $container;
+            AccessLogHandler::class => function (LogStreamHandler $log) {
+                return new AccessLogHandler();
             }
         ]);
 
         $this->expectException(\Error::class);
-        $this->expectExceptionMessage('Argument #1 ($container) of {closure:' . __FILE__ . ':' . $line .'}() for FrameworkX\Container is recursive');
-        $container->getObject(Container::class);
+        $this->expectExceptionMessage('Argument #1 ($path) of ' . LogStreamHandler::class . '::__construct() requires container config with type string, none given');
+        $container->getObject(AccessLogHandler::class);
     }
 
     public function testGetObjectThrowsIfConfigReferencesInterface(): void