Implement semantic bindings with Value Objects

Convert string-based binding information to structured VOs:
- Add BindingInfo and AopInfo VOs in Bindings/ namespace
- Replace string parsing with direct VO access in ModuleBindings
- Extend SpyCompiler to provide AopInfo directly from dependencies
- Update JSON schema to reflect new VO structure
- Maintain type safety and machine-readable binding information

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: koriym

binding-schema.json

@@ -0,0 +1,56 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Ray.Di BindingInfo Schema",
+  "description": "Schema for Ray.Di BindingInfo Value Objects",
+  "type": "array",
+  "items": {
+    "$ref": "#/definitions/bindingInfo"
+  },
+  "definitions": {
+    "bindingInfo": {
+      "type": "object",
+      "required": ["interface", "named", "type", "target"],
+      "properties": {
+        "interface": {
+          "type": "string",
+          "description": "The interface or class being bound"
+        },
+        "named": {
+          "type": ["string", "null"],
+          "description": "Named binding identifier (null if not named)"
+        },
+        "type": {
+          "type": "string",
+          "enum": ["to", "toProvider", "toInstance"],
+          "description": "The type of binding"
+        },
+        "target": {
+          "oneOf": [
+            {
+              "type": "string",
+              "description": "Target class name for 'to' or 'toProvider' bindings"
+            },
+            {
+              "type": ["string", "number", "boolean", "null"],
+              "description": "Instance value for 'toInstance' bindings"
+            }
+          ],
+          "description": "The target of the binding"
+        },
+        "aop": {
+          "type": "object",
+          "description": "AOP method bindings from AopInfo VO",
+          "additionalProperties": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "description": "Interceptor class name"
+            },
+            "description": "List of interceptors for this method"
+          }
+        }
+      },
+      "additionalProperties": false
+    }
+  }
+}

demo-bindings.php

@@ -0,0 +1,81 @@
+<?php
+
+declare(strict_types=1);
+
+use Ray\Di\AbstractModule;
+use Ray\Di\Container;
+use Ray\Di\Injector;
+use Ray\Di\ModuleBindings;
+use Ray\Di\ModuleString;
+use Ray\Di\Fake\FakeAopInterface;
+use Ray\Di\Fake\FakeAop;
+use Ray\Di\FakeDoubleInterceptor;
+
+require __DIR__ . '/vendor/autoload.php';
+
+// Example module with AOP
+class DemoAopModule extends AbstractModule
+{
+    protected function configure(): void
+    {
+        // Standard binding
+        $this->bind(FakeAopInterface::class)->to(FakeAop::class);
+        
+        // Named binding
+        $this->bind(FakeAopInterface::class)
+            ->annotatedWith('special')
+            ->to(FakeAop::class);
+        
+        // AOP binding - bind interceptor to all methods of FakeAop
+        $this->bindInterceptor(
+            $this->matcher->subclassesOf(FakeAop::class),
+            $this->matcher->any(),
+            [FakeDoubleInterceptor::class]
+        );
+    }
+}
+
+// Create injector and get container
+$module = new DemoAopModule();
+$injector = new Injector($module);
+$container = $injector->getContainer();
+
+// Get pointcuts for AOP
+$pointcuts = $container->getPointcuts();
+
+echo "=== Traditional ModuleString Output ===\n";
+$moduleString = new ModuleString();
+$output = $moduleString($container, $pointcuts);
+echo $output . "\n\n";
+
+echo "=== Machine-Readable ModuleBindings Output ===\n";
+$moduleBindings = new ModuleBindings();
+$bindings = $moduleBindings($container, $pointcuts);
+
+// Display as formatted JSON
+$json = json_encode($bindings, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);
+echo $json . "\n\n";
+
+// Show specific examples
+echo "=== Individual Binding Examples ===\n";
+foreach ($bindings as $binding) {
+    echo sprintf(
+        "Interface: %s\n  Named: %s\n  Type: %s\n  Target: %s\n",
+        $binding['interface'],
+        $binding['named'] ?? '(none)',
+        $binding['type'],
+        is_string($binding['target']) ? $binding['target'] : json_encode($binding['target'])
+    );
+    
+    if (isset($binding['aop'])) {
+        echo "  AOP Bindings:\n";
+        foreach ($binding['aop'] as $method => $interceptors) {
+            echo sprintf(
+                "    Method '%s': %s\n",
+                $method,
+                implode(', ', $interceptors)
+            );
+        }
+    }
+    echo "\n";
+}

demo-vo.php

@@ -0,0 +1,32 @@
+<?php
+
+require __DIR__ . '/vendor/autoload.php';
+
+use Ray\Di\AbstractModule;
+use Ray\Di\ModuleBindings;
+
+$module = new class extends AbstractModule {
+    protected function configure(): void
+    {
+        $this->bind('')->annotatedWith('app_name')->toInstance('MyApp');
+        $this->bind('')->annotatedWith('version')->toInstance('1.0.0');
+    }
+};
+
+$container = $module->getContainer();
+$moduleBindings = new ModuleBindings();
+$bindings = $moduleBindings($container, []);
+
+echo "=== BindingInfo Value Objects ===\n";
+foreach ($bindings as $binding) {
+    echo sprintf(
+        "Interface: '%s', Named: '%s', Type: %s, Target: %s\n",
+        $binding->interface,
+        $binding->named ?? 'null',
+        $binding->type,
+        json_encode($binding->target)
+    );
+}
+
+echo "\n=== JSON Serialized ===\n";
+echo json_encode($bindings, JSON_PRETTY_PRINT);

