Rename Result->isValid method

faabiosr · faabiosr · commit 0e8ac1817b7e · 2025-03-31T21:29:37.000+02:00
diff --git a/library/Message/StandardFormatter.php b/library/Message/StandardFormatter.php
@@ -159,7 +159,7 @@ public function resultWithPath(Result $parent, Result $child): Result
 
     private function isAlwaysVisible(Result $result, Result ...$siblings): bool
     {
-        if ($result->isValid) {
+        if ($result->hasPassed) {
             return false;
         }
 
@@ -275,11 +275,11 @@ private function extractDeduplicatedChildren(Result $result): array
             }
 
             if ($child->path === null) {
-                $deduplicatedResults[$id] = $child->isValid ? null : $child->withId($id);
+                $deduplicatedResults[$id] = $child->hasPassed ? null : $child->withId($id);
                 continue;
             }
 
-            $deduplicatedResults[$id] = $child->isValid ? null : $child;
+            $deduplicatedResults[$id] = $child->hasPassed ? null : $child;
         }
 
         return array_values(array_filter($deduplicatedResults));
diff --git a/library/Result.php b/library/Result.php
@@ -31,7 +31,7 @@ final class Result
 
     /** @param array<string, mixed> $parameters */
     public function __construct(
-        public readonly bool $isValid,
+        public readonly bool $hasPassed,
         public readonly mixed $input,
         public readonly Rule $rule,
         public readonly array $parameters = [],
@@ -77,7 +77,7 @@ public static function fromAdjacent(
         string $template = Rule::TEMPLATE_STANDARD
     ): Result {
         if ($adjacent->allowsAdjacent()) {
-            return (new Result($adjacent->isValid, $input, $rule, $parameters, $template, id: $adjacent->id))
+            return (new Result($adjacent->hasPassed, $input, $rule, $parameters, $template, id: $adjacent->id))
                 ->withPrefix($prefix)
                 ->withAdjacent($adjacent->withInput($input));
         }
@@ -202,7 +202,7 @@ public function withAdjacent(Result $adjacent): self
     public function withToggledValidation(): self
     {
         return $this->clone(
-            isValid: !$this->isValid,
+            hasPassed: !$this->hasPassed,
             adjacent: $this->adjacent?->withToggledValidation(),
             children: array_map(static fn (Result $child) => $child->withToggledValidation(), $this->children),
         );
@@ -211,7 +211,7 @@ public function withToggledValidation(): self
     public function withToggledModeAndValidation(): self
     {
         return $this->clone(
-            isValid: !$this->isValid,
+            hasPassed: !$this->hasPassed,
             mode: !$this->hasInvertedMode,
             adjacent: $this->adjacent?->withToggledModeAndValidation(),
             children: array_map(static fn (Result $child) => $child->withToggledModeAndValidation(), $this->children),
@@ -242,7 +242,7 @@ public function allowsAdjacent(): bool
      * @param array<Result>|null $children
      */
     private function clone(
-        ?bool $isValid = null,
+        ?bool $hasPassed = null,
         mixed $input = null,
         ?array $parameters = null,
         ?string $template = null,
@@ -254,7 +254,7 @@ private function clone(
         ?array $children = null
     ): self {
         return new self(
-            $isValid ?? $this->isValid,
+            $hasPassed ?? $this->hasPassed,
             $input ?? $this->input,
             $this->rule,
             $parameters ?? $this->parameters,
diff --git a/library/Rules/AllOf.php b/library/Rules/AllOf.php
@@ -39,8 +39,8 @@ final class AllOf extends Composite
     public function evaluate(mixed $input): Result
     {
         $children = array_map(static fn (Rule $rule) => $rule->evaluate($input), $this->rules);
-        $valid = array_reduce($children, static fn (bool $carry, Result $result) => $carry && $result->isValid, true);
-        $failed = array_filter($children, static fn (Result $result): bool => !$result->isValid);
+        $valid = array_reduce($children, static fn (bool $carry, Result $result) => $carry && $result->hasPassed, true);
+        $failed = array_filter($children, static fn (Result $result): bool => !$result->hasPassed);
         $template = self::TEMPLATE_SOME;
         if (count($children) === count($failed)) {
             $template = self::TEMPLATE_ALL;
diff --git a/library/Rules/AnyOf.php b/library/Rules/AnyOf.php
@@ -28,7 +28,11 @@ final class AnyOf extends Composite
     public function evaluate(mixed $input): Result
     {
         $children = array_map(static fn (Rule $rule) => $rule->evaluate($input), $this->rules);
-        $valid = array_reduce($children, static fn (bool $carry, Result $result) => $carry || $result->isValid, false);
+        $valid = array_reduce(
+            $children,
+            static fn (bool $carry, Result $result) => $carry || $result->hasPassed,
+            false,
+        );
 
         return (new Result($valid, $input, $this))->withChildren(...$children);
     }
diff --git a/library/Rules/Attributes.php b/library/Rules/Attributes.php
@@ -23,7 +23,7 @@ final class Attributes extends Standard
     public function evaluate(mixed $input): Result
     {
         $objectType = (new ObjectType())->evaluate($input);
-        if (!$objectType->isValid) {
+        if (!$objectType->hasPassed) {
             return $objectType->withId('attributes');
         }
 
diff --git a/library/Rules/Circuit.php b/library/Rules/Circuit.php
@@ -20,7 +20,7 @@ public function evaluate(mixed $input): Result
     {
         foreach ($this->rules as $rule) {
             $result = $rule->evaluate($input);
-            if (!$result->isValid) {
+            if (!$result->hasPassed) {
                 return $result;
             }
         }
diff --git a/library/Rules/Core/Envelope.php b/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)->isValid, $input, $this, $this->parameters);
+        return new Result($this->rule->evaluate($input)->hasPassed, $input, $this, $this->parameters);
     }
 }
diff --git a/library/Rules/Core/FilteredNonEmptyArray.php b/library/Rules/Core/FilteredNonEmptyArray.php
@@ -24,13 +24,13 @@ abstract protected function evaluateNonEmptyArray(array $input): Result;
     public function evaluate(mixed $input): Result
     {
         $iterableResult = (new IterableType())->evaluate($input);
-        if (!$iterableResult->isValid) {
+        if (!$iterableResult->hasPassed) {
             return $iterableResult->withIdFrom($this)->withNameFrom($this->rule);
         }
 
         $array = $this->toArray($input);
         $notEmptyResult = (new NotEmpty())->evaluate($array);
-        if (!$notEmptyResult->isValid) {
+        if (!$notEmptyResult->hasPassed) {
             return $notEmptyResult->withIdFrom($this)->withNameFrom($this->rule);
         }
 
diff --git a/library/Rules/Core/Standard.php b/library/Rules/Core/Standard.php
@@ -19,7 +19,7 @@ abstract class Standard implements Rule
      */
     public function validate(mixed $input): bool
     {
-        return $this->evaluate($input)->isValid;
+        return $this->evaluate($input)->hasPassed;
     }
 
     /**
diff --git a/library/Rules/CreditCard.php b/library/Rules/CreditCard.php
@@ -75,7 +75,7 @@ public function evaluate(mixed $input): Result
         }
 
         $filteredInput = (string) preg_replace('/[ .-]/', '', (string) $input);
-        if (!(new Luhn())->evaluate($filteredInput)->isValid) {
+        if (!(new Luhn())->evaluate($filteredInput)->hasPassed) {
             return Result::failed($input, $this, $parameters, $template);
         }
 
diff --git a/library/Rules/Domain.php b/library/Rules/Domain.php
@@ -43,19 +43,19 @@ public function __construct(bool $tldCheck = true)
     public function evaluate(mixed $input): Result
     {
         $genericResult = $this->genericRule->evaluate($input);
-        if (!$genericResult->isValid) {
+        if (!$genericResult->hasPassed) {
             return Result::failed($input, $this);
         }
 
         $parts = explode('.', (string) $input);
         if (count($parts) >= 2) {
             $childResult = $this->tldRule->evaluate(array_pop($parts));
-            if (!$childResult->isValid) {
+            if (!$childResult->hasPassed) {
                 return Result::failed($input, $this);
             }
         }
 
-        return new Result($this->partsRule->evaluate($parts)->isValid, $input, $this);
+        return new Result($this->partsRule->evaluate($parts)->hasPassed, $input, $this);
     }
 
     private function createGenericRule(): Circuit
diff --git a/library/Rules/Each.php b/library/Rules/Each.php
@@ -30,9 +30,13 @@ protected function evaluateNonEmptyArray(array $input): Result
         foreach ($input as $key => $value) {
             $children[] = $this->rule->evaluate($value)->withPath($key);
         }
-        $isValid = array_reduce($children, static fn ($carry, $childResult) => $carry && $childResult->isValid, true);
+        $hasPassed = array_reduce(
+            $children,
+            static fn ($carry, $childResult) => $carry && $childResult->hasPassed,
+            true,
+        );
 
-        return (new Result($isValid, $input, $this))
+        return (new Result($hasPassed, $input, $this))
             ->withChildren(...$children)
             ->withNameFrom($this->rule);
     }
diff --git a/library/Rules/Key.php b/library/Rules/Key.php
@@ -33,7 +33,7 @@ public function getKey(): int|string
     public function evaluate(mixed $input): Result
     {
         $keyExistsResult = (new KeyExists($this->key))->evaluate($input);
-        if (!$keyExistsResult->isValid) {
+        if (!$keyExistsResult->hasPassed) {
             return $keyExistsResult->withNameFrom($this->rule);
         }
 
diff --git a/library/Rules/KeyOptional.php b/library/Rules/KeyOptional.php
@@ -33,7 +33,7 @@ public function getKey(): int|string
     public function evaluate(mixed $input): Result
     {
         $keyExistsResult = (new KeyExists($this->key))->evaluate($input);
-        if (!$keyExistsResult->isValid) {
+        if (!$keyExistsResult->hasPassed) {
             return $keyExistsResult->withNameFrom($this->rule)->withToggledModeAndValidation();
         }
 
diff --git a/library/Rules/KeySet.php b/library/Rules/KeySet.php
@@ -76,7 +76,7 @@ public function __construct(Rule $rule, Rule ...$rules)
     public function evaluate(mixed $input): Result
     {
         $arrayResult = (new ArrayType())->evaluate($input);
-        if (!$arrayResult->isValid) {
+        if (!$arrayResult->hasPassed) {
             return $arrayResult;
         }
 
@@ -86,7 +86,7 @@ public function evaluate(mixed $input): Result
         )));
         $keysResult = $keys->evaluate($input);
 
-        return (new Result($keysResult->isValid, $input, $this, [], $this->getTemplateFromKeys(array_keys($input))))
+        return (new Result($keysResult->hasPassed, $input, $this, [], $this->getTemplateFromKeys(array_keys($input))))
             ->withChildren(...($keysResult->children === [] ? [$keysResult] : $keysResult->children));
     }
 
diff --git a/library/Rules/Luhn.php b/library/Rules/Luhn.php
@@ -29,7 +29,7 @@ final class Luhn extends Simple
 {
     public function isValid(mixed $input): bool
     {
-        if (!(new Digit())->evaluate($input)->isValid) {
+        if (!(new Digit())->evaluate($input)->hasPassed) {
             return false;
         }
 
diff --git a/library/Rules/NoneOf.php b/library/Rules/NoneOf.php
@@ -42,8 +42,8 @@ public function evaluate(mixed $input): Result
             static fn (Rule $rule) => $rule->evaluate($input)->withToggledModeAndValidation(),
             $this->rules
         );
-        $valid = array_reduce($children, static fn (bool $carry, Result $result) => $carry && $result->isValid, true);
-        $failed = array_filter($children, static fn (Result $result): bool => !$result->isValid);
+        $valid = array_reduce($children, static fn (bool $carry, Result $result) => $carry && $result->hasPassed, true);
+        $failed = array_filter($children, static fn (Result $result): bool => !$result->hasPassed);
         $template = self::TEMPLATE_SOME;
         if (count($children) === count($failed)) {
             $template = self::TEMPLATE_ALL;
diff --git a/library/Rules/NullOr.php b/library/Rules/NullOr.php
@@ -30,7 +30,7 @@ public function evaluate(mixed $input): Result
             return $this->enrichResult($result);
         }
 
-        if (!$result->isValid) {
+        if (!$result->hasPassed) {
             return $this->enrichResult($result->withToggledValidation());
         }
 
@@ -42,7 +42,7 @@ private function enrichResult(Result $result): Result
         if ($result->allowsAdjacent()) {
             return $result
                 ->withPrefix('nullOr')
-                ->withAdjacent(new Result($result->isValid, $result->input, $this));
+                ->withAdjacent(new Result($result->hasPassed, $result->input, $this));
         }
 
         return $result->withChildren(...array_map(fn(Result $child) => $this->enrichResult($child), $result->children));
diff --git a/library/Rules/OneOf.php b/library/Rules/OneOf.php
@@ -40,16 +40,20 @@ final class OneOf extends Composite
     public function evaluate(mixed $input): Result
     {
         $children = array_map(static fn (Rule $rule) => $rule->evaluate($input), $this->rules);
-        $valid = array_reduce($children, static fn (bool $carry, Result $result) => $carry xor $result->isValid, false);
-        $validChildren = array_filter($children, static fn (Result $result): bool => $result->isValid);
+        $valid = array_reduce(
+            $children,
+            static fn (bool $carry, Result $result) => $carry xor $result->hasPassed,
+            false,
+        );
+        $validChildren = array_filter($children, static fn (Result $result): bool => $result->hasPassed);
         $template = self::TEMPLATE_NONE;
         if (count($validChildren) > 1) {
             // Put the failed children at the top, so it makes sense in the main error message
-            usort($children, static fn (Result $a, Result $b): int => $a->isValid <=> $b->isValid);
+            usort($children, static fn (Result $a, Result $b): int => $a->hasPassed <=> $b->hasPassed);
 
             $template = self::TEMPLATE_MORE_THAN_ONE;
             $children = array_map(
-                static fn (Result $child) => $child->isValid ? $child->withToggledValidation() : $child,
+                static fn (Result $child) => $child->hasPassed ? $child->withToggledValidation() : $child,
                 $children
             );
         }
diff --git a/library/Rules/PostalCode.php b/library/Rules/PostalCode.php
@@ -210,7 +210,7 @@ final class PostalCode extends Envelope
     public function __construct(string $countryCode, bool $formatted = false)
     {
         $countryCodeRule = new CountryCode();
-        if (!$countryCodeRule->evaluate($countryCode)->isValid) {
+        if (!$countryCodeRule->evaluate($countryCode)->hasPassed) {
             throw new InvalidRuleConstructorException('Cannot validate postal code from "%s" country', $countryCode);
         }
 
diff --git a/library/Rules/Property.php b/library/Rules/Property.php
@@ -28,7 +28,7 @@ public function __construct(
     public function evaluate(mixed $input): Result
     {
         $propertyExistsResult = (new PropertyExists($this->propertyName))->evaluate($input);
-        if (!$propertyExistsResult->isValid) {
+        if (!$propertyExistsResult->hasPassed) {
             return $propertyExistsResult->withNameFrom($this->rule);
         }
 
diff --git a/library/Rules/PropertyOptional.php b/library/Rules/PropertyOptional.php
@@ -27,7 +27,7 @@ public function __construct(
     public function evaluate(mixed $input): Result
     {
         $propertyExistsResult = (new PropertyExists($this->propertyName))->evaluate($input);
-        if (!$propertyExistsResult->isValid) {
+        if (!$propertyExistsResult->hasPassed) {
             return $propertyExistsResult->withNameFrom($this->rule)->withToggledModeAndValidation();
         }
 
diff --git a/library/Rules/UndefOr.php b/library/Rules/UndefOr.php
@@ -33,7 +33,7 @@ public function evaluate(mixed $input): Result
             return $this->enrichResult($result);
         }
 
-        if (!$result->isValid) {
+        if (!$result->hasPassed) {
             return $this->enrichResult($result->withToggledValidation());
         }
 
@@ -45,7 +45,7 @@ private function enrichResult(Result $result): Result
         if ($result->allowsAdjacent()) {
             return $result
                 ->withPrefix('undefOr')
-                ->withAdjacent(new Result($result->isValid, $result->input, $this));
+                ->withAdjacent(new Result($result->hasPassed, $result->input, $this));
         }
 
         return $result->withChildren(...array_map(fn(Result $child) => $this->enrichResult($child), $result->children));
diff --git a/library/Rules/When.php b/library/Rules/When.php
@@ -34,7 +34,7 @@ public function __construct(
     public function evaluate(mixed $input): Result
     {
         $whenResult = $this->when->evaluate($input);
-        if ($whenResult->isValid) {
+        if ($whenResult->hasPassed) {
             return $this->then->evaluate($input);
         }
 
diff --git a/library/Validator.php b/library/Validator.php
@@ -65,14 +65,14 @@ public function evaluate(mixed $input): Result
 
     public function isValid(mixed $input): bool
     {
-        return $this->evaluate($input)->isValid;
+        return $this->evaluate($input)->hasPassed;
     }
 
     /** @param array<string, mixed>|callable(ValidationException): Throwable|string|Throwable|null $template */
     public function assert(mixed $input, array|string|Throwable|callable|null $template = null): void
     {
         $result = $this->evaluate($input);
-        if ($result->isValid) {
+        if ($result->hasPassed) {
             return;
         }
 
@@ -134,7 +134,7 @@ public function getRules(): array
      */
     public function validate(mixed $input): bool
     {
-        return $this->evaluate($input)->isValid;
+        return $this->evaluate($input)->hasPassed;
     }
 
     /**
diff --git a/tests/library/Builders/ResultBuilder.php b/tests/library/Builders/ResultBuilder.php
diff --git a/tests/library/TestCase.php b/tests/library/TestCase.php
diff --git a/tests/unit/Message/StandardFormatter/ResultCreator.php b/tests/unit/Message/StandardFormatter/ResultCreator.php
diff --git a/tests/unit/Rules/AlwaysInvalidTest.php b/tests/unit/Rules/AlwaysInvalidTest.php
diff --git a/tests/unit/Rules/AlwaysValidTest.php b/tests/unit/Rules/AlwaysValidTest.php
diff --git a/tests/unit/Rules/Core/EnvelopeTest.php b/tests/unit/Rules/Core/EnvelopeTest.php
diff --git a/tests/unit/Rules/Core/SimpleTest.php b/tests/unit/Rules/Core/SimpleTest.php

Original file line number	Diff line number	Diff line change
`@@ -159,7 +159,7 @@ public function resultWithPath(Result $parent, Result $child): Result`
`159`	`159`
`160`	`160`	`private function isAlwaysVisible(Result $result, Result ...$siblings): bool`
`161`	`161`	`{`
`162`		`- if ($result->isValid) {`
	`162`	`+ if ($result->hasPassed) {`
`163`	`163`	`return false;`
`164`	`164`	`}`
`165`	`165`
`@@ -275,11 +275,11 @@ private function extractDeduplicatedChildren(Result $result): array`
`275`	`275`	`}`
`276`	`276`
`277`	`277`	`if ($child->path === null) {`
`278`		`- $deduplicatedResults[$id] = $child->isValid ? null : $child->withId($id);`
	`278`	`+ $deduplicatedResults[$id] = $child->hasPassed ? null : $child->withId($id);`
`279`	`279`	`continue;`
`280`	`280`	`}`
`281`	`281`
`282`		`- $deduplicatedResults[$id] = $child->isValid ? null : $child;`
	`282`	`+ $deduplicatedResults[$id] = $child->hasPassed ? null : $child;`
`283`	`283`	`}`
`284`	`284`
`285`	`285`	`return array_values(array_filter($deduplicatedResults));`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,11 @@ final class AnyOf extends Composite`
`28`	`28`	`public function evaluate(mixed $input): Result`
`29`	`29`	`{`
`30`	`30`	`$children = array_map(static fn (Rule $rule) => $rule->evaluate($input), $this->rules);`
`31`		`- $valid = array_reduce($children, static fn (bool $carry, Result $result) => $carry \|\| $result->isValid, false);`
	`31`	`+ $valid = array_reduce(`
	`32`	`+ $children,`
	`33`	`+ static fn (bool $carry, Result $result) => $carry \|\| $result->hasPassed,`
	`34`	`+ false,`
	`35`	`+ );`
`32`	`36`
`33`	`37`	`return (new Result($valid, $input, $this))->withChildren(...$children);`
`34`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ final class Attributes extends Standard`
`23`	`23`	`public function evaluate(mixed $input): Result`
`24`	`24`	`{`
`25`	`25`	`$objectType = (new ObjectType())->evaluate($input);`
`26`		`- if (!$objectType->isValid) {`
	`26`	`+ if (!$objectType->hasPassed) {`
`27`	`27`	`return $objectType->withId('attributes');`
`28`	`28`	`}`
`29`	`29`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ public function evaluate(mixed $input): Result`
`20`	`20`	`{`
`21`	`21`	`foreach ($this->rules as $rule) {`
`22`	`22`	`$result = $rule->evaluate($input);`
`23`		`- if (!$result->isValid) {`
	`23`	`+ if (!$result->hasPassed) {`
`24`	`24`	`return $result;`
`25`	`25`	`}`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,6 @@ public function __construct(`
`23`	`23`
`24`	`24`	`public function evaluate(mixed $input): Result`
`25`	`25`	`{`
`26`		`- return new Result($this->rule->evaluate($input)->isValid, $input, $this, $this->parameters);`
	`26`	`+ return new Result($this->rule->evaluate($input)->hasPassed, $input, $this, $this->parameters);`
`27`	`27`	`}`
`28`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,13 +24,13 @@ abstract protected function evaluateNonEmptyArray(array $input): Result;`
`24`	`24`	`public function evaluate(mixed $input): Result`
`25`	`25`	`{`
`26`	`26`	`$iterableResult = (new IterableType())->evaluate($input);`
`27`		`- if (!$iterableResult->isValid) {`
	`27`	`+ if (!$iterableResult->hasPassed) {`
`28`	`28`	`return $iterableResult->withIdFrom($this)->withNameFrom($this->rule);`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`$array = $this->toArray($input);`
`32`	`32`	`$notEmptyResult = (new NotEmpty())->evaluate($array);`
`33`		`- if (!$notEmptyResult->isValid) {`
	`33`	`+ if (!$notEmptyResult->hasPassed) {`
`34`	`34`	`return $notEmptyResult->withIdFrom($this)->withNameFrom($this->rule);`
`35`	`35`	`}`
`36`	`36`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ abstract class Standard implements Rule`
`19`	`19`	`*/`
`20`	`20`	`public function validate(mixed $input): bool`
`21`	`21`	`{`
`22`		`- return $this->evaluate($input)->isValid;`
	`22`	`+ return $this->evaluate($input)->hasPassed;`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ public function evaluate(mixed $input): Result`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`$filteredInput = (string) preg_replace('/[ .-]/', '', (string) $input);`
`78`		`- if (!(new Luhn())->evaluate($filteredInput)->isValid) {`
	`78`	`+ if (!(new Luhn())->evaluate($filteredInput)->hasPassed) {`
`79`	`79`	`return Result::failed($input, $this, $parameters, $template);`
`80`	`80`	`}`
`81`	`81`