DrMark-thinking-sphinx 0.9.7 → 0.9.8

data/README

@@ -4,6 +4,8 @@
 
 First, if you haven't done so already, check out the main usage[http://ts.freelancing-gods.com/usage.html] page. Once you've done that, the next place to look for information is the specific method docs - ThinkingSphinx::Search and ThinkingSphinx::Index::Builder in particular.
 
+Keep in mind that while Thinking Sphinx works for ActiveRecord with Merb, it doesn't yet support DataMapper (although that is planned).
+
 == Contributing
 
 Fork on GitHub and after you've committed tested patches, send a pull request.
@@ -49,4 +51,7 @@ Since I first released this library, there's been quite a few people who have su
 - Chris Heald
 - Peter Vandenberk
 - Josh French
-- Andrew Bennett
+- Andrew Bennett
+- Jordan Fowler
+- Seth Walker
+- Joe Noon

data/lib/riddle/client/filter.rb

@@ -18,7 +18,7 @@ module Riddle
       def query_message
         message = Message.new
         
-        message.append_string self.attribute
+        message.append_string self.attribute.to_s
         case self.values
         when Range
           if self.values.first.is_a?(Float) && self.values.last.is_a?(Float)

data/lib/riddle/client.rb

@@ -100,7 +100,7 @@ module Riddle
       :match_mode, :sort_mode, :sort_by, :weights, :id_range, :filters,
       :group_by, :group_function, :group_clause, :group_distinct, :cut_off,
       :retry_count, :retry_delay, :anchor, :index_weights, :rank_mode,
-      :max_query_time, :field_weights
+      :max_query_time, :field_weights, :timeout
     attr_reader :queue
     
     # Can instantiate with a specific server and port - otherwise it assumes
@@ -134,10 +134,40 @@ module Riddle
       @max_query_time = 0
       # string keys are field names, integer values are weightings
       @field_weights  = {}
+      @timeout        = 0
       
       @queue = []
     end
     
+    # Reset attributes and settings to defaults.
+    def reset
+      # defaults
+      @offset         = 0
+      @limit          = 20
+      @max_matches    = 1000
+      @match_mode     = :all
+      @sort_mode      = :relevance
+      @sort_by        = ''
+      @weights        = []
+      @id_range       = 0..0
+      @filters        = []
+      @group_by       = ''
+      @group_function = :day
+      @group_clause   = '@group desc'
+      @group_distinct = ''
+      @cut_off        = 0
+      @retry_count    = 0
+      @retry_delay    = 0
+      @anchor         = {}
+      # string keys are index names, integer values are weightings
+      @index_weights  = {}
+      @rank_mode      = :proximity_bm25
+      @max_query_time = 0
+      # string keys are field names, integer values are weightings
+      @field_weights  = {}
+      @timeout        = 0
+    end
+    
     # Set the geo-anchor point - with the names of the attributes that contain
     # the latitude and longitude (in radians), and the reference position.
     # Note that for geocoding to work properly, you must also set
@@ -149,12 +179,12 @@ module Riddle
     # Example:
     #   client.set_anchor('lat', -0.6591741, 'long', 2.530770)
     #
-    def set_anchor(lat_attr, lat, long_attr, long)
+    def set_anchor(lat_attr, lat, long_attr, long, units='')
       @anchor = {
         :latitude_attribute   => lat_attr,
-        :latitude             => lat,
+        :latitude             => (units == 'degrees' ? lat * Math::PI / 180 : lat),
         :longitude_attribute  => long_attr,
-        :longitude            => long
+        :longitude            => (units == 'degrees' ? long * Math::PI / 180 : long)
       }
     end
     
@@ -384,6 +414,26 @@ module Riddle
     # Connects to the Sphinx daemon, and yields a socket to use. The socket is
     # closed at the end of the block.
     def connect(&block)
+      socket = nil
+      if @timeout == 0
+        socket = initialise_connection
+      else
+        begin
+          Timeout.timeout(@timeout) { socket = initialise_connection }
+        rescue Timeout::Error
+          raise Riddle::ConnectionError,
+            "Connection to #{@server} on #{@port} timed out after #{@timeout} seconds"
+        end
+      end
+      
+      begin
+        yield socket
+      ensure
+        socket.close
+      end
+    end
+    
+    def initialise_connection
       socket = TCPSocket.new @server, @port
       
       # Checking version
@@ -396,11 +446,7 @@ module Riddle
       # Send version
       socket.send [1].pack('N'), 0
       
