Example::
FormActions(
HTML(),
Submit('Save', 'Save', css_class='btn-primary')
)
"""
template = "%s/layout/formactions.html"
def __init__(self, *fields, **kwargs):
self.fields = list(fields)
self.template = kwargs.pop('template', self.template)
self.attrs = kwargs
if 'css_class' in self.attrs:
self.attrs['class'] = self.attrs.pop('css_class')
def render(self, form, form_style, context, template_pack=TEMPLATE_PACK, **kwargs):
html = self.get_rendered_fields(form, form_style, context, template_pack, **kwargs)
template = self.get_template_name(template_pack)
context.update({
'formactions': self,
'fields_output': html
})
return render_to_string(template, context.flatten())
def flat_attrs(self):
return flatatt(self.attrs)
class InlineCheckboxes(Field):
"""
Layout object for rendering checkboxes inline::
InlineCheckboxes('field_name')
"""
template = "%s/layout/checkboxselectmultiple_inline.html"
def render(self, form, form_style, context, template_pack=TEMPLATE_PACK, **kwargs):
return super(InlineCheckboxes, self).render(
form, form_style, context, template_pack=template_pack,
extra_context={'inline_class': 'inline'}
)
class InlineRadios(Field):
"""
Layout object for rendering radiobuttons inline::
InlineRadios('field_name')
"""
template = "%s/layout/radioselect_inline.html"
def render(self, form, form_style, context, template_pack=TEMPLATE_PACK, **kwargs):
return super(InlineRadios, self).render(
form, form_style, context, template_pack=template_pack,
extra_context={'inline_class': 'inline'}
)
class FieldWithButtons(Div):
template = '%s/layout/field_with_buttons.html'
field_template = '%s/layout/field.html'
def render(self, form, form_style, context, template_pack=TEMPLATE_PACK, extra_context=None, **kwargs):
# We first render the buttons
field_template = self.field_template % template_pack
buttons = ''.join(
render_field(
field, form, form_style, context,
field_template, layout_object=self,
template_pack=template_pack, **kwargs
) for field in self.fields[1:]
)
extra_context = {'div': self, 'buttons': buttons}
template = self.get_template_name(template_pack)
if isinstance(self.fields[0], Field):
# FieldWithButtons(Field('field_name'), StrictButton("go"))
# We render the field passing its name and attributes
return render_field(
self.fields[0][0], form, form_style, context,
template, attrs=self.fields[0].attrs,
template_pack=template_pack, extra_context=extra_context, **kwargs
)
else:
return render_field(
self.fields[0], form, form_style, context, template,
extra_context=extra_context, **kwargs
)
class StrictButton(object):
"""
Layout object for rendering an HTML button::
Button("button content", css_class="extra")
"""
template = '%s/layout/button.html'
field_classes = 'btn'
def __init__(self, content, **kwargs):
self.content = content
self.template = kwargs.pop('template', self.template)
kwargs.setdefault('type', 'button')
# We turn css_id and css_class into id and class
if 'css_id' in kwargs:
kwargs['id'] = kwargs.pop('css_id')
kwargs['class'] = self.field_classes
if 'css_class' in kwargs:
kwargs['class'] += " %s" % kwargs.pop('css_class')
self.flat_attrs = flatatt(kwargs)
def render(self, form, form_style, context, template_pack=TEMPLATE_PACK, **kwargs):
self.content = Template(text_type(self.content)).render(context)
template = self.template % template_pack
context.update({'button': self})
return render_to_string(template, context.flatten())
class Container(Div):
"""
Base class used for `Tab` and `AccordionGroup`, represents a basic container concept
"""
css_class = ""
def __init__(self, name, *fields, **kwargs):
super(Container, self).__init__(*fields, **kwargs)
self.template = kwargs.pop('template', self.template)
self.name = name
self._active_originally_included = "active" in kwargs
self.active = kwargs.pop("active", False)
if not self.css_id:
self.css_id = slugify(self.name)
def __contains__(self, field_name):
"""
check if field_name is contained within tab.
"""
return field_name in map(lambda pointer: pointer[1], self.get_field_names())
def render(self, form, form_style, context, template_pack=TEMPLATE_PACK, **kwargs):
if self.active:
if not 'active' in self.css_class:
self.css_class += ' active'
else:
self.css_class = self.css_class.replace('active', '')
return super(Container, self).render(form, form_style, context, template_pack)
class ContainerHolder(Div):
"""
Base class used for `TabHolder` and `Accordion`, groups containers
"""
def first_container_with_errors(self, errors):
"""
Returns the first container with errors, otherwise returns None.
"""
for tab in self.fields:
errors_here = any(error in tab for error in errors)
if errors_here:
return tab
return None
def open_target_group_for_form(self, form):
"""
Makes sure that the first group that should be open is open.
This is either the first group with errors or the first group
in the container, unless that first group was originally set to
active=False.
"""
target = self.first_container_with_errors(form.errors.keys())
if target is None:
target = self.fields[0]
if not target._active_originally_included:
target.active = True
return target
target.active = True
return target
class Tab(Container):
"""
Tab object. It wraps fields in a div whose default class is "tab-pane" and
takes a name as first argument. Example::
Tab('tab_name', 'form_field_1', 'form_field_2', 'form_field_3')
"""
css_class = 'tab-pane'
link_template = '%s/layout/tab-link.html'
def render_link(self, template_pack=TEMPLATE_PACK, **kwargs):
"""
Render the link for the tab-pane. It must be called after render so css_class is updated
with active if needed.
"""
link_template = self.link_template % template_pack
return render_to_string(link_template, {'link': self})
class TabHolder(ContainerHolder):
"""
TabHolder object. It wraps Tab objects in a container. Requires bootstrap-tab.js::
TabHolder(
Tab('form_field_1', 'form_field_2'),
Tab('form_field_3')
)
"""
template = '%s/layout/tab.html'
def render(self, form, form_style, context, template_pack=TEMPLATE_PACK, **kwargs):
for tab in self.fields:
tab.active = False
# Open the group that should be open.
self.open_target_group_for_form(form)
content = self.get_rendered_fields(form, form_style, context, template_pack)
links = ''.join(tab.render_link(template_pack) for tab in self.fields)
context.update({
'tabs': self,
'links': links,
'content': content
})
template = self.get_template_name(template_pack)
return render_to_string(template, context.flatten())
class AccordionGroup(Container):
"""
Accordion Group (pane) object. It wraps given fields inside an accordion
tab. It takes accordion tab name as first argument::
AccordionGroup("group name", "form_field_1", "form_field_2")
"""
template = "%s/accordion-group.html"
data_parent = "" # accordion parent div id.
class Accordion(ContainerHolder):
"""
Accordion menu object. It wraps `AccordionGroup` objects in a container::
Accordion(
AccordionGroup("group name", "form_field_1", "form_field_2"),
AccordionGroup("another group name", "form_field")
)
"""
template = "%s/accordion.html"
def render(self, form, form_style, context, template_pack=TEMPLATE_PACK, **kwargs):
content = ''
# accordion group needs the parent div id to set `data-parent` (I don't
# know why). This needs to be a unique id
if not self.css_id:
self.css_id = "-".join(["accordion", text_type(randint(1000, 9999))])
# Open the group that should be open.
self.open_target_group_for_form(form)
for group in self.fields:
group.data_parent = self.css_id
content += render_field(
group, form, form_style, context, template_pack=template_pack, **kwargs
)
template = self.get_template_name(template_pack)
context.update({'accordion': self, 'content': content})
return render_to_string(template, context.flatten())
class Alert(Div):
"""
`Alert` generates markup in the form of an alert dialog
Alert(content='Warning! Best check yo self, you're not looking too good.')
"""
template = "%s/layout/alert.html"
css_class = "alert"
def __init__(self, content, dismiss=True, block=False, **kwargs):
fields = []
if block:
self.css_class += ' alert-block'
Div.__init__(self, *fields, **kwargs)
self.template = kwargs.pop('template', self.template)
self.content = content
self.dismiss = dismiss
def render(self, form, form_style, context, template_pack=TEMPLATE_PACK, **kwargs):
template = self.get_template_name(template_pack)
context.update({'alert': self, 'content': self.content, 'dismiss': self.dismiss})
return render_to_string(template, context.flatten())
class UneditableField(Field):
"""
Layout object for rendering fields as uneditable in bootstrap
Example::
UneditableField('field_name', css_class="input-xlarge")
"""
template = "%s/layout/uneditable_input.html"
def __init__(self, field, *args, **kwargs):
self.attrs = {'class': 'uneditable-input'}
super(UneditableField, self).__init__(field, *args, **kwargs)
class InlineField(Field):
template = "%s/layout/inline_field.html"
django-crispy-forms-1.6.0/crispy_forms/compatibility.py 0000664 0000000 0000000 00000001432 12643543520 0023361 0 ustar 00root root 0000000 0000000 import sys
from django.utils.functional import SimpleLazyObject
try:
basestring
except:
basestring = str # Python3
PY2 = sys.version_info[0] == 2
if not PY2:
text_type = str
binary_type = bytes
string_types = (str,)
integer_types = (int,)
else:
text_type = unicode
binary_type = str
string_types = basestring
integer_types = (int, long)
try:
# avoid RemovedInDjango19Warning by using lru_cache where available
from django.utils.lru_cache import lru_cache
except ImportError:
from django.utils.functional import memoize
def lru_cache():
def decorator(function, cache_dict=None):
if cache_dict is None:
cache_dict = {}
return memoize(function, cache_dict, 1)
return decorator
django-crispy-forms-1.6.0/crispy_forms/exceptions.py 0000664 0000000 0000000 00000000511 12643543520 0022666 0 ustar 00root root 0000000 0000000 class CrispyError(Exception):
pass
class FormHelpersException(CrispyError):
"""
This is raised when building a form via helpers throws an error.
We want to catch form helper errors as soon as possible because
debugging templatetags is never fun.
"""
pass
class DynamicError(CrispyError):
pass
django-crispy-forms-1.6.0/crispy_forms/helper.py 0000664 0000000 0000000 00000034001 12643543520 0021765 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
import re
from django.core.urlresolvers import reverse, NoReverseMatch
from django.utils.safestring import mark_safe
from crispy_forms.compatibility import string_types
from crispy_forms.layout import Layout
from crispy_forms.layout_slice import LayoutSlice
from crispy_forms.utils import render_field, flatatt, TEMPLATE_PACK, list_intersection, list_difference
from crispy_forms.exceptions import FormHelpersException
class DynamicLayoutHandler(object):
def _check_layout(self):
if self.layout is None:
raise FormHelpersException("You need to set a layout in your FormHelper")
def _check_layout_and_form(self):
self._check_layout()
if self.form is None:
raise FormHelpersException("You need to pass a form instance to your FormHelper")
def all(self):
"""
Returns all layout objects of first level of depth
"""
self._check_layout()
return LayoutSlice(self.layout, slice(0, len(self.layout.fields), 1))
def filter(self, *LayoutClasses, **kwargs):
"""
Returns a LayoutSlice pointing to layout objects of type `LayoutClass`
"""
self._check_layout()
max_level = kwargs.pop('max_level', 0)
greedy = kwargs.pop('greedy', False)
filtered_layout_objects = self.layout.get_layout_objects(LayoutClasses, max_level=max_level, greedy=greedy)
return LayoutSlice(self.layout, filtered_layout_objects)
def filter_by_widget(self, widget_type):
"""
Returns a LayoutSlice pointing to fields with widgets of `widget_type`
"""
self._check_layout_and_form()
layout_field_names = self.layout.get_field_names()
# Let's filter all fields with widgets like widget_type
filtered_fields = []
for pointer in layout_field_names:
if isinstance(self.form.fields[pointer[1]].widget, widget_type):
filtered_fields.append(pointer)
return LayoutSlice(self.layout, filtered_fields)
def exclude_by_widget(self, widget_type):
"""
Returns a LayoutSlice pointing to fields with widgets NOT matching `widget_type`
"""
self._check_layout_and_form()
layout_field_names = self.layout.get_field_names()
# Let's exclude all fields with widgets like widget_type
filtered_fields = []
for pointer in layout_field_names:
if not isinstance(self.form.fields[pointer[1]].widget, widget_type):
filtered_fields.append(pointer)
return LayoutSlice(self.layout, filtered_fields)
def __getitem__(self, key):
"""
Return a LayoutSlice that makes changes affect the current instance of the layout
and not a copy.
"""
# when key is a string containing the field name
if isinstance(key, string_types):
# Django templates access FormHelper attributes using dictionary [] operator
# This could be a helper['form_id'] access, not looking for a field
if hasattr(self, key):
return getattr(self, key)
self._check_layout()
layout_field_names = self.layout.get_field_names()
filtered_field = []
for pointer in layout_field_names:
# There can be an empty pointer
if len(pointer) == 2 and pointer[1] == key:
filtered_field.append(pointer)
return LayoutSlice(self.layout, filtered_field)
return LayoutSlice(self.layout, key)
def __setitem__(self, key, value):
self.layout[key] = value
def __delitem__(self, key):
del self.layout.fields[key]
def __len__(self):
if self.layout is not None:
return len(self.layout.fields)
else:
return 0
class FormHelper(DynamicLayoutHandler):
"""
This class controls the form rendering behavior of the form passed to
the `{% crispy %}` tag. For doing so you will need to set its attributes
and pass the corresponding helper object to the tag::
{% crispy form form.helper %}
Let's see what attributes you can set and what form behaviors they apply to:
**form_method**: Specifies form method attribute.
You can see it to 'POST' or 'GET'. Defaults to 'POST'
**form_action**: Applied to the form action attribute:
- Can be a named url in your URLconf that can be executed via the `{% url %}` template tag. \
Example: 'show_my_profile'. In your URLconf you could have something like::
url(r'^show/profile/$', 'show_my_profile_view', name = 'show_my_profile')
- It can simply point to a URL '/whatever/blabla/'.
**form_id**: Generates a form id for dom identification.
If no id provided then no id attribute is created on the form.
**form_class**: String containing separated CSS clases to be applied
to form class attribute. The form will always have by default
'uniForm' class.
**form_tag**: It specifies if tags should be rendered when using a Layout.
If set to False it renders the form without the tags. Defaults to True.
**form_error_title**: If a form has `non_field_errors` to display, they
are rendered in a div. You can set title's div with this attribute.
Example: "Oooops!" or "Form Errors"
**formset_error_title**: If a formset has `non_form_errors` to display, they
are rendered in a div. You can set title's div with this attribute.
**form_style**: Uni-form has two built in different form styles. You can choose
your favorite. This can be set to "default" or "inline". Defaults to "default".
**include_media**: Whether to automatically include form media. Set to False if
you want to manually include form media outside the form. Defaults to True.
Public Methods:
**add_input(input)**: You can add input buttons using this method. Inputs
added using this method will be rendered at the end of the form/formset.
**add_layout(layout)**: You can add a `Layout` object to `FormHelper`. The Layout
specifies in a simple, clean and DRY way how the form fields should be rendered.
You can wrap fields, order them, customize pretty much anything in the form.
Best way to add a helper to a form is adding a property named helper to the form
that returns customized `FormHelper` object::
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Submit
class MyForm(forms.Form):
title = forms.CharField(_("Title"))
@property
def helper(self):
helper = FormHelper()
helper.form_id = 'this-form-rocks'
helper.form_class = 'search'
helper.add_input(Submit('save', 'save'))
[...]
return helper
You can use it in a template doing::
{% load crispy_forms_tags %}
{% crispy form %}
"""
_form_method = 'post'
_form_action = ''
_form_style = 'default'
form = None
form_id = ''
form_class = ''
layout = None
form_tag = True
form_error_title = None
formset_error_title = None
form_show_errors = True
render_unmentioned_fields = False
render_hidden_fields = False
render_required_fields = False
_help_text_inline = False
_error_text_inline = True
html5_required = False
form_show_labels = True
template = None
field_template = None
disable_csrf = False
label_class = ''
field_class = ''
include_media = True
def __init__(self, form=None):
self.attrs = {}
self.inputs = []
if form is not None:
self.form = form
self.layout = self.build_default_layout(form)
def build_default_layout(self, form):
return Layout(*form.fields.keys())
@property
def form_method(self):
return self._form_method
@form_method.setter
def form_method(self, method):
if method.lower() not in ('get', 'post'):
raise FormHelpersException('Only GET and POST are valid in the \
form_method helper attribute')
self._form_method = method.lower()
@property
def form_action(self):
try:
return reverse(self._form_action)
except NoReverseMatch:
return self._form_action
@form_action.setter
def form_action(self, action):
self._form_action = action
@property
def form_style(self):
if self._form_style == "default":
return ''
if self._form_style == "inline":
return 'inlineLabels'
@form_style.setter
def form_style(self, style):
if style.lower() not in ('default', 'inline'):
raise FormHelpersException('Only default and inline are valid in the \
form_style helper attribute')
self._form_style = style.lower()
@property
def help_text_inline(self):
return self._help_text_inline
@help_text_inline.setter
def help_text_inline(self, flag):
self._help_text_inline = flag
self._error_text_inline = not flag
@property
def error_text_inline(self):
return self._error_text_inline
@error_text_inline.setter
def error_text_inline(self, flag):
self._error_text_inline = flag
self._help_text_inline = not flag
def add_input(self, input_object):
self.inputs.append(input_object)
def add_layout(self, layout):
self.layout = layout
def render_layout(self, form, context, template_pack=TEMPLATE_PACK):
"""
Returns safe html of the rendering of the layout
"""
form.rendered_fields = set()
form.crispy_field_template = self.field_template
# This renders the specified Layout strictly
html = self.layout.render(
form,
self.form_style,
context,
template_pack=template_pack
)
# Rendering some extra fields if specified
if self.render_unmentioned_fields or self.render_hidden_fields or self.render_required_fields:
fields = set(form.fields.keys())
left_fields_to_render = fields - form.rendered_fields
for field in left_fields_to_render:
if (
self.render_unmentioned_fields or
self.render_hidden_fields and form.fields[field].widget.is_hidden or
self.render_required_fields and form.fields[field].widget.is_required
):
html += render_field(
field,
form,
self.form_style,
context,
template_pack=template_pack
)
# If the user has Meta.fields defined, not included in the layout,
# we suppose they need to be rendered
if hasattr(form, 'Meta'):
if hasattr(form.Meta, 'fields'):
current_fields = tuple(getattr(form, 'fields', {}).keys())
meta_fields = getattr(form.Meta, 'fields')
fields_to_render = list_intersection(current_fields, meta_fields)
left_fields_to_render = list_difference(fields_to_render, form.rendered_fields)
for field in left_fields_to_render:
html += render_field(field, form, self.form_style, context)
return mark_safe(html)
def get_attributes(self, template_pack=TEMPLATE_PACK):
"""
Used by crispy_forms_tags to get helper attributes
"""
items = {
'form_method': self.form_method.strip(),
'form_tag': self.form_tag,
'form_style': self.form_style.strip(),
'form_show_errors': self.form_show_errors,
'help_text_inline': self.help_text_inline,
'error_text_inline': self.error_text_inline,
'html5_required': self.html5_required,
'form_show_labels': self.form_show_labels,
'disable_csrf': self.disable_csrf,
'label_class': self.label_class,
'field_class': self.field_class,
'include_media': self.include_media
}
# col-[lg|md|sm|xs]-
label_size_match = re.search('(\d+)', self.label_class)
device_type_match = re.search('(lg|md|sm|xs)', self.label_class)
if label_size_match and device_type_match:
try:
items['label_size'] = int(label_size_match.groups()[0])
items['bootstrap_device_type'] = device_type_match.groups()[0]
except:
pass
items['attrs'] = {}
if self.attrs:
items['attrs'] = self.attrs.copy()
if self.form_action:
items['attrs']['action'] = self.form_action.strip()
if self.form_id:
items['attrs']['id'] = self.form_id.strip()
if self.form_class:
# uni_form TEMPLATE PACK has a uniForm class by default
if template_pack == 'uni_form':
items['attrs']['class'] = "uniForm %s" % self.form_class.strip()
else:
items['attrs']['class'] = self.form_class.strip()
else:
if template_pack == 'uni_form':
items['attrs']['class'] = self.attrs.get('class', '') + " uniForm"
items['flat_attrs'] = flatatt(items['attrs'])
if self.inputs:
items['inputs'] = self.inputs
if self.form_error_title:
items['form_error_title'] = self.form_error_title.strip()
if self.formset_error_title:
items['formset_error_title'] = self.formset_error_title.strip()
for attribute_name, value in self.__dict__.items():
if attribute_name not in items and attribute_name not in ['layout', 'inputs'] and not attribute_name.startswith('_'):
items[attribute_name] = value
return items
django-crispy-forms-1.6.0/crispy_forms/layout.py 0000664 0000000 0000000 00000037113 12643543520 0022032 0 ustar 00root root 0000000 0000000 from __future__ import unicode_literals
from django.template import Template
from django.template.loader import render_to_string
from django.utils.html import conditional_escape
from crispy_forms.compatibility import string_types, text_type
from crispy_forms.utils import render_field, flatatt, TEMPLATE_PACK, get_template_pack
class TemplateNameMixin(object):
def get_template_name(self, template_pack):
if '%s' in self.template:
template = self.template % template_pack
else:
template = self.template
return template
class LayoutObject(TemplateNameMixin):
def __getitem__(self, slice):
return self.fields[slice]
def __setitem__(self, slice, value):
self.fields[slice] = value
def __delitem__(self, slice):
del self.fields[slice]
def __len__(self):
return len(self.fields)
def __getattr__(self, name):
"""
This allows us to access self.fields list methods like append or insert, without
having to declare them one by one
"""
# Check necessary for unpickling, see #107
if 'fields' in self.__dict__ and hasattr(self.fields, name):
return getattr(self.fields, name)
else:
return object.__getattribute__(self, name)
def get_field_names(self, index=None):
"""
Returns a list of lists, those lists are named pointers. First parameter
is the location of the field, second one the name of the field. Example::
[
[[0,1,2], 'field_name1'],
[[0,3], 'field_name2']
]
"""
return self.get_layout_objects(string_types, greedy=True)
def get_layout_objects(self, *LayoutClasses, **kwargs):
"""
Returns a list of lists pointing to layout objects of any type matching
`LayoutClasses`::
[
[[0,1,2], 'div'],
[[0,3], 'field_name']
]
:param max_level: An integer that indicates max level depth to reach when
traversing a layout.
:param greedy: Boolean that indicates whether to be greedy. If set, max_level
is skipped.
"""
index = kwargs.pop('index', None)
max_level = kwargs.pop('max_level', 0)
greedy = kwargs.pop('greedy', False)
pointers = []
if index is not None and not isinstance(index, list):
index = [index]
elif index is None:
index = []
for i, layout_object in enumerate(self.fields):
if isinstance(layout_object, LayoutClasses):
if len(LayoutClasses) == 1 and LayoutClasses[0] == string_types:
pointers.append([index + [i], layout_object])
else:
pointers.append([index + [i], layout_object.__class__.__name__.lower()])
# If it's a layout object and we haven't reached the max depth limit or greedy
# we recursive call
if hasattr(layout_object, 'get_field_names') and (len(index) < max_level or greedy):
new_kwargs = {'index': index + [i], 'max_level': max_level, 'greedy': greedy}
pointers = pointers + layout_object.get_layout_objects(*LayoutClasses, **new_kwargs)
return pointers
def get_rendered_fields(self, form, form_style, context, template_pack=TEMPLATE_PACK, **kwargs):
return ''.join(
render_field(field, form, form_style, context, template_pack=template_pack, **kwargs)
for field in self.fields
)
class Layout(LayoutObject):
"""
Form Layout. It is conformed by Layout objects: `Fieldset`, `Row`, `Column`, `MultiField`,
`HTML`, `ButtonHolder`, `Button`, `Hidden`, `Reset`, `Submit` and fields. Form fields
have to be strings.
Layout objects `Fieldset`, `Row`, `Column`, `MultiField` and `ButtonHolder` can hold other
Layout objects within. Though `ButtonHolder` should only hold `HTML` and BaseInput
inherited classes: `Button`, `Hidden`, `Reset` and `Submit`.
Example::
helper.layout = Layout(
Fieldset('Company data',
'is_company'
),
Fieldset(_('Contact details'),
'email',
Row('password1', 'password2'),
'first_name',
'last_name',
HTML('
'),
'company'
),
ButtonHolder(
Submit('Save', 'Save', css_class='button white'),
),
)
"""
def __init__(self, *fields):
self.fields = list(fields)
def render(self, form, form_style, context, template_pack=TEMPLATE_PACK, **kwargs):
return self.get_rendered_fields(form, form_style, context, template_pack, **kwargs)
class ButtonHolder(LayoutObject):
"""
Layout object. It wraps fields in a
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap/layout/help_text.html 0000664 0000000 0000000 00000000437 12643543520 0030354 0 ustar 00root root 0000000 0000000 {% if field.help_text %}
{% if help_text_inline %}
{{ field.help_text|safe }}
{% else %}
{{ link.name|capfirst }}{% if tab.errors %}!{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap/layout/tab.html 0000664 0000000 0000000 00000000243 12643543520 0027121 0 ustar 00root root 0000000 0000000
{{ links|safe }}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap/table_inline_formset.html 0000664 0000000 0000000 00000004002 12643543520 0031217 0 ustar 00root root 0000000 0000000 {% load crispy_forms_tags %}
{% load crispy_forms_utils %}
{% load crispy_forms_field %}
{% specialspaceless %}
{% if formset_tag %}
{% endif %}
{% endspecialspaceless %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap/uni_form.html 0000664 0000000 0000000 00000000474 12643543520 0026662 0 ustar 00root root 0000000 0000000 {% load crispy_forms_utils %}
{% specialspaceless %}
{% if include_media %}{{ form.media }}{% endif %}
{% if form_show_errors %}
{% include "bootstrap/errors.html" %}
{% endif %}
{% for field in form %}
{% include "bootstrap/field.html" %}
{% endfor %}
{% endspecialspaceless %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap/uni_formset.html 0000664 0000000 0000000 00000000344 12643543520 0027372 0 ustar 00root root 0000000 0000000 {% with formset.management_form as form %}
{% include 'bootstrap/uni_form.html' %}
{% endwith %}
{% for form in formset %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/accordion.html 0000664 0000000 0000000 00000000124 12643543520 0027060 0 ustar 00root root 0000000 0000000
{% if dismiss %}{% endif %}
{{ content|safe }}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/layout/baseinput.html 0000664 0000000 0000000 00000000654 12643543520 0030436 0 ustar 00root root 0000000 0000000
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/layout/button.html 0000664 0000000 0000000 00000000110 12643543520 0027742 0 ustar 00root root 0000000 0000000
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/layout/buttonholder.html 0000664 0000000 0000000 00000000324 12643543520 0031147 0 ustar 00root root 0000000 0000000
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/layout/checkboxselectmultiple.html 0000664 0000000 0000000 00000001634 12643543520 0033205 0 ustar 00root root 0000000 0000000 {% load crispy_forms_filters %}
{% load l10n %}
'),
'company'
),
ButtonHolder(
Submit('Save', 'Save', css_class='button white'),
),
)
"""
def __init__(self, *fields):
self.fields = list(fields)
def render(self, form, form_style, context, template_pack=TEMPLATE_PACK, **kwargs):
return self.get_rendered_fields(form, form_style, context, template_pack, **kwargs)
class ButtonHolder(LayoutObject):
"""
Layout object. It wraps fields in a
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap/layout/help_text.html 0000664 0000000 0000000 00000000437 12643543520 0030354 0 ustar 00root root 0000000 0000000 {% if field.help_text %}
{% if help_text_inline %}
{{ field.help_text|safe }}
{% else %}
{{ field.help_text|safe }}
{% endif %} {% endif %} django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap/layout/help_text_and_errors.html 0000664 0000000 0000000 00000000572 12643543520 0032572 0 ustar 00root root 0000000 0000000 {% if help_text_inline and not error_text_inline %} {% include 'bootstrap/layout/help_text.html' %} {% endif %} {% if error_text_inline %} {% include 'bootstrap/layout/field_errors.html' %} {% else %} {% include 'bootstrap/layout/field_errors_block.html' %} {% endif %} {% if not help_text_inline %} {% include 'bootstrap/layout/help_text.html' %} {% endif %} django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap/layout/multifield.html 0000664 0000000 0000000 00000001025 12643543520 0030510 0 ustar 00root root 0000000 0000000 {% load crispy_forms_field %} {% if field.is_hidden %} {{ field }} {% else %} {% if field.label %} {% endif %} {% endif %} django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap/layout/prepended_appended_text.html 0000664 0000000 0000000 00000002440 12643543520 0033226 0 ustar 00root root 0000000 0000000 {% load crispy_forms_field %} {% if field.is_hidden %} {{ field }} {% else %}
{% if field.label and form_show_labels %}
{% endif %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap/layout/radioselect.html 0000664 0000000 0000000 00000001310 12643543520 0030645 0 ustar 00root root 0000000 0000000 {% load crispy_forms_filters %}
{% load l10n %}
{% if crispy_prepended_text %}{{ crispy_prepended_text|safe }}{% endif %}
{% crispy_field field %}
{% if crispy_appended_text %}{{ crispy_appended_text|safe }}{% endif %}
{% include 'bootstrap/layout/help_text_and_errors.html' %}
{% include 'bootstrap/layout/field_errors_block.html' %}
{% for choice in field.field.choices %}
{% endfor %}
{% include 'bootstrap/layout/help_text.html' %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap/layout/radioselect_inline.html 0000664 0000000 0000000 00000001160 12643543520 0032206 0 ustar 00root root 0000000 0000000 {% if field.is_hidden %}
{{ field }}
{% else %}
{% if field.label %}
{% endif %}
{% include 'bootstrap/layout/radioselect.html' %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap/layout/tab-link.html 0000664 0000000 0000000 00000000272 12643543520 0030056 0 ustar 00root root 0000000 0000000
{{ content|safe }}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap/layout/uneditable_input.html 0000664 0000000 0000000 00000001060 12643543520 0031704 0 ustar 00root root 0000000 0000000 {{ field.label|safe }}{% if field.field.required %}*{% endif %}
{% if field.value %}{{ field.value }}{% endif %}
{% include 'bootstrap/layout/help_text.html' %}
{% include 'bootstrap/uni_form.html' %}
{% endfor %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap/whole_uni_form.html 0000664 0000000 0000000 00000001172 12643543520 0030054 0 ustar 00root root 0000000 0000000 {% load crispy_forms_utils %}
{% specialspaceless %}
{% if form_tag %}{% endif %}
{% endspecialspaceless %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap/whole_uni_formset.html 0000664 0000000 0000000 00000001516 12643543520 0030572 0 ustar 00root root 0000000 0000000 {% load crispy_forms_tags %}
{% load crispy_forms_utils %}
{% specialspaceless %}
{% if formset_tag %}
{% endif %}
{% endspecialspaceless %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/ 0000775 0000000 0000000 00000000000 12643543520 0024234 5 ustar 00root root 0000000 0000000 django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/accordion-group.html 0000664 0000000 0000000 00000000716 12643543520 0030221 0 ustar 00root root 0000000 0000000
{{ fields|safe }}
{{ content|safe }}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/betterform.html 0000664 0000000 0000000 00000001234 12643543520 0027273 0 ustar 00root root 0000000 0000000 {% for fieldset in form.fieldsets %}
{% endif %}
{% endfor %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/display_form.html 0000664 0000000 0000000 00000000410 12643543520 0027605 0 ustar 00root root 0000000 0000000 {% if form.form_html %}
{% if include_media %}{{ form.media }}{% endif %}
{% if form_show_errors %}
{% include "bootstrap3/errors.html" %}
{% endif %}
{{ form.form_html }}
{% else %}
{% include "bootstrap3/uni_form.html" %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/errors.html 0000664 0000000 0000000 00000000433 12643543520 0026436 0 ustar 00root root 0000000 0000000 {% if form.non_field_errors %}
{% if form_error_title %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/errors_formset.html 0000664 0000000 0000000 00000000446 12643543520 0030201 0 ustar 00root root 0000000 0000000 {% if formset.non_form_errors %}
{{ form_error_title }}
{% endif %}-
{{ form.non_field_errors|unordered_list }}
{% if formset_error_title %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/field.html 0000664 0000000 0000000 00000004302 12643543520 0026204 0 ustar 00root root 0000000 0000000 {% load crispy_forms_field %}
{% if field.is_hidden %}
{{ field }}
{% else %}
{% if field|is_checkbox %}
{{ formset_error_title }}
{% endif %}-
{{ formset.non_form_errors|unordered_list }}
{% if label_class %}
{% endif %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/inputs.html 0000664 0000000 0000000 00000000565 12643543520 0026452 0 ustar 00root root 0000000 0000000 {% if inputs %}
{% endif %}
{% endif %}
<{% if tag %}{{ tag }}{% else %}div{% endif %} id="div_{{ field.auto_id }}" {% if not field|is_checkbox %}class="form-group{% else %}class="checkbox{% endif %}{% if wrapper_class %} {{ wrapper_class }}{% endif %}{% if form_show_errors%}{% if field.errors %} has-error{% endif %}{% endif %}{% if field.css_classes %} {{ field.css_classes }}{% endif %}">
{% if field.label and not field|is_checkbox and form_show_labels %}
{% endif %}
{% if field|is_checkboxselectmultiple %}
{% include 'bootstrap3/layout/checkboxselectmultiple.html' %}
{% endif %}
{% if field|is_radioselect %}
{% include 'bootstrap3/layout/radioselect.html' %}
{% endif %}
{% if not field|is_checkboxselectmultiple and not field|is_radioselect %}
{% if field|is_checkbox and form_show_labels %}
{% else %}
{% endif %}
{% crispy_field field %}
{% include 'bootstrap3/layout/help_text_and_errors.html' %}
{% endif %}
{% endif %}
{% if field|is_checkbox %}
{% if label_class %}
{% if label_class %}
{% endif %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/layout/ 0000775 0000000 0000000 00000000000 12643543520 0025551 5 ustar 00root root 0000000 0000000 django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/layout/alert.html 0000664 0000000 0000000 00000000405 12643543520 0027545 0 ustar 00root root 0000000 0000000
{% for input in inputs %}
{% include "bootstrap3/layout/baseinput.html" %}
{% endfor %}
{% include 'bootstrap3/layout/field_errors_block.html' %}
{% for choice in field.field.choices %}
{% if not inline_class %}
checkboxselectmultiple_inline.html 0000664 0000000 0000000 00000001217 12643543520 0034461 0 ustar 00root root 0000000 0000000 django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/layout {% if field.is_hidden %}
{{ field }}
{% else %}
{% endif %}
{% if not inline_class %}
{% endif %}
{% endfor %}
{% include 'bootstrap3/layout/help_text.html' %}
{% if field.label %}
{% endif %}
{% include 'bootstrap3/layout/checkboxselectmultiple.html' %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/layout/div.html 0000664 0000000 0000000 00000000267 12643543520 0027226 0 ustar 00root root 0000000 0000000
{{ fields|safe }}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/layout/field_errors.html 0000664 0000000 0000000 00000000346 12643543520 0031121 0 ustar 00root root 0000000 0000000 {% if form_show_errors and field.errors %}
{% for error in field.errors %}
{{ error }}
{% endfor %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/layout/field_errors_block.html 0000664 0000000 0000000 00000000340 12643543520 0032265 0 ustar 00root root 0000000 0000000 {% if form_show_errors and field.errors %}
{% for error in field.errors %}
{{ error }}
{% endfor %} {% endif %} django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/layout/field_with_buttons.html 0000664 0000000 0000000 00000001760 12643543520 0032337 0 ustar 00root root 0000000 0000000 {% load crispy_forms_field %}
{% crispy_field field %}
{{ buttons|safe }}
{% include 'bootstrap3/layout/help_text_and_errors.html' %}
{{ fields_output|safe }}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/layout/help_text.html 0000664 0000000 0000000 00000000436 12643543520 0030436 0 ustar 00root root 0000000 0000000 {% if field.help_text %}
{% if help_text_inline %}
{{ field.help_text|safe }}
{% else %}
{{ field.help_text|safe }}
{% endif %} {% endif %} django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/layout/help_text_and_errors.html 0000664 0000000 0000000 00000000576 12643543520 0032661 0 ustar 00root root 0000000 0000000 {% if help_text_inline and not error_text_inline %} {% include 'bootstrap3/layout/help_text.html' %} {% endif %} {% if error_text_inline %} {% include 'bootstrap3/layout/field_errors.html' %} {% else %} {% include 'bootstrap3/layout/field_errors_block.html' %} {% endif %} {% if not help_text_inline %} {% include 'bootstrap3/layout/help_text.html' %} {% endif %} django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/layout/inline_field.html 0000664 0000000 0000000 00000001423 12643543520 0031060 0 ustar 00root root 0000000 0000000 {% load crispy_forms_field %} {% if field.is_hidden %} {{ field }} {% else %} {% if field|is_checkbox %}
{% crispy_field field 'placeholder' field.label %}
{% endif %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/layout/multifield.html 0000664 0000000 0000000 00000001025 12643543520 0030573 0 ustar 00root root 0000000 0000000 {% load crispy_forms_field %}
{% if field.is_hidden %}
{{ field }}
{% else %}
{% if field.label %}
{% endif %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/layout/prepended_appended_text.html 0000664 0000000 0000000 00000003457 12643543520 0033322 0 ustar 00root root 0000000 0000000 {% load crispy_forms_field %}
{% if field.is_hidden %}
{{ field }}
{% else %}
{% if field.label and form_show_labels %}
{% endif %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/layout/radioselect.html 0000664 0000000 0000000 00000001513 12643543520 0030735 0 ustar 00root root 0000000 0000000 {% load crispy_forms_filters %}
{% load l10n %}
{% if field|is_select %}
{% if crispy_prepended_text %}{{ crispy_prepended_text|safe }}{% endif %}
{% crispy_field field %}
{% if crispy_appended_text %}{{ crispy_appended_text|safe }}{% endif %}
{% else %}
{% if crispy_prepended_text %}{{ crispy_prepended_text|safe }}{% endif %}
{% crispy_field field %}
{% if crispy_appended_text %}{{ crispy_appended_text|safe }}{% endif %}
{% endif %}
{% include 'bootstrap3/layout/help_text_and_errors.html' %}
{% include 'bootstrap3/layout/field_errors_block.html' %}
{% for choice in field.field.choices %}
{% if not inline_class %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/layout/radioselect_inline.html 0000664 0000000 0000000 00000001271 12643543520 0032274 0 ustar 00root root 0000000 0000000 {% if field.is_hidden %}
{{ field }}
{% else %}
{% endif %}
{% if not inline_class %}
{% endif %}
{% endfor %}
{% include 'bootstrap3/layout/help_text.html' %}
{% if field.label %}
{% endif %}
{% include 'bootstrap3/layout/radioselect.html' %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/layout/tab-link.html 0000664 0000000 0000000 00000000272 12643543520 0030141 0 ustar 00root root 0000000 0000000
{{ content|safe }}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/layout/uneditable_input.html 0000664 0000000 0000000 00000001121 12643543520 0031765 0 ustar 00root root 0000000 0000000 {% load crispy_forms_field %}
{% crispy_field field 'disabled' 'disabled' %}
{% include 'bootstrap3/layout/help_text.html' %}
{% include 'bootstrap3/uni_form.html' %}
{% endfor %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/whole_uni_form.html 0000664 0000000 0000000 00000000722 12643543520 0030137 0 ustar 00root root 0000000 0000000 {% load crispy_forms_utils %}
{% specialspaceless %}
{% if form_tag %}{% endif %}
{% endspecialspaceless %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap3/whole_uni_formset.html 0000664 0000000 0000000 00000001521 12643543520 0030651 0 ustar 00root root 0000000 0000000 {% load crispy_forms_tags %}
{% load crispy_forms_utils %}
{% specialspaceless %}
{% if formset_tag %}
{% endif %}
{% endspecialspaceless %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/ 0000775 0000000 0000000 00000000000 12643543520 0024235 5 ustar 00root root 0000000 0000000 django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/accordion-group.html 0000664 0000000 0000000 00000000716 12643543520 0030222 0 ustar 00root root 0000000 0000000
{{ fields|safe }}
{{ content|safe }}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/betterform.html 0000664 0000000 0000000 00000001234 12643543520 0027274 0 ustar 00root root 0000000 0000000 {% for fieldset in form.fieldsets %}
{% endif %}
{% endfor %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/display_form.html 0000664 0000000 0000000 00000000410 12643543520 0027606 0 ustar 00root root 0000000 0000000 {% if form.form_html %}
{% if include_media %}{{ form.media }}{% endif %}
{% if form_show_errors %}
{% include "bootstrap4/errors.html" %}
{% endif %}
{{ form.form_html }}
{% else %}
{% include "bootstrap4/uni_form.html" %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/errors.html 0000664 0000000 0000000 00000000433 12643543520 0026437 0 ustar 00root root 0000000 0000000 {% if form.non_field_errors %}
{% if form_error_title %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/errors_formset.html 0000664 0000000 0000000 00000000446 12643543520 0030202 0 ustar 00root root 0000000 0000000 {% if formset.non_form_errors %}
{{ form_error_title }}
{% endif %}-
{{ form.non_field_errors|unordered_list }}
{% if formset_error_title %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/field.html 0000664 0000000 0000000 00000004312 12643543520 0026206 0 ustar 00root root 0000000 0000000 {% load crispy_forms_field %}
{% if field.is_hidden %}
{{ field }}
{% else %}
{% if field|is_checkbox %}
{{ formset_error_title }}
{% endif %}-
{{ formset.non_form_errors|unordered_list }}
{% if label_class %}
{% endif %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/inputs.html 0000664 0000000 0000000 00000000571 12643543520 0026450 0 ustar 00root root 0000000 0000000 {% if inputs %}
{% endif %}
{% endif %}
<{% if tag %}{{ tag }}{% else %}div{% endif %} id="div_{{ field.auto_id }}" {% if not field|is_checkbox %}class="form-group row{% else %}class="checkbox{% endif %}{% if wrapper_class %} {{ wrapper_class }}{% endif %}{% if form_show_errors%}{% if field.errors %} has-error{% endif %}{% endif %}{% if field.css_classes %} {{ field.css_classes }}{% endif %}">
{% if field.label and not field|is_checkbox and form_show_labels %}
{% endif %}
{% if field|is_checkboxselectmultiple %}
{% include 'bootstrap4/layout/checkboxselectmultiple.html' %}
{% endif %}
{% if field|is_radioselect %}
{% include 'bootstrap4/layout/radioselect.html' %}
{% endif %}
{% if not field|is_checkboxselectmultiple and not field|is_radioselect %}
{% if field|is_checkbox and form_show_labels %}
{% else %}
{% endif %}
{% crispy_field field %}
{% include 'bootstrap4/layout/help_text_and_errors.html' %}
{% endif %}
{% endif %}
{% if field|is_checkbox %}
{% if label_class %}
{% if label_class %}
{% endif %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/layout/ 0000775 0000000 0000000 00000000000 12643543520 0025552 5 ustar 00root root 0000000 0000000 django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/layout/alert.html 0000664 0000000 0000000 00000000405 12643543520 0027546 0 ustar 00root root 0000000 0000000
{% for input in inputs %}
{% include "bootstrap4/layout/baseinput.html" %}
{% endfor %}
{% include 'bootstrap4/layout/field_errors_block.html' %}
{% for choice in field.field.choices %}
{% if not inline_class %}
checkboxselectmultiple_inline.html 0000664 0000000 0000000 00000001223 12643543520 0034457 0 ustar 00root root 0000000 0000000 django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/layout {% if field.is_hidden %}
{{ field }}
{% else %}
{% endif %}
{% if not inline_class %}
{% endif %}
{% endfor %}
{% include 'bootstrap4/layout/help_text.html' %}
{% if field.label %}
{% endif %}
{% include 'bootstrap4/layout/checkboxselectmultiple.html' %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/layout/div.html 0000664 0000000 0000000 00000000267 12643543520 0027227 0 ustar 00root root 0000000 0000000
{{ fields|safe }}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/layout/field_errors.html 0000664 0000000 0000000 00000000346 12643543520 0031122 0 ustar 00root root 0000000 0000000 {% if form_show_errors and field.errors %}
{% for error in field.errors %}
{{ error }}
{% endfor %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/layout/field_errors_block.html 0000664 0000000 0000000 00000000340 12643543520 0032266 0 ustar 00root root 0000000 0000000 {% if form_show_errors and field.errors %}
{% for error in field.errors %}
{{ error }}
{% endfor %} {% endif %} django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/layout/field_with_buttons.html 0000664 0000000 0000000 00000001764 12643543520 0032344 0 ustar 00root root 0000000 0000000 {% load crispy_forms_field %}
{% crispy_field field %}
{{ buttons|safe }}
{% include 'bootstrap4/layout/help_text_and_errors.html' %}
{{ fields_output|safe }}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/layout/help_text.html 0000664 0000000 0000000 00000000436 12643543520 0030437 0 ustar 00root root 0000000 0000000 {% if field.help_text %}
{% if help_text_inline %}
{{ field.help_text|safe }}
{% else %}
{{ field.help_text|safe }}
{% endif %} {% endif %} django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/layout/help_text_and_errors.html 0000664 0000000 0000000 00000000576 12643543520 0032662 0 ustar 00root root 0000000 0000000 {% if help_text_inline and not error_text_inline %} {% include 'bootstrap4/layout/help_text.html' %} {% endif %} {% if error_text_inline %} {% include 'bootstrap4/layout/field_errors.html' %} {% else %} {% include 'bootstrap4/layout/field_errors_block.html' %} {% endif %} {% if not help_text_inline %} {% include 'bootstrap4/layout/help_text.html' %} {% endif %} django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/layout/inline_field.html 0000664 0000000 0000000 00000001423 12643543520 0031061 0 ustar 00root root 0000000 0000000 {% load crispy_forms_field %} {% if field.is_hidden %} {{ field }} {% else %} {% if field|is_checkbox %}
{% crispy_field field 'placeholder' field.label %}
{% endif %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/layout/multifield.html 0000664 0000000 0000000 00000001025 12643543520 0030574 0 ustar 00root root 0000000 0000000 {% load crispy_forms_field %}
{% if field.is_hidden %}
{{ field }}
{% else %}
{% if field.label %}
{% endif %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/layout/prepended_appended_text.html 0000664 0000000 0000000 00000003463 12643543520 0033320 0 ustar 00root root 0000000 0000000 {% load crispy_forms_field %}
{% if field.is_hidden %}
{{ field }}
{% else %}
{% if field.label and form_show_labels %}
{% endif %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/layout/radioselect.html 0000664 0000000 0000000 00000001530 12643543520 0030735 0 ustar 00root root 0000000 0000000 {% load crispy_forms_filters %}
{% load l10n %}
{% if field|is_select %}
{% if crispy_prepended_text %}{{ crispy_prepended_text|safe }}{% endif %}
{% crispy_field field %}
{% if crispy_appended_text %}{{ crispy_appended_text|safe }}{% endif %}
{% else %}
{% if crispy_prepended_text %}{{ crispy_prepended_text|safe }}{% endif %}
{% crispy_field field %}
{% if crispy_appended_text %}{{ crispy_appended_text|safe }}{% endif %}
{% endif %}
{% include 'bootstrap4/layout/help_text_and_errors.html' %}
{% include 'bootstrap4/layout/field_errors_block.html' %}
{% for choice in field.field.choices %}
{% if not inline_class %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/layout/radioselect_inline.html 0000664 0000000 0000000 00000001275 12643543520 0032301 0 ustar 00root root 0000000 0000000 {% if field.is_hidden %}
{{ field }}
{% else %}
{% endif %}
{% if not inline_class %}
{% endif %}
{% endfor %}
{% include 'bootstrap4/layout/help_text.html' %}
{% if field.label %}
{% endif %}
{% include 'bootstrap4/layout/radioselect.html' %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/layout/tab-link.html 0000664 0000000 0000000 00000000272 12643543520 0030142 0 ustar 00root root 0000000 0000000
{{ content|safe }}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/layout/uneditable_input.html 0000664 0000000 0000000 00000001125 12643543520 0031772 0 ustar 00root root 0000000 0000000 {% load crispy_forms_field %}
{% crispy_field field 'disabled' 'disabled' %}
{% include 'bootstrap4/layout/help_text.html' %}
{% include 'bootstrap4/uni_form.html' %}
{% endfor %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/whole_uni_form.html 0000664 0000000 0000000 00000000722 12643543520 0030140 0 ustar 00root root 0000000 0000000 {% load crispy_forms_utils %}
{% specialspaceless %}
{% if form_tag %}{% endif %}
{% endspecialspaceless %}
django-crispy-forms-1.6.0/crispy_forms/templates/bootstrap4/whole_uni_formset.html 0000664 0000000 0000000 00000001521 12643543520 0030652 0 ustar 00root root 0000000 0000000 {% load crispy_forms_tags %}
{% load crispy_forms_utils %}
{% specialspaceless %}
{% if formset_tag %}
{% endif %}
{% endspecialspaceless %}
django-crispy-forms-1.6.0/crispy_forms/templates/uni_form/ 0000775 0000000 0000000 00000000000 12643543520 0023752 5 ustar 00root root 0000000 0000000 django-crispy-forms-1.6.0/crispy_forms/templates/uni_form/betterform.html 0000664 0000000 0000000 00000001232 12643543520 0027007 0 ustar 00root root 0000000 0000000 {% for fieldset in form.fieldsets %}
{% endif %}
{% endfor %}
django-crispy-forms-1.6.0/crispy_forms/templates/uni_form/display_form.html 0000664 0000000 0000000 00000000404 12643543520 0027326 0 ustar 00root root 0000000 0000000 {% if form.form_html %}
{% if include_media %}{{ form.media }}{% endif %}
{% if form_show_errors %}
{% include "uni_form/errors.html" %}
{% endif %}
{{ form.form_html }}
{% else %}
{% include "uni_form/uni_form.html" %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/uni_form/errors.html 0000664 0000000 0000000 00000000374 12643543520 0026160 0 ustar 00root root 0000000 0000000 {% if form.errors and form.non_field_errors %}
{% if form_error_title %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/uni_form/errors_formset.html 0000664 0000000 0000000 00000000367 12643543520 0027721 0 ustar 00root root 0000000 0000000 {% if formset.non_form_errors %}
{{ form_error_title }}
{% endif %}-
{{ form.non_field_errors|unordered_list }}
{% if formset_error_title %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/uni_form/field.html 0000664 0000000 0000000 00000002427 12643543520 0025730 0 ustar 00root root 0000000 0000000 {% load crispy_forms_field %}
{% if field.is_hidden %}
{{ field }}
{% else %}
{{ formset_error_title }}
{% endif %}-
{{ formset.non_form_errors|unordered_list }}
{% if form_show_errors %}
{% for error in field.errors %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/uni_form/field.strict.html 0000664 0000000 0000000 00000002206 12643543520 0027232 0 ustar 00root root 0000000 0000000 {% load crispy_forms_field %}
{% if field.is_hidden %}
{{ field }}
{% else %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/uni_form/layout/ 0000775 0000000 0000000 00000000000 12643543520 0025267 5 ustar 00root root 0000000 0000000 django-crispy-forms-1.6.0/crispy_forms/templates/uni_form/layout/baseinput.html 0000664 0000000 0000000 00000000700 12643543520 0030144 0 ustar 00root root 0000000 0000000
django-crispy-forms-1.6.0/crispy_forms/templates/uni_form/layout/buttonholder.html 0000664 0000000 0000000 00000000324 12643543520 0030665 0 ustar 00root root 0000000 0000000
django-crispy-forms-1.6.0/crispy_forms/templates/uni_form/layout/div.html 0000664 0000000 0000000 00000000267 12643543520 0026744 0 ustar 00root root 0000000 0000000 {{ error }}
{% endfor %} {% endif %} {% if field.label %} {% if field|is_checkbox %} {% crispy_field field %} {% endif %} {% endif %} {% if not field|is_checkbox %} {% crispy_field field %} {% endif %} {% if field.help_text %}{{ field.help_text|safe }}
{% endif %}
{{ fields|safe }}
django-crispy-forms-1.6.0/crispy_forms/templates/uni_form/layout/fieldset.html 0000664 0000000 0000000 00000000473 12643543520 0027760 0 ustar 00root root 0000000 0000000
django-crispy-forms-1.6.0/crispy_forms/templates/uni_form/layout/multifield.html 0000664 0000000 0000000 00000002012 12643543520 0030306 0 ustar 00root root 0000000 0000000
{% if form_show_errors %}
{% for field in multifield.bound_fields %}
{% if field.errors %}
{% for error in field.errors %}
django-crispy-forms-1.6.0/crispy_forms/templates/uni_form/multifield.html 0000664 0000000 0000000 00000001323 12643543520 0026775 0 ustar 00root root 0000000 0000000 {% load crispy_forms_field %}
{% if field.is_hidden %}
{{ field }}
{% else %}
{{ error }}
{% endfor %} {% endif %} {% endfor %} {% endif %} {% if multifield.label_html %}{{ multifield.label_html|safe }}
{% endif %}
{{ fields_output|safe }}
{% for field in multifield.bound_fields %}
{% if field.help_text %}
{{ field.help_text|safe }}
{% endif %} {% endfor %}
{% if form_show_labels and field.label %}
{% endif %}
{% crispy_field field %}
{% if field.help_text %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/uni_form/uni_form.html 0000664 0000000 0000000 00000000613 12643543520 0026456 0 ustar 00root root 0000000 0000000 {% if include_media %}{{ form.media }}{% endif %}
{% if form_show_errors %}
{% include "uni_form/errors.html" %}
{% endif %}
{% if form_style == "" or form_style %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/uni_form/uni_formset.html 0000664 0000000 0000000 00000000342 12643543520 0027171 0 ustar 00root root 0000000 0000000 {% with formset.management_form as form %}
{% include 'uni_form/uni_form.html' %}
{% endwith %}
{% for form in formset %}
{{ field.help_text|safe }}
{% endif %}
{% include 'uni_form/uni_form.html' %}
{% endfor %}
django-crispy-forms-1.6.0/crispy_forms/templates/uni_form/whole_uni_form.html 0000664 0000000 0000000 00000001050 12643543520 0027650 0 ustar 00root root 0000000 0000000 {% if form_tag %}{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templates/uni_form/whole_uni_formset.html 0000664 0000000 0000000 00000001377 12643543520 0030400 0 ustar 00root root 0000000 0000000 {% load crispy_forms_tags %}
{% if formset_tag %}
{% endif %}
django-crispy-forms-1.6.0/crispy_forms/templatetags/ 0000775 0000000 0000000 00000000000 12643543520 0022630 5 ustar 00root root 0000000 0000000 django-crispy-forms-1.6.0/crispy_forms/templatetags/__init__.py 0000664 0000000 0000000 00000000000 12643543520 0024727 0 ustar 00root root 0000000 0000000 django-crispy-forms-1.6.0/crispy_forms/templatetags/crispy_forms_field.py 0000664 0000000 0000000 00000012741 12643543520 0027071 0 ustar 00root root 0000000 0000000 try:
from itertools import izip
except ImportError:
izip = zip
import django
from django import forms
from django import template
from django.template import loader, Context
from django.conf import settings
from crispy_forms.utils import TEMPLATE_PACK, get_template_pack
register = template.Library()
@register.filter
def is_checkbox(field):
return isinstance(field.field.widget, forms.CheckboxInput)
@register.filter
def is_password(field):
return isinstance(field.field.widget, forms.PasswordInput)
@register.filter
def is_radioselect(field):
return isinstance(field.field.widget, forms.RadioSelect)
@register.filter
def is_select(field):
return isinstance(field.field.widget, forms.Select)
@register.filter
def is_checkboxselectmultiple(field):
return isinstance(field.field.widget, forms.CheckboxSelectMultiple)
@register.filter
def is_file(field):
return isinstance(field.field.widget, forms.ClearableFileInput)
@register.filter
def classes(field):
"""
Returns CSS classes of a field
"""
return field.widget.attrs.get('class', None)
@register.filter
def css_class(field):
"""
Returns widgets class name in lowercase
"""
return field.field.widget.__class__.__name__.lower()
def pairwise(iterable):
"""s -> (s0,s1), (s2,s3), (s4, s5), ..."""
a = iter(iterable)
return izip(a, a)
class CrispyFieldNode(template.Node):
def __init__(self, field, attrs):
self.field = field
self.attrs = attrs
self.html5_required = 'html5_required'
def render(self, context):
# Nodes are not threadsafe so we must store and look up our instance
# variables in the current rendering context first
if self not in context.render_context:
context.render_context[self] = (
template.Variable(self.field),
self.attrs,
template.Variable(self.html5_required)
)
field, attrs, html5_required = context.render_context[self]
field = field.resolve(context)
try:
html5_required = html5_required.resolve(context)
except template.VariableDoesNotExist:
html5_required = False
# If template pack has been overridden in FormHelper we can pick it from context
template_pack = context.get('template_pack', TEMPLATE_PACK)
widgets = getattr(field.field.widget, 'widgets', [field.field.widget])
if isinstance(attrs, dict):
attrs = [attrs] * len(widgets)
converters = {
'textinput': 'textinput textInput',
'fileinput': 'fileinput fileUpload',
'passwordinput': 'textinput textInput',
}
converters.update(getattr(settings, 'CRISPY_CLASS_CONVERTERS', {}))
for widget, attr in zip(widgets, attrs):
class_name = widget.__class__.__name__.lower()
class_name = converters.get(class_name, class_name)
css_class = widget.attrs.get('class', '')
if css_class:
if css_class.find(class_name) == -1:
css_class += " %s" % class_name
else:
css_class = class_name
if (
template_pack in ['bootstrap3', 'bootstrap4']
and not is_checkbox(field)
and not is_file(field)
):
css_class += ' form-control'
widget.attrs['class'] = css_class
# HTML5 required attribute
if html5_required and field.field.required and 'required' not in widget.attrs:
if field.field.widget.__class__.__name__ is not 'RadioSelect':
widget.attrs['required'] = 'required'
for attribute_name, attribute in attr.items():
attribute_name = template.Variable(attribute_name).resolve(context)
if attribute_name in widget.attrs:
widget.attrs[attribute_name] += " " + template.Variable(attribute).resolve(context)
else:
widget.attrs[attribute_name] = template.Variable(attribute).resolve(context)
return field
@register.tag(name="crispy_field")
def crispy_field(parser, token):
"""
{% crispy_field field attrs %}
"""
token = token.split_contents()
field = token.pop(1)
attrs = {}
# We need to pop tag name, or pairwise would fail
token.pop(0)
for attribute_name, value in pairwise(token):
attrs[attribute_name] = value
return CrispyFieldNode(field, attrs)
@register.simple_tag()
def crispy_addon(field, append="", prepend="", form_show_labels=True):
"""
Renders a form field using bootstrap's prepended or appended text::
{% crispy_addon form.my_field prepend="$" append=".00" %}
You can also just prepend or append like so
{% crispy_addon form.my_field prepend="$" %}
{% crispy_addon form.my_field append=".00" %}
"""
if field:
context = Context({
'field': field,
'form_show_errors': True,
'form_show_labels': form_show_labels,
})
template = loader.get_template('%s/layout/prepended_appended_text.html' % get_template_pack())
context['crispy_prepended_text'] = prepend
context['crispy_appended_text'] = append
if not prepend and not append:
raise TypeError("Expected a prepend and/or append argument")
if django.VERSION >= (1, 8):
context = context.flatten()
return template.render(context)
django-crispy-forms-1.6.0/crispy_forms/templatetags/crispy_forms_filters.py 0000664 0000000 0000000 00000006712 12643543520 0027457 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
import django
from django.conf import settings
from django.forms import forms
from django.forms.formsets import BaseFormSet
from django.template import Context
from django.template.loader import get_template
from django.utils.safestring import mark_safe
from django import template
from crispy_forms.compatibility import lru_cache
from crispy_forms.exceptions import CrispyError
from crispy_forms.utils import flatatt, TEMPLATE_PACK
@lru_cache()
def uni_formset_template(template_pack=TEMPLATE_PACK):
return get_template('%s/uni_formset.html' % template_pack)
@lru_cache()
def uni_form_template(template_pack=TEMPLATE_PACK):
return get_template('%s/uni_form.html' % template_pack)
register = template.Library()
@register.filter(name='crispy')
def as_crispy_form(form, template_pack=TEMPLATE_PACK, label_class="", field_class=""):
"""
The original and still very useful way to generate a div elegant form/formset::
{% load crispy_forms_tags %}
or, if you want to explicitly set the template pack::
{{ myform|crispy:"bootstrap" }}
In ``bootstrap3`` or ``bootstrap4`` for horizontal forms you can do::
{{ myform|label_class:"col-lg-2",field_class:"col-lg-8" }}
"""
if isinstance(form, BaseFormSet):
template = uni_formset_template(template_pack)
c = Context({
'formset': form,
'form_show_errors': True,
'form_show_labels': True,
'label_class': label_class,
'field_class': field_class,
})
else:
template = uni_form_template(template_pack)
c = Context({
'form': form,
'form_show_errors': True,
'form_show_labels': True,
'label_class': label_class,
'field_class': field_class,
})
if django.VERSION >= (1, 8):
c = c.flatten()
return template.render(c)
@register.filter(name='as_crispy_errors')
def as_crispy_errors(form, template_pack=TEMPLATE_PACK):
"""
Renders only form errors the same way as django-crispy-forms::
{% load crispy_forms_tags %}
{{ form|as_crispy_errors }}
or::
{{ form|as_crispy_errors:"bootstrap" }}
"""
if isinstance(form, BaseFormSet):
template = get_template('%s/errors_formset.html' % template_pack)
c = Context({'formset': form})
else:
template = get_template('%s/errors.html' % template_pack)
c = Context({'form': form})
if django.VERSION >= (1, 8):
c = c.flatten()
return template.render(c)
@register.filter(name='as_crispy_field')
def as_crispy_field(field, template_pack=TEMPLATE_PACK):
"""
Renders a form field like a django-crispy-forms field::
{% load crispy_forms_tags %}
{{ form.field|as_crispy_field }}
or::
{{ form.field|as_crispy_field:"bootstrap" }}
"""
if not isinstance(field, forms.BoundField) and settings.DEBUG:
raise CrispyError('|as_crispy_field got passed an invalid or inexistent field')
template = get_template('%s/field.html' % template_pack)
c = Context({'field': field, 'form_show_errors': True, 'form_show_labels': True})
if django.VERSION >= (1, 8):
c = c.flatten()
return template.render(c)
@register.filter(name='flatatt')
def flatatt_filter(attrs):
return mark_safe(flatatt(attrs))
django-crispy-forms-1.6.0/crispy_forms/templatetags/crispy_forms_tags.py 0000664 0000000 0000000 00000025005 12643543520 0026741 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
from copy import copy
import django
from django.conf import settings
from django.forms.formsets import BaseFormSet
from django.template import Context
from django.template.loader import get_template
from django import template
from crispy_forms.helper import FormHelper
from crispy_forms.compatibility import lru_cache, string_types
register = template.Library()
# We import the filters, so they are available when doing load crispy_forms_tags
from crispy_forms.templatetags.crispy_forms_filters import *
from crispy_forms.utils import TEMPLATE_PACK, get_template_pack
class ForLoopSimulator(object):
"""
Simulates a forloop tag, precisely::
{% for form in formset.forms %}
If `{% crispy %}` is rendering a formset with a helper, We inject a `ForLoopSimulator` object
in the context as `forloop` so that formset forms can do things like::
Fieldset("Item {{ forloop.counter }}", [...])
HTML("{% if forloop.first %}First form text{% endif %}"
"""
def __init__(self, formset):
self.len_values = len(formset.forms)
# Shortcuts for current loop iteration number.
self.counter = 1
self.counter0 = 0
# Reverse counter iteration numbers.
self.revcounter = self.len_values
self.revcounter0 = self.len_values - 1
# Boolean values designating first and last times through loop.
self.first = True
self.last = (0 == self.len_values - 1)
def iterate(self):
"""
Updates values as if we had iterated over the for
"""
self.counter += 1
self.counter0 += 1
self.revcounter -= 1
self.revcounter0 -= 1
self.first = False
self.last = (self.revcounter0 == self.len_values - 1)
def copy_context(context):
"""
Copies a `Context` variable. It uses `Context.__copy__` if available
(introduced in Django 1.3) or copy otherwise.
"""
if hasattr(context, "__copy__"):
return context.__copy__()
duplicate = copy(context)
duplicate.dicts = context.dicts[:]
return duplicate
class BasicNode(template.Node):
"""
Basic Node object that we can rely on for Node objects in normal
template tags. I created this because most of the tags we'll be using
will need both the form object and the helper string. This handles
both the form object and parses out the helper string into attributes
that templates can easily handle.
"""
def __init__(self, form, helper, template_pack=None):
self.form = form
if helper is not None:
self.helper = helper
else:
self.helper = None
self.template_pack = template_pack or get_template_pack()
def get_render(self, context):
"""
Returns a `Context` object with all the necessary stuff for rendering the form
:param context: `django.template.Context` variable holding the context for the node
`self.form` and `self.helper` are resolved into real Python objects resolving them
from the `context`. The `actual_form` can be a form or a formset. If it's a formset
`is_formset` is set to True. If the helper has a layout we use it, for rendering the
form or the formset's forms.
"""
# Nodes are not thread safe in multithreaded environments
# https://docs.djangoproject.com/en/dev/howto/custom-template-tags/#thread-safety-considerations
if self not in context.render_context:
context.render_context[self] = (
template.Variable(self.form),
template.Variable(self.helper) if self.helper else None
)
form, helper = context.render_context[self]
actual_form = form.resolve(context)
if self.helper is not None:
helper = helper.resolve(context)
else:
# If the user names the helper within the form `helper` (standard), we use it
# This allows us to have simplified tag syntax: {% crispy form %}
helper = FormHelper() if not hasattr(actual_form, 'helper') else actual_form.helper
# use template_pack from helper, if defined
try:
if helper.template_pack:
self.template_pack = helper.template_pack
except AttributeError:
pass
self.actual_helper = helper
# We get the response dictionary
is_formset = isinstance(actual_form, BaseFormSet)
response_dict = self.get_response_dict(helper, context, is_formset)
node_context = copy_context(context)
node_context.update(response_dict)
# If we have a helper's layout we use it, for the form or the formset's forms
if helper and helper.layout:
if not is_formset:
actual_form.form_html = helper.render_layout(actual_form, node_context, template_pack=self.template_pack)
else:
forloop = ForLoopSimulator(actual_form)
helper.render_hidden_fields = True
for form in actual_form:
node_context.update({'forloop': forloop})
form.form_html = helper.render_layout(form, node_context, template_pack=self.template_pack)
forloop.iterate()
if is_formset:
response_dict.update({'formset': actual_form})
else:
response_dict.update({'form': actual_form})
return Context(response_dict)
def get_response_dict(self, helper, context, is_formset):
"""
Returns a dictionary with all the parameters necessary to render the form/formset in a template.
:param context: `django.template.Context` for the node
:param is_formset: Boolean value. If set to True, indicates we are working with a formset.
"""
if not isinstance(helper, FormHelper):
raise TypeError('helper object provided to {% crispy %} tag must be a crispy.helper.FormHelper object.')
attrs = helper.get_attributes(template_pack=self.template_pack)
form_type = "form"
if is_formset:
form_type = "formset"
# We take form/formset parameters from attrs if they are set, otherwise we use defaults
response_dict = {
'template_pack': self.template_pack,
'%s_action' % form_type: attrs['attrs'].get("action", ''),
'%s_method' % form_type: attrs.get("form_method", 'post'),
'%s_tag' % form_type: attrs.get("form_tag", True),
'%s_class' % form_type: attrs['attrs'].get("class", ''),
'%s_id' % form_type: attrs['attrs'].get("id", ""),
'%s_style' % form_type: attrs.get("form_style", None),
'form_error_title': attrs.get("form_error_title", None),
'formset_error_title': attrs.get("formset_error_title", None),
'form_show_errors': attrs.get("form_show_errors", True),
'help_text_inline': attrs.get("help_text_inline", False),
'html5_required': attrs.get("html5_required", False),
'form_show_labels': attrs.get("form_show_labels", True),
'disable_csrf': attrs.get("disable_csrf", False),
'inputs': attrs.get('inputs', []),
'is_formset': is_formset,
'%s_attrs' % form_type: attrs.get('attrs', ''),
'flat_attrs': attrs.get('flat_attrs', ''),
'error_text_inline': attrs.get('error_text_inline', True),
'label_class': attrs.get('label_class', ''),
'label_size': attrs.get('label_size', 0),
'field_class': attrs.get('field_class', ''),
'include_media': attrs.get('include_media', True),
}
# Handles custom attributes added to helpers
for attribute_name, value in attrs.items():
if attribute_name not in response_dict:
response_dict[attribute_name] = value
if 'csrf_token' in context:
response_dict['csrf_token'] = context['csrf_token']
return response_dict
@lru_cache()
def whole_uni_formset_template(template_pack=TEMPLATE_PACK):
return get_template('%s/whole_uni_formset.html' % template_pack)
@lru_cache()
def whole_uni_form_template(template_pack=TEMPLATE_PACK):
return get_template('%s/whole_uni_form.html' % template_pack)
class CrispyFormNode(BasicNode):
def render(self, context):
c = self.get_render(context)
if self.actual_helper is not None and getattr(self.actual_helper, 'template', False):
template = get_template(self.actual_helper.template)
else:
if c['is_formset']:
template = whole_uni_formset_template(self.template_pack)
else:
template = whole_uni_form_template(self.template_pack)
if django.VERSION >= (1, 8):
c = c.flatten()
return template.render(c)
# {% crispy %} tag
@register.tag(name="crispy")
def do_uni_form(parser, token):
"""
You need to pass in at least the form/formset object, and can also pass in the
optional `crispy_forms.helpers.FormHelper` object.
helper (optional): A `crispy_forms.helper.FormHelper` object.
Usage::
{% load crispy_tags %}
{% crispy form form.helper %}
You can also provide the template pack as the third argument::
{% crispy form form.helper 'bootstrap' %}
If the `FormHelper` attribute is named `helper` you can simply do::
{% crispy form %}
{% crispy form 'bootstrap' %}
"""
token = token.split_contents()
form = token.pop(1)
helper = None
template_pack = "'%s'" % get_template_pack()
# {% crispy form helper %}
try:
helper = token.pop(1)
except IndexError:
pass
# {% crispy form helper 'bootstrap' %}
try:
template_pack = token.pop(1)
except IndexError:
pass
# {% crispy form 'bootstrap' %}
if (
helper is not None and
isinstance(helper, string_types) and
("'" in helper or '"' in helper)
):
template_pack = helper
helper = None
if template_pack is not None:
template_pack = template_pack[1:-1]
ALLOWED_TEMPLATE_PACKS = getattr(
settings,
'CRISPY_ALLOWED_TEMPLATE_PACKS',
('bootstrap', 'uni_form', 'bootstrap3', 'bootstrap4')
)
if template_pack not in ALLOWED_TEMPLATE_PACKS:
raise template.TemplateSyntaxError(
"crispy tag's template_pack argument should be in %s" %
str(ALLOWED_TEMPLATE_PACKS)
)
return CrispyFormNode(form, helper, template_pack=template_pack)
django-crispy-forms-1.6.0/crispy_forms/templatetags/crispy_forms_utils.py 0000664 0000000 0000000 00000001756 12643543520 0027152 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
import re
from django import template
from django.utils.encoding import force_text
from django.utils.functional import allow_lazy
from crispy_forms.compatibility import text_type
register = template.Library()
def remove_spaces(value):
html = re.sub(r'>\s{3,}<', '> <', force_text(value))
return re.sub(r'/><', r'/> <', force_text(html))
remove_spaces = allow_lazy(remove_spaces, text_type)
class SpecialSpacelessNode(template.Node):
def __init__(self, nodelist):
self.nodelist = nodelist
def render(self, context):
return remove_spaces(self.nodelist.render(context).strip())
@register.tag
def specialspaceless(parser, token):
"""
Removes whitespace between HTML tags, and introduces a whitespace
after buttons an inputs, necessary for Bootstrap to place them
correctly in the layout.
"""
nodelist = parser.parse(('endspecialspaceless',))
parser.delete_first_token()
return SpecialSpacelessNode(nodelist)
django-crispy-forms-1.6.0/crispy_forms/tests/ 0000775 0000000 0000000 00000000000 12643543520 0021300 5 ustar 00root root 0000000 0000000 django-crispy-forms-1.6.0/crispy_forms/tests/__init__.py 0000664 0000000 0000000 00000000000 12643543520 0023377 0 ustar 00root root 0000000 0000000 django-crispy-forms-1.6.0/crispy_forms/tests/compatibility.py 0000664 0000000 0000000 00000000323 12643543520 0024521 0 ustar 00root root 0000000 0000000 # coding: utf-8
try:
from django.template.loader import get_template_from_string
except ImportError:
from django.template import Engine
get_template_from_string = Engine.get_default().from_string
django-crispy-forms-1.6.0/crispy_forms/tests/conftest.py 0000664 0000000 0000000 00000002350 12643543520 0023477 0 ustar 00root root 0000000 0000000 # coding: utf-8
import pytest
from crispy_forms.layout import Layout, Div, Field, Submit, Fieldset, HTML
only_uni_form = pytest.mark.only('uni_form')
only_bootstrap = pytest.mark.only('bootstrap', 'bootstrap3', 'bootstrap4')
only_bootstrap3 = pytest.mark.only('bootstrap3')
only_bootstrap4 = pytest.mark.only('bootstrap4')
@pytest.fixture
def advanced_layout():
return Layout(
Div(
Div(Div('email')),
Div(Field('password1')),
Submit("save", "save"),
Fieldset(
"legend",
'first_name',
HTML("extra text"),
),
Layout(
"password2",
),
),
'last_name',
)
@pytest.fixture(autouse=True, params=('uni_form', 'bootstrap', 'bootstrap3',
'bootstrap4'))
def template_packs(request, settings):
check_template_pack(request._pyfuncitem._obj, request.param)
settings.CRISPY_TEMPLATE_PACK = request.param
def check_template_pack(function, template_pack):
if hasattr(function, 'only'):
mark = function.only
if template_pack not in mark.args:
pytest.skip('Requires %s template pack' % ' or '.join(mark.args))
django-crispy-forms-1.6.0/crispy_forms/tests/forms.py 0000664 0000000 0000000 00000007462 12643543520 0023011 0 ustar 00root root 0000000 0000000 import django
from django import forms
from django.db import models
from crispy_forms.helper import FormHelper
class TestForm(forms.Form):
is_company = forms.CharField(label="company", required=False, widget=forms.CheckboxInput())
email = forms.EmailField(label="email", max_length=30, required=True, widget=forms.TextInput(), help_text="Insert your email")
password1 = forms.CharField(label="password", max_length=30, required=True, widget=forms.PasswordInput())
password2 = forms.CharField(label="re-enter password", max_length=30, required=True, widget=forms.PasswordInput())
first_name = forms.CharField(label="first name", max_length=5, required=True, widget=forms.TextInput())
last_name = forms.CharField(label="last name", max_length=5, required=True, widget=forms.TextInput())
datetime_field = forms.DateTimeField(label="date time", widget=forms.SplitDateTimeWidget())
def clean(self):
super(TestForm, self).clean()
password1 = self.cleaned_data.get('password1', None)
password2 = self.cleaned_data.get('password2', None)
if not password1 and not password2 or password1 != password2:
raise forms.ValidationError("Passwords dont match")
return self.cleaned_data
class TestForm2(TestForm):
def __init__(self, *args, **kwargs):
super(TestForm2, self).__init__(*args, **kwargs)
self.helper = FormHelper(self)
class CheckboxesTestForm(forms.Form):
checkboxes = forms.MultipleChoiceField(
choices=(
(1, "Option one"),
(2, "Option two"),
(3, "Option three")
),
initial=(1,),
widget=forms.CheckboxSelectMultiple,
)
alphacheckboxes = forms.MultipleChoiceField(
choices=(
('option_one', "Option one"),
('option_two', "Option two"),
('option_three', "Option three")
),
initial=('option_two', 'option_three'),
widget=forms.CheckboxSelectMultiple,
)
numeric_multiple_checkboxes = forms.MultipleChoiceField(
choices=(
(1, "Option one"),
(2, "Option two"),
(3, "Option three")
),
initial=(1, 2),
widget=forms.CheckboxSelectMultiple,
)
inline_radios = forms.ChoiceField(
choices=(
('option_one', "Option one"),
('option_two', "Option two"),
),
widget=forms.RadioSelect,
initial='option_two',
)
class CrispyTestModel(models.Model):
email = models.CharField(max_length=20)
password = models.CharField(max_length=20)
class TestForm3(forms.ModelForm):
class Meta:
model = CrispyTestModel
fields = ['email', 'password']
exclude = ['password']
def __init__(self, *args, **kwargs):
super(TestForm3, self).__init__(*args, **kwargs)
self.helper = FormHelper(self)
class TestForm4(forms.ModelForm):
class Meta:
"""
before Django1.6, one cannot use __all__ shortcut for fields
without getting the following error:
django.core.exceptions.FieldError: Unknown field(s) (a, l, _) specified for CrispyTestModel
because obviously it casts the string to a set
"""
model = CrispyTestModel
if django.VERSION >= (1, 6):
fields = '__all__' # eliminate RemovedInDjango18Warning
class TestForm5(forms.Form):
choices = [
(1, 1),
(2, 2),
(1000, 1000),
]
checkbox_select_multiple = forms.MultipleChoiceField(
widget=forms.CheckboxSelectMultiple,
choices=choices
)
radio_select = forms.ChoiceField(
widget=forms.RadioSelect,
choices=choices
)
pk = forms.IntegerField()
class TestFormWithMedia(forms.Form):
class Media:
css = {'all': ('test.css',)}
js = ('test.js',)
django-crispy-forms-1.6.0/crispy_forms/tests/templates/ 0000775 0000000 0000000 00000000000 12643543520 0023276 5 ustar 00root root 0000000 0000000 django-crispy-forms-1.6.0/crispy_forms/tests/templates/crispy_render_template.html 0000664 0000000 0000000 00000000060 12643543520 0030723 0 ustar 00root root 0000000 0000000 {% load crispy_forms_tags %}
{% crispy form %}
django-crispy-forms-1.6.0/crispy_forms/tests/templates/custom_field_template.html 0000664 0000000 0000000 00000000103 12643543520 0030526 0 ustar 00root root 0000000 0000000 Special custom field
{% include 'bootstrap/field.html' %} django-crispy-forms-1.6.0/crispy_forms/tests/templates/custom_form_template.html 0000664 0000000 0000000 00000000113 12643543520 0030407 0 ustar 00root root 0000000 0000000Special custom form
{% include "bootstrap/whole_uni_form.html" %} django-crispy-forms-1.6.0/crispy_forms/tests/test_dynamic_api.py 0000664 0000000 0000000 00000032674 12643543520 0025202 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*- from django import forms import pytest from .conftest import only_uni_form from crispy_forms.compatibility import string_types from crispy_forms.exceptions import DynamicError from crispy_forms.helper import FormHelper, FormHelpersException from crispy_forms.layout import ( Layout, Fieldset, MultiField, HTML, Div, Field ) from crispy_forms.bootstrap import AppendedText from crispy_forms.tests.forms import TestForm def test_wrap_all_fields(): helper = FormHelper() layout = Layout( 'email', 'password1', 'password2', ) helper.layout = layout helper.all().wrap(Field, css_class="test-class") for field in layout.fields: assert isinstance(field, Field) assert field.attrs['class'] == "test-class" assert layout[0][0] == 'email' assert layout[1][0] == 'password1' assert layout[2][0] == 'password2' def test_wrap_selected_fields(): helper = FormHelper() layout = Layout( 'email', 'password1', 'password2', ) helper.layout = layout helper[1:3].wrap(Field, css_class="test-class") assert not isinstance(layout.fields[0], Field) assert isinstance(layout.fields[1], Field) assert isinstance(layout.fields[2], Field) helper[0].wrap(Fieldset, 'legend', css_class="test-class") assert isinstance(layout[0], Fieldset) assert layout[0].legend == 'legend' assert layout[0][0] == 'email' def test_wrap_together_with_slices(): helper = FormHelper() layout = Layout( 'email', 'password1', 'password2', ) helper.layout = layout helper[1:3].wrap_together(Field, css_class="test-class") assert layout.fields[0] == 'email' assert isinstance(layout.fields[1], Field) assert layout.fields[1][0] == 'password1' assert layout.fields[1][1] == 'password2' layout = Layout( Div('email'), 'password1', 'password2', ) helper.layout = layout helper[0:3].wrap_together(Field, css_class="test-class") assert isinstance(layout.fields[0], Field) assert isinstance(layout.fields[0][0], Div) assert layout.fields[0][0][0] == 'email' assert layout.fields[0][1] == 'password1' assert layout.fields[0][2] == 'password2' layout = Layout( 'email', 'password1', 'password2', ) helper.layout = layout helper[0].wrap_together(Field, css_class="test-class") assert isinstance(layout.fields[0], Field) assert layout.fields[1] == 'password1' assert layout.fields[2] == 'password2' layout = Layout( 'email', 'password1', 'password2', ) helper.layout = layout helper[0].wrap_together(Fieldset, "legend", css_class="test-class") assert isinstance(layout.fields[0], Fieldset) assert layout.fields[0].legend == 'legend' assert layout.fields[1] == 'password1' assert layout.fields[2] == 'password2' def test_wrap_together_partial_slices(): helper = FormHelper() layout = Layout( 'email', 'password1', 'password2', ) helper.layout = layout helper[:2].wrap_together(Field, css_class="test-class") assert isinstance(layout.fields[0], Field) assert layout.fields[1] == 'password2' assert layout.fields[0][0] == 'email' assert layout.fields[0][1] == 'password1' helper = FormHelper() layout = Layout( 'email', 'password1', 'password2', ) helper.layout = layout helper[1:].wrap_together(Field, css_class="test-class") assert layout.fields[0] == 'email' assert isinstance(layout.fields[1], Field) assert layout.fields[1][0] == 'password1' assert layout.fields[1][1] == 'password2' def test_update_attributes(): helper = FormHelper() helper.layout = Layout( 'email', Field('password1'), 'password2', ) helper['password1'].update_attributes(readonly=True) assert 'readonly' in helper.layout[1].attrs def test_update_attributes_and_wrap_once(): helper = FormHelper() layout = Layout( 'email', Field('password1'), 'password2', ) helper.layout = layout helper.filter(Field).update_attributes(readonly=True) assert isinstance(layout[1], Field) assert layout[1].attrs == {'readonly': True} layout = Layout( 'email', Div(Field('password1')), 'password2', ) helper.layout = layout helper.filter(Field, max_level=2).update_attributes(readonly=True) assert isinstance(layout[1][0], Field) assert layout[1][0].attrs == {'readonly': True} layout = Layout( 'email', Div(Field('password1')), 'password2', ) helper.layout = layout helper.filter(string_types, greedy=True).wrap_once(Field) helper.filter(Field, greedy=True).update_attributes(readonly=True) assert isinstance(layout[0], Field) assert isinstance(layout[1][0], Field) assert isinstance(layout[1][0][0], string_types) assert isinstance(layout[2], Field) assert layout[1][0].attrs == {'readonly': True} assert layout[0].attrs == {'readonly': True} assert layout[2].attrs == {'readonly': True} def test_get_layout_objects(): layout_1 = Layout( Div() ) assert layout_1.get_layout_objects(Div) == [[[0], 'div']] layout_2 = Layout( Div( Div( Div('email') ), Div('password1'), 'password2' ) ) assert layout_2.get_layout_objects(Div) == [[[0], 'div']] assert layout_2.get_layout_objects(Div, max_level=1) == [ [[0], 'div'], [[0, 0], 'div'], [[0, 1], 'div'] ] assert layout_2.get_layout_objects(Div, max_level=2) == [ [[0], 'div'], [[0, 0], 'div'], [[0, 0, 0], 'div'], [[0, 1], 'div'] ] layout_3 = Layout( 'email', Div('password1'), 'password2', ) assert layout_3.get_layout_objects(string_types, max_level=2) == [ [[0], 'email'], [[1, 0], 'password1'], [[2], 'password2'] ] layout_4 = Layout( Div( Div('field_name'), 'field_name2', ), Div('password'), 'extra_field' ) assert layout_4.get_layout_objects(Div) == [ [[0], 'div'], [[1], 'div'] ] assert layout_4.get_layout_objects(Div, max_level=1) == [ [[0], 'div'], [[0, 0], 'div'], [[1], 'div'] ] def test_filter_and_wrap(): helper = FormHelper() layout = Layout( 'email', Div('password1'), 'password2', ) helper.layout = layout helper.filter(string_types).wrap(Field, css_class="test-class") assert isinstance(layout.fields[0], Field) assert isinstance(layout.fields[1], Div) assert isinstance(layout.fields[2], Field) assert layout[2][0] == 'password2' # Wrapping a div in a div helper.filter(Div).wrap(Div, css_class="test-class") assert isinstance(layout.fields[1], Div) assert isinstance(layout.fields[1].fields[0], Div) assert layout[1][0][0] == 'password1' def test_filter_and_wrap_side_effects(): helper = FormHelper() layout = Layout( Div( 'extra_field', Div('password1'), ), ) helper.layout = layout with pytest.raises(DynamicError): helper.filter(Div, max_level=2).wrap(Div, css_class="test-class") def test_get_field_names(): layout_1 = Div( 'field_name' ) assert layout_1.get_field_names() == [ [[0], 'field_name'] ] layout_2 = Div( Div('field_name') ) assert layout_2.get_field_names() == [ [[0, 0], 'field_name'] ] layout_3 = Div( Div('field_name'), 'password' ) assert layout_3.get_field_names() == [ [[0, 0], 'field_name'], [[1], 'password'] ] layout_4 = Div( Div( Div('field_name'), 'field_name2', ), Div('password'), 'extra_field' ) assert layout_4.get_field_names() == [ [[0, 0, 0], 'field_name'], [[0, 1], 'field_name2'], [[1, 0], 'password'], [[2], 'extra_field'] ] layout_5 = Div( Div( 'field_name', 'field_name2', ), 'extra_field' ) assert layout_5.get_field_names() == [ [[0, 0], 'field_name'], [[0, 1], 'field_name2'], [[1], 'extra_field'], ] def test_layout_get_field_names(): layout_1 = Layout( Div('field_name'), 'password' ) assert layout_1.get_field_names() == [ [[0, 0], 'field_name'], [[1], 'password'], ] layout_2 = Layout( Div('field_name'), 'password', Fieldset('legend', 'extra_field') ) assert layout_2.get_field_names() == [ [[0, 0], 'field_name'], [[1], 'password'], [[2, 0], 'extra_field'], ] layout_3 = Layout( Div( Div( Div('email') ), Div('password1'), 'password2' ) ) assert layout_3.get_field_names() == [ [[0, 0, 0, 0], 'email'], [[0, 1, 0], 'password1'], [[0, 2], 'password2'], ] def test_filter_by_widget(advanced_layout): form = TestForm() form.helper = FormHelper(form) form.helper.layout = advanced_layout assert form.helper.filter_by_widget(forms.PasswordInput).slice == [ [[0, 1, 0, 0], 'password1'], [[0, 4, 0], 'password2'], ] def test_exclude_by_widget(advanced_layout): form = TestForm() form.helper = FormHelper(form) form.helper.layout = advanced_layout assert form.helper.exclude_by_widget(forms.PasswordInput).slice == [ [[0, 0, 0, 0], 'email'], [[0, 3, 0], 'first_name'], [[1], 'last_name'], ] def test_exclude_by_widget_and_wrap(advanced_layout): form = TestForm() form.helper = FormHelper(form) form.helper.layout = advanced_layout form.helper.exclude_by_widget(forms.PasswordInput).wrap(Field, css_class='hero') # Check wrapped fields assert isinstance(form.helper.layout[0][0][0][0], Field) assert isinstance(form.helper.layout[0][3][0], Field) assert isinstance(form.helper.layout[1], Field) # Check others stay the same assert isinstance(form.helper.layout[0][3][1], HTML) assert isinstance(form.helper.layout[0][1][0][0], string_types) assert isinstance(form.helper.layout[0][4][0], string_types) def test_all_without_layout(): form = TestForm() form.helper = FormHelper() with pytest.raises(FormHelpersException): form.helper.all().wrap(Div) def test_filter_by_widget_without_form(advanced_layout): form = TestForm() form.helper = FormHelper() form.helper.layout = advanced_layout with pytest.raises(FormHelpersException): form.helper.filter_by_widget(forms.PasswordInput) def test_formhelper__getitem__(): helper = FormHelper() layout = Layout( Div('email'), 'password1', ) helper.layout = layout helper['email'].wrap(Field, css_class='hero') assert isinstance(layout[0][0], Field) assert layout[0][0][0] == 'email' helper = FormHelper() helper.layout = Layout('password1') helper['password1'].wrap(AppendedText, "extra") assert isinstance(helper.layout[0], AppendedText) assert helper.layout[0][0] == 'password1' assert helper.layout[0].text == 'extra' def test_formhelper__setitem__(): helper = FormHelper() layout = Layout( 'first_field', Div('email') ) helper.layout = layout helper[0] = 'replaced' assert layout[0] == 'replaced' def test_formhelper__delitem__and__len__(): helper = FormHelper() layout = Layout( 'first_field', Div('email') ) helper.layout = layout del helper[0] assert len(helper) == 1 def test__delitem__and__len__layout_object(): layout = Layout( 'first_field', Div('email') ) del layout[0] assert len(layout) == 1 def test__getitem__layout_object(): layout = Layout( Div( Div( Div('email') ), Div('password1'), 'password2' ) ) assert isinstance(layout[0], Div) assert isinstance(layout[0][0], Div) assert isinstance(layout[0][0][0], Div) assert isinstance(layout[0][1], Div) assert isinstance(layout[0][1][0], string_types) assert isinstance(layout[0][2], string_types) def test__getattr__append_layout_object(): layout = Layout( Div('email') ) layout.append('password1') assert isinstance(layout[0], Div) assert isinstance(layout[0][0], string_types) assert isinstance(layout[1], string_types) def test__setitem__layout_object(): layout = Layout( Div('email') ) layout[0][0] = 'password1' assert isinstance(layout[0], Div) assert layout[0][0] == 'password1' @only_uni_form def test_filter(): helper = FormHelper() helper.layout = Layout( Div( MultiField('field_name'), 'field_name2', ), Div('password'), 'extra_field' ) assert helper.filter(Div, MultiField).slice == [ [[0], 'div'], [[1], 'div'] ] assert helper.filter(Div, MultiField, max_level=1).slice == [ [[0], 'div'], [[0, 0], 'multifield'], [[1], 'div'] ] assert helper.filter(MultiField, max_level=1).slice == [ [[0, 0], 'multifield'] ] django-crispy-forms-1.6.0/crispy_forms/tests/test_form_helper.py 0000664 0000000 0000000 00000053471 12643543520 0025225 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*- from __future__ import unicode_literals import re import django from django import forms from django.core.urlresolvers import reverse from django.forms.models import formset_factory from django.middleware.csrf import _get_new_csrf_key from django.template import ( TemplateSyntaxError, Context ) import pytest from django.utils.translation import ugettext_lazy as _ from .compatibility import get_template_from_string from .conftest import only_uni_form, only_bootstrap3, only_bootstrap4, only_bootstrap from .forms import TestForm, TestFormWithMedia from crispy_forms.bootstrap import ( FieldWithButtons, PrependedAppendedText, AppendedText, PrependedText, StrictButton ) from crispy_forms.compatibility import text_type from crispy_forms.helper import FormHelper, FormHelpersException from crispy_forms.layout import ( Layout, Submit, Reset, Hidden, Button, MultiField, Field ) from crispy_forms.utils import render_crispy_form from crispy_forms.templatetags.crispy_forms_tags import CrispyFormNode def test_inputs(settings): form_helper = FormHelper() form_helper.add_input(Submit('my-submit', 'Submit', css_class="button white")) form_helper.add_input(Reset('my-reset', 'Reset')) form_helper.add_input(Hidden('my-hidden', 'Hidden')) form_helper.add_input(Button('my-button', 'Button')) template = get_template_from_string(""" {% load crispy_forms_tags %} {% crispy form form_helper %} """) c = Context({'form': TestForm(), 'form_helper': form_helper}) html = template.render(c) assert 'button white' in html assert 'id="submit-id-my-submit"' in html assert 'id="reset-id-my-reset"' in html assert 'name="my-hidden"' in html assert 'id="button-id-my-button"' in html if settings.CRISPY_TEMPLATE_PACK == 'uni_form': assert 'submit submitButton' in html assert 'reset resetButton' in html assert 'class="button"' in html else: assert 'class="btn"' in html assert 'btn btn-primary' in html assert 'btn btn-inverse' in html assert len(re.findall(r'Special custom field
") == 2 @only_uni_form def test_form_show_errors(): form = TestForm({ 'email': 'invalidemail', 'first_name': 'first_name_too_long', 'last_name': 'last_name_too_long', 'password1': 'yes', 'password2': 'yes', }) form.helper = FormHelper() form.helper.layout = Layout( Field('email'), Field('first_name'), Field('last_name'), Field('password1'), Field('password2'), ) form.is_valid() form.helper.form_show_errors = True html = render_crispy_form(form) assert html.count('error') == 9 form.helper.form_show_errors = False html = render_crispy_form(form) assert html.count('error') == 0 @only_uni_form def test_multifield_errors(): form = TestForm({ 'email': 'invalidemail', 'password1': 'yes', 'password2': 'yes', }) form.helper = FormHelper() form.helper.layout = Layout( MultiField('legend', 'email') ) form.is_valid() form.helper.form_show_errors = True html = render_crispy_form(form) assert html.count('error') == 3 # Reset layout for avoiding side effects form.helper.layout = Layout( MultiField('legend', 'email') ) form.helper.form_show_errors = False html = render_crispy_form(form) assert html.count('error') == 0 @only_bootstrap def test_bootstrap_form_show_errors(): form = TestForm({ 'email': 'invalidemail', 'first_name': 'first_name_too_long', 'last_name': 'last_name_too_long', 'password1': 'yes', 'password2': 'yes', }) form.helper = FormHelper() form.helper.layout = Layout( AppendedText('email', 'whatever'), PrependedText('first_name', 'blabla'), PrependedAppendedText('last_name', 'foo', 'bar'), AppendedText('password1', 'whatever'), PrependedText('password2', 'blabla'), ) form.is_valid() form.helper.form_show_errors = True html = render_crispy_form(form) assert html.count('error') == 6 form.helper.form_show_errors = False html = render_crispy_form(form) assert html.count('error') == 0 @only_bootstrap def test_error_text_inline(settings): form = TestForm({'email': 'invalidemail'}) form.helper = FormHelper() layout = Layout( AppendedText('first_name', 'wat'), PrependedText('email', '@'), PrependedAppendedText('last_name', '@', 'wat'), ) form.helper.layout = layout form.is_valid() html = render_crispy_form(form) help_class = 'help-inline' if settings.CRISPY_TEMPLATE_PACK in ['bootstrap3', 'bootstrap4']: help_class = 'help-block' matches = re.findall( '') error_position = html.find('')
assert help_position < error_position
# Viceversa
form = TestForm({'email': 'invalidemail'})
form.helper = FormHelper()
form.helper.error_text_inline = True
form.helper.help_text_inline = False
form.helper.layout = Layout('email')
form.is_valid()
html = render_crispy_form(form)
# Check that error goes before help, otherwise CSS won't work
error_position = html.find('')
help_position = html.find(' ')
assert error_position < help_position
@only_bootstrap
def test_form_show_labels():
form = TestForm()
form.helper = FormHelper()
form.helper.layout = Layout(
'password1',
FieldWithButtons(
'password2',
StrictButton("Confirm")
),
PrependedText(
'first_name',
'Mr.'
),
AppendedText(
'last_name',
'@'
),
PrependedAppendedText(
'datetime_field',
'on',
'secs'
)
)
form.helper.form_show_labels = False
html = render_crispy_form(form)
assert html.count("