thinking-sphinx 1.3.4 → 1.3.6

data/README.textile

@@ -14,16 +14,20 @@ To quickly see if your system is ready to run the thinking sphinx specs, run the
 
 To get the spec suite running, you will need to install the ginger gem:
 
-  sudo gem install ginger --source http://gemcutter.org
+<pre><code>sudo gem install ginger --source http://gemcutter.org</code></pre>
   
-Then install the cucumber, yard, jeweler and rspec gems. Make sure you have a git install version 1.6.0.0 or higher, otherwise the jeweler gem won't install.
+Then install the cucumber, yard, jeweler and rspec gems. Make sure you have a git install version 1.6.0.0 or higher, otherwise the jeweler gem won't install. Bluecloth is required for some of the yard documentation.
 
-  sudo gem install cucumber yard jeweler rspec
+<pre>
+  sudo gem install bluecloth cucumber yard jeweler rspec 
+</pre>
 
 Then set up your database:
 
-  cp spec/fixtures/database.yml.default spec/fixtures/database.yml
+<pre>
+  cp spec/fixtures/database.yml.default spec/fixtures/database.yml &&
   mysqladmin -u root create thinking_sphinx
+</pre>
   
 This last step can be done automatically by the contribute.rb script if all dependencies are met.
 
@@ -32,11 +36,15 @@ in the app root.
 
 You should now have a passing test suite from which to build your patch on.
 
+<pre>
   rake spec
+</pre>
 
 If you get the message "Failed to start searchd daemon", run the spec with sudo:
 
+<pre>
   sudo rake spec
+</pre>
 
 If you quit the spec suite before it's completed, you may be left with data in the test
 database, causing the next run to have failures. Let that run complete and then try again.
@@ -145,3 +153,6 @@ Since I first released this library, there's been quite a few people who have su
 * Steve Madsen
 * Justin DeWind
 * Chris Z
+* Chris Roos
+* Andrew Assarattanakul
+* Jonas von Andrian

data/VERSION

@@ -0,0 +1 @@
+1.3.6

data/features/alternate_primary_key.feature

@@ -23,5 +23,5 @@ Feature: Searching on a single model
     
     When I destroy robot Expendable
     And I wait for Sphinx to catch up
-    And I search for three
+    And I search for Expendable
     Then I should get 0 results

data/features/attribute_updates.feature

@@ -9,15 +9,21 @@ Feature: Update attributes directly to Sphinx
     When I filter by 3 on value
     Then I should get 1 result
     
-    When I change the value of alpha two to 13
-    And I wait for Sphinx to catch up    
+    When I change the value of alpha four to 13
+    And I wait for Sphinx to catch up
     And I filter by 13 on value
+    And I use index alpha_core
+    Then I should get 1 result
+    When I use index alternative_core
     Then I should get 1 result
     
-    When I change the value of alpha two to 3
-    And I wait for Sphinx to catch up    
+    When I change the value of alpha four to 4
+    And I wait for Sphinx to catch up
     And I filter by 13 on value
+    And I use index alpha_core
     Then I should get 0 results
+    When I use index alternative_core
+    Then I should get 0 result
 
   Scenario: Updating attributes in Sphinx with delta indexes
     Given Sphinx is running
@@ -30,4 +36,4 @@ Feature: Update attributes directly to Sphinx
     Then I should get 1 result
     
     When I search for the document id of beta eight in the beta_delta index
-    Then it should not exist
+    Then it should not exist

data/features/deleting_instances.feature

@@ -56,6 +56,9 @@ Feature: Keeping Sphinx in line with deleted model instances
     And I am searching on betas
     When I create a new beta named thirteen
     And I wait for Sphinx to catch up
+    And I search for thirteen
+    Then I should get 1 result
+    
     And I disable delta updates
     And I destroy beta thirteen
     And I wait for Sphinx to catch up

data/features/searching_by_index.feature