src/di/BindInterface.php

@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ray\Di;
+
+interface BindInterface
+{
+    public function __toString(): string;
+
+    public function annotatedWith(string $name): self;
+
+    /**
+     * @param class-string $class
+     */
+    public function to(string $class): self;
+
+    /**
+     * @param class-string<T> $class
+     *
+     * @template T of object
+     */
+    public function toConstructor(string $class, string $name, ?InjectionPoints $injectionPoints = null, ?string $postConstruct = null): self;
+
+    /**
+     * @phpstan-param class-string $provider
+     */
+    public function toProvider(string $provider, string $context = ''): self;
+
+    public function toInstance(object $instance): self;
+
+    public function toNull(): self;
+
+    public function in(string $scope): self;
+
+    public function getBound(): DependencyInterface;
+
+    public function setBound(DependencyInterface $bound): void;
+}

src/di/Bindings/AopInfo.php

@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ray\Di\Bindings;
+
+/**
+ * Value object representing AOP binding information
+ */
+final class AopInfo
+{
+    /** @var array<string, list<string>> */
+    public $methodBindings;
+
+    /**
+     * @param array<string, list<string>|list<object>> $methodBindings
+     */
+    public function __construct(array $methodBindings)
+    {
+        // Convert objects to string representations if needed
+        $stringBindings = [];
+        foreach ($methodBindings as $method => $interceptors) {
+            $stringBindings[$method] = array_map('strval', $interceptors);
+        }
+        $this->methodBindings = $stringBindings;
+    }
+
+    /**
+     * Check if any AOP bindings exist
+     */
+    public function hasBindings(): bool
+    {
+        return !empty($this->methodBindings);
+    }
+
+    /**
+     * Convert to string representation for compatibility
+     */
+    public function __toString(): string
+    {
+        if (!$this->hasBindings()) {
+            return '';
+        }
+
+        $log = ' (aop)';
+        foreach ($this->methodBindings as $method => $interceptors) {
+            $log .= \sprintf(
+                ' +%s(%s)',
+                $method,
+                \implode(', ', $interceptors)
+            );
+        }
+
+        return $log;
+    }
+}

src/di/Bindings/BindingInfo.php

@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ray\Di\Bindings;
+
+use JsonSerializable;
+
+/**
+ * Value object representing a dependency injection binding
+ */
+final class BindingInfo implements JsonSerializable
+{
+    /** @var string */
+    public $interface;
+
+    /** @var string|null */
+    public $named;
+
+    /** @var string */
+    public $type;
+
+    /** @var mixed */
+    public $target;
+
+    /** @var array<string, list<string>>|null */
+    public $aop;
+
+    /**
+     * @param string $interface
+     * @param string|null $named
+     * @param string $type
+     * @param mixed $target
+     * @param array<string, list<string>>|null $aop
+     */
+    public function __construct(
+        string $interface,
+        ?string $named,
+        string $type,
+        $target,
+        ?array $aop = null
+    ) {
+        $this->interface = $interface;
+        $this->named = $named;
+        $this->type = $type;
+        $this->target = $target;
+        $this->aop = $aop;
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    public function jsonSerialize(): array
+    {
+        $data = [
+            'interface' => $this->interface,
+            'named' => $this->named,
+            'type' => $this->type,
+            'target' => $this->target,
+        ];
+
+        if ($this->aop !== null) {
+            $data['aop'] = $this->aop;
+        }
+
+        return $data;
+    }
+}

src/di/Dependency.php

@@ -8,6 +8,7 @@
 use Ray\Aop\CompilerInterface;
 use Ray\Aop\MethodInterceptor;
 use Ray\Aop\WeavedInterface;
+use Ray\Di\Bindings\AopInfo;
 use ReflectionClass;
 use ReflectionMethod;
 
@@ -33,6 +34,9 @@ final class Dependency implements DependencyInterface, AcceptInterface
     /** @var ?mixed */
     private $instance;
 
+    /** @var ?AopInfo */
+    private $aopInfo;
+
     public function __construct(NewInstance $newInstance, ?ReflectionMethod $postConstruct = null)
     {
         $this->newInstance = $newInstance;
@@ -142,10 +146,23 @@ public function weaveAspects(CompilerInterface $compiler, array $pointcuts): voi
             return;
         }
 
+        // Store AOP info for later retrieval
+        if ($compiler instanceof SpyCompiler) {
+            $this->aopInfo = $compiler->getAopInfo($bind);
+        }
+
         $class = $compiler->compile($className, $bind);
         $this->newInstance->weaveAspects($class, $bind);
     }
 
+    /**
+     * Get AOP information if available
+     */
+    public function getAopInfo(): ?AopInfo
+    {
+        return $this->aopInfo;
+    }
+
     /** @inheritDoc */
     public function accept(VisitorInterface $visitor)
     {