Merge pull request #9 from SergiX44/fix_for_variadic

fix variadic resolve

src/Container.php

@@ -32,7 +32,7 @@ public function __construct()
     /**
      * @template T
      *
-     * @param class-string<T> $id
+     * @param  class-string<T>  $id
      * @return T
      *
      * @inheritDoc
@@ -132,7 +132,7 @@ public function call(callable|string|array $callable, array $arguments = []): mi
     }
 
     /**
-     * @param string $class
+     * @param  string  $class
      * @return object|string|null
      *
      * @throws ContainerException
@@ -155,7 +155,7 @@ protected function resolve(string $class): object|string|null
     }
 
     /**
-     * @param ReflectionParameter[] $parameters
+     * @param  ReflectionParameter[]  $parameters
      * @return array|null[]|object[]|string[]
      *
      * @throws ContainerException
@@ -167,20 +167,29 @@ protected function getArguments(array $parameters, $additional = []): array
     {
         $positionalArgs = array_filter($additional, 'is_numeric', ARRAY_FILTER_USE_KEY);
 
-        return array_map(function (ReflectionParameter $param) use (&$additional, &$positionalArgs) {
+        $resolved = [];
+        foreach ($parameters as $param) {
             $type = $param->getType()?->getName();
 
-            return match (true) {
+            // variadic parameters can only be the last one
+            if ($param->isVariadic()) {
+                $resolved = array_merge($resolved, $additional[$param->getName()] ?? $positionalArgs);
+                break;
+            }
+
+            $resolved[] = match (true) {
                 $type !== null && $this->has($type) => $this->get($type), // via definitions
                 array_key_exists(
                     $param->getName(),
                     $additional
                 ) => $additional[$param->getName()], // defined by the user
                 !empty($positionalArgs) => array_shift($positionalArgs),
-                $param->isOptional() => $param->getDefaultValue(), // use default when available
+                $param->isOptional() && $param->isDefaultValueAvailable() => $param->getDefaultValue(), // use default when available
                 $type !== null && class_exists($type) && !enum_exists($type) => $this->resolve($type), // via reflection
                 default => throw ContainerException::parameterNotResolvable($param),
             };
-        }, $parameters);
+        }
+
+        return $resolved;
     }
 }

src/Exception/ContainerException.php

@@ -15,7 +15,7 @@ public static function invalidDefinition(string $id): self
 
     public static function parameterNotResolvable(ReflectionParameter $param): self
     {
-        return new self("Cannot resolve constructor parameter '\${$param->getName()}::{$param->getDeclaringClass()?->getName()}'");
+        return new self("Cannot resolve parameter '\${$param->getName()}::{$param->getDeclaringClass()?->getName()}'");
     }
 
     public static function invalidCallable(): self

tests/Feature/ContainerCallTest.php

@@ -177,3 +177,35 @@
         'z' => 'zzzz',
     ]);
 })->expectException(ContainerException::class);
+
+it('can resolve a call a closure with arguments and variadic', function () {
+    $container = new Container();
+    $container->bind(SimpleInterface::class, SimpleClass::class);
+
+    $f = function (SimpleInterface $simple, string ...$z) {
+        return [$simple, $z];
+    };
+
+    $result = $container->call($f, ['eee', 'aaa', 'zzz']);
+
+    expect($result)->sequence(
+        fn ($e) => $e->toBeInstanceOf(SimpleClass::class),
+        fn ($e) => $e->toBe(['eee', 'aaa', 'zzz']),
+    );
+});
+
+it('can resolve a call a closure with arguments and no variadic', function () {
+    $container = new Container();
+    $container->bind(SimpleInterface::class, SimpleClass::class);
+
+    $f = function (SimpleInterface $simple, string ...$z) {
+        return [$simple, $z];
+    };
+
+    $result = $container->call($f);
+
+    expect($result)->sequence(
+        fn ($e) => $e->toBeInstanceOf(SimpleClass::class),
+        fn ($e) => $e->toBe([]),
+    );
+});

tests/Feature/ContainerResolveTest.php

@@ -8,7 +8,9 @@
 use SergiX44\Container\Tests\Fixtures\Resolve\ConcreteClass;
 use SergiX44\Container\Tests\Fixtures\Resolve\MoreNestedClass;
 use SergiX44\Container\Tests\Fixtures\Resolve\NestedClass;
+use SergiX44\Container\Tests\Fixtures\Resolve\ResolvableClassWithConstant;
 use SergiX44\Container\Tests\Fixtures\Resolve\ResolvableClassWithDefault;
+use SergiX44\Container\Tests\Fixtures\Resolve\ResolvableClassWithEnum;
 use SergiX44\Container\Tests\Fixtures\Resolve\SimpleClass;
 use SergiX44\Container\Tests\Fixtures\Resolve\SimpleClassWithConstructor;
 use SergiX44\Container\Tests\Fixtures\Resolve\SimpleInterface;
@@ -51,6 +53,7 @@
         ->and($instance->more->r)->toBeInstanceOf(ResolvableClassWithDefault::class);
 });
 
+
 it('can resolve a definition with constructor', function () {
     $container = new Container();
 
@@ -98,6 +101,32 @@
         ->toBeInstanceOf(SimpleClass::class);
 });
 
+it('can resolve a definition with constructor default parameters as enum', function () {
+    $container = new Container();
+
+    $container->bind(SimpleInterface::class, SimpleClass::class);
+
+    $instance = $container->get(ResolvableClassWithEnum::class);
+
+    expect($instance)
+        ->toBeInstanceOf(ResolvableClassWithEnum::class)
+        ->and($instance->simple)
+        ->toBeInstanceOf(SimpleClass::class);
+});
+
+it('can resolve a definition with constructor default parameters as const', function () {
+    $container = new Container();
+
+    $container->bind(SimpleInterface::class, SimpleClass::class);
+
+    $instance = $container->get(ResolvableClassWithConstant::class);
+
+    expect($instance)
+        ->toBeInstanceOf(ResolvableClassWithConstant::class)
+        ->and($instance->simple)
+        ->toBeInstanceOf(SimpleClass::class);
+});
+
 it('can resolve a definition with a callable', function () {
     $container = new Container();
 

tests/Fixtures/Resolve/MyEnum.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace SergiX44\Container\Tests\Fixtures\Resolve;
+
+enum MyEnum: string
+{
+    case HEY = 'hey';
+    case HO = 'ho';
+}

tests/Fixtures/Resolve/ResolvableClassWithConstant.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace SergiX44\Container\Tests\Fixtures\Resolve;
+
+class ResolvableClassWithConstant
+{
+    private const MY_CONSTANT = 'my_constant';
+    public function __construct(public SimpleInterface $simple, public string $c = self::MY_CONSTANT)
+    {
+    }
+}

tests/Fixtures/Resolve/ResolvableClassWithEnum.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace SergiX44\Container\Tests\Fixtures\Resolve;
+
+class ResolvableClassWithEnum
+{
+    public function __construct(public SimpleInterface $simple, public MyEnum $enum = MyEnum::HEY)
+    {
+    }
+}