[Form] Fix ChoiceType options

Author: HeahDude

reference/forms/types/choice.rst

@@ -70,10 +70,21 @@ This will create a ``select`` drop-down like this:
 .. image:: /images/reference/form/choice-example1.png
    :align: center
 
-If the user selects ``No``, the form will return ``false`` for this field. Similarly,
-if the starting data for this field is ``true``, then ``Yes`` will be auto-selected.
-In other words, the **value** of each item is the value you want to get/set in PHP
-code, while the **key** is what will be shown to the user.
+The model data of this field, the **choice** may be any of the ``choices`` option
+values, while **keys** are used as default label that the user will see and select.
+If the user selects ``No``, the form will return a string representation of that
+choice, a string **value** (html attribute) which is by default the **choice** data
+casted to string.
+Hence, when choices are objects, either they should implement ``__toString()``
+method or the option ``choice_value`` should be defined.
+When the **choices** cannot be casted to string or when ``choice_value`` returns
+either ``null`` or non unique values an incrementing integer is used as **value**.
+
+If the starting data for this field is ``true``, then ``Yes`` will be auto-selected.
+In other words, each value of the ``choices`` option is the **choice** data you
+want to deal with in PHP code, while the **key** is the default label that will be
+shown to the user and the **value** is the string that will be submitted to the
+form and used in the template for the corresponding html attribute.
 
 .. caution::
 
@@ -83,40 +94,68 @@ code, while the **key** is what will be shown to the user.
     and will be removed in 3.0. To read about the old API, read an older version of
     the docs.
 
+.. note::
+
+    Pre selected choices will depend on the **data** passed to field and the values of
+    the ``choices`` option. However submitted choices will depend on the **string**
+    matching the **choice**. In the example above, the default values falls back on an
+    incrementing integer because ``null`` cannot be casted to string.
+    You should consider it as well when dealing with ``emtpy_data`` option::
+
+        $builder->add('isAttending', 'choice', array(
+            'choices'  => array(
+                'Maybe' => null,
+                'Yes' => true,
+                'No' => false,
+            ),
+            'choices_as_values' => true,
+            'data' => true, // pre selected choice
+            'empty_data' => '1', // default submitted value
+        ));
+
+    Also note that as a ``scalar``, ``false`` string **value** is by default ``"0"``
+    to avoid conflict with placeholder value which is always an empty string.
+
 Advanced Example (with Objects!)
 --------------------------------
 
 This field has a *lot* of options and most control how the field is displayed. In
 this example, the underlying data is some ``Category`` object that has a ``getName()``
 method::
 
