Merge branch 'symfony:2.x' into safe-classes-configurator

Author: smnandre

src/LiveComponent/CHANGELOG.md

@@ -1,5 +1,10 @@
 # CHANGELOG
 
+## 2.17.0
+
+-   Add `modifier` option in `LiveProp` so options can be modified at runtime.
+-   Fix collections hydration with serializer in LiveComponents
+
 ## 2.16.0
 
 -   LiveComponents is now stable and no longer experimental 🥳

src/LiveComponent/doc/index.rst

@@ -370,6 +370,29 @@ it won't, yet, make an Ajax call to re-render the component. Whenever
 the next re-render *does* happen, the updated ``max`` value will be
 used.
 
+This can be useful along with a button that triggers a render on click:
+
+.. code-block:: html+twig
+
+    <input data-model="norender|coupon">
+    <button data-action="live#$render">Apply</button>
+
+Forcing a Re-Render Explicitly
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+In some cases, you might want to force a component re-render explicitly. For
+example, consider a checkout component that provides a coupon input that must
+only be used when clicking on the associated "Apply coupon" button:
+
+.. code-block:: html+twig
+
+    <input data-model="norender|coupon">
+    <button data-action="live#$render">Apply coupon</button>
+
+The ``norender`` option on the input ensures that the component won't re-render
+when this input changes. The ``live#$render`` action is a special built-in action
+that triggers a re-render.
+
 .. _name-attribute-model:
 
 Using name="" instead of data-model
@@ -3427,6 +3450,53 @@ the change of one specific key::
         }
     }
 
+Set LiveProp Options Dynamically
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. versionadded:: 2.17
+
+    The ``modifier`` option was added in LiveComponents 2.17.
+
+
+If you need to configure a LiveProp's options dynamically, you can use the ``modifier`` option to use a custom
+method in your component that returns a modified version of your LiveProp::
+
+
+    #[AsLiveComponent]
+    class ProductSearch
+    {
+        #[LiveProp(writable: true, modifier: 'modifyAddedDate')]
+        public ?\DateTimeImmutable $addedDate = null;
+
+        #[LiveProp]
+        public string $dateFormat = 'Y-m-d';
+
+        // ...
+
+        public function modifyAddedDate(LiveProp $prop): LiveProp
+        {
+            return $prop->withFormat($this->dateFormat);
+        }
+    }
+
+Then, when using your component in a template, you can change the date format used for ``$addedDate``:
+
+.. code-block:: twig
+
+    {{ component('ProductSearch', {
+        dateFormat: 'd/m/Y'
+    }) }}
+
+
+All ``LiveProp::with*`` methods are immutable, so you need to use their return value as your new LiveProp.
+
+.. caution::
+
+    Avoid relying on props that also use a modifier in other modifiers methods. For example, if the ``$dateFormat``
+    property above also had a ``modifier`` option, then it wouldn't be safe to reference it from the ``modifyAddedDate``
+    modifier method. This is because the ``$dateFormat`` property may not have been hydrated by this point.
+
+
 Debugging Components
 --------------------
 

src/LiveComponent/src/Attribute/LiveProp.php

@@ -101,10 +101,19 @@ public function __construct(
          * in the URL.
          */
         private bool $url = false,
+
+        /**
+         * A hook that will be called when this LiveProp is used.
+         *
+         * Allows to modify the LiveProp options depending on the context. The
+         * original LiveProp attribute instance will be passed as an argument to
+         * it.
+         *
+         * @var string|null
+         */
+        private string|null $modifier = null,
     ) {
-        if ($this->useSerializerForHydration && ($this->hydrateWith || $this->dehydrateWith)) {
-            throw new \InvalidArgumentException('Cannot use useSerializerForHydration with hydrateWith or dehydrateWith.');
-        }
+        self::validateHydrationStrategy($this);
     }
 
     /**
@@ -119,6 +128,14 @@ public function isIdentityWritable(): bool
         return \in_array(self::IDENTITY, $this->writable, true);
     }
 
+    public function withWritable(bool|array $writable): self
+    {
+        $clone = clone $this;
+        $clone->writable = $writable;
+
+        return $clone;
+    }
+
     /**
      * @internal
      */
@@ -141,6 +158,16 @@ public function hydrateMethod(): ?string
         return $this->hydrateWith ? trim($this->hydrateWith, '()') : null;
     }
 