@@ -0,0 +1,40 @@
+Feature: Searching within a single index
+  In order to use Thinking Sphinx's core functionality
+  A developer
+  Should be able to search on a single index
+ 
+  Scenario: Searching with alternative index
+    Given Sphinx is running
+    And I am searching on alphas
+    When I order by value
+    And I use index alternative_core
+    Then I should get 7 results
+ 
+  Scenario: Searching with default index
+    Given Sphinx is running
+    And I am searching on alphas
+    When I order by value
+    And I use index alpha_core
+    Then I should get 10 results
+ 
+  Scenario: Searching without specified index
+    Given Sphinx is running
+    And I am searching on alphas
+    When I order by value
+    Then I should get 10 results
+
+  Scenario: Deleting instances from the core index
+    Given Sphinx is running
+    And I am searching on alphas
+    
+    When I create a new alpha named eleven
+    And I process the alpha_core index
+    And I process the alternative_core index
+    And I wait for Sphinx to catch up
+    And I search for eleven
+    Then I should get 1 result
+    
+    When I destroy alpha eleven
+    And I wait for Sphinx to catch up
+    And I search for eleven
+    Then I should get 0 results

data/features/step_definitions/alpha_steps.rb

@@ -1,3 +1,7 @@
+When /^I create a new alpha named (\w+)$/ do |name|
+  Alpha.create!(:name => name, :value => 101)
+end
+
 When /^I change the (\w+) of alpha (\w+) to (\w+)$/ do |column, name, replacement|
   Alpha.find_by_name(name).update_attributes(column.to_sym => replacement)
-end
+end

data/features/step_definitions/beta_steps.rb

@@ -1,5 +1,5 @@
 When /^I create a new beta named (\w+)$/ do |name|
-  Beta.create(:name => name, :value => 101)
+  Beta.create!(:name => name, :value => 101)
 end
 
 When /^I change the (\w+) of beta (\w+) to (\w+)$/ do |column, name, replacement|

data/features/step_definitions/common_steps.rb

@@ -10,6 +10,8 @@ Before do
   @with_all   = {}
   @options    = {}
   @results    = nil
+  
+  Given "updates are enabled"
 end
 
 Given /^I am searching on (.+)$/ do |model|
@@ -25,6 +27,11 @@ When /^I am searching for ids$/ do
   @method = :search_for_ids
 end
 
+When /^I use index (.+)$/ do |index|
+  @results = nil
+  @options[:index] = index
+end
+
 When /^I am retrieving the result count$/ do
   @result = nil
   @method = @model ? :search_count : :count
@@ -49,6 +56,10 @@ When /^I search for (\w+) on (\w+)$/ do |query, field|
   @conditions[field.to_sym] = query
 end
 
+When /^I output the raw result data$/ do
+  puts results.results.inspect
+end
+
 When /^I clear existing filters$/ do
   @with     = {}
   @without  = {}
@@ -143,7 +154,7 @@ Then /^I can iterate by result and (\w+)$/ do |attribute|
   iteration = lambda { |result, attr_value|
     result.should be_kind_of(@model)
     unless attribute == "group" && attr_value.nil?
-      attr_value.should be_kind_of(Integer) 
+      attr_value.should be_kind_of(Integer)
     end
   }
   

data/features/step_definitions/sphinx_steps.rb

@@ -18,6 +18,14 @@ When "I stop Sphinx" do
   ThinkingSphinx::Configuration.instance.controller.stop
 end
 
+When /^I (enable|disable) delta updates$/ do |mode|
+  ThinkingSphinx.deltas_enabled = (mode == 'enable')
+end
+
+When /^I process the (\w+) index$/ do |index|
+  ThinkingSphinx::Configuration.instance.controller.index index
+end
+
 Then /^Sphinx should be running/ do
   ThinkingSphinx.sphinx_running?.should be_true
 end
@@ -25,7 +33,3 @@ end
 Then "Sphinx should not be running" do
   ThinkingSphinx.sphinx_running?.should be_false
 end
-
-When /^I (enable|disable) delta updates$/ do |mode|
-  ThinkingSphinx.deltas_enabled = (mode == 'enable')
-end

data/features/support/db/fixtures/tags.rb

@@ -24,4 +24,4 @@ Developer.find(:all).each do |developer|
   end
 end
 
-Tagging.create(:taggable => Developer.last)
+Tagging.create(:taggable => Developer.find(:all).last)

data/features/support/env.rb