-    $builder->add('category', 'choice', [
-        'choices' => [
+    $builder->add('category', 'choice', array(
+        'choices' => array(
             new Category('Cat1'),
             new Category('Cat2'),
             new Category('Cat3'),
             new Category('Cat4'),
-        ],
+        ),
         'choices_as_values' => true,
-        'choice_label' => function($category, $key, $index) {
+        'choice_label' => function($category, $key, $value) {
             /** @var Category $category */
             return strtoupper($category->getName());
         },
-        'choice_attr' => function($category, $key, $index) {
-            return ['class' => 'category_'.strtolower($category->getName())];
+        'choice_attr' => function($category, $key, $value) {
+            return array('class' => 'category_'.strtolower($category->getName()));
         },
-        'group_by' => function($category, $key, $index) {
+        'group_by' => function($category, $key, $value) {
             // randomly assign things into 2 groups
             return rand(0, 1) == 1 ? 'Group A' : 'Group B'
         },
-        'preferred_choices' => function($category, $key, $index) {
+        'preferred_choices' => function($category, $key, $value) {
             return $category->getName() == 'Cat2' || $category->getName() == 'Cat3';
         },
-    ]);
+    ));
 
 You can also customize the `choice_name`_ and `choice_value`_ of each choice if
 you need further HTML customization.
 
+.. caution::
+
+    We avoid type hinting ``Category`` in this example as it may conflict
+    if the placeholder is passed, also you should test whether ``$choice``
+    is ``null`` before calling any method or object property.
+
 .. _forms-reference-choice-tags:
 
 .. include:: /reference/forms/types/options/select_how_rendered.rst.inc
@@ -135,19 +174,19 @@ Grouping Options
 
 You can easily "group" options in a select by passing a multi-dimensional choices array::
 
-    $builder->add('stockStatus', 'choice', [
-        'choices' => [
-            'Main Statuses' => [
+    $builder->add('stockStatus', 'choice', array(
+        'choices' => array(
+            'Main Statuses' => array(
                 'Yes' => 'stock_yes',
                 'No' => 'stock_no',
-            ],
-            'Out of Stock Statuses' => [
+            ),
+            'Out of Stock Statuses' => array(
                 'Backordered' => 'stock_backordered',
                 'Discontinued' => 'stock_discontinued',
-            ]
-        ],
+            ),
+        ),
         'choices_as_values' => true,
-    );
+    ));
 
 .. image:: /images/reference/form/choice-example4.png
    :align: center
@@ -160,18 +199,24 @@ Field Options
 choices
 ~~~~~~~
 
-**type**: ``array`` **default**: ``array()``
+**type**: ``array`` or ``\Traversable`` **default**: ``array()``
 
 This is the most basic way to specify the choices that should be used
 by this field. The ``choices`` option is an array, where the array key
-is the item's label and the array value is the item's value::
+is the choice's label and the array value is the choice's data::
 
     $builder->add('inStock', 'choice', array(
-        'choices' => array('In Stock' => true, 'Out of Stock' => false),
+        'choices' => array(
+            'In Stock' => true,
+            'Out of Stock' => false,
+        ),
         // always include this
         'choices_as_values' => true,
     ));
 
+The component will try to cast the choices data to string to use it in view
+format, but you can customize it using the `choice_value`_ option.
+
 .. include:: /reference/forms/types/options/choice_attr.rst.inc
 
 .. _reference-form-choice-label:
@@ -229,9 +274,14 @@ choice_loader
 
 **type**: :class:`Symfony\\Component\\Form\\ChoiceList\\Loader\\ChoiceLoaderInterface`
 
-The ``choice_loader`` can be used to only partially load the choices in cases where
-a fully-loaded list is not necessary. This is only needed in advanced cases and
-would replace the ``choices`` option.
+The ``choice_loader`` can be used to load the choices form a data source with a
+custom logic (e.g query language) such as database or search engine.
+The list will be fully loaded to display the form, but while submission only the
+submitted choices will be loaded.
+
+Also, the :class:``Symfony\\Component\\Form\\ChoiceList\\Factory\\ChoiceListFactoryInterface`` will cache the choice list
+so the same :class:``Symfony\\Component\\Form\\ChoiceList\\Loader\\ChoiceLoaderInterface`` can be used in different fields with more performance
+(reducing N queries to 1).
 
 .. include:: /reference/forms/types/options/choice_name.rst.inc
 
@@ -250,8 +300,8 @@ choices_as_values
 
 The ``choices_as_values`` option was added to keep backward compatibility with the
 *old* way of handling the ``choices`` option. When set to ``false`` (or omitted),
-the choice keys are used as the underlying value and the choice values are shown
-to the user.
+the choice keys are used as the view value and the choice values are shown
+to the user as label.
 
 * Before 2.7 (and deprecated now)::
 
@@ -271,12 +321,11 @@ to the user.
         'choices_as_values' => true,
     ));
 
-In Symfony 3.0, the ``choices_as_values`` option doesn't exist, but the ``choice``
-type behaves as if it were set to true:
+As of Symfony 3.0, the ``choices_as_values`` option is ``true`` by default:
 
 * Default for 3.0::
 
-    $builder->add('gender', 'choice', array(
+    $builder->add('gender', 'Symfony\Component\Form\Extension\Core\Type\ChoiceType', array(
         'choices' => array('Male' => 'm', 'Female' => 'f'),
     ));
 

reference/forms/types/options/choice_attr.rst.inc

@@ -4,13 +4,12 @@ choice_attr
 .. versionadded:: 2.7
     The ``choice_attr`` option was introduced in Symfony 2.7.
 
-**type**: ``array``, ``callable`` or ``string`` **default**: ``array()``
+**type**: ``array``, ``callable``, ``string`` or :class:``Symfony\\Component\\PropertyAccess\\PropertyPath`` **default**: ``array()``
 
-Use this to add additional HTML attributes to each choice. This can be an array
-of attributes (if they are the same for each choice), a callable or a property path
-(just like `choice_label`_).
+Use this to add additional HTML attributes to each choice. This can be used as
+a callable or a property path (just like `choice_label`_).
 
-If an array, the keys of the ``choices`` array must be used as keys::
+Also, if used as an array, the keys of the ``choices`` array must be used as keys::
 
     $builder->add('attending', 'choice', array(
         'choices' => array(
@@ -19,8 +18,21 @@ If an array, the keys of the ``choices`` array must be used as keys::
             'Maybe' => null,
         ),
         'choices_as_values' => true,
-        'choice_attr' => function($val, $key, $index) {
-            // adds a class like attending_yes, attending_no, etc
-            return ['class' => 'attending_'.strtolower($key)];
+        'choice_attr' => array(
+            // will be used for the second choice
+            'No' => array('class' => 'singular_choice_option');
+        ),
+    ));
+
+    $builder->add('attending', 'choice', array(
+        'choices' => array(
+            'Yes' => true,
+            'No' => false,
+            'Maybe' => null,
+        ),
+        'choices_as_values' => true,
+        'choice_attr' => function() {
+            // will be used for all choices
+            return array('class' => 'choice_option');
         },
     ));

reference/forms/types/options/choice_label.rst.inc

@@ -4,11 +4,29 @@ choice_label
 .. versionadded:: 2.7
     The ``choice_label`` option was introduced in Symfony 2.7.
 
-**type**: ``string``, ``callable`` or ``false`` **default**: ``null``
+**type**: ``string``, ``callable``, :class:``Symfony\\Component\\PropertyAccess\\PropertyPath`` or ``false`` **default**: ``null``
 
 Normally, the array key of each item in the ``choices`` option is used as the
 text that's shown to the user. The ``choice_label`` option allows you to take
-more control::
+more control.
+
+If your choice values are objects (default in ``EntityType``), then ``choice_label``
+can be a string :ref:`property path <reference-form-option-property-path>`. Imagine you have some
+``Status`` class with a ``getDisplayName()`` method::
+
+    $builder->add('attending', 'choice', array(
+        'choices' => array(
+            new Status(Status::YES),
+            new Status(Status::NO),
+            new Status(Status::MAYBE),
+        ),
+        'choices_as_values' => true,
+        'choice_label' => 'displayName',
+    ));
+
+If set as a callable is called for each choice, passing you its model data ``$choice``
+and the ``$key`` from the choices array (default label). ``$value`` is either
+`choice_value`_ option value when defined or the default string value of the choice::
 
     $builder->add('attending', 'choice', array(
         'choices' => array(
@@ -17,8 +35,8 @@ more control::
             'maybe' => null,
         ),
         'choices_as_values' => true,
-        'choice_label' => function ($value, $key, $index) {
-            if ($value == true) {
+        'choice_label' => function ($choice, $key, $value) {
+            if (true === $choice) {
                 return 'Definitely!';
             }
             return strtoupper($key);
@@ -28,26 +46,20 @@ more control::
         },
     ));
 
-This method is called for *each* choice, passing you the choice ``$value`` and the
-``$key`` from the choices array (``$index`` is related to `choice_value`_). This
-will give you:
+The example above would output:
 
 .. image:: /images/reference/form/choice-example2.png
    :align: center
 
-If your choice values are objects, then ``choice_label`` can also be a
-:ref:`property path <reference-form-option-property-path>`. Imagine you have some
-``Status`` class with a ``getDisplayName()`` method::
-
-    $builder->add('attending', 'choice', array(
-        'choices' => array(
-            new Status(Status::YES),
-            new Status(Status::NO),
-            new Status(Status::MAYBE),
-        ),
-        'choices_as_values' => true,
-        'choice_label' => 'displayName',
-    ));
-
 If set to ``false``, all the tag labels will be discarded for radio or checkbox
 inputs. You can also return ``false`` from the callable to discard certain labels.
+
+.. caution::
+
+    If you want to pass a string property path wich is also a callable (e.g 'range'),
+    the component will treat it as a callable. You should pass a :class:``Symfony\\Component\\PropertyAccess\\PropertyPath``
+    object to ensure the expected behavior::
+
+        use Symfony\Component\PropertyAccess\PropertyPath;
+
+        'choice_label' => new PropertyPath('range'),

reference/forms/types/options/choice_name.rst.inc

@@ -4,11 +4,13 @@ choice_name
 .. versionadded:: 2.7
     The ``choice_name`` option was introduced in Symfony 2.7.
 
-**type**: ``callable`` or ``string`` **default**: ``null``
+**type**: ``callable``, ``string`` or :class:``Symfony\\Component\\PropertyAccess\\PropertyPath`` **default**: ``null``
 
-Controls the internal field name of the choice. You normally don't care about this,
-but in some advanced cases, you might. For example, this "name" becomes the index
-of the choice views in the template.
+Controls the internal field name of the choice. You normally don't care about
+this, but in some advanced cases, you might. For example, this "name" becomes
+the index of the choice views in the template.
 
-This can be a callable or a property path. See `choice_label`_ for similar usage.
-If ``null`` is used, an incrementing integer is used as the name.
+This can be a callable or a property path. Both needs to return a non empty
+string, if ``null`` is used, an incrementing integer is used as the name.
+
+See `choice_label`_ for similar usage.