Merge pull request #3 from programmatordev/YAPV-10-create-greaterthan-rule

andrepimpao · web-flow · commit fd10fad393c2 · 2023-07-29T18:28:10.000+01:00
Create GreaterThan rule
diff --git a/src/ChainedValidatorInterface.php b/src/ChainedValidatorInterface.php
@@ -6,18 +6,16 @@
 
 interface ChainedValidatorInterface
 {
-    // --- Common ---
-
-    public function validate(mixed $input): bool;
-
     /**
      * @throws ValidationException
      */
-    public function assert(mixed $input, string $name): void;
+    public function assert(mixed $value, string $name): void;
+
+    public function validate(mixed $value): bool;
 
     // --- Rules ---
 
-    public function notBlank(?string $message = null): ChainedValidatorInterface;
+    public function notBlank(string $message = null): ChainedValidatorInterface;
 
-//    public function greaterThan(mixed $constraint): ChainedValidatorInterface;
+    public function greaterThan(mixed $constraint, string $message = null): ChainedValidatorInterface;
 }
diff --git a/src/Exception/GreaterThanException.php b/src/Exception/GreaterThanException.php
@@ -0,0 +1,5 @@
+<?php
+
+namespace ProgrammatorDev\YetAnotherPhpValidator\Exception;
+
+class GreaterThanException extends ValidationException {}
diff --git a/src/Exception/InvalidRuleException.php b/src/Exception/InvalidRuleException.php
diff --git a/src/Exception/RuleNotFoundException.php b/src/Exception/RuleNotFoundException.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace ProgrammatorDev\YetAnotherPhpValidator\Exception;
+
+class RuleNotFoundException extends \Exception
+{
+    protected $message = 'Rule does not exist.';
+}
diff --git a/src/Exception/ValidationException.php b/src/Exception/ValidationException.php
@@ -38,7 +38,7 @@ private function formatValue(mixed $value): string
         }
 
         if (\is_string($value)) {
-            return \sprintf('"%s"', $value);
+            return $value;
         }
 
         if (\is_resource($value)) {
@@ -66,6 +66,6 @@ private function formatValues(array $values): string
             $values[$key] = $this->formatValue($value);
         }
 
-        return \implode(', ', $values);
+        return \sprintf('[%s]', \implode(', ', $values));
     }
 }
diff --git a/src/Factory.php b/src/Factory.php
@@ -2,26 +2,26 @@
 
 namespace ProgrammatorDev\YetAnotherPhpValidator;
 
