Merge branch 'develop'

* develop: (56 commits)
  specify next release
  add integer ranges constraints
  add non empty string constraint
  use blackbox 6 syntax
  update links
  update changelog
  add failWith() documentation
  simplify readme
  use new api in documentation
  use promoted properties
  use old api in proof to reduce the PR diff
  deprecate Has::key()->withFailure()
  remove duplicated code
  flag internal classes/methods
  use provider for points in time to allow for ohter constraints in the future
  split shape implementation from constructor
  regroup array constraint inside a single provider for a more expressive api
  add Constraint::object() and move Constraint::instance() to Constraint::object()->instance()
  do not expose internal type
  make Constraint::build() private
  ...

Author: Baptouuuu

CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 2.0.0 - 2025-04-12
+
+### Added
+
+- `Innmind\Validation\Constraint::object()`
+- `Innmind\Validation\Constraint::failWith()`
+- `Innmind\Validation\Constraint::string()->nonEmpty()`
+- `Innmind\Validation\Constraint::int()->positive()`
+- `Innmind\Validation\Constraint::int()->negative()`
+- `Innmind\Validation\Constraint::int()->range()`
+- `Innmind\Validation\Constraint\Provider`
+
+### Changed
+
+- `Innmind\Validation\Constraint` is now a `final` class
+- `Innmind\Validation\Failure::of()` is now `internal`
+- `Innmind\Validation\Failure::under()` is now `internal`
+- `Innmind\Validation\KeyPath::root()` is now `internal`
+- `Innmind\Validation\KeyPath::under()` is now `internal`
+- `Innmind\Validation\Predicate` is now `internal`
+
+### Removed
+
+- `Innmind\Validation\Each`, you must use `Is::list()` instead
+- `Innmind\Validation\AndConstraint`, you must use `Constraint::and()` instead
+- `Innmind\Validation\OrConstraint`, you must use `Constraint::or()` instead
+- `Innmind\Validation\Map`, you must use `Constraint::map()` instead
+
 ## 1.9.0 - 2025-02-09
 
 ### Added

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Innmind
+Copyright (c) 2025-present Innmind
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -16,9 +16,7 @@ composer require innmind/validation
 
 ```php
 use Innmind\Validation\{
-    Shape,
     Is,
-    Each,
     Failure,
 };
 use Innmind\Immutable\Sequence;
@@ -41,7 +39,7 @@ $invalid = [
     'submit' => true,
 ];
 
-$validate = Shape::of('id', Is::int())
+$validate = Is::shape('id', Is::int())
     ->with('username', Is::string())
     ->with(
         'addresses',

composer.json

@@ -26,7 +26,7 @@
     },
     "require-dev": {
         "innmind/static-analysis": "^1.2.1",
-        "innmind/black-box": "~5.5",
+        "innmind/black-box": "~6.1",
         "innmind/coding-standard": "~2.0"
     }
 }

docs/constraints/associative-arrays.md

@@ -5,7 +5,7 @@ Here's the constraint to validate the HTTP response <https://packagist.org/packa
 ```php
 use Innmind\Validation\Is;
 