+    public function withHydrateWith(?string $hydrateWith): self
+    {
+        $clone = clone $this;
+        $clone->hydrateWith = $hydrateWith;
+
+        self::validateHydrationStrategy($clone);
+
+        return $clone;
+    }
+
     /**
      * @internal
      */
@@ -149,6 +176,16 @@ public function dehydrateMethod(): ?string
         return $this->dehydrateWith ? trim($this->dehydrateWith, '()') : null;
     }
 
+    public function withDehydrateWith(?string $dehydrateWith): self
+    {
+        $clone = clone $this;
+        $clone->dehydrateWith = $dehydrateWith;
+
+        self::validateHydrationStrategy($clone);
+
+        return $clone;
+    }
+
     /**
      * @internal
      */
@@ -157,6 +194,16 @@ public function useSerializerForHydration(): bool
         return $this->useSerializerForHydration;
     }
 
+    public function withUseSerializerForHydration(bool $userSerializerForHydration): self
+    {
+        $clone = clone $this;
+        $clone->useSerializerForHydration = $userSerializerForHydration;
+
+        self::validateHydrationStrategy($clone);
+
+        return $clone;
+    }
+
     /**
      * @internal
      */
@@ -165,6 +212,16 @@ public function serializationContext(): array
         return $this->serializationContext;
     }
 
+    public function withSerializationContext(array $serializationContext): self
+    {
+        $clone = clone $this;
+        $clone->serializationContext = $serializationContext;
+
+        self::validateHydrationStrategy($clone);
+
+        return $clone;
+    }
+
     /**
      * @internal
      */
@@ -181,11 +238,27 @@ public function calculateFieldName(object $component, string $fallback): string
         return $this->fieldName;
     }
 
+    public function withFieldName(?string $fieldName): self
+    {
+        $clone = clone $this;
+        $clone->fieldName = $fieldName;
+
+        return $clone;
+    }
+
     public function format(): ?string
     {
         return $this->format;
     }
 
+    public function withFormat(?string $format): self
+    {
+        $clone = clone $this;
+        $clone->format = $format;
+
+        return $clone;
+    }
+
     public function acceptUpdatesFromParent(): bool
     {
         return $this->updateFromParent;
@@ -196,8 +269,36 @@ public function onUpdated(): string|array|null
         return $this->onUpdated;
     }
 
+    public function withOnUpdated(string|array|null $onUpdated): self
+    {
+        $clone = clone $this;
+        $clone->onUpdated = $onUpdated;
+
+        return $clone;
+    }
+
     public function url(): bool
     {
         return $this->url;
     }
+
+    public function withUrl(bool $url): self
+    {
+        $clone = clone $this;
+        $clone->url = $url;
+
+        return $clone;
+    }
+
+    public function modifier(): string|null
+    {
+        return $this->modifier;
+    }
+
+    private static function validateHydrationStrategy(self $liveProp): void
+    {
+        if ($liveProp->useSerializerForHydration && ($liveProp->hydrateWith || $liveProp->dehydrateWith)) {
+            throw new \InvalidArgumentException('Cannot use useSerializerForHydration with hydrateWith or dehydrateWith.');
+        }
+    }
 }

src/LiveComponent/src/DependencyInjection/LiveComponentExtension.php

@@ -227,6 +227,7 @@ function (ChildDefinition $definition, AsLiveComponent $attribute) {
                 new Reference('request_stack'),
                 new Reference('ux.live_component.metadata_factory'),
                 new Reference('ux.live_component.query_string_props_extractor'),
+                new Reference('property_accessor'),
             ])
             ->addTag('kernel.event_subscriber');
 

src/LiveComponent/src/EventListener/QueryStringInitializeSubscriber.php

@@ -13,9 +13,11 @@
 
 use Symfony\Component\EventDispatcher\EventSubscriberInterface;
 use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\PropertyAccess\Exception\ExceptionInterface as PropertyAccessExceptionInterface;
+use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
 use Symfony\UX\LiveComponent\Metadata\LiveComponentMetadataFactory;
 use Symfony\UX\LiveComponent\Util\QueryStringPropsExtractor;
