DrMark-thinking-sphinx 0.9.8 → 0.9.9

data/lib/thinking_sphinx/search.rb

@@ -21,15 +21,17 @@ module ThinkingSphinx
         begin
           pager = WillPaginate::Collection.create(page,
             client.limit, results[:total_found] || 0) do |collection|
-            collection.replace results[:matches].collect { |match| match[:doc] }
+            collection.replace results[:matches].collect { |match|
+              match[:attributes]["sphinx_internal_id"]
+            }
             collection.instance_variable_set :@total_entries, results[:total_found]
           end
           return (options[:include_raw] ? [pager, results] : pager)
         rescue
           if options[:include_raw]
-            return results[:matches].collect { |match| match[:doc] }, results
+            results[:matches].collect { |match| match[:attributes]["sphinx_internal_id"] }, results
           else
-            return results[:matches].collect { |match| match[:doc] }
+            results[:matches].collect { |match| match[:attributes]["sphinx_internal_id"] }
           end
         end
       end
@@ -198,22 +200,30 @@ module ThinkingSphinx
         klass   = options[:class]
         page    = options[:page] ? options[:page].to_i : 1
 
-        begin
-          pager = WillPaginate::Collection.create(page,
-            client.limit, results[:total] || 0) do |collection|
-            collection.replace instances_from_results(results[:matches], options, klass)
-            collection.instance_variable_set :@total_entries, results[:total_found]
-          end
+        # begin
+          pager = ThinkingSphinx::Collection.new(page, client.limit,
+            results[:total] || 0, results[:total_found] || 0)
+          pager.replace instances_from_results(results[:matches], options, klass)
+          # pager = WillPaginate::Collection.create(page,
+          #   client.limit, results[:total] || 0) do |collection|
+          #   collection.replace instances_from_results(results[:matches], options, klass)
+          #   collection.instance_variable_set :@total_entries, results[:total_found]
+          # end
           return (options[:include_raw] ? [pager, results] : pager)
-        rescue StandardError => err
-          if options[:include_raw]
-            return instances_from_results(results[:matches], options, klass), results
-          else
-            return instances_from_results(results[:matches], options, klass)
-          end
+        # rescue StandardError => err
+        #   if options[:include_raw]
+        #     return instances_from_results(results[:matches], options, klass), results
+        #   else
+        #     return instances_from_results(results[:matches], options, klass)
+        #   end
         end
       end
 
+      def count(*args)
+        results, client = search_results(*args.clone)
+        results[:total] || 0
+      end
+
       # Checks if a document with the given id exists within a specific index.
       # Expected parameters:
       #
@@ -269,7 +279,7 @@ module ThinkingSphinx
         begin
           ::ActiveRecord::Base.logger.debug "Sphinx: #{query}"
           results = client.query query
-          ::ActiveRecord::Base.logger.debug "Sphinx Result: #{results[:matches].collect{|m| m[:doc]}.inspect}"
+          ::ActiveRecord::Base.logger.debug "Sphinx Result: #{results[:matches].collect{|m| m[:attributes]["sphinx_internal_id"]}.inspect}"
         rescue Errno::ECONNREFUSED => err
           raise ThinkingSphinx::ConnectionError, "Connection to Sphinx Daemon (searchd) failed."
         end
@@ -292,13 +302,13 @@ module ThinkingSphinx
         if klass.nil?
           results.collect { |result| instance_from_result result, options }
         else
-          ids = results.collect { |result| result[:doc] }
-          instances = klass.find(
+          ids = results.collect { |result| result[:attributes]["sphinx_internal_id"] }
+          instances = ids.length > 0 ? klass.find(
             :all,
             :conditions => {klass.primary_key.to_sym => ids},
             :include    => options[:include],
             :select     => options[:select]
-          )
+          ) : []
           final_instances = ids.collect { |obj_id| instances.detect { |obj| obj.id == obj_id } }
 
           final_instances = append_distances(final_instances, results, options[:distance_name]) if options[:distance_name] && (results.collect { |result| result[:attributes]['@geodist'] }.length > 0)
@@ -312,7 +322,8 @@ module ThinkingSphinx
       #
       def instance_from_result(result, options)
         class_from_crc(result[:attributes]["class_crc"]).find(
-          result[:doc], :include => options[:include], :select => options[:select]
+          result[:attributes]["sphinx_internal_id"],
+          :include => options[:include], :select => options[:select]
         )
       end
 
