Create named constructor to create Result

The constructor of `Result` has many arguments, but that's not the
primary reason why I'm making this change. I want to change the
constructor, and it will become more complicated, so having this named
constructor will be useful in the next refactoring.

With this change, I also made the `id` mandatory. That made the
constructor look neater and most to promote almost all properties to the
constructor.

Another change was removing the `fromAdjacent` method, which was quite
confusing. I created the `asAdjacentOf` method, which is a bit clearer.
If anything, it makes all static methods named constructors. It will be
a bit more verbose, but more intuitive.

Author: henriquemoody

library/Result.php

@@ -21,72 +21,70 @@
     /** @var array<Result> */
     public array $children;
 
-    public Id $id;
-
     /** @param array<string, mixed> $parameters */
     public function __construct(
         public bool $hasPassed,
         public mixed $input,
         public Rule $rule,
+        public Id $id,
         public array $parameters = [],
         public string $template = Rule::TEMPLATE_STANDARD,
         public bool $hasInvertedMode = false,
         public Name|null $name = null,
-        Id|null $id = null,
         public Result|null $adjacent = null,
         public Path|null $path = null,
         Result ...$children,
     ) {
-        $this->id = $id ?? Id::fromRule($rule);
         $this->children = $children;
     }
 
     /** @param array<string, mixed> $parameters */
-    public static function failed(
+    public static function of(
+        bool $hasPassed,
         mixed $input,
         Rule $rule,
         array $parameters = [],
         string $template = Rule::TEMPLATE_STANDARD,
     ): self {
-        return new self(false, $input, $rule, $parameters, $template);
+        return new self($hasPassed, $input, $rule, Id::fromRule($rule), $parameters, $template);
     }
 
     /** @param array<string, mixed> $parameters */
-    public static function passed(
+    public static function failed(
         mixed $input,
         Rule $rule,
         array $parameters = [],
         string $template = Rule::TEMPLATE_STANDARD,
     ): self {
-        return new self(true, $input, $rule, $parameters, $template);
+        return self::of(false, $input, $rule, $parameters, $template);
     }
 
     /** @param array<string, mixed> $parameters */
-    public static function fromAdjacent(
+    public static function passed(
         mixed $input,
-        string $prefix,
         Rule $rule,
-        Result $adjacent,
         array $parameters = [],
         string $template = Rule::TEMPLATE_STANDARD,
-    ): Result {
-        if ($adjacent->allowsAdjacent()) {
-            return (new Result(
-                $adjacent->hasPassed,
-                $input,
-                $rule,
-                $parameters,
-                $template,
-                id: $adjacent->id->withPrefix($prefix),
-            ))->withAdjacent($adjacent->withInput($input));
-        }
+    ): self {
+        return self::of(true, $input, $rule, $parameters, $template);
+    }
 
-        $childrenAsAdjacent = array_map(
-            static fn(Result $child) => self::fromAdjacent($input, $prefix, $rule, $child, $parameters, $template),
-            $adjacent->children,
-        );
+    public function asAdjacentOf(Result $result, string $prefix): Result
+    {
+        if ($this->allowsAdjacent()) {
+            return clone ($result, [
+                'id' => $this->id->withPrefix($prefix),
+                'adjacent' => $this->withInput($result->input),
+            ]);
+        }
 
-        return $adjacent->withInput($input)->withChildren(...$childrenAsAdjacent);
+        return clone ($this, [
+            'input' => $result->input,
+            'children' => array_map(
+                static fn(Result $child) => $child->asAdjacentOf($result, $prefix),
+                $this->children,
+            ),
+        ]);
     }
 
     public function withTemplate(string $template): self

library/Rules/AllOf.php

@@ -46,6 +46,6 @@ public function evaluate(mixed $input): Result
             $template = self::TEMPLATE_ALL;
         }
 
-        return (new Result($valid, $input, $this, [], $template))->withChildren(...$children);
+        return Result::of($valid, $input, $this, [], $template)->withChildren(...$children);
     }
 }

library/Rules/AnyOf.php

@@ -34,6 +34,6 @@ public function evaluate(mixed $input): Result
             false,
         );
 
-        return (new Result($valid, $input, $this))->withChildren(...$children);
+        return Result::of($valid, $input, $this)->withChildren(...$children);
     }
 }

library/Rules/Base.php

@@ -38,7 +38,7 @@ public function __construct(
 
     public function evaluate(mixed $input): Result
     {
-        return new Result(
+        return Result::of(
             (bool) preg_match('@^[' . mb_substr($this->chars, 0, $this->base) . ']+$@', (string) $input),
             $input,
             $this,

library/Rules/Charset.php

@@ -47,7 +47,7 @@ public function __construct(string $charset, string ...$charsets)
 
     public function evaluate(mixed $input): Result
     {
-        return new Result(
+        return Result::of(
             in_array(mb_detect_encoding($input, $this->charset, true), $this->charset),
             $input,
             $this,

library/Rules/Contains.php

@@ -37,14 +37,14 @@ public function evaluate(mixed $input): Result
     {
         $parameters = ['containsValue' => $this->containsValue];
         if (is_array($input)) {
-            return new Result(in_array($this->containsValue, $input, $this->identical), $input, $this, $parameters);
+            return Result::of(in_array($this->containsValue, $input, $this->identical), $input, $this, $parameters);
         }
 
         if (!is_scalar($input) || !is_scalar($this->containsValue)) {
             return Result::failed($input, $this, $parameters);
         }
 
-        return new Result(
+        return Result::of(
             $this->validateString((string) $input, (string) $this->containsValue),
             $input,
             $this,

library/Rules/Core/Comparison.php

@@ -33,7 +33,7 @@ public function evaluate(mixed $input): Result
             return Result::failed($input, $this, $parameters);
         }
 
-        return new Result($this->compare($left, $right), $input, $this, $parameters);
+        return Result::of($this->compare($left, $right), $input, $this, $parameters);
     }
 
     abstract protected function compare(mixed $left, mixed $right): bool;

library/Rules/Core/Envelope.php

@@ -23,6 +23,6 @@ public function __construct(
 
     public function evaluate(mixed $input): Result
     {
-        return new Result($this->rule->evaluate($input)->hasPassed, $input, $this, $this->parameters);
+        return Result::of($this->rule->evaluate($input)->hasPassed, $input, $this, $this->parameters);
     }
 }

library/Rules/Core/FilteredString.php

@@ -44,7 +44,7 @@ public function evaluate(mixed $input): Result
         $filteredInput = $this->filter($stringInput);
         $isValid = $filteredInput === '' || $this->isValid($filteredInput);
 
-        return new Result($isValid, $input, $this, $parameters, $template);
+        return Result::of($isValid, $input, $this, $parameters, $template);
     }
 
     abstract protected function isValid(string $input): bool;

library/Rules/Core/Simple.php

@@ -18,6 +18,6 @@ abstract public function isValid(mixed $input): bool;
 
     public function evaluate(mixed $input): Result
     {
-        return new Result($this->isValid($input), $input, $this);
+        return Result::of($this->isValid($input), $input, $this);
     }
 }