warp-thinking-sphinx 1.2.12 → 1.3.10

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,30 +33,31 @@ 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
       set_source_attributes         source, offset
-      set_source_sql                source, offset
       set_source_settings           source
+      set_source_sql                source, offset
 
       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
+      set_source_settings           source
       set_source_sql                source, offset, true
 
       source
@@ -146,7 +147,7 @@ module ThinkingSphinx
     end
 
     def utf8?
-      @index.options[:charset_type] == "utf-8"
+      @index.options[:charset_type] =~ /utf-8|zh_cn.utf-8/
     end
   end
 end

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) }
@@ -52,7 +54,7 @@ FROM #{ @model.quoted_table_name }
       #
       def to_sql_query_info(offset)
         "SELECT * FROM #{@model.quoted_table_name} WHERE " +
-        "#{quote_column(@model.primary_key_for_sphinx)} = (($id - #{offset}) / #{ThinkingSphinx.indexed_models.size})"
+        "#{quote_column(@model.primary_key_for_sphinx)} = (($id - #{offset}) / #{ThinkingSphinx.context.indexed_models.size})"
       end
 
       def sql_select_clause(offset)

data/lib/thinking_sphinx/tasks.rb

@@ -29,10 +29,8 @@ namespace :thinking_sphinx do
     raise RuntimeError, "searchd is already running." if sphinx_running?
     
     Dir["#{config.searchd_file_path}/*.spl"].each { |file| File.delete(file) }
-
-    system! "#{config.bin_path}#{config.searchd_binary_name} --pidfile --config \"#{config.config_file}\""
     
-    sleep(2)
+    config.controller.start
     
     if sphinx_running?
       puts "Started successfully (pid #{sphinx_pid})."
@@ -48,7 +46,7 @@ namespace :thinking_sphinx do
     else
       config = ThinkingSphinx::Configuration.instance
       pid    = sphinx_pid
-      system! "#{config.bin_path}#{config.searchd_binary_name} --stop --config \"#{config.config_file}\""
+      config.controller.stop
       puts "Stopped search daemon (pid #{pid})."
     end
   end
@@ -65,19 +63,21 @@ namespace :thinking_sphinx do
   
   desc "Index data for Sphinx using Thinking Sphinx's settings"
   task :index => :app_env do
-    ThinkingSphinx::Deltas::Job.cancel_thinking_sphinx_jobs
-    
     config = ThinkingSphinx::Configuration.instance
     unless ENV["INDEX_ONLY"] == "true"
       puts "Generating Configuration to #{config.config_file}"
       config.build
     end
-        
-    FileUtils.mkdir_p config.searchd_file_path
-    cmd = "#{config.bin_path}#{config.indexer_binary_name} --config \"#{config.config_file}\" --all"
-    cmd << " --rotate" if sphinx_running?
     
-    system! cmd
+    FileUtils.mkdir_p config.searchd_file_path
+    config.controller.index :verbose => true
+  end
+  
+  desc "Reindex Sphinx without regenerating the configuration file"
+  task :reindex => :app_env do
+    config = ThinkingSphinx::Configuration.instance
+    FileUtils.mkdir_p config.searchd_file_path
+    puts config.controller.index
   end
   
   desc "Stop Sphinx (if it's running), rebuild the indexes, and start Sphinx"
@@ -86,30 +86,6 @@ namespace :thinking_sphinx do
     Rake::Task["thinking_sphinx:index"].invoke
     Rake::Task["thinking_sphinx:start"].invoke
   end
-  
-  namespace :index do
-    task :delta => :app_env do
-      ThinkingSphinx.indexed_models.select { |model|
-        model.constantize.sphinx_indexes.any? { |index| index.delta? }
-      }.each do |model|
-        model.constantize.sphinx_indexes.select { |index|
-          index.delta? && index.delta_object.respond_to?(:delayed_index)
-        }.each { |index|
-          index.delta_object.delayed_index(index.model)
-        }
-      end
-    end
-  end
-  
-  desc "Process stored delta index requests"
-  task :delayed_delta => :app_env do
-    require 'delayed/worker'
-    
-    Delayed::Worker.new(
-      :min_priority => ENV['MIN_PRIORITY'],
-      :max_priority => ENV['MAX_PRIORITY']
-    ).start
-  end
 end
 
 namespace :ts do
@@ -123,11 +99,9 @@ namespace :ts do
   task :stop    => "thinking_sphinx:stop"
   desc "Index data for Sphinx using Thinking Sphinx's settings"
   task :in      => "thinking_sphinx:index"
-  namespace :in do
-    desc "Index Thinking Sphinx datetime delta indexes"
-    task :delta => "thinking_sphinx:index:delta"
-  end
   task :index   => "thinking_sphinx:index"
+  desc "Reindex Sphinx without regenerating the configuration file"
+  task :reindex => "thinking_sphinx:reindex"
   desc "Restart Sphinx"
   task :restart => "thinking_sphinx:restart"
   desc "Generate the Sphinx configuration file using Thinking Sphinx's settings"
