Changeset 7112

Timestamp:

02/14/08 06:56:49 (7 months ago)

Author:

mtredinnick

Message:

Fixed #6337. Refs #3632 -- Fixed ModelForms? subclassing, to the extent that it can be made to work.

This ended up being an almost complete rewrite of ModelForms?.new, but
should be backwards compatible (although the text of one error message has
changed, which is only user visible and only if you pass in invalid code).

Documentation updated, also.

This started out as a patch from semenov (many thanks!), but by the time all
the problems were hammered out, little of the original was left. Still, it was
a good starting point.

Files:

• django/trunk/django/newforms/forms.py (modified) (2 diffs)
• django/trunk/django/newforms/models.py (modified) (3 diffs)
• django/trunk/docs/modelforms.txt (modified) (1 diff)
• django/trunk/tests/modeltests/model_forms/models.py (modified) (3 diffs)

django/trunk/django/newforms/forms.py

@@ -22 +22 @@
-    name = name[0].upper() + name[1:]
-    return name.replace('_', ' ')
+
+def get_declared_fields(bases, attrs):
+    fields = [(field_name, attrs.pop(field_name)) for field_name, obj in attrs.items() if isinstance(obj, Field)]
+    fields.sort(lambda x, y: cmp(x[1].creation_counter, y[1].creation_counter))
+
+    # If this class is subclassing another Form, add that Form's fields.
+    # Note that we loop over the bases in *reverse*. This is necessary in
+    # order to preserve the correct order of fields.
+    for base in bases[::-1]:
+        if hasattr(base, 'base_fields'):
+            fields = base.base_fields.items() + fields
+
+    return SortedDict(fields)
-
-class DeclarativeFieldsMetaclass(type):
@@ -29 +42 @@
-    """
-    def __new__(cls, name, bases, attrs):
-
-
-
-
-
-
-
-
-
-
-
+
-        return type.__new__(cls, name, bases, attrs)
-

django/trunk/django/newforms/models.py

@@ -12 +12 @@
-
-from util import ValidationError, ErrorList
-
+, get_declared_fields
-from fields import Field, ChoiceField, EMPTY_VALUES
-from widgets import Select, SelectMultiple, MultipleHiddenInput
@@ -212 +212 @@
-        self.exclude = getattr(options, 'exclude', None)
-
+
-class ModelFormMetaclass(type):
-    def __new__(cls, name, bases, attrs,
-                formfield_callback=lambda f: f.formfield()):
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            base_opts = getattr(base, '_meta', None)
-            base_model = getattr(base_opts, 'model', None)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-
-class BaseModelForm(BaseForm):
-    def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,
-
+
+
-        opts = self._meta
-        if instance is None:
@@ -278 +279 @@
-    def save(self, commit=True):
-        """
-
+
+
-
-        If commit=True, then the changes to ``instance`` will be saved to the

django/trunk/docs/modelforms.txt

@@ -321 +321 @@
-   ...     class Meta:
-   ...         model = Article
+
+Form inheritance
+----------------
+As with the basic forms, you can extend and reuse ``ModelForms`` by inheriting
+them. Normally, this will be useful if you need to declare some extra fields
+or extra methods on a parent class for use in a number of forms derived from
+models. For example, using the previous ``ArticleForm`` class::
+
+    >>> class EnhancedArticleForm(ArticleForm):
+    ...     def clean_pub_date(self):
+    ...         ...
+
+This creates a form that behaves identically to ``ArticleForm``, except there
+is some extra validation and cleaning for the ``pub_date`` field.
+
+There are a couple of things to note, however. Most of these won't normally be
+of concern unless you are trying to do something tricky with subclassing.
+
+ * All the fields from the parent classes will appear in the child
+   ``ModelForm``. This means you cannot change a parent's ``Meta.exclude``
+   attribute, for example, and except it to have an effect, since the field is
+   already part of the field list in the parent class.
+
+ * Normal Python name resolution rules apply. If you have multiple base
+   classes that declare a ``Meta`` inner class, only the first one will be
+   used.  This means the child's ``Meta``, if it exists, otherwise the
+   ``Meta`` of the first parent, etc.
+
+ * For technical reasons, you cannot have a subclass that is inherited from
+   both a ``ModelForm`` and a ``Form`` simultaneously.
+
+Because of the "child inherits all fields from parents" behaviour, you
+shouldn't try to declare model fields in multiple classes (parent and child).
+Instead, declare all the model-related stuff in one class and use inheritance
+to add "extra" non-model fields and methods to the final result. Whether you
+put the "extra" functions in the parent class or the child class will depend
+on how you intend to reuse them.
+

django/trunk/tests/modeltests/model_forms/models.py

@@ -65 +65 @@
-    def __unicode__(self):
-        return self.description
-
+
-class ImageFile(models.Model):
-    description = models.CharField(max_length=20)
-    image = models.FileField(upload_to=tempfile.gettempdir())
-
+
-    def __unicode__(self):
-        return self.description
@@ -161 +161 @@
-Traceback (most recent call last):
-...
- defines a different model than its parent
+'s base classes define more than one model
-
->>> class ArticleForm(ModelForm):
@@ -179 +179 @@
-...         model = Category
-
+
+Subclassing without specifying a Meta on the class will use the parent's Meta
+(or the first parent in the MRO if there are multiple parent classes).
+
+>>> class CategoryForm(ModelForm):
+...     class Meta:
+...         model = Category
+...         exclude = ['url']
+>>> class SubCategoryForm(CategoryForm):
+...     pass
+
+>>> print SubCategoryForm()
+<tr><th><label for="id_name">Name:</label></th><td><input id="id_name" type="text" name="name" maxlength="20" /></td></tr>
+<tr><th><label for="id_slug">Slug:</label></th><td><input id="id_slug" type="text" name="slug" maxlength="20" /></td></tr>
-
-# Old form_for_x tests #######################################################