warp-thinking-sphinx 1.2.12 → 1.3.10

data/features/support/models/comment.rb

@@ -1,10 +1,10 @@
 class Comment < ActiveRecord::Base
-  belongs_to :post
-  belongs_to :category
-  
   define_index do 
     indexes :content
     
     has category.name, :facet => true, :as => :category_name, :type => :string
   end
+  
+  belongs_to :post
+  belongs_to :category
 end

data/features/support/models/fox.rb

@@ -0,0 +1,5 @@
+class Fox < Animal
+  define_index do
+    indexes :name
+  end
+end

data/features/support/models/genre.rb

@@ -0,0 +1,3 @@
+class Genre < ActiveRecord::Base
+  #
+end

data/features/support/models/medium.rb

@@ -0,0 +1,5 @@
+class Medium < ActiveRecord::Base
+  self.abstract_class = true
+  
+  belongs_to :genre
+end

data/features/support/models/music.rb

@@ -0,0 +1,8 @@
+class Music < Medium
+  set_table_name 'music'
+  
+  define_index do
+    indexes artist, track, album
+    indexes genre(:name), :as => :genre
+  end
+end

data/features/support/models/post.rb

@@ -12,7 +12,8 @@ class Post < ActiveRecord::Base
     indexes comments.content, :as => :comments
     indexes authors.name, :as => :authors
     
-    has comments(:id), :as => :comment_ids, :source => :ranged_query
+    has comments(:id), :as => :comment_ids, :source => :ranged_query,
+      :facet => true
     has category.name, :facet => true, :as => :category_name, :type => :string
     has 'COUNT(DISTINCT comments.id)', :as => :comments_count, :type => :integer
     has comments.created_at, :as => :comments_created_at

data/features/support/models/robot.rb

@@ -5,4 +5,8 @@ class Robot < ActiveRecord::Base
   define_index do
     indexes :name
   end
+  
+  def id
+    internal_id
+  end
 end

data/lib/cucumber/thinking_sphinx/external_world.rb

@@ -0,0 +1,8 @@
+require 'thinking_sphinx/test'
+
+class Cucumber::ThinkingSphinx::ExternalWorld
+  def initialize(suppress_delta_output = true)
+    ::ThinkingSphinx::Test.init
+    ::ThinkingSphinx::Test.start_with_autostop
+  end
+end

data/lib/cucumber/thinking_sphinx/internal_world.rb

@@ -0,0 +1,126 @@
+require 'cucumber/thinking_sphinx/sql_logger'
+
+module Cucumber
+  module ThinkingSphinx
+    class InternalWorld
+      attr_accessor :temporary_directory, :migrations_directory,
+        :models_directory, :fixtures_directory, :database_file
+      attr_accessor :adapter, :database, :username,
+        :password, :host
+      
+      def initialize
+        @temporary_directory  = "#{Dir.pwd}/tmp"
+        @migrations_directory = "features/support/db/migrations"
+        @models_directory     = "features/support/models"
+        @fixtures_directory   = "features/support/db/fixtures"
+        @database_file        = "features/support/database.yml"
+        
+        @adapter  = ENV['DATABASE'] || 'mysql'
+        @database = 'thinking_sphinx'
+        @username = 'thinking_sphinx'
+        # @password = 'thinking_sphinx'
+        @host     = 'localhost'
+      end
+      
+      def setup
+        make_temporary_directory
+        
+        configure_cleanup
+        configure_thinking_sphinx
+        configure_active_record
+        
+        prepare_data
+        setup_sphinx
+        
+        self
+      end
+      
+      def configure_database
+        ActiveRecord::Base.establish_connection database_settings
+        self
+      end
+      
+      private
+      
+      def config
+        @config ||= ::ThinkingSphinx::Configuration.instance
+      end
+      
+      def make_temporary_directory
+        FileUtils.mkdir_p temporary_directory
+        Dir["#{temporary_directory}/*"].each do |file|
+          FileUtils.rm_rf file
+        end
+      end
+      
+      def configure_thinking_sphinx
+        config.config_file        = "#{temporary_directory}/sphinx.conf"
+        config.searchd_log_file   = "#{temporary_directory}/searchd.log"
+        config.query_log_file     = "#{temporary_directory}/searchd.query.log"
+        config.pid_file           = "#{temporary_directory}/searchd.pid"
+        config.searchd_file_path  = "#{temporary_directory}/indexes/"
+        
+        ::ThinkingSphinx.suppress_delta_output = true
+      end
+      
+      def configure_cleanup
+        Kernel.at_exit do
+          ::ThinkingSphinx::Configuration.instance.controller.stop
+          sleep(0.5) # Ensure Sphinx has shut down completely
+          ActiveRecord::Base.logger.close
+        end
+      end
+      
+      def yaml_database_settings
+        return {} unless File.exist?(@database_file)
+        
+        YAML.load open(@database_file)
+      end
+      
+      def database_settings
+        {
+          'adapter'  => @adapter,
+          'database' => @database,
+          'username' => @username,
+          'password' => @password,
+          'host'     => @host
+        }.merge yaml_database_settings
+      end
+      
+      def configure_active_record
+        ActiveRecord::Base.logger = Logger.new(
+          open("#{temporary_directory}/active_record.log", "a")
+        )
+        
+        ActiveRecord::Base.connection.class.send(
+          :include, Cucumber::ThinkingSphinx::SqlLogger
+        )
+      end
+      
+      def prepare_data
+        ::ThinkingSphinx.deltas_enabled = false
+        
+        load_files migrations_directory
+        load_files models_directory
+        load_files fixtures_directory
+        
+        ::ThinkingSphinx.deltas_enabled = true
+      end
+      
+      def load_files(path)
+        files = Dir["#{path}/*.rb"].sort!
+        files.each do |file|
+          require file.gsub(/\.rb$/, '')
+        end
+      end
+      
+      def setup_sphinx
+        FileUtils.mkdir_p config.searchd_file_path
+        
+        config.build
+        config.controller.index
+        config.controller.start
+      end
+    end
+  end
+end

