v3 base

src/StaticPHP/DI/CallbackInvoker.php

@@ -0,0 +1,98 @@
+<?php
+
+declare(strict_types=1);
+
+namespace StaticPHP\DI;
+
+use DI\Container;
+
+/**
+ * CallbackInvoker is responsible for invoking callbacks with automatic dependency injection.
+ * It supports context-based parameter resolution, allowing temporary bindings without polluting the container.
+ */
+class CallbackInvoker
+{
+    public function __construct(
+        private Container $container
+    ) {}
+
+    /**
+     * Invoke a callback with automatic dependency injection.
+     *
+     * Resolution order for each parameter:
+     * 1. Context array (by type name)
+     * 2. Context array (by parameter name)
+     * 3. Container (by type)
+     * 4. Default value
+     * 5. Null (if nullable)
+     *
+     * @param callable $callback The callback to invoke
+     * @param array    $context  Context parameters (type => value or name => value)
+     *
+     * @return mixed The return value of the callback
+     *
+     * @throws \RuntimeException If a required parameter cannot be resolved
+     */
+    public function invoke(callable $callback, array $context = []): mixed
+    {
+        $reflection = new \ReflectionFunction(\Closure::fromCallable($callback));
+        $args = [];
+
+        foreach ($reflection->getParameters() as $param) {
+            $type = $param->getType();
+            $typeName = $type instanceof \ReflectionNamedType ? $type->getName() : null;
+            $paramName = $param->getName();
+
+            // 1. Look up by type name in context
+            if ($typeName !== null && array_key_exists($typeName, $context)) {
+                $args[] = $context[$typeName];
+                continue;
+            }
+
+            // 2. Look up by parameter name in context
+            if (array_key_exists($paramName, $context)) {
+                $args[] = $context[$paramName];
+                continue;
+            }
+
+            // 3. Look up in container by type
+            if ($typeName !== null && !$this->isBuiltinType($typeName) && $this->container->has($typeName)) {
+                $args[] = $this->container->get($typeName);
+                continue;
+            }
+
+            // 4. Use default value if available
+            if ($param->isDefaultValueAvailable()) {
+                $args[] = $param->getDefaultValue();
+                continue;
+            }
+
+            // 5. Allow null if nullable
+            if ($param->allowsNull()) {
+                $args[] = null;
+                continue;
+            }
+
+            // Cannot resolve parameter
+            throw new \RuntimeException(
+                "Cannot resolve parameter '{$paramName}'" .
+                ($typeName ? " of type '{$typeName}'" : '') .
+                ' for callback invocation'
+            );
+        }
+
+        return $callback(...$args);
+    }
+
+    /**
+     * Check if a type name is a PHP builtin type.
+     */
+    private function isBuiltinType(string $typeName): bool
+    {
+        return in_array($typeName, [
+            'string', 'int', 'float', 'bool', 'array',
+            'object', 'callable', 'iterable', 'mixed',
+            'void', 'null', 'false', 'true', 'never',
+        ], true);
+    }
+}