feat: added Email rule

Author: andrepimpao

composer.json

@@ -13,6 +13,7 @@
     ],
     "require": {
         "php": ">=8.1",
+        "egulias/email-validator": "^4.0",
         "symfony/intl": "^6.3",
         "symfony/polyfill-ctype": "^1.27"
     },

src/Exception/EmailException.php

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

src/Rule/Email.php

@@ -0,0 +1,82 @@
+<?php
+
+namespace ProgrammatorDev\YetAnotherPhpValidator\Rule;
+
+use Egulias\EmailValidator\EmailValidator;
+use Egulias\EmailValidator\Validation\NoRFCWarningsValidation;
+use ProgrammatorDev\YetAnotherPhpValidator\Exception\EmailException;
+use ProgrammatorDev\YetAnotherPhpValidator\Exception\UnexpectedOptionException;
+use ProgrammatorDev\YetAnotherPhpValidator\Exception\UnexpectedTypeException;
+
+class Email extends AbstractRule implements RuleInterface
+{
+    public const MODE_HTML5 = 'html5';
+    public const MODE_HTML5_ALLOW_NO_TLD = 'html5-allow-no-tld';
+    public const MODE_STRICT = 'strict';
+
+    private const EMAIL_MODES = [
+        self::MODE_HTML5,
+        self::MODE_HTML5_ALLOW_NO_TLD,
+        self::MODE_STRICT
+    ];
+
+    private const PATTERN_HTML5 = '/^[a-zA-Z0-9.!#$%&\'*+\\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+$/';
+    private const PATTERN_HTML5_ALLOW_NO_TLD = '/^[a-zA-Z0-9.!#$%&\'*+\\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/';
+
+    private const EMAIL_PATTERNS = [
+        self::MODE_HTML5 => self::PATTERN_HTML5,
+        self::MODE_HTML5_ALLOW_NO_TLD => self::PATTERN_HTML5_ALLOW_NO_TLD
+    ];
+
+    // Using array to bypass unallowed callable type in properties
+    private array $normalizer;
+
+    public function __construct(
+        private readonly string $mode = self::MODE_HTML5,
+        ?callable $normalizer = null,
+        private readonly string $message = 'The {{ name }} value is not a valid email address, {{ value }} given.'
+    )
+    {
+        $this->normalizer['callable'] = $normalizer;
+    }
+
+    public function assert(mixed $value, ?string $name = null): void
+    {
+        if (!\in_array($this->mode, self::EMAIL_MODES, true)) {
+            throw new UnexpectedOptionException('mode', self::EMAIL_MODES, $this->mode);
+        }
+
+        if (!\is_string($value)) {
+            throw new UnexpectedTypeException('string', get_debug_type($value));
+        }
+
+        if ($this->normalizer['callable'] !== null) {
+            $value = ($this->normalizer['callable'])($value);
+        }
+
+        if ($this->mode === self::MODE_STRICT) {
+            $emailValidator = new EmailValidator();
+
+            if (!$emailValidator->isValid($value, new NoRFCWarningsValidation())) {
+                throw new EmailException(
+                    message: $this->message,
+                    parameters: [
+                        'value' => $value,
+                        'name' => $name,
+                        'mode' => $this->mode
+                    ]
+                );
+            }
+        }
+        else if (!\preg_match(self::EMAIL_PATTERNS[$this->mode], $value)) {
+            throw new EmailException(
+                message: $this->message,
+                parameters: [
+                    'value' => $value,
+                    'name' => $name,
+                    'mode' => $this->mode
+                ]
+            );
+        }
+    }
+}

src/Rule/NotBlank.php

@@ -22,16 +22,12 @@ public function __construct(
      */
     public function assert(mixed $value, ?string $name = null): void
     {
-        // Keep original value for parameter
-        $input = $value;
-
-        // Call normalizer if provided
         if ($this->normalizer['callable'] !== null) {
-            $input = ($this->normalizer['callable'])($input);
+            $value = ($this->normalizer['callable'])($value);
         }
 
         // 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: [

tests/EmailTest.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace ProgrammatorDev\YetAnotherPhpValidator\Test;
+
+use ProgrammatorDev\YetAnotherPhpValidator\Exception\EmailException;
+use ProgrammatorDev\YetAnotherPhpValidator\Rule\Email;
+use ProgrammatorDev\YetAnotherPhpValidator\Test\Util\TestRuleFailureConditionTrait;
+use ProgrammatorDev\YetAnotherPhpValidator\Test\Util\TestRuleMessageOptionTrait;
+use ProgrammatorDev\YetAnotherPhpValidator\Test\Util\TestRuleSuccessConditionTrait;
+use ProgrammatorDev\YetAnotherPhpValidator\Test\Util\TestRuleUnexpectedValueTrait;
+
+class EmailTest extends AbstractTest
+{
+    use TestRuleUnexpectedValueTrait;
+    use TestRuleFailureConditionTrait;
+    use TestRuleSuccessConditionTrait;
+    use TestRuleMessageOptionTrait;
+
+    public static function provideRuleUnexpectedValueData(): \Generator
+    {
+        $optionMessage = '/Invalid (.*) "(.*)". Accepted values are: "(.*)"./';
+        $typeMessage = '/Expected value of type "string", "(.*)" given./';
+
+        yield 'invalid option' => [new Email('invalid'), 'test@example.com', $optionMessage];
+        yield 'invalid type' => [new Email(), 1, $typeMessage];
+    }
+
+    public static function provideRuleFailureConditionData(): \Generator
+    {
+        $exception = EmailException::class;
+        $message = '/The (.*) value is not a valid email address, (.*) given./';
+
+        yield 'html5' => [new Email('html5'), 'invalid', $exception, $message];
+        yield 'html5 without tld' => [new Email('html5'), 'test@example', $exception, $message];
+        yield 'html5-allow-no-tld' => [new Email('html5-allow-no-tld'), 'invalid', $exception, $message];
+        yield 'strict' => [new Email('strict'), 'invalid', $exception, $message];
+    }
+
+    public static function provideRuleSuccessConditionData(): \Generator
+    {
+        yield 'html5' => [new Email('html5'), 'test@example.com'];
+        yield 'html5-allow-no-tld' => [new Email('html5-allow-no-tld'), 'test@example.com'];
+        yield 'html5-allow-no-tld without tld' => [new Email('html5-allow-no-tld'), 'test@example'];
+        yield 'strict' => [new Email('strict'), 'test@example.com'];
+        yield 'normalizer' => [new Email(normalizer: 'trim'), 'test@example.com '];
+    }
+
+    public static function provideRuleMessageOptionData(): \Generator
+    {
+        yield 'message' => [
+            new Email(
+                message: 'The {{ name }} value {{ value }} in {{ mode }} mode is not a valid email address.'
+            ),
+            'invalid',
+            'The test value "invalid" in "html5" mode is not a valid email address.'
+        ];
+    }
+}