thinking-sphinx 1.2.13 → 1.4.0

data/lib/thinking_sphinx/attribute.rb

@@ -93,25 +93,25 @@ module ThinkingSphinx
       
       separator = all_ints? || all_datetimes? || @crc ? ',' : ' '
       
-      clause = @columns.collect { |column|
-        part = column_with_prefix(column)
+      clause = columns_with_prefixes.collect { |column|
         case type
         when :string
-          adapter.convert_nulls(part)
+          adapter.convert_nulls(column)
         when :datetime
-          adapter.cast_to_datetime(part)
+          adapter.cast_to_datetime(column)
         when :multi
-          part = adapter.cast_to_datetime(part)   if is_many_datetimes?
-          part = adapter.convert_nulls(part, '0') if is_many_ints?
-          part
+          column = adapter.cast_to_datetime(column)   if is_many_datetimes?
+          column = adapter.convert_nulls(column, '0') if is_many_ints?
+          column
         else
-          part
+          column
         end
       }.join(', ')
       
       clause = adapter.crc(clause)                          if @crc
       clause = adapter.concatenate(clause, separator)       if concat_ws?
       clause = adapter.group_concatenate(clause, separator) if is_many?
+      clause = adapter.downcase(clause)                     if insensitive?
       
       "#{clause} AS #{quote_column(unique_name)}"
     end
@@ -123,7 +123,8 @@ module ThinkingSphinx
         :string   => :sql_attr_str2ordinal,
         :float    => :sql_attr_float,
         :boolean  => :sql_attr_bool,
-        :integer  => :sql_attr_uint
+        :integer  => :sql_attr_uint,
+        :bigint   => :sql_attr_bigint
       }[type]
     end
     
@@ -179,8 +180,12 @@ module ThinkingSphinx
     def live_value(instance)
       object = instance
       column = @columns.first
-      column.__stack.each { |method| object = object.send(method) }
-      object.send(column.__name)
+      column.__stack.each { |method|
+        object = object.send(method)
+        return sphinx_value(nil) if object.nil?
+      }
+      
+      sphinx_value object.send(column.__name)
     end
     
     def all_ints?
@@ -297,19 +302,11 @@ WHERE #{@source.index.delta_object.clause(model, true)})
       is_many? && all_strings?
     end
        
-    def type_from_database
-      klass = @associations.values.flatten.first ? 
-        @associations.values.flatten.first.reflection.klass : @model
-      
-      column = klass.columns.detect { |col|
-        @columns.collect { |c| c.__name.to_s }.include? col.name
-      }
-      column.nil? ? nil : column.type
-    end
-    
     def translated_type_from_database
       case type_from_db = type_from_database
-      when :datetime, :string, :float, :boolean, :integer
+      when :integer
+        integer_type_from_db
+      when :datetime, :string, :float, :boolean
         type_from_db
       when :decimal
         :float
@@ -327,6 +324,32 @@ block:
       end
     end
     
+    def type_from_database
+      column = column_from_db
+      column.nil? ? nil : column.type
+    end
+    
+    def integer_type_from_db
+      column = column_from_db
+      return nil if column.nil?
+      
+      case column.sql_type
+      when adapter.bigint_pattern
+        :bigint
+      else
+        :integer
+      end
+    end
+    
+    def column_from_db
+      klass = @associations.values.flatten.first ? 
+        @associations.values.flatten.first.reflection.klass : @model
+      
+      klass.columns.detect { |col|
+        @columns.collect { |c| c.__name.to_s }.include? col.name
+      }
+    end
+    
     def all_of_type?(*column_types)
       @columns.all? { |col|
         klasses = @associations[col].empty? ? [@model] :
@@ -337,5 +360,26 @@ block:
         }
       }
     end
