Fix misplaced Outer/Inner names when using named() on Each

alganet · alganet · commit 7f4a4c203511 · 2026-01-29T18:24:50.000Z
The Each validator was using "Outer" names (the name applied to
the parent) in child results and vice-versa.

This commit fixes it, and also streamlines the Result class,
introducing helper `mapChildren` and `mapAdjacent` methods and
removing unecessary recursive array_maps.

Named children now also display their names, allowing users to
create more meaningful messages that do not spam nested
`.0`...`.0`...etc numeric keys which could be confusing. If the
user does not name them, the previous behavior is kept.
diff --git a/src/Message/Formatter/NestedArrayFormatter.php b/src/Message/Formatter/NestedArrayFormatter.php
@@ -45,6 +45,8 @@ public function format(Result $result, Renderer $renderer, array $templates): ar
                 $renderer,
                 $templates,
                 $hasString,
+                $result,
+                isParentVisible: count($children) > 1,
             ),
             [],
         );
@@ -91,12 +93,14 @@ private function appendMessage(
         Renderer $renderer,
         array $templates,
         bool $hasString,
+        Result $parent,
+        bool $isParentVisible,
     ): array {
         if ($hasString && is_numeric($key)) {
             $key = $child->id->value;
         }
 
-        $message = $this->renderChild($child, $renderer, $templates);
+        $message = $this->renderChild($child, $renderer, $templates, $parent, $isParentVisible);
 
         if (!$hasString) {
             $messages[] = $message;
@@ -124,10 +128,15 @@ private function appendMessage(
      *
      * @return array<string>|string
      */
-    private function renderChild(Result $child, Renderer $renderer, array $templates): array|string
-    {
+    private function renderChild(
+        Result $child,
+        Renderer $renderer,
+        array $templates,
+        Result $parent,
+        bool $isParentVisible,
+    ): array|string {
         $formatted = $this->format(
-            $child->withoutName(),
+            $isParentVisible && $child->name === $parent->name ? $child->withoutName() : $child,
             $renderer,
             $templates,
         );
diff --git a/src/Result.php b/src/Result.php
@@ -77,7 +77,7 @@ public function asAdjacentOf(Result $result, string $prefix): Result
         if ($this->allowsAdjacent()) {
             return clone ($result, [
                 'id' => $this->id->withPrefix($prefix),
-                'adjacent' => $this->withInput($result->input),
+                'adjacent' => clone($this, ['input' => $result->input]),
             ]);
         }
 
@@ -112,12 +112,17 @@ public function withIdFrom(Validator $validator): self
         return clone($this, ['id' => Id::fromValidator($validator)]);
     }
 
-    public function withPath(Path $path): self
+    public function withPrecedentName(bool $hasPrecedentName): self
     {
-        if ($this->path === $path) {
-            return $this;
-        }
+        return clone($this, [
+            'hasPrecedentName' => $hasPrecedentName,
+            'adjacent' => $this->adjacent?->withPrecedentName($hasPrecedentName),
+            'children' => $this->mapChildren(static fn(Result $r) => $r->withPrecedentName($hasPrecedentName)),
+        ]);
+    }
 
+    public function withPath(Path $path): self
+    {
         if ($this->path !== null) {
             $this->path->parent = $path;
 
@@ -127,11 +132,7 @@ public function withPath(Path $path): self
         return clone($this, [
             'path' => $path,
             'adjacent' => $this->adjacent?->withPath($path),
-            'hasPrecedentName' => $this->name !== null,
-            'children' => array_map(
-                static fn(Result $child) => $child->withPath($path),
-                $this->children,
-            ),
+            'children' => $this->mapChildren(static fn(Result $r) => $r->withPath($path)),
         ]);
     }
 
@@ -144,10 +145,7 @@ public function withoutName(): self
         return clone ($this, [
             'name' => null,
             'adjacent' => $this->adjacent?->withoutName(),
-            'children' => array_map(
-                fn(Result $child) => $child->name === $this->name ? $child->withoutName() : $child,
-                $this->children,
-            ),
+            'children' => $this->mapChildren(fn(Result $r) => $r->name === $this->name ? $r->withoutName() : $r),
         ]);
     }
 
@@ -164,11 +162,9 @@ public function withName(Name $name): self
 
         return clone($this, [
             'name' => $name,
+            'hasPrecedentName' => $this->path === null,
             'adjacent' => $this->adjacent?->withName($name),
-            'children' => array_map(
-                static fn(Result $child) => $child->withName($name),
-                $this->children,
-            ),
+            'children' => $this->mapChildren(static fn(Result $r) => $r->name === null ? $r->withName($name) : $r),
         ]);
     }
 
@@ -180,25 +176,7 @@ public function withNameFrom(Validator $validator): self
 
         return clone($this, [
             'name' => $this->name ?? $validator->getName(),
-            'hasPrecedentName' => true,
             'adjacent' => $this->adjacent?->withNameFrom($validator),
-            'children' => array_map(
-                static fn(Result $child) => $child->withNameFrom($validator),
-                $this->children,
-            ),
-        ]);
-    }
-
-    public function withInput(mixed $input): self
-    {
-        $currentInput = $this->input;
-
-        return clone($this, [
-            'input' => $input,
-            'children' => array_map(
-                static fn(Result $child) => $child->input === $currentInput ? $child->withInput($input) : $child,
-                $this->children,
-            ),
         ]);
     }
 
@@ -212,7 +190,6 @@ public function withToggledValidation(): self
         return clone($this, [
             'hasPassed' => !$this->hasPassed,
             'adjacent' => $this->adjacent?->withToggledValidation(),
-            'children' => array_map(static fn(Result $child) => $child->withToggledValidation(), $this->children),
         ]);
     }
 
@@ -222,10 +199,7 @@ public function withToggledModeAndValidation(): self
             'hasPassed' => !$this->hasPassed,
             'hasInvertedMode' => !$this->hasInvertedMode,
             'adjacent' => $this->adjacent?->withToggledModeAndValidation(),
-            'children' => array_map(
-                static fn(Result $child) => $child->withToggledModeAndValidation(),
-                $this->children,
-            ),
+            'children' => $this->mapChildren(static fn(Result $r) => $r->withToggledModeAndValidation()),
         ]);
     }
 
