Add Container->resolve(Closure)

CHANGELOG.md

@@ -3,6 +3,7 @@
 ## Unreleased
 
 - Accept `Closure|string` in `getParametersToResolve()`
+- Added `resolve(callable)` to `ContainerInterface`
 
 ## 0.4.0
 ### 2023-04-27

README.md

@@ -51,6 +51,13 @@ $bindings = [
 $container = new Container($bindings);
 
 $instance = $container->get(YourClass::class);
+
+//////////////////////////////////////////////
+# Extra: you can resolve closures on-the-fly using the container bindings
+$resolved = $container->resolve(function (ComplexInterface $i) {
+    // your custom logic
+    return $i->...; 
+});
 ```
 
 ### Example

src/Container/Container.php

@@ -6,6 +6,7 @@
 
 use Closure;
 use Gacela\Container\Exception\ContainerException;
+use ReflectionFunction;
 use SplObjectStorage;
 
 use function count;
@@ -17,7 +18,7 @@ class Container implements ContainerInterface
 {
     private ?DependencyResolver $dependencyResolver = null;
 
-    /** @var array<class-string,list<mixed>> */
+    /** @var array<class-string|string, list<mixed>> */
     private array $cachedDependencies = [];
 
     /** @var array<string,mixed> */
@@ -84,6 +85,22 @@ public function get(string $id): mixed
         return $this->createInstance($id);
     }
 
+    public function resolve(callable $callable): mixed
+    {
+        $callable = Closure::fromCallable($callable);
+        $reflectionFn = new ReflectionFunction($callable);
+        $callableKey = md5(serialize($reflectionFn->__toString()));
+
+        if (!isset($this->cachedDependencies[$callableKey])) {
+            $this->cachedDependencies[$callableKey] = $this
+                ->getDependencyResolver()
+                ->resolveDependencies($callable);
+        }
+
+        /** @psalm-suppress MixedMethodCall */
+        return $callable(...$this->cachedDependencies[$callableKey]);
+    }
+
     public function factory(Closure $instance): Closure
     {
         $this->factoryInstances->attach($instance);

src/Container/ContainerInterface.php

@@ -15,6 +15,11 @@ interface ContainerInterface extends PsrContainerInterface
      */
     public function get(string $id): mixed;
 
+    /**
+     * Resolve the callable loading automatically all arguments based on current bindings.
+     */
+    public function resolve(callable $callable): mixed;
+
     /**
      * Check if an instance exists.
      */

tests/Unit/ContainerTest.php → tests/Unit/ClassContainerTest.php

@@ -17,7 +17,7 @@
 use GacelaTest\Fake\PersonInterface;
 use PHPUnit\Framework\TestCase;
 
-final class ContainerTest extends TestCase
+final class ClassContainerTest extends TestCase
 {
     public function test_static_create_without_dependencies(): void
     {

tests/Unit/ClosureContainerTest.php

@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+namespace GacelaTest\Unit;
+
+use Gacela\Container\Container;
+use GacelaTest\Fake\ClassWithInterfaceDependencies;
+use GacelaTest\Fake\ClassWithoutDependencies;
+use GacelaTest\Fake\ClassWithRelationship;
+use GacelaTest\Fake\Person;
+use GacelaTest\Fake\PersonInterface;
+use PHPUnit\Framework\TestCase;
+
+final class ClosureContainerTest extends TestCase
+{
+    public function test_static_create_without_dependencies(): void
+    {
+        $container = new Container();
+
+        $actual = $container->resolve(static fn () => '');
+
+        self::assertSame('', $actual);
+    }
+
+    public function test_static_resolve_callable_with_inner_dependencies_without_dependencies(): void
+    {
+        $container = new Container();
+
+        $actual = $container->resolve(
+            static fn (ClassWithoutDependencies $object) => serialize($object),
+        );
+
+        self::assertEquals(
+            new ClassWithoutDependencies(),
+            unserialize($actual),
+        );
+    }
+
+    public function test_static_resolve_callable_with_inner_dependencies_with_many_dependencies(): void
+    {
+        $container = new Container();
+
+        $actual = $container->resolve(
+            static fn (ClassWithRelationship $object) => serialize($object),
+        );
+
+        self::assertEquals(
+            new ClassWithRelationship(new Person(), new Person()),
+            unserialize($actual),
+        );
+    }
+
+    public function test_use_mapped_interface_dependency(): void
+    {
+        $container = new Container([
+            PersonInterface::class => Person::class,
+        ]);
+
+        $actual = $container->resolve(
+            static fn (ClassWithInterfaceDependencies $object) => serialize($object),
+        );
+
+        self::assertEquals(
+            new ClassWithInterfaceDependencies(new Person()),
+            unserialize($actual),
+        );
+    }
+
+    public function test_resolve_object_from_callable(): void
+    {
+        $person = new Person();
+        $person->name = 'person-name';
+
+        $container = new Container([
+            PersonInterface::class => static fn () => $person,
+        ]);
+
+        $actual = $container->resolve(
+            static fn (PersonInterface $object) => serialize($object),
+        );
+
+        self::assertEquals($person, unserialize($actual));
+    }
+}