Change the contract of the formatters

henriquemoody · henriquemoody · commit 644ecb5190e6 · 2025-12-22T13:43:59.000+01:00
Both `ArrayFormatter` and `StringFormatter` accept an instance of the
`Translator`. Thinking about it a bit better, I realised that a
formatter might not always need a `Translator`, but it will surely need
a `Renderer`.

Besides, the `InterpolationRenderer` needs to take translation into
account, so it seems more natural to me that this is the one that will
get an instance of the `Translator`, as other implementations of the
`Renderer` might not even deal with translations.
diff --git a/library/ContainerRegistry.php b/library/ContainerRegistry.php
@@ -51,10 +51,10 @@ public static function createContainer(): Container
             'respect.validation.ignored_backtrace_paths' => [__DIR__ . '/Validator.php'],
             Validator::class => factory(static fn(Container $container) => new Validator(
                 $container->get(Factory::class),
+                $container->get(Renderer::class),
                 $container->get('respect.validation.formatter.message'),
                 $container->get('respect.validation.formatter.full_message'),
                 $container->get('respect.validation.formatter.messages'),
-                $container->get(Translator::class),
                 $container->get(ResultFilter::class),
                 $container->get('respect.validation.ignored_backtrace_paths'),
             )),
diff --git a/library/Message/ArrayFormatter.php b/library/Message/ArrayFormatter.php
@@ -18,5 +18,5 @@ interface ArrayFormatter
      *
      * @return array<string, mixed>
      */
-    public function format(Result $result, array $templates, Translator $translator): array;
+    public function format(Result $result, Renderer $renderer, array $templates): array;
 }
diff --git a/library/Message/Formatter/FirstResultStringFormatter.php b/library/Message/Formatter/FirstResultStringFormatter.php
@@ -11,31 +11,25 @@
 
 use Respect\Validation\Message\Renderer;
 use Respect\Validation\Message\StringFormatter;
-use Respect\Validation\Message\Translator;
 use Respect\Validation\Result;
 
 final readonly class FirstResultStringFormatter implements StringFormatter
 {
     public function __construct(
-        private Renderer $renderer,
         private TemplateResolver $templateResolver,
     ) {
     }
 
     /** @param array<string|int, mixed> $templates */
-    public function format(Result $result, array $templates, Translator $translator): string
+    public function format(Result $result, Renderer $renderer, array $templates): string
     {
         $matchedTemplates = $this->templateResolver->selectMatches($result, $templates);
         if (!$this->templateResolver->hasMatch($result, $matchedTemplates)) {
             foreach ($result->children as $child) {
-                return $this->format(
-                    $child,
-                    $matchedTemplates,
-                    $translator,
-                );
+                return $this->format($child, $renderer, $matchedTemplates);
             }
         }
 
-        return $this->renderer->render($this->templateResolver->resolve($result, $matchedTemplates), $translator);
+        return $renderer->render($this->templateResolver->resolve($result, $matchedTemplates));
     }
 }
diff --git a/library/Message/Formatter/NestedArrayFormatter.php b/library/Message/Formatter/NestedArrayFormatter.php
@@ -11,7 +11,6 @@
 
 use Respect\Validation\Message\ArrayFormatter;
 use Respect\Validation\Message\Renderer;
-use Respect\Validation\Message\Translator;
 use Respect\Validation\Result;
 
 use function count;
