align function naming with json schema

Author: dominikzogg

README.md

@@ -35,7 +35,7 @@ Heavily inspired by the well-known TypeScript library [zod](https://github.com/c
 Through [Composer](http://getcomposer.org) as [chubbyphp/chubbyphp-parsing][1].
 
 ```sh
-composer require chubbyphp/chubbyphp-parsing "^2.4"
+composer require chubbyphp/chubbyphp-parsing "^2.5"
 ```
 
 ## Quick Start
@@ -49,7 +49,7 @@ $p = new Parser();
 $userSchema = $p->object([
     'name' => $p->string()->minLength(1)->maxLength(100),
     'email' => $p->string()->email(),
-    'age' => $p->int()->gte(0)->lte(150),
+    'age' => $p->int()->minimum(0)->maximum(150),
 ]);
 
 // Parse and validate data
@@ -93,7 +93,7 @@ $user = $userSchema->parse([
 
 | Schema | Description | Documentation |
 |--------|-------------|---------------|
-| `literal()` | Exact value matching | [LiteralSchema](doc/Schema/LiteralSchema.md) |
+| `const()` | Exact value matching | [ConstSchema](doc/Schema/ConstSchema.md) |
 | `backedEnum()` | PHP BackedEnum validation | [BackedEnumSchema](doc/Schema/BackedEnumSchema.md) |
 | `lazy()` | Recursive/self-referencing schemas | [LazySchema](doc/Schema/LazySchema.md) |
 | `respectValidation()` | Integration with Respect/Validation | [RespectValidationSchema](doc/Schema/RespectValidationSchema.md) |

composer.json

@@ -50,7 +50,7 @@
     },
     "extra": {
         "branch-alias": {
-            "dev-master": "2.4-dev"
+            "dev-master": "2.5-dev"
         }
     },
     "scripts": {

doc/ErrorHandling.md

@@ -226,7 +226,7 @@ $p = new Parser();
 $requestSchema = $p->object([
     'name' => $p->string()->trim()->minLength(1)->maxLength(100),
     'email' => $p->string()->trim()->toLowerCase()->email(),
-    'age' => $p->int()->gte(0)->lte(150),
+    'age' => $p->int()->minimum(0)->maximum(150),
 ])->strict();
 
 function handleRequest(array $input): array
@@ -267,8 +267,8 @@ Each schema type uses a consistent error code prefix:
 | Schema | Prefix | Example Codes |
 |--------|--------|---------------|
 | string | `string.` | `string.type`, `string.minLength`, `string.email` |
-| int | `int.` | `int.type`, `int.gt`, `int.positive` |
-| float | `float.` | `float.type`, `float.gte`, `float.negative` |
+| int | `int.` | `int.type`, `int.exclusiveMinimum`, `int.positive` |
+| float | `float.` | `float.type`, `float.minimum`, `float.negative` |
 | bool | `bool.` | `bool.type` |
 | array | `array.` | `array.type`, `array.minLength` |
 | assoc | `assoc.` | `assoc.type`, `assoc.unknownField` |

doc/Schema/ArraySchema.md

@@ -19,15 +19,15 @@ $data = $schema->parse([1, 2, 3, 4, 5]); // Returns: [1, 2, 3, 4, 5]
 ### Length Constraints
 
 ```php
-$schema->length(5);     // Exact length of 5 items
-$schema->minLength(1);  // At least 1 item
-$schema->maxLength(10); // At most 10 items
+$schema->exactItems(5);  // Exact count of 5 items
+$schema->minItems(1);    // At least 1 item
+$schema->maxItems(10);   // At most 10 items
 ```
 
 ### Content Check
 
 ```php
-$schema->includes(5); // Array must contain value 5
+$schema->contains(5); // Array must contain value 5
 ```
 
 ## Transformations
@@ -89,14 +89,14 @@ $sumSchema->parse([1, 2, 3, 4, 5]); // Returns: 15
 ### Non-Empty Array
 
 ```php
-$nonEmptySchema = $p->array($p->string())->minLength(1);
+$nonEmptySchema = $p->array($p->string())->minItems(1);
 ```
 
 ### Unique Tags with Limit
 
 ```php
 $tagsSchema = $p->array($p->string()->trim()->minLength(1))
-    ->maxLength(10)
+    ->maxItems(10)
     ->map(static fn (string $tag) => strtolower($tag));
 ```
 
@@ -147,9 +147,9 @@ $matrixSchema->parse([
 | Code | Description |
 |------|-------------|
 | `array.type` | Value is not an array |
-| `array.length` | Array length doesn't match exact length |
-| `array.minLength` | Array has fewer items than minimum |
-| `array.maxLength` | Array has more items than maximum |
-| `array.includes` | Array doesn't contain required value |
+| `array.exactItems` | Array items count doesn't match exact count |
+| `array.minItems` | Array has fewer items than minimum |
+| `array.maxItems` | Array has more items than maximum |
+| `array.contains` | Array doesn't contain required value |
 
 Item-level errors will include the array index in the error path (e.g., `items.0`, `items.1`).

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/LiteralSchema.md doc/Schema/ConstSchema.mddoc/Schema/LiteralSchema.md renamed to doc/Schema/ConstSchema.md

@@ -1,6 +1,8 @@
-# LiteralSchema
+# ConstSchema
 
-The `LiteralSchema` validates that a value matches an exact literal value. It supports string, integer, float, and boolean literals.
+> **Deprecated**: Use [ConstSchema](ConstSchema.md) instead. The `ConstSchema` and `const()` method are deprecated and will be removed in a future version.
+
+The `ConstSchema` validates that a value matches an exact const value. It supports string, integer, float, and boolean consts.
 
 ## Basic Usage
 
@@ -9,27 +11,27 @@ use Chubbyphp\Parsing\Parser;
 
 $p = new Parser();
 
-// String literal
-$schema = $p->literal('email');
+// String const
+$schema = $p->const('email');
 $data = $schema->parse('email'); // Returns: 'email'
 
-// Integer literal
-$schema = $p->literal(42);
+// Integer const
+$schema = $p->const(42);
 $data = $schema->parse(42); // Returns: 42
 
-// Boolean literal
-$schema = $p->literal(true);
+// Boolean const
+$schema = $p->const(true);
 $data = $schema->parse(true); // Returns: true
 ```
 
 ## Supported Types
 
 ```php
-$p->literal('string');  // String literal
-$p->literal(42);        // Integer literal
-$p->literal(3.14);      // Float literal
-$p->literal(true);      // Boolean literal
-$p->literal(false);     // Boolean literal
+$p->const('string');  // String const
+$p->const(42);        // Integer const
+$p->const(3.14);      // Float const
+$p->const(true);      // Boolean const
+$p->const(false);     // Boolean const
 ```
 
 ## Common Patterns
@@ -41,11 +43,11 @@ Used with `DiscriminatedUnionSchema` to identify object types:
 ```php
 $contactSchema = $p->discriminatedUnion([
     $p->object([
-        'type' => $p->literal('email'),
+        'type' => $p->const('email'),
         'address' => $p->string()->email(),
     ]),
     $p->object([
-        'type' => $p->literal('phone'),
+        'type' => $p->const('phone'),
         'number' => $p->string(),
     ]),
 ], 'type');
@@ -55,9 +57,9 @@ $contactSchema = $p->discriminatedUnion([
 
 ```php
 $statusSchema = $p->union([
-    $p->literal('pending'),
-    $p->literal('approved'),
-    $p->literal('rejected'),
+    $p->const('pending'),
+    $p->const('approved'),
+    $p->const('rejected'),
 ]);
 
 $statusSchema->parse('approved'); // Returns: 'approved'
@@ -67,16 +69,16 @@ $statusSchema->parse('invalid');  // Throws error
 ### Magic Numbers
 
 ```php
-$httpOkSchema = $p->literal(200);
-$httpNotFoundSchema = $p->literal(404);
+$httpOkSchema = $p->const(200);
+$httpNotFoundSchema = $p->const(404);
 
 $responseSchema = $p->object([
     'status' => $p->union([
-        $p->literal(200),
-        $p->literal(201),
-        $p->literal(400),
-        $p->literal(404),
-        $p->literal(500),
+        $p->const(200),
+        $p->const(201),
+        $p->const(400),
+        $p->const(404),
+        $p->const(500),
     ]),
     'body' => $p->string(),
 ]);
@@ -85,12 +87,12 @@ $responseSchema = $p->object([
 ### Boolean Flags
 
 ```php
-$enabledSchema = $p->literal(true);
-$disabledSchema = $p->literal(false);
+$enabledSchema = $p->const(true);
+$disabledSchema = $p->const(false);
 
 // Only accept explicitly true
 $mustBeEnabled = $p->object([
-    'feature' => $p->literal(true),
+    'feature' => $p->const(true),
 ]);
 ```
 
@@ -99,8 +101,8 @@ $mustBeEnabled = $p->object([
 ```php
 $sortSchema = $p->record(
     $p->union([
-        $p->literal('asc'),
-        $p->literal('desc'),
+        $p->const('asc'),
+        $p->const('desc'),
     ])
 );
 
@@ -114,29 +116,29 @@ $sortSchema->parse([
 
 ```php
 $requestSchema = $p->object([
-    'version' => $p->literal('2.0'),
+    'version' => $p->const('2.0'),
     'method' => $p->string(),
     'params' => $p->record($p->string()),
 ]);
 ```
 
-### Null Literal
+### Null Const
 
-While `nullable()` is preferred for optional null values, you can use literal for explicit null:
+While `nullable()` is preferred for optional null values, you can use const for explicit null:
 
 ```php
-$nullSchema = $p->literal(null);
+$nullSchema = $p->const(null);
 
 // Useful in unions where null has specific meaning
 $valueOrNotSet = $p->union([
     $p->string(),
-    $p->literal(null),
+    $p->const(null),
 ]);
 ```
 
-## Literal vs Enum
+## Const vs Enum
 
-Use **LiteralSchema** when:
+Use **ConstSchema** when:
 - You have a single specific value
 - You're building discriminators for unions
 - You need to match magic numbers or specific strings
@@ -147,9 +149,9 @@ Use **BackedEnumSchema** when:
 - The values represent a closed set of options
 
 ```php
-// Literal: single value or ad-hoc unions
-$type = $p->literal('user');
-$direction = $p->union([$p->literal('asc'), $p->literal('desc')]);
+// Const: single value or ad-hoc unions
+$type = $p->const('user');
+$direction = $p->union([$p->const('asc'), $p->const('desc')]);
 
 // BackedEnum: related values with type safety
 enum Direction: string {
@@ -163,6 +165,6 @@ $direction = $p->backedEnum(Direction::class);
 
 | Code | Description |
 |------|-------------|
-| `literal.type` | Value doesn't match the expected literal |
+| `const.type` | Value doesn't match the expected const |
 
-The error will include the expected literal value and the actual value received.
+The error will include the expected const value and the actual value received.

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/FloatSchema.md

@@ -19,10 +19,10 @@ $data = $schema->parse(4.2); // Returns: 4.2
 ### Comparison Constraints
 
 ```php
-$schema->gt(5.0);   // Greater than 5.0
-$schema->gte(5.0);  // Greater than or equal to 5.0
-$schema->lt(10.0);  // Less than 10.0
-$schema->lte(10.0); // Less than or equal to 10.0
+$schema->minimum(5.0);  // Greater than or equal to 5.0
+$schema->exclusiveMinimum(5.0);   // Greater than 5.0
+$schema->exclusiveMaximum(10.0);  // Less than 10.0
+$schema->maximum(10.0); // Less than or equal to 10.0
 ```
 
 ### Sign Constraints
@@ -56,17 +56,18 @@ $priceSchema->parse(-5.0);  // Throws: nonNegative validation error
 ### Percentage
 
 ```php
-$percentageSchema = $p->float()->gte(0.0)->lte(100.0);
+$percentageSchema = $p->float()->minimum(0.0)->maximum(100.0);
 
 $percentageSchema->parse(75.5); // Returns: 75.5
-$percentageSchema->parse(150.0); // Throws: lte validation error
+$percentageSchema->parse(-1.0); // Throws: minimum validation error
+$percentageSchema->parse(150.0); // Throws: maximum validation error
 ```
 
 ### Coordinates
 
 ```php
-$latitudeSchema = $p->float()->gte(-90.0)->lte(90.0);
-$longitudeSchema = $p->float()->gte(-180.0)->lte(180.0);
+$latitudeSchema = $p->float()->minimum(-90.0)->maximum(90.0);
+$longitudeSchema = $p->float()->minimum(-180.0)->maximum(180.0);
 
 $coordinatesSchema = $p->object([
     'lat' => $latitudeSchema,
@@ -81,8 +82,8 @@ $coordinatesSchema->parse(['lat' => 47.1, 'lng' => 8.2]);
 | Code | Description |
 |------|-------------|
 | `float.type` | Value is not a float |
-| `float.gt` | Value is not greater than threshold (used by `gt()` and `positive()`) |
-| `float.gte` | Value is not greater than or equal to threshold (used by `gte()` and `nonNegative()`) |
-| `float.lt` | Value is not less than threshold (used by `lt()` and `negative()`) |
-| `float.lte` | Value is not less than or equal to threshold (used by `lte()` and `nonPositive()`) |
+| `float.minimum` | Value is not greater than or equal to threshold (used by `minimum` and `nonNegative()`) |
+| `float.exclusiveMinimum` | Value is not greater than threshold (used by `exclusiveMinimum()` and `positive()`) |
+| `float.exclusiveMaximum` | Value is not less than threshold (used by `exclusiveMaximum()` and `negative()`) |
+| `float.maximum` | Value is not less than or equal to threshold (used by `maximum()` and `nonPositive()`) |
 | `float.int` | Cannot convert float to int without precision loss (for `toInt()`) |