-      begin
-        yield socket
-      ensure
-        socket.close
-      end
+      socket
     end
     
     # Send a collection of messages, for a command type (eg, search, excerpts,
@@ -507,7 +553,7 @@ module Riddle
       # Per Index Weights
       message.append_int @index_weights.length
       @index_weights.each do |key,val|
-        message.append_string key
+        message.append_string key.to_s
         message.append_int val
       end
       
@@ -517,7 +563,7 @@ module Riddle
       # Per Field Weights
       message.append_int @field_weights.length
       @field_weights.each do |key,val|
-        message.append_string key
+        message.append_string key.to_s
         message.append_int val
       end
       

data/lib/riddle.rb

@@ -1,4 +1,5 @@
 require 'socket'
+require 'timeout'
 require 'riddle/client'
 require 'riddle/client/filter'
 require 'riddle/client/message'
@@ -9,14 +10,17 @@ module Riddle #:nodoc:
   end
   
   module Version #:nodoc:
-    Major = 0
-    Minor = 9
-    Tiny  = 8
+    Major   = 0
+    Minor   = 9
+    Tiny    = 8
     # Revision number for RubyForge's sake, taken from what Sphinx
     # outputs to the command line.
-    Rev   = 1198
+    Rev     = 1371
+    # Release number to mark my own fixes, beyond feature parity with
+    # Sphinx itself.
+    Release = 0
     
-    String      = [Major, Minor, Tiny].join('.') + "rc1"
-    GemVersion  = [Major, Minor, Tiny, Rev].join('.')
+    String      = [Major, Minor, Tiny].join('.')
+    GemVersion  = [Major, Minor, Tiny, Rev, Release].join('.')
   end
 end

data/lib/thinking_sphinx/active_record/delta.rb

@@ -73,10 +73,7 @@ module ThinkingSphinx
           # if running in the test environment.
           # 
           def index_delta
-            if ThinkingSphinx::Configuration.environment == "test" ||
-              !ThinkingSphinx.deltas_enabled?
-              return true
-            end
+            return true unless ThinkingSphinx.deltas_enabled?
             
             configuration = ThinkingSphinx::Configuration.new
             system "indexer --config #{configuration.config_file} --rotate #{self.class.indexes.first.name}_delta"

data/lib/thinking_sphinx/active_record.rb

@@ -10,9 +10,8 @@ module ThinkingSphinx
   module ActiveRecord
     def self.included(base)
       base.class_eval do
+        class_inheritable_array :indexes
         class << self
-          attr_accessor :indexes
-          
           # Allows creation of indexes for Sphinx. If you don't do this, there
           # isn't much point trying to search (or using this plugin at all,
           # really).
@@ -65,10 +64,10 @@ module ThinkingSphinx
           def define_index(&block)
             return unless ThinkingSphinx.define_indexes?
             
-            @indexes ||= []
+            self.indexes ||= []
             index = Index.new(self, &block)
             
-            @indexes << index
+            self.indexes << index
             unless ThinkingSphinx.indexed_models.include?(self.name)
               ThinkingSphinx.indexed_models << self.name
             end
@@ -132,7 +131,9 @@ module ThinkingSphinx
         "#{self.class.indexes.first.name}_delta",
         ['sphinx_deleted'],
         {self.id => 1}
-      ) if self.class.indexes.any? { |index| index.delta? } && self.delta?
+      ) if ThinkingSphinx.deltas_enabled? &&
+        self.class.indexes.any? { |index| index.delta? } &&
+        self.delta?
     end
   end
 end

data/lib/thinking_sphinx/configuration.rb

@@ -11,7 +11,7 @@ module ThinkingSphinx
   # query log file::        log/searchd.query.log
   # pid file::              log/searchd.#{environment}.pid
   # searchd files::         db/sphinx/#{environment}/
-  # address::               0.0.0.0 (all)
+  # address::               127.0.0.1
   # port::                  3312
   # allow star::            false
   # min prefix length::     1
@@ -63,7 +63,7 @@ module ThinkingSphinx
       self.query_log_file       = "#{self.app_root}/log/searchd.query.log"
       self.pid_file             = "#{self.app_root}/log/searchd.#{environment}.pid"
       self.searchd_file_path    = "#{self.app_root}/db/sphinx/#{environment}"
-      self.address              = "0.0.0.0"
+      self.address              = "127.0.0.1"
       self.port                 = 3312
       self.allow_star           = false
       self.min_prefix_len       = 1
@@ -165,7 +165,7 @@ searchd
         }
         
         begin
