wip

src/Attributes/FloatAttribute.php → src/Attributes/FloatAttr.php

@@ -20,7 +20,7 @@
 use function Chevere\Parameter\float;
 
 #[Attribute(Attribute::TARGET_PROPERTY | Attribute::TARGET_PARAMETER | Attribute::TARGET_CLASS_CONSTANT)]
-class FloatAttribute implements ParameterAttributeInterface
+class FloatAttr implements ParameterAttributeInterface
 {
     public readonly FloatParameterInterface $parameter;
 

src/Attributes/functions.php

@@ -47,7 +47,7 @@ function intAttr(string $name): IntAttr
     return parameterAttr($name, $caller);
 }
 
-function floatAttr(string $name): FloatAttribute
+function floatAttr(string $name): FloatAttr
 {
     $caller = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2)[1];
 
@@ -93,10 +93,12 @@ function arrayArguments(string $name): ArgumentsInterface
     $arguments = [];
     foreach ($parameters->keys() as $named) {
         $pos++;
-        $arguments[$named] = $args[$pos];
+        $arguments[$named] = match (true) {
+            array_key_exists($pos, $args) => $args[$pos],
+            default => $parameters->get($named)->default(),
+        };
     }
 
-    // @phpstan-ignore-next-line
     return $array->parameters()->__invoke(...$arguments[$name]);
 }
 