@@ -7,6 +7,9 @@ require 'will_paginate'
 require 'active_record'
 
 $:.unshift File.dirname(__FILE__) + '/../../lib'
+Dir[File.join(File.dirname(__FILE__), '../../vendor/*/lib')].each do |path|
+  $:.unshift path
+end
 
 require 'cucumber/thinking_sphinx/internal_world'
 

data/features/support/models/alpha.rb

@@ -7,4 +7,15 @@ class Alpha < ActiveRecord::Base
     
     set_property :field_weights => {"name" => 10}
   end
+  
+  define_index 'alternative' do
+    indexes :name, :as => :alternative_name, :sortable => true
+    
+    has value, created_at, created_on
+    has cost, :facet => true
+    
+    set_property :field_weights => {'alternative_name' => 10}
+    
+    where "value > 3"
+  end
 end

data/lib/cucumber/thinking_sphinx/internal_world.rb

@@ -79,11 +79,11 @@ module Cucumber
       
       def database_settings
         {
-          :adapter  => @adapter,
-          :database => @database,
-          :username => @username,
-          :password => @password,
-          :host     => @host
+          'adapter'  => @adapter,
+          'database' => @database,
+          'username' => @username,
+          'password' => @password,
+          'host'     => @host
         }.merge yaml_database_settings
       end
       
@@ -108,7 +108,8 @@ module Cucumber
       end
       
       def load_files(path)
-        Dir["#{path}/*.rb"].each do |file|
+        files = Dir["#{path}/*.rb"].sort!
+        files.each do |file|
           require file.gsub(/\.rb$/, '')
         end
       end

data/lib/thinking_sphinx.rb

@@ -52,26 +52,30 @@ module ThinkingSphinx
   # @return [String] The version number as a string
   # 
   def self.version
-    hash = YAML.load_file File.join(File.dirname(__FILE__), '../VERSION.yml')
-    [hash[:major], hash[:minor], hash[:patch]].join('.')
+    open(File.join(File.dirname(__FILE__), '../VERSION')) { |f|
+      f.read.strip
+    }
   end
   
   # The collection of indexed models. Keep in mind that Rails lazily loads
   # its classes, so this may not actually be populated with _all_ the models
   # that have Sphinx indexes.
   def self.indexed_models
-    @@indexed_models ||= []
+    Thread.current[:thinking_sphinx_indexed_models] ||= []
   end
 
   def self.unique_id_expression(offset = nil)
-    "* #{ThinkingSphinx.indexed_models.size} + #{offset || 0}"
+    "* #{indexed_models.size} + #{offset || 0}"
   end
 
   # Check if index definition is disabled.
   #
   def self.define_indexes?
-    @@define_indexes =  true unless defined?(@@define_indexes)
-    @@define_indexes == true
+    if Thread.current[:thinking_sphinx_define_indexes].nil?
+      Thread.current[:thinking_sphinx_define_indexes] = true
+    end
+    
+    Thread.current[:thinking_sphinx_define_indexes]
   end
 
   # Enable/disable indexes - you may want to do this while migrating data.
@@ -79,16 +83,19 @@ module ThinkingSphinx
   #   ThinkingSphinx.define_indexes = false
   #
   def self.define_indexes=(value)
-    @@define_indexes = value
+    Thread.current[:thinking_sphinx_define_indexes] = value
   end
 
-  @@deltas_enabled = nil
-
   # Check if delta indexing is enabled.
   #
   def self.deltas_enabled?
-    @@deltas_enabled  = (ThinkingSphinx::Configuration.environment != 'test') if @@deltas_enabled.nil?
-    @@deltas_enabled
+    if Thread.current[:thinking_sphinx_deltas_enabled].nil?
+      Thread.current[:thinking_sphinx_deltas_enabled] = (
+        ThinkingSphinx::Configuration.environment != "test"
+      )
+    end
+    
+    Thread.current[:thinking_sphinx_deltas_enabled]
   end
 
   # Enable/disable all delta indexing.
@@ -96,17 +103,20 @@ module ThinkingSphinx
   #   ThinkingSphinx.deltas_enabled = false
   #
   def self.deltas_enabled=(value)
-    @@deltas_enabled = value
+    Thread.current[:thinking_sphinx_deltas_enabled] = value
   end
 
