warp-thinking-sphinx 1.2.12 → 1.3.10

data/lib/thinking_sphinx/active_record/attribute_updates.rb

@@ -10,22 +10,25 @@ module ThinkingSphinx
       private
             
       def update_attribute_values
-        return unless ThinkingSphinx.updates_enabled? && ThinkingSphinx.sphinx_running?
+        return true unless ThinkingSphinx.updates_enabled? &&
+          ThinkingSphinx.sphinx_running?
         
         config = ThinkingSphinx::Configuration.instance
-        client = Riddle::Client.new config.address, config.port
+        client = config.client
         
-        self.sphinx_indexes.each do |index|
+        self.class.sphinx_indexes.each do |index|
           attribute_pairs  = attribute_values_for_index(index)
           attribute_names  = attribute_pairs.keys
           attribute_values = attribute_names.collect { |key|
             attribute_pairs[key]
           }
           
-          client.update "#{index.name}_core", attribute_names, {
+          client.update "#{index.core_name}", attribute_names, {
             sphinx_document_id => attribute_values
-          } if in_core_index?
+          } if self.class.search_for_id(sphinx_document_id, index.core_name)
         end
+        
+        true
       end
       
       def updatable_attributes(index)
@@ -34,15 +37,10 @@ module ThinkingSphinx
       
       def attribute_values_for_index(index)
         updatable_attributes(index).inject({}) { |hash, attrib|
-          if attrib.type == :datetime
-            hash[attrib.unique_name.to_s] = attrib.live_value(self).to_time.to_i
-          else
-            hash[attrib.unique_name.to_s] = attrib.live_value self
-          end
-          
+          hash[attrib.unique_name.to_s] = attrib.live_value self
           hash
         }
       end
     end
   end
-end
+end

data/lib/thinking_sphinx/active_record/delta.rb

@@ -12,32 +12,6 @@ module ThinkingSphinx
       def self.included(base)
         base.class_eval do
           class << self
-            # Temporarily disable delta indexing inside a block, then perform a single
-            # rebuild of index at the end.
-            #
-            # Useful when performing updates to batches of models to prevent
-            # the delta index being rebuilt after each individual update.
-            #
-            # In the following example, the delta index will only be rebuilt once,
-            # not 10 times.
-            #
-            #   SomeModel.suspended_delta do
-            #     10.times do
-            #       SomeModel.create( ... )
-            #     end
-            #   end
-            #
-            def suspended_delta(reindex_after = true, &block)
-              original_setting = ThinkingSphinx.deltas_enabled?
-              ThinkingSphinx.deltas_enabled = false
-              begin
-                yield
-              ensure
-                ThinkingSphinx.deltas_enabled = original_setting
-                self.index_delta if reindex_after
-              end
-            end
-
             # Build the delta index for the related model. This won't be called
             # if running in the test environment.
             #

data/lib/thinking_sphinx/active_record/scopes.rb

@@ -8,6 +8,40 @@ module ThinkingSphinx
       end
     
       module ClassMethods
+        
+        # Similar to ActiveRecord's default_scope method Thinking Sphinx supports
+        # a default_sphinx_scope. For example:
+        #
+        #    default_sphinx_scope :some_sphinx_named_scope
+        #
+        # The scope is automatically applied when the search method is called. It
+        # will only be applied if it is an existing sphinx_scope.
+        def default_sphinx_scope(sphinx_scope_name)
+          @default_sphinx_scope = sphinx_scope_name
+        end
+
+        # Returns the default_sphinx_scope or nil if none is set.
+        def get_default_sphinx_scope
+          @default_sphinx_scope
+        end
+
+        # Returns true if the current Model has a default_sphinx_scope. Also checks if
+        # the default_sphinx_scope actually is a scope.
+        def has_default_sphinx_scope?
+          !@default_sphinx_scope.nil? && sphinx_scopes.include?(@default_sphinx_scope)
+        end
+
+        # Similar to ActiveRecord's named_scope method Thinking Sphinx supports
+        # scopes. For example:
+        #
+        #   sphinx_scope(:latest_first) { 
+        #       {:order => 'created_at DESC, @relevance DESC'}
+        #     }
+        #
+        # Usage:
+        #
+        #   @articles =  Article.latest_first.search 'pancakes'
+        #
         def sphinx_scope(method, &block)
           @sphinx_scopes ||= []
           @sphinx_scopes << method
@@ -21,7 +55,9 @@ module ThinkingSphinx
             end
           end
         end
-        
+
+        # This returns an Array of all defined scopes. The default
+        # scope shows as :default.
         def sphinx_scopes
           @sphinx_scopes || []
         end

