Merge pull request #13 from programmatordev/YAPV-13-add-custom-rule

Create custom rule

Author: andrepimpao

src/ChainedValidatorInterface.php

@@ -3,6 +3,7 @@
 namespace ProgrammatorDev\YetAnotherPhpValidator;
 
 use ProgrammatorDev\YetAnotherPhpValidator\Exception\ValidationException;
+use ProgrammatorDev\YetAnotherPhpValidator\Rule\RuleInterface;
 
 interface ChainedValidatorInterface
 {
@@ -30,4 +31,6 @@ public function lessThanOrEqual(mixed $constraint, array $options = []): Chained
     public function notBlank(array $options = []): ChainedValidatorInterface;
 
     public function range(mixed $minConstraint, mixed $maxConstraint, array $options = []): ChainedValidatorInterface;
+
+    public function rule(RuleInterface $constraint): ChainedValidatorInterface;
 }

src/Factory/Factory.php

@@ -7,21 +7,23 @@
 
 class Factory
 {
-    private string $namespace = 'ProgrammatorDev\\YetAnotherPhpValidator\\Rule';
+    private array $namespaces = ['ProgrammatorDev\\YetAnotherPhpValidator\\Rule'];
 
     /**
      * @throws RuleNotFoundException
      */
     public function createRule(string $ruleName, array $arguments = []): RuleInterface
     {
-        $className = \sprintf('%s\\%s', $this->namespace, \ucfirst($ruleName));
+        foreach ($this->namespaces as $namespace) {
+            $className = \sprintf('%s\\%s', $namespace, \ucfirst($ruleName));
 
-        if (!class_exists($className)) {
-            throw new RuleNotFoundException(
-                \sprintf('"%s" rule does not exist.', $ruleName)
-            );
+            if (class_exists($className)) {
+                return new $className(...$arguments);
+            }
         }
 
-        return new $className(...$arguments);
+        throw new RuleNotFoundException(
+            \sprintf('"%s" rule does not exist.', $ruleName)
+        );
     }
 }

src/Rule/All.php

@@ -41,23 +41,23 @@ public function assert(mixed $value, string $name): void
             );
         }
 
-        try {
-            foreach ($value as $key => $input) {
-                foreach ($this->constraints as $constraint) {
+        foreach ($value as $key => $input) {
+            foreach ($this->constraints as $constraint) {
+                try {
                     $constraint->assert($input, $name);
                 }
+                catch (ValidationException $exception) {
+                    throw new AllException(
+                        message: $this->options['message'],
+                        parameters: [
+                            'value' => $value,
+                            'name' => $name,
+                            'key' => $key,
+                            'message' => $exception->getMessage()
+                        ]
+                    );
+                }
             }
         }
-        catch (ValidationException $exception) {
-            throw new AllException(
-                message: $this->options['message'],
-                parameters: [
-                    'value' => $value,
-                    'name' => $name,
-                    'key' => $key,
-                    'message' => $exception->getMessage()
-                ]
-            );
-        }
     }
 }

src/Rule/Rule.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace ProgrammatorDev\YetAnotherPhpValidator\Rule;
+
+class Rule extends AbstractRule implements RuleInterface
+{
+    public function __construct(private readonly RuleInterface $constraint) {}
+
+    public function assert(mixed $value, string $name): void
+    {
+        $this->constraint->assert($value, $name);
+    }
+}

src/StaticValidatorInterface.php

@@ -2,6 +2,8 @@
 
 namespace ProgrammatorDev\YetAnotherPhpValidator;
 
+use ProgrammatorDev\YetAnotherPhpValidator\Rule\RuleInterface;
+
 interface StaticValidatorInterface
 {
     public static function all(array $constraints, array $options = null): ChainedValidatorInterface;
@@ -19,4 +21,6 @@ public static function lessThanOrEqual(mixed $constraint, array $options = []):
     public static function notBlank(array $options = []): ChainedValidatorInterface;
 
     public static function range(mixed $minConstraint, mixed $maxConstraint, array $options = []): ChainedValidatorInterface;
+
+    public static function rule(RuleInterface $constraint): ChainedValidatorInterface;
 }

src/Test/Fixture/DummyRule.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace ProgrammatorDev\YetAnotherPhpValidator\Test\Fixture;
+
+use ProgrammatorDev\YetAnotherPhpValidator\Exception\UnexpectedValueException;
+use ProgrammatorDev\YetAnotherPhpValidator\Exception\ValidationException;
+use ProgrammatorDev\YetAnotherPhpValidator\Rule\AbstractRule;
+use ProgrammatorDev\YetAnotherPhpValidator\Rule\RuleInterface;
+
+class DummyRule extends AbstractRule implements RuleInterface
+{
+    public function assert(mixed $value, string $name): void
+    {
+        if (!\is_bool($value)) {
+            throw new UnexpectedValueException('Dummy unexpected value.');
+        }
+
+        if ($value === false) {
+            throw new ValidationException('Dummy exception.');
+        }
+    }
+}

tests/FactoryTest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace ProgrammatorDev\YetAnotherPhpValidator\Test;
+
+use ProgrammatorDev\YetAnotherPhpValidator\Exception\RuleNotFoundException;
+use ProgrammatorDev\YetAnotherPhpValidator\Factory\Factory;
+use ProgrammatorDev\YetAnotherPhpValidator\Rule\RuleInterface;
+
+class FactoryTest extends AbstractTest
+{
+    private Factory $factory;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->factory = new Factory();
+    }
+
+    public function testFactoryCreateRuleFailure()
+    {
+        $this->expectException(RuleNotFoundException::class);
+        $this->expectExceptionMessage('"invalidRule" rule does not exist.');
+        $this->factory->createRule('invalidRule');
+    }
+
+    public function testFactoryCreateRuleSuccess()
+    {
+        $this->assertInstanceOf(RuleInterface::class, $this->factory->createRule('notBlank'));
+    }
+}

tests/RuleTest.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace ProgrammatorDev\YetAnotherPhpValidator\Test;
+
+use ProgrammatorDev\YetAnotherPhpValidator\Exception\ValidationException;
+use ProgrammatorDev\YetAnotherPhpValidator\Rule\Rule;
+use ProgrammatorDev\YetAnotherPhpValidator\Test\Fixture\DummyRule;
+use ProgrammatorDev\YetAnotherPhpValidator\Test\Util\TestRuleFailureConditionTrait;
+use ProgrammatorDev\YetAnotherPhpValidator\Test\Util\TestRuleSuccessConditionTrait;
+use ProgrammatorDev\YetAnotherPhpValidator\Test\Util\TestRuleUnexpectedValueTrait;
+
+class RuleTest extends AbstractTest
+{
+    use TestRuleUnexpectedValueTrait;
+    use TestRuleFailureConditionTrait;
+    use TestRuleSuccessConditionTrait;
+
+    public static function provideRuleUnexpectedValueData(): \Generator
+    {
+        yield 'invalid value type' => [
+            new Rule(new DummyRule()),
+            'invalid',
+            '/Dummy unexpected value./'
+        ];
+    }
+
+    public static function provideRuleFailureConditionData(): \Generator
+    {
+        yield 'invalid value' => [
+            new Rule(new DummyRule()),
+            false,
+            ValidationException::class,
+            '/Dummy exception./'
+        ];
+    }
+
+    public static function provideRuleSuccessConditionData(): \Generator
+    {
+        yield 'valid value' => [
+            new Rule(new DummyRule()),
+            true
+        ];
+    }
+
+}