update CallableFieldType to work with services

Author: Florian-Merle

Annotation/AsGridFieldCallableService.php

@@ -0,0 +1,19 @@
+<?php
+
+/*
+ * This file is part of the Sylius package.
+ *
+ * (c) Sylius Sp. z o.o.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Sylius\Component\Grid\Annotation;
+
+#[\Attribute(\Attribute::TARGET_CLASS)]
+final class AsGridFieldCallableService
+{
+}

FieldTypes/CallableFieldType.php

@@ -13,21 +13,28 @@
 
 namespace Sylius\Component\Grid\FieldTypes;
 
+use Psr\Container\ContainerInterface;
 use Sylius\Component\Grid\DataExtractor\DataExtractorInterface;
 use Sylius\Component\Grid\Definition\Field;
 use Sylius\Component\Grid\Exception\UnexpectedValueException;
 use Symfony\Component\OptionsResolver\OptionsResolver;
 
 final class CallableFieldType implements FieldTypeInterface
 {
-    public function __construct(private DataExtractorInterface $dataExtractor)
-    {
+    public function __construct(
+        private DataExtractorInterface $dataExtractor,
+        private ContainerInterface $locator,
+    ) {
     }
 
     public function render(Field $field, $data, array $options): string
     {
+        if (isset($options['callable']) === isset($options['service'])) {
+            throw new \RuntimeException('Exactly one of the "callable" or "service" options must be defined.');
+        }
+
         $value = $this->dataExtractor->get($field, $data);
-        $value = call_user_func($options['callable'], $value);
+        $value = call_user_func($this->getCallable($options), $value);
 
         try {
             $value = (string) $value;
@@ -46,11 +53,45 @@ public function render(Field $field, $data, array $options): string
         return $value;
     }
 
+    private function getCallable(array $options): callable
+    {
+        if (isset($options['callable'])) {
+            return $options['callable'];
+        }
+
+        if (!$this->locator->has($options['service'])) {
+            throw new \RuntimeException(sprintf('Service "%s" not found, make sure it is tagged with "sylius.grid_field_callable_service".', $options['service']));
+        }
+
+        $service = $this->locator->get($options['service']);
+        if (isset($options['method'])) {
+            $callable = [$service, $options['method']];
+
+            if (!is_callable($callable)) {
+                throw new \RuntimeException(sprintf('The method "%s" is not callable on service "%s".', $options['method'], $options['service']));
+            }
+
+            return $callable;
+        }
+
+        if (!is_callable($service)) {
+            throw new \RuntimeException(sprintf('The service "%s" is not callable.', $options['service']));
+        }
+
+        return $service;
+    }
+
     public function configureOptions(OptionsResolver $resolver): void
     {
-        $resolver->setRequired('callable');
+        $resolver->setDefined('callable');
         $resolver->setAllowedTypes('callable', 'callable');
 
+        $resolver->setDefined('service');
+        $resolver->setAllowedTypes('service', 'string');
+
+        $resolver->setDefined('method');
+        $resolver->setAllowedTypes('method', 'string');
+
         $resolver->setDefault('htmlspecialchars', true);
         $resolver->setAllowedTypes('htmlspecialchars', 'bool');
     }

spec/FieldTypes/CallableFieldTypeSpec.php

@@ -18,12 +18,30 @@
 use Sylius\Component\Grid\Definition\Field;
 use Sylius\Component\Grid\Exception\UnexpectedValueException;
 use Sylius\Component\Grid\FieldTypes\FieldTypeInterface;
+use Symfony\Contracts\Service\ServiceLocatorTrait;
+use Symfony\Contracts\Service\ServiceProviderInterface;
 
 final class CallableFieldTypeSpec extends ObjectBehavior
 {
     function let(DataExtractorInterface $dataExtractor): void
     {
-        $this->beConstructedWith($dataExtractor);
+        $this->beConstructedWith(
+            $dataExtractor,
+            new class(['my_service' => fn () => new class() {
+                public function __invoke(string $value): string
+                {
+                    return strtoupper($value);
+                }
+
+                public function concatenate(array $value): string
+                {
+                    return implode(', ', $value);
+                }
+            },
+            ]) implements ServiceProviderInterface {
+                use ServiceLocatorTrait;
+            },
+        );
     }
 
     function it_is_a_grid_field_type(): void
@@ -79,6 +97,31 @@ function it_uses_data_extractor_to_obtain_data_and_passes_it_to_a_static_callabl
         ])->shouldReturn('bar');
     }
 
+    function it_uses_data_extractor_to_obtain_data_and_passes_it_to_a_service(
+        DataExtractorInterface $dataExtractor,
+        Field $field,
+    ): void {
+        $dataExtractor->get($field, ['foo' => 'bar'])->willReturn('bar');
+
+        $this->render($field, ['foo' => 'bar'], [
+            'service' => 'my_service',
+            'htmlspecialchars' => true,
+        ])->shouldReturn('BAR');
+    }
+
+    function it_uses_data_extractor_to_obtain_data_and_passes_it_to_a_service_and_method(
+        DataExtractorInterface $dataExtractor,
+        Field $field,
+    ): void {
+        $dataExtractor->get($field, ['foo' => ['foo', 'bar', 'foobar']])->willReturn(['foo', 'bar', 'foobar']);
+
+        $this->render($field, ['foo' => ['foo', 'bar', 'foobar']], [
+            'service' => 'my_service',
+            'method' => 'concatenate',
+            'htmlspecialchars' => true,
+        ])->shouldReturn('foo, bar, foobar');
+    }
+
     function it_throws_an_exception_when_a_callable_return_value_cannot_be_casted_to_string(
         DataExtractorInterface $dataExtractor,
         Field $field,
@@ -98,6 +141,35 @@ function it_throws_an_exception_when_a_callable_return_value_cannot_be_casted_to
             ]);
     }
 
+    function it_throws_an_exception_when_neither_callable_nor_service_options_are_defined(
+        DataExtractorInterface $dataExtractor,
+        Field $field,
+    ): void {
+        $this
+            ->shouldThrow(\RuntimeException::class)
+            ->during('render', [
+                $field,
+                ['foo' => 'bar'],
+                [],
+            ]);
+    }
+
+    function it_throws_an_exception_when_both_callable_and_service_options_are_defined(
+        DataExtractorInterface $dataExtractor,
+        Field $field,
+    ): void {
+        $this
+            ->shouldThrow(\RuntimeException::class)
+            ->during('render', [
+                $field,
+                ['foo' => 'bar'],
+                [
+                    'callable' => fn () => new \stdclass(),
+                    'service' => 'my_service',
+                ],
+            ]);
+    }
+
     static function callable(mixed $value): string
     {
         return strtolower($value);