vendor/symfony/form/FormConfigBuilder.php line 73

  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.     private static NativeRequestHandler $nativeRequestHandler;
  34.     /** @var bool */
  35.     protected $locked = false;
  37.     private EventDispatcherInterface $dispatcher;
  38.     private string $name;
  39.     private ?PropertyPathInterface $propertyPath = null;
  40.     private bool $mapped = true;
  41.     private bool $byReference = true;
  42.     private bool $inheritData = false;
  43.     private bool $compound = false;
  44.     private ResolvedFormTypeInterface $type;
  45.     private array $viewTransformers = [];
  46.     private array $modelTransformers = [];
  47.     private ?DataMapperInterface $dataMapper = null;
  48.     private bool $required = true;
  49.     private bool $disabled = false;
  50.     private bool $errorBubbling = false;
  51.     private mixed $emptyData = null;
  52.     private array $attributes = [];
  53.     private mixed $data = null;
  54.     private ?string $dataClass;
  55.     private bool $dataLocked = false;
  56.     private FormFactoryInterface $formFactory;
  57.     private string $action = '';
  58.     private string $method = 'POST';
  59.     private RequestHandlerInterface $requestHandler;
  60.     private bool $autoInitialize = false;
  61.     private array $options;
  62.     private ?\Closure $isEmptyCallback = null;
  64.     /**
  65.      * Creates an empty form configuration.
  66.      *
  67.      * @param string|null $name      The form name
  68.      * @param string|null $dataClass The class of the form's data
  69.      *
  70.      * @throws InvalidArgumentException if the data class is not a valid class or if
  71.      *                                  the name contains invalid characters
  72.      */
  73.     public function __construct(?string $name, ?string $dataClass, EventDispatcherInterface $dispatcher, array $options = [])
  74.     {
  75.         self::validateName($name);
  77.         if (null !== $dataClass && !class_exists($dataClass) && !interface_exists($dataClass, false)) {
  78.             throw new InvalidArgumentException(sprintf('Class "%s" not found. Is the "data_class" form option set correctly?', $dataClass));
  79.         }
  81.         $this->name = (string) $name;
  82.         $this->dataClass = $dataClass;
  83.         $this->dispatcher = $dispatcher;
  84.         $this->options = $options;
  85.     }
  87.     public function addEventListener(string $eventName, callable $listener, int $priority = 0): static
  88.     {
  89.         if ($this->locked) {
  90.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  91.         }
  93.         $this->dispatcher->addListener($eventName, $listener, $priority);
  95.         return $this;
  96.     }
  98.     public function addEventSubscriber(EventSubscriberInterface $subscriber): static
  99.     {
  100.         if ($this->locked) {
  101.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  102.         }
  104.         $this->dispatcher->addSubscriber($subscriber);
  106.         return $this;
  107.     }
  109.     public function addViewTransformer(DataTransformerInterface $viewTransformer, bool $forcePrepend = false): static
  110.     {
  111.         if ($this->locked) {
  112.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  113.         }
  115.         if ($forcePrepend) {
  116.             array_unshift($this->viewTransformers, $viewTransformer);
  117.         } else {
  118.             $this->viewTransformers[] = $viewTransformer;
  119.         }
  121.         return $this;
  122.     }
  124.     public function resetViewTransformers(): static
  125.     {
  126.         if ($this->locked) {
  127.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  128.         }
  130.         $this->viewTransformers = [];
  132.         return $this;
  133.     }
  135.     public function addModelTransformer(DataTransformerInterface $modelTransformer, bool $forceAppend = false): static
  136.     {
  137.         if ($this->locked) {
  138.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  139.         }
  141.         if ($forceAppend) {
  142.             $this->modelTransformers[] = $modelTransformer;
  143.         } else {
  144.             array_unshift($this->modelTransformers, $modelTransformer);
  145.         }
  147.         return $this;
  148.     }
  150.     public function resetModelTransformers(): static
  151.     {
  152.         if ($this->locked) {
  153.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  154.         }
  156.         $this->modelTransformers = [];
  158.         return $this;
  159.     }
  161.     public function getEventDispatcher(): EventDispatcherInterface
  162.     {
  163.         if ($this->locked && !$this->dispatcher instanceof ImmutableEventDispatcher) {
  164.             $this->dispatcher = new ImmutableEventDispatcher($this->dispatcher);
  165.         }
  167.         return $this->dispatcher;
  168.     }
  170.     public function getName(): string
  171.     {
  172.         return $this->name;
  173.     }
  175.     public function getPropertyPath(): ?PropertyPathInterface
  176.     {
  177.         return $this->propertyPath;
  178.     }
  180.     public function getMapped(): bool
  181.     {
  182.         return $this->mapped;
  183.     }
  185.     public function getByReference(): bool
  186.     {
  187.         return $this->byReference;
  188.     }
  190.     public function getInheritData(): bool
  191.     {
  192.         return $this->inheritData;
  193.     }
  195.     public function getCompound(): bool
  196.     {
  197.         return $this->compound;
  198.     }
  200.     public function getType(): ResolvedFormTypeInterface
  201.     {
  202.         return $this->type;
  203.     }
  205.     public function getViewTransformers(): array
  206.     {
  207.         return $this->viewTransformers;
  208.     }
  210.     public function getModelTransformers(): array
  211.     {
  212.         return $this->modelTransformers;
  213.     }
  215.     public function getDataMapper(): ?DataMapperInterface
  216.     {
  217.         return $this->dataMapper;
  218.     }
  220.     public function getRequired(): bool
  221.     {
  222.         return $this->required;
  223.     }
  225.     public function getDisabled(): bool
  226.     {
  227.         return $this->disabled;
  228.     }
  230.     public function getErrorBubbling(): bool
  231.     {
  232.         return $this->errorBubbling;
  233.     }
  235.     public function getEmptyData(): mixed
  236.     {
  237.         return $this->emptyData;
  238.     }
  240.     public function getAttributes(): array
  241.     {
  242.         return $this->attributes;
  243.     }
  245.     public function hasAttribute(string $name): bool
  246.     {
  247.         return \array_key_exists($name, $this->attributes);
  248.     }
  250.     public function getAttribute(string $name, mixed $default = null): mixed
  251.     {
  252.         return \array_key_exists($name, $this->attributes) ? $this->attributes[$name] : $default;
  253.     }
  255.     public function getData(): mixed
  256.     {
  257.         return $this->data;
  258.     }
  260.     public function getDataClass(): ?string
  261.     {
  262.         return $this->dataClass;
  263.     }
  265.     public function getDataLocked(): bool
  266.     {
  267.         return $this->dataLocked;
  268.     }
  270.     public function getFormFactory(): FormFactoryInterface
  271.     {
  272.         if (!isset($this->formFactory)) {
  273.             throw new BadMethodCallException('The form factory must be set before retrieving it.');
  274.         }
  276.         return $this->formFactory;
  277.     }
  279.     public function getAction(): string
  280.     {
  281.         return $this->action;
  282.     }
  284.     public function getMethod(): string
  285.     {
  286.         return $this->method;
  287.     }
  289.     public function getRequestHandler(): RequestHandlerInterface
  290.     {
  291.         return $this->requestHandler ??= self::$nativeRequestHandler ??= new NativeRequestHandler();
  292.     }
  294.     public function getAutoInitialize(): bool
  295.     {
  296.         return $this->autoInitialize;
  297.     }
  299.     public function getOptions(): array
  300.     {
  301.         return $this->options;
  302.     }
  304.     public function hasOption(string $name): bool
  305.     {
  306.         return \array_key_exists($name, $this->options);
  307.     }
  309.     public function getOption(string $name, mixed $default = null): mixed
  310.     {
  311.         return \array_key_exists($name, $this->options) ? $this->options[$name] : $default;
  312.     }
  314.     public function getIsEmptyCallback(): ?callable
  315.     {
  316.         return $this->isEmptyCallback;
  317.     }
  319.     public function setAttribute(string $name, mixed $value): static
  320.     {
  321.         if ($this->locked) {
  322.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  323.         }
  325.         $this->attributes[$name] = $value;
  327.         return $this;
  328.     }
  330.     public function setAttributes(array $attributes): static
  331.     {
  332.         if ($this->locked) {
  333.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  334.         }
  336.         $this->attributes = $attributes;
  338.         return $this;
  339.     }
  341.     public function setDataMapper(DataMapperInterface $dataMapper = null): static
  342.     {
  343.         if (1 > \func_num_args()) {
  344.             trigger_deprecation('symfony/form', '6.2', 'Calling "%s()" without any arguments is deprecated, pass null explicitly instead.', __METHOD__);
  345.         }
  346.         if ($this->locked) {
  347.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  348.         }
  350.         $this->dataMapper = $dataMapper;
  352.         return $this;
  353.     }
  355.     public function setDisabled(bool $disabled): static
  356.     {
  357.         if ($this->locked) {
  358.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  359.         }
  361.         $this->disabled = $disabled;
  363.         return $this;
  364.     }
  366.     public function setEmptyData(mixed $emptyData): static
  367.     {
  368.         if ($this->locked) {
  369.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  370.         }
  372.         $this->emptyData = $emptyData;
  374.         return $this;
  375.     }
  377.     public function setErrorBubbling(bool $errorBubbling): static
  378.     {
  379.         if ($this->locked) {
  380.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  381.         }
  383.         $this->errorBubbling = $errorBubbling;
  385.         return $this;
  386.     }
  388.     public function setRequired(bool $required): static
  389.     {
  390.         if ($this->locked) {
  391.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  392.         }
  394.         $this->required = $required;
  396.         return $this;
  397.     }
  399.     public function setPropertyPath(string|PropertyPathInterface|null $propertyPath): static
  400.     {
  401.         if ($this->locked) {
  402.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  403.         }
  405.         if (null !== $propertyPath && !$propertyPath instanceof PropertyPathInterface) {
  406.             $propertyPath = new PropertyPath($propertyPath);
  407.         }
  409.         $this->propertyPath = $propertyPath;
  411.         return $this;
  412.     }
  414.     public function setMapped(bool $mapped): static
  415.     {
  416.         if ($this->locked) {
  417.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  418.         }
  420.         $this->mapped = $mapped;
  422.         return $this;
  423.     }
  425.     public function setByReference(bool $byReference): static
  426.     {
  427.         if ($this->locked) {
  428.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  429.         }
  431.         $this->byReference = $byReference;
  433.         return $this;
  434.     }
  436.     public function setInheritData(bool $inheritData): static
  437.     {
  438.         if ($this->locked) {
  439.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  440.         }
  442.         $this->inheritData = $inheritData;
  444.         return $this;
  445.     }
  447.     public function setCompound(bool $compound): static
  448.     {
  449.         if ($this->locked) {
  450.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  451.         }
  453.         $this->compound = $compound;
  455.         return $this;
  456.     }
  458.     public function setType(ResolvedFormTypeInterface $type): static
  459.     {
  460.         if ($this->locked) {
  461.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  462.         }
  464.         $this->type = $type;
  466.         return $this;
  467.     }
  469.     public function setData(mixed $data): static
  470.     {
  471.         if ($this->locked) {
  472.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  473.         }
  475.         $this->data = $data;
  477.         return $this;
  478.     }
  480.     public function setDataLocked(bool $locked): static
  481.     {
  482.         if ($this->locked) {
  483.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  484.         }
  486.         $this->dataLocked = $locked;
  488.         return $this;
  489.     }
  491.     public function setFormFactory(FormFactoryInterface $formFactory)
  492.     {
  493.         if ($this->locked) {
  494.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  495.         }
  497.         $this->formFactory = $formFactory;
  499.         return $this;
  500.     }
  502.     public function setAction(string $action): static
  503.     {
  504.         if ($this->locked) {
  505.             throw new BadMethodCallException('The config builder cannot be modified anymore.');
  506.         }
  508.         $this->action = $action;
  510.         return $this;
  511.     }
  513.     public function setMethod(string $method): static
  514.     {
  515.         if ($this->locked) {
  516.             throw new BadMethodCallException('The config builder cannot be modified anymore.');
  517.         }
  519.         $this->method = strtoupper($method);
  521.         return $this;
  522.     }
  524.     public function setRequestHandler(RequestHandlerInterface $requestHandler): static
  525.     {
  526.         if ($this->locked) {
  527.             throw new BadMethodCallException('The config builder cannot be modified anymore.');
  528.         }
  530.         $this->requestHandler = $requestHandler;
  532.         return $this;
  533.     }
  535.     public function setAutoInitialize(bool $initialize): static
  536.     {
  537.         if ($this->locked) {
  538.             throw new BadMethodCallException('FormConfigBuilder methods cannot be accessed anymore once the builder is turned into a FormConfigInterface instance.');
  539.         }
  541.         $this->autoInitialize = $initialize;
  543.         return $this;
  544.     }
  546.     public function getFormConfig(): FormConfigInterface
  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 method should be idempotent, so clone the builder
  553.         $config = clone $this;
  554.         $config->locked = true;
  556.         return $config;
  557.     }
  559.     public function setIsEmptyCallback(?callable $isEmptyCallback): static
  560.     {
  561.         $this->isEmptyCallback = null === $isEmptyCallback ? null : $isEmptyCallback(...);
  563.         return $this;
  564.     }
  566.     /**
  567.      * Validates whether the given variable is a valid form name.
  568.      *
  569.      * @throws InvalidArgumentException if the name contains invalid characters
  570.      *
  571.      * @internal
  572.      */
  573.     final public static function validateName(?string $name)
  574.     {
  575.         if (!self::isValidName($name)) {
  576.             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));
  577.         }
  578.     }
  580.     /**
  581.      * Returns whether the given variable contains a valid form name.
  582.      *
  583.      * A name is accepted if it
  584.      *
  585.      *   * is empty
  586.      *   * starts with a letter, digit or underscore
  587.      *   * contains only letters, digits, numbers, underscores ("_"),
  588.      *     hyphens ("-") and colons (":")
  589.      */
  590.     final public static function isValidName(?string $name): bool
  591.     {
  592.         return '' === $name || null === $name || preg_match('/^[a-zA-Z0-9_][a-zA-Z0-9_\-:]*$/D', $name);
  593.     }
  594. }