blinkster: comparison web/lib/django/forms/formsets.py

equal deleted inserted replaced

-:b758351d191f
+:cc9b7e14412b
 from forms import Form
+from django.core.exceptions import ValidationError
 from django.utils.encoding import StrAndUnicode
 from django.utils.safestring import mark_safe
 from django.utils.translation import ugettext as _
 from fields import IntegerField, BooleanField
 from widgets import Media, HiddenInput
-from util import ErrorList, ErrorDict, ValidationError
+from util import ErrorList
 __all__ = ('BaseFormSet', 'all_valid')
 # special field names
 TOTAL_FORM_COUNT = 'TOTAL_FORMS'
 INITIAL_FORM_COUNT = 'INITIAL_FORMS'
+MAX_NUM_FORM_COUNT = 'MAX_NUM_FORMS'
 ORDERING_FIELD_NAME = 'ORDER'
 DELETION_FIELD_NAME = 'DELETE'
 class ManagementForm(Form):
 """
 increment the count field of this form as well.
 """
 def __init__(self, *args, **kwargs):
 self.base_fields[TOTAL_FORM_COUNT] = IntegerField(widget=HiddenInput)
 self.base_fields[INITIAL_FORM_COUNT] = IntegerField(widget=HiddenInput)
+self.base_fields[MAX_NUM_FORM_COUNT] = IntegerField(required=False, widget=HiddenInput)
 super(ManagementForm, self).__init__(*args, **kwargs)
 class BaseFormSet(StrAndUnicode):
 """
 A collection of instances of the same Form class.
 if not form.is_valid():
 raise ValidationError('ManagementForm data is missing or has been tampered with')
 else:
 form = ManagementForm(auto_id=self.auto_id, prefix=self.prefix, initial={
 TOTAL_FORM_COUNT: self.total_form_count(),
-INITIAL_FORM_COUNT: self.initial_form_count()
+INITIAL_FORM_COUNT: self.initial_form_count(),
+MAX_NUM_FORM_COUNT: self.max_num
 })
 return form
 management_form = property(_management_form)
 def total_form_count(self):
 """Returns the total number of forms in this FormSet."""
 if self.data or self.files:
 return self.management_form.cleaned_data[TOTAL_FORM_COUNT]
 else:
-total_forms = self.initial_form_count() + self.extra
+initial_forms = self.initial_form_count()
-if total_forms > self.max_num > 0:
+total_forms = initial_forms + self.extra
+# Allow all existing related objects/inlines to be displayed,
+# but don't allow extra beyond max_num.
+if initial_forms > self.max_num >= 0:
+total_forms = initial_forms
+elif total_forms > self.max_num >= 0:
 total_forms = self.max_num
 return total_forms
 def initial_form_count(self):
 """Returns the number of forms that are required in this FormSet."""
 if self.data or self.files:
 return self.management_form.cleaned_data[INITIAL_FORM_COUNT]
 else:
 # Use the length of the inital data if it's there, 0 otherwise.
 initial_forms = self.initial and len(self.initial) or 0
-if initial_forms > self.max_num > 0:
+if initial_forms > self.max_num >= 0:
 initial_forms = self.max_num
 return initial_forms
 def _construct_forms(self):
 # instantiate all the forms and put them in self.forms
 def _get_extra_forms(self):
 """Return a list of all the extra forms in this formset."""
 return self.forms[self.initial_form_count():]
 extra_forms = property(_get_extra_forms)
+def _get_empty_form(self, **kwargs):
+defaults = {
+'auto_id': self.auto_id,
+'prefix': self.add_prefix('__prefix__'),
+'empty_permitted': True,
+}
+if self.data or self.files:
+defaults['data'] = self.data
+defaults['files'] = self.files
+defaults.update(kwargs)
+form = self.form(**defaults)
+self.add_fields(form, None)
+return form
+empty_form = property(_get_empty_form)
 # Maybe this should just go away?
 def _get_cleaned_data(self):
 """
 Returns a list of form.cleaned_data dicts for every form in self.forms.
 """
 for i in range(0, self.total_form_count()):
 form = self.forms[i]
 # if this is an extra form and hasn't changed, don't consider it
 if i >= self.initial_form_count() and not form.has_changed():
 continue
-if form.cleaned_data[DELETION_FIELD_NAME]:
+if self._should_delete_form(form):
 self._deleted_form_indexes.append(i)
 return [self.forms[i] for i in self._deleted_form_indexes]
 deleted_forms = property(_get_deleted_forms)
 def _get_ordered_forms(self):
 form = self.forms[i]
 # if this is an extra form and hasn't changed, don't consider it
 if i >= self.initial_form_count() and not form.has_changed():
 continue
 # don't add data marked for deletion to self.ordered_data
-if self.can_delete and form.cleaned_data[DELETION_FIELD_NAME]:
+if self.can_delete and self._should_delete_form(form):
 continue
 self._ordering.append((i, form.cleaned_data[ORDERING_FIELD_NAME]))
 # After we're done populating self._ordering, sort it.
 # A sort function to order things numerically ascending, but
 # None should be sorted below anything else. Allowing None as
 if self._errors is None:
 self.full_clean()
 return self._errors
 errors = property(_get_errors)
+def _should_delete_form(self, form):
+# The way we lookup the value of the deletion field here takes
+# more code than we'd like, but the form's cleaned_data will
+# not exist if the form is invalid.
+field = form.fields[DELETION_FIELD_NAME]
+raw_value = form._raw_value(DELETION_FIELD_NAME)
+should_delete = field.clean(raw_value)
+return should_delete
 def is_valid(self):
 """
 Returns True if form.errors is empty for every form in self.forms.
 """
 if not self.is_bound:
 # first failure to make sure validation gets triggered for every form.
 forms_valid = True
 for i in range(0, self.total_form_count()):
 form = self.forms[i]
 if self.can_delete:
-# The way we lookup the value of the deletion field here takes
+if self._should_delete_form(form):
-# more code than we'd like, but the form's cleaned_data will
-# not exist if the form is invalid.
-field = form.fields[DELETION_FIELD_NAME]
-raw_value = form._raw_value(DELETION_FIELD_NAME)
-should_delete = field.clean(raw_value)
-if should_delete:
 # This form is going to be deleted so any of its errors
 # should not cause the entire formset to be invalid.
 continue
 if bool(self.errors[i]):
 forms_valid = False
 self._errors.append(form.errors)
 # Give self.clean() a chance to do cross-form validation.
 try:
 self.clean()
 except ValidationError, e:
-self._non_form_errors = e.messages
+self._non_form_errors = self.error_class(e.messages)
 def clean(self):
 """
 Hook for doing any extra formset-wide cleaning after Form.clean() has
 been called on every form. Any ValidationError raised by this method
 def add_fields(self, form, index):
 """A hook for adding extra fields on to each form instance."""
 if self.can_order:
 # Only pre-fill the ordering field for initial forms.
-if index < self.initial_form_count():
+if index is not None and index < self.initial_form_count():
 form.fields[ORDERING_FIELD_NAME] = IntegerField(label=_(u'Order'), initial=index+1, required=False)
 else:
 form.fields[ORDERING_FIELD_NAME] = IntegerField(label=_(u'Order'), required=False)
 if self.can_delete:
 form.fields[DELETION_FIELD_NAME] = BooleanField(label=_(u'Delete'), required=False)
 # table row with each field as a td.
 forms = u' '.join([form.as_table() for form in self.forms])
 return mark_safe(u'\n'.join([unicode(self.management_form), forms]))
 def formset_factory(form, formset=BaseFormSet, extra=1, can_order=False,
-can_delete=False, max_num=0):
+can_delete=False, max_num=None):
 """Return a FormSet for the given form class."""
 attrs = {'form': form, 'extra': extra,
 'can_order': can_order, 'can_delete': can_delete,
 'max_num': max_num}
 return type(form.__name__ + 'FormSet', (formset,), attrs)

changeset 29	cc9b7e14412b
parent 0	0d40e90630ef