Renaming of parameters, changing defaults, other fixes for error_types

Author: dyve

AUTHORS.rst

@@ -17,6 +17,7 @@ Contributors
 * Caio Ariede <[email protected]>
 * Fabio C. Barrionuevo da Luz <[email protected]>
 * Fabio Perfetti <[email protected]>
+* Irving Ckam <https://github.com/ickam>
 * Jay Pipes <[email protected]>
 * Jonas Hagstedt <[email protected]>
 * Jordan Starcher <[email protected]>

HISTORY.rst

@@ -8,7 +8,7 @@ Development (in progress)
 +++++++++++++++++++++++++
 
 * Renamed requirements-dev.txt back to requirements.txt because that suits ReadTheDocs better
-* Added 'errors_type' support on bootstrap3_form (thanks @mkoistinen)
+* Added 'error_types' support on bootstrap3_form (thanks @mkoistinen and @ickam)
 
 
 8.2.3 (2017-05-05)

bootstrap3/forms.py

@@ -53,12 +53,12 @@ def render_form(form, **kwargs):
     return renderer_cls(form, **kwargs).render()
 
 
-def render_form_errors(form, type='all', **kwargs):
+def render_form_errors(form, error_types='non_field_errors', **kwargs):
     """
     Render form errors to a Bootstrap layout
     """
     renderer_cls = get_form_renderer(**kwargs)
-    return renderer_cls(form, **kwargs).render_errors(type)
+    return renderer_cls(form, **kwargs).render_errors(error_types)
 
 
 def render_field(field, **kwargs):

bootstrap3/renderers.py

@@ -166,7 +166,7 @@ def __init__(self, form, *args, **kwargs):
         if DBS3_SET_REQUIRED_SET_DISABLED and self.form.empty_permitted:
             self.set_required = False
 
-        self.errors_type = kwargs.get('errors_type', 'all')
+        self.error_types = kwargs.get('error_types', 'non_field_errors')
         self.error_css_class = kwargs.get('error_css_class', None)
         self.required_css_class = kwargs.get('required_css_class', None)
         self.bound_css_class = kwargs.get('bound_css_class', None)
@@ -202,14 +202,16 @@ def get_fields_errors(self):
                 form_errors += field.errors
         return form_errors
 
-    def render_errors(self, type='all'):
+    def render_errors(self, error_types='all'):
         form_errors = []
-        if type == 'all':
+        if error_types == 'all':
             form_errors = self.get_fields_errors() + self.form.non_field_errors()
-        elif type == 'fields':
+        elif error_types == 'field_errors':
             form_errors = self.get_fields_errors()
-        elif type == 'non_fields':
+        elif error_types == 'non_field_errors':
             form_errors = self.form.non_field_errors()
+        elif error_types and error_types != 'none':
+            raise Exception('Illegal value "{}" for error_types.')
 
         if form_errors:
             return render_template_file(
@@ -218,14 +220,14 @@ def render_errors(self, type='all'):
                     'errors': form_errors,
                     'form': self.form,
                     'layout': self.layout,
-                    'type': type,
+                    'error_types': error_types,
                 }
             )
 
         return ''
 
     def _render(self):
-        return self.render_errors(self.errors_type) + self.render_fields()
+        return self.render_errors(self.error_types) + self.render_fields()
 
 
 class FieldRenderer(BaseRenderer):

bootstrap3/templatetags/bootstrap3.py

@@ -318,12 +318,12 @@ def bootstrap_form(*args, **kwargs):
             A list of field names (comma separated) that should not be rendered
             E.g. exclude=subject,bcc
 
-        errors_type
+        error_types
             This controls the types of errors that are rendered above the form.
-            Choices are: "all", "fields", "non_fields" or "none". This will not
+            Choices are: "all", "field_errors", "non_field_errors" or "none". This will not
             affect the display of errors on the fields themselves.
 
-            Default is "all".
+            Default is "non_field_errors".
 
         See bootstrap_field_ for other arguments
 
@@ -352,16 +352,16 @@ def bootstrap_form_errors(*args, **kwargs):
         form
             The form that is to be rendered
 
-        type
+        error_types
             Control which type of errors should be rendered.
 
             One of the following values:
 
                 * ``'all'``
-                * ``'fields'``
-                * ``'non_fields'``
+                * ``'field_errors'``
+                * ``'non_field_errors'``
 
-            :default: ``'all'``
+            :default: ``'non_field_errors'``
 
         layout
             Context value that is available in the template ``bootstrap3/form_errors.html`` as ``layout``.

bootstrap3/tests.py

@@ -38,6 +38,24 @@
 )
 
 
