Update some templates and improve tests

Some templates were a bit confusing, and I would like to favour adding
the `{{name}}` at the beginning of the templates as it helps when
reading nested messages.

I also deleted the regression tests for issue #1348, because it's a
non-issue, actually. The best approach to that problem is indeed using
`When` insteaf of `OneOf`.

Author: henriquemoody

docs/03-handling-exceptions.md

@@ -19,7 +19,7 @@ try {
 The code above generates the following output:
 
 ```no-highlight
-- All the required rules must pass for "The Respect Panda"
+- "The Respect Panda" must pass all the rules
   - "The Respect Panda" must contain only letters (a-z) and digits (0-9)
   - "The Respect Panda" must contain only lowercase letters
 ```
@@ -44,7 +44,7 @@ The code above generates the following output:
 ```no-highlight
 Array
 (
-    [__root__] => All the required rules must pass for "The Respect Panda"
+    [__root__] => "The Respect Panda" must pass all the rules
     [alnum] => "The Respect Panda" must contain only letters (a-z) and digits (0-9)
     [lowercase] => "The Respect Panda" must contain only lowercase letters
 )

docs/rules/AllOf.md

@@ -12,17 +12,21 @@ v::allOf(v::intVal(), v::positive())->isValid(15); // true
 
 ### `AllOf::TEMPLATE_SOME`
 
-| Mode       | Template                               |
-|------------|----------------------------------------|
-| `default`  | These rules must pass for {{name}}     |
-| `inverted` | These rules must not pass for {{name}} |
+Used when some rules must be failed.
 
-### `AllOf::TEMPLATE_NONE`
+| Mode       | Template                     |
+|------------|------------------------------|
+| `default`  | {{name}} must pass the rules |
+| `inverted` | {{name}} must pass the rules |
 
-| Mode       | Template                                      |
-|------------|-----------------------------------------------|
-| `default`  | All the required rules must pass for {{name}} |
-| `inverted` | None of these rules must pass for {{name}}    |
+### `AllOf::TEMPLATE_ALL`
+
+Used when all rules have failed.
+
+| Mode       | Template                         |
+|------------|----------------------------------|
+| `default`  | {{name}} must pass all the rules |
+| `inverted` | {{name}} must pass all the rules |
 
 ## Template placeholders
 

docs/rules/AnyOf.md

@@ -17,10 +17,10 @@ so `AnyOf()` returns true.
 
 ### `AnyOf::TEMPLATE_STANDARD`
 
-| Mode       | Template                                               |
-|------------|--------------------------------------------------------|
-| `default`  | At least one of these rules must pass for {{name}}     |
-| `inverted` | At least one of these rules must not pass for {{name}} |
+| Mode       | Template                                     |
+|------------|----------------------------------------------|
+| `default`  | {{name}} must pass at least one of the rules |
+| `inverted` | {{name}} must pass at least one of the rules |
 
 ## Template placeholders
 

docs/rules/Attributes.md

@@ -49,10 +49,10 @@ v::attributes()->assert(new Person('John Doe', 'john.doe@gmail.com', '2020-06-23
 
 v::attributes()->assert(new Person('', 'not an email', 'not a date', 'not a phone number'));
 // Full message:
-// - All the required rules must pass for `Person { +$name="" +$email="not an email" +$birthdate="not a date" +$phone="not a phone number" }`
+// - `Person { +$name="" +$email="not an email" +$birthdate="not a date" +$phone="not a phone number" }` must pass all the rules
 //   - name must not be empty
 //   - email must be a valid email address
-//   - All the required rules must pass for birthdate
+//   - birthdate must pass all the rules
 //     - birthdate must be a valid date in the format "2005-12-30"
 //     - For comparison with now, birthdate must be a valid datetime
 //   - phone must be a valid telephone number or must be null

docs/rules/NoneOf.md

@@ -15,12 +15,23 @@ In the sample above, 'foo' isn't a integer nor a float, so noneOf returns true.
 
 ## Templates
 
-### `NoneOf::TEMPLATE_STANDARD`
+### `NoneOf::TEMPLATE_SOME`
 
-| Mode       | Template                                   |
-|------------|--------------------------------------------|
-| `default`  | None of these rules must pass for {{name}} |
-| `inverted` | All of these rules must pass for {{name}}  |
+Used when some rules have passed.
+
+| Mode       | Template                     |
+|------------|------------------------------|
+| `default`  | {{name}} must pass the rules |
+| `inverted` | {{name}} must pass the rules |
+
+### `NoneOf::TEMPLATE_ALL`
+
+Used when all rules have passed.
+
+| Mode       | Template                         |
+|------------|----------------------------------|
+| `default`  | {{name}} must pass all the rules |
+| `inverted` | {{name}} must pass all the rules |
 
 ## Template placeholders
 

docs/rules/OneOf.md

@@ -16,12 +16,23 @@ character, one or the other, but not neither nor both.
 
 ## Templates
 
-### `OneOf::TEMPLATE_STANDARD`
+### `OneOf::TEMPLATE_NONE`
 
-| Mode       | Template                                           |
-|------------|----------------------------------------------------|
-| `default`  | Only one of these rules must pass for {{name}}     |
-| `inverted` | Only one of these rules must not pass for {{name}} |
+Used when none of the rules have passed.
+
+| Mode       | Template                            |
+|------------|-------------------------------------|
+| `default`  | {{name}} must pass one of the rules |
+| `inverted` | {{name}} must pass one of the rules |
+
+### `OneOf::TEMPLATE_MORE_THAN_ONE`
+
+Used when more than one rule has passed.
+
+| Mode       | Template                                 |
+|------------|------------------------------------------|
+| `default`  | {{name}} must pass only one of the rules |
+| `inverted` | {{name}} must pass only one of the rules |
 
 ## Template placeholders
 

library/Rules/AllOf.php

@@ -22,18 +22,18 @@
 
 #[Attribute(Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
 #[Template(
-    'These rules must pass for {{name}}',
-    'These rules must not pass for {{name}}',
+    '{{name}} must pass the rules',
+    '{{name}} must pass the rules',
     self::TEMPLATE_SOME,
 )]
 #[Template(
-    'All the required rules must pass for {{name}}',
-    'None of these rules must pass for {{name}}',
-    self::TEMPLATE_NONE,
+    '{{name}} must pass all the rules',
+    '{{name}} must pass all the rules',
+    self::TEMPLATE_ALL,
 )]
 final class AllOf extends Composite
 {
-    public const TEMPLATE_NONE = '__none__';
+    public const TEMPLATE_ALL = '__all__';
     public const TEMPLATE_SOME = '__some__';
 
     public function evaluate(mixed $input): Result
@@ -43,7 +43,7 @@ public function evaluate(mixed $input): Result
         $failed = array_filter($children, static fn (Result $result): bool => !$result->isValid);
         $template = self::TEMPLATE_SOME;
         if (count($children) === count($failed)) {
-            $template = self::TEMPLATE_NONE;
+            $template = self::TEMPLATE_ALL;
         }
 
         return (new Result($valid, $input, $this, [], $template))->withChildren(...$children);

library/Rules/AnyOf.php

@@ -20,8 +20,8 @@
 
 #[Attribute(Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
 #[Template(
-    'At least one of these rules must pass for {{name}}',
-    'At least one of these rules must not pass for {{name}}',
+    '{{name}} must pass at least one of the rules',
+    '{{name}} must pass at least one of the rules',
 )]
 final class AnyOf extends Composite
 {

library/Rules/NoneOf.php

@@ -15,24 +15,37 @@
 use Respect\Validation\Rule;
 use Respect\Validation\Rules\Core\Composite;
 
+use function array_filter;
 use function array_map;
 use function array_reduce;
+use function count;
 
 #[Attribute(Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
 #[Template(
-    'None of these rules must pass for {{name}}',
-    'All of these rules must pass for {{name}}',
+    '{{name}} must pass the rules',
+    '{{name}} must pass the rules',
+    self::TEMPLATE_SOME,
+)]
+#[Template(
+    '{{name}} must pass all the rules',
+    '{{name}} must pass all the rules',
+    self::TEMPLATE_ALL,
 )]
 final class NoneOf extends Composite
 {
+    public const TEMPLATE_ALL = '__all__';
+    public const TEMPLATE_SOME = '__some__';
+
     public function evaluate(mixed $input): Result
     {
-        $children = array_map(
-            static fn (Rule $rule) => $rule->evaluate($input)->withInvertedMode(),
-            $this->rules
-        );
+        $children = array_map(static fn (Rule $rule) => $rule->evaluate($input)->withInvertedMode(), $this->rules);
         $valid = array_reduce($children, static fn (bool $carry, Result $result) => $carry && $result->isValid, true);
+        $failed = array_filter($children, static fn (Result $result): bool => !$result->isValid);
+        $template = self::TEMPLATE_SOME;
+        if (count($children) === count($failed)) {
+            $template = self::TEMPLATE_ALL;
+        }
 
-        return (new Result($valid, $input, $this))->withChildren(...$children);
+        return (new Result($valid, $input, $this, [], $template))->withChildren(...$children);
     }
 }

library/Rules/OneOf.php

@@ -15,21 +15,45 @@
 use Respect\Validation\Rule;
 use Respect\Validation\Rules\Core\Composite;
 
+use function array_filter;
 use function array_map;
 use function array_reduce;
+use function count;
+use function usort;
 
 #[Attribute(Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
 #[Template(
-    'Only one of these rules must pass for {{name}}',
-    'Only one of these rules must not pass for {{name}}',
+    '{{name}} must pass one of the rules',
+    '{{name}} must pass one of the rules',
+    self::TEMPLATE_NONE,
+)]
+#[Template(
+    '{{name}} must pass only one of the rules',
+    '{{name}} must pass only one of the rules',
+    self::TEMPLATE_MORE_THAN_ONE,
 )]
 final class OneOf extends Composite
 {
+    public const TEMPLATE_NONE = '__none__';
+    public const TEMPLATE_MORE_THAN_ONE = '__more_than_one__';
+
     public function evaluate(mixed $input): Result
     {
         $children = array_map(static fn (Rule $rule) => $rule->evaluate($input), $this->rules);
         $valid = array_reduce($children, static fn (bool $carry, Result $result) => $carry xor $result->isValid, false);
+        $validChildren = array_filter($children, static fn (Result $result): bool => $result->isValid);
+        $template = self::TEMPLATE_NONE;
+        if (count($validChildren) > 1) {
+            // Put the failed children at the top, so it makes sense in the main error message
+            usort($children, static fn (Result $a, Result $b): int => $a->isValid <=> $b->isValid);
+
+            $template = self::TEMPLATE_MORE_THAN_ONE;
+            $children = array_map(
+                static fn (Result $child) => $child->isValid ? $child->withInvertedValidation() : $child,
+                $children
+            );
+        }
 
-        return (new Result($valid, $input, $this))->withChildren(...$children);
+        return (new Result($valid, $input, $this, [], $template))->withChildren(...$children);
     }
 }