fix(container): support factories with 0, 1, or 2 arguments using reflection

Author: Fahl-Design

src/Container/SimpleContainer.php

@@ -5,11 +5,17 @@
 namespace WebProject\PhpOpenApiMockServer\Container;
 
 use function array_key_exists;
+use function class_exists;
+use Closure;
 use function is_array;
 use function is_callable;
 use function is_int;
+use function is_object;
 use function is_string;
 use Psr\Container\ContainerInterface;
+use ReflectionFunction;
+use ReflectionMethod;
+use function str_contains;
 use Webmozart\Assert\Assert;
 use WebProject\PhpOpenApiMockServer\Container\Exception\ContainerException;
 use WebProject\PhpOpenApiMockServer\Container\Exception\NotFoundException;
@@ -55,7 +61,21 @@ public function get(string $id): mixed
             throw new ContainerException("Factory for '{$resolved}' is not callable.");
         }
 
-        $instance = $factory($this, $resolved);
+        $reflection = match (true) {
+            $factory instanceof Closure                          => new ReflectionFunction($factory),
+            is_string($factory) && !str_contains($factory, '::') => new ReflectionFunction($factory),
+            is_string($factory) && str_contains($factory, '::')  => new ReflectionMethod($factory),
+            is_array($factory)                                   => new ReflectionMethod($factory[0], $factory[1]),
+            is_object($factory)                                  => new ReflectionMethod($factory, '__invoke'),
+            default                                              => throw new ContainerException("Unsupported factory type for '{$resolved}'."),
+        };
+
+        $params   = $reflection->getNumberOfParameters();
+        $instance = match (true) {
+            0 === $params => $factory(),
+            1 === $params => $factory($this),
+            default       => $factory($this, $resolved),
+        };
 
         if (isset($this->delegators[$resolved])) {
             foreach ($this->delegators[$resolved] as $delegator) {

tests/Unit/SimpleContainerFactoryTest.php

@@ -0,0 +1,84 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WebProject\PhpOpenApiMockServer\Tests\Unit;
+
+use Codeception\Test\Unit;
+use Psr\Container\ContainerInterface;
+use stdClass;
+use WebProject\PhpOpenApiMockServer\Container\SimpleContainer;
+
+class SimpleContainerFactoryTest extends Unit
+{
+    public function test0ArgClosureFactory(): void
+    {
+        $container = new SimpleContainer();
+        $container->setFactory('service', static function () {
+            return new stdClass();
+        });
+
+        $instance = $container->get('service');
+        self::assertInstanceOf(stdClass::class, $instance);
+    }
+
+    public function test1ArgClosureFactory(): void
+    {
+        $container = new SimpleContainer();
+        $container->setFactory('service', function ($container) {
+            $this->assertInstanceOf(ContainerInterface::class, $container);
+
+            return new stdClass();
+        });
+
+        $instance = $container->get('service');
+        self::assertInstanceOf(stdClass::class, $instance);
+    }
+
+    public function test2ArgClosureFactory(): void
+    {
+        $container = new SimpleContainer();
+        $container->setFactory('service', function ($container, $id) {
+            $this->assertInstanceOf(ContainerInterface::class, $container);
+            $this->assertSame('service', $id);
+
+            return new stdClass();
+        });
+
+        $instance = $container->get('service');
+        self::assertInstanceOf(stdClass::class, $instance);
+    }
+
+    public function testNative0ArgFunction(): void
+    {
+        $container = new SimpleContainer();
+        $container->setFactory('service', 'time');
+
+        $instance = $container->get('service');
+        self::assertIsInt($instance);
+    }
+
+    public function testInvokableClassFactory(): void
+    {
+        $container = new SimpleContainer();
+        $container->setInvokableClass('service', stdClass::class);
+
+        $instance = $container->get('service');
+        self::assertInstanceOf(stdClass::class, $instance);
+    }
+
+    public function test1ArgInvokableObjectFactory(): void
+    {
+        $container = new SimpleContainer();
+        $factory   = new class {
+            public function __invoke(ContainerInterface $container): stdClass
+            {
+                return new stdClass();
+            }
+        };
+        $container->setFactory('service', $factory);
+
+        $instance = $container->get('service');
+        self::assertInstanceOf(stdClass::class, $instance);
+    }
+}