Ticket #10728: 10728.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):
+            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 +96 @@
 
     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/fields.py

@@ -40 +40 @@
             return value
         return Small(value[0], value[1])
 
-    def get_db_prep_save(self, value):
+    def get_db_prep_save(self, value, connection):
         return unicode(value)
 
     def get_prep_lookup(self, lookup_type, value):
@@ -53 +53 @@
         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
 
@@ -62 +68 @@
     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):
+    def get_db_prep_save(self, value, connection):
         if value is None:
             return None
         return json.dumps(value)

tests/modeltests/field_subclassing/models.py

@@ -5 +5 @@
 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):
+class AbstractSmallModel(models.Model):
     name = models.CharField(max_length=10)
-    data = SmallField('small field')
+
+    class Meta:
+        abstract = True
 
     def __unicode__(self):
         return force_unicode(self.name)
 
+
+class SmallModel(AbstractSmallModel):
+    data = SmallField('small field')
+
+
+try:
+    class SmallerModel(AbstractSmallModel):
+        data = SmallerField('small field')
+except RuntimeError: # Ticket #10728
+    SmallerModel = None
+
+
 class DataModel(models.Model):
     data = JSONField()

tests/modeltests/field_subclassing/tests.py

@@ -2 +2 @@
 from django.test import TestCase
 
 from fields import Small
-from models import DataModel, MyModel
+from models import DataModel, SmallModel, SmallerModel
 
 
 class CustomField(TestCase):
@@ -22 +22 @@
         self.assertTrue(isinstance(d.data, list))
         self.assertEqual(d.data, [1, 2, 3])
 
-    def test_custom_field(self):
+    def test_custom_field(self, MyModel=SmallModel):
         # Creating a model with custom fields is done as per normal.
         s = Small(1, 2)
         self.assertEqual(str(s), "12")
@@ -55 +55 @@
 
         # Serialization works, too.
         stream = serializers.serialize("json", MyModel.objects.all())
-        self.assertEqual(stream, '[{"pk": 1, "model": "field_subclassing.mymodel", "fields": {"data": "12", "name": "m"}}]')
+        self.assertEqual(stream, '[{"pk": 1, "model": "field_subclassing.%s", '
+                                 '"fields": {"data": "12", "name": "m"}}]'
+                                 % MyModel.__name__.lower())
 
         obj = list(serializers.deserialize("json", stream))[0]
         self.assertEqual(obj.object, m)
@@ -73 +75 @@
             ],
             lambda m: str(m.data)
         )
+
+    def test_custom_field_subclass(self):
+        if not SmallerModel:
+            self.fail("Couldn't subclass SubfieldBase field")
+        else:
+            self.test_custom_field(SmallerModel)
+