@@ -247,4 +221,10 @@ public function allowsAdjacent(): bool
 
         return count($childrenThatAllowAdjacent) === 1;
     }
+
+    /** @return array<Result> */
+    private function mapChildren(callable $callback): array
+    {
+        return $this->children === [] ? [] : array_map($callback, $this->children);
+    }
 }
diff --git a/src/Validators/Core/FilteredNonEmptyArray.php b/src/Validators/Core/FilteredNonEmptyArray.php
@@ -28,7 +28,7 @@ public function evaluate(mixed $input): Result
     {
         $iterableResult = (new IterableType())->evaluate($input);
         if (!$iterableResult->hasPassed) {
-            return $iterableResult->withIdFrom($this)->withNameFrom($this->validator);
+            return $iterableResult->withIdFrom($this);
         }
 
         $array = $this->toArray($input);
@@ -38,7 +38,7 @@ public function evaluate(mixed $input): Result
         );
         $result = $validator->evaluate($array);
         if (!$result->hasPassed) {
-            return $result->withIdFrom($this)->withNameFrom($this->validator);
+            return $result->withIdFrom($this);
         }
 
         // @phpstan-ignore-next-line
diff --git a/src/Validators/Each.php b/src/Validators/Each.php
@@ -37,7 +37,7 @@ protected function evaluateNonEmptyArray(array $input): Result
     {
         $children = [];
         foreach ($input as $key => $value) {
-            $children[] = $this->validator->evaluate($value)->withPath(new Path($key));
+            $children[] = $this->validator->evaluate($value)->withPath(new Path($key))->withPrecedentName(false);
         }
 
         $hasPassed = array_reduce(
@@ -46,6 +46,6 @@ protected function evaluateNonEmptyArray(array $input): Result
             true,
         );
 
-        return Result::of($hasPassed, $input, $this)->withChildren(...$children)->withNameFrom($this->validator);
+        return Result::of($hasPassed, $input, $this)->withChildren(...$children);
     }
 }
