Actualización

vendor/symfony/form/ChoiceList/ArrayChoiceList.php

@@ -0,0 +1,246 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Form\ChoiceList;
+
+/**
+ * A list of choices with arbitrary data types.
+ *
+ * The user of this class is responsible for assigning string values to the
+ * choices. Both the choices and their values are passed to the constructor.
+ * Each choice must have a corresponding value (with the same array key) in
+ * the value array.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+class ArrayChoiceList implements ChoiceListInterface
+{
+    /**
+     * The choices in the list.
+     *
+     * @var array
+     */
+    protected $choices;
+
+    /**
+     * The values indexed by the original keys.
+     *
+     * @var array
+     */
+    protected $structuredValues;
+
+    /**
+     * The original keys of the choices array.
+     *
+     * @var int[]|string[]
+     */
+    protected $originalKeys;
+
+    /**
+     * The callback for creating the value for a choice.
+     *
+     * @var callable
+     */
+    protected $valueCallback;
+
+    /**
+     * Creates a list with the given choices and values.
+     *
+     * The given choice array must have the same array keys as the value array.
+     *
+     * @param array|\Traversable $choices The selectable choices
+     * @param callable|null      $value   The callable for creating the value
+     *                                    for a choice. If `null` is passed,
+     *                                    incrementing integers are used as
+     *                                    values
+     */
+    public function __construct($choices, callable $value = null)
+    {
+        if ($choices instanceof \Traversable) {
+            $choices = iterator_to_array($choices);
+        }
+
+        if (null === $value && $this->castableToString($choices)) {
+            $value = function ($choice) {
+                return false === $choice ? '0' : (string) $choice;
+            };
+        }
+
+        if (null !== $value) {
+            // If a deterministic value generator was passed, use it later
+            $this->valueCallback = $value;
+        } else {
+            // Otherwise simply generate incrementing integers as values
+            $i = 0;
+            $value = function () use (&$i) {
+                return $i++;
+            };
+        }
+
+        // If the choices are given as recursive array (i.e. with explicit
+        // choice groups), flatten the array. The grouping information is needed
+        // in the view only.
+        $this->flatten($choices, $value, $choicesByValues, $keysByValues, $structuredValues);
+
+        $this->choices = $choicesByValues;
+        $this->originalKeys = $keysByValues;
+        $this->structuredValues = $structuredValues;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getChoices()
+    {
+        return $this->choices;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getValues()
+    {
+        return array_map('strval', array_keys($this->choices));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getStructuredValues()
+    {
+        return $this->structuredValues;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getOriginalKeys()
+    {
+        return $this->originalKeys;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getChoicesForValues(array $values)
+    {
+        $choices = array();
+
+        foreach ($values as $i => $givenValue) {
+            if (array_key_exists($givenValue, $this->choices)) {
+                $choices[$i] = $this->choices[$givenValue];
+            }
+        }
+
+        return $choices;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getValuesForChoices(array $choices)
+    {
+        $values = array();
+
+        // Use the value callback to compare choices by their values, if present
+        if ($this->valueCallback) {
+            $givenValues = array();
+
+            foreach ($choices as $i => $givenChoice) {
+                $givenValues[$i] = (string) call_user_func($this->valueCallback, $givenChoice);
+            }
+
+            return array_intersect($givenValues, array_keys($this->choices));
+        }
+
+        // Otherwise compare choices by identity
+        foreach ($choices as $i => $givenChoice) {
+            foreach ($this->choices as $value => $choice) {
+                if ($choice === $givenChoice) {
+                    $values[$i] = (string) $value;
+                    break;
+                }
+            }
+        }
+
+        return $values;
+    }
+
+    /**
+     * Flattens an array into the given output variables.
+     *
+     * @param array    $choices          The array to flatten
+     * @param callable $value            The callable for generating choice values
+     * @param array    $choicesByValues  The flattened choices indexed by the
+     *                                   corresponding values
+     * @param array    $keysByValues     The original keys indexed by the
+     *                                   corresponding values
+     * @param array    $structuredValues The values indexed by the original keys
+     *
+     * @internal Must not be used by user-land code
+     */
+    protected function flatten(array $choices, $value, &$choicesByValues, &$keysByValues, &$structuredValues)
+    {
+        if (null === $choicesByValues) {
+            $choicesByValues = array();
+            $keysByValues = array();
+            $structuredValues = array();
+        }
+
+        foreach ($choices as $key => $choice) {
+            if (is_array($choice)) {
+                $this->flatten($choice, $value, $choicesByValues, $keysByValues, $structuredValues[$key]);
+
+                continue;
+            }
+
+            $choiceValue = (string) call_user_func($value, $choice);
+            $choicesByValues[$choiceValue] = $choice;
+            $keysByValues[$choiceValue] = $key;
+            $structuredValues[$key] = $choiceValue;
+        }
+    }
+
+    /**
+     * Checks whether the given choices can be cast to strings without
+     * generating duplicates.
+     *
+     * @param array      $choices The choices
+     * @param array|null $cache   The cache for previously checked entries. Internal
+     *
+     * @return bool Returns true if the choices can be cast to strings and
+     *              false otherwise.
+     */
+    private function castableToString(array $choices, array &$cache = array())
+    {
+        foreach ($choices as $choice) {
+            if (is_array($choice)) {
+                if (!$this->castableToString($choice, $cache)) {
+                    return false;
+                }
+
+                continue;
+            } elseif (!is_scalar($choice)) {
+                return false;
+            }
+
+            $choice = false === $choice ? '0' : (string) $choice;
+
+            if (isset($cache[$choice])) {
+                return false;
+            }
+
+            $cache[$choice] = true;
+        }
+
+        return true;
+    }
+}

vendor/symfony/form/ChoiceList/ChoiceListInterface.php

@@ -0,0 +1,116 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Form\ChoiceList;
+
+/**
+ * A list of choices that can be selected in a choice field.
+ *
+ * A choice list assigns unique string values to each of a list of choices.
+ * These string values are displayed in the "value" attributes in HTML and
+ * submitted back to the server.
+ *
+ * The acceptable data types for the choices depend on the implementation.
+ * Values must always be strings and (within the list) free of duplicates.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+interface ChoiceListInterface
+{
+    /**
+     * Returns all selectable choices.
+     *
+     * @return array The selectable choices indexed by the corresponding values
+     */
+    public function getChoices();
+
+    /**
+     * Returns the values for the choices.
+     *
+     * The values are strings that do not contain duplicates.
+     *
+     * @return string[] The choice values
+     */
+    public function getValues();
+
+    /**
+     * Returns the values in the structure originally passed to the list.
+     *
+     * Contrary to {@link getValues()}, the result is indexed by the original
+     * keys of the choices. If the original array contained nested arrays, these
+     * nested arrays are represented here as well:
+     *
+     *     $form->add('field', 'choice', array(
+     *         'choices' => array(
+     *             'Decided' => array('Yes' => true, 'No' => false),
+     *             'Undecided' => array('Maybe' => null),
+     *         ),
+     *     ));
+     *
+     * In this example, the result of this method is:
+     *
+     *     array(
+     *         'Decided' => array('Yes' => '0', 'No' => '1'),
+     *         'Undecided' => array('Maybe' => '2'),
+     *     )
+     *
+     * @return string[] The choice values
+     */
+    public function getStructuredValues();
+
+    /**
+     * Returns the original keys of the choices.
+     *
+     * The original keys are the keys of the choice array that was passed in the
+     * "choice" option of the choice type. Note that this array may contain
+     * duplicates if the "choice" option contained choice groups:
+     *
+     *     $form->add('field', 'choice', array(
+     *         'choices' => array(
+     *             'Decided' => array(true, false),
+     *             'Undecided' => array(null),
+     *         ),
+     *     ));
+     *
+     * In this example, the original key 0 appears twice, once for `true` and
+     * once for `null`.
+     *
+     * @return int[]|string[] The original choice keys indexed by the
+     *                        corresponding choice values
+     */
+    public function getOriginalKeys();
+
+    /**
+     * Returns the choices corresponding to the given values.
+     *
+     * The choices are returned with the same keys and in the same order as the
+     * corresponding values in the given array.
+     *
+     * @param string[] $values An array of choice values. Non-existing values in
+     *                         this array are ignored
+     *
+     * @return array An array of choices
+     */
+    public function getChoicesForValues(array $values);
+
+    /**
+     * Returns the values corresponding to the given choices.
+     *
+     * The values are returned with the same keys and in the same order as the
+     * corresponding choices in the given array.
+     *
+     * @param array $choices An array of choices. Non-existing choices in this
+     *                       array are ignored
+     *
+     * @return string[] An array of choice values
+     */
+    public function getValuesForChoices(array $choices);
+}

vendor/symfony/form/ChoiceList/Factory/CachingFactoryDecorator.php

@@ -0,0 +1,174 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Form\ChoiceList\Factory;
+
+use Symfony\Component\Form\ChoiceList\ChoiceListInterface;
+use Symfony\Component\Form\ChoiceList\Loader\ChoiceLoaderInterface;
+use Symfony\Component\Form\ChoiceList\View\ChoiceListView;
+
+/**
+ * Caches the choice lists created by the decorated factory.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+class CachingFactoryDecorator implements ChoiceListFactoryInterface
+{
+    /**
+     * @var ChoiceListFactoryInterface
+     */
+    private $decoratedFactory;
+
+    /**
+     * @var ChoiceListInterface[]
+     */
+    private $lists = array();
+
+    /**
+     * @var ChoiceListView[]
+     */
+    private $views = array();
+
+    /**
+     * Generates a SHA-256 hash for the given value.
+     *
+     * Optionally, a namespace string can be passed. Calling this method will
+     * the same values, but different namespaces, will return different hashes.
+     *
+     * @param mixed  $value     The value to hash
+     * @param string $namespace Optional. The namespace
+     *
+     * @return string The SHA-256 hash
+     *
+     * @internal Should not be used by user-land code.
+     */
+    public static function generateHash($value, $namespace = '')
+    {
+        if (is_object($value)) {
+            $value = spl_object_hash($value);
+        } elseif (is_array($value)) {
+            array_walk_recursive($value, function (&$v) {
+                if (is_object($v)) {
+                    $v = spl_object_hash($v);
+                }
+            });
+        }
+
+        return hash('sha256', $namespace.':'.serialize($value));
+    }
+
+    /**
+     * Flattens an array into the given output variable.
+     *
+     * @param array $array  The array to flatten
+     * @param array $output The flattened output
+     *
+     * @internal Should not be used by user-land code
+     */
+    private static function flatten(array $array, &$output)
+    {
+        if (null === $output) {
+            $output = array();
+        }
+
+        foreach ($array as $key => $value) {
+            if (is_array($value)) {
+                self::flatten($value, $output);
+                continue;
+            }
+
+            $output[$key] = $value;
+        }
+    }
+
+    /**
+     * Decorates the given factory.
+     *
+     * @param ChoiceListFactoryInterface $decoratedFactory The decorated factory
+     */
+    public function __construct(ChoiceListFactoryInterface $decoratedFactory)
+    {
+        $this->decoratedFactory = $decoratedFactory;
+    }
+
+    /**
+     * Returns the decorated factory.
+     *
+     * @return ChoiceListFactoryInterface The decorated factory
+     */
+    public function getDecoratedFactory()
+    {
+        return $this->decoratedFactory;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createListFromChoices($choices, $value = null)
+    {
+        if ($choices instanceof \Traversable) {
+            $choices = iterator_to_array($choices);
+        }
+
+        // The value is not validated on purpose. The decorated factory may
+        // decide which values to accept and which not.
+
+        // We ignore the choice groups for caching. If two choice lists are
+        // requested with the same choices, but a different grouping, the same
+        // choice list is returned.
+        self::flatten($choices, $flatChoices);
+
+        $hash = self::generateHash(array($flatChoices, $value), 'fromChoices');
+
+        if (!isset($this->lists[$hash])) {
+            $this->lists[$hash] = $this->decoratedFactory->createListFromChoices($choices, $value);
+        }
+
+        return $this->lists[$hash];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createListFromLoader(ChoiceLoaderInterface $loader, $value = null)
+    {
+        $hash = self::generateHash(array($loader, $value), 'fromLoader');
+
+        if (!isset($this->lists[$hash])) {
+            $this->lists[$hash] = $this->decoratedFactory->createListFromLoader($loader, $value);
+        }
+
+        return $this->lists[$hash];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createView(ChoiceListInterface $list, $preferredChoices = null, $label = null, $index = null, $groupBy = null, $attr = null)
+    {
+        // The input is not validated on purpose. This way, the decorated
+        // factory may decide which input to accept and which not.
+        $hash = self::generateHash(array($list, $preferredChoices, $label, $index, $groupBy, $attr));
+
+        if (!isset($this->views[$hash])) {
+            $this->views[$hash] = $this->decoratedFactory->createView(
+                $list,
+                $preferredChoices,
+                $label,
+                $index,
+                $groupBy,
+                $attr
+            );
+        }
+
+        return $this->views[$hash];
+    }
+}

vendor/symfony/form/ChoiceList/Factory/ChoiceListFactoryInterface.php

@@ -0,0 +1,97 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Form\ChoiceList\Factory;
+
+use Symfony\Component\Form\ChoiceList\ChoiceListInterface;
+use Symfony\Component\Form\ChoiceList\Loader\ChoiceLoaderInterface;
+use Symfony\Component\Form\ChoiceList\View\ChoiceListView;
+
+/**
+ * Creates {@link ChoiceListInterface} instances.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+interface ChoiceListFactoryInterface
+{
+    /**
+     * Creates a choice list for the given choices.
+     *
+     * The choices should be passed in the values of the choices array.
+     *
+     * Optionally, a callable can be passed for generating the choice values.
+     * The callable receives the choice as first and the array key as the second
+     * argument.
+     *
+     * @param array|\Traversable $choices The choices
+     * @param null|callable      $value   The callable generating the choice
+     *                                    values
+     *
+     * @return ChoiceListInterface The choice list
+     */
+    public function createListFromChoices($choices, $value = null);
+
+    /**
+     * Creates a choice list that is loaded with the given loader.
+     *
+     * Optionally, a callable can be passed for generating the choice values.
+     * The callable receives the choice as first and the array key as the second
+     * argument.
+     *
+     * @param ChoiceLoaderInterface $loader The choice loader
+     * @param null|callable         $value  The callable generating the choice
+     *                                      values
+     *
+     * @return ChoiceListInterface The choice list
+     */
+    public function createListFromLoader(ChoiceLoaderInterface $loader, $value = null);
+
+    /**
+     * Creates a view for the given choice list.
+     *
+     * Callables may be passed for all optional arguments. The callables receive
+     * the choice as first and the array key as the second argument.
+     *
+     *  * The callable for the label and the name should return the generated
+     *    label/choice name.
+     *  * The callable for the preferred choices should return true or false,
+     *    depending on whether the choice should be preferred or not.
+     *  * The callable for the grouping should return the group name or null if
+     *    a choice should not be grouped.
+     *  * The callable for the attributes should return an array of HTML
+     *    attributes that will be inserted in the tag of the choice.
+     *
+     * If no callable is passed, the labels will be generated from the choice
+     * keys. The view indices will be generated using an incrementing integer
+     * by default.
+     *
+     * The preferred choices can also be passed as array. Each choice that is
+     * contained in that array will be marked as preferred.
+     *
+     * The attributes can be passed as multi-dimensional array. The keys should
+     * match the keys of the choices. The values should be arrays of HTML
+     * attributes that should be added to the respective choice.
+     *
+     * @param ChoiceListInterface $list             The choice list
+     * @param null|array|callable $preferredChoices The preferred choices
+     * @param null|callable       $label            The callable generating the
+     *                                              choice labels
+     * @param null|callable       $index            The callable generating the
+     *                                              view indices
+     * @param null|callable       $groupBy          The callable generating the
+     *                                              group names
+     * @param null|array|callable $attr             The callable generating the
+     *                                              HTML attributes
+     *
+     * @return ChoiceListView The choice list view
+     */
+    public function createView(ChoiceListInterface $list, $preferredChoices = null, $label = null, $index = null, $groupBy = null, $attr = null);
+}

vendor/symfony/form/ChoiceList/Factory/DefaultChoiceListFactory.php

@@ -0,0 +1,243 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Form\ChoiceList\Factory;
+
+use Symfony\Component\Form\ChoiceList\ArrayChoiceList;
+use Symfony\Component\Form\ChoiceList\ChoiceListInterface;
+use Symfony\Component\Form\ChoiceList\LazyChoiceList;
+use Symfony\Component\Form\ChoiceList\Loader\ChoiceLoaderInterface;
+use Symfony\Component\Form\ChoiceList\View\ChoiceGroupView;
+use Symfony\Component\Form\ChoiceList\View\ChoiceListView;
+use Symfony\Component\Form\ChoiceList\View\ChoiceView;
+
+/**
+ * Default implementation of {@link ChoiceListFactoryInterface}.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+class DefaultChoiceListFactory implements ChoiceListFactoryInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function createListFromChoices($choices, $value = null)
+    {
+        return new ArrayChoiceList($choices, $value);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createListFromLoader(ChoiceLoaderInterface $loader, $value = null)
+    {
+        return new LazyChoiceList($loader, $value);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createView(ChoiceListInterface $list, $preferredChoices = null, $label = null, $index = null, $groupBy = null, $attr = null)
+    {
+        $preferredViews = array();
+        $otherViews = array();
+        $choices = $list->getChoices();
+        $keys = $list->getOriginalKeys();
+
+        if (!is_callable($preferredChoices) && !empty($preferredChoices)) {
+            $preferredChoices = function ($choice) use ($preferredChoices) {
+                return in_array($choice, $preferredChoices, true);
+            };
+        }
+
+        // The names are generated from an incrementing integer by default
+        if (null === $index) {
+            $index = 0;
+        }
+
+        // If $groupBy is a callable, choices are added to the group with the
+        // name returned by the callable. If the callable returns null, the
+        // choice is not added to any group
+        if (is_callable($groupBy)) {
+            foreach ($choices as $value => $choice) {
+                self::addChoiceViewGroupedBy(
+                    $groupBy,
+                    $choice,
+                    (string) $value,
+                    $label,
+                    $keys,
+                    $index,
+                    $attr,
+                    $preferredChoices,
+                    $preferredViews,
+                    $otherViews
+                );
+            }
+        } else {
+            // Otherwise use the original structure of the choices
+            self::addChoiceViewsGroupedBy(
+                $list->getStructuredValues(),
+                $label,
+                $choices,
+                $keys,
+                $index,
+                $attr,
+                $preferredChoices,
+                $preferredViews,
+                $otherViews
+            );
+        }
+
+        // Remove any empty group view that may have been created by
+        // addChoiceViewGroupedBy()
+        foreach ($preferredViews as $key => $view) {
+            if ($view instanceof ChoiceGroupView && 0 === count($view->choices)) {
+                unset($preferredViews[$key]);
+            }
+        }
+
+        foreach ($otherViews as $key => $view) {
+            if ($view instanceof ChoiceGroupView && 0 === count($view->choices)) {
+                unset($otherViews[$key]);
+            }
+        }
+
+        return new ChoiceListView($otherViews, $preferredViews);
+    }
+
+    private static function addChoiceView($choice, $value, $label, $keys, &$index, $attr, $isPreferred, &$preferredViews, &$otherViews)
+    {
+        // $value may be an integer or a string, since it's stored in the array
+        // keys. We want to guarantee it's a string though.
+        $key = $keys[$value];
+        $nextIndex = is_int($index) ? $index++ : call_user_func($index, $choice, $key, $value);
+
+        // BC normalize label to accept a false value
+        if (null === $label) {
+            // If the labels are null, use the original choice key by default
+            $label = (string) $key;
+        } elseif (false !== $label) {
+            // If "choice_label" is set to false and "expanded" is true, the value false
+            // should be passed on to the "label" option of the checkboxes/radio buttons
+            $dynamicLabel = call_user_func($label, $choice, $key, $value);
+            $label = false === $dynamicLabel ? false : (string) $dynamicLabel;
+        }
+
+        $view = new ChoiceView(
+            $choice,
+            $value,
+            $label,
+            // The attributes may be a callable or a mapping from choice indices
+            // to nested arrays
+            is_callable($attr) ? call_user_func($attr, $choice, $key, $value) : (isset($attr[$key]) ? $attr[$key] : array())
+        );
+
+        // $isPreferred may be null if no choices are preferred
+        if ($isPreferred && call_user_func($isPreferred, $choice, $key, $value)) {
+            $preferredViews[$nextIndex] = $view;
+        } else {
+            $otherViews[$nextIndex] = $view;
+        }
+    }
+
+    private static function addChoiceViewsGroupedBy($groupBy, $label, $choices, $keys, &$index, $attr, $isPreferred, &$preferredViews, &$otherViews)
+    {
+        foreach ($groupBy as $key => $value) {
+            if (null === $value) {
+                continue;
+            }
+
+            // Add the contents of groups to new ChoiceGroupView instances
+            if (is_array($value)) {
+                $preferredViewsForGroup = array();
+                $otherViewsForGroup = array();
+
+                self::addChoiceViewsGroupedBy(
+                    $value,
+                    $label,
+                    $choices,
+                    $keys,
+                    $index,
+                    $attr,
+                    $isPreferred,
+                    $preferredViewsForGroup,
+                    $otherViewsForGroup
+                );
+
+                if (count($preferredViewsForGroup) > 0) {
+                    $preferredViews[$key] = new ChoiceGroupView($key, $preferredViewsForGroup);
+                }
+
+                if (count($otherViewsForGroup) > 0) {
+                    $otherViews[$key] = new ChoiceGroupView($key, $otherViewsForGroup);
+                }
+
+                continue;
+            }
+
+            // Add ungrouped items directly
+            self::addChoiceView(
+                $choices[$value],
+                $value,
+                $label,
+                $keys,
+                $index,
+                $attr,
+                $isPreferred,
+                $preferredViews,
+                $otherViews
+            );
+        }
+    }
+
+    private static function addChoiceViewGroupedBy($groupBy, $choice, $value, $label, $keys, &$index, $attr, $isPreferred, &$preferredViews, &$otherViews)
+    {
+        $groupLabel = call_user_func($groupBy, $choice, $keys[$value], $value);
+
+        if (null === $groupLabel) {
+            // If the callable returns null, don't group the choice
+            self::addChoiceView(
+                $choice,
+                $value,
+                $label,
+                $keys,
+                $index,
+                $attr,
+                $isPreferred,
+                $preferredViews,
+                $otherViews
+            );
+
+            return;
+        }
+
+        $groupLabel = (string) $groupLabel;
+
+        // Initialize the group views if necessary. Unnecessarily built group
+        // views will be cleaned up at the end of createView()
+        if (!isset($preferredViews[$groupLabel])) {
+            $preferredViews[$groupLabel] = new ChoiceGroupView($groupLabel);
+            $otherViews[$groupLabel] = new ChoiceGroupView($groupLabel);
+        }
+
+        self::addChoiceView(
+            $choice,
+            $value,
+            $label,
+            $keys,
+            $index,
+            $attr,
+            $isPreferred,
+            $preferredViews[$groupLabel]->choices,
+            $otherViews[$groupLabel]->choices
+        );
+    }
+}

vendor/symfony/form/ChoiceList/Factory/PropertyAccessDecorator.php

@@ -0,0 +1,229 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Form\ChoiceList\Factory;
+
+use Symfony\Component\Form\ChoiceList\ChoiceListInterface;
+use Symfony\Component\Form\ChoiceList\Loader\ChoiceLoaderInterface;
+use Symfony\Component\Form\ChoiceList\View\ChoiceListView;
+use Symfony\Component\PropertyAccess\Exception\UnexpectedTypeException;
+use Symfony\Component\PropertyAccess\PropertyAccess;
+use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
+use Symfony\Component\PropertyAccess\PropertyPath;
+
+/**
+ * Adds property path support to a choice list factory.
+ *
+ * Pass the decorated factory to the constructor:
+ *
+ * ```php
+ * $decorator = new PropertyAccessDecorator($factory);
+ * ```
+ *
+ * You can now pass property paths for generating choice values, labels, view
+ * indices, HTML attributes and for determining the preferred choices and the
+ * choice groups:
+ *
+ * ```php
+ * // extract values from the $value property
+ * $list = $createListFromChoices($objects, 'value');
+ * ```
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+class PropertyAccessDecorator implements ChoiceListFactoryInterface
+{
+    /**
+     * @var ChoiceListFactoryInterface
+     */
+    private $decoratedFactory;
+
+    /**
+     * @var PropertyAccessorInterface
+     */
+    private $propertyAccessor;
+
+    /**
+     * Decorates the given factory.
+     *
+     * @param ChoiceListFactoryInterface     $decoratedFactory The decorated factory
+     * @param null|PropertyAccessorInterface $propertyAccessor The used property accessor
+     */
+    public function __construct(ChoiceListFactoryInterface $decoratedFactory, PropertyAccessorInterface $propertyAccessor = null)
+    {
+        $this->decoratedFactory = $decoratedFactory;
+        $this->propertyAccessor = $propertyAccessor ?: PropertyAccess::createPropertyAccessor();
+    }
+
+    /**
+     * Returns the decorated factory.
+     *
+     * @return ChoiceListFactoryInterface The decorated factory
+     */
+    public function getDecoratedFactory()
+    {
+        return $this->decoratedFactory;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @param array|\Traversable                $choices The choices
+     * @param null|callable|string|PropertyPath $value   The callable or path for
+     *                                                   generating the choice values
+     *
+     * @return ChoiceListInterface The choice list
+     */
+    public function createListFromChoices($choices, $value = null)
+    {
+        if (is_string($value) && !is_callable($value)) {
+            $value = new PropertyPath($value);
+        } elseif (is_string($value) && is_callable($value)) {
+            @trigger_error('Passing callable strings is deprecated since version 3.1 and PropertyAccessDecorator will treat them as property paths in 4.0. You should use a "\Closure" instead.', E_USER_DEPRECATED);
+        }
+
+        if ($value instanceof PropertyPath) {
+            $accessor = $this->propertyAccessor;
+            $value = function ($choice) use ($accessor, $value) {
+                // The callable may be invoked with a non-object/array value
+                // when such values are passed to
+                // ChoiceListInterface::getValuesForChoices(). Handle this case
+                // so that the call to getValue() doesn't break.
+                if (is_object($choice) || is_array($choice)) {
+                    return $accessor->getValue($choice, $value);
+                }
+            };
+        }
+
+        return $this->decoratedFactory->createListFromChoices($choices, $value);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @param ChoiceLoaderInterface             $loader The choice loader
+     * @param null|callable|string|PropertyPath $value  The callable or path for
+     *                                                  generating the choice values
+     *
+     * @return ChoiceListInterface The choice list
+     */
+    public function createListFromLoader(ChoiceLoaderInterface $loader, $value = null)
+    {
+        if (is_string($value) && !is_callable($value)) {
+            $value = new PropertyPath($value);
+        } elseif (is_string($value) && is_callable($value)) {
+            @trigger_error('Passing callable strings is deprecated since version 3.1 and PropertyAccessDecorator will treat them as property paths in 4.0. You should use a "\Closure" instead.', E_USER_DEPRECATED);
+        }
+
+        if ($value instanceof PropertyPath) {
+            $accessor = $this->propertyAccessor;
+            $value = function ($choice) use ($accessor, $value) {
+                // The callable may be invoked with a non-object/array value
+                // when such values are passed to
+                // ChoiceListInterface::getValuesForChoices(). Handle this case
+                // so that the call to getValue() doesn't break.
+                if (is_object($choice) || is_array($choice)) {
+                    return $accessor->getValue($choice, $value);
+                }
+            };
+        }
+
+        return $this->decoratedFactory->createListFromLoader($loader, $value);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @param ChoiceListInterface                     $list             The choice list
+     * @param null|array|callable|string|PropertyPath $preferredChoices The preferred choices
+     * @param null|callable|string|PropertyPath       $label            The callable or path generating the choice labels
+     * @param null|callable|string|PropertyPath       $index            The callable or path generating the view indices
+     * @param null|callable|string|PropertyPath       $groupBy          The callable or path generating the group names
+     * @param null|array|callable|string|PropertyPath $attr             The callable or path generating the HTML attributes
+     *
+     * @return ChoiceListView The choice list view
+     */
+    public function createView(ChoiceListInterface $list, $preferredChoices = null, $label = null, $index = null, $groupBy = null, $attr = null)
+    {
+        $accessor = $this->propertyAccessor;
+
+        if (is_string($label) && !is_callable($label)) {
+            $label = new PropertyPath($label);
+        } elseif (is_string($label) && is_callable($label)) {
+            @trigger_error('Passing callable strings is deprecated since version 3.1 and PropertyAccessDecorator will treat them as property paths in 4.0. You should use a "\Closure" instead.', E_USER_DEPRECATED);
+        }
+
+        if ($label instanceof PropertyPath) {
+            $label = function ($choice) use ($accessor, $label) {
+                return $accessor->getValue($choice, $label);
+            };
+        }
+
+        if (is_string($preferredChoices) && !is_callable($preferredChoices)) {
+            $preferredChoices = new PropertyPath($preferredChoices);
+        } elseif (is_string($preferredChoices) && is_callable($preferredChoices)) {
+            @trigger_error('Passing callable strings is deprecated since version 3.1 and PropertyAccessDecorator will treat them as property paths in 4.0. You should use a "\Closure" instead.', E_USER_DEPRECATED);
+        }
+
+        if ($preferredChoices instanceof PropertyPath) {
+            $preferredChoices = function ($choice) use ($accessor, $preferredChoices) {
+                try {
+                    return $accessor->getValue($choice, $preferredChoices);
+                } catch (UnexpectedTypeException $e) {
+                    // Assume not preferred if not readable
+                    return false;
+                }
+            };
+        }
+
+        if (is_string($index) && !is_callable($index)) {
+            $index = new PropertyPath($index);
+        } elseif (is_string($index) && is_callable($index)) {
+            @trigger_error('Passing callable strings is deprecated since version 3.1 and PropertyAccessDecorator will treat them as property paths in 4.0. You should use a "\Closure" instead.', E_USER_DEPRECATED);
+        }
+
+        if ($index instanceof PropertyPath) {
+            $index = function ($choice) use ($accessor, $index) {
+                return $accessor->getValue($choice, $index);
+            };
+        }
+
+        if (is_string($groupBy) && !is_callable($groupBy)) {
+            $groupBy = new PropertyPath($groupBy);
+        } elseif (is_string($groupBy) && is_callable($groupBy)) {
+            @trigger_error('Passing callable strings is deprecated since version 3.1 and PropertyAccessDecorator will treat them as property paths in 4.0. You should use a "\Closure" instead.', E_USER_DEPRECATED);
+        }
+
+        if ($groupBy instanceof PropertyPath) {
+            $groupBy = function ($choice) use ($accessor, $groupBy) {
+                try {
+                    return $accessor->getValue($choice, $groupBy);
+                } catch (UnexpectedTypeException $e) {
+                    // Don't group if path is not readable
+                }
+            };
+        }
+
+        if (is_string($attr) && !is_callable($attr)) {
+            $attr = new PropertyPath($attr);
+        } elseif (is_string($attr) && is_callable($attr)) {
+            @trigger_error('Passing callable strings is deprecated since version 3.1 and PropertyAccessDecorator will treat them as property paths in 4.0. You should use a "\Closure" instead.', E_USER_DEPRECATED);
+        }
+
+        if ($attr instanceof PropertyPath) {
+            $attr = function ($choice) use ($accessor, $attr) {
+                return $accessor->getValue($choice, $attr);
+            };
+        }
+
+        return $this->decoratedFactory->createView($list, $preferredChoices, $label, $index, $groupBy, $attr);
+    }
+}

vendor/symfony/form/ChoiceList/LazyChoiceList.php

@@ -0,0 +1,203 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Form\ChoiceList;
+
+use Symfony\Component\Form\ChoiceList\Loader\ChoiceLoaderInterface;
+
+/**
+ * A choice list that loads its choices lazily.
+ *
+ * The choices are fetched using a {@link ChoiceLoaderInterface} instance.
+ * If only {@link getChoicesForValues()} or {@link getValuesForChoices()} is
+ * called, the choice list is only loaded partially for improved performance.
+ *
+ * Once {@link getChoices()} or {@link getValues()} is called, the list is
+ * loaded fully.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+class LazyChoiceList implements ChoiceListInterface
+{
+    /**
+     * The choice loader.
+     *
+     * @var ChoiceLoaderInterface
+     */
+    private $loader;
+
+    /**
+     * The callable creating string values for each choice.
+     *
+     * If null, choices are simply cast to strings.
+     *
+     * @var null|callable
+     */
+    private $value;
+
+    /**
+     * @var ChoiceListInterface|null
+     *
+     * @deprecated Since 3.1, to be removed in 4.0. Cache the choice list in the {@link ChoiceLoaderInterface} instead.
+     */
+    private $loadedList;
+
+    /**
+     * @var bool
+     *
+     * @deprecated Flag used for BC layer since 3.1. To be removed in 4.0.
+     */
+    private $loaded = false;
+
+    /**
+     * Creates a lazily-loaded list using the given loader.
+     *
+     * Optionally, a callable can be passed for generating the choice values.
+     * The callable receives the choice as first and the array key as the second
+     * argument.
+     *
+     * @param ChoiceLoaderInterface $loader The choice loader
+     * @param null|callable         $value  The callable generating the choice
+     *                                      values
+     */
+    public function __construct(ChoiceLoaderInterface $loader, callable $value = null)
+    {
+        $this->loader = $loader;
+        $this->value = $value;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getChoices()
+    {
+        if ($this->loaded) {
+            // We can safely invoke the {@link ChoiceLoaderInterface} assuming it has the list
+            // in cache when the lazy list is already loaded
+            if ($this->loadedList !== $this->loader->loadChoiceList($this->value)) {
+                @trigger_error(sprintf('Caching the choice list in %s is deprecated since 3.1 and will not happen in 4.0. Cache the list in the %s instead.', __CLASS__, ChoiceLoaderInterface::class), E_USER_DEPRECATED);
+            }
+
+            return $this->loadedList->getChoices();
+        }
+
+        // BC
+        $this->loadedList = $this->loader->loadChoiceList($this->value);
+        $this->loaded = true;
+
+        return $this->loadedList->getChoices();
+        // In 4.0 keep the following line only:
+        // return $this->loader->loadChoiceList($this->value)->getChoices()
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getValues()
+    {
+        if ($this->loaded) {
+            // Check whether the loader has the same cache
+            if ($this->loadedList !== $this->loader->loadChoiceList($this->value)) {
+                @trigger_error(sprintf('Caching the choice list in %s is deprecated since 3.1 and will not happen in 4.0. Cache the list in the %s instead.', __CLASS__, ChoiceLoaderInterface::class), E_USER_DEPRECATED);
+            }
+
+            return $this->loadedList->getValues();
+        }
+
+        // BC
+        $this->loadedList = $this->loader->loadChoiceList($this->value);
+        $this->loaded = true;
+
+        return $this->loadedList->getValues();
+        // In 4.0 keep the following line only:
+        // return $this->loader->loadChoiceList($this->value)->getValues()
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getStructuredValues()
+    {
+        if ($this->loaded) {
+            // Check whether the loader has the same cache
+            if ($this->loadedList !== $this->loader->loadChoiceList($this->value)) {
+                @trigger_error(sprintf('Caching the choice list in %s is deprecated since 3.1 and will not happen in 4.0. Cache the list in the %s instead.', __CLASS__, ChoiceLoaderInterface::class), E_USER_DEPRECATED);
+            }
+
+            return $this->loadedList->getStructuredValues();
+        }
+
+        // BC
+        $this->loadedList = $this->loader->loadChoiceList($this->value);
+        $this->loaded = true;
+
+        return $this->loadedList->getStructuredValues();
+        // In 4.0 keep the following line only:
+        // return $this->loader->loadChoiceList($this->value)->getStructuredValues();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getOriginalKeys()
+    {
+        if ($this->loaded) {
+            // Check whether the loader has the same cache
+            if ($this->loadedList !== $this->loader->loadChoiceList($this->value)) {
+                @trigger_error(sprintf('Caching the choice list in %s is deprecated since 3.1 and will not happen in 4.0. Cache the list in the %s instead.', __CLASS__, ChoiceLoaderInterface::class), E_USER_DEPRECATED);
+            }
+
+            return $this->loadedList->getOriginalKeys();
+        }
+
+        // BC
+        $this->loadedList = $this->loader->loadChoiceList($this->value);
+        $this->loaded = true;
+
+        return $this->loadedList->getOriginalKeys();
+        // In 4.0 keep the following line only:
+        // return $this->loader->loadChoiceList($this->value)->getOriginalKeys();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getChoicesForValues(array $values)
+    {
+        if ($this->loaded) {
+            // Check whether the loader has the same cache
+            if ($this->loadedList !== $this->loader->loadChoiceList($this->value)) {
+                @trigger_error(sprintf('Caching the choice list in %s is deprecated since 3.1 and will not happen in 4.0. Cache the list in the %s instead.', __CLASS__, ChoiceLoaderInterface::class), E_USER_DEPRECATED);
+            }
+
+            return $this->loadedList->getChoicesForValues($values);
+        }
+
+        return $this->loader->loadChoicesForValues($values, $this->value);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getValuesForChoices(array $choices)
+    {
+        if ($this->loaded) {
+            // Check whether the loader has the same cache
+            if ($this->loadedList !== $this->loader->loadChoiceList($this->value)) {
+                @trigger_error(sprintf('Caching the choice list in %s is deprecated since 3.1 and will not happen in 4.0. Cache the list in the %s instead.', __CLASS__, ChoiceLoaderInterface::class), E_USER_DEPRECATED);
+            }
+
+            return $this->loadedList->getValuesForChoices($choices);
+        }
+
+        return $this->loader->loadValuesForChoices($choices, $this->value);
+    }
+}

vendor/symfony/form/ChoiceList/Loader/CallbackChoiceLoader.php

@@ -0,0 +1,77 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Form\ChoiceList\Loader;
+
+use Symfony\Component\Form\ChoiceList\ArrayChoiceList;
+
+/**
+ * Loads an {@link ArrayChoiceList} instance from a callable returning an array of choices.
+ *
+ * @author Jules Pietri <jules@heahprod.com>
+ */
+class CallbackChoiceLoader implements ChoiceLoaderInterface
+{
+    private $callback;
+
+    /**
+     * The loaded choice list.
+     *
+     * @var ArrayChoiceList
+     */
+    private $choiceList;
+
+    /**
+     * @param callable $callback The callable returning an array of choices
+     */
+    public function __construct(callable $callback)
+    {
+        $this->callback = $callback;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function loadChoiceList($value = null)
+    {
+        if (null !== $this->choiceList) {
+            return $this->choiceList;
+        }
+
+        return $this->choiceList = new ArrayChoiceList(call_user_func($this->callback), $value);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function loadChoicesForValues(array $values, $value = null)
+    {
+        // Optimize
+        if (empty($values)) {
+            return array();
+        }
+
+        return $this->loadChoiceList($value)->getChoicesForValues($values);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function loadValuesForChoices(array $choices, $value = null)
+    {
+        // Optimize
+        if (empty($choices)) {
+            return array();
+        }
+
+        return $this->loadChoiceList($value)->getValuesForChoices($choices);
+    }
+}

vendor/symfony/form/ChoiceList/Loader/ChoiceLoaderInterface.php

@@ -0,0 +1,76 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Form\ChoiceList\Loader;
+
+use Symfony\Component\Form\ChoiceList\ChoiceListInterface;
+
+/**
+ * Loads a choice list.
+ *
+ * The methods {@link loadChoicesForValues()} and {@link loadValuesForChoices()}
+ * can be used to load the list only partially in cases where a fully-loaded
+ * list is not necessary.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+interface ChoiceLoaderInterface
+{
+    /**
+     * Loads a list of choices.
+     *
+     * Optionally, a callable can be passed for generating the choice values.
+     * The callable receives the choice as first and the array key as the second
+     * argument.
+     *
+     * @param null|callable $value The callable which generates the values
+     *                             from choices
+     *
+     * @return ChoiceListInterface The loaded choice list
+     */
+    public function loadChoiceList($value = null);
+
+    /**
+     * Loads the choices corresponding to the given values.
+     *
+     * The choices are returned with the same keys and in the same order as the
+     * corresponding values in the given array.
+     *
+     * Optionally, a callable can be passed for generating the choice values.
+     * The callable receives the choice as first and the array key as the second
+     * argument.
+     *
+     * @param string[]      $values An array of choice values. Non-existing
+     *                              values in this array are ignored
+     * @param null|callable $value  The callable generating the choice values
+     *
+     * @return array An array of choices
+     */
+    public function loadChoicesForValues(array $values, $value = null);
+
+    /**
+     * Loads the values corresponding to the given choices.
+     *
+     * The values are returned with the same keys and in the same order as the
+     * corresponding choices in the given array.
+     *
+     * Optionally, a callable can be passed for generating the choice values.
+     * The callable receives the choice as first and the array key as the second
+     * argument.
+     *
+     * @param array         $choices An array of choices. Non-existing choices in
+     *                               this array are ignored
+     * @param null|callable $value   The callable generating the choice values
+     *
+     * @return string[] An array of choice values
+     */
+    public function loadValuesForChoices(array $choices, $value = null);
+}

vendor/symfony/form/ChoiceList/View/ChoiceGroupView.php

@@ -0,0 +1,57 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Form\ChoiceList\View;
+
+/**
+ * Represents a group of choices in templates.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+class ChoiceGroupView implements \IteratorAggregate
+{
+    /**
+     * The label of the group.
+     *
+     * @var string
+     */
+    public $label;
+
+    /**
+     * The choice views in the group.
+     *
+     * @var ChoiceGroupView[]|ChoiceView[]
+     */
+    public $choices;
+
+    /**
+     * Creates a new choice group view.
+     *
+     * @param string                         $label   The label of the group
+     * @param ChoiceGroupView[]|ChoiceView[] $choices The choice views in the
+     *                                                group.
+     */
+    public function __construct($label, array $choices = array())
+    {
+        $this->label = $label;
+        $this->choices = $choices;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return self[]|ChoiceView[]
+     */
+    public function getIterator()
+    {
+        return new \ArrayIterator($this->choices);
+    }
+}

vendor/symfony/form/ChoiceList/View/ChoiceListView.php

@@ -0,0 +1,71 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Form\ChoiceList\View;
+
+/**
+ * Represents a choice list in templates.
+ *
+ * A choice list contains choices and optionally preferred choices which are
+ * displayed in the very beginning of the list. Both choices and preferred
+ * choices may be grouped in {@link ChoiceGroupView} instances.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+class ChoiceListView
+{
+    /**
+     * The choices.
+     *
+     * @var ChoiceGroupView[]|ChoiceView[]
+     */
+    public $choices;
+
+    /**
+     * The preferred choices.
+     *
+     * @var ChoiceGroupView[]|ChoiceView[]
+     */
+    public $preferredChoices;
+
+    /**
+     * Creates a new choice list view.
+     *
+     * @param ChoiceGroupView[]|ChoiceView[] $choices          The choice views
+     * @param ChoiceGroupView[]|ChoiceView[] $preferredChoices The preferred
+     *                                                         choice views.
+     */
+    public function __construct(array $choices = array(), array $preferredChoices = array())
+    {
+        $this->choices = $choices;
+        $this->preferredChoices = $preferredChoices;
+    }
+
+    /**
+     * Returns whether a placeholder is in the choices.
+     *
+     * A placeholder must be the first child element, not be in a group and have an empty value.
+     *
+     * @return bool
+     */
+    public function hasPlaceholder()
+    {
+        if ($this->preferredChoices) {
+            $firstChoice = reset($this->preferredChoices);
+
+            return $firstChoice instanceof ChoiceView && '' === $firstChoice->value;
+        }
+
+        $firstChoice = reset($this->choices);
+
+        return $firstChoice instanceof ChoiceView && '' === $firstChoice->value;
+    }
+}

vendor/symfony/form/ChoiceList/View/ChoiceView.php

@@ -0,0 +1,64 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Form\ChoiceList\View;
+
+/**
+ * Represents a choice in templates.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+class ChoiceView
+{
+    /**
+     * The label displayed to humans.
+     *
+     * @var string
+     */
+    public $label;
+
+    /**
+     * The view representation of the choice.
+     *
+     * @var string
+     */
+    public $value;
+
+    /**
+     * The original choice value.
+     *
+     * @var mixed
+     */
+    public $data;
+
+    /**
+     * Additional attributes for the HTML tag.
+     *
+     * @var array
+     */
+    public $attr;
+
+    /**
+     * Creates a new choice view.
+     *
+     * @param mixed  $data  The original choice
+     * @param string $value The view representation of the choice
+     * @param string $label The label displayed to humans
+     * @param array  $attr  Additional attributes for the HTML tag
+     */
+    public function __construct($data, $value, $label, array $attr = array())
+    {
+        $this->data = $data;
+        $this->value = $value;
+        $this->label = $label;
+        $this->attr = $attr;
+    }
+}