-          model_name.classify.constantize
+          model_name.camelize.constantize
         rescue LoadError
           model_name.gsub!(/.*[\/\\]/, '')
           retry

data/lib/thinking_sphinx/index.rb

@@ -41,6 +41,11 @@ module ThinkingSphinx
       model.name.underscore.tr(':/\\', '_')
     end
     
+    def empty?(part = :core)
+      config = ThinkingSphinx::Configuration.new
+      File.size?("#{config.searchd_file_path}/#{self.name}_#{part}.spa").nil?
+    end
+    
     def to_config(index, database_conf, charset_type)
       # Set up associations and joins
       link!
@@ -252,7 +257,7 @@ GROUP BY #{ (
       
       unless @model.descends_from_active_record?
         stored_class = @model.store_full_sti_class ? @model.name : @model.name.demodulize
-        builder.where("#{@model.inheritance_column} = '#{stored_class}'")
+        builder.where("#{@model.quoted_table_name}.#{quote_column(@model.inheritance_column)} = '#{stored_class}'")
       end
 
       @fields     = builder.fields

data/lib/thinking_sphinx/search.rb

@@ -5,7 +5,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
     class << self
       # Searches for results that match the parameters provided. Will only
@@ -14,16 +14,23 @@ module ThinkingSphinx
       #
       def search_for_ids(*args)
         results, client = search_results(*args.clone)
-        
+
         options = args.extract_options!
         page    = options[:page] ? options[:page].to_i : 1
-        
+
         begin
-          pager = WillPaginate::Collection.new(page,
-            client.limit, results[:total] || 0)
-          pager.replace results[:matches].collect { |match| match[:doc] }
+          pager = WillPaginate::Collection.create(page,
+            client.limit, results[:total_found] || 0) do |collection|
+            collection.replace results[:matches].collect { |match| match[:doc] }
+            collection.instance_variable_set :@total_entries, results[:total_found]
+          end
+          return (options[:include_raw] ? [pager, results] : pager)
         rescue
-          results[:matches].collect { |match| match[:doc] }
+          if options[:include_raw]
+            return results[:matches].collect { |match| match[:doc] }, results
+          else
+            return results[:matches].collect { |match| match[:doc] }
+          end
         end
       end
 
@@ -35,11 +42,11 @@ module ThinkingSphinx
       # just like paginate. The same parameters - :page and :per_page - work as
       # expected, and the returned result set can be used by the will_paginate
       # helper.
-      # 
+      #
       # == Basic Searching
       #
       # The simplest way of searching is straight text.
-      # 
+      #
       #   ThinkingSphinx::Search.search "pat"
       #   ThinkingSphinx::Search.search "google"
       #   User.search "pat", :page => (params[:page] || 1)
@@ -47,14 +54,32 @@ module ThinkingSphinx
       #
       # If you specify :include, like in an #find call, this will be respected
       # when loading the relevant models from the search results.
-      # 
+      #
       #   User.search "pat", :include => :posts
       #
+      # == Advanced Searching
+      #
+      # Sphinx supports 5 different matching modes. By default Thinking Sphinx
+      # uses :all, which unsurprisingly requires all the supplied search terms
+      # to match a result.
+      #
+      # Alternative modes include:
+      #
+      #   User.search "pat allan", :match_mode => :any
+      #   User.search "pat allan", :match_mode => :phrase
+      #   User.search "pat | allan", :match_mode => :boolean
+      #   User.search "@name pat | @username pat", :match_mode => :extended
+      #
+      # Any will find results with any of the search terms. Phrase treats the search
+      # terms a single phrase instead of individual words. Boolean and extended allow
+      # for more complex query syntax, refer to the sphinx documentation for further
+      # details.
+      #
       # == Searching by Fields
-      # 
+      #
       # If you want to step it up a level, you can limit your search terms to
       # specific fields:
-      # 
+      #
       #   User.search :conditions => {:name => "pat"}
       #
       # This uses Sphinx's extended match mode, unless you specify a different
@@ -74,11 +99,11 @@ module ThinkingSphinx
       # (not multi-model searching). With a single model, Thinking Sphinx
       # can figure out what attributes and fields are available, so you can
       # put it all in the :conditions hash, and it will sort it out.
-      # 
+      #
       #   Node.search :conditions => {:parent_id => 10}
-      # 
+      #
       # Filters can be single values, arrays of values, or ranges.
-      # 
+      #
       #   Article.search "East Timor", :conditions => {:rating => 3..5}
       #
       # == Excluding by Attributes
