symfony · fancyweb · Sep 19, 2019 · yceruto · Sep 30, 2019 · fancyweb
diff --git a/UPGRADE-4.4.md b/UPGRADE-4.4.md
@@ -89,6 +89,7 @@ Form
    reference date is deprecated.
  * Using `int` or `float` as data for the `NumberType` when the `input` option is set to `string` is deprecated.
  * Overriding the methods `FormIntegrationTestCase::setUp()`, `TypeTestCase::setUp()` and `TypeTestCase::tearDown()` without the `void` return-type is deprecated.
+ * The `ButtonBuilder::__construct()` method second argument should be an `EventDispatcherInterface` instance. The existing array `$options` argument has been moved to the third position.
 
 FrameworkBundle
 ---------------

@@ -11,6 +11,10 @@
 
 namespace Symfony\Component\Form;
 
+use Symfony\Component\EventDispatcher\LegacyEventDispatcherProxy;
+use Symfony\Component\Form\Event\PostSetDataEvent;
+use Symfony\Component\Form\Event\PostSubmitEvent;
+use Symfony\Component\Form\Event\PreSubmitEvent;
 use Symfony\Component\Form\Exception\AlreadySubmittedException;
 use Symfony\Component\Form\Exception\BadMethodCallException;
 
@@ -200,6 +204,11 @@ public function getErrors($deep = false, $flatten = true)
      */
     public function setData($modelData)
     {
+        $dispatcher = LegacyEventDispatcherProxy::decorate($this->config->getEventDispatcher());
+        if ($dispatcher->hasListeners(FormEvents::POST_SET_DATA)) {
+            $dispatcher->dispatch(new PostSetDataEvent($this, $modelData), FormEvents::POST_SET_DATA);
+        }
+
         // no-op, called during initialization of the form tree
         return $this;
     }
@@ -384,8 +393,17 @@ public function submit($submittedData, $clearMissing = true)
             throw new AlreadySubmittedException('A form can only be submitted once');
         }
 
+        $dispatcher = LegacyEventDispatcherProxy::decorate($this->config->getEventDispatcher());
+        if ($dispatcher->hasListeners(FormEvents::PRE_SUBMIT)) {
+            $dispatcher->dispatch(new PreSubmitEvent($this, $submittedData), FormEvents::PRE_SUBMIT);
+        }
+
         $this->submitted = true;
 
+        if ($dispatcher->hasListeners(FormEvents::POST_SUBMIT)) {
+            $dispatcher->dispatch(new PostSubmitEvent($this, $submittedData), FormEvents::POST_SUBMIT);
+        }
+
         return $this;
     }
 

@@ -11,7 +11,10 @@
 
 namespace Symfony\Component\Form;
 
+use Symfony\Component\EventDispatcher\EventDispatcher;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
 use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+use Symfony\Component\EventDispatcher\ImmutableEventDispatcher;
 use Symfony\Component\Form\Exception\BadMethodCallException;
 use Symfony\Component\Form\Exception\InvalidArgumentException;
 
