vendor/symfony/form/FormConfigBuilder.php line 116

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\EventDispatcher\EventDispatcherInterface;
  15. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  16. use Symfony\Component\EventDispatcher\ImmutableEventDispatcher;
  17. use Symfony\Component\Form\Exception\BadMethodCallException;
  18. use Symfony\Component\Form\Exception\InvalidArgumentException;
  19. use Symfony\Component\PropertyAccess\PropertyPath;
  20. use Symfony\Component\PropertyAccess\PropertyPathInterface;
  22. /**
  23. * A basic form configuration.
  24. *
  25. * @author Bernhard Schussek <bschussek@gmail.com>
  26. */
  27. class FormConfigBuilder implements FormConfigBuilderInterface
  28. {
  29. /**
  30. * Caches a globally unique {@link NativeRequestHandler} instance.
  31. *
  32. * @var NativeRequestHandler
  33. */
  34. private static $nativeRequestHandler;
  36. protected $locked = false;
  37. private $dispatcher;
  38. private $name;
  40. /**
  41. * @var PropertyPathInterface|string|null
  42. */
  43. private $propertyPath;
  45. private $mapped = true;
  46. private $byReference = true;
  47. private $inheritData = false;
  48. private $compound = false;
  50. /**
  51. * @var ResolvedFormTypeInterface
  52. */
  53. private $type;
  55. private $viewTransformers = [];
  56. private $modelTransformers = [];
  58. /**
  59. * @var DataMapperInterface|null
  60. */
  61. private $dataMapper;
  63. private $required = true;
  64. private $disabled = false;
  65. private $errorBubbling = false;
  67. /**
  68. * @var mixed
  69. */
  70. private $emptyData;
  72. private $attributes = [];
  74. /**
  75. * @var mixed
  76. */
  77. private $data;
  79. /**
  80. * @var string|null
  81. */
  82. private $dataClass;
  84. private $dataLocked = false;
  86. /**
  87. * @var FormFactoryInterface|null
  88. */
  89. private $formFactory;
  91. private $action = '';
  92. private $method = 'POST';
  94. /**
  95. * @var RequestHandlerInterface|null
  96. */
  97. private $requestHandler;
  99. private $autoInitialize = false;
  100. private $options;
  101. private $isEmptyCallback;
  103. /**
  104. * Creates an empty form configuration.
  105. *
  106. * @param string|null $name The form name
  107. * @param string|null $dataClass The class of the form's data
  108. *
  109. * @throws InvalidArgumentException if the data class is not a valid class or if
  110. * the name contains invalid characters
  111. */
  112. public function __construct(?string $name, ?string $dataClass, EventDispatcherInterface $dispatcher, array $options = [])
  113. {
  114. self::validateName($name);
  116. if (null !== $dataClass && !class_exists($dataClass) && !interface_exists($dataClass, false)) {
  117. throw new InvalidArgumentException(sprintf('Class "%s" not found. Is the "data_class" form option set correctly?', $dataClass));
  118. }
  120. $this->name = (string) $name;
  121. $this->dataClass = $dataClass;
  122. $this->dispatcher = $dispatcher;
  123. $this->options = $options;
  124. }
  126. /**
  127. * {@inheritdoc}
  128. */
  129. public function addEventListener(string $eventName, callable $listener, int $priority = 0)
  130. {
  131. if ($this->locked) {
  132. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  133. }
  135. $this->dispatcher->addListener($eventName, $listener, $priority);
  137. return $this;
  138. }
  140. /**
  141. * {@inheritdoc}
  142. */
  143. public function addEventSubscriber(EventSubscriberInterface $subscriber)
  144. {
  145. if ($this->locked) {
  146. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  147. }
  149. $this->dispatcher->addSubscriber($subscriber);
  151. return $this;
  152. }
  154. /**
  155. * {@inheritdoc}
  156. */
  157. public function addViewTransformer(DataTransformerInterface $viewTransformer, bool $forcePrepend = false)
  158. {
  159. if ($this->locked) {
  160. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  161. }
  163. if ($forcePrepend) {
  164. array_unshift($this->viewTransformers, $viewTransformer);
  165. } else {
  166. $this->viewTransformers[] = $viewTransformer;
  167. }
  169. return $this;
  170. }
  172. /**
  173. * {@inheritdoc}
  174. */
  175. public function resetViewTransformers()
  176. {
  177. if ($this->locked) {
  178. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  179. }
  181. $this->viewTransformers = [];
  183. return $this;
  184. }
  186. /**
  187. * {@inheritdoc}
  188. */
  189. public function addModelTransformer(DataTransformerInterface $modelTransformer, bool $forceAppend = false)
  190. {
  191. if ($this->locked) {
  192. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  193. }
  195. if ($forceAppend) {
  196. $this->modelTransformers[] = $modelTransformer;
  197. } else {
  198. array_unshift($this->modelTransformers, $modelTransformer);
  199. }
  201. return $this;
  202. }
  204. /**
  205. * {@inheritdoc}
  206. */
  207. public function resetModelTransformers()
  208. {
  209. if ($this->locked) {
  210. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  211. }
  213. $this->modelTransformers = [];
  215. return $this;
  216. }
  218. /**
  219. * {@inheritdoc}
  220. */
  221. public function getEventDispatcher()
  222. {
  223. if ($this->locked && !$this->dispatcher instanceof ImmutableEventDispatcher) {
  224. $this->dispatcher = new ImmutableEventDispatcher($this->dispatcher);
  225. }
  227. return $this->dispatcher;
  228. }
  230. /**
  231. * {@inheritdoc}
  232. */
  233. public function getName()
  234. {
  235. return $this->name;
  236. }
  238. /**
  239. * {@inheritdoc}
  240. */
  241. public function getPropertyPath()
  242. {
  243. return $this->propertyPath;
  244. }
  246. /**
  247. * {@inheritdoc}
  248. */
  249. public function getMapped()
  250. {
  251. return $this->mapped;
  252. }
  254. /**
  255. * {@inheritdoc}
  256. */
  257. public function getByReference()
  258. {
  259. return $this->byReference;
  260. }
  262. /**
  263. * {@inheritdoc}
  264. */
  265. public function getInheritData()
  266. {
  267. return $this->inheritData;
  268. }
  270. /**
  271. * {@inheritdoc}
  272. */
  273. public function getCompound()
  274. {
  275. return $this->compound;
  276. }
  278. /**
  279. * {@inheritdoc}
  280. */
  281. public function getType()
  282. {
  283. return $this->type;
  284. }
  286. /**
  287. * {@inheritdoc}
  288. */
  289. public function getViewTransformers()
  290. {
  291. return $this->viewTransformers;
  292. }
  294. /**
  295. * {@inheritdoc}
  296. */
  297. public function getModelTransformers()
  298. {
  299. return $this->modelTransformers;
  300. }
  302. /**
  303. * {@inheritdoc}
  304. */
  305. public function getDataMapper()
  306. {
  307. return $this->dataMapper;
  308. }
  310. /**
  311. * {@inheritdoc}
  312. */
  313. public function getRequired()
  314. {
  315. return $this->required;
  316. }
  318. /**
  319. * {@inheritdoc}
  320. */
  321. public function getDisabled()
  322. {
  323. return $this->disabled;
  324. }
  326. /**
  327. * {@inheritdoc}
  328. */
  329. public function getErrorBubbling()
  330. {
  331. return $this->errorBubbling;
  332. }
  334. /**
  335. * {@inheritdoc}
  336. */
  337. public function getEmptyData()
  338. {
  339. return $this->emptyData;
  340. }
  342. /**
  343. * {@inheritdoc}
  344. */
  345. public function getAttributes()
  346. {
  347. return $this->attributes;
  348. }
  350. /**
  351. * {@inheritdoc}
  352. */
  353. public function hasAttribute(string $name)
  354. {
  355. return \array_key_exists($name, $this->attributes);
  356. }
  358. /**
  359. * {@inheritdoc}
  360. */
  361. public function getAttribute(string $name, $default = null)
  362. {
  363. return \array_key_exists($name, $this->attributes) ? $this->attributes[$name] : $default;
  364. }
  366. /**
  367. * {@inheritdoc}
  368. */
  369. public function getData()
  370. {
  371. return $this->data;
  372. }
  374. /**
  375. * {@inheritdoc}
  376. */
  377. public function getDataClass()
  378. {
  379. return $this->dataClass;
  380. }
  382. /**
  383. * {@inheritdoc}
  384. */
  385. public function getDataLocked()
  386. {
  387. return $this->dataLocked;
  388. }
  390. /**
  391. * {@inheritdoc}
  392. */
  393. public function getFormFactory()
  394. {
  395. if (!isset($this->formFactory)) {
  396. throw new BadMethodCallException('The form factory must be set before retrieving it.');
  397. }
  399. return $this->formFactory;
  400. }
  402. /**
  403. * {@inheritdoc}
  404. */
  405. public function getAction()
  406. {
  407. return $this->action;
  408. }
  410. /**
  411. * {@inheritdoc}
  412. */
  413. public function getMethod()
  414. {
  415. return $this->method;
  416. }
  418. /**
  419. * {@inheritdoc}
  420. */
  421. public function getRequestHandler()
  422. {
  423. if (null === $this->requestHandler) {
  424. if (null === self::$nativeRequestHandler) {
  425. self::$nativeRequestHandler = new NativeRequestHandler();
  426. }
  427. $this->requestHandler = self::$nativeRequestHandler;
  428. }
  430. return $this->requestHandler;
  431. }
  433. /**
  434. * {@inheritdoc}
  435. */
  436. public function getAutoInitialize()
  437. {
  438. return $this->autoInitialize;
  439. }
  441. /**
  442. * {@inheritdoc}
  443. */
  444. public function getOptions()
  445. {
  446. return $this->options;
  447. }
  449. /**
  450. * {@inheritdoc}
  451. */
  452. public function hasOption(string $name)
  453. {
  454. return \array_key_exists($name, $this->options);
  455. }
  457. /**
  458. * {@inheritdoc}
  459. */
  460. public function getOption(string $name, $default = null)
  461. {
  462. return \array_key_exists($name, $this->options) ? $this->options[$name] : $default;
  463. }
  465. /**
  466. * {@inheritdoc}
  467. */
  468. public function getIsEmptyCallback(): ?callable
  469. {
  470. return $this->isEmptyCallback;
  471. }
  473. /**
  474. * {@inheritdoc}
  475. */
  476. public function setAttribute(string $name, $value)
  477. {
  478. if ($this->locked) {
  479. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  480. }
  482. $this->attributes[$name] = $value;
  484. return $this;
  485. }
  487. /**
  488. * {@inheritdoc}
  489. */
  490. public function setAttributes(array $attributes)
  491. {
  492. if ($this->locked) {
  493. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  494. }
  496. $this->attributes = $attributes;
  498. return $this;
  499. }
  501. /**
  502. * {@inheritdoc}
  503. */
  504. public function setDataMapper(?DataMapperInterface $dataMapper = null)
  505. {
  506. if ($this->locked) {
  507. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  508. }
  510. $this->dataMapper = $dataMapper;
  512. return $this;
  513. }
  515. /**
  516. * {@inheritdoc}
  517. */
  518. public function setDisabled(bool $disabled)
  519. {
  520. if ($this->locked) {
  521. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  522. }
  524. $this->disabled = $disabled;
  526. return $this;
  527. }
  529. /**
  530. * {@inheritdoc}
  531. */
  532. public function setEmptyData($emptyData)
  533. {
  534. if ($this->locked) {
  535. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  536. }
  538. $this->emptyData = $emptyData;
  540. return $this;
  541. }
  543. /**
  544. * {@inheritdoc}
  545. */
  546. public function setErrorBubbling(bool $errorBubbling)
  547. {
  548. if ($this->locked) {
  549. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  550. }
  552. $this->errorBubbling = $errorBubbling;
  554. return $this;
  555. }
  557. /**
  558. * {@inheritdoc}
  559. */
  560. public function setRequired(bool $required)
  561. {
  562. if ($this->locked) {
  563. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  564. }
  566. $this->required = $required;
  568. return $this;
  569. }
  571. /**
  572. * {@inheritdoc}
  573. */
  574. public function setPropertyPath($propertyPath)
  575. {
  576. if ($this->locked) {
  577. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  578. }
  580. if (null !== $propertyPath && !$propertyPath instanceof PropertyPathInterface) {
  581. $propertyPath = new PropertyPath($propertyPath);
  582. }
  584. $this->propertyPath = $propertyPath;
  586. return $this;
  587. }
  589. /**
  590. * {@inheritdoc}
  591. */
  592. public function setMapped(bool $mapped)
  593. {
  594. if ($this->locked) {
  595. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  596. }
  598. $this->mapped = $mapped;
  600. return $this;
  601. }
  603. /**
  604. * {@inheritdoc}
  605. */
  606. public function setByReference(bool $byReference)
  607. {
  608. if ($this->locked) {
  609. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  610. }
  612. $this->byReference = $byReference;
  614. return $this;
  615. }
  617. /**
  618. * {@inheritdoc}
  619. */
  620. public function setInheritData(bool $inheritData)
  621. {
  622. if ($this->locked) {
  623. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  624. }
  626. $this->inheritData = $inheritData;
  628. return $this;
  629. }
  631. /**
  632. * {@inheritdoc}
  633. */
  634. public function setCompound(bool $compound)
  635. {
  636. if ($this->locked) {
  637. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  638. }
  640. $this->compound = $compound;
  642. return $this;
  643. }
  645. /**
  646. * {@inheritdoc}
  647. */
  648. public function setType(ResolvedFormTypeInterface $type)
  649. {
  650. if ($this->locked) {
  651. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  652. }
  654. $this->type = $type;
  656. return $this;
  657. }
  659. /**
  660. * {@inheritdoc}
  661. */
  662. public function setData($data)
  663. {
  664. if ($this->locked) {
  665. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  666. }
  668. $this->data = $data;
  670. return $this;
  671. }
  673. /**
  674. * {@inheritdoc}
  675. */
  676. public function setDataLocked(bool $locked)
  677. {
  678. if ($this->locked) {
  679. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  680. }
  682. $this->dataLocked = $locked;
  684. return $this;
  685. }
  687. /**
  688. * {@inheritdoc}
  689. */
  690. public function setFormFactory(FormFactoryInterface $formFactory)
  691. {
  692. if ($this->locked) {
  693. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  694. }
  696. $this->formFactory = $formFactory;
  698. return $this;
  699. }
  701. /**
  702. * {@inheritdoc}
  703. */
  704. public function setAction(string $action)
  705. {
  706. if ($this->locked) {
  707. throw new BadMethodCallException('The config builder cannot be modified anymore.');
  708. }
  710. $this->action = $action;
  712. return $this;
  713. }
  715. /**
  716. * {@inheritdoc}
  717. */
  718. public function setMethod(string $method)
  719. {
  720. if ($this->locked) {
  721. throw new BadMethodCallException('The config builder cannot be modified anymore.');
  722. }
  724. $this->method = strtoupper($method);
  726. return $this;
  727. }
  729. /**
  730. * {@inheritdoc}
  731. */
  732. public function setRequestHandler(RequestHandlerInterface $requestHandler)
  733. {
  734. if ($this->locked) {
  735. throw new BadMethodCallException('The config builder cannot be modified anymore.');
  736. }
  738. $this->requestHandler = $requestHandler;
  740. return $this;
  741. }
  743. /**
  744. * {@inheritdoc}
  745. */
  746. public function setAutoInitialize(bool $initialize)
  747. {
  748. if ($this->locked) {
  749. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  750. }
  752. $this->autoInitialize = $initialize;
  754. return $this;
  755. }
  757. /**
  758. * {@inheritdoc}
  759. */
  760. public function getFormConfig()
  761. {
  762. if ($this->locked) {
  763. throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  764. }
  766. // This method should be idempotent, so clone the builder
  767. $config = clone $this;
  768. $config->locked = true;
  770. return $config;
  771. }
  773. /**
  774. * {@inheritdoc}
  775. */
  776. public function setIsEmptyCallback(?callable $isEmptyCallback)
  777. {
  778. $this->isEmptyCallback = $isEmptyCallback;
  780. return $this;
  781. }
  783. /**
  784. * Validates whether the given variable is a valid form name.
  785. *
  786. * @throws InvalidArgumentException if the name contains invalid characters
  787. *
  788. * @internal
  789. */
  790. final public static function validateName(?string $name)
  791. {
  792. if (!self::isValidName($name)) {
  793. throw new InvalidArgumentException(sprintf('The name "%s" contains illegal characters. Names should start with a letter, digit or underscore and only contain letters, digits, numbers, underscores ("_"), hyphens ("-") and colons (":").', $name));
  794. }
  795. }
  797. /**
  798. * Returns whether the given variable contains a valid form name.
  799. *
  800. * A name is accepted if it
  801. *
  802. * * is empty
  803. * * starts with a letter, digit or underscore
  804. * * contains only letters, digits, numbers, underscores ("_"),
  805. * hyphens ("-") and colons (":")
  806. */
  807. final public static function isValidName(?string $name): bool
  808. {
  809. return '' === $name || null === $name || preg_match('/^[a-zA-Z0-9_][a-zA-Z0-9_\-:]*$/D', $name);
  810. }
  811. }