feat: added Count rule

Author: andrepimpao

src/Exception/CountException.php

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

src/Rule/Count.php

@@ -0,0 +1,70 @@
+<?php
+
+namespace ProgrammatorDev\Validator\Rule;
+
+use ProgrammatorDev\Validator\Exception\CountException;
+use ProgrammatorDev\Validator\Exception\UnexpectedTypeException;
+use ProgrammatorDev\Validator\Exception\UnexpectedValueException;
+
+class Count extends AbstractRule implements RuleInterface
+{
+    private string $minMessage = 'The {{ name }} value should contain {{ min }} elements or more, {{ numElements }} elements given.';
+    private string $maxMessage = 'The {{ name }} value should contain {{ max }} elements or less, {{ numElements }} elements given.';
+    private string $exactMessage = 'The {{ name }} value should contain exactly {{ numElements }} elements, {{ numElements }} elements given.';
+
+    public function __construct(
+        private readonly ?int $min = null,
+        private readonly ?int $max = null,
+        ?string $minMessage = null,
+        ?string $maxMessage = null,
+        ?string $exactMessage = null
+    )
+    {
+        $this->minMessage = $minMessage ?? $this->minMessage;
+        $this->maxMessage = $maxMessage ?? $this->maxMessage;
+        $this->exactMessage = $exactMessage ?? $this->exactMessage;
+    }
+
+    public function assert(mixed $value, ?string $name = null): void
+    {
+        if ($this->min === null && $this->max === null) {
+            throw new UnexpectedValueException('At least one of the options "min" or "max" must be given.');
+        }
+
+        if (!\is_countable($value)) {
+            throw new UnexpectedTypeException('array|\Countable', get_debug_type($value));
+        }
+
+        $numElements = \count($value);
+
+        if ($this->min !== null && $numElements < $this->min) {
+            $message = $this->min === $this->max ? $this->exactMessage : $this->minMessage;
+
+            throw new CountException(
+                message: $message,
+                parameters: [
+                    'value' => $value,
+                    'name' => $name,
+                    'min' => $this->min,
+                    'max' => $this->max,
+                    'numElements' => $numElements
+                ]
+            );
+        }
+
+        if ($this->max !== null && $numElements > $this->max) {
+            $message = $this->min === $this->max ? $this->exactMessage : $this->maxMessage;
+
+            throw new CountException(
+                message: $message,
+                parameters: [
+                    'value' => $value,
+                    'name' => $name,
+                    'min' => $this->min,
+                    'max' => $this->max,
+                    'numElements' => $numElements
+                ]
+            );
+        }
+    }
+}

tests/CountTest.php

@@ -0,0 +1,82 @@
+<?php
+
+namespace ProgrammatorDev\Validator\Test;
+
+use ProgrammatorDev\Validator\Exception\CountException;
+use ProgrammatorDev\Validator\Rule\Count;
+use ProgrammatorDev\Validator\Test\Util\TestRuleFailureConditionTrait;
+use ProgrammatorDev\Validator\Test\Util\TestRuleMessageOptionTrait;
+use ProgrammatorDev\Validator\Test\Util\TestRuleSuccessConditionTrait;
+use ProgrammatorDev\Validator\Test\Util\TestRuleUnexpectedValueTrait;
+
+class CountTest extends AbstractTest
+{
+    use TestRuleUnexpectedValueTrait;
+    use TestRuleFailureConditionTrait;
+    use TestRuleSuccessConditionTrait;
+    use TestRuleMessageOptionTrait;
+
+    public static function provideRuleUnexpectedValueData(): \Generator
+    {
+        $missingOptionsMessage = '/At least one of the options "min" or "max" must be given./';
+        $invalidTypeMessage = '/Expected value of type "array|\Countable", "(.*)" given./';
+
+        yield 'missing options' => [new Count(), [1, 2, 3], $missingOptionsMessage];
+        yield 'invalid type value' => [new Count(min: 5, max: 10), 1, $invalidTypeMessage];
+    }
+
+    public static function provideRuleFailureConditionData(): \Generator
+    {
+        $value = [1, 2, 3, 4, 5];
+        $exception = CountException::class;
+        $minMessage = '/The (.*) value should contain (.*) elements or more, (.*) elements given./';
+        $maxMessage = '/The (.*) value should contain (.*) elements or less, (.*) elements given./';
+        $exactMessage = '/The (.*) value should contain exactly (.*) elements, (.*) elements given./';
+
+        yield 'min constraint' => [new Count(min: 10), $value, $exception, $minMessage];
+        yield 'max constraint' => [new Count(max: 2), $value, $exception, $maxMessage];
+        yield 'min and max constraint' => [new Count(min: 10, max: 20), $value, $exception, $minMessage];
+        yield 'exact constraint' => [new Count(min: 2, max: 2), $value, $exception, $exactMessage];
+    }
+
+    public static function provideRuleSuccessConditionData(): \Generator
+    {
+        $value = [1, 2, 3, 4, 5];
+
+        yield 'min constraint' => [new Count(min: 5), $value];
+        yield 'max constraint' => [new Count(max: 5), $value];
+        yield 'min and max constraint' => [new Count(min: 4, max: 6), $value];
+        yield 'exact constraint' => [new Count(min: 5, max: 5), $value];
+    }
+
+    public static function provideRuleMessageOptionData(): \Generator
+    {
+        $value = [1, 2, 3, 4, 5];
+
+        yield 'min message' => [
+            new Count(
+                min: 10,
+                minMessage: 'The {{ name }} value should have at least {{ min }} elements.'
+            ),
+            $value,
+            'The test value should have at least 10 elements.'
+        ];
+        yield 'max message' => [
+            new Count(
+                max: 2,
+                maxMessage: 'The {{ name }} value should have at most {{ max }} elements.'
+            ),
+            $value,
+            'The test value should have at most 2 elements.'
+        ];
+        yield 'exact message' => [
+            new Count(
+                min: 2,
+                max: 2,
+                exactMessage: 'The {{ name }} value should have exactly {{ min }} elements.'
+            ),
+            $value,
+            'The test value should have exactly 2 elements.'
+        ];
+    }
+}