feat: added LessThan rule

Author: andrepimpao

src/ChainedValidatorInterface.php

@@ -15,7 +15,9 @@ public function validate(mixed $value): bool;
 
     // --- Rules ---
 
-    public function notBlank(string $message = null): ChainedValidatorInterface;
+    public function notBlank(array $options = []): ChainedValidatorInterface;
 
-    public function greaterThan(mixed $constraint, string $message = null): ChainedValidatorInterface;
+    public function greaterThan(mixed $constraint, array $options = []): ChainedValidatorInterface;
+
+    public function lessThan(mixed $constraint, array $options = []): ChainedValidatorInterface;
 }

src/Exception/LessThanException.php

@@ -0,0 +1,5 @@
+<?php
+
+namespace ProgrammatorDev\YetAnotherPhpValidator\Exception;
+
+class LessThanException extends ValidationException {}

src/Factory.php src/Factory/Factory.phpsrc/Factory.php renamed to src/Factory/Factory.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace ProgrammatorDev\YetAnotherPhpValidator;
+namespace ProgrammatorDev\YetAnotherPhpValidator\Factory;
 
 use ProgrammatorDev\YetAnotherPhpValidator\Exception\RuleNotFoundException;
 use ProgrammatorDev\YetAnotherPhpValidator\Rule\RuleInterface;

src/Rule/LessThan.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace ProgrammatorDev\YetAnotherPhpValidator\Rule;
+
+use ProgrammatorDev\YetAnotherPhpValidator\Exception\LessThanException;
+use ProgrammatorDev\YetAnotherPhpValidator\Rule\Util\AssertComparableTrait;
+use Symfony\Component\OptionsResolver\OptionsResolver;
+
+class LessThan extends AbstractRule implements RuleInterface
+{
+    use AssertComparableTrait;
+
+    private array $options;
+
+    public function __construct(private readonly mixed $constraint, array $options = [])
+    {
+        $resolver = new OptionsResolver();
+
+        $resolver->setDefaults(['message' => 'The "{{ name }}" value should be less than "{{ constraint }}", "{{ value }}" given.']);
+
+        $resolver->setAllowedTypes('message', 'string');
+
+        $this->options = $resolver->resolve($options);
+    }
+
+    /**
+     * @throws LessThanException
+     */
+    public function assert(mixed $value, string $name): void
+    {
+        // Assert if constraint and value can be compared
+        $this->assertComparable($this->constraint, $value, LessThanException::class);
+
+        if (!($value < $this->constraint)) {
+            throw new LessThanException(
+                message: $this->options['message'],
+                parameters: [
+                    'name' => $name,
+                    'constraint' => $this->constraint,
+                    'value' => $value
+                ]
+            );
+        }
+    }
+}

src/StaticValidatorInterface.php

@@ -4,7 +4,9 @@
 
 interface StaticValidatorInterface
 {
-    public static function notBlank(string $message = null): ChainedValidatorInterface;
+    public static function notBlank(array $options = []): ChainedValidatorInterface;
 
-    public static function greaterThan(mixed $constraint, string $message = null): ChainedValidatorInterface;
+    public static function greaterThan(mixed $constraint, array $options = []): ChainedValidatorInterface;
+
+    public static function lessThan(mixed $constraint, array $options = []): ChainedValidatorInterface;
 }

src/Validator.php

@@ -4,6 +4,7 @@
 
 use ProgrammatorDev\YetAnotherPhpValidator\Exception\RuleNotFoundException;
 use ProgrammatorDev\YetAnotherPhpValidator\Exception\ValidationException;
+use ProgrammatorDev\YetAnotherPhpValidator\Factory\Factory;
 use ProgrammatorDev\YetAnotherPhpValidator\Rule\RuleInterface;
 
 /**

tests/LessThanTest.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace ProgrammatorDev\YetAnotherPhpValidator\Test;
+
+use ProgrammatorDev\YetAnotherPhpValidator\Exception\LessThanException;
+use ProgrammatorDev\YetAnotherPhpValidator\Rule\LessThan;
+use ProgrammatorDev\YetAnotherPhpValidator\Test\Util\TestRuleCustomMessageTrait;
+use ProgrammatorDev\YetAnotherPhpValidator\Test\Util\TestRuleFailureConditionTrait;
+use ProgrammatorDev\YetAnotherPhpValidator\Test\Util\TestRuleSuccessConditionTrait;
+
+class LessThanTest extends AbstractTest
+{
+    use TestRuleFailureConditionTrait;
+    use TestRuleSuccessConditionTrait;
+    use TestRuleCustomMessageTrait;
+
+    public static function provideRuleFailureConditionData(): \Generator
+    {
+        $exception = LessThanException::class;
+        $exceptionMessageInvalid = '/Cannot compare a type "(.*)" with a type "(.*)"/';
+        $exceptionMessageFailure = '/The "(.*)" value should be less than "(.*)", "(.*)" given./';
+
+        yield 'datetime constraint with int value' => [new LessThan(new \DateTime()), 10, $exception, $exceptionMessageInvalid];
+        yield 'datetime constraint with float value' => [new LessThan(new \DateTime()), 1.0, $exception, $exceptionMessageInvalid];
+        yield 'datetime constraint with string value' => [new LessThan(new \DateTime()), 'a', $exception, $exceptionMessageInvalid];
+        yield 'int constraint with string value' => [new LessThan(10), 'a', $exception, $exceptionMessageInvalid];
+        yield 'float constraint with string value' => [new LessThan(1.0), 'a', $exception, $exceptionMessageInvalid];
+        yield 'array constraint' => [new LessThan([10]), 10, $exception, $exceptionMessageInvalid];
+        yield 'null constraint' => [new LessThan(null), 10, $exception, $exceptionMessageInvalid];
+
+        yield 'datetime' => [new LessThan(new \DateTime('today')), new \DateTime('tomorrow'), $exception, $exceptionMessageFailure];
+        yield 'same datetime' => [new LessThan(new \DateTime('today')), new \DateTime('today'), $exception, $exceptionMessageFailure];
+        yield 'int' => [new LessThan(10), 20, $exception, $exceptionMessageFailure];
+        yield 'same int' => [new LessThan(10), 10, $exception, $exceptionMessageFailure];
+        yield 'float' => [new LessThan(10.0), 20.0, $exception, $exceptionMessageFailure];
+        yield 'same float' => [new LessThan(10.0), 10.0, $exception, $exceptionMessageFailure];
+        yield 'int with float' => [new LessThan(10), 20.0, $exception, $exceptionMessageFailure];
+        yield 'same int with float' => [new LessThan(10), 10.0, $exception, $exceptionMessageFailure];
+        yield 'string' => [new LessThan('a'), 'z', $exception, $exceptionMessageFailure];
+        yield 'same string' => [new LessThan('a'), 'a', $exception, $exceptionMessageFailure];
+    }
+
+    public static function provideRuleSuccessConditionData(): \Generator
+    {
+        yield 'datetime' => [new LessThan(new \DateTime('today')), new \DateTime('yesterday')];
+        yield 'int' => [new LessThan(10), 1];
+        yield 'float' => [new LessThan(10.0), 1.0];
+        yield 'int with float' => [new LessThan(10), 1.0];
+        yield 'string' => [new LessThan('z'), 'a'];
+    }
+
+    public static function provideRuleCustomMessageData(): \Generator
+    {
+        yield 'message' => [
+            new LessThan(10, [
+                'message' => 'The "{{ name }}" value "{{ value }}" is not less than "{{ constraint }}".'
+            ]),
+            20,
+            'The "test" value "20" is not less than "10".'
+        ];
+    }
+}