Merge branch 'release/4.7.0'

Author: dyve

HISTORY.rst

@@ -4,18 +4,24 @@ History
 -------
 
 
+4.7.0 (2014-06-04)
+++++++++++++++++++
+
+* `size` option added to formsets, forms, fields and buttons
+
+
 4.6.0 (2014-05-22)
 ++++++++++++++++++
 
-* new bootstrap_formset_errors tag
+* new `bootstrap_formset_errors` tag
 
 
 4.5.0 (2014-05-21)
 ++++++++++++++++++
 
 * bug fixes in formsets
 * new formset renderer
-* new bootstrap_form_errors tag
+* new `bootstrap_form_errors` tag
 
 
 4.4.2 (2014-05-20)
@@ -132,7 +138,7 @@ History
 
 * project refactored
 * added skeleton for creating documentation (fix issue #30)
-* fixed FileField issues
+* fixed `FileField` issues
 
 
 

bootstrap3/__init__.py

@@ -1,3 +1,3 @@
 # -*- coding: utf-8 -*-
 
-__version__ = '4.6.0'
+__version__ = '4.7.0'

bootstrap3/bootstrap.py

@@ -80,23 +80,24 @@ def theme_url():
     return get_bootstrap_setting('theme_url')
 
 
-def get_renderer(renderers, layout):
+def get_renderer(renderers, **kwargs):
+    layout = kwargs.get('layout', '')
     path = renderers.get(layout, renderers['default'])
     mod, cls = path.rsplit(".", 1)
     return getattr(import_module(mod), cls)
 
 
-def get_formset_renderer(layout):
+def get_formset_renderer(**kwargs):
     renderers = get_bootstrap_setting('formset_renderers')
-    return get_renderer(renderers, layout)
+    return get_renderer(renderers, **kwargs)
 
 
-def get_form_renderer(layout):
+def get_form_renderer(**kwargs):
     renderers = get_bootstrap_setting('form_renderers')
-    return get_renderer(renderers, layout)
+    return get_renderer(renderers, **kwargs)
 
 
-def get_field_renderer(layout):
+def get_field_renderer(**kwargs):
     renderers = get_bootstrap_setting('field_renderers')
-    return get_renderer(renderers, layout)
+    return get_renderer(renderers, **kwargs)
 

bootstrap3/forms.py

@@ -2,8 +2,7 @@
 from __future__ import unicode_literals
 
 from django.contrib.admin.widgets import AdminFileWidget
-from django.forms import HiddenInput, FileInput, CheckboxSelectMultiple, Textarea, TextInput, DateInput, Select
-from django.forms.formsets import BaseFormSet
+from django.forms import HiddenInput, FileInput, CheckboxSelectMultiple, Textarea, TextInput
 
 from .bootstrap import get_bootstrap_setting, get_form_renderer, get_field_renderer, get_formset_renderer
 from .text import text_concat, text_value
@@ -15,48 +14,44 @@
 FORM_GROUP_CLASS = 'form-group'
 
 
-def render_formset(formset, layout='', **kwargs):
+def render_formset(formset, **kwargs):
     """
     Render a formset to a Bootstrap layout
     """
-    # if not isinstance(formset, BaseFormSet):
-    #     raise BootstrapError('Parameter "formset" should contain a valid Django FormSet.')
-    # forms = [render_form(f, **kwargs) for f in formset]
-    # return text_value(formset.management_form) + '\n' + '\n'.join(forms)
-    renderer_cls = get_formset_renderer(layout)
-    return renderer_cls(formset, layout, **kwargs).render()
+    renderer_cls = get_formset_renderer(**kwargs)
+    return renderer_cls(formset, **kwargs).render()
 
 
-def render_formset_errors(form, layout='', **kwargs):
+def render_formset_errors(form, **kwargs):
     """
     Render formset errors to a Bootstrap layout
     """
-    renderer_cls = get_formset_renderer(layout)
-    return renderer_cls(form, layout, **kwargs).render_errors()
+    renderer_cls = get_formset_renderer(**kwargs)
+    return renderer_cls(form, **kwargs).render_errors()
 
 
-def render_form(form, layout='', **kwargs):
+def render_form(form, **kwargs):
     """
     Render a formset to a Bootstrap layout
     """
-    renderer_cls = get_form_renderer(layout)
-    return renderer_cls(form, layout, **kwargs).render()
+    renderer_cls = get_form_renderer(**kwargs)
+    return renderer_cls(form, **kwargs).render()
 
 
 def render_form_errors(form, layout='', type='all', **kwargs):
     """
     Render form errors to a Bootstrap layout
     """
-    renderer_cls = get_form_renderer(layout)
-    return renderer_cls(form, layout, **kwargs).render_errors(type)
+    renderer_cls = get_form_renderer(**kwargs)
+    return renderer_cls(form, **kwargs).render_errors(type)
 
 
-def render_field(field, layout='', **kwargs):
+def render_field(field, **kwargs):
     """
     Render a formset to a Bootstrap layout
     """
-    renderer_cls = get_field_renderer(layout)
-    return renderer_cls(field, layout, **kwargs).render()
+    renderer_cls = get_field_renderer(**kwargs)
+    return renderer_cls(field, **kwargs).render()
 
 
 def render_label(content, label_for=None, label_class=None, label_title=''):
@@ -73,18 +68,30 @@ def render_label(content, label_for=None, label_class=None, label_title=''):
     return render_tag('label', attrs=attrs, content=content)
 
 
-def render_button(content, button_type=None, icon=None, button_class=''):
+def render_button(content, button_type=None, icon=None, button_class='', size=''):
     """
     Render a button with content
     """
     attrs = {}
-    attrs['class'] = add_css_class('btn', button_class)
+    classes = add_css_class('btn', button_class)
+    size = text_value(size).lower().strip()
+    if size == 'xs':
+        classes = add_css_class(classes, 'btn-xs')
+    elif size == 'sm' or size == 'small':
+        classes = add_css_class(classes, 'btn-sm')
+    elif size == 'lg' or size == 'large':
+        classes = add_css_class(classes, 'btn-lg')
+    elif size == 'md' or size == 'medium':
+        pass
+    elif size:
+        raise BootstrapError('Parameter "size" should be "xs", "sm", "lg" or empty.')
     if button_type:
         if button_type == 'submit':
-            attrs['class'] = add_css_class(attrs['class'], 'btn-primary')
+            classes = add_css_class(classes, 'btn-primary')
         elif button_type != 'reset' and button_type != 'button':
             raise BootstrapError('Parameter "button_type" should be "submit", "reset", "button" or empty.')
         attrs['type'] = button_type
+    attrs['class'] = classes
     icon_content = render_icon(icon) if icon else ''
     return render_tag('button', attrs=attrs, content=text_concat(icon_content, content, separator=' '))
 

bootstrap3/renderers.py

@@ -19,25 +19,51 @@
                     is_widget_with_placeholder, is_widget_required_attribute, FORM_GROUP_CLASS)
 
 