@@ -136,8 +110,6 @@ namespace :ts do
   task :config  => "thinking_sphinx:configure"
   desc "Stop Sphinx (if it's running), rebuild the indexes, and start Sphinx"
   task :rebuild => "thinking_sphinx:rebuild"
-  desc "Process stored delta index requests"
-  task :dd      => "thinking_sphinx:delayed_delta"
 end
 
 def sphinx_pid
@@ -147,19 +119,3 @@ end
 def sphinx_running?
   ThinkingSphinx.sphinx_running?
 end
-
-# a fail-fast, hopefully helpful version of system
-def system!(cmd)
-  unless system(cmd)
-    raise <<-SYSTEM_CALL_FAILED
-The following command failed:
-  #{cmd}
-
-This could be caused by a PATH issue in the environment of cron/passenger/etc. Your current PATH:
-  #{ENV['PATH']}
-You can set the path to your indexer and searchd binaries using the bin_path property in config/sphinx.yml:
-  production:
-    bin_path: '/usr/local/bin'
-SYSTEM_CALL_FAILED
-  end
-end

data/lib/thinking_sphinx/test.rb

@@ -0,0 +1,52 @@
+class ThinkingSphinx::Test
+  def self.init(suppress_delta_output = true)
+    set_flags suppress_delta_output
+    create_indexes_folder
+  end
+  
+  def self.start
+    config.build
+    config.controller.index
+    config.controller.start
+  end
+  
+  def self.start_with_autostop
+    autostop
+    start
+  end
+  
+  def self.stop
+    config.controller.stop
+    sleep(0.5) # Ensure Sphinx has shut down completely
+  end
+  
+  def self.autostop
+    Kernel.at_exit do
+      ThinkingSphinx::Test.stop
+    end
+  end
+  
+  def self.run(&block)
+    start
+    yield
+    stop
+  end
+  
+  def self.config
+    @config ||= ::ThinkingSphinx::Configuration.instance
+  end
+  
+  def self.index(*indexes)
+    config.controller.index *indexes
+  end
+  
+  def self.set_flags(suppress_delta_output)
+    ::ThinkingSphinx.deltas_enabled        = true
+    ::ThinkingSphinx.updates_enabled       = true
+    ::ThinkingSphinx.suppress_delta_output = suppress_delta_output
+  end
+  
+  def self.create_indexes_folder
+    FileUtils.mkdir_p config.searchd_file_path
+  end
+end

data/rails/init.rb

@@ -1,3 +1,7 @@
+Dir[File.join(File.dirname(__FILE__), '../vendor/*/lib')].each do |path|
+  $LOAD_PATH.unshift path
+end
+
 require 'thinking_sphinx'
 require 'action_controller/dispatcher'
 
@@ -9,6 +13,4 @@ ActionController::Dispatcher.to_prepare :thinking_sphinx do
   elsif Rails::VERSION::STRING.to_f > 2.1
     I18n.backend.load_translations(*I18n.load_path)
   end
-  
-  ThinkingSphinx::Configuration.instance.load_models
 end

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/thinking_sphinx/active_record/scopes_spec.rb

