Ticket #13621: ticket13621.diff

django/contrib/admin/options.py

@@ -2 +2 @@
 from django.forms.formsets import all_valid
 from django.forms.models import modelform_factory, modelformset_factory, inlineformset_factory
 from django.forms.models import BaseInlineFormSet
+from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.admin import widgets
 from django.contrib.admin import helpers
@@ -116 +117 @@
         for klass in db_field.__class__.mro():
             if klass in self.formfield_overrides:
                 kwargs = dict(self.formfield_overrides[klass], **kwargs)
+                if settings.USE_L10N and 'localize' not in kwargs:
+                    kwargs['localize']=True
                 return db_field.formfield(**kwargs)
 
         # For any other type of field, just call its formfield() method.
+        if settings.USE_L10N and 'localize' not in kwargs:
+            kwargs['localize'] = True
         return db_field.formfield(**kwargs)
 
     def formfield_for_choice_field(self, db_field, request=None, **kwargs):

django/forms/fields.py

@@ -107 +107 @@
         self.localize = localize
         if self.localize:
             widget.is_localized = True
+        if hasattr(self, 'input_formats'):
+            widget.input_formats = self.input_formats
 
         # Hook into self.widget_attrs() for any Field-specific HTML attributes.
         extra_attrs = self.widget_attrs(widget)
@@ -323 +325 @@
     }
 
     def __init__(self, input_formats=None, *args, **kwargs):
-        super(DateField, self).__init__(*args, **kwargs)
         self.input_formats = input_formats
+        super(DateField, self).__init__(*args, **kwargs)
 
     def to_python(self, value):
         """
@@ -351 +353 @@
     }
 
     def __init__(self, input_formats=None, *args, **kwargs):
-        super(TimeField, self).__init__(*args, **kwargs)
         self.input_formats = input_formats
+        super(TimeField, self).__init__(*args, **kwargs)
 
     def to_python(self, value):
         """
@@ -377 +379 @@
     }
 
     def __init__(self, input_formats=None, *args, **kwargs):
-        super(DateTimeField, self).__init__(*args, **kwargs)
         self.input_formats = input_formats
+        super(DateTimeField, self).__init__(*args, **kwargs)
 
     def to_python(self, value):
         """

django/forms/widgets.py

@@ -134 +134 @@
     is_hidden = False          # Determines whether this corresponds to an <input type="hidden">.
     needs_multipart_form = False # Determines does this widget need multipart-encrypted form
     is_localized = False
+    input_formats = None # Input formats explicitly specified for the form field
 
     def __init__(self, attrs=None):
         if attrs is not None:
@@ -302 +303 @@
 
 class DateInput(Input):
     input_type = 'text'
-    format = '%Y-%m-%d'     # '2006-10-25'
+    fallback_format = '%Y-%m-%d'     # '2006-10-25'
+    format = None
 
     def __init__(self, attrs=None, format=None):
         super(DateInput, self).__init__(attrs)
@@ -310 +312 @@
             self.format = format
 
     def _format_value(self, value):
+        base_format = self.format
+        if self.format is None and self.input_formats:
+            base_format = self.input_formats[0]
+
         if self.is_localized:
-            return formats.localize_input(value)
+            return formats.localize_input(value, default=base_format)
         elif hasattr(value, 'strftime'):
             value = datetime_safe.new_date(value)
-            return value.strftime(self.format)
+            return value.strftime(base_format is not None\
+                    and base_format or self.fallback_format)
         return value
 
     def _has_changed(self, initial, data):
@@ -330 +337 @@
 
 class DateTimeInput(Input):
     input_type = 'text'
-    format = '%Y-%m-%d %H:%M:%S'     # '2006-10-25 14:30:59'
+    fallback_format = '%Y-%m-%d %H:%M:%S'     # '2006-10-25 14:30:59'
+    format = None
 
     def __init__(self, attrs=None, format=None):
         super(DateTimeInput, self).__init__(attrs)
@@ -338 +346 @@
             self.format = format
 
     def _format_value(self, value):
+        base_format = self.format
+        if self.format is None and self.input_formats:
+            base_format = self.input_formats[0]
+
         if self.is_localized:
-            return formats.localize_input(value)
+            return formats.localize_input(value, default=base_format)
         elif hasattr(value, 'strftime'):
             value = datetime_safe.new_datetime(value)
-            return value.strftime(self.format)
+            return value.strftime(base_format is not None\
+                    and base_format or self.fallback_format)
         return value
 
     def _has_changed(self, initial, data):
@@ -358 +371 @@
 
 class TimeInput(Input):
     input_type = 'text'
-    format = '%H:%M:%S'     # '14:30:59'
+    fallback_format = '%H:%M:%S'     # '14:30:59'
+    format = None
 
     def __init__(self, attrs=None, format=None):
         super(TimeInput, self).__init__(attrs)
@@ -366 +380 @@
             self.format = format
 
     def _format_value(self, value):
+        base_format = self.format
+        if self.format is None and self.input_formats:
+            base_format = self.input_formats[0]
+
         if self.is_localized:
-            return formats.localize_input(value)
+            return formats.localize_input(value, default=base_format)
         elif hasattr(value, 'strftime'):
-            return value.strftime(self.format)
+            return value.strftime(base_format is not None\
+                    and base_format or self.fallback_format)
         return value
 
     def _has_changed(self, initial, data):
@@ -764 +783 @@
             return [value.date(), value.time().replace(microsecond=0)]
         return [None, None]
 
+    def set_date_format(self, fmt):
+        self.widgets[0].format = fmt
+
+    def set_time_format(self, fmt):
+        self.widgets[1].format = fmt
+
 class SplitHiddenDateTimeWidget(SplitDateTimeWidget):
     """
     A Widget that splits datetime input into two <input type="hidden"> inputs.