@@ -351,15 +362,18 @@ module ThinkingSphinx
             options[key] || index_options[key] || client.send(key)
           )
         end
-
+        
+        options[:classes] = [klass] if klass
+        
         client.anchor = anchor_conditions(klass, options) || {} if client.anchor.empty?
 
         client.filters << Riddle::Client::Filter.new(
           "sphinx_deleted", [0]
         )
+        
         # class filters
         client.filters << Riddle::Client::Filter.new(
-          "class_crc", options[:classes].collect { |klass| klass.to_crc32 }
+          "subclass_crcs", options[:classes].collect { |k| k.to_crc32s }.flatten
         ) if options[:classes]
 
         # normal attribute filters
@@ -400,18 +414,13 @@ module ThinkingSphinx
         conditions.each do |key,val|
           if attributes.include?(key.to_sym)
             filters << Riddle::Client::Filter.new(
-              key.to_s,
-              val.is_a?(Range) ? val : Array(val)
+              key.to_s, filter_value(val)
             )
           else
             search_string << "@#{key} #{val} "
           end
         end
-
-        filters << Riddle::Client::Filter.new(
-          "class_crc", [klass.to_crc32]
-        ) if klass
-
+        
         return search_string, filters
       end
 

data/lib/thinking_sphinx.rb

@@ -4,6 +4,7 @@ require 'riddle'
 require 'thinking_sphinx/active_record'
 require 'thinking_sphinx/association'
 require 'thinking_sphinx/attribute'
+require 'thinking_sphinx/collection'
 require 'thinking_sphinx/configuration'
 require 'thinking_sphinx/field'
 require 'thinking_sphinx/index'
@@ -20,7 +21,7 @@ module ThinkingSphinx
   module Version #:nodoc:
     Major = 0
     Minor = 9
-    Tiny  = 8
+    Tiny  = 9
     
     String = [Major, Minor, Tiny].join('.')
   end
@@ -58,7 +59,7 @@ module ThinkingSphinx
   # 
   def self.deltas_enabled?
     @@deltas_enabled  = (ThinkingSphinx::Configuration.environment != 'test') if @@deltas_enabled.nil?
-    @@deltas_enabled == true
+    @@deltas_enabled
   end
   
   # Enable/disable all delta indexing.
@@ -69,6 +70,24 @@ module ThinkingSphinx
     @@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
+  end
+  
+  # Enable/disable updates to Sphinx
+  # 
+  #   ThinkingSphinx.updates_enabled = false
+  #
+  def self.updates_enabled=(value)
+    @@updates_enabled = value
+  end
+  
   # Checks to see if MySQL will allow simplistic GROUP BY statements. If not,
   # or if not using MySQL, this will return false.
   # 

data/spec/unit/thinking_sphinx/active_record/delta_spec.rb

@@ -150,12 +150,10 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
       ThinkingSphinx.stub_method(:deltas_enabled? => true)
       
       @person = Person.new
-      @person.stub_method(:system => true)
-    end
-    
-    after :each do
-      ThinkingSphinx::Configuration.unstub_method(:environment)
-      ThinkingSphinx.unstub_method(:deltas_enabled?)
+      @person.stub_method(:system => true, :in_core_index? => false)
+      
+      @client = Riddle::Client.stub_instance(:update => true)
+      Riddle::Client.stub_method(:new => @client)
     end
     
     it "shouldn't index if delta indexing is disabled" do
@@ -163,6 +161,15 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
       
       @person.send(:index_delta)
       
+      @person.should_not have_received(:system)
+      @client.should_not have_received(:update)
+    end
+    
+    it "shouldn't index if index updating is disabled" do
+      ThinkingSphinx.stub_method(:updates_enabled? => false)
+      
+      @person.send(:index_delta)
+      
       @person.should_not have_received(:system)
     end
     
@@ -182,5 +189,19 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
         "indexer --config #{ThinkingSphinx::Configuration.new.config_file} --rotate person_delta"
       )
     end
+    
+    it "shouldn't update the deleted attribute if not in the index" do
+      @person.send(:index_delta)
+      
+      @client.should_not have_received(:update)
+    end
+    
+    it "should update the deleted attribute if in the core index" do
+      @person.stub_method(:in_core_index? => true)
+      
+      @person.send(:index_delta)
+      
+      @client.should have_received(:update)
+    end
   end
 end

