Replace template rendering code with Respect\StringFormatter

I've moved almost all the code for placeholder replacement and parameter
modifiers into an external library called Respect\StringFormatter. This approach
allows us to evolve the template capabilities without making major changes to the
Validation's code.

This commit will introduce another dependency, `respect/string-formatter`, and
will upgrade the version of `respect/string-formatter`, which simplifies our
internal API greatly.

While making this change, I also updated how we generate exceptions. Instead of
rendering the full message and the array of messages, we delegate that creation
to the `ResultQuery`, which improves performance because we don’t need to render
those big messages unless the user actually needs them.

Author: henriquemoody

composer.json

@@ -23,7 +23,8 @@
         "php": ">=8.5",
         "php-di/php-di": "^7.1",
         "psr/container": "^2.0",
-        "respect/stringifier": "^2.0.0",
+        "respect/string-formatter": "^0.1.0",
+        "respect/stringifier": "^3.0",
         "symfony/polyfill-mbstring": "^1.33"
     },
     "require-dev": {
@@ -46,6 +47,7 @@
         "sokil/php-isocodes-db-only": "^4.0",
         "squizlabs/php_codesniffer": "^4.0",
         "symfony/console": "^7.4",
+        "symfony/translation": "^8.0",
         "symfony/var-exporter": "^6.4 || ^7.0"
     },
     "suggest": {

docs/messages/placeholder-pipes.md

@@ -62,25 +62,25 @@ v::templated(
 // → Le champ "adresse e-mail" est invalide
 ```
 
-### listOr
+### list:or
 
-The `listOr` modifier formats arrays as readable lists using "or":
+The `list:or` modifier formats arrays as readable lists using "or":
 
 ```php
 v::templated(
-    'Status must be {{haystack|listOr}}',
+    'Status must be {{haystack|list:or}}',
     v::in(['active', 'pending', 'archived']),
 )->assert('deleted');
 // → Status must be "active", "pending", or "archived"
 ```
 
-### listAnd
+### list:and
 
-The `listAnd` modifier formats arrays as readable lists using "and":
+The `list:and` modifier formats arrays as readable lists using "and":
 
 ```php
 v::templated(
-    'User must have {{roles|listAnd}} roles to perform this action',
+    'User must have {{roles|list:and}} roles to perform this action',
     v::callback(fn(User $user) => $user->hasRoles(['admin', 'editor'])),
     ['roles' => ['admin', 'editor']],
 )->assert($user);

library/ContainerRegistry.php

@@ -12,27 +12,33 @@
 
 use DI\Container;
 use Psr\Container\ContainerInterface;
+use Respect\StringFormatter\BypassTranslator;
+use Respect\StringFormatter\Modifier;
+use Respect\StringFormatter\Modifiers\ListModifier;
+use Respect\StringFormatter\Modifiers\QuoteModifier;
+use Respect\StringFormatter\Modifiers\RawModifier;
+use Respect\StringFormatter\Modifiers\StringifyModifier;
+use Respect\StringFormatter\Modifiers\TransModifier;
+use Respect\StringFormatter\PlaceholderFormatter;
+use Respect\Stringifier\DumpStringifier;
+use Respect\Stringifier\Handler;
+use Respect\Stringifier\Handlers\CompositeHandler;
+use Respect\Stringifier\HandlerStringifier;
 use Respect\Stringifier\Quoter;
-use Respect\Stringifier\Quoters\StandardQuoter;
+use Respect\Stringifier\Quoters\CodeQuoter;
 use Respect\Stringifier\Stringifier;
 use Respect\Validation\Message\Formatter\FirstResultStringFormatter;
 use Respect\Validation\Message\Formatter\NestedArrayFormatter;
 use Respect\Validation\Message\Formatter\NestedListStringFormatter;
 use Respect\Validation\Message\Formatter\TemplateResolver;
 use Respect\Validation\Message\InterpolationRenderer;
-use Respect\Validation\Message\Modifier;
-use Respect\Validation\Message\Modifier\ListAndModifier;
-use Respect\Validation\Message\Modifier\ListOrModifier;
-use Respect\Validation\Message\Modifier\QuoteModifier;
-use Respect\Validation\Message\Modifier\RawModifier;
-use Respect\Validation\Message\Modifier\StringifyModifier;
-use Respect\Validation\Message\Modifier\TransModifier;
 use Respect\Validation\Message\Renderer;
-use Respect\Validation\Message\Translator;
-use Respect\Validation\Message\Translator\DummyTranslator;
-use Respect\Validation\Message\ValidationStringifier;
+use Respect\Validation\Message\Stringifier\Handlers\NameHandler;
+use Respect\Validation\Message\Stringifier\Handlers\PathHandler;
+use Respect\Validation\Message\Stringifier\Handlers\ResultHandler;
 use Respect\Validation\Transformers\Prefix;
 use Respect\Validation\Transformers\Transformer;
+use Symfony\Contracts\Translation\TranslatorInterface;
 
 use function DI\autowire;
 use function DI\create;
@@ -47,9 +53,7 @@ public static function createContainer(): Container
         return new Container([
             Transformer::class => create(Prefix::class),
             TemplateResolver::class => create(TemplateResolver::class),
-            Quoter::class => create(StandardQuoter::class)->constructor(ValidationStringifier::MAXIMUM_LENGTH),
-            Stringifier::class => autowire(ValidationStringifier::class),
-            Translator::class => autowire(DummyTranslator::class),
+            TranslatorInterface::class => autowire(BypassTranslator::class),
             Renderer::class => autowire(InterpolationRenderer::class),
             ResultFilter::class => create(OnlyFailedChildrenResultFilter::class),
             'respect.validation.formatter.message' => autowire(FirstResultStringFormatter::class),
@@ -61,19 +65,33 @@ public static function createContainer(): Container
                 $container->get(Transformer::class),
                 $container->get('respect.validation.rule_factory.namespaces'),
             )),
+            Quoter::class => create(CodeQuoter::class)->constructor(120),
+            Handler::class => factory(static function (Container $container) {
+                $handler = CompositeHandler::create();
+                $handler->prependHandler(new PathHandler($container->get(Quoter::class)));
+                $handler->prependHandler(new NameHandler());
+                $handler->prependHandler(new ResultHandler($handler));
+
+                return $handler;
+            }),
+            PlaceholderFormatter::class => factory(static fn(Container $container) => new PlaceholderFormatter(
+                [],
+                $container->get(Modifier::class),
+            )),
+            Stringifier::class => factory(static fn(Container $container) => new HandlerStringifier(
+                $container->get(Handler::class),
+                new DumpStringifier(),
+            )),
             Modifier::class => factory(static fn(Container $container) => new TransModifier(
-                $container->get(Translator::class),
-                new ListOrModifier(
-                    $container->get(Translator::class),
-                    new ListAndModifier(
-                        $container->get(Translator::class),
-                        new QuoteModifier(
-                            new RawModifier(
-                                new StringifyModifier($container->get(Stringifier::class)),
-                            ),
+                new ListModifier(
+                    new QuoteModifier(
+                        new RawModifier(
+                            new StringifyModifier($container->get(Stringifier::class)),
                         ),
                     ),
+                    $container->get(TranslatorInterface::class),
                 ),
+                $container->get(TranslatorInterface::class),
             )),
             ValidatorBuilder::class => factory(static fn(Container $container) => new ValidatorBuilder(
                 $container->get(ValidatorFactory::class),

library/Exceptions/ValidationException.php

@@ -18,22 +18,18 @@
 namespace Respect\Validation\Exceptions;
 
 use InvalidArgumentException;
+use Respect\Validation\ResultQuery;
 
 use function array_shift;
 use function in_array;
 use function realpath;
 
 final class ValidationException extends InvalidArgumentException implements Exception
 {
-    /**
-     * @param array<string|int, mixed> $messages
-     * @param array<string>            $ignoredBacktracePaths
-     */
     public function __construct(
         string $message,
-        private readonly string $fullMessage,
-        private readonly array $messages,
-        array $ignoredBacktracePaths = [],
+        private readonly ResultQuery $resultQuery,
+        string ...$ignoredBacktracePaths,
     ) {
         $this->overwriteFileAndLine($ignoredBacktracePaths);
 
@@ -42,13 +38,13 @@ public function __construct(
 
     public function getFullMessage(): string
     {
-        return $this->fullMessage;
+        return $this->resultQuery->getFullMessage();
     }
 
     /** @return array<string|int, mixed> */
     public function getMessages(): array
     {
-        return $this->messages;
+        return $this->resultQuery->getMessages();
     }
 
     /** @param array<string> $ignoredBacktracePaths */

library/Message/InterpolationRenderer.php

@@ -10,38 +10,32 @@
 
 namespace Respect\Validation\Message;
 
+use Respect\StringFormatter\PlaceholderFormatter;
 use Respect\Validation\Message\Formatter\TemplateResolver;
-use Respect\Validation\Message\Placeholder\Subject;
 use Respect\Validation\Result;
-
-use function array_key_exists;
-use function array_pad;
-use function assert;
-use function is_string;
-use function preg_replace_callback;
+use Symfony\Contracts\Translation\TranslatorInterface;
 
 final readonly class InterpolationRenderer implements Renderer
 {
     public function __construct(
-        private Translator $translator,
-        private Modifier $modifier,
+        private TranslatorInterface $translator,
+        private PlaceholderFormatter $formatter,
         private TemplateResolver $templateResolver,
     ) {
     }
 
     /** @param array<string|int, mixed> $templates */
     public function render(Result $result, array $templates): string
     {
-        $parameters = ['path' => $result->path, 'input' => $result->input, 'subject' => Subject::fromResult($result)];
+        $parameters = ['path' => $result->path, 'input' => $result->input, 'subject' => $result];
         $parameters += $result->parameters;
 
         $givenTemplate = $this->templateResolver->getGivenTemplate($result, $templates);
         $ruleTemplate = $this->templateResolver->getValidatorTemplate($result);
 
-        $rendered = (string) preg_replace_callback(
-            '/{{(\w+)(\|([^}]+))?}}/',
-            fn(array $matches) => $this->processPlaceholder($parameters, $matches),
-            $this->translator->translate($givenTemplate ?? $ruleTemplate),
+        $rendered = $this->formatter->formatUsing(
+            $this->translator->trans($givenTemplate ?? $ruleTemplate),
+            $parameters,
         );
 
         if (!$result->hasCustomTemplate() && $givenTemplate === null && $result->adjacent !== null) {
@@ -50,20 +44,4 @@ public function render(Result $result, array $templates): string
 
         return $rendered;
     }
-
-    /**
-     * @param array<string, mixed>    $parameters
-     * @param array<int, string|null> $matches
-     */
-    private function processPlaceholder(array $parameters, array $matches): string
-    {
-        [$placeholder, $name, , $pipe] = array_pad($matches, 4, null);
-        assert(is_string($placeholder));
-        assert(is_string($name));
-        if (!array_key_exists($name, $parameters)) {
-            return $placeholder;
-        }
-
-        return $this->modifier->modify($parameters[$name], $pipe);
-    }
 }