+    
+    def sphinx_value(value)
+      case value
+      when TrueClass
+        1
+      when FalseClass, NilClass
+        0
+      when Time
+        value.to_i
+      when Date
+        value.to_time.to_i
+      when String
+        value.to_crc32
+      else
+        value
+      end
+    end
+    
+    def insensitive?
+      @sortable == :insensitive
+    end
   end
-end
+end

data/lib/thinking_sphinx/auto_version.rb

@@ -0,0 +1,24 @@
+module ThinkingSphinx
+  class AutoVersion
+    def self.detect
+      version = ThinkingSphinx::Configuration.instance.version
+      case version
+      when '0.9.8', '0.9.9'
+        require "riddle/#{version}"
+      when '1.10-beta'
+        require 'riddle/1.10'
+      else
+        STDERR.puts %Q{
+Sphinx cannot be found on your system. You may need to configure the following
+settings in your config/sphinx.yml file:
+  * bin_path
+  * searchd_binary_name
+  * indexer_binary_name
+
+For more information, read the documentation:
+http://freelancing-god.github.com/ts/en/advanced_config.html
+}
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/bundled_search.rb

@@ -0,0 +1,44 @@
+module ThinkingSphinx
+  class BundledSearch
+    attr_reader :client
+    
+    def initialize
+      @searches = []
+    end
+    
+    def search(*args)
+      @searches << ThinkingSphinx.search(*args)
+      @searches.last.append_to client
+    end
+    
+    def search_for_ids(*args)
+      @searches << ThinkingSphinx.search_for_ids(*args)
+      @searches.last.append_to client
+    end
+    
+    def searches
+      populate
+      @searches
+    end
+    
+    private
+    
+    def client
+      @client ||= ThinkingSphinx::Configuration.instance.client
+    end
+    
+    def populated?
+      @populated
+    end
+    
+    def populate
+      return if populated?
+      
+      @populated = true
+      
+      client.run.each_with_index do |results, index|
+        searches[index].populate_from_queue results
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/class_facet.rb

@@ -8,8 +8,9 @@ module ThinkingSphinx
       "class_crc"
     end
     
-    def value(object, attribute_value)
-      object.class.name
+    def value(object, attribute_hash)
+      crc = attribute_hash['class_crc']
+      ThinkingSphinx::Configuration.instance.models_by_crc[crc]
     end
   end
 end

data/lib/thinking_sphinx/configuration.rb

@@ -13,7 +13,7 @@ module ThinkingSphinx
   # pid file::              log/searchd.#{environment}.pid
   # searchd files::         db/sphinx/#{environment}/
   # address::               127.0.0.1
-  # port::                  3312
+  # port::                  9312
   # allow star::            false
   # min prefix length::     1
   # min infix length::      1
@@ -49,25 +49,29 @@ module ThinkingSphinx
   class Configuration
     include Singleton
     
