Add CallableFactory

Author: coisa

src/Exception/RuntimeException.php

@@ -65,4 +65,22 @@ public static function forNonPublicMethod(string $class, string $method): self
             $method
         ));
     }
+
+    /**
+     * Creates an exception for an invalid parameter type.
+     *
+     * This method MUST be used when a parameter expected to represent a class name
+     * or interface name does not satisfy this constraint.
+     *
+     * @param string $parameter the name of the parameter with the invalid type
+     *
+     * @return self a RuntimeException instance with a descriptive message
+     */
+    public static function forInvalidParameterType(string $parameter): self
+    {
+        return new self(\sprintf(
+            'Parameter "%s" is not a valid type. It MUST be a class name or an interface name.',
+            $parameter
+        ));
+    }
 }

src/Factory/CallableFactory.php

@@ -15,6 +15,7 @@
 
 namespace FastForward\Container\Factory;
 
+use FastForward\Container\Exception\RuntimeException;
 use Psr\Container\ContainerInterface;
 
 /**
@@ -55,6 +56,32 @@ public function __construct(callable $callable)
      */
     public function __invoke(ContainerInterface $container): mixed
     {
-        return \call_user_func($this->callable, $container);
+        $arguments = $this->getArguments($container, new \ReflectionFunction($this->callable));
+
+        return $this->callable->call($container, ...$arguments);
+    }
+
+    /**
+     * Retrieves the arguments for the callable from the container.
+     *
+     * @param ContainerInterface  $container the PSR-11 container for dependency resolution
+     * @param \ReflectionFunction $function  the reflection function of the callable
+     *
+     * @return array the resolved arguments for the callable
+     */
+    private function getArguments(ContainerInterface $container, \ReflectionFunction $function): array
+    {
+        $arguments = [];
+
+        foreach ($function->getParameters() as $parameter) {
+            if (!$parameter->getType() || $parameter->getType()->isBuiltin()) {
+                throw RuntimeException::forInvalidParameterType($parameter->getName());
+            }
+
+            $className   = $parameter->getType()->getName();
+            $arguments[] = $container->get($className);
+        }
+
+        return $arguments;
     }
 }

src/functions.php

@@ -39,7 +39,7 @@
  * composed of all resolved sources.
  *
  * @param ConfigInterface|PsrContainerInterface|ServiceProviderInterface|string ...$initializers
- *      A variadic list of container initializers, optionally including config or provider classes.
+ *        A variadic list of container initializers, optionally including config or provider classes.
  *
  * @return ContainerInterface the composed and autowire-enabled container
  *

tests/ContainerFunctionTest.php

