thinking-sphinx 1.3.4 → 1.3.6

data/lib/thinking_sphinx/active_record/attribute_updates.rb

@@ -10,22 +10,25 @@ module ThinkingSphinx
       private
             
       def update_attribute_values
-        return unless ThinkingSphinx.updates_enabled? && ThinkingSphinx.sphinx_running?
+        return true unless ThinkingSphinx.updates_enabled? &&
+          ThinkingSphinx.sphinx_running?
         
         config = ThinkingSphinx::Configuration.instance
-        client = Riddle::Client.new config.address, config.port
+        client = config.client
         
-        self.sphinx_indexes.each do |index|
+        self.class.sphinx_indexes.each do |index|
           attribute_pairs  = attribute_values_for_index(index)
           attribute_names  = attribute_pairs.keys
           attribute_values = attribute_names.collect { |key|
             attribute_pairs[key]
           }
           
-          client.update "#{index.name}_core", attribute_names, {
+          client.update "#{index.core_name}", attribute_names, {
             sphinx_document_id => attribute_values
-          } if in_core_index?
+          } if self.class.search_for_id(sphinx_document_id, index.core_name)
         end
+        
+        true
       end
       
       def updatable_attributes(index)
@@ -45,4 +48,4 @@ module ThinkingSphinx
       end
     end
   end
-end
+end

data/lib/thinking_sphinx/configuration.rb

@@ -124,7 +124,7 @@ module ThinkingSphinx
     end
     
     def self.environment