@@ -120,6 +122,9 @@ function valid(?string $name = null): void
     $arguments = [];
     foreach ($parameters->keys() as $named) {
         $pos++;
+        if (! isset($args[$pos])) {
+            continue;
+        }
         $arguments[$named] = $args[$pos];
     }
     if ($name === null) {
@@ -129,7 +134,11 @@ function valid(?string $name = null): void
     }
 
     try {
-        $parameters->get($name)->__invoke($arguments[$name]);
+        $parameter = $parameters->get($name);
+        if ($parameters->optionalKeys()->contains($name) && ! array_key_exists($name, $arguments)) {
+            return;
+        }
+        $parameter->__invoke($arguments[$name]);
     } catch (Throwable $e) {
         $invoker = $trace[0];
 

src/IterableParameter.php

@@ -18,6 +18,9 @@
 use Chevere\Parameter\Interfaces\TypeInterface;
 use Chevere\Parameter\Traits\ArrayParameterTrait;
 use Chevere\Parameter\Traits\ParameterTrait;
+use InvalidArgumentException;
+use Throwable;
+use function Chevere\Message\message;
 
 final class IterableParameter implements IterableParameterInterface
 {
@@ -47,7 +50,38 @@ final public function __construct(
      */
     public function __invoke(iterable $value): iterable
     {
-        return assertIterable($this, $value);
+        if (empty($value)) {
+            throw new InvalidArgumentException(
+                (string) message('Argument value provided is empty')
+            );
+        }
+        $iterable = ' *iterable';
+        $iterableKey = '_K' . $iterable;
+        $iterableValue = '_V' . $iterable;
+
+        try {
+            foreach ($value as $k => $v) {
+                assertNamedArgument($iterableKey, $this->key, $k);
+                assertNamedArgument($iterableValue, $this->value, $v);
+            }
+        } catch (Throwable $e) {
+            $message = $e->getMessage();
+            $strstr = strstr($message, ':', false);
+            if (! is_string($strstr)) {
+                $strstr = $message; // @codeCoverageIgnore
+            } else {
+                $strstr = substr($strstr, 2);
+            }
+            $calledIn = strpos($strstr, ', called in');
+
+            $message = $calledIn
+                ? substr($strstr, 0, $calledIn)
+                : $strstr;
+
+            throw new InvalidArgumentException($message);
+        }
+
+        return $value;
     }
 
     public function default(): ?iterable

src/NullParameter.php

@@ -15,7 +15,6 @@
 
 use Chevere\Parameter\Interfaces\NullParameterInterface;
 use Chevere\Parameter\Interfaces\TypeInterface;
-use Chevere\Parameter\Traits\ParameterDefaultNullTrait;
 use Chevere\Parameter\Traits\ParameterTrait;
 use Chevere\Parameter\Traits\SchemaTrait;
 use TypeError;
@@ -24,9 +23,11 @@
 final class NullParameter implements NullParameterInterface
 {
     use ParameterTrait;
-    use ParameterDefaultNullTrait;
     use SchemaTrait;
 
+    // @phpstan-ignore-next-line
+    private mixed $default;
+
     public function __invoke(mixed $value): mixed
     {
         if ($value === null) {
@@ -38,6 +39,19 @@ public function __invoke(mixed $value): mixed
         );
     }
 
+    public function default(): mixed
+    {
+        return null;
+    }
+
+    public function withDefault(mixed $null): NullParameterInterface
+    {
+        $new = clone $this;
+        $new->default = $null;
+
+        return $new;
+    }
+
     /**
      * @codeCoverageIgnore
      */

src/functions.php

@@ -133,45 +133,6 @@ function assertNamedArgument(
     }
 }
 
-// @phpstan-ignore-next-line
-function assertIterable(
-    IterableParameterInterface $parameter,
-    iterable $argument,
-): iterable {
-    if (empty($argument)) {
-        throw new InvalidArgumentException(
-            (string) message('Argument value provided is empty')
-        );
-    }
-    $iterable = ' *iterable';
-    $iterableKey = '_K' . $iterable;
-    $iterableValue = '_V' . $iterable;
-
-    try {
-        foreach ($argument as $key => $value) {
-            assertNamedArgument($iterableKey, $parameter->key(), $key);
-            assertNamedArgument($iterableValue, $parameter->value(), $value);
-        }
-    } catch (Throwable $e) {
-        $message = $e->getMessage();
-        $strstr = strstr($message, ':', false);
-        if (! is_string($strstr)) {
-            $strstr = $message; // @codeCoverageIgnore
-        } else {
-            $strstr = substr($strstr, 2);
-        }
-        $calledIn = strpos($strstr, ', called in');
-
-        $message = $calledIn
-            ? substr($strstr, 0, $calledIn)
-            : $strstr;
-
-        throw new InvalidArgumentException($message);
-    }
-
-    return $argument;
-}
-
 function toParameter(string $type): ParameterInterface
 {
     $class = TypeInterface::TYPE_TO_PARAMETER[$type]
@@ -287,14 +248,37 @@ function reflectionToParameters(ReflectionFunction|ReflectionMethod $reflection)
         } catch (LogicException) {
             $push = new ReflectionParameterTyped($parameter);
         }
-        $callable = match ($parameter->isOptional()) {
+        $push = $push->parameter();
+        if ($parameter->isDefaultValueAvailable()) {
+            try {
+                $push = $push->withDefault($parameter->getDefaultValue());
+            } catch (Throwable $e) {
+                $name = $parameter->getName();
+                $class = $parameter->getDeclaringClass()?->getName() ?? null;
+                $function = $parameter->getDeclaringFunction()->getName();
+                $caller = match (true) {
+                    $class === null => $function,
+                    default => $class . '::' . $function,
+                };
+
+                throw new InvalidArgumentException(
+                    (string) message(
+                        'Unable to use default value for parameter `%name%` in `%caller%`: %message%',
+                        name: $name,
+                        caller: $caller,
+                        message: $e->getMessage(),
+                    )
+                );
+            }
+        }
+        $withMethod = match ($parameter->isOptional()) {
             true => 'withOptional',
             default => 'withRequired',
         };
 
-        $parameters = $parameters->{$callable}(
+        $parameters = $parameters->{$withMethod}(
             $parameter->getName(),
-            $push->parameter()
+            $push
         );
     }
 

tests/ArgumentsIterableTest.php

@@ -17,7 +17,6 @@
 use InvalidArgumentException;
 use PHPUnit\Framework\TestCase;
 use function Chevere\Parameter\arrayp;
-use function Chevere\Parameter\assertIterable;
 use function Chevere\Parameter\int;
 use function Chevere\Parameter\iterable;
 use function Chevere\Parameter\parameters;
@@ -194,7 +193,7 @@ public function testIterableArray(array $args): void
             K: string()
         );
         $this->expectNotToPerformAssertions();
-        assertIterable($parameter, $args);
+        $parameter($args);
     }
 
     /**
@@ -208,6 +207,6 @@ public function testIterableArrayConflict(array $args): void
         );
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessageMatches('/^\[_V \*iterable\]\:.*/');
-        assertIterable($parameter, $args);
+        $parameter($args);
     }
 }

