pixeltrix-thinking-sphinx 1.1.5 → 1.2.1

data/lib/thinking_sphinx/source.rb

@@ -0,0 +1,150 @@
+require 'thinking_sphinx/source/internal_properties'
+require 'thinking_sphinx/source/sql'
+
+module ThinkingSphinx
+  class Source
+    include ThinkingSphinx::Source::InternalProperties
+    include ThinkingSphinx::Source::SQL
+    
+    attr_accessor :model, :fields, :attributes, :conditions, :groupings,
+      :options
+    attr_reader :base, :index
+    
+    def initialize(index, options = {})
+      @index        = index
+      @model        = index.model
+      @fields       = []
+      @attributes   = []
+      @conditions   = []
+      @groupings    = []
+      @options      = options
+      @associations = {}
+      
+      @base = ::ActiveRecord::Associations::ClassMethods::JoinDependency.new(
+        @model, [], nil
+      )
+      
+      unless @model.descends_from_active_record?
+        stored_class = @model.store_full_sti_class ? @model.name : @model.name.demodulize
+        @conditions << "#{@model.quoted_table_name}.#{quote_column(@model.inheritance_column)} = '#{stored_class}'"
+      end
+      
+      add_internal_attributes_and_facets
+    end
+    
+    def name
+      @model.name.underscore.tr(':/\\', '_')
+    end
+    
+    def to_riddle_for_core(offset, index)
+      source = Riddle::Configuration::SQLSource.new(
+        "#{name}_core_#{index}", adapter.sphinx_identifier
+      )
+      
+      set_source_database_settings  source
+      set_source_attributes         source, offset
+      set_source_sql                source, offset
+      set_source_settings           source
+      
+      source
+    end
+    
+    def to_riddle_for_delta(offset, index)
+      source = Riddle::Configuration::SQLSource.new(
+        "#{name}_delta_#{index}", adapter.sphinx_identifier
+      )
+      source.parent = "#{name}_core_#{index}"
+      
+      set_source_database_settings  source
+      set_source_attributes         source, offset, true
+      set_source_sql                source, offset, true
+      
+      source
+    end
+    
+    def delta?
+      !@index.delta_object.nil?
+    end
+    
+    # Gets the association stack for a specific key.
+    # 
+    def association(key)
+      @associations[key] ||= Association.children(@model, key)
+    end
+    
+    private
+    
+    def adapter
+      @adapter ||= @model.sphinx_database_adapter
+    end
+    
+    def set_source_database_settings(source)
+      config = @model.connection.instance_variable_get(:@config)
+      
+      source.sql_host = config[:host]           || "localhost"
+      source.sql_user = config[:username]       || config[:user] || ""
+      source.sql_pass = (config[:password].to_s || "").gsub('#', '\#')
+      source.sql_db   = config[:database]
+      source.sql_port = config[:port]
+      source.sql_sock = config[:socket]
+    end
+    
+    def set_source_attributes(source, offset, delta = false)
+      attributes.each do |attrib|
+        source.send(attrib.type_to_config) << attrib.config_value(offset, delta)
+      end
+    end
+    
+    def set_source_sql(source, offset, delta = false)
+      source.sql_query        = to_sql(:offset => offset, :delta => delta).gsub(/\n/, ' ')
+      source.sql_query_range  = to_sql_query_range(:delta => delta)
+      source.sql_query_info   = to_sql_query_info(offset)
+      
+      source.sql_query_pre += send(!delta ? :sql_query_pre_for_core : :sql_query_pre_for_delta)
+      
+      if @index.local_options[:group_concat_max_len]
+        source.sql_query_pre << "SET SESSION group_concat_max_len = #{@index.local_options[:group_concat_max_len]}"
+      end
+      
+      source.sql_query_pre += [adapter.utf8_query_pre].compact if utf8?
+    end
+    
+    def set_source_settings(source)
+      config = ThinkingSphinx::Configuration.instance
+      config.source_options.each do |key, value|
+        source.send("#{key}=".to_sym, value)
+      end
+      
+      source_options = ThinkingSphinx::Configuration::SourceOptions
+      @options.each do |key, value|
+        if source_options.include?(key.to_s) && !value.nil?
+          source.send("#{key}=".to_sym, value)
+        end
+      end
+    end
+    
+    # Returns all associations used amongst all the fields and attributes.
+    # This includes all associations between the model and what the actual
+    # columns are from.
+    # 
+    def all_associations
+      @all_associations ||= (
+        # field associations
+        @fields.collect { |field|
+          field.associations.values
+        }.flatten +
+        # attribute associations
+        @attributes.collect { |attrib|
+          attrib.associations.values if attrib.include_as_association?
+        }.compact.flatten
+      ).uniq.collect { |assoc|
+        # get ancestors as well as column-level associations
+        assoc.ancestors
+      }.flatten.uniq
+    end
+    
+    def utf8?
+      @index.options[:charset_type] == "utf-8"
+    end
+  end
+end

data/lib/thinking_sphinx/tasks.rb

@@ -2,14 +2,23 @@ require 'fileutils'
 
 namespace :thinking_sphinx do
   task :app_env do
-    Rake::Task[:environment].invoke if defined?(RAILS_ROOT)
+    if defined?(RAILS_ROOT)
+      Rake::Task[:environment].invoke
+      Rails.configuration.cache_classes = false
+    end
+    
     Rake::Task[:merb_env].invoke    if defined?(Merb)
   end
   