-      @@environment ||= (
+      Thread.current[:thinking_sphinx_environment] ||= (
         defined?(Merb) ? Merb.environment : ENV['RAILS_ENV']
       ) || "development"
     end

data/lib/thinking_sphinx/deltas/default_delta.rb

@@ -13,18 +13,8 @@ module ThinkingSphinx
           ThinkingSphinx.deltas_enabled?
         return true if instance && !toggled(instance)
         
-        config = ThinkingSphinx::Configuration.instance
-        client = Riddle::Client.new config.address, config.port
-        rotate = ThinkingSphinx.sphinx_running? ? "--rotate" : ""
-        
-        output = `#{config.bin_path}#{config.indexer_binary_name} --config #{config.config_file} #{rotate} #{delta_index_name model}`
-        puts(output) unless ThinkingSphinx.suppress_delta_output?
-        
-        client.update(
-          core_index_name(model),
-          ['sphinx_deleted'],
-          {instance.sphinx_document_id => [1]}
-        ) if instance && ThinkingSphinx.sphinx_running? && instance.in_both_indexes?
+        update_delta_indexes model
+        delete_from_core     model, instance if instance
         
         true
       end
@@ -48,17 +38,21 @@ module ThinkingSphinx
         " = #{adapter.boolean(toggled)}"
       end
       
-      protected
+      private
       
-      def core_index_name(model)
-        "#{model.source_of_sphinx_index.name.underscore.tr(':/\\', '_')}_core"
+      def update_delta_indexes(model)
+        config = ThinkingSphinx::Configuration.instance
+        rotate = ThinkingSphinx.sphinx_running? ? "--rotate" : ""
+        
+        output = `#{config.bin_path}#{config.indexer_binary_name} --config #{config.config_file} #{rotate} #{model.delta_index_names.join(' ')}`
+        puts(output) unless ThinkingSphinx.suppress_delta_output?
       end
       
-      def delta_index_name(model)
-        "#{model.source_of_sphinx_index.name.underscore.tr(':/\\', '_')}_delta"
-      end  
-      
-      private
+      def delete_from_core(model, instance)
+        model.core_index_names.each do |index_name|
+          model.delete_in_index index_name, instance.sphinx_document_id
+        end
+      end
       
       def adapter
         @adapter = @index.model.sphinx_database_adapter

data/lib/thinking_sphinx/index.rb

@@ -2,14 +2,8 @@ require 'thinking_sphinx/index/builder'
 require 'thinking_sphinx/index/faux_column'
 
 module ThinkingSphinx
-  # The Index class is a ruby representation of a Sphinx source (not a Sphinx
-  # index - yes, I know it's a little confusing. You'll manage). This is
-  # another 'internal' Thinking Sphinx class - if you're using it directly,
-  # you either know what you're doing, or messing with things beyond your ken.
-  # Enjoy.
-  # 
   class Index
-    attr_accessor :model, :sources, :delta_object
+    attr_accessor :name, :model, :sources, :delta_object
     
     # Create a new index instance by passing in the model it is tied to, and
     # a block to build it with (optional but recommended). For documentation
@@ -26,6 +20,7 @@ module ThinkingSphinx
     #   end
     #
     def initialize(model, &block)
+      @name         = self.class.name_for model
       @model        = model
       @sources      = []
       @options      = {}
@@ -40,8 +35,19 @@ module ThinkingSphinx
       @sources.collect { |source| source.attributes }.flatten
     end
     
-    def name
-      self.class.name_for @model
+    def core_name
+      "#{name}_core"
+    end
+    
+    def delta_name
+      "#{name}_delta"
+    end
+    
+    def all_names
+      names  = [core_name]
+      names << delta_name if delta?
+      
+      names
     end
     
     def self.name_for(model)
@@ -61,7 +67,7 @@ module ThinkingSphinx
     end
     
     def options
-      all_index_options = ThinkingSphinx::Configuration.instance.index_options.clone
+      all_index_options = config.index_options.clone
       @options.keys.select { |key|
         ThinkingSphinx::Configuration::IndexOptions.include?(key.to_s) ||
         ThinkingSphinx::Configuration::CustomOptions.include?(key.to_s)
@@ -73,6 +79,12 @@ module ThinkingSphinx
       !@delta_object.nil?
     end
     
+    def to_riddle(offset)
+      indexes = [to_riddle_for_core(offset)]
+      indexes << to_riddle_for_delta(offset) if delta?
+      indexes << to_riddle_for_distributed
+    end
+    
     private
     
     def adapter
@@ -83,17 +95,62 @@ module ThinkingSphinx
       options[:charset_type] == "utf-8"
     end
     
-    # Does all the magic with the block provided to the base #initialize.
-    # Creates a new class subclassed from Builder, and evaluates the block
-    # on it, then pulls all relevant settings - fields, attributes, conditions,
-    # properties - into the new index.
-    # 
-    def initialize_from_builder(&block)
-      #
-    end
-    
     def sql_query_pre_for_delta
       [""]
     end
+    
+    def config
+      @config ||= ThinkingSphinx::Configuration.instance
+    end
+    
+    def to_riddle_for_core(offset)
+      index = Riddle::Configuration::Index.new core_name
+      index.path = File.join config.searchd_file_path, index.name
+      
+      set_configuration_options_for_indexes index
+      set_field_settings_for_indexes        index
+      
+      sources.each_with_index do |source, i|
+        index.sources << source.to_riddle_for_core(offset, i)
+      end
+      
+      index
+    end
+    
+    def to_riddle_for_delta(offset)
+      index = Riddle::Configuration::Index.new delta_name
+      index.parent = core_name
+      index.path = File.join config.searchd_file_path, index.name
+      
+      sources.each_with_index do |source, i|
+        index.sources << source.to_riddle_for_delta(offset, i)
+      end
+      
+      index
+    end
+    
+    def to_riddle_for_distributed
+      index = Riddle::Configuration::DistributedIndex.new name
+      index.local_indexes << core_name
+      index.local_indexes.unshift delta_name if delta?
+      index
+    end
+    
+    def set_configuration_options_for_indexes(index)
+      config.index_options.each do |key, value|
+        index.send("#{key}=".to_sym, value)
+      end
+      
+      options.each do |key, value|
+        index.send("#{key}=".to_sym, value) if ThinkingSphinx::Configuration::IndexOptions.include?(key.to_s) && !value.nil?
+      end
+    end
+    
+    def set_field_settings_for_indexes(index)
+      field_names = lambda { |field| field.unique_name.to_s }
+      
+      index.prefix_field_names += prefix_fields.collect(&field_names)
+      index.infix_field_names  += infix_fields.collect(&field_names)
+    end
   end
 end

data/lib/thinking_sphinx/index/builder.rb

@@ -20,9 +20,9 @@ module ThinkingSphinx
         }
       }
       