-class FormsetRenderer(object):
+class BaseRenderer(object):
+
+    def __init__(self, *args, **kwargs):
+        self.layout = kwargs.get('layout', '')
+        self.form_group_class = kwargs.get('form_group_class', FORM_GROUP_CLASS)
+        self.field_class = kwargs.get('field_class', '')
+        self.label_class = kwargs.get('label_class', '')
+        self.show_help = kwargs.get('show_help', True)
+        self.show_label = kwargs.get('show_label', True)
+        self.exclude = kwargs.get('exclude', '')
+        self.set_required = kwargs.get('set_required', True)
+        self.size = self.parse_size(kwargs.get('size', ''))
+
+    def parse_size(self, size):
+        size = text_value(size).lower().strip()
+        if size in ('sm', 'small'):
+            return 'small'
+        if size in ('lg', 'large'):
+            return 'large'
+        if size in ('md', 'medium', ''):
+            return 'medium'
+        raise BootstrapError('Invalid value "%s" for parameter "size".' % size)
+
+    def get_size_class(self):
+        if self.size == 'small':
+            return 'input-sm'
+        if self.size == 'large':
+            return 'input-lg'
+        return ''
+
+
+class FormsetRenderer(BaseRenderer):
     """
     Default formset renderer
     """
 
-    def __init__(self, formset, layout='', form_group_class=FORM_GROUP_CLASS,
-                 field_class='', label_class='', show_help=True, exclude='',
-                 set_required=True):
+    def __init__(self, formset, *args, **kwargs):
         if not isinstance(formset, BaseFormSet):
             raise BootstrapError(
                 'Parameter "formset" should contain a valid Django Formset.')
         self.formset = formset
-        self.layout = layout
-        self.form_group_class = form_group_class
-        self.field_class = field_class
-        self.label_class = label_class
-        self.show_help = show_help
-        self.exclude = exclude
-        self.set_required = set_required
+        super(FormsetRenderer, self).__init__(*args, **kwargs)
+
+    def render_management_form(self):
+        return text_value(self.formset.management_form)
 
     def render_forms(self):
         rendered_forms = []
@@ -69,28 +95,19 @@ def render_errors(self):
         return ''
 
     def render(self):
-        return self.render_errors() + self.render_forms()
-
+        return self.render_errors() + self.render_management_form() + self.render_forms()
 
 
-class FormRenderer(object):
+class FormRenderer(BaseRenderer):
     """
     Default form renderer
     """
 
-    def __init__(self, form, layout='', form_group_class=FORM_GROUP_CLASS,
-                 field_class='', label_class='', show_help=True, exclude='',
-                 set_required=True):
+    def __init__(self, form, *args, **kwargs):
         if not isinstance(form, BaseForm):
             raise BootstrapError('Parameter "form" should contain a valid Django Form.')
         self.form = form
