Update the validation engine of comparison-based rules

Signed-off-by: Henrique Moody <henriquemoody@gmail.com>

library/Rules/Comparison.php

@@ -10,8 +10,9 @@ declare(strict_types=1);
 namespace Respect\Validation\Rules;
 
 use Respect\Validation\Helpers\CanCompareValues;
+use Respect\Validation\Result;
 
-abstract class AbstractComparison extends AbstractRule
+abstract class Comparison extends Standard
 {
     use CanCompareValues;
 
@@ -24,23 +25,17 @@ abstract class AbstractComparison extends AbstractRule
         $this->compareTo = $maxValue;
     }
 
-    public function validate(mixed $input): bool
+    public function evaluate(mixed $input): Result
     {
         $left = $this->toComparable($input);
         $right = $this->toComparable($this->compareTo);
 
+        $parameters = ['compareTo' => $this->compareTo];
+
         if (!$this->isAbleToCompareValues($left, $right)) {
-            return false;
+            return Result::failed($input, $this)->withParameters($parameters);
         }
 
-        return $this->compare($left, $right);
-    }
-
-    /**
-     * @return array<string, mixed>
-     */
-    public function getParams(): array
-    {
-        return ['compareTo' => $this->compareTo];
+        return (new Result($this->compare($left, $right), $input, $this))->withParameters($parameters);
     }
 }

library/Rules/Equals.php

@@ -15,7 +15,7 @@ use Respect\Validation\Message\Template;
     '{{name}} must equal {{compareTo}}',
     '{{name}} must not equal {{compareTo}}',
 )]
-final class Equals extends AbstractComparison
+final class Equals extends Comparison
 {
     protected function compare(mixed $left, mixed $right): bool
     {

library/Rules/Equivalent.php

@@ -18,36 +18,14 @@ use function mb_strtoupper;
     '{{name}} must be equivalent to {{compareTo}}',
     '{{name}} must not be equivalent to {{compareTo}}',
 )]
-final class Equivalent extends AbstractRule
+final class Equivalent extends Comparison
 {
-    public function __construct(
-        private readonly mixed $compareTo
-    ) {
-    }
-
-    public function validate(mixed $input): bool
+    protected function compare(mixed $left, mixed $right): bool
     {
-        if (is_scalar($input)) {
-            return $this->isStringEquivalent((string) $input);
+        if (!is_scalar($left)) {
+            return $left == $right;
         }
 
-        return $input == $this->compareTo;
-    }
-
-    /**
-     * @return array<string, mixed>
-     */
-    public function getParams(): array
-    {
-        return ['compareTo' => $this->compareTo];
-    }
-
-    private function isStringEquivalent(string $input): bool
-    {
-        if (!is_scalar($this->compareTo)) {
-            return false;
-        }
-
-        return mb_strtoupper((string) $input) === mb_strtoupper((string) $this->compareTo);
+        return mb_strtoupper((string) $left) === mb_strtoupper((string) $right);
     }
 }

library/Rules/GreaterThan.php

@@ -15,7 +15,7 @@ use Respect\Validation\Message\Template;
     '{{name}} must be greater than {{compareTo}}',
     '{{name}} must not be greater than {{compareTo}}',
 )]
-final class GreaterThan extends AbstractComparison
+final class GreaterThan extends Comparison
 {
     protected function compare(mixed $left, mixed $right): bool
     {

library/Rules/Identical.php

@@ -15,7 +15,7 @@ use Respect\Validation\Message\Template;
     '{{name}} must be identical as {{compareTo}}',
     '{{name}} must not be identical as {{compareTo}}',
 )]
-final class Identical extends AbstractComparison
+final class Identical extends Comparison
 {
     protected function compare(mixed $left, mixed $right): bool
     {

library/Rules/LessThan.php

@@ -15,7 +15,7 @@ use Respect\Validation\Message\Template;
     '{{name}} must be less than {{compareTo}}',
     '{{name}} must not be less than {{compareTo}}',
 )]
