DrMark-thinking-sphinx 1.1.15 → 1.2.5

data/lib/thinking_sphinx.rb

@@ -5,22 +5,24 @@ end
 require 'active_record'
 require 'riddle'
 require 'after_commit'
+require 'yaml'
 
 require 'thinking_sphinx/core/string'
 require 'thinking_sphinx/property'
 require 'thinking_sphinx/active_record'
 require 'thinking_sphinx/association'
 require 'thinking_sphinx/attribute'
-require 'thinking_sphinx/collection'
 require 'thinking_sphinx/configuration'
+require 'thinking_sphinx/excerpter'
 require 'thinking_sphinx/facet'
 require 'thinking_sphinx/class_facet'
-require 'thinking_sphinx/facet_collection'
+require 'thinking_sphinx/facet_search'
 require 'thinking_sphinx/field'
 require 'thinking_sphinx/index'
 require 'thinking_sphinx/source'
 require 'thinking_sphinx/rails_additions'
 require 'thinking_sphinx/search'
+require 'thinking_sphinx/search_methods'
 require 'thinking_sphinx/deltas'
 
 require 'thinking_sphinx/adapters/abstract_adapter'
@@ -34,19 +36,11 @@ Merb::Plugins.add_rakefiles(
 ) if defined?(Merb)
 
 module ThinkingSphinx
-  module Version #:nodoc:
-    Major = 1
-    Minor = 1
-    Tiny  = 15
-    
-    String = [Major, Minor, Tiny].join('.')
-  end
-  
   # A ConnectionError will get thrown when a connection to Sphinx can't be
   # made.
   class ConnectionError < StandardError
   end
-  
+
   # A StaleIdsException is thrown by Collection.instances_from_matches if there
   # are records in Sphinx but not in the database, so the search can be retried.
   class StaleIdsException < StandardError
@@ -56,41 +50,50 @@ module ThinkingSphinx
     end
   end
   
+  # The current version of Thinking Sphinx.
+  # 
+  # @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('.')
+  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 ||= []
   end
-  
+
   def self.unique_id_expression(offset = nil)
     "* #{ThinkingSphinx.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
   end
-  
+
   # Enable/disable indexes - you may want to do this while migrating data.
-  # 
+  #
   #   ThinkingSphinx.define_indexes = false
-  # 
+  #
   def self.define_indexes=(value)
     @@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
   end
-  
+
   # Enable/disable all delta indexing.
   #
   #   ThinkingSphinx.deltas_enabled = false
@@ -98,38 +101,38 @@ module ThinkingSphinx
   def self.deltas_enabled=(value)
     @@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
-  
+
   @@suppress_delta_output = false
-  
+
   def self.suppress_delta_output?
     @@suppress_delta_output
   end
-  
+
   def self.suppress_delta_output=(value)
     @@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(
@@ -137,46 +140,71 @@ module ThinkingSphinx
       ).all? { |key,value| value.nil? || value[/ONLY_FULL_GROUP_BY/].nil? }
     )
   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
+  end
+
+  # Tells Thinking Sphinx that Sphinx is running on a different machine, and
+  # thus it can't reliably guess whether it is running or not (ie: the
+  # #sphinx_running? method), and so just assumes it is.
+  #
+  # Useful for multi-machine deployments. Set it in your production.rb file.
+  #
+  #   ThinkingSphinx.remote_sphinx = true
+  #
+  def self.remote_sphinx=(value)
+    @@remote_sphinx = value
+  end
+
+  # Check if Sphinx is running. If remote_sphinx is set to true (indicating
+  # Sphinx is on a different machine), this will always return true, and you
+  # will have to handle any connection errors yourself.
+  #
   def self.sphinx_running?
+    remote_sphinx? || sphinx_running_by_pid?
+  end
+
+  # Check if Sphinx is actually running, provided the pid is on the same
+  # machine as this code.
+  #
+  def self.sphinx_running_by_pid?
     !!sphinx_pid && pid_active?(sphinx_pid)
   end
-  
+
   def self.sphinx_pid
-    pid_file    = ThinkingSphinx::Configuration.instance.pid_file
-    cat_command = 'cat'
-    return nil unless File.exists?(pid_file)
-    
-    if microsoft?
-      pid_file.gsub!('/', '\\')
-      cat_command = 'type'
+    if File.exists?(ThinkingSphinx::Configuration.instance.pid_file)
+      File.read(ThinkingSphinx::Configuration.instance.pid_file)[/\d+/]
+    else
+      nil
     end
-    
-    `#{cat_command} #{pid_file}`[/\d+/]
   end
-  
+
   def self.pid_active?(pid)
-    return true if microsoft?
-    
-    begin
-      # In JRuby this returns -1 if the process doesn't exist
-      Process.getpgid(pid.to_i) != -1
-    rescue Exception => e
-      false
-    end
+    !!Process.kill(0, pid.to_i)
+  rescue Exception => e
+    false
   end