-$validate = Is::associativeArray(
+$validate = Is::array()->associative(
     Is::string(),
     Is::shape('repository', Is::string())
         ->with('abandoned', Is::bool()->or(Is::string())),

docs/constraints/custom.md

@@ -1,15 +1,15 @@
 # Custom
 
-At some point you'll want to use your own constraints for a custom business logic. Instead of implementing the whole `Constraint` interface you can do:
+At some point you'll want to use your own constraints for a custom business logic. You can do:
 
 ```php
 use Innmind\Validation\{
-    Of,
+    Constraint,
     Failure,
 };
 use Innmind\Immutable\Validation;
 
-$validate = Of::callable(static function(mixed $input) {
+$validate = Constraint::of(static function(mixed $input) {
     if (/* your validation here */) {
         return Validation::success($input);
     }
@@ -24,12 +24,12 @@ For example if you know the input has to be a `string` you can do:
 
 ```php hl_lines="7"
 use Innmind\Validation\{
-    Of,
+    Constraint,
     Failure,
 };
 use Innmind\Immutable\Validation;
 
-$validate = Is::string()->and(Of::callable(static function(string $input) {
+$validate = Is::string()->and(Constraint::of(static function(string $input) {
     if (/* your validation here */) {
         return Validation::success($input);
     }

docs/constraints/dates.md

@@ -3,14 +3,13 @@
 This will transform `string`s into `PointInTime`s from the [`innmind/time-continuum` package](https://github.com/Innmind/TimeContinuum/).
 
 ```php
-use Innmind\Validation\PointInTime;
+use Innmind\Validation\Constraint;
 use Innmind\TimeContinuum\{
     Clock,
     Format,
 };
 
-$validate = PointInTime::ofFormat(
-    Clock::live(),
+$validate = Constraint::pointInTime(Clock::live())->format(
     Format::iso8601(),
 );
 ```

docs/constraints/index.md

@@ -7,6 +7,7 @@ Each `Constraint` have the following methods:
 - `->or()`
 - `->map()`
 - `->asPredicate()`
+- `->failWith()`
 
 ## `->__invoke()`
 
@@ -39,13 +40,13 @@ Let's take the example of making sure a `string` is shorter than `255` character
 ```php hl_lines="3-4 6 9-14"
 use Innmind\Validation\{
     Is,
-    Of,
+    Constraint,
     Failure,
 };
 use Innmind\Immutable\Validation;
 
 function(mixed $input): string {
-    $validate = Is::string()->and(Of::callable(
+    $validate = Is::string()->and(Constraint::of(
         static fn(string $value) => match (true) {
             \strlen($value) < 255 => Validation::success($value),
             default => Validation::fail(Failure::of('String is too long')),
@@ -120,6 +121,18 @@ Sequence::of(1, 'a', null, 'b', new \stdClass, 'c')
 ??? note
     There's no need to apply transformations on your constraints when used as predicates as the outputed value is not used.
 
+## `->failWith()`
+
+This method allows to change the failure message.
+
+```php
+use Innmind\Validation\Is;
+
+$password = Is::string()->failWith('The password is required');
+
+$password($someInput);
+```
+
 ## Handling failures
 
 In the examples above we've thrown exceptions in case of errors but you have access to all the failures messages and where they happened.

docs/constraints/objects.md

@@ -1,6 +1,14 @@
 # Objects
 
-You can check the input is an object of a given instance like this:
+You can check the input is an object like this:
+
+```php
+use Innmind\Validation\Constraint;
+
+$validate = Constraint::object();
+```
+
+And if you want to make sure it is an instance of some class:
 
 ```php
 use Innmind\Validation\Instance;

docs/constraints/primitives.md

@@ -7,13 +7,44 @@
     $validate = Is::string();
     ```
 
+=== "`non-empty-string`"
+    ```php
+    use Innmind\Validation\Is;
+
+    $validate = Is::string()->nonEmpty();
+    ```
+
 === "`int`"
     ```php
     use Innmind\Validation\Is;
 
     $validate = Is::int();
     ```
 
+=== "`int<1, max>`"
+    ```php
+    use Innmind\Validation\Is;
+
+    $validate = Is::int()->positive();
+    ```
+
+=== "`int<min, -1>`"
+    ```php
+    use Innmind\Validation\Is;
+
+    $validate = Is::int()->negative();
+    ```
+
+=== "`int` range"
+    ```php
+    use Innmind\Validation\Is;
+
+    $min = 0;
+    $max = 100;
+
+    $validate = Is::int()->range($min, $max);
+    ```
+
 === "`float`"
     ```php
     use Innmind\Validation\Is;
@@ -45,7 +76,7 @@
 By default the error message will be `Value is not of type {primitive}`. You can change it via:
 
 ```php
-$validate = Is::string()->withFailure('Some error message');
+$validate = Is::string()->failWith('Some error message');
 ```
 
 ## Lists
@@ -61,7 +92,7 @@ use Innmind\Validation\Is;
 $validate = Is::list();
 ```
 
-You can also validate that each value in the list is of a given type. Here's how to validate a list os `string`s:
+You can also validate that each value in the list is of a given type. Here's how to validate a list of `string`s:
 
 ```php
 use Innmind\Validation\Is;