tests/regressiontests/forms/fields.py

@@ -350 +350 @@
         self.assertEqual(None, f.clean(''))
         self.assertEqual('None', repr(f.clean('')))
 
+    def test_ticket13621_localized_inputformats(self):
+        # Explicit input formats should have precedence over any
+        # other format specification.
+
+        f = TimeField(input_formats=["%I:%M %p"], widget=TimeInput,
+                localize=True)
+        result = f.clean('1:30 PM')
+        self.assertNotEqual(None, result)
+        text = f.widget._format_value(result)
+        self.assertNotEqual(None, f.clean(text))
+
+        f = DateTimeField(input_formats=["%I:%M %p"], localize=True)
+        result = f.clean('1:30 PM')
+        text = f.widget._format_value(result)
+        f.clean(text)
+        self.assertNotEqual(None, f.clean(text))
+
+        f = DateField(input_formats=["%I:%M %p"], localize=True)
+        result = f.clean('1:30 PM')
+        text = f.widget._format_value(result)
+        f.clean(text)
+        self.assertNotEqual(None, f.clean(text))
+
+        # If no localization should be used and input_formats are
+        # provided, use them (or actually the first in the list).
+
+
+        f = DateTimeField(input_formats=["%I:%M %p"], localize=False)
+        result = f.clean('1:30 PM')
+        text = f.widget._format_value(result)
+        f.clean(text)
+        self.assertNotEqual(None, f.clean(text))
+
+        f = DateField(input_formats=["%I:%M %p"], localize=False)
+        result = f.clean('1:30 PM')
+        text = f.widget._format_value(result)
+        f.clean(text)
+        self.assertNotEqual(None, f.clean(text))
+
+        f = TimeField(widget=TimeInput)
+        result = f.clean('12:30:00')
+        self.assertNotEqual(None, result)
+        text = f.widget._format_value(result)
+        self.assertNotEqual(None, f.clean(text))
+
+        f = DateTimeField()
+        result = f.clean('2006-10-25 12:30:00')
+        self.assertNotEqual(None, result)
+        text = f.widget._format_value(result)
+        self.assertNotEqual(None, f.clean(text))
+
+    def test_ticket13621_timefield_notlocalized(self):
+        f = TimeField(input_formats=["%I:%M %p"], widget=TimeInput,
+                localize=False)
+        result = f.clean('1:30 PM')
+        self.assertNotEqual(None, result)
+        text = f.widget._format_value(result)
+        self.assertNotEqual(None, f.clean(text))
+
+    def test_ticket13621_datefield_fallback(self):
+        f = DateField(widget=DateInput)
+        result = f.clean('2006-10-25')
+        self.assertNotEqual(None, result)
+        text = f.widget._format_value(result)
+        self.assertNotEqual(None, f.clean(text))
+
+    def test_ticket13621_timefield_globally_localized(self):
+        """
+        Test if the timeinput widgets produces the same output format that it 
+        accepts as input when set using a format module.
+        """
+        from django.utils import formats
+        from django.conf import settings
+        old_setting = settings.USE_L10N
+        settings.USE_L10N = True
+        _get_format_modules = formats.get_format_modules
+        try:
+            # We have to do a bit of mocking here to get into the L10N system
+            # properly.
+            class _GetFormatModules(object):
+                mock_format_modules = None
+
+                def __call__(self, reverse=False):
+                    if self.mock_format_modules is None:
+                        return _get_format_modules(reverse)
+                    return reverse and reversed(self.mock_format_modules)\
+                            or self.mock_format_modules
+
+            class MockFormatModule(object):
+                TIME_INPUT_FORMATS = ["%I:%M %p"]
+                DATE_INPUT_FORMATS = ["%I:%M %p"]
+                DATETIME_INPUT_FORMATS = ["%I:%M %p"]
+
+            formats.get_format_modules = _GetFormatModules()
+            formats.get_format_modules.mock_format_modules = [
+                    MockFormatModule()]
+
+            f = TimeField(localize=True)
+            result = f.clean('1:30 PM')
+            f.clean(f.widget._format_value(result))
+
+            f = DateField(localize=True)
+            result = f.clean('1:30 PM')
+            f.clean(f.widget._format_value(result))
+
+            f = DateTimeField(localize=True)
+            result = f.clean('1:30 PM')
+            f.clean(f.widget._format_value(result))
+
+            # If an explicit input format is provided, use that
+
+            f = TimeField(input_formats=["%I"], localize=True)
+            result = f.clean('1')
+            f.clean(f.widget._format_value(result))
+
+            f = DateField(input_formats=["%I"], localize=True)
+            result = f.clean('1')
+            f.clean(f.widget._format_value(result))
+
+            f = DateTimeField(input_formats=["%I"], localize=True)
+            result = f.clean('1')
+            f.clean(f.widget._format_value(result))
+        finally:
+            formats.get_format_modules = _get_format_modules
+            settings.USE_L10N = old_setting
+
+
     # RegexField ##################################################################
 
     def test_regexfield_27(self):