tests/IterableParameterTest.php

@@ -17,7 +17,6 @@
 use InvalidArgumentException;
 use PHPUnit\Framework\TestCase;
 use function Chevere\Parameter\arguments;
-use function Chevere\Parameter\assertIterable;
 use function Chevere\Parameter\int;
 use function Chevere\Parameter\iterable;
 use function Chevere\Parameter\string;
@@ -102,7 +101,7 @@ public function testNestedIterable(): void
         $argument = [
             'a' => 'A',
         ];
-        assertIterable($parameter, $argument);
+        $parameter($argument);
         $parameter = iterable(
             V: $parameter,
         );
@@ -114,7 +113,7 @@ public function testNestedIterable(): void
                 'c' => 'C',
             ],
         ];
-        assertIterable($parameter, $argument);
+        $parameter($argument);
     }
 
     public function testIterableArguments(): void
@@ -151,6 +150,17 @@ public function testInvoke(): void
         $parameter = iterable(union(int(), string()));
         $parameter($value);
         $this->expectException(InvalidArgumentException::class);
-        $parameter([null, false]);
+        $parameter([]);
+    }
+
+    public function testWithDefault(): void
+    {
+        $value = [10, '10'];
+        $parameter = iterable(union(int(), string()));
+        $with = $parameter->withDefault($value);
+        $this->assertNotSame($parameter, $with);
+        $this->assertSame($value, $with->default());
+        $this->expectException(InvalidArgumentException::class);
+        $parameter->withDefault([null, false]);
     }
 }

tests/src/UsesParameterAttributes.php

@@ -14,9 +14,13 @@
 namespace Chevere\Tests\src;
 
 use Chevere\Parameter\Attributes\ArrayAttr;
+use Chevere\Parameter\Attributes\BoolAttr;
 use Chevere\Parameter\Attributes\CallableAttr;
+use Chevere\Parameter\Attributes\EnumAttr;
+use Chevere\Parameter\Attributes\FloatAttr;
 use Chevere\Parameter\Attributes\IntAttr;
 use Chevere\Parameter\Attributes\IterableAttr;
+use Chevere\Parameter\Attributes\NullAttr;
 use Chevere\Parameter\Attributes\ReturnAttr;
 use Chevere\Parameter\Attributes\StringAttr;
 use Chevere\Parameter\Interfaces\ParameterInterface;
@@ -42,16 +46,28 @@ public function __construct(
         #[ArrayAttr(
             id: new CallableAttr(__CLASS__ . '::callable'),
         )]
-        array $cols = [],
+        array $cols = [
+            'id' => 1,
+        ],
         #[IterableAttr(
             new StringAttr('/^[A-Za-z]+$/'),
         )]
-        iterable $tags = [],
+        iterable $tags = ['Chevere', 'Chevere', 'Chevere', 'Uh'],
+        #[BoolAttr()]
+        bool $flag = false,
+        #[FloatAttr(min: 0)]
+        float $amount = 0,
+        #[NullAttr()]
+        mixed $null = null,
+        #[EnumAttr('test', 'value')]
+        string $enum = 'value',
     ) {
         valid('name');
         valid('age');
         valid('cols');
         valid('tags');
+        valid('flag');
+        valid('amount');
         valid();
         $name = stringAttr('name')($name);
         $age = intAttr('age')($age);