@@ -87,7 +112,7 @@ module ThinkingSphinx
       # attribute values to exclude. This is done with the :without option:
       #
       #   User.search :without => {:role_id => 1}
-      # 
+      #
       # == Sorting
       #
       # Sphinx can only sort by attributes, so generally you will need to avoid
@@ -112,13 +137,13 @@ module ThinkingSphinx
       # detail though.
       #
       # == Grouping
-      # 
+      #
       # For this you can use the group_by, group_clause and group_function
       # options - which are all directly linked to Sphinx's expectations. No
       # magic from Thinking Sphinx. It can get a little tricky, so make sure
       # you read all the relevant
       # documentation[http://sphinxsearch.com/doc.html#clustering] first.
-      # 
+      #
       # Yes this section will be expanded, but this is a start.
       #
       # == Geo/Location Searching
@@ -128,11 +153,11 @@ module ThinkingSphinx
       # take advantage of this, you will need to have both of those values in
       # attributes. To search with that point, you can then use one of the
       # following syntax examples:
-      # 
+      #
       #   Address.search "Melbourne", :geo => [1.4, -2.217]
       #   Address.search "Australia", :geo => [-0.55, 3.108],
       #     :latitude_attr => "latit", :longitude_attr => "longit"
-      # 
+      #
       # The first example applies when your latitude and longitude attributes
       # are named any of lat, latitude, lon, long or longitude. If that's not
       # the case, you will need to explicitly state them in your search, _or_
@@ -141,17 +166,17 @@ module ThinkingSphinx
       #   define_index do
       #     has :latit  # Float column, stored in radians
       #     has :longit # Float column, stored in radians
-      #     
+      #
       #     set_property :latitude_attr   => "latit"
       #     set_property :longitude_attr  => "longit"
       #   end
-      # 
+      #
       # Now, geo-location searching really only has an affect if you have a
       # filter, sort or grouping clause related to it - otherwise it's just a
       # normal search. To make use of the positioning difference, use the
       # special attribute "@geodist" in any of your filters or sorting or grouping
       # clauses.
-      # 
+      #
       # And don't forget - both the latitude and longitude you use in your
       # search, and the values in your indexes, need to be stored as a float in radians,
       # _not_ degrees. Keep in mind that if you do this conversion in SQL
@@ -161,75 +186,82 @@ module ThinkingSphinx
       #     has 'RADIANS(lat)', :as => :lat,  :type => :float
       #     # ...
       #   end
-      # 
+      #
       def search(*args)
         results, client = search_results(*args.clone)
-        
+
         ::ActiveRecord::Base.logger.error(
           "Sphinx Error: #{results[:error]}"
         ) if results[:error]
-        
+
         options = args.extract_options!
         klass   = options[:class]
         page    = options[:page] ? options[:page].to_i : 1
-        
+
         begin
-          pager = WillPaginate::Collection.new(page,
-            client.limit, results[:total] || 0)
-          pager.replace instances_from_results(results[:matches], options, klass)
+          pager = WillPaginate::Collection.create(page,
+            client.limit, results[:total] || 0) do |collection|
+            collection.replace instances_from_results(results[:matches], options, klass)
+            collection.instance_variable_set :@total_entries, results[:total_found]
+          end
+          return (options[:include_raw] ? [pager, results] : pager)
         rescue StandardError => err
-          instances_from_results(results[:matches], options, klass)
+          if options[:include_raw]
+            return instances_from_results(results[:matches], options, klass), results
+          else
+            return instances_from_results(results[:matches], options, klass)
+          end
         end
       end
-      
+
       # Checks if a document with the given id exists within a specific index.
       # Expected parameters:
       #
       # - ID of the document
       # - Index to check within
       # - Options hash (defaults to {})
-      # 
+      #
       # Example:
-      # 
+      #
       #   ThinkingSphinx::Search.search_for_id(10, "user_core", :class => User)
-      # 
+      #
       def search_for_id(*args)
         options = args.extract_options!
         client  = client_from_options options
-        
+
         query, filters    = search_conditions(
           options[:class], options[:conditions] || {}
         )
         client.filters   += filters
         client.match_mode = :extended unless query.empty?
         client.id_range   = args.first..args.first
-        
+
         begin
           return client.query(query, args[1])[:matches].length > 0
         rescue Errno::ECONNREFUSED => err
           raise ThinkingSphinx::ConnectionError, "Connection to Sphinx Daemon (searchd) failed."
         end
       end
-      
+
       private
-      
+
       # This method handles the common search functionality, and returns both
       # the result hash and the client. Not super elegant, but it'll do for
       # the moment.
