Fix deep path chain and __root__ template cascading bugs

Result::withPath() previously set `$this->path->parent = $path` directly
on the leaf node, overwriting intermediate path segments. With 3+ levels
of nested keys (e.g. server.database.host), the middle segment was lost,
producing `.server.host` instead of `.server.database.host`. The fix
walks to the root of the existing path chain before appending.

TemplateResolver::getGivenTemplate() treated `__root__` as a universal
fallback in the lookup chain, causing it to match ALL results in the tree
instead of only the composite it was intended for. The fix introduces an
`$isRoot` flag threaded from each formatter through the Renderer into
TemplateResolver, combined with a `fullyConsumed` check from path
drilling, so `__root__` only applies when the result is at the correct
template scope.

Optimizations made during the fixes:

- NestedListStringFormatter::isVisible(): replaced O(n!) mutual sibling
  recursion with O(n) linear scan — the transitive visibility check
  reduces to "does any sibling have a custom template or != 1 children"
- InterpolationRenderer: inlined getValidatorTemplate() into the ??
  expression so it short-circuits when a given template exists

Add 12 feature tests covering deep path rendering, multi-level __root__
scoping, deep template resolution, partial template coverage, and mixed
depth siblings.

Author: alganet

src/Message/Formatter/FirstResultStringFormatter.php

@@ -18,14 +18,14 @@
 final readonly class FirstResultStringFormatter implements StringFormatter
 {
     /** @param array<string|int, mixed> $templates */
-    public function format(Result $result, Renderer $renderer, array $templates): string
+    public function format(Result $result, Renderer $renderer, array $templates, bool $isRoot = true): string
     {
         if (!$result->hasCustomTemplate()) {
             foreach ($result->children as $child) {
-                return $this->format($child, $renderer, $templates);
+                return $this->format($child, $renderer, $templates, false);
             }
         }
 
-        return $renderer->render($result, $templates);
+        return $renderer->render($result, $templates, $isRoot);
     }
 }

src/Message/Formatter/NestedArrayFormatter.php

@@ -28,10 +28,10 @@
      *
      * @return array<string|int, mixed>
      */
-    public function format(Result $result, Renderer $renderer, array $templates): array
+    public function format(Result $result, Renderer $renderer, array $templates, bool $isRoot = true): array
     {
         if ($result->children === []) {
-            return [$result->path->value ?? $result->id->value => $renderer->render($result, $templates)];
+            return [$result->path->value ?? $result->id->value => $renderer->render($result, $templates, $isRoot)];
         }
 
         $hasStringKey = false;
@@ -57,7 +57,7 @@ public function format(Result $result, Renderer $renderer, array $templates): ar
         }
 
         if (count($messages) > 1) {
-            return ['__root__' => $renderer->render($result, $templates)] + $messages;
+            return ['__root__' => $renderer->render($result, $templates, $isRoot)] + $messages;
         }
 
         return $messages;