-  
+
   def self.microsoft?
     RUBY_PLATFORM =~ /mswin/
   end
-  
+
   def self.jruby?
     defined?(JRUBY_VERSION)
   end
-  
+
   def self.mysql?
-    ::ActiveRecord::Base.connection.class.name.demodulize == "MysqlAdapter" || (
+    ::ActiveRecord::Base.connection.class.name.demodulize == "MysqlAdapter" ||
+    ::ActiveRecord::Base.connection.class.name.demodulize == "MysqlplusAdapter" || (
       jruby? && ::ActiveRecord::Base.connection.config[:adapter] == "jdbcmysql"
     )
   end
+  
+  extend ThinkingSphinx::SearchMethods::ClassMethods
 end

data/rails/init.rb

@@ -0,0 +1,14 @@
+require 'thinking_sphinx'
+require 'action_controller/dispatcher'
+
+ActionController::Dispatcher.to_prepare :thinking_sphinx do
+  # Force internationalisation to be loaded.
+  if Rails::VERSION::STRING.to_f > 2.2
+    I18n.backend.reload!
+    I18n.backend.available_locales
+  elsif Rails::VERSION::STRING.to_f > 2.1
+    I18n.backend.load_translations(*I18n.load_path)
+  end
+  
+  ThinkingSphinx::Configuration.instance.load_models
+end

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

@@ -80,7 +80,8 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
         :sphinx_document_id => 1
       )
       
-      @client = Riddle::Client.stub_instance(:update => true)
+      @client = Riddle::Client.new
+      @client.stub!(:update => true)
       Riddle::Client.stub_method(:new => @client)
     end
     
@@ -120,17 +121,16 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
     end
     
     it "shouldn't update the deleted attribute if not in the index" do
-      @person.send(:index_delta)
+      @client.should_not_receive(:update)
       
-      @client.should_not have_received(:update)
+      @person.send(:index_delta)
     end
     
     it "should update the deleted attribute if in the core index" do
       @person.stub_method(:in_both_indexes? => true)
+      @client.should_receive(:update)
       
       @person.send(:index_delta)
-      
-      @client.should have_received(:update)
     end
   end
 end

data/spec/lib/thinking_sphinx/active_record/scopes_spec.rb

@@ -0,0 +1,96 @@
+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 '.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_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
+end

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

@@ -3,7 +3,7 @@ require 'spec/spec_helper'
 describe "ThinkingSphinx::ActiveRecord" do
   describe "define_index method" do
     before :each do
-      module TestModule
+      module ::TestModule
         class TestModel < ActiveRecord::Base; end
       end
       
@@ -185,7 +185,8 @@ describe "ThinkingSphinx::ActiveRecord" do
         :address  => "an address",
         :port     => 123
       )
-      @client = Riddle::Client.stub_instance(:update => true)
+      @client = Riddle::Client.new
+      @client.stub!(:update => true)
       @person = Person.find(:first)
       
       Riddle::Client.stub_method(:new => @client)
@@ -202,87 +203,82 @@ describe "ThinkingSphinx::ActiveRecord" do
     end
     
     it "should update the core index's deleted flag if in core index" do
