should_index: handle unbound method

Author: PLNech

src/models.py

@@ -101,8 +101,9 @@ def __init__(self, model, client):
                     should_index_attr_name = self.should_index
                     if isinstance(attr, bool):
                         self.should_index = lambda instance: getattr(instance, should_index_attr_name) is True
+                        self.should_index._is_default = True
                     else:
-                        raise AlgoliaIndexError('{} should be a callable or a boolean attribute.'.format(
+                        raise AlgoliaIndexError('{} should be a bound callable or a boolean attribute.'.format(
                             self.should_index))
             else:
                 raise AlgoliaIndexError('{} is not an attribute of {}.'.format(
@@ -194,7 +195,7 @@ def _build_object(self, instance):
     def update_obj_index(self, instance):
         '''Update the object.'''
         if self.should_index:
-            if not self.should_index(instance):
+            if not self._should_really_index(instance):
                 # Should not index, but since we don't now the state of the
                 # instance, we need to send a DELETE request to ensure that if
                 # the instance was previously indexed, it will be removed.
@@ -206,8 +207,20 @@ def update_obj_index(self, instance):
         logger.debug('UPDATE %s FROM %s', obj['objectID'], self.model)
 
     def _should_index(self, instance):
-        '''Return true if the object should be indexed.'''
-        return self.should_index(instance) if self.should_index else True
+        """Return true if the object should be indexed (including when self.should_index is not set)."""
+        if self.should_index:
+            return self._should_really_index(instance)
+        else:
+            return True
+
+    def _should_really_index(self, instance):
+        """Return true if according to should_index the object should be indexed."""
+        if hasattr(self.should_index, "__self__") or hasattr(self.should_index, '_is_default'):
+            # bound method or lambda, let's use instance
+            return self.should_index(instance)
+        else:
+            # unbound method, simply call without arguments
+            return self.should_index()
 
     def delete_obj_index(self, instance):
         '''Delete the object.'''

tests/models.py

@@ -19,3 +19,11 @@ def geolocations(self):
 
     def has_name(self):
         return self.name is not None
+
+    @staticmethod
+    def static_should_index():
+        return True
+
+    @staticmethod
+    def static_should_not_index():
+        return False

tests/test_index.py

@@ -182,6 +182,24 @@ class ExampleIndex(AlgoliaIndex):
         self.assertFalse(index._should_index(instance_should_not),
                         "We should not index an instance when should_index(instance) returns False")
 
+    def test_should_index_unbound(self):
+        class ExampleIndex(AlgoliaIndex):
+            fields = 'name'
+            should_index = 'static_should_index'
+        index = ExampleIndex(Example, self.client)
+        obj = index._build_object(self.instance)
+        self.assertTrue(index._should_index(self.instance),
+                        "We should index an instance when should_index() returns True")
+
+        class ExampleIndex(AlgoliaIndex):
+            fields = 'name'
+            should_index = 'static_should_not_index'
+        index = ExampleIndex(Example, self.client)
+        instance_should_not = Example()
+        obj = index._build_object(instance_should_not)
+        self.assertFalse(index._should_index(instance_should_not),
+                        "We should not index an instance when should_index() returns False")
+
     def test_should_index_attr(self):
         class ExampleIndex(AlgoliaIndex):
             fields = 'name'