-      # 
+      #
       def search_results(*args)
         options = args.extract_options!
         client  = client_from_options options
-        
+
         query, filters    = search_conditions(
           options[:class], options[:conditions] || {}
         )
         client.filters   += filters
         client.match_mode = :extended unless query.empty?
         query             = args.join(" ") + query
-        
+
         set_sort_options! client, options
-        
+
         client.limit  = options[:per_page].to_i if options[:per_page]
         page          = options[:page] ? options[:page].to_i : 1
         client.offset = (page - 1) * client.limit
@@ -241,10 +273,21 @@ module ThinkingSphinx
         rescue Errno::ECONNREFUSED => err
           raise ThinkingSphinx::ConnectionError, "Connection to Sphinx Daemon (searchd) failed."
         end
-        
+
         return results, client
       end
-      
+
+      # This function loops over the records and appends a 'distance' variable to each one with
+      # the value from Sphinx
+      def append_distances(instances, results, distance_name)
+        instances.each_with_index do |record, index|
+          if record
+            distance = (results[index][:attributes]['@geodist'] or nil)
+            record.instance_variable_get('@attributes')["#{distance_name}"] = distance
+          end
+        end
+      end
+
       def instances_from_results(results, options = {}, klass = nil)
         if klass.nil?
           results.collect { |result| instance_from_result result, options }
@@ -256,43 +299,47 @@ module ThinkingSphinx
             :include    => options[:include],
             :select     => options[:select]
           )
-          ids.collect { |obj_id| instances.detect { |obj| obj.id == obj_id } }
+          final_instances = ids.collect { |obj_id| instances.detect { |obj| obj.id == obj_id } }
+
+          final_instances = append_distances(final_instances, results, options[:distance_name]) if options[:distance_name] && (results.collect { |result| result[:attributes]['@geodist'] }.length > 0)
+
+          return final_instances
         end
       end
-      
+
       # Either use the provided class to instantiate a result from a model, or
       # get the result's CRC value and determine the class from that.
-      # 
+      #
       def instance_from_result(result, options)
         class_from_crc(result[:attributes]["class_crc"]).find(
           result[:doc], :include => options[:include], :select => options[:select]
         )
       end
-      
+
       # Convert a CRC value to the corresponding class.
-      # 
+      #
       def class_from_crc(crc)
         unless @models_by_crc
           Configuration.new.load_models
-          
+
           @models_by_crc = ThinkingSphinx.indexed_models.inject({}) do |hash, model|
             hash[model.constantize.to_crc32] = model
             hash
           end
         end
-        
+
         @models_by_crc[crc].constantize
       end
-      
+
       # Set all the appropriate settings for the client, using the provided
       # options hash.
       # 
-      def client_from_options(options)
+      def client_from_options(options = {})
         config = ThinkingSphinx::Configuration.new
         client = Riddle::Client.new config.address, config.port
         klass  = options[:class]
         index_options = klass ? klass.indexes.last.options : {}
-        
+
         [
           :max_matches, :match_mode, :sort_mode, :sort_by, :id_range,
           :group_by, :group_function, :group_clause, :group_distinct, :cut_off,
@@ -304,9 +351,9 @@ module ThinkingSphinx
             options[key] || index_options[key] || client.send(key)
           )
         end
-        
+
         client.anchor = anchor_conditions(klass, options) || {} if client.anchor.empty?
-        
+
         client.filters << Riddle::Client::Filter.new(
           "sphinx_deleted", [0]
         )
@@ -314,20 +361,20 @@ module ThinkingSphinx
         client.filters << Riddle::Client::Filter.new(
           "class_crc", options[:classes].collect { |klass| klass.to_crc32 }
         ) if options[:classes]
-        
+
         # normal attribute filters
         client.filters += options[:with].collect { |attr,val|
           Riddle::Client::Filter.new attr.to_s, filter_value(val)
         } if options[:with]
-        
+
         # exclusive attribute filters
         client.filters += options[:without].collect { |attr,val|
           Riddle::Client::Filter.new attr.to_s, filter_value(val), true
         } if options[:without]
-        
+
         client
       end
-      
+
       def filter_value(value)
         case value
         when Range
@@ -338,18 +385,18 @@ module ThinkingSphinx
           Array(value)
         end
       end
-      
+
       # Translate field and attribute conditions to the relevant search string
       # and filters.
-      # 
+      #
       def search_conditions(klass, conditions={})
         attributes = klass ? klass.indexes.collect { |index|
           index.attributes.collect { |attrib| attrib.unique_name }
         }.flatten : []