@@ -22,6 +25,11 @@
  */
 class ButtonBuilder implements \IteratorAggregate, FormBuilderInterface
 {
+    private const UNSUPPORTED_FORM_EVENTS = [
+        FormEvents::PRE_SET_DATA => [FormEvents::POST_SET_DATA],
+        FormEvents::SUBMIT => [FormEvents::PRE_SUBMIT, FormEvents::POST_SUBMIT],
+    ];
+
     protected $locked = false;
 
     /**
@@ -49,16 +57,36 @@ class ButtonBuilder implements \IteratorAggregate, FormBuilderInterface
      */
     private $options;
 
+    private $dispatcher;
+
     /**
      * @throws InvalidArgumentException if the name is empty
      */
-    public function __construct(?string $name, array $options = [])
+    public function __construct(?string $name, /*EventDispatcherInterface*/ $dispatcher = null, array $options = [])
     {
+        if (\func_num_args() > 1) {
+            if (!$dispatcher instanceof EventDispatcherInterface) {
+                @trigger_error(sprintf('The "%s" method second argument must be an instance of "%s" since Symfony 4.4. The existing array "$options" argument has been moved to the third position.', __METHOD__, EventDispatcherInterface::class), E_USER_DEPRECATED);
+
+                if (!\is_array($dispatcher)) {
+                    throw new \TypeError(sprintf('The second argument passed to the "%s" method must be an instance of "%s", "%s" given.', __METHOD__, EventDispatcherInterface::class, \is_object($dispatcher) ? \get_class($dispatcher) : \gettype($dispatcher)));
+                }
+
+                $options = $dispatcher;
+                $dispatcher = new EventDispatcher();
+            }
+        } else {
+            @trigger_error(sprintf('The "%s" method requires an instance of "%s" as its second argument since Symfony 4.4.', __METHOD__, EventDispatcherInterface::class), E_USER_DEPRECATED);
+
+            $dispatcher = new EventDispatcher();
+        }
+
         if ('' === $name || null === $name) {
             throw new InvalidArgumentException('Buttons cannot have empty names.');
         }
 
         $this->name = $name;
+        $this->dispatcher = $dispatcher;
         $this->options = $options;
 
         if (preg_match('/^([^a-z0-9_].*)?(.*[^a-zA-Z0-9_\-:].*)?$/D', $name, $matches)) {
@@ -159,31 +187,45 @@ public function getForm()
     }
 
     /**
-     * Unsupported method.
-     *
-     * This method should not be invoked.
-     *
-     * @param string   $eventName
-     * @param callable $listener
-     * @param int      $priority
+     * {@inheritdoc}
      *
      * @throws BadMethodCallException
      */
     public function addEventListener($eventName, $listener, $priority = 0)
     {
-        throw new BadMethodCallException('Buttons do not support event listeners.');
+        if ($this->locked) {
+            throw new BadMethodCallException('ButtonBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
+        }
+
+        if (isset(self::UNSUPPORTED_FORM_EVENTS[$eventName])) {
+            throw new BadMethodCallException(sprintf('Buttons do not support the "%s" form event. Use "%s" instead.', $eventName, implode('" or "', self::UNSUPPORTED_FORM_EVENTS[$eventName])));
+        }
+
+        $this->dispatcher->addListener($eventName, $listener, $priority);
+
+        return $this;
     }
 
     /**
-     * Unsupported method.
-     *
-     * This method should not be invoked.
+     * {@inheritdoc}
      *
      * @throws BadMethodCallException
      */
     public function addEventSubscriber(EventSubscriberInterface $subscriber)
     {
-        throw new BadMethodCallException('Buttons do not support event subscribers.');
+        if ($this->locked) {
+            throw new BadMethodCallException('ButtonBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
+        }
+
+        foreach ($subscriber::getSubscribedEvents() as $eventName => $_) {
+            if (isset(self::UNSUPPORTED_FORM_EVENTS[$eventName])) {
+                throw new BadMethodCallException(sprintf('Buttons do not support the "%s" form event. Use "%s" instead.', $eventName, implode('" or "', self::UNSUPPORTED_FORM_EVENTS[$eventName])));
+            }
+        }
+
+        $this->dispatcher->addSubscriber($subscriber);
+
+        return $this;
     }
 
     /**
@@ -513,11 +555,15 @@ public function getFormConfig()
     }
 
     /**
-     * Unsupported method.
+     * {@inheritdoc}
      */
     public function getEventDispatcher()
     {
-        return null;
+        if ($this->locked && !$this->dispatcher instanceof ImmutableEventDispatcher) {
+            $this->dispatcher = new ImmutableEventDispatcher($this->dispatcher);
+        }
+
+        return $this->dispatcher;
     }
 
     /**

@@ -13,6 +13,8 @@ CHANGELOG
  * marked all dispatched event classes as `@final`
  * Added the `validate` option to `SubmitType` to toggle the browser built-in form validation.
  * Added the `alpha3` option to `LanguageType` and `CountryType` to use alpha3 instead of alpha2 codes
+ * The `ButtonBuilder::__construct()` method second argument should be an `EventDispatcherInterface` instance. The existing array `$options` argument has been moved to the third position.
+ * Added support for event listeners on buttons.
 
 4.3.0
 -----

@@ -206,11 +206,11 @@ public function getOptionsResolver()
     protected function newBuilder($name, $dataClass, FormFactoryInterface $factory, array $options)
     {
         if ($this->innerType instanceof ButtonTypeInterface) {
-            return new ButtonBuilder($name, $options);
+            return new ButtonBuilder($name, new EventDispatcher(), $options);
         }
 
         if ($this->innerType instanceof SubmitButtonTypeInterface) {
-            return new SubmitButtonBuilder($name, $options);
+            return new SubmitButtonBuilder($name, new EventDispatcher(), $options);
         }
 
         return new FormBuilder($name, $dataClass, new EventDispatcher(), $factory, $options);

@@ -12,8 +12,13 @@
 namespace Symfony\Component\Form\Tests;
 
 use PHPUnit\Framework\TestCase;
+use Symfony\Component\EventDispatcher\EventDispatcher;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+use Symfony\Component\EventDispatcher\ImmutableEventDispatcher;
 use Symfony\Component\Form\ButtonBuilder;
+use Symfony\Component\Form\Exception\BadMethodCallException;
 use Symfony\Component\Form\Exception\InvalidArgumentException;
+use Symfony\Component\Form\FormEvents;
 
 /**
  * @author Alexander Cheprasov <cheprasov.84@ya.ru>
@@ -36,15 +41,15 @@ public function getValidNames()
      */
     public function testValidNames($name)
     {
-        $this->assertInstanceOf('\Symfony\Component\Form\ButtonBuilder', new ButtonBuilder($name));
+        $this->assertInstanceOf('\Symfony\Component\Form\ButtonBuilder', new ButtonBuilder($name, new EventDispatcher()));
     }
 
     /**
      * @group legacy
      */
     public function testNameContainingIllegalCharacters()
     {
-        $this->assertInstanceOf('\Symfony\Component\Form\ButtonBuilder', new ButtonBuilder('button[]'));
+        $this->assertInstanceOf('\Symfony\Component\Form\ButtonBuilder', new ButtonBuilder('button[]', new EventDispatcher()));
     }
 
     /**
@@ -71,6 +76,106 @@ public function testInvalidNames($name)
     {
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Buttons cannot have empty names.');
-        new ButtonBuilder($name);
+        new ButtonBuilder($name, new EventDispatcher());
+    }
+
+    /**
+     * @dataProvider supportedEventsProvider
+     */
+    public function testSupportedEvents(string $event)
+    {
+        $buttonBuilder = new ButtonBuilder('foo', new EventDispatcher());
+
+        $buttonBuilder->addEventListener($event, ['class', 'method']);
+
+        $subscriber = new class() implements EventSubscriberInterface {
+            public static $event = 'foo';
+
+            /**
+             * {@inheritdoc}
+             */
+            public static function getSubscribedEvents(): array
+            {
+                return [
+                    self::$event => 'method',
+                ];
+            }
+        };
+        $subscriber::$event = $event;
+        $buttonBuilder->addEventSubscriber($subscriber);
+
+        $this->assertSame([
+            ['class', 'method'],
+            [$subscriber, 'method'],
+        ], $buttonBuilder->getEventDispatcher()->getListeners($event));
+    }
+
+    public function supportedEventsProvider()
+    {
+        return [
+            [FormEvents::POST_SET_DATA],
+            [FormEvents::PRE_SUBMIT],
+            [FormEvents::POST_SUBMIT],
+        ];
+    }
+
+    /**
+     * @dataProvider unsupportedEventsProvider
+     */
+    public function testUnsupportedEventsWithAListener(string $expectedMessage, string $event)
+    {
+        $this->expectException(BadMethodCallException::class);
+        $this->expectExceptionMessage($expectedMessage);
+
+        (new ButtonBuilder('foo', new EventDispatcher()))->addEventListener($event, []);
+    }
+
+    /**
+     * @dataProvider unsupportedEventsProvider
+     */
+    public function testUnsupportedEventsWithASubscriber(string $expectedMessage, string $event)
+    {
+        $this->expectException(BadMethodCallException::class);
+        $this->expectExceptionMessage($expectedMessage);
+
+        $subscriber = new class() implements EventSubscriberInterface {
+            public static $event = 'foo';
+
+            /**
+             * {@inheritdoc}
+             */
+            public static function getSubscribedEvents(): array
+            {
+                return [
+                    self::$event => 'method',
+                ];
+            }
+        };
+        $subscriber::$event = $event;
+
+        (new ButtonBuilder('foo', new EventDispatcher()))->addEventSubscriber($subscriber);
+    }
+
+    public function unsupportedEventsProvider()
+    {
+        return [
+            ['Buttons do not support the "form.pre_set_data" form event. Use "form.post_set_data" instead.', FormEvents::PRE_SET_DATA],
+            ['Buttons do not support the "form.submit" form event. Use "form.pre_submit" or "form.post_submit" instead.', FormEvents::SUBMIT],
+        ];
+    }
+
+    public function testGetEventDispatcher()
+    {
+        $eventDispatcher = new EventDispatcher();
+        $buttonBuilder = new ButtonBuilder('foo', $eventDispatcher);
+
+        $this->assertSame($eventDispatcher, $buttonBuilder->getEventDispatcher());
+
+        $eventDispatcher->addListener($event = 'foo.bar', $callable = function () {});
+
+        $immutableEventDispatcher = $buttonBuilder->getFormConfig()->getEventDispatcher();
+
+        $this->assertInstanceOf(ImmutableEventDispatcher::class, $immutableEventDispatcher);
+        $this->assertSame([$callable], $immutableEventDispatcher->getListeners($event));
     }
 }