-use ProgrammatorDev\YetAnotherPhpValidator\Exception\InvalidRuleException;
+use ProgrammatorDev\YetAnotherPhpValidator\Exception\RuleNotFoundException;
 use ProgrammatorDev\YetAnotherPhpValidator\Rule\RuleInterface;
 
 class Factory
 {
     private string $namespace = 'ProgrammatorDev\\YetAnotherPhpValidator\\Rule';
 
     /**
-     * @throws InvalidRuleException
+     * @throws RuleNotFoundException
      */
     public function createRule(string $ruleName, array $arguments = []): RuleInterface
     {
-        try {
-            $className = \sprintf('%s\\%s', $this->namespace, \ucfirst($ruleName));
-            return new $className(...$arguments);
-        }
-        catch (\Error) {
-            throw new InvalidRuleException(
+        $className = \sprintf('%s\\%s', $this->namespace, \ucfirst($ruleName));
+
+        if (!class_exists($className)) {
+            throw new RuleNotFoundException(
                 \sprintf('"%s" rule does not exist.', $ruleName)
             );
         }
+
+        return new $className(...$arguments);
     }
 }
diff --git a/src/Rule/AbstractRule.php b/src/Rule/AbstractRule.php
@@ -2,19 +2,24 @@
 
 namespace ProgrammatorDev\YetAnotherPhpValidator\Rule;
 
-class AbstractRule
-{
-    private string $name;
-
-    public function getName(): string
-    {
-        return $this->name;
-    }
+use ProgrammatorDev\YetAnotherPhpValidator\Exception\ValidationException;
 
-    public function setName(string $name): static
+abstract class AbstractRule
+{
+    public function validate($value): bool
     {
-        $this->name = $name;
+        try {
+            $this->assert($value, 'null');
+        }
+        catch (ValidationException) {
+            return false;
+        }
 
-        return $this;
+        return true;
     }
+
+    /**
+     * @throws ValidationException
+     */
+    public abstract function assert(mixed $value, string $name): void;
 }
diff --git a/src/Rule/GreaterThan.php b/src/Rule/GreaterThan.php
@@ -0,0 +1,41 @@
+<?php
+
+namespace ProgrammatorDev\YetAnotherPhpValidator\Rule;
+
+use ProgrammatorDev\YetAnotherPhpValidator\Exception\GreaterThanException;
+use ProgrammatorDev\YetAnotherPhpValidator\Rule\Util\AssertComparableTrait;
+
+class GreaterThan extends AbstractRule implements RuleInterface
+{
+    use AssertComparableTrait;
+
+    private string $message;
+
+    public function __construct(
+        private readonly mixed $constraint,
+        string $message = null
+    )
+    {
+        $this->message = $message ?? 'The "{{ name }}" value should be greater than "{{ constraint }}", "{{ value }}" given.';
+    }
+
+    /**
+     * @throws GreaterThanException
+     */
+    public function assert(mixed $value, string $name): void
+    {
+        // Assert if constraint and value can be compared
+        $this->assertComparable($this->constraint, $value, GreaterThanException::class);
+
+        if (!($value > $this->constraint)) {
+            throw new GreaterThanException(
+                message: $this->message,
+                parameters: [
+                    'name' => $name,
+                    'constraint' => $this->constraint,
+                    'value' => $value
+                ]
+            );
+        }
+    }
+}
diff --git a/src/Rule/NotBlank.php b/src/Rule/NotBlank.php
@@ -6,28 +6,25 @@
 
 class NotBlank extends AbstractRule implements RuleInterface
 {
-    public function __construct(private ?string $message = null)
+    private string $message;
+
+    public function __construct(string $message = null)
     {
-        $this->message ??= 'The {{ name }} value should not be blank.';
+        $this->message = $message ?? 'The "{{ name }}" value should not be blank, "{{ value }}" given.';
     }
 
     /**
      * @throws NotBlankException
      */
-    public function validate(mixed $input): void
+    public function assert(mixed $value, string $name): void
     {
-        // Strip whitespace in case of a string
-        if (\is_string($input)) {
-            $input = trim($input);
-        }
-
         // Do not allow null, false, [] and ''
-        if ($input === false || (empty($input) && $input != '0')) {
+        if ($value === false || (empty($value) && $value != '0')) {
             throw new NotBlankException(
                 message: $this->message,
                 parameters: [
-                    'input' => $input,
-                    'name' => $this->getName()
+                    'name' => $name,
+                    'value' => $value
                 ]
             );
         }
diff --git a/src/Rule/RuleInterface.php b/src/Rule/RuleInterface.php
@@ -9,9 +9,7 @@ interface RuleInterface
     /**
      * @throws ValidationException
      */
-    public function validate(mixed $input): void;
+    public function assert(mixed $value, string $name): void;
 
-    public function getName(): string;
-
-    public function setName(string $name): static;
+    public function validate(mixed $value): bool;
 }
diff --git a/src/Rule/Util/AssertComparableTrait.php b/src/Rule/Util/AssertComparableTrait.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace ProgrammatorDev\YetAnotherPhpValidator\Rule\Util;
+
+trait AssertComparableTrait
+{
+    private function assertComparable(mixed $value1, mixed $value2, string $exception): bool
+    {
+        if ($value1 instanceof \DateTimeInterface && $value2 instanceof \DateTimeInterface) {
+            return true;
+        }
+
+        if (\is_numeric($value1) && \is_numeric($value2)) {
+            return true;
+        }
+
+        if (\is_string($value1) && \is_string($value2)) {
+            return true;
+        }
+
+        throw new $exception(
+            \sprintf(
+                'Cannot compare a type "%s" with a type "%s"',
+                get_debug_type($value1),
+                get_debug_type($value2)
+            )
+        );
+    }
+}
diff --git a/src/StaticValidatorInterface.php b/src/StaticValidatorInterface.php
@@ -4,7 +4,7 @@
 
 interface StaticValidatorInterface
 {
-    public static function notBlank(?string $message = null): ChainedValidatorInterface;
+    public static function notBlank(string $message = null): ChainedValidatorInterface;
 
-//    public static function greaterThan(mixed $constraint): ChainedValidatorInterface;
+    public static function greaterThan(mixed $constraint, string $message = null): ChainedValidatorInterface;
 }
diff --git a/src/Test/Util/TestRuleCustomMessageTrait.php b/src/Test/Util/TestRuleCustomMessageTrait.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace ProgrammatorDev\YetAnotherPhpValidator\Test\Util;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use ProgrammatorDev\YetAnotherPhpValidator\Rule\RuleInterface;
+
+trait TestRuleCustomMessageTrait
+{
+    public static abstract function provideRuleCustomMessageData(): \Generator;
+
+    #[DataProvider('provideRuleCustomMessageData')]
+    public function testRuleCustomMessage(RuleInterface $rule, mixed $value, string $exceptionMessage): void
+    {
+        $this->expectExceptionMessage($exceptionMessage);
+        $rule->assert($value, 'test');
+    }
+}
diff --git a/src/Test/Util/TestRuleFailureConditionTrait.php b/src/Test/Util/TestRuleFailureConditionTrait.php
@@ -0,0 +1,26 @@
+<?php
+
+namespace ProgrammatorDev\YetAnotherPhpValidator\Test\Util;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use ProgrammatorDev\YetAnotherPhpValidator\Rule\RuleInterface;
+
+trait TestRuleFailureConditionTrait
+{
+    public static abstract function provideRuleFailureConditionData(): \Generator;
+
+    #[DataProvider('provideRuleFailureConditionData')]
+    public function testRuleFailureCondition(
+        RuleInterface $rule,
+        mixed $value,
+        string $expectedException,
+        string $expectedExceptionMessage
+    ): void
+    {
+        $this->assertFalse($rule->validate($value));
+
+        $this->expectException($expectedException);
+        $this->expectExceptionMessageMatches($expectedExceptionMessage);
+        $rule->assert($value, 'test');
+    }
+}
diff --git a/src/Test/Util/TestRuleSuccessConditionTrait.php b/src/Test/Util/TestRuleSuccessConditionTrait.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace ProgrammatorDev\YetAnotherPhpValidator\Test\Util;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use ProgrammatorDev\YetAnotherPhpValidator\Rule\RuleInterface;
+
+trait TestRuleSuccessConditionTrait
+{
+    public static abstract function provideRuleSuccessConditionData(): \Generator;
+
+    #[DataProvider('provideRuleSuccessConditionData')]
+    public function testRuleSuccessCondition(RuleInterface $rule, mixed $value): void
+    {
+        $rule->assert($value, 'test');
+
+        $this->assertTrue($rule->validate($value));
+    }
+}
diff --git a/src/Validator.php b/src/Validator.php
@@ -2,7 +2,7 @@
 
 namespace ProgrammatorDev\YetAnotherPhpValidator;
 
-use ProgrammatorDev\YetAnotherPhpValidator\Exception\InvalidRuleException;
+use ProgrammatorDev\YetAnotherPhpValidator\Exception\RuleNotFoundException;
 use ProgrammatorDev\YetAnotherPhpValidator\Exception\ValidationException;
 use ProgrammatorDev\YetAnotherPhpValidator\Rule\RuleInterface;
 
@@ -24,15 +24,15 @@ private static function create(): self
     }
 
     /**
-     * @throws InvalidRuleException
+     * @throws RuleNotFoundException
      */
     public static function __callStatic(string $ruleName, array $arguments = []): self
     {
         return self::create()->__call($ruleName, $arguments);
     }
 
     /**
-     * @throws InvalidRuleException
+     * @throws RuleNotFoundException
      */
     public function __call(string $ruleName, array $arguments = []): self
     {
@@ -45,17 +45,17 @@ public function __call(string $ruleName, array $arguments = []): self
     /**
      * @throws ValidationException
      */
-    public function assert(mixed $input, string $name): void
+    public function assert(mixed $value, string $name): void
     {
         foreach ($this->getRules() as $rule) {
-            $rule->setName($name)->validate($input);
+            $rule->assert($value, $name);
         }
     }
 
-    public function validate(mixed $input): bool
+    public function validate(mixed $value): bool
     {
         try {
-            $this->assert($input, 'null');
+            $this->assert($value, 'null');
         }
         catch (ValidationException) {
             return false;
diff --git a/tests/GreaterThanTest.php b/tests/GreaterThanTest.php
diff --git a/tests/NotBlankTest.php b/tests/NotBlankTest.php

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +<?php
++
 +namespace ProgrammatorDev\YetAnotherPhpValidator\Exception;
++
 +class GreaterThanException extends ValidationException {}
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ private function formatValue(mixed $value): string`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`if (\is_string($value)) {`
`41`		`- return \sprintf('"%s"', $value);`
	`41`	`+ return $value;`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`if (\is_resource($value)) {`
`@@ -66,6 +66,6 @@ private function formatValues(array $values): string`
`66`	`66`	`$values[$key] = $this->formatValue($value);`
`67`	`67`	`}`
`68`	`68`
`69`		`- return \implode(', ', $values);`
	`69`	`+ return \sprintf('[%s]', \implode(', ', $values));`
`70`	`70`	`}`
`71`	`71`	`}`