data/spec/unit/thinking_sphinx/active_record/search_spec.rb

@@ -9,6 +9,10 @@ describe "ThinkingSphinx::ActiveRecord::Search" do
     ActiveRecord::Base.methods.should include("search")
   end
   
+  it "should add search_count to ActiveRecord::Base" do
+    ActiveRecord::Base.methods.should include("search_count")
+  end
+
   it "should add search_for_id to ActiveRecord::Base" do
     ActiveRecord::Base.methods.should include("search_for_id")
   end
@@ -78,4 +82,26 @@ describe "ThinkingSphinx::ActiveRecord::Search" do
       )
     end
   end
+
+  describe "search_count method" do
+    before :each do
+      ThinkingSphinx::Search.stub_method(:count => true)
+    end
+
+    it "should call ThinkingSphinx::Search#search with the class option set" do
+      Person.search_count("search")
+
+      ThinkingSphinx::Search.should have_received(:count).with(
+        "search", :class => Person
+      )
+    end
+
+    it "should override the class option" do
+      Person.search_count("search", :class => Friendship)
+
+      ThinkingSphinx::Search.should have_received(:count).with(
+        "search", :class => Person
+      )
+    end
+  end
 end

data/spec/unit/thinking_sphinx/active_record_spec.rb

@@ -21,7 +21,7 @@ describe "ThinkingSphinx::ActiveRecord" do
       # Remove the class so we can redefine it
       TestModule.send(:remove_const, :TestModel)
       
-      ThinkingSphinx::Index.unstub_method(:new)
+      ThinkingSphinx.indexed_models.delete "TestModule::TestModel"
     end
     
     it "should return nil and do nothing if indexes are disabled" do
@@ -207,6 +207,19 @@ describe "ThinkingSphinx::ActiveRecord" do
         "person_delta", ["sphinx_deleted"], {@person.id => 1}
       )
     end
+    
+    it "should not update either index if updates are disabled" do
+      ThinkingSphinx.stub_methods(
+        :updates_enabled? => false,
+        :deltas_enabled   => true
+      )
+      Person.indexes.each { |index| index.stub_method(:delta? => true) }
+      @person.delta = true
+      
+      @person.toggle_deleted
+      
+      @client.should_not have_received(:update)
+    end
   end
 
   describe "indexes in the inheritance chain (STI)" do

data/spec/unit/thinking_sphinx/attribute_spec.rb

@@ -199,8 +199,12 @@ describe ThinkingSphinx::Attribute do
       @first_join   = Object.stub_instance(:aliased_table_name => "tabular")
       @second_join  = Object.stub_instance(:aliased_table_name => "data")
       
-      @first_assoc  = ThinkingSphinx::Association.stub_instance(:join => @first_join)
-      @second_assoc = ThinkingSphinx::Association.stub_instance(:join => @second_join)
+      @first_assoc  = ThinkingSphinx::Association.stub_instance(
+        :join => @first_join, :has_column? => true
+      )
+      @second_assoc = ThinkingSphinx::Association.stub_instance(
+        :join => @second_join, :has_column? => true
+      )
     end
     
     it "should return the column name if the column is a string" do

data/spec/unit/thinking_sphinx/configuration_spec.rb

@@ -36,7 +36,7 @@ describe ThinkingSphinx::Configuration do
       ThinkingSphinx::Configuration.stub_method(:environment => "spec")
       ThinkingSphinx::Configuration.new.environment.should == "spec"
       ThinkingSphinx::Configuration.should have_received(:environment)
-    end
+    end    
   end
   
   describe "build method" do
@@ -59,13 +59,16 @@ describe ThinkingSphinx::Configuration do
       })
       
       @person_index_a = ThinkingSphinx::Index.stub_instance(
-        :to_config => "", :adapter => :mysql, :delta? => false, :name => "person"
+        :to_config => "",   :adapter => :mysql, :delta? => false,
+        :name => "person",  :model => Person
       )
       @person_index_b = ThinkingSphinx::Index.stub_instance(
-        :to_config => "", :adapter => :mysql, :delta? => false, :name => "person"
+        :to_config => "",   :adapter => :mysql, :delta? => false,
+        :name => "person",  :model => Person
       )
       @friendship_index_a = ThinkingSphinx::Index.stub_instance(
-        :to_config => "", :adapter => :mysql, :delta? => false, :name => "friendship"
+        :to_config => "",       :adapter => :mysql, :delta? => false,
+        :name => "friendship",  :model => Friendship
       )
       
       Person.stub_method(:indexes => [@person_index_a, @person_index_b])