+  desc "Output the current Thinking Sphinx version"
+  task :version => :app_env do
+    puts "Thinking Sphinx v" + ThinkingSphinx::Version::String
+  end
+  
   desc "Stop if running, then start a Sphinx searchd daemon using Thinking Sphinx's settings"
   task :running_start => :app_env do
-   Rake::Task["thinking_sphinx:stop"].invoke if sphinx_running?
-   Rake::Task["thinking_sphinx:start"].invoke
+    Rake::Task["thinking_sphinx:stop"].invoke if sphinx_running?
+    Rake::Task["thinking_sphinx:start"].invoke
   end
   
   desc "Start a Sphinx searchd daemon using Thinking Sphinx's settings"
@@ -21,16 +30,14 @@ namespace :thinking_sphinx do
     
     Dir["#{config.searchd_file_path}/*.spl"].each { |file| File.delete(file) }
 
-    cmd = "#{config.bin_path}searchd --pidfile --config #{config.config_file}"
-    puts cmd
-    system cmd
+    system! "#{config.bin_path}#{config.searchd_binary_name} --pidfile --config \"#{config.config_file}\""
     
     sleep(2)
     
     if sphinx_running?
       puts "Started successfully (pid #{sphinx_pid})."
     else
-      puts "Failed to start searchd daemon. Check #{config.searchd_log_file}."
+      puts "Failed to start searchd daemon. Check #{config.searchd_log_file}"
     end
   end
   
@@ -39,7 +46,7 @@ namespace :thinking_sphinx do
     raise RuntimeError, "searchd is not running." unless sphinx_running?
     config = ThinkingSphinx::Configuration.instance
     pid    = sphinx_pid
-    system "searchd --stop --config #{config.config_file}"
+    system! "#{config.bin_path}#{config.searchd_binary_name} --stop --config \"#{config.config_file}\""
     puts "Stopped search daemon (pid #{pid})."
   end
   
@@ -64,10 +71,17 @@ namespace :thinking_sphinx do
     end
         
     FileUtils.mkdir_p config.searchd_file_path
-    cmd = "#{config.bin_path}indexer --config #{config.config_file} --all"
+    cmd = "#{config.bin_path}#{config.indexer_binary_name} --config \"#{config.config_file}\" --all"
     cmd << " --rotate" if sphinx_running?
-    puts cmd
-    system cmd
+    
+    system! cmd
+  end
+  
+  desc "Stop Sphinx (if it's running), rebuild the indexes, and start Sphinx"
+  task :rebuild => :app_env do
+    Rake::Task["thinking_sphinx:stop"].invoke if sphinx_running?
+    Rake::Task["thinking_sphinx:index"].invoke
+    Rake::Task["thinking_sphinx:start"].invoke
   end
   
   namespace :index do
@@ -96,6 +110,8 @@ namespace :thinking_sphinx do
 end
 
 namespace :ts do
+  desc "Output the current Thinking Sphinx version"
+  task :version => "thinking_sphinx:version"
   desc "Stop if running, then start a Sphinx searchd daemon using Thinking Sphinx's settings"
   task :run     => "thinking_sphinx:running_start"
   desc "Start a Sphinx searchd daemon using Thinking Sphinx's settings"
@@ -115,6 +131,8 @@ namespace :ts do
   task :conf    => "thinking_sphinx:configure"
   desc "Generate the Sphinx configuration file using Thinking Sphinx's settings"
   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
@@ -126,3 +144,19 @@ 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.rb

@@ -7,17 +7,21 @@ require 'riddle'
 require 'after_commit'
 
 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/facet_collection'
+require 'thinking_sphinx/class_facet'
+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'
@@ -33,8 +37,8 @@ Merb::Plugins.add_rakefiles(
 module ThinkingSphinx
   module Version #:nodoc:
     Major = 1
-    Minor = 1
-    Tiny  = 3
+    Minor = 2
+    Tiny  = 1
     
     String = [Major, Minor, Tiny].join('.')
   end
@@ -60,6 +64,10 @@ module ThinkingSphinx
     @@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?
@@ -124,21 +132,87 @@ module ThinkingSphinx
   # or if not using MySQL, this will return false.
   # 
   def self.use_group_by_shortcut?
-    ::ActiveRecord::ConnectionAdapters.constants.include?("MysqlAdapter") &&
-    ::ActiveRecord::Base.connection.is_a?(
-      ::ActiveRecord::ConnectionAdapters::MysqlAdapter
-    ) &&
-    ::ActiveRecord::Base.connection.select_all(
-      "SELECT @@global.sql_mode, @@session.sql_mode;"
-    ).all? { |key,value| value.nil? || value[/ONLY_FULL_GROUP_BY/].nil? }
+    !!(
+      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
+  
+  @@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?
-    !!sphinx_pid
+    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 #{pid_file}`[/\d+/] if File.exists?(pid_file)
+    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'
+    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
   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 == "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

@@ -76,11 +76,12 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
       
       @person = Person.new
       @person.stub_method(
-        :in_core_index?     => false,
+        :in_both_indexes?     => false,
         :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_core_index? => true)
+      @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,92 @@
+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 object" do
+      Alpha.by_name('foo').should be_a(ThinkingSphinx::Search)
+    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