thinking-sphinx 2.0.0.rc2 → 2.0.0

data/lib/thinking_sphinx/configuration.rb

@@ -53,15 +53,16 @@ module ThinkingSphinx
       mysql_ssl_ca sql_range_step sql_query_pre sql_query_post
       sql_query_killlist sql_ranged_throttle sql_query_post_index unpack_zlib
       unpack_mysqlcompress unpack_mysqlcompress_maxsize )
-
-    IndexOptions  = %w( charset_table charset_type charset_dictpath docinfo
-      enable_star exceptions html_index_attrs html_remove_elements html_strip
-      index_exact_words ignore_chars inplace_docinfo_gap inplace_enable
-      inplace_hit_gap inplace_reloc_factor inplace_write_factor min_infix_len
-      min_prefix_len min_stemming_len min_word_len mlock morphology ngram_chars
-      ngram_len ondisk_dict overshort_step phrase_boundary phrase_boundary_step
-      preopen stopwords stopwords_step wordforms )
-
+    
+    IndexOptions  = %w( blend_chars charset_table charset_type charset_dictpath
+      docinfo enable_star exceptions expand_keywords hitless_words
+      html_index_attrs html_remove_elements html_strip index_exact_words
+      ignore_chars inplace_docinfo_gap inplace_enable inplace_hit_gap
+      inplace_reloc_factor inplace_write_factor min_infix_len min_prefix_len
+      min_stemming_len min_word_len mlock morphology ngram_chars ngram_len
+      ondisk_dict overshort_step phrase_boundary phrase_boundary_step preopen
+      stopwords stopwords_step wordforms )
+    
     CustomOptions = %w( disable_range )
 
     attr_accessor :searchd_file_path, :allow_star, :database_yml_file,
@@ -232,10 +233,13 @@ module ThinkingSphinx
     def indexer_binary_name=(name)
       @controller.indexer_binary_name = name
     end
-
+    
+    attr_accessor :timeout
+    
     def client
       client = Riddle::Client.new address, port
       client.max_matches = configuration.searchd.max_matches || 1000
+      client.timeout = timeout || 0
       client
     end
 

data/lib/thinking_sphinx/context.rb

@@ -65,8 +65,10 @@ class ThinkingSphinx::Context
           model_name.gsub!(/.*[\/\\]/, '').nil? ? next : retry
         rescue NameError
           next
-        rescue StandardError
-          STDERR.puts "Warning: Error loading #{file}"
+        rescue StandardError => err
+          STDERR.puts "Warning: Error loading #{file}:"
+          STDERR.puts err.message
+          STDERR.puts err.backtrace.join("\n"), ''
         end
       end
     end

data/lib/thinking_sphinx/property.rb

@@ -13,6 +13,7 @@ module ThinkingSphinx
       @alias    = options[:as]
       @faceted  = options[:facet]
       @admin    = options[:admin]
+      @sortable = options[:sortable] || false
       
       @alias    = @alias.to_sym unless @alias.blank?
       

data/lib/thinking_sphinx/railtie.rb

@@ -5,8 +5,8 @@ module ThinkingSphinx
   class Railtie < Rails::Railtie
 
     initializer "thinking_sphinx.active_record" do
-      if defined?(ActiveRecord)
-        ::ActiveRecord::Base.send(:include, ThinkingSphinx::ActiveRecord)
+      ActiveSupport.on_load :active_record do
+        include ThinkingSphinx::ActiveRecord
       end
     end
 

data/lib/thinking_sphinx/search.rb

@@ -57,20 +57,16 @@ module ThinkingSphinx
       ThinkingSphinx.facets *args
     end
     
-    def self.bundle_searches(enum)
-      client = ThinkingSphinx::Configuration.instance.client
+    def self.bundle_searches(enum = nil)
+      bundle = ThinkingSphinx::BundledSearch.new
       
-      searches = enum.collect { |item|
-        search = yield ThinkingSphinx, item
-        search.append_to client
-        search
-      }
-      
-      client.run.each_with_index.collect { |results, index|
-        searches[index].populate_from_queue results
-      }
+      if enum.nil?
+        yield bundle
+      else
+        enum.each { |item| yield bundle, item }
+      end
       
