Ticket #10728: SubfieldBase-#10728-r12890.patch

django/db/models/fields/subclassing.py

@@ -76 +76 @@
     A metaclass for custom Field subclasses. This ensures the model's attribute
     has the descriptor protocol attached to it.
     """
-    def __new__(cls, base, name, attrs):
-        new_class = super(SubfieldBase, cls).__new__(cls, base, name, attrs)
-        new_class.contribute_to_class = make_contrib(
-                attrs.get('contribute_to_class'))
-        return new_class
+    def __init__(cls, name, base, attrs):
+        def contribute_to_class(self, model_cls, name):
+            assert isinstance(self, cls)
+            super(cls, self).contribute_to_class(model_cls, name)
+            setattr(model_cls, name, Creator(self))
+        cls.contribute_to_class = contribute_to_class
 
 class Creator(object):
     """
@@ -96 +97 @@
 
     def __set__(self, obj, value):
         obj.__dict__[self.field.name] = self.field.to_python(value)
-
-def make_contrib(func=None):
-    """
-    Returns a suitable contribute_to_class() method for the Field subclass.
-
-    If 'func' is passed in, it is the existing contribute_to_class() method on
-    the subclass and it is called before anything else. It is assumed in this
-    case that the existing contribute_to_class() calls all the necessary
-    superclass methods.
-    """
-    def contribute_to_class(self, cls, name):
-        if func:
-            func(self, cls, name)
-        else:
-            super(self.__class__, self).contribute_to_class(cls, name)
-        setattr(cls, self.name, Creator(self))
-
-    return contribute_to_class

tests/modeltests/field_subclassing/models.py

@@ -6 +6 @@
 from django.db import models
 from django.utils.encoding import force_unicode
 
-from fields import Small, SmallField, JSONField
+from fields import Small, SmallField, SmallerField, JSONField
 
 
 class MyModel(models.Model):
@@ -19 +19 @@
 class DataModel(models.Model):
     data = JSONField()
 
+def make_smallermodel():
+    """
+    Isolate SmallerModel class definition.
+
+    When the test fails, it fails at class definition with a long
+    stack trace. This confuses test discovery, so wrap it in a function.
+    """
+    try:
+        class SmallerModel(models.Model):
+            other_data = SmallerField(default='example')
+    except RuntimeError: # Maximum recursion depth
+        raise RuntimeError("Couldn't subclass field")
+    else:
+        return SmallerModel
+
 __test__ = {'API_TESTS': ur"""
 # Creating a model with custom fields is done as per normal.
 >>> s = Small(1, 2)
@@ -61 +76 @@
 >>> obj.object == m
 True
 
+# Test custom field subclassing.
+>>> SmallerModel = make_smallermodel()
+>>> sm = SmallerModel()
+>>> sm.other_data = 'plop'
+>>> str(sm.other_data)
+"pl"
+
 # Test retrieving custom field data
 >>> m.delete()
 >>> m1 = MyModel(name="1", data=Small(1, 2))

tests/modeltests/field_subclassing/fields.py

@@ -51 +51 @@
         raise TypeError('Invalid lookup type: %r' % lookup_type)
 
 
+class SmallerField(SmallField):
+    """
+    Checks that the SubfieldBase metaclass works with inheritance.
+    """
+
 class JSONField(models.TextField):
     __metaclass__ = models.SubfieldBase
-    
+
     description = ("JSONField automatically serializes and desializes values to "
         "and from JSON.")
-    
+
     def to_python(self, value):
         if not value:
             return None
-        
         if isinstance(value, basestring):
             value = json.loads(value)
         return value
-    
+
     def get_db_prep_save(self, value):
         if value is None:
             return None