-  @@updates_enabled = nil
-
   # Check if updates are enabled. True by default, unless within the test
   # environment.
   #
   def self.updates_enabled?
-    @@updates_enabled  = (ThinkingSphinx::Configuration.environment != 'test') if @@updates_enabled.nil?
-    @@updates_enabled
+    if Thread.current[:thinking_sphinx_updates_enabled].nil?
+      Thread.current[:thinking_sphinx_updates_enabled] = (
+        ThinkingSphinx::Configuration.environment != "test"
+      )
+    end
+    
+    Thread.current[:thinking_sphinx_updates_enabled]
   end
 
   # Enable/disable updates to Sphinx
@@ -114,38 +124,37 @@ module ThinkingSphinx
   #   ThinkingSphinx.updates_enabled = false
   #
   def self.updates_enabled=(value)
-    @@updates_enabled = value
+    Thread.current[:thinking_sphinx_updates_enabled] = value
   end
 
-  @@suppress_delta_output = false
-
   def self.suppress_delta_output?
-    @@suppress_delta_output
+    Thread.current[:thinking_sphinx_suppress_delta_output] ||= false
   end
 
   def self.suppress_delta_output=(value)
-    @@suppress_delta_output = value
+    Thread.current[:thinking_sphinx_suppress_delta_output] = value
   end
   
-  @@use_group_by_shortcut = nil
   # Checks to see if MySQL will allow simplistic GROUP BY statements. If not,
   # or if not using MySQL, this will return false.
   #
   def self.use_group_by_shortcut?
-    @@use_group_by_shortcut ||= !!(
-      mysql? && ::ActiveRecord::Base.connection.select_all(
-        "SELECT @@global.sql_mode, @@session.sql_mode;"
-      ).all? { |key,value| value.nil? || value[/ONLY_FULL_GROUP_BY/].nil? }
-    )
+    if Thread.current[:thinking_sphinx_use_group_by_shortcut].nil?
+      Thread.current[:thinking_sphinx_use_group_by_shortcut] = !!(
+        mysql? && ::ActiveRecord::Base.connection.select_all(
+          "SELECT @@global.sql_mode, @@session.sql_mode;"
+        ).all? { |key,value| value.nil? || value[/ONLY_FULL_GROUP_BY/].nil? }
+      )
+    end
+    
+    Thread.current[:thinking_sphinx_use_group_by_shortcut]
   end
 
-  @@remote_sphinx = false
-
   # An indication of whether Sphinx is running on a remote machine instead of
   # the same machine.
   #
   def self.remote_sphinx?
-    @@remote_sphinx
+    Thread.current[:thinking_sphinx_remote_sphinx] ||= false
   end
 
   # Tells Thinking Sphinx that Sphinx is running on a different machine, and
@@ -157,7 +166,7 @@ module ThinkingSphinx
   #   ThinkingSphinx.remote_sphinx = true
   #
   def self.remote_sphinx=(value)
-    @@remote_sphinx = value
+    Thread.current[:thinking_sphinx_remote_sphinx] = value
   end
 
   # Check if Sphinx is running. If remote_sphinx is set to true (indicating

data/lib/thinking_sphinx/active_record.rb

@@ -12,8 +12,10 @@ module ThinkingSphinx
     def self.included(base)
       base.class_eval do
         class_inheritable_array :sphinx_indexes, :sphinx_facets
+        
+        extend ThinkingSphinx::ActiveRecord::ClassMethods
+        
         class << self
-          
           def set_sphinx_primary_key(attribute)
             @sphinx_primary_key_attribute = attribute
           end
@@ -22,93 +24,6 @@ module ThinkingSphinx
             @sphinx_primary_key_attribute || primary_key
           end
           
