fix: apply linter suggestions

Author: wilcorrea

src/Core/Reflect/Resolver/RequirementResolver.php

@@ -57,18 +57,7 @@ private function applyRequirementRule(ReflectionParameter $parameter, Field $fie
             return;
         }
 
-        if ($this->shouldBePresent($parameter)) {
-            $field->present();
-            return;
-        }
-
-        if ($this->shouldBeFilled($parameter)) {
-            $field->filled();
-        }
-
-        if ($this->shouldUseSometimesRequired($parameter)) {
-            $field->required();
-        }
+        $this->applyRequirementRuleNotStrict($parameter, $field);
     }
 
     private function isStrictlyRequired(ReflectionParameter $parameter): bool
@@ -98,4 +87,20 @@ private function shouldUseSometimesRequired(ReflectionParameter $parameter): boo
             $parameter->isDefaultValueAvailable() &&
             ! $parameter->allowsNull();
     }
+
+    private function applyRequirementRuleNotStrict(ReflectionParameter $parameter, Field $field): void
+    {
+        if ($this->shouldBePresent($parameter)) {
+            $field->present();
+            return;
+        }
+
+        if ($this->shouldBeFilled($parameter)) {
+            $field->filled();
+        }
+
+        if ($this->shouldUseSometimesRequired($parameter)) {
+            $field->required();
+        }
+    }
 }

src/Core/Serialize/Builder.php

@@ -30,7 +30,7 @@ class Builder extends Engine
      * @return T
      * @throws AdapterException
      */
-    public function build(string $class, Set $set, array $path = []): mixed
+    public function build(string $class, Set $set = new Set([]), array $path = []): mixed
     {
         try {
             return $this->make($class, $set, $path);

src/Factory/DefaultSpecsFactory.php

@@ -5,6 +5,7 @@
 namespace Constructo\Factory;
 
 use Constructo\Contract\Reflect\SpecsFactory;
+use Constructo\Core\Serialize\Builder;
 use Constructo\Support\Metadata\Schema\Registry\Specs;
 use InvalidArgumentException;
 
@@ -17,13 +18,15 @@
 
 readonly class DefaultSpecsFactory implements SpecsFactory
 {
-    public function __construct(private array $specs = [])
-    {
+    public function __construct(
+        private Builder $builder,
+        private array $specs = [],
+    ) {
     }
 
     public function make(): Specs
     {
-        $registry = new Specs();
+        $registry = new Specs($this->builder);
         foreach ($this->specs as $key => $value) {
             $this->validate($key, $value);
             $registry->register(stringify($key), arrayify($value));

src/Support/Metadata/Schema/Field.php

@@ -166,11 +166,11 @@ public function hasRule(string $rule): bool
 
     public function __call(string $name, array $arguments): self
     {
-        if ($this->is(self::MAPPING, $name)) {
+        if ($this->isFrom(self::MAPPING, $name)) {
             $this->handleMapping(...$arguments);
             return $this;
         }
-        if ($this->is(self::VISIBILITY, $name)) {
+        if ($this->isFrom(self::VISIBILITY, $name)) {
             $this->handleVisibility($name);
             return $this;
         }
@@ -182,7 +182,7 @@ public function __call(string $name, array $arguments): self
         throw new BadMethodCallException(sprintf("Entry '%s' is not supported.", $name));
     }
 
-    private function is(array $haystack, string $needle): bool
+    private function isFrom(array $haystack, string $needle): bool
     {
         return in_array($needle, $haystack, true);
     }

src/Support/Metadata/Schema/Field/Formatter/MergeFormatter.php

@@ -19,14 +19,25 @@
 class MergeFormatter implements Formatter
 {
     public function format(mixed $value, mixed $option = null): array
+    {
+        $items = $this->getItems($value);
+        if (is_string($items) && class_exists($items) && is_subclass_of($items, BackedEnum::class)) {
+            $items = $items::cases();
+        }
+        return $this->formatItems($items);
+    }
+
+    private function getItems(mixed $value): mixed
     {
         if (! is_array($value) || count($value) < 1) {
             throw new BadMethodCallException('MergeFormatter requires an array with at least one element.');
         }
         [$items] = $value;
-        if (is_string($items) && class_exists($items) && is_subclass_of($items, BackedEnum::class)) {
-            $items = $items::cases();
-        }
+        return $items;
+    }
+
+    private function formatItems(mixed $items): array
+    {
         $callback = fn (mixed $item) => match (true) {
             $item instanceof BackedEnum => $item->value,
             default => stringify($item),

src/Support/Metadata/Schema/Field/Rule.php

@@ -57,7 +57,7 @@ private function enforce(mixed $item): string
                     fn ($element): string => $this->enforce($element),
                     is_array($item)
                         ? $item
-                        : iterator_to_array($item)
+                        : iterator_to_array($item, false)
                 )
             ),
             default => stringify($item),

src/Support/Metadata/Schema/Registry/Specs.php

@@ -5,6 +5,7 @@
 namespace Constructo\Support\Metadata\Schema\Registry;
 
 use Constructo\Contract\Formatter;
+use Constructo\Core\Serialize\Builder;
 use Constructo\Support\Set;
 use InvalidArgumentException;
 
@@ -18,6 +19,10 @@ class Specs
 {
     private array $specs = [];
 
+    public function __construct(private readonly Builder $builder)
+    {
+    }
+
     public function get(string $name): ?Spec
     {
         $name = snakify($name);
@@ -54,7 +59,15 @@ protected function defineFormatter(Set $properties): ?Formatter
             $given = gettype($formatter);
             throw new InvalidArgumentException(sprintf('Formatter must be a valid class-string, %s given.', $given));
         }
-        $instance = new $formatter();
+        return $this->createFormatter($formatter);
+    }
+
+    /**
+     * @param class-string<object> $formatter
+     */
+    private function createFormatter(string $formatter): Formatter
+    {
+        $instance = $this->builder->build($formatter);
         if (! $instance instanceof Formatter) {
             $given = gettype($instance);
             throw new InvalidArgumentException(

src/Testing/MakeExtension.php

@@ -13,14 +13,14 @@
 trait MakeExtension
 {
     /**
-     * @template T of mixed
+     * @template T of object
      * @param class-string<T> $class
      * @param array<string, mixed> $args
      *
      * @return T
      * @throws ReflectionException
      */
-    protected function make(string $class, array $args = []): mixed
+    protected function make(string $class, array $args = []): object
     {
         return (new ReflectionClass($class))->newInstanceArgs(array_values($args));
     }