thinking-sphinx 1.4.6 → 1.4.7

data/lib/thinking_sphinx/configuration.rb

@@ -15,6 +15,7 @@ module ThinkingSphinx
   # address::               127.0.0.1
   # port::                  9312
   # allow star::            false
+  # stop timeout::          5
   # min prefix length::     1
   # min infix length::      1
   # mem limit::             64M
@@ -49,29 +50,25 @@ module ThinkingSphinx
   class Configuration
     include Singleton
     
-    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( 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,
-      :app_root, :model_directories, :delayed_job_priority, :indexed_models
+    SourceOptions = Riddle::Configuration::SQLSource.settings.map { |setting|
+      setting.to_s
+    } - %w( type sql_query_pre sql_query sql_joined_field sql_file_field
+      sql_query_range sql_attr_uint sql_attr_bool sql_attr_bigint sql_query_info
+      sql_attr_timestamp sql_attr_str2ordinal sql_attr_float sql_attr_multi
+      sql_attr_string sql_attr_str2wordcount sql_column_buffers sql_field_string
+      sql_field_str2wordcount )
+    IndexOptions  = Riddle::Configuration::Index.settings.map     { |setting|
+      setting.to_s
+    } - %w( source prefix_fields infix_fields )
+    CustomOptions = %w( disable_range use_64_bit )
+    
+    attr_accessor :searchd_file_path, :allow_star, :app_root,
+      :model_directories, :delayed_job_priority, :indexed_models, :use_64_bit,
+      :touched_reindex_file, :stop_timeout, :version
     
     attr_accessor :source_options, :index_options
-    attr_accessor :version
     
-    attr_reader :environment, :configuration, :controller
+    attr_reader :configuration, :controller
     
     @@environment = nil
     
@@ -107,9 +104,9 @@ module ThinkingSphinx
       
       self.address              = "127.0.0.1"
       self.port                 = 9312
-      self.database_yml_file    = "#{self.app_root}/config/database.yml"
       self.searchd_file_path    = "#{self.app_root}/db/sphinx/#{environment}"
       self.allow_star           = false
+      self.stop_timeout         = 5
       self.model_directories    = ["#{app_root}/app/models/"] +
         Dir.glob("#{app_root}/vendor/plugins/*/app/models/")
       self.delayed_job_priority = 0
@@ -128,21 +125,15 @@ module ThinkingSphinx
     end
     
     def self.environment
-      if @@environment.nil?
-        ThinkingSphinx.mutex.synchronize do
-          @@environment ||= if defined?(Merb)
-            Merb.environment
-          elsif defined?(RAILS_ENV)
-            RAILS_ENV
-          elsif defined?(Sinatra)
-            Sinatra::Application.environment.to_s
-          else
-            ENV['RAILS_ENV'] || 'development'
-          end
-        end
+      @@environment ||= if defined?(Merb)
+        Merb.environment
+      elsif defined?(RAILS_ENV)
+        RAILS_ENV
+      elsif defined?(Sinatra)
+        Sinatra::Application.environment.to_s
+      else
+        ENV['RAILS_ENV'] || 'development'
       end
-      
-      @@environment
     end
     
     def self.reset_environment
@@ -276,7 +267,12 @@ module ThinkingSphinx
         end
       end
     end
-    
+
+    def touch_reindex_file(output)
+      return FileUtils.touch(@touched_reindex_file) if @touched_reindex_file and output =~ /succesfully sent SIGHUP to searchd/
+      false
+    end
+
     private
     
     # Parse the config/sphinx.yml file - if it exists - then use the attribute

data/lib/thinking_sphinx/context.rb

@@ -55,12 +55,13 @@ class ThinkingSphinx::Context
         model_name = file.gsub(/^#{base}([\w_\/\\]+)\.rb/, '\1')
         
         next if model_name.nil?
+        camelized_model = model_name.camelize
         next if ::ActiveRecord::Base.send(:subclasses).detect { |model|
-          model.name == model_name.camelize
+          model.name == camelized_model
         }
         
         begin
-          model_name.camelize.constantize
+          camelized_model.constantize
         rescue LoadError
           model_name.gsub!(/.*[\/\\]/, '').nil? ? next : retry
         rescue NameError

data/lib/thinking_sphinx/deploy/capistrano.rb

@@ -61,27 +61,25 @@ DESC
 
     desc "Start the Sphinx daemon"
     task :start do
-      configure
-      rake "thinking_sphinx:start"
+      rake "thinking_sphinx:configure thinking_sphinx:start"
     end
 
     desc "Stop the Sphinx daemon"
     task :stop do
-      configure
-      rake "thinking_sphinx:stop"
+      rake "thinking_sphinx:configure thinking_sphinx:stop"
     end
 
     desc "Stop and then start the Sphinx daemon"
     task :restart do
-      stop
-      start
+      rake "thinking_sphinx:configure thinking_sphinx:stop \
+        thinking_sphinx:start"
     end
 
     desc "Stop, re-index and then start the Sphinx daemon"
     task :rebuild do
-      stop
-      index
-      start
+      rake "thinking_sphinx:configure thinking_sphinx:stop \
+        thinking_sphinx:reindex \
+        thinking_sphinx:start"
     end
 
     desc "Add the shared folder for sphinx files"

data/lib/thinking_sphinx/search.rb

@@ -6,7 +6,7 @@ module ThinkingSphinx
   # Most times, you will just want a specific model's results - to search and
   # search_for_ids methods will do the job in exactly the same manner when
   # called from a model.
-  # 
+  #
   class Search < Array
     CoreMethods = %w( == class class_eval extend frozen? id instance_eval
       instance_of? instance_values instance_variable_defined?
@@ -15,145 +15,145 @@ module ThinkingSphinx
       respond_to_missing? send should type )
     SafeMethods = %w( partition private_methods protected_methods
       public_methods send class )
-    
+
     instance_methods.select { |method|
       method.to_s[/^__/].nil? && !CoreMethods.include?(method.to_s)
     }.each { |method|
       undef_method method
     }
-    
+
     HashOptions   = [:conditions, :with, :without, :with_all, :without_any]
     ArrayOptions  = [:classes, :without_ids]
-    
+
     attr_reader :args, :options
-    
+
     # Deprecated. Use ThinkingSphinx.search
     def self.search(*args)
       warn 'ThinkingSphinx::Search.search is deprecated. Please use ThinkingSphinx.search instead.'
       ThinkingSphinx.search(*args)
     end
-    
+
     # Deprecated. Use ThinkingSphinx.search_for_ids
     def self.search_for_ids(*args)
       warn 'ThinkingSphinx::Search.search_for_ids is deprecated. Please use ThinkingSphinx.search_for_ids instead.'
       ThinkingSphinx.search_for_ids(*args)
     end
-    
+
     # Deprecated. Use ThinkingSphinx.search_for_ids
     def self.search_for_id(*args)
       warn 'ThinkingSphinx::Search.search_for_id is deprecated. Please use ThinkingSphinx.search_for_id instead.'
       ThinkingSphinx.search_for_id(*args)
     end
-    
+
     # Deprecated. Use ThinkingSphinx.count
     def self.count(*args)
       warn 'ThinkingSphinx::Search.count is deprecated. Please use ThinkingSphinx.count instead.'
       ThinkingSphinx.count(*args)
     end
-    
+
     # Deprecated. Use ThinkingSphinx.facets
     def self.facets(*args)
       warn 'ThinkingSphinx::Search.facets is deprecated. Please use ThinkingSphinx.facets instead.'
       ThinkingSphinx.facets(*args)
     end
-    
+
     def self.bundle_searches(enum = nil)
       bundle = ThinkingSphinx::BundledSearch.new
-      
+
       if enum.nil?
         yield bundle
       else
         enum.each { |item| yield bundle, item }
       end
-      
+
       bundle.searches
     end
-    
+
     def self.matching_fields(fields, bitmask)
       matches   = []
       bitstring = bitmask.to_s(2).rjust(32, '0').reverse
-      
+
       fields.each_with_index do |field, index|
         matches << field if bitstring[index, 1] == '1'
       end
       matches
     end
-    
+
     def initialize(*args)
       ThinkingSphinx.context.define_indexes
-      
+
       @array    = []
       @options  = args.extract_options!
       @args     = args
-      
+
       add_default_scope unless options[:ignore_default]
-      
+
       populate if @options[:populate]
     end
-    
+
     def to_a
       populate
       @array
     end
-    
+
     def freeze
       populate
       @array.freeze
       self
     end
-    
+
     # Indication of whether the request has been made to Sphinx for the search
     # query.
-    # 
+    #
     # @return [Boolean] true if the results have been requested.
-    # 
+    #
     def populated?
       !!@populated
     end
-    
+
     # Indication of whether the request resulted in an error from Sphinx.
-    # 
+    #
     # @return [Boolean] true if Sphinx reports query error
-    # 
+    #
     def error?
       !!error
     end
-    
+
     # The Sphinx-reported error, if any.
-    # 
+    #
     # @return [String, nil]
-    # 
+    #
     def error
       populate
       @results[:error]
     end
-    
+
     # Indication of whether the request resulted in a warning from Sphinx.
-    # 
+    #
     # @return [Boolean] true if Sphinx reports query warning
-    # 
+    #
     def warning?
       !!warning
     end
-    
+
     # The Sphinx-reported warning, if any.
-    # 
+    #
     # @return [String, nil]
-    # 
+    #
     def warning
       populate
       @results[:warning]
     end
-    
+
     # The query result hash from Riddle.
-    # 
+    #
     # @return [Hash] Raw Sphinx results
-    # 
+    #
     def results
       populate
       @results
     end
-    
+
     def method_missing(method, *args, &block)
       if is_scope?(method)
         add_scope(method, *args, &block)
@@ -166,62 +166,70 @@ module ThinkingSphinx
       elsif !SafeMethods.include?(method.to_s)
         populate
       end
-      
+
       if method.to_s[/^each_with_.*/] && !@array.respond_to?(method)
         each_with_attribute method.to_s.gsub(/^each_with_/, ''), &block
       else
         @array.send(method, *args, &block)
       end
     end
-        
+
     # Returns true if the Search object or the underlying Array object respond
     # to the requested method.
-    # 
+    #
     # @param [Symbol] method The method name
     # @return [Boolean] true if either Search or Array responds to the method.
-    # 
+    #
     def respond_to?(method, include_private = false)
       super || @array.respond_to?(method, include_private)
     end
-    
+
     # The current page number of the result set. Defaults to 1 if no page was
     # explicitly requested.
-    # 
+    #
     # @return [Integer]
-    # 
+    #
     def current_page
       @options[:page].blank? ? 1 : @options[:page].to_i
     end
-    
+
+    def first_page?
+      current_page == 1
+    end
+
     # Kaminari support
     def page(page_number)
       @options[:page] = page_number
       self
     end
-    
+
     # The next page number of the result set. If there are no more pages
     # available, nil is returned.
-    # 
+    #
     # @return [Integer, nil]
-    # 
+    #
     def next_page
       current_page >= total_pages ? nil : current_page + 1
     end
-    
+
+    def next_page?
+      !next_page.nil?
+    end
+
     # The previous page number of the result set. If this is the first page,
     # then nil is returned.
-    # 
+    #
     # @return [Integer, nil]
-    # 
+    #
     def previous_page
       current_page == 1 ? nil : current_page - 1
     end
-    
+
     # The amount of records per set of paged results. Defaults to 20 unless a
     # specific page size is requested.
-    # 
+    #
     # @return [Integer]
-    # 
+    #
     def per_page
       @options[:limit] ||= @options[:per_page]
       @options[:limit] ||= 20
@@ -229,29 +237,29 @@ module ThinkingSphinx
     end
     # Kaminari support
     alias_method :limit_value, :per_page
-    
+
     # Kaminari support
     def per(limit)
       @options[:limit] = limit
       self
     end
-    
+
     # The total number of pages available if the results are paginated.
-    # 
+    #
     # @return [Integer]
-    # 
+    #
     def total_pages
       populate
       return 0 if @results[:total].nil?
-      
+
       @total_pages ||= (@results[:total] / per_page.to_f).ceil
     end
     # Compatibility with kaminari and older versions of will_paginate
     alias_method :page_count, :total_pages
     alias_method :num_pages,  :total_pages
-    
+
     # Query time taken
-    # 
+    #
     # @return [Integer]
     #
     def query_time
@@ -262,34 +270,37 @@ module ThinkingSphinx
     end
 
     # The total number of search results available.
-    # 
+    #
     # @return [Integer]
-    # 
+    #
     def total_entries
       populate
       return 0 if @results[:total_found].nil?
-      
+
       @total_entries ||= @results[:total_found]
     end
-    
+
+    # Compatibility with kaminari
+    alias_method :total_count, :total_entries
+
     # The current page's offset, based on the number of records per page.
-    # Or explicit :offset if given. 
-    # 
+    # Or explicit :offset if given.
+    #
     # @return [Integer]
-    # 
+    #
     def offset
       @options[:offset] || ((current_page - 1) * per_page)
     end
-    
+
     def indexes
       return options[:index] if options[:index]
       return '*' if classes.empty?
-      
+
       classes.collect { |klass|
         klass.sphinx_index_names
       }.flatten.uniq.join(',')
     end
-    
+
     def each_with_groupby_and_count(&block)
       populate
       results[:matches].each_with_index do |match, index|
@@ -299,42 +310,44 @@ module ThinkingSphinx
       end
     end
     alias_method :each_with_group_and_count, :each_with_groupby_and_count
-    
+
     def each_with_weighting(&block)
       populate
       results[:matches].each_with_index do |match, index|
         yield self[index], match[:weight]
       end
     end
-    
+
     def each_with_match(&block)
       populate
       results[:matches].each_with_index do |match, index|
         yield self[index], match
       end
     end
-    
+
     def excerpt_for(string, model = nil)
       if model.nil? && one_class
         model ||= one_class
       end
-      
+
       populate
+
+      index = options[:index] || "#{model.core_index_names.first}"
       client.excerpts(
         {
           :docs   => [string.to_s],
           :words  => results[:words].keys.join(' '),
-          :index  => options[:index] || "#{model.core_index_names.first}"
+          :index  => index.split(',').first.strip
         }.merge(options[:excerpt_options] || {})
       ).first
     end
-    
+
     def search(*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,
@@ -343,45 +356,45 @@ module ThinkingSphinx
       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
       client.reset
     end
-    
+
     def populate_from_queue(results)
       return if @populated
       @populated = true
       @results   = results
-      
+
       compose_results
     end
-    
+
     private
-    
+
     def config
       ThinkingSphinx::Configuration.instance
     end
-    
+
     def populate
       return if @populated
       @populated = true
-      
+
       retry_on_stale_index do
         begin
           log "Querying: '#{query}'"
@@ -390,9 +403,9 @@ module ThinkingSphinx
           }
           log "Found #{@results[:total_found]} results", :debug,
             "Sphinx (#{sprintf("%f", runtime)}s)"
-          
+
           log "Sphinx Daemon returned warning: #{warning}", :error if warning?
-          
+
           if error?
             log "Sphinx Daemon returned error: #{error}", :error
             raise SphinxError.new(error, @results) unless options[:ignore_errors]
@@ -401,7 +414,7 @@ module ThinkingSphinx
           raise ThinkingSphinx::ConnectionError,
             'Connection to Sphinx Daemon (searchd) failed.'
         end
-        
+
         compose_results
       end
     end
@@ -418,13 +431,13 @@ module ThinkingSphinx
         add_matching_fields if client.rank_mode == :fieldmask
       end
     end
-    
+
     def compose_ids_results
       replace @results[:matches].collect { |match|
         match[:attributes]['sphinx_internal_id']
       }
     end
-    
+
     def compose_only_results
       replace @results[:matches].collect { |match|
         case only = options[:only]
@@ -440,30 +453,30 @@ module ThinkingSphinx
         end
       }
     end
-    
+
     def add_excerpter
       each do |object|
         next if object.nil?
-        
+
         object.excerpts = ThinkingSphinx::Excerpter.new self, object
       end
     end
-    
+
     def add_sphinx_attributes
       each do |object|
         next if object.nil?
-        
+
         match = match_hash object
         next if match.nil?
-        
+
         object.sphinx_attributes = match[:attributes]
       end
     end
-    
+
     def add_matching_fields
       each do |object|
         next if object.nil?
-        
+
         match = match_hash object
         next if match.nil?
         object.matching_fields = ThinkingSphinx::Search.matching_fields(
@@ -471,21 +484,21 @@ module ThinkingSphinx
         )
       end
     end
-    
+
     def match_hash(object)
       @results[:matches].detect { |match|
         class_crc = object.class.name
         class_crc = object.class.to_crc32 if Riddle.loaded_version.to_i < 2
-        
+
         match[:attributes]['sphinx_internal_id'] == object.
           primary_key_for_sphinx &&
         match[:attributes][crc_attribute] == class_crc
       }
     end
-    
+
     def self.log(message, method = :debug, identifier = 'Sphinx')
       return if ::ActiveRecord::Base.logger.nil?
-      
+
       info = ''
       if ::ActiveRecord::Base.colorize_logging
         identifier_color, message_color = "4;32;1", "0" # 0;1 = Bold
@@ -494,20 +507,20 @@ module ThinkingSphinx
       else
         info = "#{identifier}   #{message}"
       end
-      
+
       ::ActiveRecord::Base.logger.send method, info
     end
-    
+
     def log(*args)
       self.class.log(*args)
     end
-    
+
     def prepare(client)
       index_options = {}
       if one_class && one_class.sphinx_indexes && one_class.sphinx_indexes.first
         index_options = one_class.sphinx_indexes.first.local_options
       end
-      
+
       [
         :max_matches, :group_by, :group_function, :group_clause,
         :group_distinct, :id_range, :cut_off, :retry_count, :retry_delay,
@@ -519,7 +532,7 @@ module ThinkingSphinx
 
       # treated non-standard as :select is already used for AR queries
       client.select = options[:sphinx_select] || '*'
-      
+
       client.limit      = per_page
       client.offset     = offset
       client.match_mode = match_mode
@@ -530,62 +543,62 @@ module ThinkingSphinx
       client.group_function = group_function if group_function
       client.index_weights  = index_weights
       client.anchor     = anchor
-      
+
       client
     end
-    
+
     def retry_on_stale_index(&block)
       stale_ids = []
       retries   = stale_retries
-      
+
       begin
         options[:raise_on_stale] = retries > 0
         block.call
-        
+
         # If ThinkingSphinx::Search#instances_from_matches found records in
         # Sphinx but not in the DB and the :raise_on_stale option is set, this
         # exception is raised. We retry a limited number of times, excluding the
         # stale ids from the search.
       rescue StaleIdsException => err
         retries -= 1
-        
+
         # For logging
         stale_ids |= err.ids
         # ID exclusion
         options[:without_ids] = Array(options[:without_ids]) | err.ids
-        
+
         log 'Sphinx Stale Ids (%s %s left): %s' % [
           retries, (retries == 1 ? 'try' : 'tries'), stale_ids.join(', ')
         ]
         retry
       end
     end
-    
+
     def classes
       @classes ||= options[:classes] || []
     end
-    
+
     def one_class
       @one_class ||= classes.length != 1 ? nil : classes.first
     end
-    
+
     def query
       @query ||= begin
         q = @args.join(' ') << conditions_as_query
         (options[:star] ? star_query(q) : q).strip
       end
     end
-    
+
     def conditions_as_query
       return '' if @options[:conditions].blank?
-      
+
       ' ' + @options[:conditions].keys.collect { |key|
         "@#{key} #{options[:conditions][key]}"
       }.join(' ')
     end
-    
+
     def star_query(query)
-      token = options[:star].is_a?(Regexp) ? options[:star] : /\w+/u
+      token = options[:star].is_a?(Regexp) ? options[:star] : default_star_token
 
       query.gsub(/("#{token}(.*?#{token})?"|(?![!-])#{token})/u) do
         pre, proper, post = $`, $&, $'
@@ -602,15 +615,25 @@ module ThinkingSphinx
         end
       end
     end
-    
+
+    if Regexp.instance_methods.include?(:encoding)
+      DefaultStarToken = Regexp.new('\p{Word}+')
+    else
+      DefaultStarToken = Regexp.new('\w+', nil, 'u')
+    end
+
+    def default_star_token
+      DefaultStarToken
+    end
+
     def comment
       options[:comment] || ''
     end
-    
+
     def match_mode
       options[:match_mode] || (options[:conditions].blank? ? :all : :extended)
     end
-    
+
     def sort_mode
       @sort_mode ||= case options[:sort_mode]
       when :asc
@@ -630,7 +653,7 @@ module ThinkingSphinx
         options[:sort_mode]
       end
     end
-    
+
     def sort_by
       case @sort_by = (options[:sort_by] || options[:order])
       when String
@@ -642,28 +665,28 @@ module ThinkingSphinx
         ''
       end
     end
-    
+
     def field_names
       return [] unless one_class
-      
+
       one_class.sphinx_indexes.collect { |index|
         index.fields.collect { |field| field.unique_name }
       }.flatten
     end
-    
+
     def sorted_fields_to_attributes(order_string)
       field_names.each { |field|
         order_string.gsub!(/(^|\s)#{field}(,?\s|$)/) { |match|
           match.gsub field.to_s, field.to_s.concat("_sort")
         }
       }
-      
+
       order_string
     end
-    
+
     # Turn :index_weights => { "foo" => 2, User => 1 } into :index_weights =>
     # { "foo" => 2, "user_core" => 1, "user_delta" => 1 }
-    # 
+    #
     def index_weights
       weights = options[:index_weights] || {}
       weights.keys.inject({}) do |hash, key|
@@ -674,37 +697,37 @@ module ThinkingSphinx
         else
           hash[key] = weights[key]
         end
-        
+
         hash
       end
     end
-    
+
     def group_by
       options[:group] ? options[:group].to_s : nil
     end
-    
+
     def group_function
       options[:group] ? :attr : nil
     end
-    
+
     def internal_filters
       filters = [Riddle::Client::Filter.new('sphinx_deleted', [0])]
-      
+
       class_crcs = classes.collect { |klass|
         klass.to_crc32s
       }.flatten
-      
+
       unless class_crcs.empty?
         filters << Riddle::Client::Filter.new('class_crc', class_crcs)
       end
-      
+
       filters << Riddle::Client::Filter.new(
         'sphinx_internal_id', filter_value(options[:without_ids]), true
-      ) if options[:without_ids]
-      
+      ) unless options[:without_ids].nil? || options[:without_ids].empty?
+
       filters
     end
-    
+
     def filters
       internal_filters +
       (options[:with] || {}).collect { |attrib, value|
@@ -724,7 +747,7 @@ module ThinkingSphinx
         }
       }.flatten
     end
-    
+
     # When passed a Time instance, returns the integer timestamp.
     def filter_value(value)
       case value
@@ -740,10 +763,10 @@ module ThinkingSphinx
         Array(value)
       end
     end
-    
+
     def anchor
       return {} unless options[:geo] || (options[:lat] && options[:lng])
-      
+
       {
         :latitude   => options[:geo] ? options[:geo].first : options[:lat],
         :longitude  => options[:geo] ? options[:geo].last  : options[:lng],
@@ -751,43 +774,43 @@ module ThinkingSphinx
         :longitude_attribute => longitude_attr.to_s
       }
     end
-    
+
     def latitude_attr
       options[:latitude_attr]      ||
       index_option(:latitude_attr) ||
       attribute(:lat, :latitude)
     end
-    
+
     def longitude_attr
       options[:longitude_attr]      ||
       index_option(:longitude_attr) ||
       attribute(:lon, :lng, :longitude)
     end
-    
+
     def index_option(key)
       return nil unless one_class
-      
+
       one_class.sphinx_indexes.collect { |index|
         index.local_options[key]
       }.compact.first
     end
-    
+
     def attribute(*keys)
       return nil unless one_class
-      
+
       keys.detect { |key|
         attributes.include?(key)
       }
     end
-    
+
     def attributes
       return [] unless one_class
-      
+
       attributes = one_class.sphinx_indexes.collect { |index|
         index.attributes.collect { |attrib| attrib.unique_name }
       }.flatten
     end
-    
+
     def stale_retries
       case options[:retry_stale]
       when TrueClass
@@ -798,10 +821,10 @@ module ThinkingSphinx
         options[:retry_stale].to_i
       end
     end
-    
+
     def include_for_class(klass)
       includes = options[:include] || klass.sphinx_index_options[:include]
-      
+
       case includes
       when NilClass
         nil
@@ -829,7 +852,7 @@ module ThinkingSphinx
       end
       scoped_array.empty? ? nil : scoped_array
     end
-    
+
     def include_from_hash(hash, klass)
       scoped_hash = {}
       hash.keys.each do |key|
@@ -837,7 +860,7 @@ module ThinkingSphinx
       end
       scoped_hash.empty? ? nil : scoped_hash
     end
-    
+
     def instances_from_class(klass, matches)
       index_options = klass.sphinx_index_options
 
@@ -852,7 +875,7 @@ module ThinkingSphinx
       ) : []
 
       # Raise an exception if we find records in Sphinx but not in the DB, so
-      # the search method can retry without them. See 
+      # the search method can retry without them. See
       # ThinkingSphinx::Search.retry_search_on_stale_index.
       if options[:raise_on_stale] && instances.length < ids.length
         stale_ids = ids - instances.map { |i| i.id }
@@ -869,13 +892,13 @@ module ThinkingSphinx
         end
       }
     end
-    
+
     # Group results by class and call #find(:all) once for each group to reduce
     # the number of #find's in multi-model searches.
-    # 
+    #
     def instances_from_matches
       return single_class_results if one_class
-      
+
       groups = results[:matches].group_by { |match|
         match[:attributes][crc_attribute]
       }
@@ -884,7 +907,7 @@ module ThinkingSphinx
           instances_from_class(class_from_crc(crc), group)
         )
       end
-      
+
       results[:matches].collect do |match|
         groups.detect { |crc, group|
           crc == match[:attributes][crc_attribute]
@@ -893,11 +916,11 @@ module ThinkingSphinx
         }
       end
     end
-    
+
     def single_class_results
       instances_from_class one_class, results[:matches]
     end
-    
+
     def class_from_crc(crc)
       if Riddle.loaded_version.to_i < 2
         config.models_by_crc[crc].constantize
@@ -905,7 +928,7 @@ module ThinkingSphinx
         crc.constantize
       end
     end
-    
+
     def each_with_attribute(attribute, &block)
       populate
       results[:matches].each_with_index do |match, index|
@@ -913,25 +936,25 @@ module ThinkingSphinx
           (match[:attributes][attribute] || match[:attributes]["@#{attribute}"])
       end
     end
-    
+
     def is_scope?(method)
       one_class && one_class.sphinx_scopes.include?(method)
     end
-    
+
     # Adds the default_sphinx_scope if set.
     def add_default_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)
       method = "#{method}_without_default".to_sym
       merge_search one_class.send(method, *args, &block), self.args, options
     end
-    
+
     def merge_search(search, args, options)
       search.args.each { |arg| args << arg }
-      
+
       search.options.keys.each do |key|
         if HashOptions.include?(key)
           options[key] ||= {}
@@ -945,18 +968,18 @@ module ThinkingSphinx
         end
       end
     end
-    
+
     def scoped_count
       return self.total_entries if(@options[:ids_only] || @options[:only])
-      
+
       @options[:ids_only] = true
       results_count = self.total_entries
       @options[:ids_only] = false
       @populated = false
-      
+
       results_count
     end
-    
+
     def crc_attribute
       Riddle.loaded_version.to_i < 2 ? 'class_crc' : 'sphinx_internal_class'
     end