vendor/symfony/form/Form.php line 765

Open in your IDE?
  1. <?php
  3. /*
  4. * This file is part of the Symfony package.
  5. *
  6. * (c) Fabien Potencier <fabien@symfony.com>
  7. *
  8. * For the full copyright and license information, please view the LICENSE
  9. * file that was distributed with this source code.
  10. */
  12. namespace Symfony\Component\Form;
  14. use Symfony\Component\Form\Event\PostSetDataEvent;
  15. use Symfony\Component\Form\Event\PostSubmitEvent;
  16. use Symfony\Component\Form\Event\PreSetDataEvent;
  17. use Symfony\Component\Form\Event\PreSubmitEvent;
  18. use Symfony\Component\Form\Event\SubmitEvent;
  19. use Symfony\Component\Form\Exception\AlreadySubmittedException;
  20. use Symfony\Component\Form\Exception\LogicException;
  21. use Symfony\Component\Form\Exception\OutOfBoundsException;
  22. use Symfony\Component\Form\Exception\RuntimeException;
  23. use Symfony\Component\Form\Exception\TransformationFailedException;
  24. use Symfony\Component\Form\Exception\UnexpectedTypeException;
  25. use Symfony\Component\Form\Extension\Core\Type\TextType;
  26. use Symfony\Component\Form\Util\FormUtil;
  27. use Symfony\Component\Form\Util\InheritDataAwareIterator;
  28. use Symfony\Component\Form\Util\OrderedHashMap;
  29. use Symfony\Component\PropertyAccess\PropertyPath;
  30. use Symfony\Component\PropertyAccess\PropertyPathInterface;
  32. /**
  33. * Form represents a form.
  34. *
  35. * To implement your own form fields, you need to have a thorough understanding
  36. * of the data flow within a form. A form stores its data in three different
  37. * representations:
  38. *
  39. * (1) the "model" format required by the form's object
  40. * (2) the "normalized" format for internal processing
  41. * (3) the "view" format used for display simple fields
  42. * or map children model data for compound fields
  43. *
  44. * A date field, for example, may store a date as "Y-m-d" string (1) in the
  45. * object. To facilitate processing in the field, this value is normalized
  46. * to a DateTime object (2). In the HTML representation of your form, a
  47. * localized string (3) may be presented to and modified by the user, or it could be an array of values
  48. * to be mapped to choices fields.
  49. *
  50. * In most cases, format (1) and format (2) will be the same. For example,
  51. * a checkbox field uses a Boolean value for both internal processing and
  52. * storage in the object. In these cases you need to set a view transformer
  53. * to convert between formats (2) and (3). You can do this by calling
  54. * addViewTransformer().
  55. *
  56. * In some cases though it makes sense to make format (1) configurable. To
  57. * demonstrate this, let's extend our above date field to store the value
  58. * either as "Y-m-d" string or as timestamp. Internally we still want to
  59. * use a DateTime object for processing. To convert the data from string/integer
  60. * to DateTime you can set a model transformer by calling
  61. * addModelTransformer(). The normalized data is then converted to the displayed
  62. * data as described before.
  63. *
  64. * The conversions (1) -> (2) -> (3) use the transform methods of the transformers.
  65. * The conversions (3) -> (2) -> (1) use the reverseTransform methods of the transformers.
  66. *
  67. * @author Fabien Potencier <fabien@symfony.com>
  68. * @author Bernhard Schussek <bschussek@gmail.com>
  69. *
  70. * @implements \IteratorAggregate<string, FormInterface>
  71. */
  72. class Form implements \IteratorAggregate, FormInterface, ClearableErrorsInterface
  73. {
  74. /**
  75. * @var FormConfigInterface
  76. */
  77. private $config;
  79. /**
  80. * @var FormInterface|null
  81. */
  82. private $parent;
  84. /**
  85. * A map of FormInterface instances.
  86. *
  87. * @var OrderedHashMap<string, FormInterface>
  88. */
  89. private $children;
  91. /**
  92. * @var FormError[]
  93. */
  94. private $errors = [];
  96. /**
  97. * @var bool
  98. */
  99. private $submitted = false;
  101. /**
  102. * The button that was used to submit the form.
  103. *
  104. * @var FormInterface|ClickableInterface|null
  105. */
  106. private $clickedButton;
  108. /**
  109. * @var mixed
  110. */
  111. private $modelData;
  113. /**
  114. * @var mixed
  115. */
  116. private $normData;
  118. /**
  119. * @var mixed
  120. */
  121. private $viewData;
  123. /**
  124. * The submitted values that don't belong to any children.
  125. *
  126. * @var array
  127. */
  128. private $extraData = [];
  130. /**
  131. * The transformation failure generated during submission, if any.
  132. *
  133. * @var TransformationFailedException|null
  134. */
  135. private $transformationFailure;
  137. /**
  138. * Whether the form's data has been initialized.
  139. *
  140. * When the data is initialized with its default value, that default value
  141. * is passed through the transformer chain in order to synchronize the
  142. * model, normalized and view format for the first time. This is done
  143. * lazily in order to save performance when {@link setData()} is called
  144. * manually, making the initialization with the configured default value
  145. * superfluous.
  146. *
  147. * @var bool
  148. */
  149. private $defaultDataSet = false;
  151. /**
  152. * Whether setData() is currently being called.
  153. *
  154. * @var bool
  155. */
  156. private $lockSetData = false;
  158. /**
  159. * @var string
  160. */
  161. private $name = '';
  163. /**
  164. * Whether the form inherits its underlying data from its parent.
  165. *
  166. * @var bool
  167. */
  168. private $inheritData;
  170. /**
  171. * @var PropertyPathInterface|null
  172. */
  173. private $propertyPath;
  175. /**
  176. * @throws LogicException if a data mapper is not provided for a compound form
  177. */
  178. public function __construct(FormConfigInterface $config)
  179. {
  180. // Compound forms always need a data mapper, otherwise calls to
  181. // `setData` and `add` will not lead to the correct population of
  182. // the child forms.
  183. if ($config->getCompound() && !$config->getDataMapper()) {
  184. throw new LogicException('Compound forms need a data mapper.');
  185. }
  187. // If the form inherits the data from its parent, it is not necessary
  188. // to call setData() with the default data.
  189. if ($this->inheritData = $config->getInheritData()) {
  190. $this->defaultDataSet = true;
  191. }
  193. $this->config = $config;
  194. $this->children = new OrderedHashMap();
  195. $this->name = $config->getName();
  196. }
  198. public function __clone()
  199. {
  200. $this->children = clone $this->children;
  202. foreach ($this->children as $key => $child) {
  203. $this->children[$key] = clone $child;
  204. }
  205. }
  207. /**
  208. * {@inheritdoc}
  209. */
  210. public function getConfig()
  211. {
  212. return $this->config;
  213. }
  215. /**
  216. * {@inheritdoc}
  217. */
  218. public function getName()
  219. {
  220. return $this->name;
  221. }
  223. /**
  224. * {@inheritdoc}
  225. */
  226. public function getPropertyPath()
  227. {
  228. if ($this->propertyPath || $this->propertyPath = $this->config->getPropertyPath()) {
  229. return $this->propertyPath;
  230. }
  232. if ('' === $this->name) {
  233. return null;
  234. }
  236. $parent = $this->parent;
  238. while ($parent && $parent->getConfig()->getInheritData()) {
  239. $parent = $parent->getParent();
  240. }
  242. if ($parent && null === $parent->getConfig()->getDataClass()) {
  243. $this->propertyPath = new PropertyPath('['.$this->name.']');
  244. } else {
  245. $this->propertyPath = new PropertyPath($this->name);
  246. }
  248. return $this->propertyPath;
  249. }
  251. /**
  252. * {@inheritdoc}
  253. */
  254. public function isRequired()
  255. {
  256. if (null === $this->parent || $this->parent->isRequired()) {
  257. return $this->config->getRequired();
  258. }
  260. return false;
  261. }
  263. /**
  264. * {@inheritdoc}
  265. */
  266. public function isDisabled()
  267. {
  268. if (null === $this->parent || !$this->parent->isDisabled()) {
  269. return $this->config->getDisabled();
  270. }
  272. return true;
  273. }
  275. /**
  276. * {@inheritdoc}
  277. */
  278. public function setParent(?FormInterface $parent = null)
  279. {
  280. if ($this->submitted) {
  281. throw new AlreadySubmittedException('You cannot set the parent of a submitted form.');
  282. }
  284. if (null !== $parent && '' === $this->name) {
  285. throw new LogicException('A form with an empty name cannot have a parent form.');
  286. }
  288. $this->parent = $parent;
  290. return $this;
  291. }
  293. /**
  294. * {@inheritdoc}
  295. */
  296. public function getParent()
  297. {
  298. return $this->parent;
  299. }
  301. /**
  302. * {@inheritdoc}
  303. */
  304. public function getRoot()
  305. {
  306. return $this->parent ? $this->parent->getRoot() : $this;
  307. }
  309. /**
  310. * {@inheritdoc}
  311. */
  312. public function isRoot()
  313. {
  314. return null === $this->parent;
  315. }
  317. /**
  318. * {@inheritdoc}
  319. */
  320. public function setData($modelData)
  321. {
  322. // If the form is submitted while disabled, it is set to submitted, but the data is not
  323. // changed. In such cases (i.e. when the form is not initialized yet) don't
  324. // abort this method.
  325. if ($this->submitted && $this->defaultDataSet) {
  326. throw new AlreadySubmittedException('You cannot change the data of a submitted form.');
  327. }
  329. // If the form inherits its parent's data, disallow data setting to
  330. // prevent merge conflicts
  331. if ($this->inheritData) {
  332. throw new RuntimeException('You cannot change the data of a form inheriting its parent data.');
  333. }
  335. // Don't allow modifications of the configured data if the data is locked
  336. if ($this->config->getDataLocked() && $modelData !== $this->config->getData()) {
  337. return $this;
  338. }
  340. if (\is_object($modelData) && !$this->config->getByReference()) {
  341. $modelData = clone $modelData;
  342. }
  344. if ($this->lockSetData) {
  345. throw new RuntimeException('A cycle was detected. Listeners to the PRE_SET_DATA event must not call setData(). You should call setData() on the FormEvent object instead.');
  346. }
  348. $this->lockSetData = true;
  349. $dispatcher = $this->config->getEventDispatcher();
  351. // Hook to change content of the model data before transformation and mapping children
  352. if ($dispatcher->hasListeners(FormEvents::PRE_SET_DATA)) {
  353. $event = new PreSetDataEvent($this, $modelData);
  354. $dispatcher->dispatch($event, FormEvents::PRE_SET_DATA);
  355. $modelData = $event->getData();
  356. }
  358. // Treat data as strings unless a transformer exists
  359. if (\is_scalar($modelData) && !$this->config->getViewTransformers() && !$this->config->getModelTransformers()) {
  360. $modelData = (string) $modelData;
  361. }
  363. // Synchronize representations - must not change the content!
  364. // Transformation exceptions are not caught on initialization
  365. $normData = $this->modelToNorm($modelData);
  366. $viewData = $this->normToView($normData);
  368. // Validate if view data matches data class (unless empty)
  369. if (!FormUtil::isEmpty($viewData)) {
  370. $dataClass = $this->config->getDataClass();
  372. if (null !== $dataClass && !$viewData instanceof $dataClass) {
  373. $actualType = get_debug_type($viewData);
  375. throw new LogicException('The form\'s view data is expected to be a "'.$dataClass.'", but it is a "'.$actualType.'". You can avoid this error by setting the "data_class" option to null or by adding a view transformer that transforms "'.$actualType.'" to an instance of "'.$dataClass.'".');
  376. }
  377. }
  379. $this->modelData = $modelData;
  380. $this->normData = $normData;
  381. $this->viewData = $viewData;
  382. $this->defaultDataSet = true;
  383. $this->lockSetData = false;
  385. // Compound forms don't need to invoke this method if they don't have children
  386. if (\count($this->children) > 0) {
  387. // Update child forms from the data (unless their config data is locked)
  388. $this->config->getDataMapper()->mapDataToForms($viewData, new \RecursiveIteratorIterator(new InheritDataAwareIterator($this->children)));
  389. }
  391. if ($dispatcher->hasListeners(FormEvents::POST_SET_DATA)) {
  392. $event = new PostSetDataEvent($this, $modelData);
  393. $dispatcher->dispatch($event, FormEvents::POST_SET_DATA);
  394. }
  396. return $this;
  397. }
  399. /**
  400. * {@inheritdoc}
  401. */
  402. public function getData()
  403. {
  404. if ($this->inheritData) {
  405. if (!$this->parent) {
  406. throw new RuntimeException('The form is configured to inherit its parent\'s data, but does not have a parent.');
  407. }
  409. return $this->parent->getData();
  410. }
  412. if (!$this->defaultDataSet) {
  413. if ($this->lockSetData) {
  414. throw new RuntimeException('A cycle was detected. Listeners to the PRE_SET_DATA event must not call getData() if the form data has not already been set. You should call getData() on the FormEvent object instead.');
  415. }
  417. $this->setData($this->config->getData());
  418. }
  420. return $this->modelData;
  421. }
  423. /**
  424. * {@inheritdoc}
  425. */
  426. public function getNormData()
  427. {
  428. if ($this->inheritData) {
  429. if (!$this->parent) {
  430. throw new RuntimeException('The form is configured to inherit its parent\'s data, but does not have a parent.');
  431. }
  433. return $this->parent->getNormData();
  434. }
  436. if (!$this->defaultDataSet) {
  437. if ($this->lockSetData) {
  438. throw new RuntimeException('A cycle was detected. Listeners to the PRE_SET_DATA event must not call getNormData() if the form data has not already been set.');
  439. }
  441. $this->setData($this->config->getData());
  442. }
  444. return $this->normData;
  445. }
  447. /**
  448. * {@inheritdoc}
  449. */
  450. public function getViewData()
  451. {
  452. if ($this->inheritData) {
  453. if (!$this->parent) {
  454. throw new RuntimeException('The form is configured to inherit its parent\'s data, but does not have a parent.');
  455. }
  457. return $this->parent->getViewData();
  458. }
  460. if (!$this->defaultDataSet) {
  461. if ($this->lockSetData) {
  462. throw new RuntimeException('A cycle was detected. Listeners to the PRE_SET_DATA event must not call getViewData() if the form data has not already been set.');
  463. }
  465. $this->setData($this->config->getData());
  466. }
  468. return $this->viewData;
  469. }
  471. /**
  472. * {@inheritdoc}
  473. */
  474. public function getExtraData()
  475. {
  476. return $this->extraData;
  477. }
  479. /**
  480. * {@inheritdoc}
  481. */
  482. public function initialize()
  483. {
  484. if (null !== $this->parent) {
  485. throw new RuntimeException('Only root forms should be initialized.');
  486. }
  488. // Guarantee that the *_SET_DATA events have been triggered once the
  489. // form is initialized. This makes sure that dynamically added or
  490. // removed fields are already visible after initialization.
  491. if (!$this->defaultDataSet) {
  492. $this->setData($this->config->getData());
  493. }
  495. return $this;
  496. }
  498. /**
  499. * {@inheritdoc}
  500. */
  501. public function handleRequest($request = null)
  502. {
  503. $this->config->getRequestHandler()->handleRequest($this, $request);
  505. return $this;
  506. }
  508. /**
  509. * {@inheritdoc}
  510. */
  511. public function submit($submittedData, bool $clearMissing = true)
  512. {
  513. if ($this->submitted) {
  514. throw new AlreadySubmittedException('A form can only be submitted once.');
  515. }
  517. // Initialize errors in the very beginning so we're sure
  518. // they are collectable during submission only
  519. $this->errors = [];
  521. // Obviously, a disabled form should not change its data upon submission.
  522. if ($this->isDisabled()) {
  523. $this->submitted = true;
  525. return $this;
  526. }
  528. // The data must be initialized if it was not initialized yet.
  529. // This is necessary to guarantee that the *_SET_DATA listeners
  530. // are always invoked before submit() takes place.
  531. if (!$this->defaultDataSet) {
  532. $this->setData($this->config->getData());
  533. }
  535. // Treat false as NULL to support binding false to checkboxes.
  536. // Don't convert NULL to a string here in order to determine later
  537. // whether an empty value has been submitted or whether no value has
  538. // been submitted at all. This is important for processing checkboxes
  539. // and radio buttons with empty values.
  540. if (false === $submittedData) {
  541. $submittedData = null;
  542. } elseif (\is_scalar($submittedData)) {
  543. $submittedData = (string) $submittedData;
  544. } elseif ($this->config->getRequestHandler()->isFileUpload($submittedData)) {
  545. if (!$this->config->getOption('allow_file_upload')) {
  546. $submittedData = null;
  547. $this->transformationFailure = new TransformationFailedException('Submitted data was expected to be text or number, file upload given.');
  548. }
  549. } elseif (\is_array($submittedData) && !$this->config->getCompound() && !$this->config->getOption('multiple', false)) {
  550. $submittedData = null;
  551. $this->transformationFailure = new TransformationFailedException('Submitted data was expected to be text or number, array given.');
  552. }
  554. $dispatcher = $this->config->getEventDispatcher();
  556. $modelData = null;
  557. $normData = null;
  558. $viewData = null;
  560. try {
  561. if (null !== $this->transformationFailure) {
  562. throw $this->transformationFailure;
  563. }
  565. // Hook to change content of the data submitted by the browser
  566. if ($dispatcher->hasListeners(FormEvents::PRE_SUBMIT)) {
  567. $event = new PreSubmitEvent($this, $submittedData);
  568. $dispatcher->dispatch($event, FormEvents::PRE_SUBMIT);
  569. $submittedData = $event->getData();
  570. }
  572. // Check whether the form is compound.
  573. // This check is preferable over checking the number of children,
  574. // since forms without children may also be compound.
  575. // (think of empty collection forms)
  576. if ($this->config->getCompound()) {
  577. if (null === $submittedData) {
  578. $submittedData = [];
  579. }
  581. if (!\is_array($submittedData)) {
  582. throw new TransformationFailedException('Compound forms expect an array or NULL on submission.');
  583. }
  585. foreach ($this->children as $name => $child) {
  586. $isSubmitted = \array_key_exists($name, $submittedData);
  588. if ($isSubmitted || $clearMissing) {
  589. $child->submit($isSubmitted ? $submittedData[$name] : null, $clearMissing);
  590. unset($submittedData[$name]);
  592. if (null !== $this->clickedButton) {
  593. continue;
  594. }
  596. if ($child instanceof ClickableInterface && $child->isClicked()) {
  597. $this->clickedButton = $child;
  599. continue;
  600. }
  602. if (method_exists($child, 'getClickedButton') && null !== $child->getClickedButton()) {
  603. $this->clickedButton = $child->getClickedButton();
  604. }
  605. }
  606. }
  608. $this->extraData = $submittedData;
  609. }
  611. // Forms that inherit their parents' data also are not processed,
  612. // because then it would be too difficult to merge the changes in
  613. // the child and the parent form. Instead, the parent form also takes
  614. // changes in the grandchildren (i.e. children of the form that inherits
  615. // its parent's data) into account.
  616. // (see InheritDataAwareIterator below)
  617. if (!$this->inheritData) {
  618. // If the form is compound, the view data is merged with the data
  619. // of the children using the data mapper.
  620. // If the form is not compound, the view data is assigned to the submitted data.
  621. $viewData = $this->config->getCompound() ? $this->viewData : $submittedData;
  623. if (FormUtil::isEmpty($viewData)) {
  624. $emptyData = $this->config->getEmptyData();
  626. if ($emptyData instanceof \Closure) {
  627. $emptyData = $emptyData($this, $viewData);
  628. }
  630. $viewData = $emptyData;
  631. }
  633. // Merge form data from children into existing view data
  634. // It is not necessary to invoke this method if the form has no children,
  635. // even if it is compound.
  636. if (\count($this->children) > 0) {
  637. // Use InheritDataAwareIterator to process children of
  638. // descendants that inherit this form's data.
  639. // These descendants will not be submitted normally (see the check
  640. // for $this->config->getInheritData() above)
  641. $this->config->getDataMapper()->mapFormsToData(
  642. new \RecursiveIteratorIterator(new InheritDataAwareIterator($this->children)),
  643. $viewData
  644. );
  645. }
  647. // Normalize data to unified representation
  648. $normData = $this->viewToNorm($viewData);
  650. // Hook to change content of the data in the normalized
  651. // representation
  652. if ($dispatcher->hasListeners(FormEvents::SUBMIT)) {
  653. $event = new SubmitEvent($this, $normData);
  654. $dispatcher->dispatch($event, FormEvents::SUBMIT);
  655. $normData = $event->getData();
  656. }
  658. // Synchronize representations - must not change the content!
  659. $modelData = $this->normToModel($normData);
  660. $viewData = $this->normToView($normData);
  661. }
  662. } catch (TransformationFailedException $e) {
  663. $this->transformationFailure = $e;
  665. // If $viewData was not yet set, set it to $submittedData so that
  666. // the erroneous data is accessible on the form.
  667. // Forms that inherit data never set any data, because the getters
  668. // forward to the parent form's getters anyway.
  669. if (null === $viewData && !$this->inheritData) {
  670. $viewData = $submittedData;
  671. }
  672. }
  674. $this->submitted = true;
  675. $this->modelData = $modelData;
  676. $this->normData = $normData;
  677. $this->viewData = $viewData;
  679. if ($dispatcher->hasListeners(FormEvents::POST_SUBMIT)) {
  680. $event = new PostSubmitEvent($this, $viewData);
  681. $dispatcher->dispatch($event, FormEvents::POST_SUBMIT);
  682. }
  684. return $this;
  685. }
  687. /**
  688. * {@inheritdoc}
  689. */
  690. public function addError(FormError $error)
  691. {
  692. if (null === $error->getOrigin()) {
  693. $error->setOrigin($this);
  694. }
  696. if ($this->parent && $this->config->getErrorBubbling()) {
  697. $this->parent->addError($error);
  698. } else {
  699. $this->errors[] = $error;
  700. }
  702. return $this;
  703. }
  705. /**
  706. * {@inheritdoc}
  707. */
  708. public function isSubmitted()
  709. {
  710. return $this->submitted;
  711. }
  713. /**
  714. * {@inheritdoc}
  715. */
  716. public function isSynchronized()
  717. {
  718. return null === $this->transformationFailure;
  719. }
  721. /**
  722. * {@inheritdoc}
  723. */
  724. public function getTransformationFailure()
  725. {
  726. return $this->transformationFailure;
  727. }
  729. /**
  730. * {@inheritdoc}
  731. */
  732. public function isEmpty()
  733. {
  734. foreach ($this->children as $child) {
  735. if (!$child->isEmpty()) {
  736. return false;
  737. }
  738. }
  740. if (!method_exists($this->config, 'getIsEmptyCallback')) {
  741. trigger_deprecation('symfony/form', '5.1', 'Not implementing the "%s::getIsEmptyCallback()" method in "%s" is deprecated.', FormConfigInterface::class, \get_class($this->config));
  743. $isEmptyCallback = null;
  744. } else {
  745. $isEmptyCallback = $this->config->getIsEmptyCallback();
  746. }
  748. if (null !== $isEmptyCallback) {
  749. return $isEmptyCallback($this->modelData);
  750. }
  752. return FormUtil::isEmpty($this->modelData) ||
  753. // arrays, countables
  754. ((\is_array($this->modelData) || $this->modelData instanceof \Countable) && 0 === \count($this->modelData)) ||
  755. // traversables that are not countable
  756. ($this->modelData instanceof \Traversable && 0 === iterator_count($this->modelData));
  757. }
  759. /**
  760. * {@inheritdoc}
  761. */
  762. public function isValid()
  763. {
  764. if (!$this->submitted) {
  765. throw new LogicException('Cannot check if an unsubmitted form is valid. Call Form::isSubmitted() before Form::isValid().');
  766. }
  768. if ($this->isDisabled()) {
  769. return true;
  770. }
  772. return 0 === \count($this->getErrors(true));
  773. }
  775. /**
  776. * Returns the button that was used to submit the form.
  777. *
  778. * @return FormInterface|ClickableInterface|null
  779. */
  780. public function getClickedButton()
  781. {
  782. if ($this->clickedButton) {
  783. return $this->clickedButton;
  784. }
  786. return $this->parent && method_exists($this->parent, 'getClickedButton') ? $this->parent->getClickedButton() : null;
  787. }
  789. /**
  790. * {@inheritdoc}
  791. */
  792. public function getErrors(bool $deep = false, bool $flatten = true)
  793. {
  794. $errors = $this->errors;
  796. // Copy the errors of nested forms to the $errors array
  797. if ($deep) {
  798. foreach ($this as $child) {
  799. /** @var FormInterface $child */
  800. if ($child->isSubmitted() && $child->isValid()) {
  801. continue;
  802. }
  804. $iterator = $child->getErrors(true, $flatten);
  806. if (0 === \count($iterator)) {
  807. continue;
  808. }
  810. if ($flatten) {
  811. foreach ($iterator as $error) {
  812. $errors[] = $error;
  813. }
  814. } else {
  815. $errors[] = $iterator;
  816. }
  817. }
  818. }
  820. return new FormErrorIterator($this, $errors);
  821. }
  823. /**
  824. * {@inheritdoc}
  825. */
  826. public function clearErrors(bool $deep = false): self
  827. {
  828. $this->errors = [];
  830. if ($deep) {
  831. // Clear errors from children
  832. foreach ($this as $child) {
  833. if ($child instanceof ClearableErrorsInterface) {
  834. $child->clearErrors(true);
  835. }
  836. }
  837. }
  839. return $this;
  840. }
  842. /**
  843. * {@inheritdoc}
  844. */
  845. public function all()
  846. {
  847. return iterator_to_array($this->children);
  848. }
  850. /**
  851. * {@inheritdoc}
  852. */
  853. public function add($child, ?string $type = null, array $options = [])
  854. {
  855. if ($this->submitted) {
  856. throw new AlreadySubmittedException('You cannot add children to a submitted form.');
  857. }
  859. if (!$this->config->getCompound()) {
  860. throw new LogicException('You cannot add children to a simple form. Maybe you should set the option "compound" to true?');
  861. }
  863. if (!$child instanceof FormInterface) {
  864. if (!\is_string($child) && !\is_int($child)) {
  865. throw new UnexpectedTypeException($child, 'string or Symfony\Component\Form\FormInterface');
  866. }
  868. $child = (string) $child;
  870. if (null !== $type && !\is_string($type)) {
  871. throw new UnexpectedTypeException($type, 'string or null');
  872. }
  874. // Never initialize child forms automatically
  875. $options['auto_initialize'] = false;
  877. if (null === $type && null === $this->config->getDataClass()) {
  878. $type = TextType::class;
  879. }
  881. if (null === $type) {
  882. $child = $this->config->getFormFactory()->createForProperty($this->config->getDataClass(), $child, null, $options);
  883. } else {
  884. $child = $this->config->getFormFactory()->createNamed($child, $type, null, $options);
  885. }
  886. } elseif ($child->getConfig()->getAutoInitialize()) {
  887. throw new RuntimeException(sprintf('Automatic initialization is only supported on root forms. You should set the "auto_initialize" option to false on the field "%s".', $child->getName()));
  888. }
  890. $this->children[$child->getName()] = $child;
  892. $child->setParent($this);
  894. // If setData() is currently being called, there is no need to call
  895. // mapDataToForms() here, as mapDataToForms() is called at the end
  896. // of setData() anyway. Not doing this check leads to an endless
  897. // recursion when initializing the form lazily and an event listener
  898. // (such as ResizeFormListener) adds fields depending on the data:
  899. //
  900. // * setData() is called, the form is not initialized yet
  901. // * add() is called by the listener (setData() is not complete, so
  902. // the form is still not initialized)
  903. // * getViewData() is called
  904. // * setData() is called since the form is not initialized yet
  905. // * ... endless recursion ...
  906. //
  907. // Also skip data mapping if setData() has not been called yet.
  908. // setData() will be called upon form initialization and data mapping
  909. // will take place by then.
  910. if (!$this->lockSetData && $this->defaultDataSet && !$this->inheritData) {
  911. $viewData = $this->getViewData();
  912. $this->config->getDataMapper()->mapDataToForms(
  913. $viewData,
  914. new \RecursiveIteratorIterator(new InheritDataAwareIterator(new \ArrayIterator([$child->getName() => $child])))
  915. );
  916. }
  918. return $this;
  919. }
  921. /**
  922. * {@inheritdoc}
  923. */
  924. public function remove(string $name)
  925. {
  926. if ($this->submitted) {
  927. throw new AlreadySubmittedException('You cannot remove children from a submitted form.');
  928. }
  930. if (isset($this->children[$name])) {
  931. if (!$this->children[$name]->isSubmitted()) {
  932. $this->children[$name]->setParent(null);
  933. }
  935. unset($this->children[$name]);
  936. }
  938. return $this;
  939. }
  941. /**
  942. * {@inheritdoc}
  943. */
  944. public function has(string $name)
  945. {
  946. return isset($this->children[$name]);
  947. }
  949. /**
  950. * {@inheritdoc}
  951. */
  952. public function get(string $name)
  953. {
  954. if (isset($this->children[$name])) {
  955. return $this->children[$name];
  956. }
  958. throw new OutOfBoundsException(sprintf('Child "%s" does not exist.', $name));
  959. }
  961. /**
  962. * Returns whether a child with the given name exists (implements the \ArrayAccess interface).
  963. *
  964. * @param string $name The name of the child
  965. *
  966. * @return bool
  967. */
  968. #[\ReturnTypeWillChange]
  969. public function offsetExists($name)
  970. {
  971. return $this->has($name);
  972. }
  974. /**
  975. * Returns the child with the given name (implements the \ArrayAccess interface).
  976. *
  977. * @param string $name The name of the child
  978. *
  979. * @return FormInterface
  980. *
  981. * @throws OutOfBoundsException if the named child does not exist
  982. */
  983. #[\ReturnTypeWillChange]
  984. public function offsetGet($name)
  985. {
  986. return $this->get($name);
  987. }
  989. /**
  990. * Adds a child to the form (implements the \ArrayAccess interface).
  991. *
  992. * @param string $name Ignored. The name of the child is used
  993. * @param FormInterface $child The child to be added
  994. *
  995. * @return void
  996. *
  997. * @throws AlreadySubmittedException if the form has already been submitted
  998. * @throws LogicException when trying to add a child to a non-compound form
  999. *
  1000. * @see self::add()
  1001. */
  1002. #[\ReturnTypeWillChange]
  1003. public function offsetSet($name, $child)
  1004. {
  1005. $this->add($child);
  1006. }
  1008. /**
  1009. * Removes the child with the given name from the form (implements the \ArrayAccess interface).
  1010. *
  1011. * @param string $name The name of the child to remove
  1012. *
  1013. * @return void
  1014. *
  1015. * @throws AlreadySubmittedException if the form has already been submitted
  1016. */
  1017. #[\ReturnTypeWillChange]
  1018. public function offsetUnset($name)
  1019. {
  1020. $this->remove($name);
  1021. }
  1023. /**
  1024. * Returns the iterator for this group.
  1025. *
  1026. * @return \Traversable<string, FormInterface>
  1027. */
  1028. #[\ReturnTypeWillChange]
  1029. public function getIterator()
  1030. {
  1031. return $this->children;
  1032. }
  1034. /**
  1035. * Returns the number of form children (implements the \Countable interface).
  1036. *
  1037. * @return int
  1038. */
  1039. #[\ReturnTypeWillChange]
  1040. public function count()
  1041. {
  1042. return \count($this->children);
  1043. }
  1045. /**
  1046. * {@inheritdoc}
  1047. */
  1048. public function createView(?FormView $parent = null)
  1049. {
  1050. if (null === $parent && $this->parent) {
  1051. $parent = $this->parent->createView();
  1052. }
  1054. $type = $this->config->getType();
  1055. $options = $this->config->getOptions();
  1057. // The methods createView(), buildView() and finishView() are called
  1058. // explicitly here in order to be able to override either of them
  1059. // in a custom resolved form type.
  1060. $view = $type->createView($this, $parent);
  1062. $type->buildView($view, $this, $options);
  1064. foreach ($this->children as $name => $child) {
  1065. $view->children[$name] = $child->createView($view);
  1066. }
  1068. $this->sort($view->children);
  1070. $type->finishView($view, $this, $options);
  1072. return $view;
  1073. }
  1075. /**
  1076. * Sorts view fields based on their priority value.
  1077. */
  1078. private function sort(array &$children): void
  1079. {
  1080. $c = [];
  1081. $i = 0;
  1082. $needsSorting = false;
  1083. foreach ($children as $name => $child) {
  1084. $c[$name] = ['p' => $child->vars['priority'] ?? 0, 'i' => $i++];
  1086. if (0 !== $c[$name]['p']) {
  1087. $needsSorting = true;
  1088. }
  1089. }
  1091. if (!$needsSorting) {
  1092. return;
  1093. }
  1095. uksort($children, static function ($a, $b) use ($c): int {
  1096. return [$c[$b]['p'], $c[$a]['i']] <=> [$c[$a]['p'], $c[$b]['i']];
  1097. });
  1098. }
  1100. /**
  1101. * Normalizes the underlying data if a model transformer is set.
  1102. *
  1103. * @return mixed
  1104. *
  1105. * @throws TransformationFailedException If the underlying data cannot be transformed to "normalized" format
  1106. */
  1107. private function modelToNorm($value)
  1108. {
  1109. try {
  1110. foreach ($this->config->getModelTransformers() as $transformer) {
  1111. $value = $transformer->transform($value);
  1112. }
  1113. } catch (TransformationFailedException $exception) {
  1114. throw new TransformationFailedException(sprintf('Unable to transform data for property path "%s": ', $this->getPropertyPath()).$exception->getMessage(), $exception->getCode(), $exception, $exception->getInvalidMessage(), $exception->getInvalidMessageParameters());
  1115. }
  1117. return $value;
  1118. }
  1120. /**
  1121. * Reverse transforms a value if a model transformer is set.
  1122. *
  1123. * @return mixed
  1124. *
  1125. * @throws TransformationFailedException If the value cannot be transformed to "model" format
  1126. */
  1127. private function normToModel($value)
  1128. {
  1129. try {
  1130. $transformers = $this->config->getModelTransformers();
  1132. for ($i = \count($transformers) - 1; $i >= 0; --$i) {
  1133. $value = $transformers[$i]->reverseTransform($value);
  1134. }
  1135. } catch (TransformationFailedException $exception) {
  1136. throw new TransformationFailedException(sprintf('Unable to reverse value for property path "%s": ', $this->getPropertyPath()).$exception->getMessage(), $exception->getCode(), $exception, $exception->getInvalidMessage(), $exception->getInvalidMessageParameters());
  1137. }
  1139. return $value;
  1140. }
  1142. /**
  1143. * Transforms the value if a view transformer is set.
  1144. *
  1145. * @return mixed
  1146. *
  1147. * @throws TransformationFailedException If the normalized value cannot be transformed to "view" format
  1148. */
  1149. private function normToView($value)
  1150. {
  1151. // Scalar values should be converted to strings to
  1152. // facilitate differentiation between empty ("") and zero (0).
  1153. // Only do this for simple forms, as the resulting value in
  1154. // compound forms is passed to the data mapper and thus should
  1155. // not be converted to a string before.
  1156. if (!($transformers = $this->config->getViewTransformers()) && !$this->config->getCompound()) {
  1157. return null === $value || \is_scalar($value) ? (string) $value : $value;
  1158. }
  1160. try {
  1161. foreach ($transformers as $transformer) {
  1162. $value = $transformer->transform($value);
  1163. }
  1164. } catch (TransformationFailedException $exception) {
  1165. throw new TransformationFailedException(sprintf('Unable to transform value for property path "%s": ', $this->getPropertyPath()).$exception->getMessage(), $exception->getCode(), $exception, $exception->getInvalidMessage(), $exception->getInvalidMessageParameters());
  1166. }
  1168. return $value;
  1169. }
  1171. /**
  1172. * Reverse transforms a value if a view transformer is set.
  1173. *
  1174. * @return mixed
  1175. *
  1176. * @throws TransformationFailedException If the submitted value cannot be transformed to "normalized" format
  1177. */
  1178. private function viewToNorm($value)
  1179. {
  1180. if (!$transformers = $this->config->getViewTransformers()) {
  1181. return '' === $value ? null : $value;
  1182. }
  1184. try {
  1185. for ($i = \count($transformers) - 1; $i >= 0; --$i) {
  1186. $value = $transformers[$i]->reverseTransform($value);
  1187. }
  1188. } catch (TransformationFailedException $exception) {
  1189. throw new TransformationFailedException(sprintf('Unable to reverse value for property path "%s": ', $this->getPropertyPath()).$exception->getMessage(), $exception->getCode(), $exception, $exception->getInvalidMessage(), $exception->getInvalidMessageParameters());
  1190. }
  1192. return $value;
  1193. }
  1194. }