@@ -20,7 +19,6 @@
 final readonly class NestedArrayFormatter implements ArrayFormatter
 {
     public function __construct(
-        private Renderer $renderer,
         private TemplateResolver $templateResolver,
     ) {
     }
@@ -30,14 +28,13 @@ public function __construct(
      *
      * @return array<string|int, mixed>
      */
-    public function format(Result $result, array $templates, Translator $translator): array
+    public function format(Result $result, Renderer $renderer, array $templates): array
     {
         $matchedTemplates = $this->templateResolver->selectMatches($result, $templates);
         if (count($result->children) === 0 || $this->templateResolver->hasMatch($result, $matchedTemplates)) {
             return [
-                $result->path->value ?? $result->id->value => $this->renderer->render(
+                $result->path->value ?? $result->id->value => $renderer->render(
                     $this->templateResolver->resolve($result->withoutParentPath(), $matchedTemplates),
-                    $translator,
                 ),
             ];
         }
@@ -47,8 +44,8 @@ public function format(Result $result, array $templates, Translator $translator)
             $key = $child->path->value ?? $child->id->value;
             $messages[$key] = $this->format(
                 $child->withoutParentPath()->withoutName(),
+                $renderer,
                 $this->templateResolver->selectMatches($child, $matchedTemplates),
-                $translator,
             );
             if (count($messages[$key]) !== 1) {
                 continue;
@@ -59,9 +56,8 @@ public function format(Result $result, array $templates, Translator $translator)
 
         if (count($messages) > 1) {
             $self = [
-                '__root__' => $this->renderer->render(
+                '__root__' => $renderer->render(
                     $this->templateResolver->resolve($result->withoutParentPath(), $matchedTemplates),
-                    $translator,
                 ),
             ];
 
diff --git a/library/Message/Formatter/NestedListStringFormatter.php b/library/Message/Formatter/NestedListStringFormatter.php
@@ -11,7 +11,6 @@
 
 use Respect\Validation\Message\Renderer;
 use Respect\Validation\Message\StringFormatter;
-use Respect\Validation\Message\Translator;
 use Respect\Validation\Result;
 
 use function array_filter;
@@ -26,23 +25,22 @@
 final readonly class NestedListStringFormatter implements StringFormatter
 {
     public function __construct(
-        private Renderer $renderer,
         private TemplateResolver $templateResolver,
     ) {
     }
 
     /** @param array<string|int, mixed> $templates */
-    public function format(Result $result, array $templates, Translator $translator): string
+    public function format(Result $result, Renderer $renderer, array $templates): string
     {
-        return $this->formatRecursively($result, $templates, $translator, 0);
+        return $this->formatRecursively($result, $renderer, $templates, 0);
     }
 
     /** @param array<string|int, mixed> $templates */
     private function formatRecursively(
         Result $result,
+        Renderer $renderer,
         array $templates,
-        Translator $translator,
-        int $depth = 0,
+        int $depth,
         Result ...$siblings,
     ): string {
         $matchedTemplates = $this->templateResolver->selectMatches($result, $templates);
@@ -55,12 +53,11 @@ private function formatRecursively(
             $formatted .= sprintf(
                 '%s- %s' . PHP_EOL,
                 $indentation,
-                $this->renderer->render(
+                $renderer->render(
                     $this->templateResolver->resolve(
                         $result->withoutParentPath(),
                         $matchedTemplates,
                     ),
-                    $translator,
                 ),
             );
             $depth++;
@@ -70,8 +67,8 @@ private function formatRecursively(
             foreach ($result->children as $child) {
                 $formatted .= $this->formatRecursively(
                     $displayedName === $child->name ? $child->withoutName() : $child,
+                    $renderer,
                     $matchedTemplates,
-                    $translator,
                     $depth,
                     ...array_filter($result->children, static fn(Result $sibling) => $sibling !== $child),
                 );
diff --git a/library/Message/InterpolationRenderer.php b/library/Message/InterpolationRenderer.php
@@ -31,29 +31,30 @@ final class InterpolationRenderer implements Renderer
     private array $templates = [];
 
     public function __construct(
+        private readonly Translator $translator,
         private readonly Stringifier $stringifier = new ValidationStringifier(),
     ) {
     }
 
-    public function render(Result $result, Translator $translator): string
+    public function render(Result $result): string
     {
         $parameters = ['path' => $result->path, 'input' => $result->input, 'name' => $this->getName($result)];
         $parameters += $result->parameters;
 
         $rendered = (string) preg_replace_callback(
             '/{{(\w+)(\|([^}]+))?}}/',
-            function (array $matches) use ($parameters, $translator) {
+            function (array $matches) use ($parameters) {
                 if (!isset($parameters[$matches[1]])) {
                     return $matches[0];
                 }
 
-                return $this->placeholder($matches[1], $parameters[$matches[1]], $translator, $matches[3] ?? null);
+                return $this->placeholder($matches[1], $parameters[$matches[1]], $matches[3] ?? null);
             },
-            $translator->translate($this->getTemplateMessage($result)),
+            $this->translator->translate($this->getTemplateMessage($result)),
         );
 
         if (!$result->hasCustomTemplate() && $result->adjacent !== null) {
-            $rendered .= ' ' . $this->render($result->adjacent, $translator);
+            $rendered .= ' ' . $this->render($result->adjacent);
         }
 
         return $rendered;
@@ -75,27 +76,26 @@ private function extractTemplates(Rule $rule): array
     private function placeholder(
         string $name,
         mixed $value,
-        Translator $translator,
         string|null $modifier = null,
     ): string {
         if ($modifier === 'quote' && is_string($value)) {
-            return $this->placeholder($name, new Quoted($value), $translator);
+            return $this->placeholder($name, new Quoted($value));
         }
 
         if ($modifier === 'listOr' && is_array($value)) {
-            return $this->placeholder($name, new Listed($value, $translator->translate('or')), $translator);
+            return $this->placeholder($name, new Listed($value, $this->translator->translate('or')));
         }
 
         if ($modifier === 'listAnd' && is_array($value)) {
-            return $this->placeholder($name, new Listed($value, $translator->translate('and')), $translator);
+            return $this->placeholder($name, new Listed($value, $this->translator->translate('and')));
         }
 
         if ($modifier === 'raw' && is_scalar($value)) {
             return is_bool($value) ? (string) (int) $value : (string) $value;
         }
 
         if ($modifier === 'trans' && is_string($value)) {
-            return $translator->translate($value);
+            return $this->translator->translate($value);
         }
 
         return $this->stringifier->stringify($value, 0) ?? print_r($value, true);
diff --git a/library/Message/Renderer.php b/library/Message/Renderer.php
@@ -13,5 +13,5 @@
 
 interface Renderer
 {
-    public function render(Result $result, Translator $translator): string;
+    public function render(Result $result): string;
 }
diff --git a/library/Message/StringFormatter.php b/library/Message/StringFormatter.php
@@ -14,5 +14,5 @@
 interface StringFormatter
 {
     /** @param array<string, mixed> $templates */
-    public function format(Result $result, array $templates, Translator $translator): string;
+    public function format(Result $result, Renderer $renderer, array $templates): string;
 }
diff --git a/library/Validator.php b/library/Validator.php
@@ -11,8 +11,8 @@
 
 use Respect\Validation\Exceptions\ValidationException;
 use Respect\Validation\Message\ArrayFormatter;
+use Respect\Validation\Message\Renderer;
 use Respect\Validation\Message\StringFormatter;
-use Respect\Validation\Message\Translator;
 use Respect\Validation\Mixins\Builder;
 use Respect\Validation\Rules\Core\Nameable;
 use Respect\Validation\Rules\Core\Reducer;
@@ -38,10 +38,10 @@ final class Validator implements Rule, Nameable
     /** @param array<string> $ignoredBacktracePaths */
     public function __construct(
         private readonly Factory $factory,
+        private readonly Renderer $renderer,
         private readonly StringFormatter $mainMessageFormatter,
         private readonly StringFormatter $fullMessageFormatter,
         private readonly ArrayFormatter $messagesFormatter,
-        private readonly Translator $translator,
         private readonly ResultFilter $resultFilter,
         private readonly array $ignoredBacktracePaths,
     ) {
@@ -89,9 +89,9 @@ public function assert(mixed $input, array|string|Throwable|callable|null $templ
         $failedResult = $this->resultFilter->filter($result);
 
         $exception = new ValidationException(
-            $this->mainMessageFormatter->format($failedResult, $templates, $this->translator),
-            $this->fullMessageFormatter->format($failedResult, $templates, $this->translator),
-            $this->messagesFormatter->format($failedResult, $templates, $this->translator),
+            $this->mainMessageFormatter->format($failedResult, $this->renderer, $templates),
+            $this->fullMessageFormatter->format($failedResult, $this->renderer, $templates),
+            $this->messagesFormatter->format($failedResult, $this->renderer, $templates),
             $this->ignoredBacktracePaths,
         );
 
diff --git a/tests/library/Message/TestingMessageRenderer.php b/tests/library/Message/TestingMessageRenderer.php
@@ -10,12 +10,11 @@
 namespace Respect\Validation\Test\Message;
 
 use Respect\Validation\Message\Renderer;
-use Respect\Validation\Message\Translator;
 use Respect\Validation\Result;
 
 final class TestingMessageRenderer implements Renderer
 {
-    public function render(Result $result, Translator $translator): string
+    public function render(Result $result): string
     {
         return $result->template;
     }
diff --git a/tests/unit/Message/Formatter/FirstResultStringFormatterTest.php b/tests/unit/Message/Formatter/FirstResultStringFormatterTest.php
@@ -14,7 +14,6 @@
 use PHPUnit\Framework\Attributes\Test;
 use Respect\Validation\Exceptions\ComponentException;
 use Respect\Validation\Message\StandardFormatter\ResultCreator;
-use Respect\Validation\Message\Translator\DummyTranslator;
 use Respect\Validation\Result;
 use Respect\Validation\Rule;
 use Respect\Validation\Test\Builders\ResultBuilder;
@@ -35,29 +34,25 @@ final class FirstResultStringFormatterTest extends TestCase
     #[DataProvider('provideForMain')]
     public function itShouldFormatMainMessage(Result $result, string $expected, array $templates = []): void
     {
-        $formatter = new FirstResultStringFormatter(
-            renderer: new TestingMessageRenderer(),
-            templateResolver: new TemplateResolver(),
-        );
+        $renderer = new TestingMessageRenderer();
+        $formatter = new FirstResultStringFormatter(new TemplateResolver());
 
-        self::assertSame($expected, $formatter->format($result, $templates, new DummyTranslator()));
+        self::assertSame($expected, $formatter->format($result, $renderer, $templates));
     }
 
     #[Test]
     public function itShouldThrowAnExceptionWhenTryingToFormatAndTemplateIsInvalid(): void
     {
-        $formatter = new FirstResultStringFormatter(
-            renderer: new TestingMessageRenderer(),
-            templateResolver: new TemplateResolver(),
-        );
+        $renderer = new TestingMessageRenderer();
+        $formatter = new FirstResultStringFormatter(new TemplateResolver());
         $result = (new ResultBuilder())->id('foo')->build();
 
         $template = new stdClass();
 
         $this->expectException(ComponentException::class);
         $this->expectExceptionMessage(sprintf('Template for "foo" must be a string, %s given', stringify($template)));
 
-        $formatter->format($result, ['foo' => $template], new DummyTranslator());
+        $formatter->format($result, $renderer, ['foo' => $template]);
     }
 
     /** @return array<string, array{0: Result, 1: string, 2?: array<string, mixed>}> */
diff --git a/tests/unit/Message/Formatter/NestedArrayFormatterTest.php b/tests/unit/Message/Formatter/NestedArrayFormatterTest.php
@@ -14,7 +14,6 @@
 use PHPUnit\Framework\Attributes\Test;
 use Respect\Validation\Exceptions\ComponentException;
 use Respect\Validation\Message\StandardFormatter\ResultCreator;
-use Respect\Validation\Message\Translator\DummyTranslator;
 use Respect\Validation\Result;
 use Respect\Validation\Test\Builders\ResultBuilder;
 use Respect\Validation\Test\Message\TestingMessageRenderer;
@@ -37,29 +36,25 @@ final class NestedArrayFormatterTest extends TestCase
     #[DataProvider('provideForArray')]
     public function itShouldFormatArrayMessage(Result $result, array $expected, array $templates = []): void
     {
-        $formatter = new NestedArrayFormatter(
-            renderer: new TestingMessageRenderer(),
-            templateResolver: new TemplateResolver(),
-        );
+        $renderer = new TestingMessageRenderer();
+        $formatter = new NestedArrayFormatter(new TemplateResolver());
 
-        self::assertSame($expected, $formatter->format($result, $templates, new DummyTranslator()));
+        self::assertSame($expected, $formatter->format($result, $renderer, $templates));
     }
 
     #[Test]
     public function itShouldThrowAnExceptionWhenTryingToFormatAndTemplateIsInvalid(): void
     {
-        $formatter = new NestedArrayFormatter(
-            renderer: new TestingMessageRenderer(),
-            templateResolver: new TemplateResolver(),
-        );
+        $renderer = new TestingMessageRenderer();
+        $formatter = new NestedArrayFormatter(new TemplateResolver());
         $result = (new ResultBuilder())->id('foo')->build();
 
         $template = new stdClass();
 
         $this->expectException(ComponentException::class);
         $this->expectExceptionMessage(sprintf('Template for "foo" must be a string, %s given', stringify($template)));
 
-        $formatter->format($result, ['foo' => $template], new DummyTranslator());
+        $formatter->format($result, $renderer, ['foo' => $template]);
     }
 
     /** @return array<string, array{0: Result, 1: array<string, mixed>, 2?: array<string, mixed>}> */
diff --git a/tests/unit/Message/Formatter/NestedListStringFormatterTest.php b/tests/unit/Message/Formatter/NestedListStringFormatterTest.php
diff --git a/tests/unit/Message/InterpolationRendererTest.php b/tests/unit/Message/InterpolationRendererTest.php

Original file line number	Diff line number	Diff line change
`@@ -18,5 +18,5 @@ interface ArrayFormatter`
`18`	`18`	`*`
`19`	`19`	`* @return array<string, mixed>`
`20`	`20`	`*/`
`21`		`- public function format(Result $result, array $templates, Translator $translator): array;`
	`21`	`+ public function format(Result $result, Renderer $renderer, array $templates): array;`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,31 +11,25 @@`
`11`	`11`
`12`	`12`	`use Respect\Validation\Message\Renderer;`
`13`	`13`	`use Respect\Validation\Message\StringFormatter;`
`14`		`-use Respect\Validation\Message\Translator;`
`15`	`14`	`use Respect\Validation\Result;`
`16`	`15`
`17`	`16`	`final readonly class FirstResultStringFormatter implements StringFormatter`
`18`	`17`	`{`
`19`	`18`	`public function __construct(`
`20`		`- private Renderer $renderer,`
`21`	`19`	`private TemplateResolver $templateResolver,`
`22`	`20`	`) {`
`23`	`21`	`}`
`24`	`22`
`25`	`23`	`/** @param array<string\|int, mixed> $templates */`
`26`		`- public function format(Result $result, array $templates, Translator $translator): string`
	`24`	`+ public function format(Result $result, Renderer $renderer, array $templates): string`
`27`	`25`	`{`
`28`	`26`	`$matchedTemplates = $this->templateResolver->selectMatches($result, $templates);`
`29`	`27`	`if (!$this->templateResolver->hasMatch($result, $matchedTemplates)) {`
`30`	`28`	`foreach ($result->children as $child) {`
`31`		`- return $this->format(`
`32`		`- $child,`
`33`		`- $matchedTemplates,`
`34`		`- $translator,`
`35`		`- );`
	`29`	`+ return $this->format($child, $renderer, $matchedTemplates);`
`36`	`30`	`}`
`37`	`31`	`}`
`38`	`32`
`39`		`- return $this->renderer->render($this->templateResolver->resolve($result, $matchedTemplates), $translator);`
	`33`	`+ return $renderer->render($this->templateResolver->resolve($result, $matchedTemplates));`
`40`	`34`	`}`
`41`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,5 +13,5 @@`
`13`	`13`
`14`	`14`	`interface Renderer`
`15`	`15`	`{`
`16`		`- public function render(Result $result, Translator $translator): string;`
	`16`	`+ public function render(Result $result): string;`
`17`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,5 +14,5 @@`
`14`	`14`	`interface StringFormatter`
`15`	`15`	`{`
`16`	`16`	`/** @param array<string, mixed> $templates */`
`17`		`- public function format(Result $result, array $templates, Translator $translator): string;`
	`17`	`+ public function format(Result $result, Renderer $renderer, array $templates): string;`
`18`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,12 +10,11 @@`
`10`	`10`	`namespace Respect\Validation\Test\Message;`
`11`	`11`
`12`	`12`	`use Respect\Validation\Message\Renderer;`
`13`		`-use Respect\Validation\Message\Translator;`
`14`	`13`	`use Respect\Validation\Result;`
`15`	`14`
`16`	`15`	`final class TestingMessageRenderer implements Renderer`
`17`	`16`	`{`
`18`		`- public function render(Result $result, Translator $translator): string`
	`17`	`+ public function render(Result $result): string`
`19`	`18`	`{`
`20`	`19`	`return $result->template;`
`21`	`20`	`}`