-    SourceOptions = %w( mysql_connect_flags sql_range_step sql_query_pre
-      sql_query_post sql_ranged_throttle sql_query_post_index )
+    SourceOptions = %w( mysql_connect_flags mysql_ssl_cert mysql_ssl_key
+      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 docinfo enable_star
-      exceptions html_index_attrs html_remove_elements html_strip ignore_chars
-      min_infix_len min_prefix_len min_word_len mlock morphology ngram_chars
-      ngram_len phrase_boundary phrase_boundary_step preopen stopwords
-      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 :config_file, :searchd_log_file, :query_log_file,
-      :pid_file, :searchd_file_path, :address, :port, :allow_star,
-      :database_yml_file, :app_root, :bin_path, :model_directories,
-      :delayed_job_priority, :searchd_binary_name, :indexer_binary_name
+    attr_accessor :searchd_file_path, :allow_star, :database_yml_file,
+      :app_root, :model_directories, :delayed_job_priority, :indexed_models
     
     attr_accessor :source_options, :index_options
+    attr_accessor :version
     
-    attr_reader :environment, :configuration
+    attr_reader :environment, :configuration, :controller
     
     # Load in the configuration settings - this will look for config/sphinx.yml
     # and parse it according to the current environment.
@@ -91,60 +95,64 @@ module ThinkingSphinx
       end
       
       @configuration = Riddle::Configuration.new
-      @configuration.searchd.address    = "127.0.0.1"
-      @configuration.searchd.port       = 3312
       @configuration.searchd.pid_file   = "#{self.app_root}/log/searchd.#{environment}.pid"
       @configuration.searchd.log        = "#{self.app_root}/log/searchd.log"
       @configuration.searchd.query_log  = "#{self.app_root}/log/searchd.query.log"
       
+      @controller = Riddle::Controller.new @configuration,
+        "#{self.app_root}/config/#{environment}.sphinx.conf"
+      
+      self.address              = "127.0.0.1"
+      self.port                 = 9312
       self.database_yml_file    = "#{self.app_root}/config/database.yml"
-      self.config_file          = "#{self.app_root}/config/#{environment}.sphinx.conf"
       self.searchd_file_path    = "#{self.app_root}/db/sphinx/#{environment}"
       self.allow_star           = false
-      self.bin_path             = ""
       self.model_directories    = ["#{app_root}/app/models/"] +
         Dir.glob("#{app_root}/vendor/plugins/*/app/models/")
       self.delayed_job_priority = 0
+      self.indexed_models       = []
       
       self.source_options  = {}
       self.index_options   = {
         :charset_type => "utf-8"
       }
       
-      self.searchd_binary_name = "searchd"
-      self.indexer_binary_name = "indexer"
-            
+      self.version = nil
       parse_config
+      self.version ||= @controller.sphinx_version
       
       self
     end
     
     def self.environment
-      @@environment ||= (
-        defined?(Merb) ? Merb.environment : ENV['RAILS_ENV']
-      ) || "development"
+      Thread.current[:thinking_sphinx_environment] ||= begin
+        if defined?(Merb)
+          Merb.environment
+        elsif defined?(RAILS_ENV)
+          RAILS_ENV
+        else
+          ENV['RAILS_ENV'] || 'development'
+        end
+      end
     end
     
     def environment
       self.class.environment
     end
     
-    def controller
-      @controller ||= Riddle::Controller.new(@configuration, self.config_file)
-    end
-    
     # Generate the config file for Sphinx by using all the settings defined and
     # looping through all the models with indexes to build the relevant
     # indexer and searchd configuration, and sources and indexes details.
     #
     def build(file_path=nil)
-      load_models
       file_path ||= "#{self.config_file}"
       
       @configuration.indexes.clear
       
-      ThinkingSphinx.indexed_models.each_with_index do |model, model_index|
-        @configuration.indexes.concat model.constantize.to_riddle(model_index)
+      ThinkingSphinx.context.indexed_models.each do |model|
+        model = model.constantize
+        model.define_indexes
+        @configuration.indexes.concat model.to_riddle
       end
       
       open(file_path, "w") do |file|
@@ -152,50 +160,21 @@ module ThinkingSphinx
       end
     end
     
-    # Make sure all models are loaded - without reloading any that
-    # ActiveRecord::Base is already aware of (otherwise we start to hit some
-    # messy dependencies issues).
-    # 
-    def load_models
-      return if defined?(Rails) &&
-        Rails::VERSION::STRING.to_f > 2.1 &&
-        Rails.configuration.cache_classes
-      
-      self.model_directories.each do |base|
-        Dir["#{base}**/*.rb"].each do |file|
-          model_name = file.gsub(/^#{base}([\w_\/\\]+)\.rb/, '\1')
-        
-          next if model_name.nil?
-          next if ::ActiveRecord::Base.send(:subclasses).detect { |model|
-            model.name == model_name
-          }
-        
-          begin
-            model_name.camelize.constantize
-          rescue LoadError
-            model_name.gsub!(/.*[\/\\]/, '').nil? ? next : retry
-          rescue NameError
-            next
-          rescue StandardError
-            puts "Warning: Error loading #{file}"
-          end
-        end
-      end
-    end
-    
     def address
-      @configuration.searchd.address
+      @address
     end
     
     def address=(address)
+      @address = address
       @configuration.searchd.address = address
     end
     
     def port
-      @configuration.searchd.port
+      @port
     end
     
     def port=(port)
+      @port = port
       @configuration.searchd.port = port
     end
     
@@ -223,15 +202,50 @@ module ThinkingSphinx
       @configuration.searchd.query_log = file
     end
     
+    def config_file
+      @controller.path
+    end
+    
+    def config_file=(file)
+      @controller.path = file
+    end
+    
+    def bin_path
+      @controller.bin_path
+    end
+    
+    def bin_path=(path)
+      @controller.bin_path = path
+    end
+    
+    def searchd_binary_name
+      @controller.searchd_binary_name
+    end
+    
+    def searchd_binary_name=(name)
+      @controller.searchd_binary_name = name
+    end
+    
+    def indexer_binary_name
+      @controller.indexer_binary_name
+    end
+    
+    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
     
     def models_by_crc
       @models_by_crc ||= begin
-        ThinkingSphinx.indexed_models.inject({}) do |hash, model|
+        ThinkingSphinx.context.indexed_models.inject({}) do |hash, model|
           hash[model.constantize.to_crc32] = model
           Object.subclasses_of(model.constantize).each { |subclass|
             hash[subclass.to_crc32] = subclass.name

data/lib/thinking_sphinx/context.rb

@@ -0,0 +1,76 @@
+class ThinkingSphinx::Context
+  attr_reader :indexed_models
+  
+  def initialize(*models)
+    @indexed_models = []
+  end
+  
+  def prepare
+    ThinkingSphinx::Configuration.instance.indexed_models.each do |model|
+      add_indexed_model model
+    end
+    
+    return unless indexed_models.empty?
+    
+    load_models
+    add_indexed_models
+  end
+  
+  def define_indexes
+    indexed_models.each { |model|
+      model.constantize.define_indexes
+    }
+  end
+  
+  def add_indexed_model(model)
+    model = model.name if model.is_a?(Class)
+    
+    indexed_models << model
+    indexed_models.uniq!
+    indexed_models.sort!
+  end
+  
+  def superclass_indexed_models
+    klasses = indexed_models.collect { |name| name.constantize }
+    klasses.reject { |klass|
+      klass.superclass.ancestors.any? { |ancestor| klasses.include?(ancestor) }
+    }.collect { |klass| klass.name }
+  end
+  
+  private
+  
+  def add_indexed_models
+    Object.subclasses_of(ActiveRecord::Base).each do |klass|
+      add_indexed_model klass if klass.has_sphinx_indexes?
+    end
+  end
+  
+  # Make sure all models are loaded - without reloading any that
+  # ActiveRecord::Base is already aware of (otherwise we start to hit some
+  # messy dependencies issues).
+  #
+  def load_models
+    ThinkingSphinx::Configuration.instance.model_directories.each do |base|
+      Dir["#{base}**/*.rb"].each do |file|
+        model_name = file.gsub(/^#{base}([\w_\/\\]+)\.rb/, '\1')
+        
+        next if model_name.nil?
+        next if ::ActiveRecord::Base.send(:subclasses).detect { |model|
+          model.name == model_name.camelize
+        }
+        
+        begin
+          model_name.camelize.constantize
+        rescue LoadError
+          model_name.gsub!(/.*[\/\\]/, '').nil? ? next : retry
+        rescue NameError
+          next
+        rescue StandardError => err
+          STDERR.puts "Warning: Error loading #{file}:"
+          STDERR.puts err.message
+          STDERR.puts err.backtrace.join("\n"), ''
+        end
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/deltas/default_delta.rb

@@ -13,18 +13,8 @@ module ThinkingSphinx
           ThinkingSphinx.deltas_enabled?
         return true if instance && !toggled(instance)
         
-        config = ThinkingSphinx::Configuration.instance
-        client = Riddle::Client.new config.address, config.port
-        rotate = ThinkingSphinx.sphinx_running? ? "--rotate" : ""
-        
-        output = `#{config.bin_path}#{config.indexer_binary_name} --config #{config.config_file} #{rotate} #{delta_index_name model}`
-        puts(output) unless ThinkingSphinx.suppress_delta_output?
-        
-        client.update(
-          core_index_name(model),
-          ['sphinx_deleted'],
-          {instance.sphinx_document_id => [1]}
-        ) if instance && ThinkingSphinx.sphinx_running? && instance.in_both_indexes?
+        update_delta_indexes model
+        delete_from_core     model, instance if instance
         
         true
       end
@@ -48,17 +38,21 @@ module ThinkingSphinx
         " = #{adapter.boolean(toggled)}"
       end
       
-      protected
+      private
       
-      def core_index_name(model)
-        "#{model.source_of_sphinx_index.name.underscore.tr(':/\\', '_')}_core"
+      def update_delta_indexes(model)
+        config = ThinkingSphinx::Configuration.instance
+        rotate = ThinkingSphinx.sphinx_running? ? "--rotate" : ""
+        
+        output = `#{config.bin_path}#{config.indexer_binary_name} --config "#{config.config_file}" #{rotate} #{model.delta_index_names.join(' ')}`
+        puts(output) unless ThinkingSphinx.suppress_delta_output?
       end
       
-      def delta_index_name(model)
-        "#{model.source_of_sphinx_index.name.underscore.tr(':/\\', '_')}_delta"
-      end  
-      
-      private
+      def delete_from_core(model, instance)
+        model.core_index_names.each do |index_name|
+          model.delete_in_index index_name, instance.sphinx_document_id
+        end
+      end
       
       def adapter
         @adapter = @index.model.sphinx_database_adapter

data/lib/thinking_sphinx/deltas.rb

@@ -1,6 +1,4 @@
 require 'thinking_sphinx/deltas/default_delta'
-require 'thinking_sphinx/deltas/delayed_delta'
-require 'thinking_sphinx/deltas/datetime_delta'
 
 module ThinkingSphinx
   module Deltas

data/lib/thinking_sphinx/deploy/capistrano.rb

@@ -93,7 +93,7 @@ DESC
       rails_env = fetch(:rails_env, "production")
       rake = fetch(:rake, "rake")
       tasks.each do |t|
-        run "cd #{current_path}; #{rake} RAILS_ENV=#{rails_env} #{t}"
+        run "if [ -d #{release_path} ]; then cd #{release_path}; else cd #{current_path}; fi; #{rake} RAILS_ENV=#{rails_env} #{t}"
       end
     end
   end

data/lib/thinking_sphinx/excerpter.rb

@@ -14,7 +14,7 @@ module ThinkingSphinx
     end
     
     def method_missing(method, *args, &block)
-      string = CGI::escapeHTML @instance.send(method, *args, &block).to_s
+      string = @instance.send(method, *args, &block).to_s
       
       @search.excerpt_for(string, @instance.class)
     end

data/lib/thinking_sphinx/facet.rb

@@ -71,7 +71,12 @@ module ThinkingSphinx
       @property.is_a?(Field) ? :string : @property.type
     end
     
-    def value(object, attribute_value)
+    def float?
+      @property.type == :float
+    end
+    
+    def value(object, attribute_hash)
+      attribute_value = attribute_hash['@groupby']
       return translate(object, attribute_value) if translate? || float?
       
       case @property.type
@@ -117,9 +122,5 @@ module ThinkingSphinx
     def column
       @property.columns.first
     end
-    
-    def float?
-      @property.type == :float
-    end
   end
 end