Ticket #12398: 12398-TypedMultipleChoiceField-r11901.diff

django/forms/fields.py

@@ -30 +30 @@
     'BooleanField', 'NullBooleanField', 'ChoiceField', 'MultipleChoiceField',
     'ComboField', 'MultiValueField', 'FloatField', 'DecimalField',
     'SplitDateTimeField', 'IPAddressField', 'FilePathField', 'SlugField',
-    'TypedChoiceField'
+    'TypedChoiceField', 'TypedMultipleChoiceField'
 )
 
 # These values, if given to to_python(), will trigger the self.required check.
@@ -711 +711 @@
                 raise ValidationError(self.error_messages['invalid_choice'] % {'value': val})
         return new_value
 
+class TypedMultipleChoiceField(MultipleChoiceField):
+    def __init__(self, *args, **kwargs):
+        self.coerce = kwargs.pop('coerce', lambda val: val)
+        self.empty_value = kwargs.pop('empty_value', [])
+        super(TypedMultipleChoiceField, self).__init__(*args, **kwargs)
+
+    def clean(self, value):
+        """
+        Validate that the values are in self.choices and can be coerced to the
+        right type.
+        """
+        value = super(TypedMultipleChoiceField, self).clean(value)
+        if not value:
+            return self.empty_value
+
+        # Hack alert: This field is purpose-made to use with Field.to_python as
+        # a coercion function so that ModelForms with choices work. However,
+        # Django's Field.to_python raises
+        # django.core.exceptions.ValidationError, which is a *different*
+        # exception than django.forms.util.ValidationError. So we need to catch
+        # both.
+        new_value = []
+        for choice in value:
+            try:
+                new_value.append(self.coerce(choice))
+            except (ValueError, TypeError, django.core.exceptions.ValidationError):
+                raise ValidationError(self.error_messages['invalid_choice'] % {'value': choice})
+        return new_value
+
 class ComboField(Field):
     """
     A Field whose clean() method calls multiple Field clean() methods.

tests/regressiontests/forms/fields.py

@@ -732 +732 @@
         self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. 6 is not one of the available choices.']", f.clean, ['6'])
         self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. 6 is not one of the available choices.']", f.clean, ['1','6'])
 
+    # TypedMultipleChoiceField ############################################################
+    # TypedMultipleChoiceField is just like MultipleChoiceField, except that coerced types
+    # will be returned:
+
+    def test_typedmultiplechoicefield_71(self):
+        f = TypedMultipleChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=int)
+        self.assertEqual([1], f.clean(['1']))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. 2 is not one of the available choices.']", f.clean, ['2'])
+
+    def test_typedmultiplechoicefield_72(self):
+        # Different coercion, same validation.
+        f = TypedMultipleChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=float)
+        self.assertEqual([1.0], f.clean(['1']))
+
+    def test_typedmultiplechoicefield_73(self):
+        # This can also cause weirdness: be careful (bool(-1) == True, remember)
+        f = TypedMultipleChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=bool)
+        self.assertEqual([True], f.clean(['-1']))
+
+    def test_typedmultiplechoicefield_74(self):
+        # Even more weirdness: if you have a valid choice but your coercion function
+        # can't coerce, you'll still get a validation error. Don't do this!
+        f = TypedMultipleChoiceField(choices=[('A', 'A'), ('B', 'B')], coerce=int)
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. B is not one of the available choices.']", f.clean, ['B'])
+        # Required fields require values
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, [])
+
+    def test_typedmultiplechoicefield_75(self):
+        # Non-required fields aren't required
+        f = TypedMultipleChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=int, required=False)
+        self.assertEqual([], f.clean([]))
+
+    def test_typedmultiplechoicefield_76(self):
+        # If you want cleaning an empty value to return a different type, tell the field
+        f = TypedMultipleChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=int, required=False, empty_value=None)
+        self.assertEqual(None, f.clean([]))
+
     # ComboField ##################################################################
 
     def test_combofield_63(self):

docs/ref/forms/fields.txt

@@ -335 +335 @@
 
 .. class:: TypedChoiceField(**kwargs)
 
-Just like a :class:`ChoiceField`, except :class:`TypedChoiceField` takes an
-extra ``coerce`` argument.
+Just like a :class:`ChoiceField`, except :class:`TypedChoiceField` takes two
+extra arguments, ``coerce`` and ``empty_value``.
 
     * Default widget: ``Select``
     * Empty value: Whatever you've given as ``empty_value``
-    * Normalizes to: the value returned by the ``coerce`` argument.
-    * Validates that the given value exists in the list of choices.
+    * Normalizes to: The value returned by the ``coerce`` argument.
+    * Validates that the given value exists in the list of choices and can be
+      coerced.
     * Error message keys: ``required``, ``invalid_choice``
 
 Takes extra arguments:
@@ -604 +605 @@
       of choices.
     * Error message keys: ``required``, ``invalid_choice``, ``invalid_list``
 
-Takes one extra argument, ``choices``, as for ``ChoiceField``.
+Takes one extra required argument, ``choices``, as for ``ChoiceField``.
 
+``TypedMultipleChoiceField``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. class:: TypedMultipleChoiceField(**kwargs)
+
+Just like a :class:`MultipleChoiceField`, except :class:`TypedMultipleChoiceField`
+takes two extra arguments, ``coerce`` and ``empty_value``.
+
+    * Default widget: ``SelectMultiple``
+    * Empty value: Whatever you've given as ``empty_value``
+    * Normalizes to: A list of values, each returned by the ``coerce`` argument.
+    * Validates that the given values exists in the list of choices and can be
+      coerced.
+    * Error message keys: ``required``, ``invalid_choice``
+
+Takes two extra arguments, ``coerce`` and ``empty_value``, as for ``TypedChoiceField``.
+
 ``NullBooleanField``
 ~~~~~~~~~~~~~~~~~~~~