-        
+
         search_string = ""
         filters       = []
-        
+
         conditions.each do |key,val|
           if attributes.include?(key.to_sym)
             filters << Riddle::Client::Filter.new(
@@ -360,48 +407,48 @@ module ThinkingSphinx
             search_string << "@#{key} #{val} "
           end
         end
-        
+
         filters << Riddle::Client::Filter.new(
           "class_crc", [klass.to_crc32]
         ) if klass
-        
+
         return search_string, filters
       end
-      
+
       # Return the appropriate latitude and longitude values, depending on
       # whether the relevant attributes have been defined, and also whether
       # there's actually any values.
-      # 
+      #
       def anchor_conditions(klass, options)
         attributes = klass ? klass.indexes.collect { |index|
           index.attributes.collect { |attrib| attrib.unique_name }
         }.flatten : []
-        
+
         lat_attr = klass ? klass.indexes.collect { |index|
           index.options[:latitude_attr]
         }.compact.first : nil
-        
+
         lon_attr = klass ? klass.indexes.collect { |index|
           index.options[:longitude_attr]
         }.compact.first : nil
-        
+
         lat_attr = options[:latitude_attr] if options[:latitude_attr]
         lat_attr ||= :lat       if attributes.include?(:lat)
         lat_attr ||= :latitude  if attributes.include?(:latitude)
-        
+
         lon_attr = options[:longitude_attr] if options[:longitude_attr]
         lon_attr ||= :lon       if attributes.include?(:lon)
         lon_attr ||= :long      if attributes.include?(:long)
         lon_attr ||= :longitude if attributes.include?(:longitude)
-        
+
         lat = options[:lat]
         lon = options[:lon]
-        
+
         if options[:geo]
           lat = options[:geo].first
           lon = options[:geo].last
         end
-        
+
         lat && lon ? {
           :latitude_attribute   => lat_attr,
           :latitude             => lat,
@@ -409,19 +456,19 @@ module ThinkingSphinx
           :longitude            => lon
         } : nil
       end
-      
+
       # Set the sort options using the :order key as well as the appropriate
       # Riddle settings.
-      # 
+      #
       def set_sort_options!(client, options)
         klass = options[:class]
         fields = klass ? klass.indexes.collect { |index|
           index.fields.collect { |field| field.unique_name }
         }.flatten : []
-        
+
         case order = options[:order]
         when Symbol
-          client.sort_mode ||= :attr_asc
+          client.sort_mode = :attr_asc if client.sort_mode == :relevance || client.sort_mode.nil?
           if fields.include?(order)
             client.sort_by = order.to_s.concat("_sort")
           else
@@ -433,23 +480,23 @@ module ThinkingSphinx
         else
           # do nothing
         end
-        
+
         client.sort_mode = :attr_asc  if client.sort_mode == :asc
         client.sort_mode = :attr_desc if client.sort_mode == :desc
       end
-      
+
       # Search through a collection of fields and translate any appearances
       # of them in a string to their attribute equivalent for sorting.
-      # 
+      #
       def sorted_fields_to_attributes(string, fields)
         fields.each { |field|
           string.gsub!(/(^|\s)#{field}(,?\s|$)/) { |match|
             match.gsub field.to_s, field.to_s.concat("_sort")
           }
         }
-        
+
         string
       end
     end
   end
-end
+end

data/lib/thinking_sphinx.rb

@@ -20,7 +20,7 @@ module ThinkingSphinx
   module Version #:nodoc:
     Major = 0
     Minor = 9
-    Tiny  = 7
+    Tiny  = 8
     
     String = [Major, Minor, Tiny].join('.')
   end
@@ -52,10 +52,12 @@ module ThinkingSphinx
     @@define_indexes = value
   end
   
+  @@deltas_enabled = nil
+
   # Check if delta indexing is enabled.
   # 
   def self.deltas_enabled?
-    @@deltas_enabled =  true unless defined?(@@deltas_enabled)
+    @@deltas_enabled  = (ThinkingSphinx::Configuration.environment != 'test') if @@deltas_enabled.nil?
     @@deltas_enabled == true
   end
   
@@ -79,4 +81,4 @@ module ThinkingSphinx
       "SELECT @@global.sql_mode, @@session.sql_mode;"
     ).all? { |key,value| value.nil? || value[/ONLY_FULL_GROUP_BY/].nil? }
   end
-end
+end

data/spec/unit/thinking_sphinx/active_record/delta_spec.rb