-          # Allows creation of indexes for Sphinx. If you don't do this, there
-          # isn't much point trying to search (or using this plugin at all,
-          # really).
-          #
-          # An example or two:
-          #
-          #   define_index
-          #     indexes :id, :as => :model_id
-          #     indexes name
-          #   end
-          #
-          # You can also grab fields from associations - multiple levels deep
-          # if necessary.
-          #
-          #   define_index do
-          #     indexes tags.name, :as => :tag
-          #     indexes articles.content
-          #     indexes orders.line_items.product.name, :as => :product
-          #   end
-          #
-          # And it will automatically concatenate multiple fields:
-          #
-          #   define_index do
-          #     indexes [author.first_name, author.last_name], :as => :author
-          #   end
-          #
-          # The #indexes method is for fields - if you want attributes, use
-          # #has instead. All the same rules apply - but keep in mind that
-          # attributes are for sorting, grouping and filtering, not searching.
-          #
-          #   define_index do
-          #     # fields ...
-          #     
-          #     has created_at, updated_at
-          #   end
-          #
-          # One last feature is the delta index. This requires the model to
-          # have a boolean field named 'delta', and is enabled as follows:
-          #
-          #   define_index do
-          #     # fields ...
-          #     # attributes ...
-          #     
-          #     set_property :delta => true
-          #   end
-          #
-          # Check out the more detailed documentation for each of these methods
-          # at ThinkingSphinx::Index::Builder.
-          # 
-          def define_index(&block)
-            return unless ThinkingSphinx.define_indexes?
-            
-            self.sphinx_indexes ||= []
-            self.sphinx_facets  ||= []
-            index = ThinkingSphinx::Index::Builder.generate(self, &block)
-            
-            self.sphinx_indexes << index
-            unless ThinkingSphinx.indexed_models.include?(self.name)
-              ThinkingSphinx.indexed_models << self.name
-            end
-            
-            if index.delta?
-              before_save   :toggle_delta
-              after_commit  :index_delta
-            end
-            
-            after_destroy :toggle_deleted
-            
-            include ThinkingSphinx::SearchMethods
-            include ThinkingSphinx::ActiveRecord::AttributeUpdates
-            include ThinkingSphinx::ActiveRecord::Scopes
-            
-            index
-            
-            # We want to make sure that if the database doesn't exist, then Thinking
-            # Sphinx doesn't mind when running non-TS tasks (like db:create, db:drop
-            # and db:migrate). It's a bit hacky, but I can't think of a better way.
-          rescue StandardError => err
-            case err.class.name
-            when "Mysql::Error", "Java::JavaSql::SQLException", "ActiveRecord::StatementInvalid"
-              return
-            else
-              raise err
-            end
-          end
-          alias_method :sphinx_index, :define_index
-          
           def sphinx_index_options
             sphinx_indexes.last.options
           end
@@ -127,26 +42,6 @@ module ThinkingSphinx
             (subclasses << self).collect { |klass| klass.to_crc32 }
           end
           
-          def source_of_sphinx_index
-            possible_models = self.sphinx_indexes.collect { |index| index.model }
-            return self if possible_models.include?(self)
-
-            parent = self.superclass
-            while !possible_models.include?(parent) && parent != ::ActiveRecord::Base
-              parent = parent.superclass
-            end
-
-            return parent
-          end
-          
-          def to_riddle(offset)
-            sphinx_database_adapter.setup
-            
-            indexes = [to_riddle_for_core(offset)]
-            indexes << to_riddle_for_delta(offset) if sphinx_delta?
-            indexes << to_riddle_for_distributed
-          end
-          
           def sphinx_database_adapter
             @sphinx_database_adapter ||=
               ThinkingSphinx::AbstractAdapter.detect(self)
@@ -156,86 +51,14 @@ module ThinkingSphinx
             self.name.underscore.tr(':/\\', '_')
           end
           
-          def sphinx_index_names
-            klass = source_of_sphinx_index
-            names = ["#{klass.sphinx_name}_core"]
-            names << "#{klass.sphinx_name}_delta" if sphinx_delta?
-            
-            names
-          end
-          
           private
           
           def sphinx_delta?
             self.sphinx_indexes.any? { |index| index.delta? }
           end