@@ -85,12 +85,13 @@ private function formatChild(
             $hasMultipleChildren && $child->name === $parent->name ? $child->withoutName() : $child,
             $renderer,
             $templates,
+            false,
         );
 
         $childMessage = count($formatted) === 1 ? current($formatted) : $formatted;
 
         if (is_array($childMessage) && count($childMessage) > 1 && !isset($childMessage['__root__'])) {
-            $childMessage = ['__root__' => $renderer->render($child, $templates)] + $childMessage;
+            $childMessage = ['__root__' => $renderer->render($child, $templates, false)] + $childMessage;
         }
 
         if (!$hasStringKey) {
@@ -147,7 +148,7 @@ private function flattenToIndexedList(
         Renderer $renderer,
         array $templates,
     ): array {
-        $parentMessage = $messages['__root__'] ?? $renderer->render($parent, $templates);
+        $parentMessage = $messages['__root__'] ?? $renderer->render($parent, $templates, false);
 
         return ['__root__' => $parentMessage] + array_values($messages) + [count($messages) => $childMessage];
     }

src/Message/Formatter/NestedListStringFormatter.php

@@ -29,7 +29,7 @@
     /** @param array<string|int, mixed> $templates */
     public function format(Result $result, Renderer $renderer, array $templates): string
     {
-        return $this->formatRecursively($result, $renderer, $templates, 0, null);
+        return $this->formatRecursively($result, $renderer, $templates, 0, null, true);
     }
 
     /** @param array<string|int, mixed> $templates */
@@ -39,6 +39,7 @@ private function formatRecursively(
         array $templates,
         int $depth,
         Name|null $lastVisibleName,
+        bool $isRoot,
         Result ...$siblings,
     ): string {
         $formatted = '';
@@ -50,6 +51,7 @@ private function formatRecursively(
                 $renderer->render(
                     $lastVisibleName === $result->name ? $result->withoutName() : $result,
                     $templates,
+                    $isRoot,
                 ),
             );
             $lastVisibleName ??= $result->name;
@@ -63,6 +65,7 @@ private function formatRecursively(
                 $templates,
                 $depth,
                 $lastVisibleName,
+                false,
                 ...array_filter($result->children, static fn(Result $sibling) => $sibling !== $child),
             );
             $formatted .= PHP_EOL;
@@ -77,21 +80,12 @@ private function isVisible(Result $result, Result ...$siblings): bool
             return true;
         }
 
-        // Parents of an only child are not visible by default
         if (count($result->children) !== 1) {
             return true;
         }
 
-        // Only children are always visible
-        if (count($siblings) === 0) {
-            return false;
-        }
-
-        // The visibility of a result then will depend on whether any of its siblings is visible
-        foreach ($siblings as $key => $currentSibling) {
-            $otherSiblings = $siblings;
-            unset($otherSiblings[$key]);
-            if ($this->isVisible($currentSibling, ...$otherSiblings)) {
+        foreach ($siblings as $sibling) {
+            if ($sibling->hasCustomTemplate() || count($sibling->children) !== 1) {
                 return true;
             }
         }

src/Message/Formatter/TemplateResolver.php

@@ -15,8 +15,6 @@
 use Respect\Validation\Path;
 use Respect\Validation\Result;
 
-use function array_reduce;
-use function array_reverse;
 use function is_array;
 use function is_string;
 
@@ -28,26 +26,33 @@ public function __construct(
     }
 
     /** @param array<string|int, mixed> $templates */
-    public function getGivenTemplate(Result $result, array $templates): string|null
+    public function getGivenTemplate(Result $result, array $templates, bool $isRoot = true): string|null
     {
         if ($result->hasCustomTemplate()) {
             return $result->template;
         }
 
+        $filtered = $templates;
+        $isAtCorrectScope = $isRoot;
+
         if ($result->path !== null) {
-            $templates = $this->filterByPath($result->path, $templates);
+            [$filtered, $isAtCorrectScope] = $this->filterByPath($result->path, $templates);
         }
 
-        foreach ([$result->path?->value, $result->name?->value, $result->id->value, '__root__'] as $key) {
-            if ($key === null || !isset($templates[$key])) {
+        foreach ([$result->path?->value, $result->name?->value, $result->id->value] as $key) {
+            if ($key === null || !isset($filtered[$key])) {
                 continue;
             }
 
-            if (is_string($templates[$key])) {
-                return $templates[$key];
+            if (is_string($filtered[$key])) {
+                return $filtered[$key];
             }
         }
 
+        if ($isAtCorrectScope && isset($filtered['__root__']) && is_string($filtered['__root__'])) {
+            return $filtered['__root__'];
+        }
+
         return null;
     }
 
@@ -69,31 +74,22 @@ public function getValidatorTemplate(Result $result): string
     }
 
     /**
-     * @param array<string|int> $nodes
+     * @param array<string|int, mixed> $templates
      *
-     * @return non-empty-array<string|int>
+     * @return array{array<string|int, mixed>, bool}
      */
-    private function getNodes(Path $path, array $nodes = []): array
+    private function filterByPath(Path $path, array $templates): array
     {
-        $nodes[] = $path->value;
         if ($path->parent !== null) {
-            return $this->getNodes($path->parent, $nodes);
+            [$templates, $fullyConsumed] = $this->filterByPath($path->parent, $templates);
+        } else {
+            $fullyConsumed = true;
         }
 
-        return $nodes;
-    }
+        if (isset($templates[$path->value]) && is_array($templates[$path->value])) {
+            return [$templates[$path->value], $fullyConsumed];
+        }
 
-    /**
-     * @param array<string|int, mixed> $templates
-     *
-     * @return array<string|int, mixed>
-     */
-    private function filterByPath(Path $path, array $templates): array
-    {
-        return array_reduce(
-            array_reverse($this->getNodes($path)),
-            static fn(array $carry, $node) => isset($carry[$node]) && is_array($carry[$node]) ? $carry[$node] : $carry,
-            $templates,
-        );
+        return [$templates, false];
     }
 }

src/Message/InterpolationRenderer.php

@@ -26,21 +26,20 @@ public function __construct(
     }
 
     /** @param array<string|int, mixed> $templates */
-    public function render(Result $result, array $templates): string
+    public function render(Result $result, array $templates, bool $isRoot = true): string
     {
         $parameters = ['path' => $result->path, 'input' => $result->input, 'subject' => $result];
         $parameters += $result->parameters;
 
-        $givenTemplate = $this->templateResolver->getGivenTemplate($result, $templates);
-        $ruleTemplate = $this->templateResolver->getValidatorTemplate($result);
+        $givenTemplate = $this->templateResolver->getGivenTemplate($result, $templates, $isRoot);
 
         $rendered = $this->formatter->formatUsing(
-            $this->translator->trans($givenTemplate ?? $ruleTemplate),
+            $this->translator->trans($givenTemplate ?? $this->templateResolver->getValidatorTemplate($result)),
             $parameters,
         );
 
         if (!$result->hasCustomTemplate() && $givenTemplate === null && $result->adjacent !== null) {
-            $rendered .= ' ' . $this->render($result->adjacent, $templates);
+            $rendered .= ' ' . $this->render($result->adjacent, $templates, false);
         }
 
         return $rendered;

src/Message/Renderer.php

@@ -16,5 +16,5 @@
 interface Renderer
 {
     /** @param array<string|int, mixed> $templates */
-    public function render(Result $result, array $templates): string;
+    public function render(Result $result, array $templates, bool $isRoot = true): string;
 }

src/Result.php

@@ -125,7 +125,12 @@ public function withPrecedentName(bool $hasPrecedentName): self
     public function withPath(Path $path): self
     {
         if ($this->path !== null) {
-            $this->path->parent = $path;
+            $current = $this->path;
+            while ($current->parent !== null) {
+                $current = $current->parent;
+            }
+
+            $current->parent = $path;
 
             return $this;
         }