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,9 +267,10 @@ 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` |
+| const | `const.` | `const.type` |
 | array | `array.` | `array.type`, `array.minLength` |
 | assoc | `assoc.` | `assoc.type`, `assoc.unknownField` |
 | object | `object.` | `object.type`, `object.unknownField` |
@@ -278,7 +279,6 @@ Each schema type uses a consistent error code prefix:
 | record | `record.` | `record.type` |
 | union | `union.` | `union.type` |
 | discriminatedUnion | `discriminatedUnion.` | `discriminatedUnion.type`, `discriminatedUnion.discriminator` |
-| literal | `literal.` | `literal.type` |
 | backedEnum | `backedEnum.` | `backedEnum.type` |
 | lazy | (delegates to inner schema) | |
 | respectValidation | `respectValidation.` | `respectValidation.assert` |

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

@@ -170,7 +170,7 @@ enum Rank: int
 {
     case Two = 2;
     case Three = 3;
-    // ... 
+    // ...
     case Jack = 11;
     case Queen = 12;
     case King = 13;
@@ -182,7 +182,7 @@ $cardSchema = $p->object([
     'rank' => $p->backedEnum(Rank::class),
 ]);
 
-$cardSchema->parse(['suit' => 'H', 'rank' => 14]); 
+$cardSchema->parse(['suit' => 'H', 'rank' => 14]);
 // Returns object with Suit::Hearts and Rank::Ace
 ```
 
@@ -204,14 +204,14 @@ $tagsSchema->parse(['featured', 'new', 'sale']);
 // Returns: [Tag::Featured, Tag::New, Tag::Sale]
 ```
 
-## BackedEnum vs Literal Union
+## BackedEnum vs Const Union
 
 Use **BackedEnumSchema** when:
 - You already have a PHP enum defined
 - You want type safety with enum instances
 - You need enum methods/functionality
 
-Use **Literal union** when:
+Use **Const union** when:
 - Values are ad-hoc or temporary
 - You don't need enum type safety
 - You're matching simple string/int values
@@ -222,8 +222,8 @@ enum Status: string { case Active = 'active'; case Inactive = 'inactive'; }
 $schema = $p->backedEnum(Status::class);
 // Returns Status enum instances
 
-// Literal union: simple string values
-$schema = $p->union([$p->literal('active'), $p->literal('inactive')]);
+// Const union: simple string values
+$schema = $p->union([$p->const('active'), $p->const('inactive')]);
 // Returns strings
 ```
 

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.