Add object by class from container in MethodFactory

Author: coisa

src/Factory/MethodFactory.php

@@ -84,6 +84,12 @@ public function __invoke(ContainerInterface $container): mixed
             return $reflectionMethod->invokeArgs(null, $arguments);
         }
 
-        return $reflectionMethod->invokeArgs(new ($this->class)(), $arguments);
+        try {
+            $object = $container->get($this->class);
+        } catch (\Throwable) {
+            $object = new ($this->class)();
+        }
+
+        return $reflectionMethod->invokeArgs($object, $arguments);
     }
 }

tests/Factory/MethodFactoryTest.php

@@ -2,17 +2,6 @@
 
 declare(strict_types=1);
 
-/**
- * This file is part of php-fast-forward/container.
- *
- * This source file is subject to the license bundled
- * with this source code in the file LICENSE.
- *
- * @link      https://github.com/php-fast-forward/container
- * @copyright Copyright (c) 2025 Felipe Sayão Lobato Abreu <github@mentordosnerds.com>
- * @license   https://opensource.org/licenses/MIT MIT License
- */
-
 namespace FastForward\Container\Tests\Factory;
 
 use FastForward\Container\Exception\RuntimeException;
@@ -23,9 +12,6 @@
 use Prophecy\PhpUnit\ProphecyTrait;
 use Psr\Container\ContainerInterface;
 
-/**
- * @internal
- */
 #[CoversClass(MethodFactory::class)]
 #[UsesClass(RuntimeException::class)]
 final class MethodFactoryTest extends TestCase
@@ -34,14 +20,14 @@ final class MethodFactoryTest extends TestCase
 
     public function testInvokeInstanceMethod(): void
     {
-        $service = new MethodTarget();
+        $service = new MethodFactoryTestTargetStub();
 
         $container = $this->prophesize(ContainerInterface::class);
         $container->has('prefix')->willReturn(false);
-        $container->has(MethodTarget::class)->willReturn(true);
-        $container->get(MethodTarget::class)->willReturn($service);
+        $container->has(MethodFactoryTestTargetStub::class)->willReturn(true);
+        $container->get(MethodFactoryTestTargetStub::class)->willReturn($service);
 
-        $factory = new MethodFactory(MethodTarget::class, 'instanceMethod', 'prefix');
+        $factory = new MethodFactory(MethodFactoryTestTargetStub::class, 'instanceMethod', 'prefix');
 
         $result = $factory($container->reveal());
 
@@ -51,10 +37,9 @@ public function testInvokeInstanceMethod(): void
     public function testInvokeStaticMethod(): void
     {
         $container = $this->prophesize(ContainerInterface::class);
-        $container->has(MethodTarget::class)->willReturn(false);
         $container->has('value')->willReturn(false);
 
-        $factory = new MethodFactory(MethodTarget::class, 'staticMethod', 'value');
+        $factory = new MethodFactory(MethodFactoryTestTargetStub::class, 'staticMethod', 'value');
 
         $result = $factory($container->reveal());
 
@@ -63,16 +48,16 @@ public function testInvokeStaticMethod(): void
 
     public function testInvokeResolvesArgumentsFromContainer(): void
     {
-        $service = new MethodTarget();
+        $service = new MethodFactoryTestTargetStub();
         $argObj  = new \stdClass();
 
         $container = $this->prophesize(ContainerInterface::class);
-        $container->has(MethodTarget::class)->willReturn(true);
-        $container->get(MethodTarget::class)->willReturn($service);
+        $container->has(MethodFactoryTestTargetStub::class)->willReturn(true);
+        $container->get(MethodFactoryTestTargetStub::class)->willReturn($service);
         $container->has('dependency')->willReturn(true);
         $container->get('dependency')->willReturn($argObj);
 
-        $factory = new MethodFactory(MethodTarget::class, 'acceptsObject', 'dependency');
+        $factory = new MethodFactory(MethodFactoryTestTargetStub::class, 'acceptsObject', 'dependency');
 
         $result = $factory($container->reveal());
 
@@ -81,23 +66,50 @@ public function testInvokeResolvesArgumentsFromContainer(): void
 
     public function testInvokeThrowsForNonPublicMethod(): void
     {
-        $service = new MethodTarget();
-
         $container = $this->prophesize(ContainerInterface::class);
-        $container->has(MethodTarget::class)->willReturn(true);
-        $container->get(MethodTarget::class)->willReturn($service);
+        $container->has(MethodFactoryTestTargetStub::class)->willReturn(false);
 
-        $factory = new MethodFactory(MethodTarget::class, 'privateMethod');
+        $factory = new MethodFactory(MethodFactoryTestTargetStub::class, 'privateMethod');
 
         $this->expectException(RuntimeException::class);
-        $this->expectExceptionMessage('Method "FastForward\Container\Tests\Factory\MethodTarget::privateMethod" MUST be public to be invoked as a service.');
 
         $factory($container->reveal());
     }
+
+    public function testInvokeWillConstructTargetIfContainerDoesNotProvide(): void
+    {
+        $container = $this->prophesize(ContainerInterface::class);
+        $container->has('prefix')->willReturn(false);
+        $container->get(MethodFactoryTestTargetStub::class)->willThrow(new \Exception());
+
+        $factory = new MethodFactory(MethodFactoryTestTargetStub::class, 'instanceMethod', 'prefix');
+
+        $result = $factory($container->reveal());
+
+        self::assertSame('prefix-instance', $result);
+    }
+
+    public function testConstructorDependencyIsResolvedFromContainer(): void
+    {
+        $dependency = new MethodFactoryTestDependencyStub();
+
+        $container = $this->prophesize(ContainerInterface::class);
+        $container->has(MethodFactoryTestTargetStub::class)->willReturn(true);
+        $container->get(MethodFactoryTestTargetStub::class)->willReturn(new MethodFactoryTestTargetStub($dependency))->shouldBeCalledOnce();
+        $container->has('suffix')->willReturn(false);
+
+        $factory = new MethodFactory(MethodFactoryTestTargetStub::class, 'usesConstructorArgument', 'suffix');
+
+        $result = $factory($container->reveal());
+
+        self::assertSame(MethodFactoryTestDependencyStub::class . '-suffix', $result);
+    }
 }
 
-class MethodTarget
+class MethodFactoryTestTargetStub
 {
+    public function __construct(private ?MethodFactoryTestDependencyStub $dependency = null) {}
+
     public function instanceMethod(string $prefix): string
     {
         return $prefix . '-instance';
@@ -113,5 +125,14 @@ public function acceptsObject(object $obj): object
         return $obj;
     }
 
+    public function usesConstructorArgument(string $suffix): string
+    {
+        return $this->dependency::class . '-' . $suffix;
+    }
+
     private function privateMethod(): void {}
 }
+
+class MethodFactoryTestDependencyStub
+{
+}