regexp => pattern (like in the json spec)

Author: dominikzogg

src/Schema/StringSchema.php

@@ -46,6 +46,9 @@ final class StringSchema extends AbstractSchemaInnerParse implements SchemaInter
     public const string ERROR_MATCH_CODE = 'string.match';
     public const string ERROR_MATCH_TEMPLATE = '{{given}} does not match {{match}}';
 
+    public const string ERROR_PATTERN_CODE = 'string.pattern';
+    public const string ERROR_PATTERN_TEMPLATE = '{{given}} does not pattern {{pattern}}';
+
     public const string ERROR_REGEXP_CODE = 'string.regexp';
     public const string ERROR_REGEXP_TEMPLATE = '{{given}} does not regexp {{regexp}}';
 
@@ -263,11 +266,11 @@ public function mac(): static
     }
 
     /**
-     * @deprecated: use regexp
+     * @deprecated: use pattern
      */
     public function match(string $match): static
     {
-        @trigger_error('Use regexp instead', E_USER_DEPRECATED);
+        @trigger_error('Use pattern instead', E_USER_DEPRECATED);
 
         if (false === @preg_match($match, '')) {
             throw new \InvalidArgumentException(\sprintf('Invalid match "%s" given', $match));
@@ -290,8 +293,36 @@ public function match(string $match): static
         });
     }
 
+    public function pattern(string $pattern): static
+    {
+        if (false === @preg_match($pattern, '')) {
+            throw new \InvalidArgumentException(\sprintf('Invalid pattern "%s" given', $pattern));
+        }
+
+        return $this->postParse(static function (string $string) use ($pattern) {
+            $doesMatch = filter_var($string, FILTER_VALIDATE_REGEXP, ['options' => ['regexp' => $pattern]]);
+
+            if (false === $doesMatch) {
+                throw new ErrorsException(
+                    new Error(
+                        self::ERROR_PATTERN_CODE,
+                        self::ERROR_PATTERN_TEMPLATE,
+                        ['pattern' => $pattern, 'given' => $string]
+                    )
+                );
+            }
+
+            return $string;
+        });
+    }
+
+    /**
+     * @deprecated: use pattern
+     */
     public function regexp(string $regexp): static
     {
+        @trigger_error('Use pattern instead', E_USER_DEPRECATED);
+
         if (false === @preg_match($regexp, '')) {
             throw new \InvalidArgumentException(\sprintf('Invalid regexp "%s" given', $regexp));
         }

tests/Unit/Schema/StringSchemaTest.php

@@ -570,7 +570,7 @@ public function testParseWithValidMatch(): void
         self::assertArrayHasKey('type', $lastError);
         self::assertSame(E_USER_DEPRECATED, $lastError['type']);
         self::assertArrayHasKey('message', $lastError);
-        self::assertSame('Use regexp instead', $lastError['message']);
+        self::assertSame('Use pattern instead', $lastError['message']);
     }
 
     public function testParseWithInvalidMatch(): void
@@ -600,6 +600,53 @@ public function testParseWithInvalidMatch(): void
         }
     }
 
+    public function testParseWithPatternWithInvalidPattern(): void
+    {
+        try {
+            (new StringSchema())->pattern('test');
+
+            throw new \Exception('code should not be reached');
+        } catch (\InvalidArgumentException $e) {
+            self::assertSame('Invalid pattern "test" given', $e->getMessage());
+        }
+    }
+
+    public function testParseWithValidPattern(): void
+    {
+        $input = 'aBcDeFg';
+
+        $schema = (new StringSchema())->pattern('/^[a-z]+$/i');
+
+        self::assertSame($input, $schema->parse($input));
+    }
+
+    public function testParseWithInvalidPattern(): void
+    {
+        $input = 'a1B2C3d4';
+
+        $schema = (new StringSchema())->pattern('/^[a-z]+$/i');
+
+        try {
+            $schema->parse($input);
+
+            throw new \Exception('code should not be reached');
+        } catch (ErrorsException $errorsException) {
+            self::assertSame([
+                [
+                    'path' => '',
+                    'error' => [
+                        'code' => 'string.pattern',
+                        'template' => '{{given}} does not pattern {{pattern}}',
+                        'variables' => [
+                            'pattern' => '/^[a-z]+$/i',
+                            'given' => $input,
+                        ],
+                    ],
+                ],
+            ], $errorsException->errors->jsonSerialize());
+        }
+    }
+
     public function testParseWithRegexpWithInvalidPattern(): void
     {
         try {
@@ -613,11 +660,21 @@ public function testParseWithRegexpWithInvalidPattern(): void
 
     public function testParseWithValidRegexp(): void
     {
+        error_clear_last();
+
         $input = 'aBcDeFg';
 
         $schema = (new StringSchema())->regexp('/^[a-z]+$/i');
 
         self::assertSame($input, $schema->parse($input));
+
+        $lastError = error_get_last();
+
+        self::assertNotNull($lastError);
+        self::assertArrayHasKey('type', $lastError);
+        self::assertSame(E_USER_DEPRECATED, $lastError['type']);
+        self::assertArrayHasKey('message', $lastError);
+        self::assertSame('Use pattern instead', $lastError['message']);
     }
 
     public function testParseWithInvalidRegexp(): void