feat: added Choice rule

Author: andrepimpao

src/ChainedValidatorInterface.php

@@ -20,4 +20,6 @@ public function notBlank(array $options = []): ChainedValidatorInterface;
     public function greaterThan(mixed $constraint, array $options = []): ChainedValidatorInterface;
 
     public function lessThan(mixed $constraint, array $options = []): ChainedValidatorInterface;
+
+    public function choice(array $constraints, bool $isMultiple = false, ?int $minConstraint = null, ?int $maxConstraint = null, array $options = []): ChainedValidatorInterface;
 }

src/Exception/ChoiceException.php

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

src/Exception/UnexpectedValueException.php

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

src/Rule/Choice.php

@@ -0,0 +1,101 @@
+<?php
+
+namespace ProgrammatorDev\YetAnotherPhpValidator\Rule;
+
+use ProgrammatorDev\YetAnotherPhpValidator\Exception\ChoiceException;
+use ProgrammatorDev\YetAnotherPhpValidator\Exception\UnexpectedValueException;
+use Symfony\Component\OptionsResolver\OptionsResolver;
+
+class Choice extends AbstractRule implements RuleInterface
+{
+    private array $options;
+
+    public function __construct(
+        private readonly array $constraints,
+        private readonly bool $isMultiple = false,
+        private readonly ?int $minConstraint = null,
+        private readonly ?int $maxConstraint = null,
+        array $options = []
+    )
+    {
+        $resolver = new OptionsResolver();
+
+        $resolver->setDefaults([
+            'message' => 'The "{{ name }}" value is not a valid choice, "{{ value }}" given. Accepted values are: "{{ constraints }}".',
+            'maxMessage' => 'The "{{ name }}" value must have at most {{ maxConstraint }} choices, {{ numValues }} choices given.',
+            'minMessage' => 'The "{{ name }}" value must have at least {{ minConstraint }} choices, {{ numValues }} choices given.',
+            'multipleMessage' => 'The "{{ name }}" value has one or more invalid choices, "{{ value }}" given. Accepted values are: "{{ constraints }}".'
+        ]);
+
+        $resolver->setAllowedTypes('message', 'string');
+        $resolver->setAllowedTypes('maxMessage', 'string');
+        $resolver->setAllowedTypes('minMessage', 'string');
+        $resolver->setAllowedTypes('multipleMessage', 'string');
+
+        $this->options = $resolver->resolve($options);
+    }
+
+    public function assert(mixed $value, string $name): void
+    {
+        if ($this->isMultiple && !\is_array($value)) {
+            throw new UnexpectedValueException(
+                \sprintf('Expected value of type "array", "%s" given', get_debug_type($value))
+            );
+        }
+
+        if ($this->isMultiple) {
+            foreach ($value as $input) {
+                if (!\in_array($input, $this->constraints, true)) {
+                    throw new ChoiceException(
+                        message: $this->options['multipleMessage'],
+                        parameters: [
+                            'value' => $value,
+                            'name' => $name,
+                            'constraints' => $this->constraints
+                        ]
+                    );
+                }
+            }
+
+            $numValues = \count($value);
+
+            if ($this->minConstraint !== null && $numValues < $this->minConstraint) {
+                throw new ChoiceException(
+                    message: $this->options['minMessage'],
+                    parameters: [
+                        'value' => $value,
+                        'numValues' => $numValues,
+                        'name' => $name,
+                        'constraints' => $this->constraints,
+                        'minConstraint' => $this->minConstraint,
+                        'maxConstraint' => $this->maxConstraint
+                    ]
+                );
+            }
+
+            if ($this->maxConstraint !== null && $numValues > $this->maxConstraint) {
+                throw new ChoiceException(
+                    message: $this->options['maxMessage'],
+                    parameters: [
+                        'value' => $value,
+                        'numValues' => $numValues,
+                        'name' => $name,
+                        'constraints' => $this->constraints,
+                        'minConstraint' => $this->minConstraint,
+                        'maxConstraint' => $this->maxConstraint
+                    ]
+                );
+            }
+        }
+        else if (!\in_array($value, $this->constraints, true)) {
+            throw new ChoiceException(
+                message: $this->options['message'],
+                parameters: [
+                    'value' => $value,
+                    'name' => $name,
+                    'constraints' => $this->constraints
+                ]
+            );
+        }
+    }
+}

src/StaticValidatorInterface.php

@@ -9,4 +9,6 @@ public static function notBlank(array $options = []): ChainedValidatorInterface;
     public static function greaterThan(mixed $constraint, array $options = []): ChainedValidatorInterface;
 
     public static function lessThan(mixed $constraint, array $options = []): ChainedValidatorInterface;
+
+    public static function choice(array $constraints, bool $isMultiple = false, ?int $minConstraint = null, ?int $maxConstraint = null, array $options = []): ChainedValidatorInterface;
 }