-          
-          def to_riddle_for_core(offset)
-            index = Riddle::Configuration::Index.new("#{sphinx_name}_core")
-            index.path = File.join(
-              ThinkingSphinx::Configuration.instance.searchd_file_path, index.name
-            )
-            
-            set_configuration_options_for_indexes index
-            set_field_settings_for_indexes        index
-            
-            self.sphinx_indexes.select { |ts_index|
-              ts_index.model == self
-            }.each_with_index do |ts_index, i|
-              index.sources += ts_index.sources.collect { |source|
-                source.to_riddle_for_core(offset, i)
-              }
-            end
-            
-            index
-          end
-          
-          def to_riddle_for_delta(offset)
-            index = Riddle::Configuration::Index.new("#{sphinx_name}_delta")
-            index.parent = "#{sphinx_name}_core"
-            index.path = File.join(ThinkingSphinx::Configuration.instance.searchd_file_path, index.name)
-            
-            self.sphinx_indexes.each_with_index do |ts_index, i|
-              index.sources += ts_index.sources.collect { |source|
-                source.to_riddle_for_delta(offset, i)
-              } if ts_index.delta?
-            end
-            
-            index
-          end
-          
-          def to_riddle_for_distributed
-            index = Riddle::Configuration::DistributedIndex.new(sphinx_name)
-            index.local_indexes << "#{sphinx_name}_core"
-            index.local_indexes.unshift "#{sphinx_name}_delta" if sphinx_delta?
-            index
-          end
-          
-          def set_configuration_options_for_indexes(index)
-            ThinkingSphinx::Configuration.instance.index_options.each do |key, value|
-              index.send("#{key}=".to_sym, value)
-            end
-            
-            self.sphinx_indexes.each do |ts_index|
-              ts_index.options.each do |key, value|
-                index.send("#{key}=".to_sym, value) if ThinkingSphinx::Configuration::IndexOptions.include?(key.to_s) && !value.nil?
-              end
-            end
-          end
-          
-          def set_field_settings_for_indexes(index)
-            field_names = lambda { |field| field.unique_name.to_s }
-            
-            self.sphinx_indexes.each do |ts_index|
-              index.prefix_field_names += ts_index.prefix_fields.collect(&field_names)
-              index.infix_field_names  += ts_index.infix_fields.collect(&field_names)
-            end
-          end
         end
       end
       
-      base.send(:include, ThinkingSphinx::ActiveRecord::Delta)
-      
       ::ActiveRecord::Associations::HasManyAssociation.send(
         :include, ThinkingSphinx::ActiveRecord::HasManyAssociation
       )
@@ -244,6 +67,160 @@ module ThinkingSphinx
       )
     end
     