-      @person.toggle_deleted
-      
-      @client.should have_received(:update).with(
+      @client.should_receive(:update).with(
         "person_core", ["sphinx_deleted"], {@person.sphinx_document_id => 1}
       )
+      
+      @person.toggle_deleted
     end
     
     it "shouldn't update the core index's deleted flag if the record isn't in it" do
       @person.stub_method(:in_core_index? => false)
-      
-      @person.toggle_deleted
-      
-      @client.should_not have_received(:update).with(
+      @client.should_not_receive(:update).with(
         "person_core", ["sphinx_deleted"], {@person.sphinx_document_id => 1}
       )
+      
+      @person.toggle_deleted
     end
     
     it "shouldn't attempt to update the deleted flag if sphinx isn't running" do
       ThinkingSphinx.stub_method(:sphinx_running? => false)
+      @client.should_not_receive(:update)
       
       @person.toggle_deleted
       
       @person.should_not have_received(:in_core_index?)
-      @client.should_not have_received(:update)
     end
     
     it "should update the delta index's deleted flag if delta indexes are enabled and the instance's delta is true" do
       ThinkingSphinx.stub_method(:deltas_enabled? => true)
       Person.sphinx_indexes.each { |index| index.stub_method(:delta? => true) }
       @person.delta = true
-      
-      @person.toggle_deleted
-      
-      @client.should have_received(:update).with(
+      @client.should_receive(:update).with(
         "person_delta", ["sphinx_deleted"], {@person.sphinx_document_id => 1}
       )
+      
+      @person.toggle_deleted
     end
     
     it "should not update the delta index's deleted flag if delta indexes are enabled and the instance's delta is false" do
       ThinkingSphinx.stub_method(:deltas_enabled? => true)
       Person.sphinx_indexes.each { |index| index.stub_method(:delta? => true) }
       @person.delta = false
-      
-      @person.toggle_deleted
-      
-      @client.should_not have_received(:update).with(
+      @client.should_not_receive(:update).with(
         "person_delta", ["sphinx_deleted"], {@person.sphinx_document_id => 1}
       )
+      
+      @person.toggle_deleted
     end
     
     it "should not update the delta index's deleted flag if delta indexes are enabled and the instance's delta is equivalent to false" do
       ThinkingSphinx.stub_method(:deltas_enabled? => true)
       Person.sphinx_indexes.each { |index| index.stub_method(:delta? => true) }
       @person.delta = 0
-
-      @person.toggle_deleted
-
-      @client.should_not have_received(:update).with(
+      @client.should_not_receive(:update).with(
         "person_delta", ["sphinx_deleted"], {@person.sphinx_document_id => 1}
       )
+
+      @person.toggle_deleted
     end
 
     it "shouldn't update the delta index if delta indexes are disabled" do
       ThinkingSphinx.stub_method(:deltas_enabled? => true)
-      @person.toggle_deleted
-      
-      @client.should_not have_received(:update).with(
+      @client.should_not_receive(:update).with(
         "person_delta", ["sphinx_deleted"], {@person.sphinx_document_id => 1}
       )
+      
+      @person.toggle_deleted
     end
     
     it "should not update the delta index if delta indexing is disabled" do
       ThinkingSphinx.stub_method(:deltas_enabled? => false)
       Person.sphinx_indexes.each { |index| index.stub_method(:delta? => true) }
       @person.delta = true
-      
-      @person.toggle_deleted
-      
-      @client.should_not have_received(:update).with(
+      @client.should_not_receive(:update).with(
         "person_delta", ["sphinx_deleted"], {@person.sphinx_document_id => 1}
       )
+      
+      @person.toggle_deleted
     end
     
     it "should not update either index if updates are disabled" do
@@ -292,10 +288,9 @@ describe "ThinkingSphinx::ActiveRecord" do
       )
       Person.sphinx_indexes.each { |index| index.stub_method(:delta? => true) }
       @person.delta = true
+      @client.should_not_receive(:update)
       
       @person.toggle_deleted
-      
-      @client.should_not have_received(:update)
     end
   end
 
@@ -331,4 +326,29 @@ describe "ThinkingSphinx::ActiveRecord" do
     
     (beta.id * model_count + offset).should == beta.sphinx_document_id
   end
+  
+  describe '#primary_key_for_sphinx' do
+    before :each do
+      @person = Person.find(:first)
+    end
+    
+    after :each do
+      Person.set_sphinx_primary_key nil
+    end
+    
+    it "should return the id by default" do
+      @person.primary_key_for_sphinx.should == @person.id
+    end
+    
+    it "should use the sphinx primary key to determine the value" do
+      Person.set_sphinx_primary_key :first_name
+      @person.primary_key_for_sphinx.should == @person.first_name
+    end
+    
+    it "should not use accessor methods but the attributes hash" do
+      id = @person.id
+      @person.stub!(:id => 'unique_hash')
+      @person.primary_key_for_sphinx.should == id
+    end
+  end
 end

data/spec/{unit → lib}/thinking_sphinx/association_spec.rb

@@ -79,7 +79,8 @@ describe ThinkingSphinx::Association do
     before :each do
       @parent_join = ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.stub_instance
       @join = ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.stub_instance
-      @parent = ThinkingSphinx::Association.stub_instance(:join_to => true, :join => nil)
+      @parent = ThinkingSphinx::Association.new(nil, nil)
+      @parent.stub!(:join_to => true, :join => nil)
       @base_join = Object.stub_instance(:joins => [:a, :b, :c])
       
       ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.stub_method(:new => @join)
@@ -87,19 +88,17 @@ describe ThinkingSphinx::Association do
     
     it "should call the parent's join_to if parent has no join" do
       @assoc = ThinkingSphinx::Association.new(@parent, :ref)
+      @parent.should_receive(:join_to).with(@base_join)
       
       @assoc.join_to(@base_join)
-      
-      @parent.should have_received(:join_to).with(@base_join)
     end
     
     it "should not call the parent's join_to if it already has a join" do
       @assoc = ThinkingSphinx::Association.new(@parent, :ref)
       @parent.stub_method(:join => @parent_join)
+      @parent.should_not_receive(:join_to)
       
       @assoc.join_to(@base_join)
-      
-      @parent.should_not have_received(:join_to)
     end
     
     it "should define the join association with a JoinAssociation instance" do