diff --git a/src/Validators/Key.php b/src/Validators/Key.php
@@ -44,6 +44,7 @@ public function evaluate(mixed $input): Result
             return $keyExistsResult->withNameFrom($this->validator);
         }
 
-        return $this->validator->evaluate($input[$this->key])->withPath($keyExistsResult->path ?? new Path($this->key));
+        return $this->validator->evaluate($input[$this->key])
+            ->withPath($keyExistsResult->path ?? new Path($this->key));
     }
 }
diff --git a/tests/feature/Validators/EachTest.php b/tests/feature/Validators/EachTest.php
@@ -65,52 +65,52 @@
 test('With name, non-iterable', catchAll(
     fn() => v::each(v::named('Wrapped', v::intType()))->assert(null),
     fn(string $message, string $fullMessage, array $messages) => expect()
-        ->and($message)->toBe('Wrapped must be iterable')
-        ->and($fullMessage)->toBe('- Wrapped must be iterable')
-        ->and($messages)->toBe(['each' => 'Wrapped must be iterable']),
+        ->and($message)->toBe('`null` must be iterable')
+        ->and($fullMessage)->toBe('- `null` must be iterable')
+        ->and($messages)->toBe(['each' => '`null` must be iterable']),
 ));
 
 test('With name, empty', catchAll(
     fn() => v::each(v::named('Wrapped', v::intType()))->assert([]),
     fn(string $message, string $fullMessage, array $messages) => expect()
-        ->and($message)->toBe('The length of Wrapped must be greater than 0')
-        ->and($fullMessage)->toBe('- The length of Wrapped must be greater than 0')
-        ->and($messages)->toBe(['each' => 'The length of Wrapped must be greater than 0']),
+        ->and($message)->toBe('The length of `[]` must be greater than 0')
+        ->and($fullMessage)->toBe('- The length of `[]` must be greater than 0')
+        ->and($messages)->toBe(['each' => 'The length of `[]` must be greater than 0']),
 ));
 
 test('With name, default', catchAll(
-    fn() => v::named('Wrapper', v::each(v::named('Wrapped', v::intType())))->assert(['a', 'b', 'c']),
+    fn() => v::named('Outer', v::each(v::named('Inner', v::intType())))->assert(['a', 'b', 'c']),
     fn(string $message, string $fullMessage, array $messages) => expect()
-        ->and($message)->toBe('Wrapped must be an integer')
+        ->and($message)->toBe('`.0` (<- Inner) must be an integer')
         ->and($fullMessage)->toBe(<<<'FULL_MESSAGE'
-        - Each item in Wrapped must be valid
-          - `.0` must be an integer
-          - `.1` must be an integer
-          - `.2` must be an integer
+        - Each item in Outer must be valid
+          - `.0` (<- Inner) must be an integer
+          - `.1` (<- Inner) must be an integer
+          - `.2` (<- Inner) must be an integer
         FULL_MESSAGE)
         ->and($messages)->toBe([
-            '__root__' => 'Each item in Wrapped must be valid',
-            0 => '`.0` must be an integer',
-            1 => '`.1` must be an integer',
-            2 => '`.2` must be an integer',
+            '__root__' => 'Each item in Outer must be valid',
+            0 => '`.0` (<- Inner) must be an integer',
+            1 => '`.1` (<- Inner) must be an integer',
+            2 => '`.2` (<- Inner) must be an integer',
         ]),
 ));
 
 test('With name, inverted', catchAll(
-    fn() => v::named('Not', v::not(v::named('Wrapper', v::each(v::named('Wrapped', v::intType())))))->assert([1, 2, 3]),
+    fn() => v::named('Not', v::not(v::named('Outer', v::each(v::named('Inner', v::intType())))))->assert([1, 2, 3]),
     fn(string $message, string $fullMessage, array $messages) => expect()
-        ->and($message)->toBe('Wrapped must not be an integer')
+        ->and($message)->toBe('`.0` (<- Inner) must not be an integer')
         ->and($fullMessage)->toBe(<<<'FULL_MESSAGE'
-        - Each item in Wrapped must be invalid
-          - `.0` must not be an integer
-          - `.1` must not be an integer
-          - `.2` must not be an integer
+        - Each item in Outer must be invalid
+          - `.0` (<- Inner) must not be an integer
+          - `.1` (<- Inner) must not be an integer
+          - `.2` (<- Inner) must not be an integer
         FULL_MESSAGE)
         ->and($messages)->toBe([
-            '__root__' => 'Each item in Wrapped must be invalid',
-            0 => '`.0` must not be an integer',
-            1 => '`.1` must not be an integer',
-            2 => '`.2` must not be an integer',
+            '__root__' => 'Each item in Outer must be invalid',
+            0 => '`.0` (<- Inner) must not be an integer',
+            1 => '`.1` (<- Inner) must not be an integer',
+            2 => '`.2` (<- Inner) must not be an integer',
         ]),
 ));
 

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ public function evaluate(mixed $input): Result`
`28`	`28`	`{`
`29`	`29`	`$iterableResult = (new IterableType())->evaluate($input);`
`30`	`30`	`if (!$iterableResult->hasPassed) {`
`31`		`- return $iterableResult->withIdFrom($this)->withNameFrom($this->validator);`
	`31`	`+ return $iterableResult->withIdFrom($this);`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`$array = $this->toArray($input);`
`@@ -38,7 +38,7 @@ public function evaluate(mixed $input): Result`
`38`	`38`	`);`
`39`	`39`	`$result = $validator->evaluate($array);`
`40`	`40`	`if (!$result->hasPassed) {`
`41`		`- return $result->withIdFrom($this)->withNameFrom($this->validator);`
	`41`	`+ return $result->withIdFrom($this);`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`// @phpstan-ignore-next-line`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ protected function evaluateNonEmptyArray(array $input): Result`
`37`	`37`	`{`
`38`	`38`	`$children = [];`
`39`	`39`	`foreach ($input as $key => $value) {`
`40`		`- $children[] = $this->validator->evaluate($value)->withPath(new Path($key));`
	`40`	`+ $children[] = $this->validator->evaluate($value)->withPath(new Path($key))->withPrecedentName(false);`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`$hasPassed = array_reduce(`
`@@ -46,6 +46,6 @@ protected function evaluateNonEmptyArray(array $input): Result`
`46`	`46`	`true,`
`47`	`47`	`);`
`48`	`48`
`49`		`- return Result::of($hasPassed, $input, $this)->withChildren(...$children)->withNameFrom($this->validator);`
	`49`	`+ return Result::of($hasPassed, $input, $this)->withChildren(...$children);`
`50`	`50`	`}`
`51`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,6 +44,7 @@ public function evaluate(mixed $input): Result`
`44`	`44`	`return $keyExistsResult->withNameFrom($this->validator);`
`45`	`45`	`}`
`46`	`46`
`47`		`- return $this->validator->evaluate($input[$this->key])->withPath($keyExistsResult->path ?? new Path($this->key));`
	`47`	`+ return $this->validator->evaluate($input[$this->key])`
	`48`	`+ ->withPath($keyExistsResult->path ?? new Path($this->key));`
`48`	`49`	`}`
`49`	`50`	`}`