data/lib/cucumber/thinking_sphinx/sql_logger.rb

@@ -0,0 +1,20 @@
+module Cucumber
+  module ThinkingSphinx
+    module SqlLogger
+      def self.included(base)
+        base.send :alias_method_chain, :execute, :query_record
+      end
+      
+      IGNORED_SQL = [
+        /^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/,
+        /^SELECT @@ROWCOUNT/, /^SHOW FIELDS/
+      ]
+      
+      def execute_with_query_record(sql, name = nil, &block)
+        $queries_executed ||= []
+        $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
+        execute_without_query_record(sql, name, &block)
+      end
+    end
+  end
+end

data/lib/thinking_sphinx.rb

@@ -1,13 +1,10 @@
-Dir[File.join(File.dirname(__FILE__), '../vendor/*/lib')].each do |path|
-  $LOAD_PATH.unshift path
-end
-
 require 'active_record'
-require 'riddle'
 require 'after_commit'
 require 'yaml'
 require 'cgi'
+require 'riddle'
 
+require 'thinking_sphinx/auto_version'
 require 'thinking_sphinx/core/array'
 require 'thinking_sphinx/core/string'
 require 'thinking_sphinx/property'
@@ -15,6 +12,7 @@ require 'thinking_sphinx/active_record'
 require 'thinking_sphinx/association'
 require 'thinking_sphinx/attribute'
 require 'thinking_sphinx/configuration'
+require 'thinking_sphinx/context'
 require 'thinking_sphinx/excerpter'
 require 'thinking_sphinx/facet'
 require 'thinking_sphinx/class_facet'
@@ -57,26 +55,39 @@ 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 ||= []
+  def self.context
+    if Thread.current[:thinking_sphinx_context].nil?
+      Thread.current[:thinking_sphinx_context] = ThinkingSphinx::Context.new
+      Thread.current[:thinking_sphinx_context].prepare
+    end
+    
+    Thread.current[:thinking_sphinx_context]
+  end
+  
+  def self.reset_context!
+    Thread.current[:thinking_sphinx_context] = nil
   end
 
   def self.unique_id_expression(offset = nil)
-    "* #{ThinkingSphinx.indexed_models.size} + #{offset || 0}"
+    "* #{context.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.
@@ -84,16 +95,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.
@@ -101,17 +115,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
@@ -119,37 +136,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
-
+  
   # 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?