@@ -81,8 +84,8 @@ describe ThinkingSphinx::Configuration do
       
       Person.unstub_method      :indexes
       Friendship.unstub_method  :indexes
-      
-      FileUtils.rm_rf "#{@config.app_root}/config"
+      # 
+      # FileUtils.rm_rf "#{@config.app_root}/config"
     end
     
     it "should load the models" do
@@ -137,13 +140,13 @@ describe ThinkingSphinx::Configuration do
       @config.build
       
       @person_index_a.should have_received(:to_config).with(
-        0, {:option => "value"}, @config.charset_type
+        Person, 0, {:option => "value"}, @config.charset_type, 0
       )
       @person_index_b.should have_received(:to_config).with(
-        1, {:option => "value"}, @config.charset_type
+        Person, 1, {:option => "value"}, @config.charset_type, 0
       )
       @friendship_index_a.should have_received(:to_config).with(
-        0, {:option => "value"}, @config.charset_type
+        Friendship, 0, {:option => "value"}, @config.charset_type, 1
       )
     end
     
@@ -204,7 +207,7 @@ describe ThinkingSphinx::Configuration do
     before :each do
       @settings = {
         "development" => {
-          "config_file"       => "my_conf_file.conf",
+          "config_file"       => "tmp/config/development.sphinx.conf",
           "searchd_log_file"  => "searchd_log_file.log",
           "query_log_file"    => "query_log_file.log",
           "pid_file"          => "pid_file.pid",
@@ -222,7 +225,7 @@ describe ThinkingSphinx::Configuration do
           "ignore_chars"      => "e"
         }
       }
-      # puts YAML.dump(settings)
+      
       open("#{RAILS_ROOT}/config/sphinx.yml", "w") do |f|
         f.write  YAML.dump(@settings)
       end
@@ -234,14 +237,16 @@ describe ThinkingSphinx::Configuration do
         config.send(key).should == value
       end
     end
+    
+    after :each do
+      FileUtils.rm "#{RAILS_ROOT}/config/sphinx.yml"
+    end
   end
   
   describe "core_index_for_model method" do
     before :each do
       @config = ThinkingSphinx::Configuration.new
-      @model  = Class.stub_instance(
-        :indexes  => [ThinkingSphinx::Index.new(Person)]
-      )
+      @model  = Person
     end
     
     it "should take its name from the model, with _core appended" do
@@ -312,12 +317,13 @@ describe ThinkingSphinx::Configuration do
     end
     
     it "should include the star-related settings when allow_star is true" do
-      @config.allow_star = true
+      @config.allow_star      = true
+      @config.min_prefix_len  = 1
       text =  @config.send(:core_index_for_model, @model, "my sources")
       
       text.should match(/enable_star\s+= 1/)
       text.should match(/min_prefix_len\s+= 1/)
-      text.should match(/min_infix_len\s+= 1/)
+      # text.should match(/min_infix_len\s+= 1/)
     end
     
     it "should use the configuration's infix and prefix length values if set" do
@@ -327,7 +333,7 @@ describe ThinkingSphinx::Configuration do
       text =  @config.send(:core_index_for_model, @model, "my sources")
       
       text.should match(/min_prefix_len\s+= 3/)
-      text.should match(/min_infix_len\s+= 2/)
+      # text.should match(/min_infix_len\s+= 2/)
     end
     
     it "should not include the star-related settings when allow_star is false" do