@@ -167,6 +167,7 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
     end
     
     it "shouldn't index if the environment is 'test'" do
+      ThinkingSphinx.unstub_method(:deltas_enabled?)
       ThinkingSphinx::Configuration.stub_method(:environment => "test")
       
       @person.send(:index_delta)
@@ -182,4 +183,4 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
       )
     end
   end
-end
+end

data/spec/unit/thinking_sphinx/active_record/search_spec.rb

@@ -78,4 +78,4 @@ describe "ThinkingSphinx::ActiveRecord::Search" do
       )
     end
   end
-end
+end

data/spec/unit/thinking_sphinx/active_record_spec.rb

@@ -125,12 +125,6 @@ describe "ThinkingSphinx::ActiveRecord" do
       @person.stub_method(:in_core_index? => true)
     end
     
-    # after :each do
-    #   ThinkingSphinx::Configuration.unstub_method(:new)
-    #   Riddle::Client.unstub_method(:new)
-    #   Person.indexes.each { |index| index.unstub_method(:delta?) }
-    # end
-    
     it "should create a client using the Configuration's address and port" do
       @person.toggle_deleted
       
@@ -157,7 +151,8 @@ describe "ThinkingSphinx::ActiveRecord" do
       )
     end
     
-    it "should update the delta index's deleted flag if delta indexing is enabled and the instance's delta is true" do
+    it "should update the delta index's deleted flag if delta indexes are enabled and the instance's delta is true" do
+      ThinkingSphinx.stub_method(:deltas_enabled? => true)
       Person.indexes.each { |index| index.stub_method(:delta? => true) }
       @person.delta = true
       
@@ -168,7 +163,8 @@ describe "ThinkingSphinx::ActiveRecord" do
       )
     end
     
-    it "should not update the delta index's deleted flag if delta indexing is enabled and the instance's delta is false" do
+    it "should not update the delta index's deleted flag if delta indexes are enabled and the instance's delta is false" do
+      ThinkingSphinx.stub_method(:deltas_enabled? => true)
       Person.indexes.each { |index| index.stub_method(:delta? => true) }
       @person.delta = false
       
@@ -179,7 +175,8 @@ describe "ThinkingSphinx::ActiveRecord" do
       )
     end
     
-    it "should not update the delta index's deleted flag if delta indexing is enabled and the instance's delta is equivalent to false" do
+    it "should not update the delta index's deleted flag if delta indexes are enabled and the instance's delta is equivalent to false" do
+      ThinkingSphinx.stub_method(:deltas_enabled? => true)
       Person.indexes.each { |index| index.stub_method(:delta? => true) }
       @person.delta = 0
 
@@ -190,7 +187,20 @@ describe "ThinkingSphinx::ActiveRecord" do
       )
     end
 
-    it "shouldn't update the delta index if delta indexing is disabled" do
+    it "shouldn't update the delta index if delta indexes are disabled" do
+      ThinkingSphinx.stub_method(:deltas_enabled? => true)
+      @person.toggle_deleted
+      
+      @client.should_not have_received(:update).with(
+        "person_delta", ["sphinx_deleted"], {@person.id => 1}
+      )
+    end
+    
+    it "should not update the delta index if delta indexing is disabled" do
+      ThinkingSphinx.stub_method(:deltas_enabled? => false)
+      Person.indexes.each { |index| index.stub_method(:delta? => true) }
+      @person.delta = true
+      
       @person.toggle_deleted
       
       @client.should_not have_received(:update).with(
@@ -198,4 +208,16 @@ describe "ThinkingSphinx::ActiveRecord" do
       )
     end
   end
-end
+
+  describe "indexes in the inheritance chain (STI)" do
+    it "should hand defined indexes on a class down to its child classes" do
+      Child.indexes.should include(*Person.indexes)
+    end
+
+    it "should allow associations to other STI models" do
+      Child.indexes.last.link!
+      sql = Child.indexes.last.to_sql.gsub('$start', '0').gsub('$end', '100')
+      lambda { Child.connection.execute(sql) }.should_not raise_error(ActiveRecord::StatementInvalid)
+    end
+  end
+end

data/spec/unit/thinking_sphinx/index_spec.rb

@@ -207,7 +207,7 @@ describe ThinkingSphinx::Index do
     end
   end
   
-  describe "infix_fields" do
+  describe "infix_fields method" do
     before :each do
       @index = ThinkingSphinx::Index.new(Person)
       
@@ -227,4 +227,41 @@ describe ThinkingSphinx::Index do
       @index.infix_fields.should_not include(@field_b)
     end
   end