-      searches
+      bundle.searches
     end
     
     def self.matching_fields(fields, bitmask)
@@ -90,6 +86,8 @@ module ThinkingSphinx
       @options  = args.extract_options!
       @args     = args
       
+      add_default_scope unless options[:ignore_default]
+      
       populate if @options[:populate]
     end
     
@@ -127,7 +125,7 @@ module ThinkingSphinx
         add_scope(method, *args, &block)
         return self
       elsif method == :search_count
-        merge_search one_class.search(*args)
+        merge_search one_class.search(*args), self.args, options
         return scoped_count
       elsif method.to_s[/^each_with_.*/].nil? && !@array.respond_to?(method)
         super
@@ -274,18 +272,43 @@ module ThinkingSphinx
       
       populate
       client.excerpts(
-        :docs   => [string],
-        :words  => results[:words].keys.join(' '),
-        :index  => options[:index] || "#{model.source_of_sphinx_index.sphinx_name}_core"
+        {
+          :docs   => [string.to_s],
+          :words  => results[:words].keys.join(' '),
+          :index  => options[:index] || "#{model.source_of_sphinx_index.sphinx_name}_core"
+        }.merge(options[:excerpt_options] || {})
       ).first
     end
     
     def search(*args)
-      add_default_scope
-      merge_search ThinkingSphinx::Search.new(*args)
+      args << args.extract_options!.merge(:ignore_default => true)
+      merge_search ThinkingSphinx::Search.new(*args), self.args, options
       self
     end
     
+    def search_for_ids(*args)
+      args << args.extract_options!.merge(
+        :ignore_default => true,
+        :ids_only       => true
+      )
+      merge_search ThinkingSphinx::Search.new(*args), self.args, options
+      self
+    end
+    
+    def facets(*args)
+      options = args.extract_options!
+      merge_search self, args, options
+      args << options
+      
+      ThinkingSphinx::FacetSearch.new *args
+    end
+    
+    def client
+      client = options[:client] || config.client
+      
+      prepare client
+    end
+    
     def append_to(client)
       prepare client
       client.append_query query, indexes, comment
@@ -386,9 +409,16 @@ module ThinkingSphinx
     
     def self.log(message, method = :debug, identifier = 'Sphinx')
       return if ::ActiveRecord::Base.logger.nil?
-      identifier_color, message_color = "4;32;1", "0" # 0;1 = Bold
-      info = "  \e[#{identifier_color}m#{identifier}\e[0m   "
-      info << "\e[#{message_color}m#{message}\e[0m"
+      
+      info = ''
+      if ::ActiveRecord::LogSubscriber.colorize_logging
+        identifier_color, message_color = "4;32;1", "0" # 0;1 = Bold
+        info << "  \e[#{identifier_color}m#{identifier}\e[0m   "
+        info << "\e[#{message_color}m#{message}\e[0m"
+      else
+        info = "#{identifier}   #{message}"
+      end
+      
       ::ActiveRecord::Base.logger.send method, info
     end
     
@@ -396,12 +426,6 @@ module ThinkingSphinx
       self.class.log(*args)
     end
     
-    def client
-      client = config.client
-      
-      prepare client
-    end
-    
     def prepare(client)
       index_options = one_class ?
         one_class.sphinx_indexes.first.local_options : {}