-    !!(
-      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
@@ -161,7 +178,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
@@ -210,3 +227,5 @@ module ThinkingSphinx
   
   extend ThinkingSphinx::SearchMethods::ClassMethods
 end
+
+ThinkingSphinx::AutoVersion.detect

data/lib/thinking_sphinx/active_record.rb

@@ -12,7 +12,11 @@ module ThinkingSphinx
     def self.included(base)
       base.class_eval do
         class_inheritable_array :sphinx_indexes, :sphinx_facets
+        
+        extend ThinkingSphinx::ActiveRecord::ClassMethods
+        
         class << self
+          attr_accessor :sphinx_index_blocks
           
           def set_sphinx_primary_key(attribute)
             @sphinx_primary_key_attribute = attribute
@@ -22,93 +26,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 +44,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 +53,36 @@ 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
+          #
+          # The above method to_crc32s is dependant on the subclasses being loaded consistently
+          # After a reset_subclasses is called (during a Dispatcher.cleanup_application in development)
+          # Our subclasses will be lost but our context will not reload them for us.
+          #
+          # We reset the context which causes the subclasses to be reloaded next time the context is called.
+          #
+          def reset_subclasses_with_thinking_sphinx
+            reset_subclasses_without_thinking_sphinx
+            ThinkingSphinx.reset_context!
           end
           
-          private
+          alias_method_chain :reset_subclasses, :thinking_sphinx
           
-          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
+          private
           
-          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
+          def defined_indexes?
+            @defined_indexes
           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
+          def defined_indexes=(value)
+            @defined_indexes = value
           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
+          def sphinx_delta?
+            self.sphinx_indexes.any? { |index| index.delta? }
           end
         end
       end
       
-      base.send(:include, ThinkingSphinx::ActiveRecord::Delta)
-      
       ::ActiveRecord::Associations::HasManyAssociation.send(
         :include, ThinkingSphinx::ActiveRecord::HasManyAssociation
       )
@@ -244,6 +91,228 @@ 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)
+        self.sphinx_index_blocks ||= []
+        self.sphinx_indexes      ||= []
+        self.sphinx_facets       ||= []
+        
+        ThinkingSphinx.context.add_indexed_model self
+        
+        if sphinx_index_blocks.empty?
+          before_validation :define_indexes
+          before_destroy    :define_indexes
+        end
+        
+        self.sphinx_index_blocks << lambda {
+          index = ThinkingSphinx::Index::Builder.generate self, name, &block
+          add_sphinx_callbacks_and_extend(index.delta?)
+          add_sphinx_index index
+        }
+        
+        include ThinkingSphinx::ActiveRecord::Scopes
+        include ThinkingSphinx::SearchMethods
+      end
+      
+      def define_indexes
+        return if sphinx_index_blocks.nil? ||
+          defined_indexes?                 ||
+          !ThinkingSphinx.define_indexes?
+        
+        sphinx_index_blocks.each do |block|
+          block.call
+        end
+        
+        self.defined_indexes = true
+        
+        # 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 add_sphinx_index(index)
+        self.sphinx_indexes << index
+        subclasses.each { |klass| klass.add_sphinx_index(index) }
+      end
+      
+      def has_sphinx_indexes?
+        sphinx_indexes      && 
+        sphinx_index_blocks &&
+        (sphinx_indexes.length > 0 || sphinx_index_blocks.length > 0)
+      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
+        define_indexes
+        sphinx_indexes.collect(&:all_names).flatten
+      end
+      
+      def core_index_names
+        define_indexes
+        sphinx_indexes.collect(&:core_name)
+      end
+      
+      def delta_index_names
+        define_indexes
+        sphinx_indexes.select(&:delta?).collect(&:delta_name)
+      end
+      
+      def to_riddle
+        define_indexes
+        sphinx_database_adapter.setup
+        
+        local_sphinx_indexes.collect { |index|
+          index.to_riddle(sphinx_offset)
+        }.flatten
+      end
+      
+      def source_of_sphinx_index
+        define_indexes
+        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
+      
+      def sphinx_offset
+        ThinkingSphinx.context.superclass_indexed_models.
+          index eldest_indexed_ancestor
+      end
+      
+      # Temporarily disable delta indexing inside a block, then perform a single
+      # rebuild of index at the end.
+      #
+      # Useful when performing updates to batches of models to prevent
+      # the delta index being rebuilt after each individual update.
+      #
+      # In the following example, the delta index will only be rebuilt once,
+      # not 10 times.
+      #
+      #   SomeModel.suspended_delta do
+      #     10.times do
+      #       SomeModel.create( ... )
+      #     end
+      #   end
+      #
+      def suspended_delta(reindex_after = true, &block)
+        define_indexes
+        original_setting = ThinkingSphinx.deltas_enabled?
+        ThinkingSphinx.deltas_enabled = false
+        begin
+          yield
+        ensure
+          ThinkingSphinx.deltas_enabled = original_setting
+          self.index_delta if reindex_after
+        end
+      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::ActiveRecord::AttributeUpdates
+        end
+        
+        if delta && !delta_indexed_by_sphinx?
+          include ThinkingSphinx::ActiveRecord::Delta
+          
+          before_save   :toggle_delta
+          after_commit  :index_delta
+        end
+      end
+      
+      def eldest_indexed_ancestor
+        ancestors.reverse.detect { |ancestor|
+          ThinkingSphinx.context.indexed_models.include?(ancestor.name)
+        }.name
+      end
+    end
+    
     def in_index?(suffix)
       self.class.search_for_id self.sphinx_document_id, sphinx_index_name(suffix)
     end
@@ -261,23 +330,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
@@ -293,8 +354,8 @@ module ThinkingSphinx
     end
     
     def sphinx_document_id
-      primary_key_for_sphinx * ThinkingSphinx.indexed_models.size +
-        ThinkingSphinx.indexed_models.index(self.class.source_of_sphinx_index.name)
+      primary_key_for_sphinx * ThinkingSphinx.context.indexed_models.size +
+        self.class.sphinx_offset
     end
 
     private
@@ -302,5 +363,9 @@ module ThinkingSphinx
     def sphinx_index_name(suffix)
       "#{self.class.source_of_sphinx_index.name.underscore.tr(':/\\', '_')}_#{suffix}"
     end
+    
+    def define_indexes
+      self.class.define_indexes
+    end
   end
 end