@@ -0,0 +1,177 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::Scopes do
+  after :each do
+    Alpha.remove_sphinx_scopes
+  end
+  
+  it "should be included into models with indexes" do
+    Alpha.included_modules.should include(ThinkingSphinx::ActiveRecord::Scopes)
+  end
+  
+  it "should not be included into models without indexes" do
+    Gamma.included_modules.should_not include(
+      ThinkingSphinx::ActiveRecord::Scopes
+    )
+  end
+  
+  describe '.sphinx_scope' do
+    before :each do
+      Alpha.sphinx_scope(:by_name) { |name| {:conditions => {:name => name}} }
+    end
+    
+    it "should define a method on the model" do
+      Alpha.should respond_to(:by_name)
+    end
+  end
+  
+  describe '.sphinx_scopes' do
+    before :each do
+      Alpha.sphinx_scope(:by_name) { |name| {:conditions => {:name => name}} }
+    end
+    
+    it "should return an array of defined scope names as symbols" do
+      Alpha.sphinx_scopes.should == [:by_name]
+    end
+  end
+
+  describe '.default_sphinx_scope' do
+    before :each do
+      Alpha.sphinx_scope(:scope_used_as_default_scope) { {:conditions => {:name => 'name'}} }
+      Alpha.default_sphinx_scope :scope_used_as_default_scope
+    end
+    
+    it "should return an array of defined scope names as symbols" do
+      Alpha.sphinx_scopes.should == [:scope_used_as_default_scope]
+    end
+    
+    it "should have a default_sphinx_scope" do
+      Alpha.has_default_sphinx_scope?.should be_true
+    end
+  end
+
+  describe '.remove_sphinx_scopes' do
+    before :each do
+      Alpha.sphinx_scope(:by_name) { |name| {:conditions => {:name => name}} }
+      Alpha.remove_sphinx_scopes
+    end
+    
+    it "should remove sphinx scope methods" do
+      Alpha.should_not respond_to(:by_name)
+    end
+    
+    it "should empty the list of sphinx scopes" do
+      Alpha.sphinx_scopes.should be_empty
+    end
+  end
+
+  describe '.example_default_scope' do
+    before :each do
+      Alpha.sphinx_scope(:foo_scope){ {:conditions => {:name => 'foo'}} }
+      Alpha.default_sphinx_scope :foo_scope
+      Alpha.sphinx_scope(:by_name) { |name| {:conditions => {:name => name}} }
+      Alpha.sphinx_scope(:by_foo)  { |foo|  {:conditions => {:foo  => foo}}  }
+    end
+
+    it "should return a ThinkingSphinx::Search object" do
+      Alpha.search.should be_a(ThinkingSphinx::Search)
+    end
+
+    it "should apply the default scope options to the underlying search object" do
+      search = ThinkingSphinx::Search.new(:classes => [Alpha])
+      search.search.options[:conditions].should == {:name => 'foo'}
+    end
+
+    it "should apply the default scope options and scope options to the underlying search object" do
+      search = ThinkingSphinx::Search.new(:classes => [Alpha])
+      search.by_foo('foo').search.options[:conditions].should == {:foo => 'foo', :name => 'foo'}
+    end
+
+    # FIXME: Probably the other way around is more logical? How to do this?
+    it "should apply the default scope options after other scope options to the underlying search object" do
+      search = ThinkingSphinx::Search.new(:classes => [Alpha])
+      search.by_name('bar').search.options[:conditions].should == {:name => 'foo'}
+    end
+  end
+
+  describe '.example_scope' do
+    before :each do
+      Alpha.sphinx_scope(:by_name) { |name| {:conditions => {:name => name}} }
+      Alpha.sphinx_scope(:by_foo)  { |foo|  {:conditions => {:foo  => foo}}  }
+      Alpha.sphinx_scope(:with_betas) { {:classes => [Beta]} }
+    end
+    
+    it "should return a ThinkingSphinx::Search object" do
+      Alpha.by_name('foo').should be_a(ThinkingSphinx::Search)
+    end
+    
+    it "should set the classes option" do
+      Alpha.by_name('foo').options[:classes].should == [Alpha]
+    end
+    
+    it "should be able to be called on a ThinkingSphinx::Search object" do
+      search = ThinkingSphinx::Search.new(:classes => [Alpha])
+      lambda {
+        search.by_name('foo')
+      }.should_not raise_error
+    end
+    
+    it "should return the search object it gets called upon" do
+      search = ThinkingSphinx::Search.new(:classes => [Alpha])
+      search.by_name('foo').should == search
+    end
+    
+    it "should apply the scope options to the underlying search object" do
+      search = ThinkingSphinx::Search.new(:classes => [Alpha])
+      search.by_name('foo').options[:conditions].should == {:name => 'foo'}
+    end
+    
+    it "should combine hash option scopes such as :conditions" do
+      search = ThinkingSphinx::Search.new(:classes => [Alpha])
+      search.by_name('foo').by_foo('bar').options[:conditions].
+        should == {:name => 'foo', :foo => 'bar'}
+    end
+    
+    it "should combine array option scopes such as :classes" do
+      search = ThinkingSphinx::Search.new(:classes => [Alpha])
+      search.with_betas.options[:classes].should == [Alpha, Beta]
+    end
+  end
+  
+  describe '.search_count_with_scope' do
+    before :each do
+      @config = ThinkingSphinx::Configuration.instance
+      @client = Riddle::Client.new
+
+      @config.stub!(:client => @client)
+      @client.stub!(:query => {:matches => [], :total_found => 43})
+      Alpha.sphinx_scope(:by_name) { |name| {:conditions => {:name => name}} }
+      Alpha.sphinx_scope(:ids_only) { {:ids_only => true} }
+    end
+    
+    it "should return the total number of results" do
+      Alpha.by_name('foo').search_count.should == 43
+    end
+    
+    it "should not make any calls to the database" do
+      Alpha.should_not_receive(:find)
+      
+      Alpha.by_name('foo').search_count
+    end
+    
+    it "should not leave the :ids_only option set and the results populated if it was not set before" do
+      stored_scope = Alpha.by_name('foo')
+      stored_scope.search_count
+      stored_scope.options[:ids_only].should be_false
+      stored_scope.populated?.should be_false
+    end
+    
+    it "should leave the :ids_only option set and the results populated if it was set before" do
+      stored_scope = Alpha.by_name('foo').ids_only
+      stored_scope.search_count
+      stored_scope.options[:ids_only].should be_true
+      stored_scope.populated?.should be_true
+    end
+  end
+  
+end