@@ -493,7 +517,8 @@ module ThinkingSphinx
       query.gsub(/("#{token}(.*?#{token})?"|(?![!-])#{token})/u) do
         pre, proper, post = $`, $&, $'
         # E.g. "@foo", "/2", "~3", but not as part of a token
-        is_operator = pre.match(%r{(\W|^)[@~/]\Z})
+        is_operator = pre.match(%r{(\W|^)[@~/]\Z}) ||
+                      pre.match(%r{(\W|^)@\([^\)]*$})
         # E.g. "foo bar", with quotes
         is_quote    = proper.starts_with?('"') && proper.ends_with?('"')
         has_star    = pre.ends_with?("*") || post.starts_with?("*")
@@ -607,24 +632,8 @@ module ThinkingSphinx
       filters
     end
     
-    def condition_filters
-      (options[:conditions] || {}).collect { |attrib, value|
-        if attributes.include?(attrib.to_sym)
-          puts <<-MSG
-Deprecation Warning: filters on attributes should be done using the :with
-option, not :conditions. For example:
-  :with => {:#{attrib} => #{value.inspect}}
-MSG
-          Riddle::Client::Filter.new attrib.to_s, filter_value(value)
-        else
-          nil
-        end
-      }.compact
-    end
-    
     def filters
       internal_filters +
-      condition_filters +
       (options[:with] || {}).collect { |attrib, value|
         Riddle::Client::Filter.new attrib.to_s, filter_value(value)
       } +
@@ -712,6 +721,21 @@ MSG
       end
     end
     
+    def include_for_class(klass)
+      includes = options[:include] || klass.sphinx_index_options[:include]
+      
+      case includes
+      when NilClass
+        nil
+      when Array
+        includes.select { |inc| klass.reflections[inc] }
+      when Symbol
+        klass.reflections[includes].nil? ? nil : includes
+      else
+        includes
+      end
+    end
+    
     def instances_from_class(klass, matches)
       index_options = klass.sphinx_index_options
 
@@ -720,7 +744,7 @@ MSG
         :all,
         :joins      => options[:joins],
         :conditions => {klass.primary_key_for_sphinx.to_sym => ids},
-        :include    => (options[:include] || index_options[:include]),
+        :include    => include_for_class(klass),
         :select     => (options[:select]  || index_options[:select]),
         :order      => (options[:sql_order] || index_options[:sql_order])
       ) : []
@@ -790,14 +814,16 @@ MSG
     
     # Adds the default_sphinx_scope if set.
     def add_default_scope
-      add_scope(one_class.get_default_sphinx_scope) if one_class && one_class.has_default_sphinx_scope?
+      return unless one_class && one_class.has_default_sphinx_scope?
+      add_scope(one_class.get_default_sphinx_scope.to_sym)
     end
     
     def add_scope(method, *args, &block)
-      merge_search one_class.send(method, *args, &block)
+      method = "#{method}_without_default".to_sym
+      merge_search one_class.send(method, *args, &block), self.args, options
     end
     
-    def merge_search(search)
+    def merge_search(search, args, options)
       search.args.each { |arg| args << arg }
       
       search.options.keys.each do |key|

data/lib/thinking_sphinx/source/sql.rb

@@ -20,7 +20,7 @@ module ThinkingSphinx
         )
 
         all_associations.each do |assoc|
-          relation = relation.joins(assoc.join.with_join_class(Arel::OuterJoin))
+          relation = relation.joins(assoc.arel_join)
         end
 
         relation = relation.where(sql_where_clause(options))

data/lib/thinking_sphinx/tasks.rb

@@ -1,4 +1,5 @@
 require 'fileutils'
+require 'timeout'
 
 namespace :thinking_sphinx do
   task :app_env do
@@ -47,6 +48,12 @@ namespace :thinking_sphinx do
       config = ThinkingSphinx::Configuration.instance
       pid    = sphinx_pid
       config.controller.stop
+      
+      # Ensure searchd is stopped, but don't try too hard
+      Timeout.timeout(5) do
+        sleep(1) until config.controller.stop
+      end
+      
       puts "Stopped search daemon (pid #{pid})."
     end
   end

data/spec/thinking_sphinx/active_record/scopes_spec.rb

@@ -87,10 +87,9 @@ describe ThinkingSphinx::ActiveRecord::Scopes do
       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
+    it "should apply the default scope options before 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'}
+      search.by_name('bar').search.options[:conditions].should == {:name => 'bar'}
     end
   end
 

data/spec/thinking_sphinx/adapters/abstract_adapter_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::AbstractAdapter do
+  describe '.detect' do
+    let(:model) { stub('model') }
+    
+    it "returns a MysqlAdapter object for :mysql" do
+      ThinkingSphinx::AbstractAdapter.stub(:adapter_for_model => :mysql)
+      
+      adapter = ThinkingSphinx::AbstractAdapter.detect(model)
+      adapter.should be_a(ThinkingSphinx::MysqlAdapter)
+    end
+    
+    it "returns a PostgreSQLAdapter object for :postgresql" do
+      ThinkingSphinx::AbstractAdapter.stub(:adapter_for_model => :postgresql)
+      
+      adapter = ThinkingSphinx::AbstractAdapter.detect(model)
+      adapter.should be_a(ThinkingSphinx::PostgreSQLAdapter)
+    end
+    
+    it "raises an exception for other responses" do
+      ThinkingSphinx::AbstractAdapter.stub(:adapter_for_model => :sqlite)
+      
+      lambda {
+        ThinkingSphinx::AbstractAdapter.detect(model)
+      }.should raise_error
+    end
+  end
+  
+  describe '.adapter_for_model' do
+    let(:model) { stub('model') }
+    
+    after :each do
+      ThinkingSphinx.database_adapter = nil
+    end
+    
+    it "translates strings to symbols" do
+      ThinkingSphinx.database_adapter = 'foo'
+      
+      ThinkingSphinx::AbstractAdapter.adapter_for_model(model).should == :foo
+    end
+    
+    it "passes through symbols unchanged" do
+      ThinkingSphinx.database_adapter = :bar
+      
+      ThinkingSphinx::AbstractAdapter.adapter_for_model(model).should == :bar
+    end
+    
+    it "returns standard_adapter_for_model if database_adapter is not set" do
+      ThinkingSphinx.database_adapter = nil
+      ThinkingSphinx::AbstractAdapter.stub!(:standard_adapter_for_model => :baz)
+      
+      ThinkingSphinx::AbstractAdapter.adapter_for_model(model).should == :baz
+    end
+    
+    it "calls the lambda and returns it if one is provided" do
+      ThinkingSphinx.database_adapter = lambda { |model| :foo }
+      
+      ThinkingSphinx::AbstractAdapter.adapter_for_model(model).should == :foo
+    end
+  end
+  
+  describe '.standard_adapter_for_model' do
+    let(:klass)      { stub('connection class') }
+    let(:connection) { stub('connection', :class => klass) }
+    let(:model)      { stub('model', :connection => connection) }
+    
+    it "translates a normal MySQL adapter" do
+      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::MysqlAdapter')
+      
+      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
+        should == :mysql
+    end
+    
+    it "translates a MySQL plus adapter" do
+      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::MysqlplusAdapter')
+      
+      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
+        should == :mysql
+    end
+    
+    it "translates a MySQL2 adapter" do
+      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::Mysql2Adapter')
+      
+      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
+        should == :mysql
+    end
+    
+    it "translates a NullDB adapter to MySQL" do
+      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::NullDBAdapter')
+      
+      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
+        should == :mysql
+    end
+    
+    it "translates a normal PostgreSQL adapter" do
+      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter')
+      
+      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
+        should == :postgresql
+    end
+    
+    it "translates a JDBC MySQL adapter to MySQL" do
+      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      connection.stub(:config => {:adapter => 'jdbcmysql'})
+      
+      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
+        should == :mysql
+    end
+    
+    it "translates a JDBC PostgreSQL adapter to PostgreSQL" do
+      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      connection.stub(:config => {:adapter => 'jdbcpostgresql'})
+      
+      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
+        should == :postgresql
+    end
+    
+    it "returns other JDBC adapters without translation" do
+      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      connection.stub(:config => {:adapter => 'jdbcmssql'})
+      
+      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
+        should == 'jdbcmssql'
+    end
+    
+    it "returns other unknown adapters without translation" do
+      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::FooAdapter')
+      
+      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
+        should == 'ActiveRecord::ConnectionAdapters::FooAdapter'
+    end
+  end
+end