thinking-sphinx 1.2.13 → 1.4.0

data/features/thinking_sphinx/models/alpha.rb

@@ -0,0 +1,23 @@
+class Alpha < ActiveRecord::Base
+  define_index do
+    indexes :name, :sortable => true
+    
+    has value, created_at, created_on
+    has cost, :facet => true
+    has active
+    
+    set_property :field_weights => {"name" => 10}
+  end
+  
+  define_index 'alternative' do
+    indexes :name, :as => :alternative_name, :sortable => true
+    
+    has value, created_at, created_on
+    has cost, :facet => true
+    has active
+    
+    set_property :field_weights => {'alternative_name' => 10}
+    
+    where "value > 3"
+  end
+end

data/features/thinking_sphinx/models/andrew.rb

@@ -0,0 +1,17 @@
+require "#{File.dirname(__FILE__)}/person"
+
+class Andrew < ActiveRecord::Base
+  set_table_name 'people'
+  
+  define_index do
+    indexes first_name, last_name, street_address
+  end
+  
+  sphinx_scope(:locked_first_name) {
+    {:conditions => {:first_name => 'Andrew'}}
+  }
+  sphinx_scope(:locked_last_name) {
+    {:conditions => {:last_name => 'Byrne'}}
+  }
+  default_sphinx_scope :locked_first_name
+end

data/features/{support → thinking_sphinx}/models/beta.rb

@@ -1,6 +1,6 @@
 class Beta < ActiveRecord::Base
   define_index do
-    indexes :name, :sortable => true
+    indexes :name, :sortable => true, :facet => true
     has value
     
     set_property :delta => true

data/features/{support → thinking_sphinx}/models/developer.rb

@@ -1,5 +1,5 @@
-require 'features/support/models/tag'
-require 'features/support/models/tagging'
+require "#{File.dirname(__FILE__)}/tag"
+require "#{File.dirname(__FILE__)}/tagging"
 
 class Developer < ActiveRecord::Base
   has_many :taggings, :as => :taggable

data/features/{support → thinking_sphinx}/models/extensible_beta.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), "..", "lib", "generic_delta_handler")
+require "#{Dir.pwd}/features/support/lib/generic_delta_handler"
 
 class ExtensibleBeta < ActiveRecord::Base
   define_index do

data/features/thinking_sphinx/models/fox.rb

@@ -0,0 +1,5 @@
+class Fox < Animal
+  define_index do
+    indexes :name
+  end
+end

data/features/thinking_sphinx/models/genre.rb

@@ -0,0 +1,3 @@
+class Genre < ActiveRecord::Base
+  #
+end

data/features/thinking_sphinx/models/medium.rb

@@ -0,0 +1,5 @@
+class Medium < ActiveRecord::Base
+  self.abstract_class = true
+  
+  belongs_to :genre
+end

data/features/thinking_sphinx/models/music.rb

@@ -0,0 +1,8 @@
+class Music < Medium
+  set_table_name 'music'
+  
+  define_index do
+    indexes artist, track, album
+    indexes genre(:name), :as => :genre
+  end
+end

data/features/{support → thinking_sphinx}/models/person.rb

@@ -1,6 +1,7 @@
 class Person < ActiveRecord::Base
   define_index do
-    indexes first_name, last_name, :sortable => true
+    indexes first_name, :sortable => true
+    indexes last_name,  :sortable => :insensitive
     
     has [first_name, middle_initial, last_name], :as => :name_sort
     has birthday

data/features/{support → thinking_sphinx}/models/post.rb

@@ -12,7 +12,8 @@ class Post < ActiveRecord::Base
     indexes comments.content, :as => :comments
     indexes authors.name, :as => :authors
     
-    has comments(:id), :as => :comment_ids, :source => :ranged_query
+    has comments(:id), :as => :comment_ids, :source => :ranged_query,
+      :facet => true
     has category.name, :facet => true, :as => :category_name, :type => :string
     has 'COUNT(DISTINCT comments.id)', :as => :comments_count, :type => :integer
     has comments.created_at, :as => :comments_created_at

data/lib/cucumber/thinking_sphinx/external_world.rb

@@ -0,0 +1,12 @@
+require 'thinking_sphinx/test'
+
+module Cucumber
+  module ThinkingSphinx
+    class ExternalWorld
+      def initialize(suppress_delta_output = true)
+        ::ThinkingSphinx::Test.init
+        ::ThinkingSphinx::Test.start_with_autostop
+      end
+    end
+  end
+end

data/lib/cucumber/thinking_sphinx/internal_world.rb

@@ -9,11 +9,12 @@ module Cucumber
         :password, :host
       
       def initialize
