vendor/symfony/form/Extension/Core/Type/ChoiceType.php line 50

  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\Extension\Core\Type;
  14. use Symfony\Component\Form\AbstractType;
  15. use Symfony\Component\Form\ChoiceList\ChoiceListInterface;
  16. use Symfony\Component\Form\ChoiceList\Factory\Cache\ChoiceAttr;
  17. use Symfony\Component\Form\ChoiceList\Factory\Cache\ChoiceFieldName;
  18. use Symfony\Component\Form\ChoiceList\Factory\Cache\ChoiceFilter;
  19. use Symfony\Component\Form\ChoiceList\Factory\Cache\ChoiceLabel;
  20. use Symfony\Component\Form\ChoiceList\Factory\Cache\ChoiceLoader;
  21. use Symfony\Component\Form\ChoiceList\Factory\Cache\ChoiceTranslationParameters;
  22. use Symfony\Component\Form\ChoiceList\Factory\Cache\ChoiceValue;
  23. use Symfony\Component\Form\ChoiceList\Factory\Cache\GroupBy;
  24. use Symfony\Component\Form\ChoiceList\Factory\Cache\PreferredChoice;
  25. use Symfony\Component\Form\ChoiceList\Factory\CachingFactoryDecorator;
  26. use Symfony\Component\Form\ChoiceList\Factory\ChoiceListFactoryInterface;
  27. use Symfony\Component\Form\ChoiceList\Factory\DefaultChoiceListFactory;
  28. use Symfony\Component\Form\ChoiceList\Factory\PropertyAccessDecorator;
  29. use Symfony\Component\Form\ChoiceList\Loader\ChoiceLoaderInterface;
  30. use Symfony\Component\Form\ChoiceList\View\ChoiceGroupView;
  31. use Symfony\Component\Form\ChoiceList\View\ChoiceListView;
  32. use Symfony\Component\Form\ChoiceList\View\ChoiceView;
  33. use Symfony\Component\Form\Exception\TransformationFailedException;
  34. use Symfony\Component\Form\Extension\Core\DataMapper\CheckboxListMapper;
  35. use Symfony\Component\Form\Extension\Core\DataMapper\RadioListMapper;
  36. use Symfony\Component\Form\Extension\Core\DataTransformer\ChoicesToValuesTransformer;
  37. use Symfony\Component\Form\Extension\Core\DataTransformer\ChoiceToValueTransformer;
  38. use Symfony\Component\Form\Extension\Core\EventListener\MergeCollectionListener;
  39. use Symfony\Component\Form\FormBuilderInterface;
  40. use Symfony\Component\Form\FormError;
  41. use Symfony\Component\Form\FormEvent;
  42. use Symfony\Component\Form\FormEvents;
  43. use Symfony\Component\Form\FormInterface;
  44. use Symfony\Component\Form\FormView;
  45. use Symfony\Component\OptionsResolver\Options;
  46. use Symfony\Component\OptionsResolver\OptionsResolver;
  47. use Symfony\Component\PropertyAccess\PropertyPath;
  48. use Symfony\Contracts\Translation\TranslatorInterface;
  50. class ChoiceType extends AbstractType
  51. {
  52.     private ChoiceListFactoryInterface $choiceListFactory;
  53.     private ?TranslatorInterface $translator;
  55.     public function __construct(ChoiceListFactoryInterface $choiceListFactory = null, TranslatorInterface $translator = null)
  56.     {
  57.         $this->choiceListFactory = $choiceListFactory ?? new CachingFactoryDecorator(
  58.             new PropertyAccessDecorator(
  59.                 new DefaultChoiceListFactory()
  60.             )
  61.         );
  62.         $this->translator = $translator;
  63.     }
  65.     public function buildForm(FormBuilderInterface $builder, array $options)
  66.     {
  67.         $unknownValues = [];
  68.         $choiceList = $this->createChoiceList($options);
  69.         $builder->setAttribute('choice_list', $choiceList);
  71.         if ($options['expanded']) {
  72.             $builder->setDataMapper($options['multiple'] ? new CheckboxListMapper() : new RadioListMapper());
  74.             // Initialize all choices before doing the index check below.
  75.             // This helps in cases where index checks are optimized for non
  76.             // initialized choice lists. For example, when using an SQL driver,
  77.             // the index check would read in one SQL query and the initialization
  78.             // requires another SQL query. When the initialization is done first,
  79.             // one SQL query is sufficient.
  81.             $choiceListView = $this->createChoiceListView($choiceList, $options);
  82.             $builder->setAttribute('choice_list_view', $choiceListView);
  84.             // Check if the choices already contain the empty value
  85.             // Only add the placeholder option if this is not the case
  86.             if (null !== $options['placeholder'] && 0 === \count($choiceList->getChoicesForValues(['']))) {
  87.                 $placeholderView = new ChoiceView(null, '', $options['placeholder']);
  89.                 // "placeholder" is a reserved name
  90.                 $this->addSubForm($builder, 'placeholder', $placeholderView, $options);
  91.             }
  93.             $this->addSubForms($builder, $choiceListView->preferredChoices, $options);
  94.             $this->addSubForms($builder, $choiceListView->choices, $options);
  95.         }
  97.         if ($options['expanded'] || $options['multiple']) {
  98.             // Make sure that scalar, submitted values are converted to arrays
  99.             // which can be submitted to the checkboxes/radio buttons
  100.             $builder->addEventListener(FormEvents::PRE_SUBMIT, function (FormEvent $event) use ($choiceList, $options, &$unknownValues) {
  101.                 $form = $event->getForm();
  102.                 $data = $event->getData();
  104.                 // Since the type always use mapper an empty array will not be
  105.                 // considered as empty in Form::submit(), we need to evaluate
  106.                 // empty data here so its value is submitted to sub forms
  107.                 if (null === $data) {
  108.                     $emptyData = $form->getConfig()->getEmptyData();
  109.                     $data = $emptyData instanceof \Closure ? $emptyData($form, $data) : $emptyData;
  110.                 }
  112.                 // Convert the submitted data to a string, if scalar, before
  113.                 // casting it to an array
  114.                 if (!\is_array($data)) {
  115.                     if ($options['multiple']) {
  116.                         throw new TransformationFailedException('Expected an array.');
  117.                     }
  119.                     $data = (array) (string) $data;
  120.                 }
  122.                 // A map from submitted values to integers
  123.                 $valueMap = array_flip($data);
  125.                 // Make a copy of the value map to determine whether any unknown
  126.                 // values were submitted
  127.                 $unknownValues = $valueMap;
  129.                 // Reconstruct the data as mapping from child names to values
  130.                 $knownValues = [];
  132.                 if ($options['expanded']) {
  133.                     /** @var FormInterface $child */
  134.                     foreach ($form as $child) {
  135.                         $value = $child->getConfig()->getOption('value');
  137.                         // Add the value to $data with the child's name as key
  138.                         if (isset($valueMap[$value])) {
  139.                             $knownValues[$child->getName()] = $value;
  140.                             unset($unknownValues[$value]);
  141.                             continue;
  142.                         } else {
  143.                             $knownValues[$child->getName()] = null;
  144.                         }
  145.                     }
  146.                 } else {
  147.                     foreach ($data as $value) {
  148.                         if ($choiceList->getChoicesForValues([$value])) {
  149.                             $knownValues[] = $value;
  150.                             unset($unknownValues[$value]);
  151.                         }
  152.                     }
  153.                 }
  155.                 // The empty value is always known, independent of whether a
  156.                 // field exists for it or not
  157.                 unset($unknownValues['']);
  159.                 // Throw exception if unknown values were submitted (multiple choices will be handled in a different event listener below)
  160.                 if (\count($unknownValues) > 0 && !$options['multiple']) {
  161.                     throw new TransformationFailedException(sprintf('The choices "%s" do not exist in the choice list.', implode('", "', array_keys($unknownValues))));
  162.                 }
  164.                 $event->setData($knownValues);
  165.             });
  166.         }
  168.         if ($options['multiple']) {
  169.             $messageTemplate = $options['invalid_message'] ?? 'The value {{ value }} is not valid.';
  171.             $builder->addEventListener(FormEvents::POST_SUBMIT, function (FormEvent $event) use (&$unknownValues, $messageTemplate) {
  172.                 // Throw exception if unknown values were submitted
  173.                 if (\count($unknownValues) > 0) {
  174.                     $form = $event->getForm();
  176.                     $clientDataAsString = \is_scalar($form->getViewData()) ? (string) $form->getViewData() : (\is_array($form->getViewData()) ? implode('", "', array_keys($unknownValues)) : \gettype($form->getViewData()));
  178.                     if (null !== $this->translator) {
  179.                         $message = $this->translator->trans($messageTemplate, ['{{ value }}' => $clientDataAsString], 'validators');
  180.                     } else {
  181.                         $message = strtr($messageTemplate, ['{{ value }}' => $clientDataAsString]);
  182.                     }
  184.                     $form->addError(new FormError($message, $messageTemplate, ['{{ value }}' => $clientDataAsString], null, new TransformationFailedException(sprintf('The choices "%s" do not exist in the choice list.', $clientDataAsString))));
  185.                 }
  186.             });
  188.             // <select> tag with "multiple" option or list of checkbox inputs
  189.             $builder->addViewTransformer(new ChoicesToValuesTransformer($choiceList));
  190.         } else {
  191.             // <select> tag without "multiple" option or list of radio inputs
  192.             $builder->addViewTransformer(new ChoiceToValueTransformer($choiceList));
  193.         }
  195.         if ($options['multiple'] && $options['by_reference']) {
  196.             // Make sure the collection created during the client->norm
  197.             // transformation is merged back into the original collection
  198.             $builder->addEventSubscriber(new MergeCollectionListener(true, true));
  199.         }
  201.         // To avoid issues when the submitted choices are arrays (i.e. array to string conversions),
  202.         // we have to ensure that all elements of the submitted choice data are NULL, strings or ints.
  203.         $builder->addEventListener(FormEvents::PRE_SUBMIT, function (FormEvent $event) {
  204.             $data = $event->getData();
  206.             if (!\is_array($data)) {
  207.                 return;
  208.             }
  210.             foreach ($data as $v) {
  211.                 if (null !== $v && !\is_string($v) && !\is_int($v)) {
  212.                     throw new TransformationFailedException('All choices submitted must be NULL, strings or ints.');
  213.                 }
  214.             }
  215.         }, 256);
  216.     }
  218.     public function buildView(FormView $view, FormInterface $form, array $options)
  219.     {
  220.         $choiceTranslationDomain = $options['choice_translation_domain'];
  221.         if ($view->parent && null === $choiceTranslationDomain) {
  222.             $choiceTranslationDomain = $view->vars['translation_domain'];
  223.         }
  225.         /** @var ChoiceListInterface $choiceList */
  226.         $choiceList = $form->getConfig()->getAttribute('choice_list');
  228.         /** @var ChoiceListView $choiceListView */
  229.         $choiceListView = $form->getConfig()->hasAttribute('choice_list_view')
  230.             ? $form->getConfig()->getAttribute('choice_list_view')
  231.             : $this->createChoiceListView($choiceList, $options);
  233.         $view->vars = array_replace($view->vars, [
  234.             'multiple' => $options['multiple'],
  235.             'expanded' => $options['expanded'],
  236.             'preferred_choices' => $choiceListView->preferredChoices,
  237.             'choices' => $choiceListView->choices,
  238.             'separator' => '-------------------',
  239.             'placeholder' => null,
  240.             'choice_translation_domain' => $choiceTranslationDomain,
  241.             'choice_translation_parameters' => $options['choice_translation_parameters'],
  242.         ]);
  244.         // The decision, whether a choice is selected, is potentially done
  245.         // thousand of times during the rendering of a template. Provide a
  246.         // closure here that is optimized for the value of the form, to
  247.         // avoid making the type check inside the closure.
  248.         if ($options['multiple']) {
  249.             $view->vars['is_selected'] = function ($choice, array $values) {
  250.                 return \in_array($choice, $values, true);
  251.             };
  252.         } else {
  253.             $view->vars['is_selected'] = function ($choice, $value) {
  254.                 return $choice === $value;
  255.             };
  256.         }
  258.         // Check if the choices already contain the empty value
  259.         $view->vars['placeholder_in_choices'] = $choiceListView->hasPlaceholder();
  261.         // Only add the empty value option if this is not the case
  262.         if (null !== $options['placeholder'] && !$view->vars['placeholder_in_choices']) {
  263.             $view->vars['placeholder'] = $options['placeholder'];
  264.         }
  266.         if ($options['multiple'] && !$options['expanded']) {
  267.             // Add "[]" to the name in case a select tag with multiple options is
  268.             // displayed. Otherwise only one of the selected options is sent in the
  269.             // POST request.
  270.             $view->vars['full_name'] .= '[]';
  271.         }
  272.     }
  274.     public function finishView(FormView $view, FormInterface $form, array $options)
  275.     {
  276.         if ($options['expanded']) {
  277.             // Radio buttons should have the same name as the parent
  278.             $childName = $view->vars['full_name'];
  280.             // Checkboxes should append "[]" to allow multiple selection
  281.             if ($options['multiple']) {
  282.                 $childName .= '[]';
  283.             }
  285.             foreach ($view as $childView) {
  286.                 $childView->vars['full_name'] = $childName;
  287.             }
  288.         }
  289.     }
  291.     public function configureOptions(OptionsResolver $resolver)
  292.     {
  293.         $emptyData = function (Options $options) {
  294.             if ($options['expanded'] && !$options['multiple']) {
  295.                 return null;
  296.             }
  298.             if ($options['multiple']) {
  299.                 return [];
  300.             }
  302.             return '';
  303.         };
  305.         $placeholderDefault = function (Options $options) {
  306.             return $options['required'] ? null : '';
  307.         };
  309.         $placeholderNormalizer = function (Options $options, $placeholder) {
  310.             if ($options['multiple']) {
  311.                 // never use an empty value for this case
  312.                 return null;
  313.             } elseif ($options['required'] && ($options['expanded'] || isset($options['attr']['size']) && $options['attr']['size'] > 1)) {
  314.                 // placeholder for required radio buttons or a select with size > 1 does not make sense
  315.                 return null;
  316.             } elseif (false === $placeholder) {
  317.                 // an empty value should be added but the user decided otherwise
  318.                 return null;
  319.             } elseif ($options['expanded'] && '' === $placeholder) {
  320.                 // never use an empty label for radio buttons
  321.                 return 'None';
  322.             }
  324.             // empty value has been set explicitly
  325.             return $placeholder;
  326.         };
  328.         $compound = function (Options $options) {
  329.             return $options['expanded'];
  330.         };
  332.         $choiceTranslationDomainNormalizer = function (Options $options, $choiceTranslationDomain) {
  333.             if (true === $choiceTranslationDomain) {
  334.                 return $options['translation_domain'];
  335.             }
  337.             return $choiceTranslationDomain;
  338.         };
  340.         $resolver->setDefaults([
  341.             'multiple' => false,
  342.             'expanded' => false,
  343.             'choices' => [],
  344.             'choice_filter' => null,
  345.             'choice_loader' => null,
  346.             'choice_label' => null,
  347.             'choice_name' => null,
  348.             'choice_value' => null,
  349.             'choice_attr' => null,
  350.             'choice_translation_parameters' => [],
  351.             'preferred_choices' => [],
  352.             'group_by' => null,
  353.             'empty_data' => $emptyData,
  354.             'placeholder' => $placeholderDefault,
  355.             'error_bubbling' => false,
  356.             'compound' => $compound,
  357.             // The view data is always a string or an array of strings,
  358.             // even if the "data" option is manually set to an object.
  359.             // See https://github.com/symfony/symfony/pull/5582
  360.             'data_class' => null,
  361.             'choice_translation_domain' => true,
  362.             'trim' => false,
  363.             'invalid_message' => 'The selected choice is invalid.',
  364.         ]);
  366.         $resolver->setNormalizer('placeholder', $placeholderNormalizer);
  367.         $resolver->setNormalizer('choice_translation_domain', $choiceTranslationDomainNormalizer);
  369.         $resolver->setAllowedTypes('choices', ['null', 'array', \Traversable::class]);
  370.         $resolver->setAllowedTypes('choice_translation_domain', ['null', 'bool', 'string']);
  371.         $resolver->setAllowedTypes('choice_loader', ['null', ChoiceLoaderInterface::class, ChoiceLoader::class]);
  372.         $resolver->setAllowedTypes('choice_filter', ['null', 'callable', 'string', PropertyPath::class, ChoiceFilter::class]);
  373.         $resolver->setAllowedTypes('choice_label', ['null', 'bool', 'callable', 'string', PropertyPath::class, ChoiceLabel::class]);
  374.         $resolver->setAllowedTypes('choice_name', ['null', 'callable', 'string', PropertyPath::class, ChoiceFieldName::class]);
  375.         $resolver->setAllowedTypes('choice_value', ['null', 'callable', 'string', PropertyPath::class, ChoiceValue::class]);
  376.         $resolver->setAllowedTypes('choice_attr', ['null', 'array', 'callable', 'string', PropertyPath::class, ChoiceAttr::class]);
  377.         $resolver->setAllowedTypes('choice_translation_parameters', ['null', 'array', 'callable', ChoiceTranslationParameters::class]);
  378.         $resolver->setAllowedTypes('preferred_choices', ['array', \Traversable::class, 'callable', 'string', PropertyPath::class, PreferredChoice::class]);
  379.         $resolver->setAllowedTypes('group_by', ['null', 'callable', 'string', PropertyPath::class, GroupBy::class]);
  380.     }
  382.     public function getBlockPrefix(): string
  383.     {
  384.         return 'choice';
  385.     }
  387.     /**
  388.      * Adds the sub fields for an expanded choice field.
  389.      */
  390.     private function addSubForms(FormBuilderInterface $builder, array $choiceViews, array $options)
  391.     {
  392.         foreach ($choiceViews as $name => $choiceView) {
  393.             // Flatten groups
  394.             if (\is_array($choiceView)) {
  395.                 $this->addSubForms($builder, $choiceView, $options);
  396.                 continue;
  397.             }
  399.             if ($choiceView instanceof ChoiceGroupView) {
  400.                 $this->addSubForms($builder, $choiceView->choices, $options);
  401.                 continue;
  402.             }
  404.             $this->addSubForm($builder, $name, $choiceView, $options);
  405.         }
  406.     }
  408.     private function addSubForm(FormBuilderInterface $builder, string $name, ChoiceView $choiceView, array $options)
  409.     {
  410.         $choiceOpts = [
  411.             'value' => $choiceView->value,
  412.             'label' => $choiceView->label,
  413.             'label_html' => $options['label_html'],
  414.             'attr' => $choiceView->attr,
  415.             'label_translation_parameters' => $choiceView->labelTranslationParameters,
  416.             'translation_domain' => $options['choice_translation_domain'],
  417.             'block_name' => 'entry',
  418.         ];
  420.         if ($options['multiple']) {
  421.             $choiceType = CheckboxType::class;
  422.             // The user can check 0 or more checkboxes. If required
  423.             // is true, they are required to check all of them.
  424.             $choiceOpts['required'] = false;
  425.         } else {
  426.             $choiceType = RadioType::class;
  427.         }
  429.         $builder->add($name, $choiceType, $choiceOpts);
  430.     }
  432.     private function createChoiceList(array $options)
  433.     {
  434.         if (null !== $options['choice_loader']) {
  435.             return $this->choiceListFactory->createListFromLoader(
  436.                 $options['choice_loader'],
  437.                 $options['choice_value'],
  438.                 $options['choice_filter']
  439.             );
  440.         }
  442.         // Harden against NULL values (like in EntityType and ModelType)
  443.         $choices = null !== $options['choices'] ? $options['choices'] : [];
  445.         return $this->choiceListFactory->createListFromChoices(
  446.             $choices,
  447.             $options['choice_value'],
  448.             $options['choice_filter']
  449.         );
  450.     }
  452.     private function createChoiceListView(ChoiceListInterface $choiceList, array $options)
  453.     {
  454.         return $this->choiceListFactory->createView(
  455.             $choiceList,
  456.             $options['preferred_choices'],
  457.             $options['choice_label'],
  458.             $options['choice_name'],
  459.             $options['group_by'],
  460.             $options['choice_attr'],
  461.             $options['choice_translation_parameters']
  462.         );
  463.     }
  464. }