data/lib/thinking_sphinx/adapters/mysql_adapter.rb

@@ -13,7 +13,7 @@ module ThinkingSphinx
     end
     
     def group_concatenate(clause, separator = ' ')
-      "GROUP_CONCAT(DISTINCT #{clause} SEPARATOR '#{separator}')"
+      "GROUP_CONCAT(DISTINCT IFNULL(#{clause}, '0') SEPARATOR '#{separator}')"
     end
     
     def cast_to_string(clause)

data/lib/thinking_sphinx/adapters/postgresql_adapter.rb

@@ -10,18 +10,17 @@ module ThinkingSphinx
     end
     
     def concatenate(clause, separator = ' ')
-      clause.split(', ').collect { |field|
-        case field
-        when /COALESCE/, "'')"
-          field
-        else
-          "COALESCE(CAST(#{field} as varchar), '')"
-        end
-      }.join(" || '#{separator}' || ")
+      if clause[/^COALESCE/]
+        clause.split('), ').join(") || '#{separator}' || ")
+      else
+        clause.split(', ').collect { |field|
+          "CAST(COALESCE(#{field}, '') as varchar)"
+        }.join(" || '#{separator}' || ")
+      end
     end
     
     def group_concatenate(clause, separator = ' ')
-      "array_to_string(array_accum(#{clause}), '#{separator}')"
+      "array_to_string(array_accum(COALESCE(#{clause}, '0')), '#{separator}')"
     end
     
     def cast_to_string(clause)
@@ -37,8 +36,16 @@ module ThinkingSphinx
     end
     
     def convert_nulls(clause, default = '')
-      default = "'#{default}'"  if default.is_a?(String)
-      default = 'NULL'          if default.nil?
+      default = case default
+      when String
+        "'#{default}'"
+      when NilClass
+        'NULL'
+      when Fixnum
+        "#{default}::bigint"
+      else
+        default
+      end
       
       "COALESCE(#{clause}, #{default})"
     end

data/lib/thinking_sphinx/attribute.rb

@@ -101,14 +101,14 @@ module ThinkingSphinx
         when :datetime
           adapter.cast_to_datetime(part)
         when :multi
-          part = adapter.cast_to_datetime(part) if is_many_datetimes?
-          adapter.convert_nulls(part, 0)
+          part = adapter.cast_to_datetime(part)   if is_many_datetimes?
+          part = adapter.convert_nulls(part, '0') if is_many_ints?
+          part
         else
           part
         end
       }.join(', ')
 
-      # clause = adapter.cast_to_datetime(clause)             if type == :datetime
       clause = adapter.crc(clause)                          if @crc
       clause = adapter.concatenate(clause, separator)       if concat_ws?
 
@@ -179,7 +179,7 @@ module ThinkingSphinx
       object = instance
       column = @columns.first
       column.__stack.each { |method| object = object.send(method) }
-      object.send(column.__name)
+      sphinx_value object.send(column.__name)
     end
 
     def all_ints?
@@ -336,5 +336,20 @@ 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
+      else
+        value
+      end
+    end
   end
 end

data/lib/thinking_sphinx/auto_version.rb

@@ -0,0 +1,22 @@
+module ThinkingSphinx
+  class AutoVersion
+    def self.detect
+      version = ThinkingSphinx::Configuration.instance.controller.sphinx_version
+      case version
+      when '0.9.8', '0.9.9'
+        require "riddle/#{version}"
+      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/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,27 @@ 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( 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 )
     
     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
     
     attr_accessor :source_options, :index_options
     
-    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.
@@ -92,16 +94,17 @@ module ThinkingSphinx
       
       @configuration = Riddle::Configuration.new
       @configuration.searchd.address    = "127.0.0.1"
-      @configuration.searchd.port       = 3312
+      @configuration.searchd.port       = 9312
       @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.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
@@ -111,16 +114,13 @@ module ThinkingSphinx
         :charset_type => "utf-8"
       }
       
-      self.searchd_binary_name = "searchd"
-      self.indexer_binary_name = "indexer"
-            
       parse_config
       
       self
     end
     
     def self.environment
-      @@environment ||= (
+      Thread.current[:thinking_sphinx_environment] ||= (
         defined?(Merb) ? Merb.environment : ENV['RAILS_ENV']
       ) || "development"
     end
@@ -129,22 +129,19 @@ module ThinkingSphinx
       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,37 +149,6 @@ 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
     end
@@ -223,6 +189,38 @@ 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
+    
     def client
       client = Riddle::Client.new address, port
       client.max_matches = configuration.searchd.max_matches || 1000
@@ -231,7 +229,7 @@ module ThinkingSphinx
     
     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