-      def self.generate(model, &block)
+      def self.generate(model, name = nil, &block)
         index  = ThinkingSphinx::Index.new(model)
-        model.sphinx_facets ||= []
+        index.name = name unless name.nil?
         
         Builder.new(index, &block) if block_given?
         

data/lib/thinking_sphinx/search.rb

@@ -155,6 +155,8 @@ module ThinkingSphinx
     # 
     def total_pages
       populate
+      return 0 if @results[:total].nil?
+      
       @total_pages ||= (@results[:total] / per_page.to_f).ceil
     end
     # Compatibility with older versions of will_paginate
@@ -166,6 +168,8 @@ module ThinkingSphinx
     # 
     def total_entries
       populate
+      return 0 if @results[:total_found].nil?
+      
       @total_entries ||= @results[:total_found]
     end
     
@@ -313,6 +317,9 @@ module ThinkingSphinx
         # puts "value: #{value.inspect}"
         client.send("#{key}=", value) if value
       end
+
+      # treated non-standard as :select is already used for AR queries
+      client.select = options[:sphinx_select] || '*'
       
       client.limit      = per_page
       client.offset     = offset

data/lib/thinking_sphinx/search_methods.rb

@@ -155,7 +155,7 @@ module ThinkingSphinx
       # asterisks. You need to make the config/sphinx.yml changes yourself.
       #
       # By default, the tokens are assumed to match the regular expression
-      # /\w+/u. If you've modified the charset_table, pass another regular
+      # /\w\+/u\+. If you've modified the charset_table, pass another regular
       # expression, e.g.
       #
       #   User.search("oo@bar.c", :star => /[\w@.]+/u)
@@ -313,13 +313,31 @@ module ThinkingSphinx
       # Once you've got your results set, you can access the distances as
       # follows:
       # 
-      # @results.each_with_geodist do |result, distance|
-      #   # ...
-      # end
+      #   @results.each_with_geodist do |result, distance|
+      #     # ...
+      #   end
       # 
       # The distance value is returned as a float, representing the distance in
       # metres.
       # 
+      # == Filtering by custom attributes
+      #
+      # Do note that this applies only to sphinx 0.9.9
+      # 
+      # Should you find yourself in desperate need of a filter that involves
+      # selecting either one of multiple conditions, one solution could be
+      # provided by the :sphinx_select option within the search. 
+      # This handles which fields are selected by sphinx from its store.
+      #
+      # The default value is "*", and you can add custom fields using syntax
+      # similar to sql:
+      #
+      #   Flower.search "foo",
+      #     :sphinx_select => "*, petals < 1 or color = 2 as grass"
+      #
+      # This will add the 'grass' attribute, which will now be usable in your
+      # filters.
+      #   
       # == Handling a Stale Index
       #
       # Especially if you don't use delta indexing, you risk having records in

data/lib/thinking_sphinx/source.rb

@@ -33,12 +33,12 @@ module ThinkingSphinx
     end
     
     def name
-      @model.sphinx_name
+      index.name
     end
     
-    def to_riddle_for_core(offset, index)
+    def to_riddle_for_core(offset, position)
       source = Riddle::Configuration::SQLSource.new(
-        "#{name}_core_#{index}", adapter.sphinx_identifier
+        "#{index.core_name}_#{position}", adapter.sphinx_identifier
       )
       
       set_source_database_settings  source
@@ -49,11 +49,11 @@ module ThinkingSphinx
       source
     end
     
-    def to_riddle_for_delta(offset, index)
+    def to_riddle_for_delta(offset, position)
       source = Riddle::Configuration::SQLSource.new(
-        "#{name}_delta_#{index}", adapter.sphinx_identifier
+        "#{index.delta_name}_#{position}", adapter.sphinx_identifier
       )
-      source.parent = "#{name}_core_#{index}"
+      source.parent = "#{index.core_name}_#{position}"
       
       set_source_database_settings  source
       set_source_attributes         source, offset, true

data/lib/thinking_sphinx/source/sql.rb

@@ -13,8 +13,10 @@ module ThinkingSphinx
       #   source.to_sql(:delta => true)
       #
       def to_sql(options={})
