BACKWARD-INCOMPATIBLE: All "concrete" SearchIndex classes must now mixin indexes.Indexable as well in order to be included in the index.

Author: toastdriven

docs/autocomplete.rst

@@ -29,23 +29,22 @@ Example (continuing from the tutorial)::
 
     import datetime
     from haystack import indexes
-    from haystack import site
     from myapp.models import Note
     
     
-    class NoteIndex(indexes.SearchIndex):
+    class NoteIndex(indexes.SearchIndex, indexes.Indexable):
         text = indexes.CharField(document=True, use_template=True)
         author = indexes.CharField(model_attr='user')
         pub_date = indexes.DateTimeField(model_attr='pub_date')
         # We add this for autocomplete.
         content_auto = indexes.EdgeNgramField(model_attr='content')
         
+        def get_model(self):
+            return Note
+        
         def index_queryset(self):
             """Used when the entire index for model is updated."""
             return Note.objects.filter(pub_date__lte=datetime.datetime.now())
-    
-    
-    site.register(Note, NoteIndex)
 
 As with all schema changes, you'll need to rebuild/update your index after
 making this change.

docs/boost.rst

@@ -65,7 +65,7 @@ Document boosting is done by adding a ``boost`` field to the prepared data
     from notes.models import Note
     
     
-    class NoteSearchIndex(indexes.SearchIndex):
+    class NoteSearchIndex(indexes.SearchIndex, indexes.Indexable):
         # Your regular fields here then...
         
         def prepare(self, obj):
@@ -88,6 +88,9 @@ An example of this might be increasing the significance of a ``title``::
     from notes.models import Note
     
     
-    class NoteSearchIndex(indexes.SearchIndex):
+    class NoteSearchIndex(indexes.SearchIndex, indexes.Indexable):
         text = indexes.CharField(document=True, use_template=True)
         title = indexes.CharField(model_attr='title', boost=1.125)
+        
+        def get_model(self):
+            return Note

docs/debugging.rst

@@ -81,10 +81,10 @@ A way to solve this is to subclass ``SearchIndex`` instead::
     
     # Change from:
     # 
-    #   class MySearchIndex(indexes.RealTimeSearchIndex):
+    #   class MySearchIndex(indexes.RealTimeSearchIndex, indexes.Indexable):
     # 
     # to:
-    class MySearchIndex(indexes.SearchIndex):
+    class MySearchIndex(indexes.SearchIndex, indexes.Indexable):
         ...
 
 The final step is to set up a cron job that runs

docs/faceting.rst

@@ -50,7 +50,7 @@ searchable in the standard ways.
 To inform Haystack of this, you simply pass along a ``faceted=True`` parameter
 on the field(s) you wish to facet on. So to modify our existing example::
 
-    class NoteIndex(SearchIndex):
+    class NoteIndex(SearchIndex, indexes.Indexable):
         text = CharField(document=True, use_template=True)
         author = CharField(model_attr='user', faceted=True)
         pub_date = DateTimeField(model_attr='pub_date')

docs/installing_search_engines.rst

@@ -56,7 +56,7 @@ that mirrors the ``text`` field, but has ``indexed=False`` on it. This disables
 the post-processing that Solr does, which can mess up your suggestions.
 Something like the following is suggested::
 
-    class MySearchIndex(indexes.SearchIndex):
+    class MySearchIndex(indexes.SearchIndex, indexes.Indexable):
         text = indexes.CharField(document=True, use_template=True)
         # ... normal fields then...
         suggestions = indexes.CharField()

docs/migration_from_1_to_2.rst

@@ -146,7 +146,7 @@ A converted Haystack 2.X index should look like::
     from myapp.models import Note
     
     
-    class NoteIndex(indexes.SearchIndex):
+    class NoteIndex(indexes.SearchIndex, indexes.Indexable):
         text = indexes.CharField(document=True, use_template=True)
         author = indexes.CharField(model_attr='user')
         pub_date = indexes.DateTimeField(model_attr='pub_date')
@@ -162,6 +162,13 @@ Note the import on ``site`` & the registration statements are gone. Newly added
 are is the ``NoteIndex.get_model`` method. This is a **required** method &
 should simply return the ``Model`` class the index is for.
 
+There's also a new, additional class added to the ``class`` definition. The
+``indexes.Indexable`` class is a simple mixin that serves to identify the
+classes Haystack should automatically discover & use. If you have a custom
+base class (say ``QueuedSearchIndex``) that other indexes inherit from, simply
+leave the ``indexes.Indexable`` off that declaration & Haystack won't try to
+use it.
+
 Additionally, the name of the ``document=True`` field is now enforced to be
 ``text`` across all indexes. If you need it named something else, you should
 set the ``HAYSTACK_DOCUMENT_FIELD`` setting. For example::

docs/searchfield_api.rst

@@ -62,12 +62,16 @@ fields in ``django.forms.Form`` or ``django.db.models.Model`` objects. For
 example::
 
     from haystack import indexes
+    from myapp.models import Note
     
     
-    class NoteIndex(indexes.SearchIndex):
+    class NoteIndex(indexes.SearchIndex, indexes.Indexable):
         text = indexes.CharField(document=True, use_template=True)
         author = indexes.CharField(model_attr='user')
         pub_date = indexes.DateTimeField(model_attr='pub_date')
+        
+        def get_model(self):
+            return Note
 
 This will hook up those fields with the index and, when updating a ``Model``
 object, pull the relevant data out and prepare it for storage in the index.

docs/searchindex_api.rst

@@ -26,7 +26,7 @@ For the impatient::
     from myapp.models import Note
     
     