+    module ClassMethods
+      # Allows creation of indexes for Sphinx. If you don't do this, there
+      # isn't much point trying to search (or using this plugin at all,
+      # really).
+      #
+      # An example or two:
+      #
+      #   define_index
+      #     indexes :id, :as => :model_id
+      #     indexes name
+      #   end
+      #
+      # You can also grab fields from associations - multiple levels deep
+      # if necessary.
+      #
+      #   define_index do
+      #     indexes tags.name, :as => :tag
+      #     indexes articles.content
+      #     indexes orders.line_items.product.name, :as => :product
+      #   end
+      #
+      # And it will automatically concatenate multiple fields:
+      #
+      #   define_index do
+      #     indexes [author.first_name, author.last_name], :as => :author
+      #   end
+      #
+      # The #indexes method is for fields - if you want attributes, use
+      # #has instead. All the same rules apply - but keep in mind that
+      # attributes are for sorting, grouping and filtering, not searching.
+      #
+      #   define_index do
+      #     # fields ...
+      #     
+      #     has created_at, updated_at
+      #   end
+      #
+      # One last feature is the delta index. This requires the model to
+      # have a boolean field named 'delta', and is enabled as follows:
+      #
+      #   define_index do
+      #     # fields ...
+      #     # attributes ...
+      #     
+      #     set_property :delta => true
+      #   end
+      #
+      # Check out the more detailed documentation for each of these methods
+      # at ThinkingSphinx::Index::Builder.
+      # 
+      def define_index(name = nil, &block)
+        return unless ThinkingSphinx.define_indexes?
+        
+        self.sphinx_indexes ||= []
+        self.sphinx_facets  ||= []
+        
+        index = ThinkingSphinx::Index::Builder.generate self, name, &block
+        
+        unless ThinkingSphinx.indexed_models.include?(self.name)
+          ThinkingSphinx.indexed_models << self.name
+        end
+        
+        add_sphinx_callbacks_and_extend(index.delta?)
+        self.sphinx_indexes << index
+        
+        index
+        
+        # We want to make sure that if the database doesn't exist, then Thinking
+        # Sphinx doesn't mind when running non-TS tasks (like db:create, db:drop
+        # and db:migrate). It's a bit hacky, but I can't think of a better way.
+      rescue StandardError => err
+        case err.class.name
+        when "Mysql::Error", "Java::JavaSql::SQLException", "ActiveRecord::StatementInvalid"
+          return
+        else
+          raise err
+        end
+      end
+      
+      def indexed_by_sphinx?
+        sphinx_indexes && sphinx_indexes.length > 0
+      end
+      
+      def delta_indexed_by_sphinx?
+        sphinx_indexes && sphinx_indexes.any? { |index| index.delta? }
+      end
+      
+      def sphinx_index_names
+        sphinx_indexes.collect(&:all_names).flatten
+      end
+      
+      def core_index_names
+        sphinx_indexes.collect(&:core_name)
+      end
+      
+      def delta_index_names
+        sphinx_indexes.select(&:delta?).collect(&:delta_name)
+      end
+      
+      def to_riddle(offset)
+        sphinx_database_adapter.setup
+        
+        local_sphinx_indexes.collect { |index|
+          index.to_riddle(offset)
+        }.flatten
+      end
+      
+      def source_of_sphinx_index
+        possible_models = self.sphinx_indexes.collect { |index| index.model }
+        return self if possible_models.include?(self)
+
+        parent = self.superclass
+        while !possible_models.include?(parent) && parent != ::ActiveRecord::Base
+          parent = parent.superclass
+        end
+
+        return parent
+      end
+      
+      def delete_in_index(index, document_id)
+        return unless ThinkingSphinx.sphinx_running? &&
+          search_for_id(document_id, index)
+        
+        ThinkingSphinx::Configuration.instance.client.update(
+          index, ['sphinx_deleted'], {document_id => [1]}
+        )
+      end
+      
+      private
+      
+      def local_sphinx_indexes
+        sphinx_indexes.select { |index|
+          index.model == self
+        }
+      end
+      
+      def add_sphinx_callbacks_and_extend(delta = false)
+        unless indexed_by_sphinx?
+          after_destroy :toggle_deleted
+      
+          include ThinkingSphinx::SearchMethods
+          include ThinkingSphinx::ActiveRecord::AttributeUpdates
+          include ThinkingSphinx::ActiveRecord::Scopes
+        end
+        
+        if delta && !delta_indexed_by_sphinx?
+          include ThinkingSphinx::ActiveRecord::Delta
+          
+          before_save   :toggle_delta
+          after_commit  :index_delta
+        end
+      end
+    end
+    
     def in_index?(suffix)
       self.class.search_for_id self.sphinx_document_id, sphinx_index_name(suffix)
     end
@@ -261,23 +238,15 @@ module ThinkingSphinx
     end
     
     def toggle_deleted
-      return unless ThinkingSphinx.updates_enabled? && ThinkingSphinx.sphinx_running?
-      
-      config = ThinkingSphinx::Configuration.instance
-      client = Riddle::Client.new config.address, config.port
+      return unless ThinkingSphinx.updates_enabled?
       
-      client.update(
-        "#{self.class.sphinx_indexes.first.name}_core",
-        ['sphinx_deleted'],
-        {self.sphinx_document_id => [1]}
-      ) if self.in_core_index?
+      self.class.core_index_names.each do |index_name|
+        self.class.delete_in_index index_name, self.sphinx_document_id
+      end
+      self.class.delta_index_names.each do |index_name|
+        self.class.delete_in_index index_name, self.sphinx_document_id
+      end if self.class.delta_indexed_by_sphinx? && toggled_delta?
       
-      client.update(
-        "#{self.class.sphinx_indexes.first.name}_delta",
-        ['sphinx_deleted'],
-        {self.sphinx_document_id => [1]}
-      ) if self.class.sphinx_indexes.any? { |index| index.delta? } &&
-        self.toggled_delta?
     rescue ::ThinkingSphinx::ConnectionError
       # nothing
     end