+  
+  describe "empty? method" do
+    before :each do
+      @index = ThinkingSphinx::Index.new(Person)
+      config = ThinkingSphinx::Configuration.new
+      
+      `mkdir -p #{config.searchd_file_path}`
+      @file_path = "#{config.searchd_file_path}/#{@index.name}_core.spa"
+    end
+    
+    after :each do
+      `rm #{@file_path}` if File.exists?(@file_path)
+    end
+    
+    it "should return true if the core index files are empty" do
+      `touch #{@file_path}`
+      @index.should be_empty
+    end
+    
+    it "should return true if the core index files don't exist" do
+      @index.should be_empty
+    end
+    
+    it "should return false if the core index files aren't empty" do
+      `echo 'a' > #{@file_path}`
+      @index.should_not be_empty
+    end
+    
+    it "should check the delta files if specified" do
+      @index.should be_empty(:delta)
+      
+      `echo 'a' > #{@file_path.gsub(/_core.spa$/, '_delta.spa')}`
+      @index.should_not be_empty(:delta)
+      
+      `rm #{@file_path}` if File.exists?(@file_path.gsub(/_core.spa$/, '_delta.spa'))
+    end
+  end
 end

data/spec/unit/thinking_sphinx/search_spec.rb

@@ -1,6 +1,10 @@
 require 'spec/spec_helper'
 
 describe ThinkingSphinx::Search do
+  describe "search method" do
+    it "should actually have some tests"
+  end
+  
   describe "search_for_id method" do
     before :each do
       @client = Riddle::Client.stub_instance(
@@ -82,10 +86,14 @@ describe ThinkingSphinx::Search do
       @person_b = Person.stub_instance
       @person_c = Person.stub_instance
 
+      @person_a.stub_method(:attributes => [])
+      @person_b.stub_method(:attributes => [])
+      @person_c.stub_method(:attributes => [])
+      
       @results = [
-        {:doc => @person_a.id},
-        {:doc => @person_b.id},
-        {:doc => @person_c.id}
+        {:doc => @person_a.id, :attributes => {'@geodist' => 10}},
+        {:doc => @person_b.id, :attributes => {'@geodist' => 10}},
+        {:doc => @person_c.id, :attributes => {'@geodist' => 10}}
       ]
       
       Person.stub_method(
@@ -105,13 +113,13 @@ describe ThinkingSphinx::Search do
       )
 
       ThinkingSphinx::Search.should have_received(:instance_from_result).with(
-        {:doc => @person_a.id}, {}
+        {:doc => @person_a.id, :attributes => {'@geodist' => 10}}, {}
       )
       ThinkingSphinx::Search.should have_received(:instance_from_result).with(
-        {:doc => @person_b.id}, {}
+        {:doc => @person_b.id, :attributes => {'@geodist' => 10}}, {}
       )
       ThinkingSphinx::Search.should have_received(:instance_from_result).with(
-        {:doc => @person_c.id}, {}
+        {:doc => @person_c.id, :attributes => {'@geodist' => 10}}, {}
       )
     end
 
@@ -159,5 +167,22 @@ describe ThinkingSphinx::Search do
         :instances_from_results, @results, {:select => :fields}, Person
       ).should == [@person_a, @person_b, @person_c]
     end
+    
+    it "should run the append distances function when distance_name is passed" do
+      ThinkingSphinx::Search.stub_method(:append_distances => @results)
+      
+      ThinkingSphinx::Search.send(
+        :instances_from_results, @results, {:distance_name => 'distance'}, Person
+      )
+      
+      Person.should have_received(:find).with(
+        :all,
+        :conditions => {:id => [@person_a.id, @person_b.id, @person_c.id]},
+        :include    => nil,
+        :select     => nil
+      )
+    end
+    
+    it "should have a test for the append_distances function"
   end
 end

data/spec/unit/thinking_sphinx_spec.rb

@@ -24,6 +24,7 @@ describe ThinkingSphinx do
   end
   
   it "should index deltas by default" do
+    ThinkingSphinx.deltas_enabled = nil
     ThinkingSphinx.deltas_enabled?.should be_true
   end
   
@@ -104,4 +105,4 @@ describe ThinkingSphinx do
       end
     end
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: DrMark-thinking-sphinx
 version: !ruby/object:Gem::Version 
-  version: 0.9.7
+  version: 0.9.8
 platform: ruby
 authors: 
 - Pat Allan
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-25 00:00:00 -07:00
+date: 2008-07-08 00:00:00 -07:00
 default_executable: 
 dependencies: []