-        self.layout = layout
-        self.form_group_class = form_group_class
-        self.field_class = field_class
-        self.label_class = label_class
-        self.show_help = show_help
-        self.exclude = exclude
-        self.set_required = set_required
+        super(FormRenderer, self).__init__(*args, **kwargs)
 
     def render_fields(self):
         rendered_fields = []
@@ -136,37 +153,30 @@ def render(self):
         return self.render_errors() + self.render_fields()
 
 
-class FieldRenderer(object):
+class FieldRenderer(BaseRenderer):
     """
     Default field renderer
     """
 
-    def __init__(self, field, layout='', form_group_class=FORM_GROUP_CLASS,
-                 field_class=None, label_class=None, show_label=True,
-                 show_help=True, exclude='', set_required=True,
-                 addon_before=None, addon_after=None,
-                 error_css_class='', required_css_class=''):
-        # Only allow BoundField
+    def __init__(self, field, *args, **kwargs):
         if not isinstance(field, BoundField):
             raise BootstrapError('Parameter "field" should contain a valid Django BoundField.')
-
         self.field = field
-        self.layout = layout
-        self.form_group_class = form_group_class
-        self.field_class = field_class
-        self.label_class = label_class
-        self.show_label = show_label
-        self.exclude = exclude
-        self.set_required = set_required
+        super(FieldRenderer, self).__init__(*args, **kwargs)
+
         self.widget = field.field.widget
         self.initial_attrs = self.widget.attrs.copy()
-        self.field_help = text_value(mark_safe(field.help_text)) if show_help and field.help_text else ''
+        self.field_help = text_value(mark_safe(field.help_text)) if self.show_help and field.help_text else ''
         self.field_errors = [conditional_escape(text_value(error)) for error in field.errors]
+
         self.placeholder = field.label
-        self.addon_before = addon_before
-        self.addon_after = addon_after
+
+        self.addon_before = kwargs.get('addon_before', '')
+        self.addon_after = kwargs.get('addon_after', '')
 
         # These are set in Django or in the global BOOTSTRAP3 settings, and they can be overwritten in the template
+        error_css_class = kwargs.get('error_css_class', '')
+        required_css_class = kwargs.get('required_css_class', '')
         if error_css_class:
             self.form_error_class = error_css_class
         else:
@@ -180,13 +190,14 @@ def restore_widget_attrs(self):
         self.widget.attrs = self.initial_attrs
 
     def add_class_attrs(self):
-        self.widget.attrs['class'] = self.widget.attrs.get('class', '')
+        classes = self.widget.attrs.get('class', '')
         if not isinstance(self.widget, (CheckboxInput,
                                         RadioSelect,
                                         CheckboxSelectMultiple,
                                         FileInput)):
-            self.widget.attrs['class'] = add_css_class(
-                self.widget.attrs['class'], 'form-control')
+            classes = add_css_class(classes, 'form-control')
+        classes = add_css_class(classes, self.get_size_class())
+        self.widget.attrs['class'] = classes
 
     def add_placeholder_attrs(self):
         placeholder = self.widget.attrs.get('placeholder', self.placeholder)

bootstrap3/templatetags/bootstrap3.py

@@ -317,7 +317,7 @@ def bootstrap_field(*args, **kwargs):
 
     **example**::
 
-        {% bootstrap_form form_field FIXTHIS %}
+        {% bootstrap_form form_field form.subject %}
     """
     return render_field(*args, **kwargs)
 

bootstrap3/tests.py

@@ -234,6 +234,23 @@ def test_input_group(self):
         self.assertIn('class="input-group-addon">$', res)
         self.assertIn('class="input-group-addon">.00', res)
 
+    def test_size(self):
+        def _test_size(param, klass):
+            res = render_template('{% bootstrap_field form.subject size="' + param + '" %}')
+            self.assertIn(klass, res)
+        def _test_size_medium(param):
+            res = render_template('{% bootstrap_field form.subject size="' + param + '" %}')
+            self.assertNotIn('input-lg', res)
+            self.assertNotIn('input-sm', res)
+            self.assertNotIn('input-md', res)
+        _test_size('sm', 'input-sm')
+        _test_size('small', 'input-sm')
+        _test_size('lg', 'input-lg')
+        _test_size('large', 'input-lg')
+        _test_size_medium('md')
+        _test_size_medium('medium')
+        _test_size_medium('')
+
 
 class ComponentsTest(TestCase):
     def test_icon(self):

demo/demo/templates/demo/formset.html

@@ -10,7 +10,6 @@
     {% bootstrap_formset_errors form %}
     <form role="form" method="post">
         {% csrf_token %}
-        {{ form.management_form }}
         {% bootstrap_formset form %}
         {% buttons submit='OK' reset="Cancel" %}{% endbuttons %}
     </form>

demo/demo/templates/demo/misc.html

@@ -8,7 +8,7 @@
 
 {% block content %}
 
-    {% bootstrap_button 'button' %}
+    {% bootstrap_button 'button' size='lg' %}
 
     {% bootstrap_alert "Something went wrong" alert_type='danger' %}