-        @temporary_directory  = "#{Dir.pwd}/tmp"
-        @migrations_directory = "features/support/db/migrations"
-        @models_directory     = "features/support/models"
-        @fixtures_directory   = "features/support/db/fixtures"
-        @database_file        = "features/support/database.yml"
+        pwd = Dir.pwd
+        @temporary_directory  = "#{pwd}/tmp"
+        @migrations_directory = "#{pwd}/features/thinking_sphinx/db/migrations"
+        @models_directory     = "#{pwd}/features/thinking_sphinx/models"
+        @fixtures_directory   = "#{pwd}/features/thinking_sphinx/db/fixtures"
+        @database_file        = "#{pwd}/features/thinking_sphinx/database.yml"
         
         @adapter  = ENV['DATABASE'] || 'mysql'
         @database = 'thinking_sphinx'
@@ -79,11 +80,11 @@ module Cucumber
       
       def database_settings
         {
-          :adapter  => @adapter,
-          :database => @database,
-          :username => @username,
-          :password => @password,
-          :host     => @host
+          'adapter'  => @adapter,
+          'database' => @database,
+          'username' => @username,
+          'password' => @password,
+          'host'     => @host
         }.merge yaml_database_settings
       end
       
@@ -108,7 +109,8 @@ module Cucumber
       end
       
       def load_files(path)
-        Dir["#{path}/*.rb"].each do |file|
+        files = Dir["#{path}/*.rb"].sort!
+        files.each do |file|
           require file.gsub(/\.rb$/, '')
         end
       end

data/lib/thinking_sphinx/active_record/attribute_updates.rb

@@ -10,22 +10,22 @@ 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
-        
-        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, {
-            sphinx_document_id => attribute_values
-          } if in_core_index?
+          update_index index.core_name, attribute_names, attribute_values
+          next unless index.delta?
+          update_index index.delta_name, attribute_names, attribute_values
         end
+        
+        true
       end
       
       def updatable_attributes(index)
@@ -34,15 +34,17 @@ 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
+      
+      def update_index(index_name, attribute_names, attribute_values)
+        config = ThinkingSphinx::Configuration.instance
+        config.client.update index_name, attribute_names, {
+          sphinx_document_id => attribute_values
+        } if self.class.search_for_id(sphinx_document_id, index_name)
+      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/has_many_association.rb

@@ -2,27 +2,50 @@ module ThinkingSphinx
   module ActiveRecord
     module HasManyAssociation
       def search(*args)
+        options   = args.extract_options!
+        options[:with] ||= {}
+        options[:with].merge! default_filter
+        
+        args << options
+        @reflection.klass.search(*args)
+      end
+      
+      def method_missing(method, *args, &block)
+        if responds_to_scope(method)
+          @reflection.klass.
+            search(:with => default_filter).
+            send(method, *args, &block)
+        else
+          super
+        end
+      end
+      
+      private
+      
+      def attribute_for_foreign_key
         foreign_key = @reflection.primary_key_name
         stack = [@reflection.options[:through]].compact
         
-        attribute   = nil
+        @reflection.klass.define_indexes
         (@reflection.klass.sphinx_indexes || []).each do |index|
           attribute = index.attributes.detect { |attrib|
             attrib.columns.length == 1 &&
             attrib.columns.first.__name  == foreign_key.to_sym
           }
-          break if attribute
+          return attribute unless attribute.nil?
         end
         
-        raise "Missing Attribute for Foreign Key #{foreign_key}" unless attribute
-        
-        options = args.extract_options!
-        options[:with] ||= {}
-        options[:with][attribute.unique_name] = @owner.id
-        
-        args << options
-        @reflection.klass.search(*args)
+        raise "Missing Attribute for Foreign Key #{foreign_key}"
+      end
+      
+      def default_filter
+        {attribute_for_foreign_key.unique_name => @owner.id}
+      end
+      
+      def responds_to_scope(scope)
+        @reflection.klass.respond_to?(:sphinx_scopes)   &&
+        @reflection.klass.sphinx_scopes.include?(scope)
       end
     end
   end
-end
+end

data/lib/thinking_sphinx/active_record/scopes.rb

@@ -8,27 +8,70 @@ 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
           
-          metaclass.instance_eval do
+          singleton_class.instance_eval do
             define_method(method) do |*args|
               options = {:classes => classes_option}
               options.merge! block.call(*args)
               
               ThinkingSphinx::Search.new(options)
             end
+            
+            define_method("#{method}_without_default".to_sym) do |*args|
+              options = {:classes => classes_option, :ignore_default => true}
+              options.merge! block.call(*args)
+              
+              ThinkingSphinx::Search.new(options)
+            end
           end
         end
-        
+
+        # This returns an Array of all defined scopes. The default
+        # scope shows as :default.
         def sphinx_scopes
           @sphinx_scopes || []
         end
         
         def remove_sphinx_scopes
           sphinx_scopes.each do |scope|
-            metaclass.send(:undef_method, scope)
+            singleton_class.send(:undef_method, scope)
           end
           
           sphinx_scopes.clear