@@ -45,13 +45,6 @@ final class ContainerFunctionTest extends TestCase
 {
     use ProphecyTrait;
 
-    private string $configKey;
-
-    protected function setUp(): void
-    {
-        $this->configKey = \sprintf('%s.%s', ConfigContainer::ALIAS, ContainerInterface::class);
-    }
-
     public function testReturnsAutowireContainerWrappingAggregate(): void
     {
         $result = container();
@@ -86,8 +79,8 @@ public function testAcceptsServiceProviderAsInitializer(): void
     public function testAcceptsConfigInterfaceAsInitializer(): void
     {
         $config = $this->prophesize(ConfigInterface::class);
-        $config->has($this->configKey)->willReturn(true);
-        $config->get($this->configKey)->willReturn([]);
+        $config->has(ContainerInterface::class)->willReturn(true);
+        $config->get(ContainerInterface::class)->willReturn([]);
 
         $container = container($config->reveal());
 
@@ -115,8 +108,8 @@ public function testConfigContainerWithNestedInitializers(): void
         $nested = new DummyContainer();
 
         $config = $this->prophesize(ConfigInterface::class);
-        $config->has($this->configKey)->willReturn(true);
-        $config->get($this->configKey)->willReturn([$nested]);
+        $config->has(ContainerInterface::class)->willReturn(true);
+        $config->get(ContainerInterface::class)->willReturn([$nested]);
 
         $container = container($config->reveal());
 
@@ -126,8 +119,8 @@ public function testConfigContainerWithNestedInitializers(): void
     public function testContainerSkipsThrowableThrownByConfigContainer(): void
     {
         $config = $this->prophesize(ConfigInterface::class);
-        $config->has($this->configKey)->willReturn(true);
-        $config->get($this->configKey)->willThrow(new \RuntimeException('unexpected'));
+        $config->has(ContainerInterface::class)->willReturn(true);
+        $config->get(ContainerInterface::class)->willThrow(new \RuntimeException('unexpected'));
 
         $container = container($config->reveal());
 

tests/Exception/RuntimeExceptionTest.php

@@ -46,4 +46,15 @@ public function testForNonPublicMethodReturnsProperException(): void
             $exception->getMessage()
         );
     }
+
+    public function testForInvalidParameterTypeReturnsProperException(): void
+    {
+        $exception = RuntimeException::forInvalidParameterType('logger');
+
+        self::assertInstanceOf(RuntimeException::class, $exception);
+        self::assertSame(
+            'Parameter "logger" is not a valid type. It MUST be a class name or an interface name.',
+            $exception->getMessage()
+        );
+    }
 }

tests/Factory/CallableFactoryTest.php

@@ -15,8 +15,12 @@
 
 namespace FastForward\Container\Tests\Factory;
 
+use FastForward\Container\Exception\RuntimeException;
 use FastForward\Container\Factory\CallableFactory;
+use FastForward\Container\Factory\FactoryInterface;
+use Interop\Container\ServiceProviderInterface;
 use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\UsesClass;
 use PHPUnit\Framework\TestCase;
 use Prophecy\PhpUnit\ProphecyTrait;
 use Psr\Container\ContainerInterface;
@@ -25,30 +29,62 @@
  * @internal
  */
 #[CoversClass(CallableFactory::class)]
+#[UsesClass(RuntimeException::class)]
 final class CallableFactoryTest extends TestCase
 {
     use ProphecyTrait;
 
-    public function testInvokeExecutesProvidedClosure(): void
+    public function testInvokeWillReturnProvidedCallableReturns(): void
     {
         $container = $this->prophesize(ContainerInterface::class)->reveal();
 
-        $factory = new CallableFactory(static fn (ContainerInterface $c) => (object) ['resolved' => true]);
+        $factory = new CallableFactory(fn () => (object) ['resolved' => true]);
 
         $result = $factory($container);
 
         self::assertIsObject($result);
         self::assertTrue($result->resolved);
     }
 
-    public function testClosureReceivesContainerAsArgument(): void
+    public function testInvokeWillBindToContainer(): void
     {
-        $expected = $this->prophesize(ContainerInterface::class)->reveal();
+        $container = $this->prophesize(ContainerInterface::class);
+        $expected  = $container->reveal();
 
-        $factory = new CallableFactory(static fn (ContainerInterface $container) => $container);
+        $factory = new CallableFactory(fn () => $this);
 
         $actual = $factory($expected);
 
         self::assertSame($expected, $actual);
     }
+
+    public function testClosureReceivesContainerDependenciesAsArgument(): void
+    {
+        $container        = $this->prophesize(ContainerInterface::class);
+        $factoryInterface = $this->prophesize(FactoryInterface::class)->reveal();
+        $serviceProvider  = $this->prophesize(ServiceProviderInterface::class)->reveal();
+
+        $container->get(ServiceProviderInterface::class)->willReturn($serviceProvider);
+        $container->get(FactoryInterface::class)->willReturn($factoryInterface);
+
+        $factory = new CallableFactory(fn (
+            ServiceProviderInterface $serviceProvider,
+            FactoryInterface $factoryInterface
+        ) => compact('serviceProvider', 'factoryInterface'));
+
+        $actual = $factory($container->reveal());
+
+        self::assertSame(compact('serviceProvider', 'factoryInterface'), $actual);
+    }
+
+    public function testInvokeWillThrowRuntimeExceptionIfParameterIsNotAClass(): void
+    {
+        $container = $this->prophesize(ContainerInterface::class)->reveal();
+
+        $factory = new CallableFactory(fn (string $notAClass) => $notAClass);
+
+        $this->expectException(RuntimeException::class);
+
+        $factory($container);
+    }
 }