-    class NoteIndex(indexes.SearchIndex):
+    class NoteIndex(indexes.SearchIndex, indexes.Indexable):
         text = indexes.CharField(document=True, use_template=True)
         author = indexes.CharField(model_attr='user')
         pub_date = indexes.DateTimeField(model_attr='pub_date')
@@ -124,13 +124,13 @@ contents of that field, which avoids the database hit.:
 
 Within ``myapp/search_indexes.py``::
 
-    class NoteIndex(SearchIndex):
+    class NoteIndex(SearchIndex, indexes.Indexable):
         text = CharField(document=True, use_template=True)
         author = CharField(model_attr='user')
         pub_date = DateTimeField(model_attr='pub_date')
         # Define the additional field.
         rendered = CharField(use_template=True, indexed=False)
-    
+
 Then, inside a template named ``search/indexes/myapp/note_rendered.txt``::
 
     <h2>{{ object.title }}</h2>
@@ -224,11 +224,14 @@ To keep with our existing example, one use case might be altering the name
 inside the ``author`` field to be "firstname lastname <email>". In this case,
 you might write the following code::
 
-    class NoteIndex(SearchIndex):
+    class NoteIndex(SearchIndex, indexes.Indexable):
         text = CharField(document=True, use_template=True)
         author = CharField(model_attr='user')
         pub_date = DateTimeField(model_attr='pub_date')
         
+        def get_model(self):
+            return Note
+        
         def prepare_author(self, obj):
             return "%s <%s>" % (obj.user.get_full_name(), obj.user.email)
 
@@ -239,11 +242,14 @@ data may come from the field itself.
 Just like ``Form.clean_FOO``, the field's ``prepare`` runs before the
 ``prepare_FOO``, allowing you to access ``self.prepared_data``. For example::
 
-    class NoteIndex(SearchIndex):
+    class NoteIndex(SearchIndex, indexes.Indexable):
         text = CharField(document=True, use_template=True)
         author = CharField(model_attr='user')
         pub_date = DateTimeField(model_attr='pub_date')
         
+        def get_model(self):
+            return Note
+        
         def prepare_author(self, obj):
             # Say we want last name first, the hard way.
             author = u''
@@ -257,12 +263,15 @@ Just like ``Form.clean_FOO``, the field's ``prepare`` runs before the
 This method is fully function with ``model_attr``, so if there's no convenient
 way to access the data you want, this is an excellent way to prepare it::
 
-    class NoteIndex(SearchIndex):
+    class NoteIndex(SearchIndex, indexes.Indexable):
         text = CharField(document=True, use_template=True)
         author = CharField(model_attr='user')
         categories = MultiValueField()
         pub_date = DateTimeField(model_attr='pub_date')
         
+        def get_model(self):
+            return Note
+        
         def prepare_categories(self, obj):
             # Since we're using a M2M relationship with a complex lookup,
             # we can prepare the list here.
@@ -280,11 +289,14 @@ Overriding this method is useful if you need to collect more than one piece
 of data or need to incorporate additional data that is not well represented
 by a single ``SearchField``. An example might look like::
 
-    class NoteIndex(SearchIndex):
+    class NoteIndex(SearchIndex, indexes.Indexable):
         text = CharField(document=True, use_template=True)
         author = CharField(model_attr='user')
         pub_date = DateTimeField(model_attr='pub_date')
         
+        def get_model(self):
+            return Note
+        
         def prepare(self, object):
             self.prepared_data = super(NoteIndex, self).prepare(object)
             
@@ -511,11 +523,14 @@ By default, returns ``all()`` on the model's default manager.
 
 Example::
 
-    class NoteIndex(SearchIndex):
+    class NoteIndex(SearchIndex, indexes.Indexable):
         text = CharField(document=True, use_template=True)
         author = CharField(model_attr='user')
         pub_date = DateTimeField(model_attr='pub_date')
         
+        def get_model(self):
+            return Note
+        
         def load_all_queryset(self):
             # Pull all objects related to the Note in search results.
             return Note.objects.all().select_related()
@@ -585,18 +600,20 @@ For the impatient::
     from myapp.models import Note
     
     # All Fields
-    class AllNoteIndex(indexes.ModelSearchIndex):
+    class AllNoteIndex(indexes.ModelSearchIndex, indexes.Indexable):
         class Meta:
-            pass
+            model = Note
     
     # Blacklisted Fields
-    class LimitedNoteIndex(indexes.ModelSearchIndex):
+    class LimitedNoteIndex(indexes.ModelSearchIndex, indexes.Indexable):
         class Meta:
+            model = Note
             excludes = ['user']
     
     # Whitelisted Fields
-    class NoteIndex(indexes.ModelSearchIndex):
+    class NoteIndex(indexes.ModelSearchIndex, indexes.Indexable):
         class Meta:
+            model = Note
             fields = ['user', 'pub_date']
         
         # Note that regular ``SearchIndex`` methods apply.

docs/tutorial.rst

@@ -181,7 +181,7 @@ it applies to, though that is not required. This allows
     from myapp.models import Note
     
     
-    class NoteIndex(indexes.SearchIndex):
+    class NoteIndex(indexes.SearchIndex, indexes.Indexable):
         text = indexes.CharField(document=True, use_template=True)
         author = indexes.CharField(model_attr='user')
         pub_date = indexes.DateTimeField(model_attr='pub_date')

example_project/bare_bones_app/search_indexes.py

@@ -6,6 +6,6 @@
 # `haystack.indexes.BasicSearchIndex`, whose only requirement will be that
 # you create a `search/indexes/bare_bones_app/cat_text.txt` data template
 # for indexing.
-class CatIndex(indexes.BasicSearchIndex):
+class CatIndex(indexes.BasicSearchIndex, indexes.Indexable):
     def get_model(self):
         return Cat