+class SmallTestForm(forms.Form):
+    sender = forms.EmailField(
+        label='Sender © unicode',
+        help_text='E.g., "[email protected]"')
+    subject = forms.CharField(
+        max_length=100,
+        help_text='my_help_text',
+        required=True,
+        widget=forms.TextInput(attrs={'placeholder': 'placeholdertest'}),
+    )
+
+    def clean(self):
+        cleaned_data = super(SmallTestForm, self).clean()
+        raise forms.ValidationError(
+            "This error was added to show the non field errors styling.")
+        return cleaned_data
+
+
 class TestForm(forms.Form):
     """
     Form with a variety of widgets to test bootstrap3 rendering.
@@ -220,30 +238,26 @@ def test_bootstrap_css_tag(self):
             res
         )
 
+    def test_settings_filter(self):
+        res = render_template_with_form('{{ "required_css_class"|bootstrap_setting }}')
+        self.assertEqual(res.strip(), 'bootstrap3-req')
+        res = render_template_with_form('{% if "javascript_in_head"|bootstrap_setting %}head{% else %}body{% endif %}')
+        self.assertEqual(res.strip(), 'head')
 
-def test_settings_filter(self):
-    res = render_template_with_form('{{ "required_css_class"|bootstrap_setting }}')
-    self.assertEqual(res.strip(), 'bootstrap3-req')
-    res = render_template_with_form('{% if "javascript_in_head"|bootstrap_setting %}head{% else %}body{% endif %}')
-    self.assertEqual(res.strip(), 'head')
-
-
-def test_required_class(self):
-    form = TestForm()
-    res = render_template_with_form('{% bootstrap_form form %}', {'form': form})
-    self.assertIn('bootstrap3-req', res)
-
-
-def test_error_class(self):
-    form = TestForm({})
-    res = render_template_with_form('{% bootstrap_form form %}', {'form': form})
-    self.assertIn('bootstrap3-err', res)
+    def test_required_class(self):
+        form = TestForm()
+        res = render_template_with_form('{% bootstrap_form form %}', {'form': form})
+        self.assertIn('bootstrap3-req', res)
 
+    def test_error_class(self):
+        form = TestForm({})
+        res = render_template_with_form('{% bootstrap_form form %}', {'form': form})
+        self.assertIn('bootstrap3-err', res)
 
-def test_bound_class(self):
-    form = TestForm({'sender': 'sender'})
-    res = render_template_with_form('{% bootstrap_form form %}', {'form': form})
-    self.assertIn('bootstrap3-bound', res)
+    def test_bound_class(self):
+        form = TestForm({'sender': 'sender'})
+        res = render_template_with_form('{% bootstrap_form form %}', {'form': form})
+        self.assertIn('bootstrap3-bound', res)
 
 
 class TemplateTest(TestCase):
@@ -379,6 +393,64 @@ def test_bound_class(self):
         )
         self.assertNotIn('bootstrap3-bound', res)
 
+    def test_error_types(self):
+        form = SmallTestForm({'sender': 'sender'})
+
+        pattern = re.compile(r'\s')
+
+        res = render_template_with_form(
+            '{% bootstrap_form form error_types="all" %}',
+            {'form': form}
+        )
+        expected = """
+            <div class="alert alert-danger alert-dismissable alert-link">
+               <button class="close" type="button" data-dismiss="alert" aria-hidden="true">&#215;</button>
+               Enter a valid email address.<br>
+               This field is required.<br>
+               This error was added to show the non field errors styling.
+           </div>
+        """
+        self.assertIn(
+            re.sub(pattern, '', expected),
+            re.sub(pattern, '', res)
+        )
+
+        res = render_template_with_form(
+            '{% bootstrap_form form error_types="non_field_errors" %}',
+            {'form': form}
+        )
+        expected = """
+            <div class="alert alert-danger alert-dismissable alert-link">
+                <button class="close" type="button" data-dismiss="alert" aria-hidden="true">&#215;</button>
+                This error was added to show the non field errors styling.
+            </div>
+     """
+        self.assertIn(
+            re.sub(pattern, '', expected),
+            re.sub(pattern, '', res)
+        )
+        res2 = render_template_with_form(
+            '{% bootstrap_form form %}',
+            {'form': form}
+        )
+        self.assertEqual(res, res2)
+
+        res = render_template_with_form(
+            '{% bootstrap_form form error_types="field_errors" %}',
+            {'form': form}
+        )
+        expected = """
+         <div class="alert alert-danger alert-dismissable alert-link">
+            <button class="close" type="button" data-dismiss="alert" aria-hidden="true">&#215;</button>
+            Enter a valid email address.<br>
+            This field is required.
+        </div>
+     """
+        self.assertIn(
+            re.sub(pattern, '', expected),
+            re.sub(pattern, '', res)
+        )
+
 
 class FieldTest(TestCase):
     def test_illegal_field(self):

demo/demo/settings.py

@@ -116,6 +116,7 @@
     'django.contrib.sites',
     'django.contrib.messages',
     'django.contrib.staticfiles',
+    'django.contrib.admin',
 
     'bootstrap3',
     'demo',