-use Symfony\UX\TwigComponent\Event\PreMountEvent;
+use Symfony\UX\TwigComponent\Event\PostMountEvent;
 
 /**
  * @author Nicolas Rigaud <squrious@protonmail.com>
@@ -28,17 +30,18 @@ public function __construct(
         private readonly RequestStack $requestStack,
         private readonly LiveComponentMetadataFactory $metadataFactory,
         private readonly QueryStringPropsExtractor $queryStringPropsExtractor,
+        private readonly PropertyAccessorInterface $propertyAccessor,
     ) {
     }
 
     public static function getSubscribedEvents(): array
     {
         return [
-            PreMountEvent::class => 'onPreMount',
+            PostMountEvent::class => ['onPostMount', 256],
         ];
     }
 
-    public function onPreMount(PreMountEvent $event): void
+    public function onPostMount(PostMountEvent $event): void
     {
         if (!$event->getMetadata()->get('live', false)) {
             // Not a live component
@@ -53,12 +56,20 @@ public function onPreMount(PreMountEvent $event): void
 
         $metadata = $this->metadataFactory->getMetadata($event->getMetadata()->getName());
 
-        if (!$metadata->hasQueryStringBindings()) {
+        if (!$metadata->hasQueryStringBindings($event->getComponent())) {
             return;
         }
 
         $queryStringData = $this->queryStringPropsExtractor->extract($request, $metadata, $event->getComponent());
 
-        $event->setData(array_merge($event->getData(), $queryStringData));
+        $component = $event->getComponent();
+
+        foreach ($queryStringData as $name => $value) {
+            try {
+                $this->propertyAccessor->setValue($component, $name, $value);
+            } catch (PropertyAccessExceptionInterface $exception) {
+                // Ignore errors
+            }
+        }
     }
 }

src/LiveComponent/src/LiveComponentHydrator.php

@@ -63,7 +63,7 @@ public function dehydrate(object $component, ComponentAttributes $attributes, Li
         $takenFrontendPropertyNames = [];
 
         $dehydratedProps = new DehydratedProps();
-        foreach ($componentMetadata->getAllLivePropsMetadata() as $propMetadata) {
+        foreach ($componentMetadata->getAllLivePropsMetadata($component) as $propMetadata) {
             $propertyName = $propMetadata->getName();
             $frontendName = $propMetadata->calculateFieldName($component, $propertyName);
 
@@ -143,8 +143,9 @@ public function hydrate(object $component, array $props, array $updatedProps, Li
         $attributes = new ComponentAttributes($dehydratedOriginalProps->getPropValue(self::ATTRIBUTES_KEY, []));
         $dehydratedOriginalProps->removePropValue(self::ATTRIBUTES_KEY);
 
-        foreach ($componentMetadata->getAllLivePropsMetadata() as $propMetadata) {
+        foreach ($componentMetadata->getAllLivePropsMetadata($component) as $propMetadata) {
             $frontendName = $propMetadata->calculateFieldName($component, $propMetadata->getName());
+
             if (!$dehydratedOriginalProps->hasPropValue($frontendName)) {
                 // this property was not sent, so skip
                 // even if this has writable paths, if no identity is sent,
@@ -255,11 +256,22 @@ public function hydrateValue(mixed $value, LivePropMetadata $propMetadata, objec
                 throw new \LogicException(sprintf('The LiveProp "%s" on component "%s" has "useSerializerForHydration: true", but the given serializer does not implement DenormalizerInterface.', $propMetadata->getName(), $parentObject::class));
             }
 
-            if (null === $propMetadata->getType()) {
+            if ($propMetadata->collectionValueType()) {
+                $builtInType = $propMetadata->collectionValueType()->getBuiltinType();
+                if (Type::BUILTIN_TYPE_OBJECT === $builtInType) {
+                    $type = $propMetadata->collectionValueType()->getClassName().'[]';
+                } else {
+                    $type = $builtInType.'[]';
+                }
+            } else {
+                $type = $propMetadata->getType();
+            }
+
+            if (null === $type) {
                 throw new \LogicException(sprintf('The "%s::%s" object should be hydrated with the Serializer, but no type could be guessed.', $parentObject::class, $propMetadata->getName()));
             }
 
-            return $this->serializer->denormalize($value, $propMetadata->getType(), 'json', $propMetadata->serializationContext());
+            return $this->serializer->denormalize($value, $type, 'json', $propMetadata->serializationContext());
         }
 
         if ($propMetadata->collectionValueType() && Type::BUILTIN_TYPE_OBJECT === $propMetadata->collectionValueType()->getBuiltinType()) {