@@ -341,8 +347,16 @@ describe ThinkingSphinx::Configuration do
     
     it "should set prefix_fields if any fields are flagged explicitly" do
       @model.indexes.first.stub_methods(
-        :prefix_fields => ["a", "b", "c"],
-        :infix_fields  => ["d", "e", "f"]
+        :prefix_fields => [
+          ThinkingSphinx::Field.stub_instance(:unique_name => "a"),
+          ThinkingSphinx::Field.stub_instance(:unique_name => "b"),
+          ThinkingSphinx::Field.stub_instance(:unique_name => "c")
+        ],
+        :infix_fields  => [
+          ThinkingSphinx::Field.stub_instance(:unique_name => "d"),
+          ThinkingSphinx::Field.stub_instance(:unique_name => "e"),
+          ThinkingSphinx::Field.stub_instance(:unique_name => "f")
+        ]
       )
       
       @config.send(:core_index_for_model, @model, "my sources").should match(
@@ -358,8 +372,16 @@ describe ThinkingSphinx::Configuration do
     
     it "should set infix_fields if any fields are flagged explicitly" do
       @model.indexes.first.stub_methods(
-        :prefix_fields => ["a", "b", "c"],
-        :infix_fields  => ["d", "e", "f"]
+        :prefix_fields => [
+          ThinkingSphinx::Field.stub_instance(:unique_name => "a"),
+          ThinkingSphinx::Field.stub_instance(:unique_name => "b"),
+          ThinkingSphinx::Field.stub_instance(:unique_name => "c")
+        ],
+        :infix_fields  => [
+          ThinkingSphinx::Field.stub_instance(:unique_name => "d"),
+          ThinkingSphinx::Field.stub_instance(:unique_name => "e"),
+          ThinkingSphinx::Field.stub_instance(:unique_name => "f")
+        ]
       )
       
       @config.send(:core_index_for_model, @model, "my sources").should match(
@@ -399,9 +421,7 @@ describe ThinkingSphinx::Configuration do
   describe "delta_index_for_model method" do
     before :each do
       @config = ThinkingSphinx::Configuration.new
-      @model  = Class.stub_instance(
-        :indexes => [ThinkingSphinx::Index.new(Person)]
-      )
+      @model  = Person
     end
     
     it "should take its name from the model, with _delta appended" do
@@ -427,9 +447,7 @@ describe ThinkingSphinx::Configuration do
   describe "distributed_index_for_model method" do
     before :each do
       @config = ThinkingSphinx::Configuration.new
-      @model  = Class.stub_instance(
-        :indexes  => [ThinkingSphinx::Index.new(Person)]
-      )
+      @model  = Person
     end
     
     it "should take its name from the model" do

data/spec/unit/thinking_sphinx/field_spec.rb

@@ -158,8 +158,17 @@ describe ThinkingSphinx::Field do
       @first_join   = Object.stub_instance(:aliased_table_name => "tabular")
       @second_join  = Object.stub_instance(:aliased_table_name => "data")
       
-      @first_assoc  = ThinkingSphinx::Association.stub_instance(:join => @first_join)
-      @second_assoc = ThinkingSphinx::Association.stub_instance(:join => @second_join)
+      @first_assoc  = ThinkingSphinx::Association.stub_instance(
+        :join => @first_join, :has_column? => true
+      )
+      @second_assoc = ThinkingSphinx::Association.stub_instance(
+        :join => @second_join, :has_column? => true
+      )
+    end
+    
+    it "should return the column name if the column is a string" do
+      @field.columns = [ThinkingSphinx::Index::FauxColumn.new("string")]
+      @field.send(:column_with_prefix, @field.columns.first).should == "string"
     end
     
     it "should return the column with model's table prefix if there's no associations for the column" do

data/spec/unit/thinking_sphinx/index/faux_column_spec.rb

@@ -17,6 +17,33 @@ describe ThinkingSphinx::Index::FauxColumn do
     #
   end
   
+  describe "coerce class method" do
+    before :each do
+      @column = ThinkingSphinx::Index::FauxColumn.stub_instance
+      ThinkingSphinx::Index::FauxColumn.stub_method(:new => @column)
+    end
+    
+    it "should return a single faux column if passed a string" do
+      ThinkingSphinx::Index::FauxColumn.coerce("string").should == @column
+    end
+    
+    it "should return a single faux column if passed a symbol" do
+      ThinkingSphinx::Index::FauxColumn.coerce(:string).should == @column
+    end
+    
+    it "should return an array of faux columns if passed an array of strings" do
+      ThinkingSphinx::Index::FauxColumn.coerce(["one", "two"]).should == [
+        @column, @column
+      ]
+    end
+    
+    it "should return an array of faux columns if passed an array of symbols" do
+      ThinkingSphinx::Index::FauxColumn.coerce([:one, :two]).should == [
+        @column, @column
+      ]
+    end
+  end
+  
   describe "method_missing calls with no arguments" do
     it "should push any further method calls into name, and the old name goes into the stack" do
       #