-final class LessThan extends AbstractComparison
+final class LessThan extends Comparison
 {
     protected function compare(mixed $left, mixed $right): bool
     {

library/Rules/Max.php

@@ -15,7 +15,7 @@ use Respect\Validation\Message\Template;
     '{{name}} must be less than or equal to {{compareTo}}',
     '{{name}} must not be less than or equal to {{compareTo}}',
 )]
-final class Max extends AbstractComparison
+final class Max extends Comparison
 {
     protected function compare(mixed $left, mixed $right): bool
     {

library/Rules/Min.php

@@ -15,7 +15,7 @@ use Respect\Validation\Message\Template;
     '{{name}} must be greater than or equal to {{compareTo}}',
     '{{name}} must not be greater than or equal to {{compareTo}}',
 )]
-final class Min extends AbstractComparison
+final class Min extends Comparison
 {
     protected function compare(mixed $left, mixed $right): bool
     {

tests/unit/Rules/EqualsTest.php

@@ -11,7 +11,6 @@ namespace Respect\Validation\Rules;
 
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\Group;
-use PHPUnit\Framework\Attributes\Test;
 use Respect\Validation\Test\RuleTestCase;
 use stdClass;
 
@@ -19,16 +18,6 @@ use stdClass;
 #[CoversClass(Equals::class)]
 final class EqualsTest extends RuleTestCase
 {
-    #[Test]
-    public function shouldPassCompareToParameterToException(): void
-    {
-        $compareTo = new stdClass();
-        $equals = new Equals($compareTo);
-        $exception = $equals->reportError('input');
-
-        self::assertSame($compareTo, $exception->getParam('compareTo'));
-    }
-
     /** @return iterable<array{Equals, mixed}> */
     public static function providerForValidInput(): iterable
     {

tests/unit/Rules/GreaterThanTest.php

@@ -15,7 +15,6 @@ use Respect\Validation\Test\RuleTestCase;
 use Respect\Validation\Test\Stubs\CountableStub;
 
 #[Group('rule')]
-#[CoversClass(AbstractComparison::class)]
 #[CoversClass(GreaterThan::class)]
 final class GreaterThanTest extends RuleTestCase
 {

tests/unit/Rules/IdenticalTest.php

@@ -11,7 +11,6 @@ namespace Respect\Validation\Rules;
 
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\Group;
-use PHPUnit\Framework\Attributes\Test;
 use Respect\Validation\Test\RuleTestCase;
 use stdClass;
 
@@ -19,16 +18,6 @@ use stdClass;
 #[CoversClass(Identical::class)]
 final class IdenticalTest extends RuleTestCase
 {
-    #[Test]
-    public function shouldPassCompareToParameterToException(): void
-    {
-        $compareTo = new stdClass();
-        $rule = new Identical($compareTo);
-        $exception = $rule->reportError('input');
-
-        self::assertSame($compareTo, $exception->getParam('compareTo'));
-    }
-
     /** @return iterable<array{Identical, mixed}> */
     public static function providerForValidInput(): iterable
     {

tests/unit/Rules/LessThanTest.php

@@ -15,7 +15,7 @@ use Respect\Validation\Test\RuleTestCase;
 use Respect\Validation\Test\Stubs\CountableStub;
 
 #[Group('rule')]
-#[CoversClass(AbstractComparison::class)]
+#[CoversClass(Comparison::class)]
 #[CoversClass(LessThan::class)]
 final class LessThanTest extends RuleTestCase
 {

tests/unit/Rules/MaxTest.php

@@ -17,7 +17,6 @@ use Respect\Validation\Test\RuleTestCase;
 use Respect\Validation\Test\Stubs\CountableStub;
 
 #[Group('rule')]
-#[CoversClass(AbstractComparison::class)]
 #[CoversClass(Max::class)]
 final class MaxTest extends RuleTestCase
 {

tests/unit/Rules/MinTest.php

@@ -17,7 +17,6 @@ use Respect\Validation\Test\RuleTestCase;
 use Respect\Validation\Test\Stubs\CountableStub;
 
 #[Group('rule')]
-#[CoversClass(AbstractComparison::class)]
 #[CoversClass(Min::class)]
 final class MinTest extends RuleTestCase
 {