-        sql = <<-SQL
-SELECT #{ sql_select_clause options[:offset] }
+        sql = "SELECT "
+        sql += "SQL_NO_CACHE " if adapter.sphinx_identifier == "mysql"
+        sql += <<-SQL
+#{ sql_select_clause options[:offset] }
 FROM #{ @model.quoted_table_name }
   #{ all_associations.collect { |assoc| assoc.to_sql }.join(' ') }
 #{ sql_where_clause(options) }

data/spec/{lib/thinking_sphinx → thinking_sphinx}/active_record/delta_spec.rb

@@ -73,14 +73,12 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
       Person.delta_object.stub!(:` => "", :toggled => true)
       
       @person = Person.new
-      @person.stub!(
-        :in_both_indexes?     => false,
-        :sphinx_document_id => 1
-      )
+      Person.stub!(:search_for_id => false)
+      @person.stub!(:sphinx_document_id => 1)
       
       @client = Riddle::Client.new
       @client.stub!(:update => true)
-      Riddle::Client.stub!(:new => @client)
+      ThinkingSphinx::Configuration.instance.stub!(:client => @client)
     end
     
     it "shouldn't index if delta indexing is disabled" do
@@ -121,7 +119,7 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
     end
     
     it "should update the deleted attribute if in the core index" do
-      @person.stub!(:in_both_indexes? => true)
+      Person.stub!(:search_for_id => true)
       @client.should_receive(:update)
       
       @person.send(:index_delta)

data/spec/{lib/thinking_sphinx → thinking_sphinx}/active_record_spec.rb

@@ -1,102 +1,59 @@
 require 'spec/spec_helper'
 
 describe ThinkingSphinx::ActiveRecord do
-  describe '.define_index' do
-    before :each do
-      module ::TestModule
-        class TestModel < ActiveRecord::Base; end
-      end
-      
-      TestModule::TestModel.stub!(
-        :before_save    => true,
-        :after_commit   => true,
-        :after_destroy  => true
-      )
-      
-      @index = ThinkingSphinx::Index.new(TestModule::TestModel)
-      @index.stub!(:delta? => false)
-      ThinkingSphinx::Index::Builder.stub!(:generate => @index)
-    end
-    
-    after :each do
-      # Remove the class so we can redefine it
-      TestModule.send(:remove_const, :TestModel)
-      
-      ThinkingSphinx.indexed_models.delete "TestModule::TestModel"
-    end
+  before :each do
+    @existing_alpha_indexes = Alpha.sphinx_indexes.clone
+    @existing_beta_indexes  = Beta.sphinx_indexes.clone
     
+    Alpha.sphinx_indexes.clear
+    Beta.sphinx_indexes.clear
+  end
+  
+  after :each do
+    Alpha.sphinx_indexes.replace @existing_alpha_indexes
+    Beta.sphinx_indexes.replace  @existing_beta_indexes
+  end
+  
+  describe '.define_index' do
     it "should do nothing if indexes are disabled" do
       ThinkingSphinx.define_indexes = false
       ThinkingSphinx::Index.should_not_receive(:new)
       
-      TestModule::TestModel.define_index {}
+      Alpha.define_index { }
       
       ThinkingSphinx.define_indexes = true
     end
     
     it "should add a new index to the model" do
-      TestModule::TestModel.define_index {}
+      index = Alpha.define_index { indexes :name }
       
-      TestModule::TestModel.sphinx_indexes.length.should == 1
+      Alpha.sphinx_indexes.should include(index)
     end
     
     it "should add to ThinkingSphinx.indexed_models if the model doesn't already exist in the array" do
-      TestModule::TestModel.define_index do; end
+      Alpha.define_index { indexes :name }
       
-      ThinkingSphinx.indexed_models.should include("TestModule::TestModel")
+      ThinkingSphinx.indexed_models.should include("Alpha")
     end
     
     it "shouldn't add to ThinkingSphinx.indexed_models if the model already exists in the array" do
-      TestModule::TestModel.define_index do; end
+      Alpha.define_index { indexes :name }
+      Alpha.define_index { indexes :name }
       
       ThinkingSphinx.indexed_models.select { |model|
-        model == "TestModule::TestModel"
+        model == "Alpha"
       }.length.should == 1
-      
-      TestModule::TestModel.define_index do; end
-      
-      ThinkingSphinx.indexed_models.select { |model|
-        model == "TestModule::TestModel"
-      }.length.should == 1
-    end
-    
-    it "should add before_save and after_commit hooks to the model if delta indexing is enabled" do
-      @index.stub!(:delta? => true)
-      TestModule::TestModel.should_receive(:before_save).with(:toggle_delta)
-      TestModule::TestModel.should_receive(:after_commit).with(:index_delta)
-      
-      TestModule::TestModel.define_index do; end
-    end
-    
-    it "should not add before_save and after_commit hooks to the model if delta indexing is disabled" do
-      TestModule::TestModel.should_not_receive(:before_save).with(:toggle_delta)
-      TestModule::TestModel.should_not_receive(:after_commit).with(:index_delta)
-      
-      TestModule::TestModel.define_index do; end
-    end
-    
-    it "should add an after_destroy hook with delta indexing enabled" do
-      @index.stub!(:delta? => true)
-      TestModule::TestModel.should_receive(:after_destroy).with(:toggle_deleted)
-      
-      TestModule::TestModel.define_index do; end
-    end
-    
-    it "should add an after_destroy hook with delta indexing disabled" do
-      TestModule::TestModel.should_receive(:after_destroy).with(:toggle_deleted)
-      
-      TestModule::TestModel.define_index do; end
     end
     
     it "should return the new index" do
-      TestModule::TestModel.define_index.should == @index
+      Alpha.define_index.should be_a(ThinkingSphinx::Index)
     end
     
     it "should die quietly if there is a database error" do
       ThinkingSphinx::Index::Builder.stub(:generate) { raise Mysql::Error }
       
       lambda {
-        TestModule::TestModel.define_index
+        Alpha.define_index { indexes :name }
       }.should_not raise_error
     end
     
@@ -104,9 +61,122 @@ describe ThinkingSphinx::ActiveRecord do
       ThinkingSphinx::Index::Builder.stub(:generate) { raise StandardError }
       
       lambda {
-        TestModule::TestModel.define_index
+        Alpha.define_index { indexes :name }
       }.should raise_error
     end
+    
+    it "should set the index's name using the parameter if provided" do
+      index = Alpha.define_index('custom') { indexes :name }
+      
+      index.name.should == 'custom'
+    end
+    
+    context 'callbacks' do
+      it "should add a toggle_deleted callback" do
+        Alpha.should_receive(:after_destroy).with(:toggle_deleted)
+      
+        Alpha.define_index { indexes :name }
+      end
+      
+      it "should not add toggle_deleted callback more than once" do
+        Alpha.should_receive(:after_destroy).with(:toggle_deleted).once
+      
+        Alpha.define_index { indexes :name }
+        Alpha.define_index { indexes :name }
+      end
+      
+      it "should add a update_attribute_values callback" do
+        Alpha.should_receive(:after_commit).with(:update_attribute_values)
+      
+        Alpha.define_index { indexes :name }
+      end
+    
+      it "should not add update_attribute_values callback more than once" do
+        Alpha.should_receive(:after_commit).with(:update_attribute_values).once
+      
+        Alpha.define_index { indexes :name }
+        Alpha.define_index { indexes :name }
+      end
+      
+      it "should add a toggle_delta callback if deltas are enabled" do
+        Beta.should_receive(:before_save).with(:toggle_delta)
+
+        Beta.define_index {
+          indexes :name
+          set_property :delta => true
+        }
+      end
+      
+      it "should not add a toggle_delta callback if deltas are disabled" do
+        Alpha.should_not_receive(:before_save).with(:toggle_delta)
+
+        Alpha.define_index { indexes :name }
+      end
+      
+      it "should add the toggle_delta callback if deltas are disabled in other indexes" do
+        Beta.should_receive(:before_save).with(:toggle_delta).once
+
+        Beta.define_index { indexes :name }
+        Beta.define_index {
+          indexes :name
+          set_property :delta => true
+        }
+      end
+      
+      it "should only add the toggle_delta callback once" do
+        Beta.should_receive(:before_save).with(:toggle_delta).once
+
+        Beta.define_index {
+          indexes :name
+          set_property :delta => true
+        }
+        Beta.define_index {
+          indexes :name
+          set_property :delta => true
+        }
+      end
+      
+      it "should add an index_delta callback if deltas are enabled" do
+        Beta.stub!(:after_commit => true)
+        Beta.should_receive(:after_commit).with(:index_delta)
+
+        Beta.define_index {
+          indexes :name
+          set_property :delta => true
+        }
+      end
+      
+      it "should not add an index_delta callback if deltas are disabled" do
+        Alpha.should_not_receive(:after_commit).with(:index_delta)
+
+        Alpha.define_index { indexes :name }
+      end
+      
+      it "should add the index_delta callback if deltas are disabled in other indexes" do
+        Beta.stub!(:after_commit => true)
+        Beta.should_receive(:after_commit).with(:index_delta).once
+
+        Beta.define_index { indexes :name }
+        Beta.define_index {
+          indexes :name
+          set_property :delta => true
+        }
+      end
+      
+      it "should only add the index_delta callback once" do
+        Beta.stub!(:after_commit => true)
+        Beta.should_receive(:after_commit).with(:index_delta).once
+
+        Beta.define_index {
+          indexes :name
+          set_property :delta => true
+        }
+        Beta.define_index {
+          indexes :name
+          set_property :delta => true
+        }
+      end
+    end    
   end
 
   describe "index methods" do
@@ -188,17 +258,9 @@ describe ThinkingSphinx::ActiveRecord do
       @client.stub!(:update => true)
       @person = Person.find(:first)
       
-      Riddle::Client.stub!(:new => @client)
+      @configuration.stub!(:client => @client)
       Person.sphinx_indexes.each { |index| index.stub!(:delta? => false) }
-      @person.stub!(:in_core_index? => true)
-    end
-    
-    it "should create a client using the Configuration's address and port" do
-      Riddle::Client.should_receive(:new).with(
-        @configuration.address, @configuration.port
-      )
-      
-      @person.toggle_deleted
+      Person.stub!(:search_for_id => true)
     end
     
     it "should update the core index's deleted flag if in core index" do
@@ -210,7 +272,7 @@ describe ThinkingSphinx::ActiveRecord do
     end
     
     it "shouldn't update the core index's deleted flag if the record isn't in it" do
-      @person.stub!(:in_core_index? => false)
+      Person.stub!(:search_for_id => false)
       @client.should_not_receive(:update).with(
         "person_core", ["sphinx_deleted"], {@person.sphinx_document_id => [1]}
       )
@@ -221,7 +283,7 @@ describe ThinkingSphinx::ActiveRecord do
     it "shouldn't attempt to update the deleted flag if sphinx isn't running" do
       ThinkingSphinx.stub!(:sphinx_running? => false)
       @client.should_not_receive(:update)
-      @person.should_not_receive(:in_core_index?)
+      Person.should_not_receive(:search_for_id)
       
       @person.toggle_deleted
     end
@@ -294,22 +356,29 @@ describe ThinkingSphinx::ActiveRecord do
     end
   end
   
-  it "should return the sphinx document id as expected" do
-    person      = Person.find(:first)
-    model_count = ThinkingSphinx.indexed_models.length
-    offset      = ThinkingSphinx.indexed_models.index("Person")
-    
-    (person.id * model_count + offset).should == person.sphinx_document_id
-    
-    alpha       = Alpha.find(:first)
-    offset      = ThinkingSphinx.indexed_models.index("Alpha")
-    
-    (alpha.id * model_count + offset).should == alpha.sphinx_document_id
-    
-    beta        = Beta.find(:first)
-    offset      = ThinkingSphinx.indexed_models.index("Beta")
+  describe '#sphinx_document_id' do
+    before :each do
+      Alpha.define_index { indexes :name }
+      Beta.define_index  { indexes :name }
+    end
     
-    (beta.id * model_count + offset).should == beta.sphinx_document_id
+    it "should return values with the expected offset" do
+      person      = Person.find(:first)
+      model_count = ThinkingSphinx.indexed_models.length
+      offset      = ThinkingSphinx.indexed_models.index("Person")
+      
+      (person.id * model_count + offset).should == person.sphinx_document_id
+      
+      alpha       = Alpha.find(:first)
+      offset      = ThinkingSphinx.indexed_models.index("Alpha")
+      
+      (alpha.id * model_count + offset).should == alpha.sphinx_document_id
+      
+      beta        = Beta.find(:first)
+      offset      = ThinkingSphinx.indexed_models.index("Beta")
+      
+      (beta.id * model_count + offset).should == beta.sphinx_document_id
+    end
   end
   
   describe '#primary_key_for_sphinx' do
@@ -339,10 +408,16 @@ describe ThinkingSphinx::ActiveRecord do
   
   describe '.sphinx_index_names' do
     it "should return the core index" do
+      Alpha.define_index { indexes :name }
       Alpha.sphinx_index_names.should == ['alpha_core']
     end
     
     it "should return the delta index if enabled" do
+      Beta.define_index {
+        indexes :name
+        set_property :delta => true
+      }
+      
       Beta.sphinx_index_names.should == ['beta_core', 'beta_delta']
     end
     
@@ -350,4 +425,89 @@ describe ThinkingSphinx::ActiveRecord do
       Parent.sphinx_index_names.should == ['person_core', 'person_delta']
     end
   end
+  
+  describe '.indexed_by_sphinx?' do
+    it "should return true if there is at least one index on the model" do
+      Alpha.define_index { indexes :name }
+      
+      Alpha.should be_indexed_by_sphinx
+    end
+    
+    it "should return false if there are no indexes on the model" do
+      Gamma.should_not be_indexed_by_sphinx
+    end
+  end
+  
+  describe '.delta_indexed_by_sphinx?' do
+    it "should return true if there is at least one delta index on the model" do
+      Beta.define_index {
+        indexes :name
+        set_property :delta => true
+      }
+      
+      Beta.should be_delta_indexed_by_sphinx
+    end
+    
+    it "should return false if there are no delta indexes on the model" do
+      Alpha.define_index { indexes :name }
+      
+      Alpha.should_not be_delta_indexed_by_sphinx
+    end
+  end
+  
+  describe '.delete_in_index' do
+    before :each do
+      @client = stub('client')
+      ThinkingSphinx.stub!(:sphinx_running? => true)
+      ThinkingSphinx::Configuration.instance.stub!(:client => @client)
+      Alpha.stub!(:search_for_id => true)
+    end
+    
+    it "should not update if the document isn't in the given index" do
+      Alpha.stub!(:search_for_id => false)
+      @client.should_not_receive(:update)
+      
+      Alpha.delete_in_index('alpha_core', 42)
+    end
+    
+    it "should direct the update to the supplied index" do
+      @client.should_receive(:update) do |index, attributes, values|
+        index.should == 'custom_index_core'
+      end
+      
+      Alpha.delete_in_index('custom_index_core', 42)
+    end
+    
+    it "should set the sphinx_deleted flag to true" do
+      @client.should_receive(:update) do |index, attributes, values|
+        attributes.should == ['sphinx_deleted']
+        values.should == {42 => [1]}
+      end
+      
+      Alpha.delete_in_index('alpha_core', 42)
+    end
+  end
+  
+  describe '.core_index_names' do
+    it "should return each index's core name" do
+      foo = Alpha.define_index { indexes :name }
+      foo.name = 'foo'
+      bar = Alpha.define_index { indexes :name }
+      bar.name = 'bar'
+      
+      Alpha.core_index_names.should == ['foo_core', 'bar_core']
+    end
+  end
+  
+  describe '.delta_index_names' do
+    it "should return index delta names, for indexes with deltas enabled" do
+      foo = Alpha.define_index { indexes :name }
+      foo.name = 'foo'
+      foo.delta_object = stub('delta')
+      bar = Alpha.define_index { indexes :name }
+      bar.name = 'bar'
+      
+      Alpha.delta_index_names.should == ['foo_delta']
+    end
+  end
 end