Update AllLookupsFilter handling

This includes deprecating ALL_LOOKUPS for '__all__', as the former
was an array of lookup_types. Given the new lookup expression handling,
this is no longer compatible. '__all__' is just a Meta.fields shorthand
for declaring an AllLookupsFilter

Author: Ryan P Kilby

rest_framework_filters/filters.py

@@ -4,11 +4,12 @@
 from django.utils import six
 
 from django_filters.filters import *
-from django_filters.filters import LOOKUP_TYPES
 
 from . import fields
 
-ALL_LOOKUPS = LOOKUP_TYPES
+
+class ALL_LOOKUPS(object):
+    pass
 
 
 def _import_class(path):

rest_framework_filters/filterset.py

@@ -13,6 +13,7 @@
 from django_filters import filterset
 
 from . import filters
+from . import utils
 
 
 def _base(f):
@@ -33,6 +34,8 @@ def _get_fix_filter_field(cls):
 
 class FilterSetMetaclass(filterset.FilterSetMetaclass):
     def __new__(cls, name, bases, attrs):
+        cls.convert__all__(attrs)
+
         new_class = super(FilterSetMetaclass, cls).__new__(cls, name, bases, attrs)
         fix_filter_field = _get_fix_filter_field(new_class)
 
@@ -43,7 +46,7 @@ def __new__(cls, name, bases, attrs):
                 model = new_class._meta.model
                 field = filterset.get_model_field(model, filter_.name)
 
-                for lookup_expr in filters.LOOKUP_TYPES:
+                for lookup_expr in utils.lookups_for_field(field):
                     if isinstance(field, ForeignObjectRel):
                         f = new_class.filter_for_reverse_field(field, filter_.name)
                     else:
@@ -77,6 +80,29 @@ def related_filters(self):
             ])
         return self._related_filters
 
+    @staticmethod
+    def convert__all__(attrs):
+        """
+        Extract Meta.fields and convert any fields w/ `__all__`
+        to a declared AllLookupsFilter.
+        """
+        meta = attrs.get('Meta', None)
+        fields = getattr(meta, 'fields', None)
+
+        if isinstance(fields, dict):
+            for name, lookups in six.iteritems(fields.copy()):
+                if lookups == filters.ALL_LOOKUPS:
+                    warnings.warn(
+                        "ALL_LOOKUPS has been deprecated in favor of '__all__'. See: "
+                        "https://github.com/philipn/django-rest-framework-filters/issues/62",
+                        DeprecationWarning, stacklevel=2
+                    )
+                    lookups = '__all__'
+
+                if lookups == '__all__':
+                    del fields[name]
+                    attrs[name] = filters.AllLookupsFilter()
+
 
 class FilterSet(six.with_metaclass(FilterSetMetaclass, filterset.FilterSet)):
     filter_overrides = {

rest_framework_filters/utils.py

@@ -0,0 +1,40 @@
+
+from collections import OrderedDict
+
+from django.db.models.constants import LOOKUP_SEP
+from django.db.models.lookups import Transform
+from django.utils import six
+
+
+def lookups_for_field(model_field):
+    """
+    Generates a list of all possible lookup expressions for a model field.
+    """
+    lookups = []
+
+    for expr, lookup in six.iteritems(class_lookups(model_field)):
+        if issubclass(lookup, Transform):
+            lookups += [
+                LOOKUP_SEP.join([expr, transform]) for transform
+                in lookups_for_field(lookup(model_field).output_field)
+            ]
+        else:
+            lookups.append(expr)
+
+    return lookups
+
+
+def class_lookups(model_field):
+    """
+    Get a compiled set of class_lookups for a model field.
+    """
+    field_class = model_field.__class__
+    class_lookups = OrderedDict()
+
+    # traverse MRO in reverse, as this puts standard
+    # lookups before subclass transforms/lookups
+    for cls in field_class.mro()[::-1]:
+        if hasattr(cls, 'class_lookups'):
+            class_lookups.update(getattr(cls, 'class_lookups'))
+
+    return class_lookups

tests/test_deprecations.py

@@ -3,7 +3,9 @@
 from django.test import TestCase
 
 from rest_framework_filters import FilterSet
+from rest_framework_filters import filters
 
+from .testapp.models import User
 from .testapp.filters import UserFilter
 
 
@@ -57,3 +59,43 @@ class F(FilterSet):
                 pass
 
             self.assertEqual(len(w), 0)
+
+
+class AllLookupsDeprecationTests(TestCase):
+
+    def test_ALL_LOOKUPS_notification(self):
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+
+            class F(FilterSet):
+                class Meta:
+                    model = User
+                    fields = {
+                        'last_login': filters.ALL_LOOKUPS,
+                    }
+
+            self.assertEqual(len(w), 1)
+
+    def test_no_notification_for__all__(self):
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+
+            class F(FilterSet):
+                class Meta:
+                    model = User
+                    fields = {
+                        'last_login': '__all__',
+                    }
+
+            self.assertEqual(len(w), 0)
+
+    def test_no_notification_for_fields_list(self):
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+
+            class F(FilterSet):
+                class Meta:
+                    model = User
+                    fields = ['last_login']
+
+            self.assertEqual(len(w), 0)

tests/test_utils.py

@@ -0,0 +1,52 @@
+
+import unittest
+import django
+from django.test import TestCase
+
+from rest_framework_filters import utils
+
+from .testapp.models import Person
+
+
+class LookupsForFieldTests(TestCase):
+    def test_standard_field(self):
+        model_field = Person._meta.get_field('name')
+        lookups = utils.lookups_for_field(model_field)
+
+        self.assertIn('exact', lookups)
+        if django.VERSION >= (1, 9):
+            self.assertNotIn('year', lookups)
+            self.assertNotIn('date', lookups)
+        else:
+            self.assertIn('year', lookups)
+
+    @unittest.skipIf(django.VERSION < (1, 9), "version does not support transformed lookup expressions")
+    def test_transformed_field(self):
+        model_field = Person._meta.get_field('datetime_joined')
+        lookups = utils.lookups_for_field(model_field)
+
+        self.assertIn('exact', lookups)
+        self.assertIn('year__exact', lookups)
+        self.assertIn('date__year__exact', lookups)
+
+
+class ClassLookupsTests(TestCase):
+    def test_standard_field(self):
+        model_field = Person._meta.get_field('name')
+        class_lookups = utils.class_lookups(model_field)
+
+        self.assertIn('exact', class_lookups)
+        if django.VERSION >= (1, 9):
+            self.assertNotIn('year', class_lookups)
+            self.assertNotIn('date', class_lookups)
+        else:
+            self.assertIn('year', class_lookups)
+
+    @unittest.skipIf(django.VERSION < (1, 9), "version does not support transformed lookup expressions")
+    def test_transformed_field(self):
+        model_field = Person._meta.get_field('datetime_joined')
+        class_lookups = utils.class_lookups(model_field)
+
+        self.assertIn('exact', class_lookups)
+        self.assertIn('year', class_lookups)
+        self.assertIn('date', class_lookups)

tests/testapp/filters.py

@@ -223,4 +223,4 @@ class BlogPostOverrideFilter(FilterSet):
 
     class Meta:
         model = BlogPost
-        fields = {'publish_date': filters.ALL_LOOKUPS, }
+        fields = {'publish_date': '__all__', }