regexp => pattern (like in the json spec)

Author: dominikzogg

doc/Schema/AssocSchema.md

@@ -158,7 +158,7 @@ echo $config['database']['host']; // 'localhost'
 $addressSchema = $p->assoc([
     'street' => $p->string(),
     'city' => $p->string(),
-    'zipCode' => $p->string()->regexp('/^\d{5}$/'),
+    'zipCode' => $p->string()->pattern('/^\d{5}$/'),
 ]);
 
 $personSchema = $p->assoc([

doc/Schema/DiscriminatedUnionSchema.md

@@ -63,7 +63,7 @@ $contactSchema = $p->discriminatedUnion([
     ]),
     $p->object([
         '_type' => $p->literal('phone'),
-        'number' => $p->string()->regexp('/^\+\d{10,15}$/'),
+        'number' => $p->string()->pattern('/^\+\d{10,15}$/'),
         'country' => $p->string()->length(2),
     ]),
     $p->object([
@@ -124,9 +124,9 @@ $eventSchema = $p->discriminatedUnion([
 $paymentSchema = $p->discriminatedUnion([
     $p->object([
         'method' => $p->literal('credit_card'),
-        'cardNumber' => $p->string()->regexp('/^\d{16}$/'),
-        'expiry' => $p->string()->regexp('/^\d{2}\/\d{2}$/'),
-        'cvv' => $p->string()->regexp('/^\d{3,4}$/'),
+        'cardNumber' => $p->string()->pattern('/^\d{16}$/'),
+        'expiry' => $p->string()->pattern('/^\d{2}\/\d{2}$/'),
+        'cvv' => $p->string()->pattern('/^\d{3,4}$/'),
     ]),
     $p->object([
         'method' => $p->literal('bank_transfer'),

doc/Schema/ObjectSchema.md

@@ -133,7 +133,7 @@ $createUserSchema = $p->object([
 $addressSchema = $p->object([
     'street' => $p->string(),
     'city' => $p->string(),
-    'zipCode' => $p->string()->regexp('/^\d{5}$/'),
+    'zipCode' => $p->string()->pattern('/^\d{5}$/'),
 ]);
 
 $personSchema = $p->object([

doc/Schema/StringSchema.md

@@ -30,7 +30,7 @@ $schema->maxLength(100); // Maximum 100 characters
 $schema->includes('amp');    // Must contain 'amp'
 $schema->startsWith('exa');  // Must start with 'exa'
 $schema->endsWith('ple');    // Must end with 'ple'
-$schema->regexp('/^[a-z]+$/i'); // Must match regex pattern
+$schema->pattern('/^[a-z]+$/i'); // Must match regex pattern
 ```
 
 ### Format Validations
@@ -110,7 +110,7 @@ $usernameSchema = $p->string()
     ->toLowerCase()
     ->minLength(3)
     ->maxLength(20)
-    ->regexp('/^[a-z0-9_]+$/');
+    ->pattern('/^[a-z0-9_]+$/');
 
 $usernameSchema->parse('  John_Doe123  '); // Returns: 'john_doe123'
 ```

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