friendlyfashion-thinking-sphinx 2.0.13

data/lib/thinking_sphinx/active_record/attribute_updates.rb

@@ -0,0 +1,53 @@
+module ThinkingSphinx
+  module ActiveRecord
+    module AttributeUpdates
+      def self.included(base)
+        base.class_eval do
+          after_save :update_attribute_values
+        end
+      end
+
+      private
+
+      def update_attribute_values
+        return true unless ThinkingSphinx.updates_enabled? &&
+          ThinkingSphinx.sphinx_running?
+
+        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]
+          }
+
+          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)
+        index.attributes.select { |attrib| attrib.updatable? }
+      end
+
+      def attribute_values_for_index(index)
+        updatable_attributes(index).inject({}) { |hash, attrib|
+          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
+        }
+      rescue Riddle::ConnectionError, Riddle::ResponseError,
+        ThinkingSphinx::SphinxError, Errno::ETIMEDOUT
+        # Not the end of the world if Sphinx isn't running.
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/active_record/collection_proxy.rb

@@ -0,0 +1,47 @@
+module ThinkingSphinx
+  module ActiveRecord
+    module CollectionProxy
+      def search(*args)
+        proxy_association.klass.search(*association_args(args))
+      end
+
+      def facets(*args)
+        proxy_association.klass.facets(*association_args(args))
+      end
+
+      private
+
+      def association_args(args)
+        options = args.extract_options!
+        options[:with] ||= {}
+        options[:with].merge! default_filter
+
+        args + [options]
+      end
+
+      def attribute_for_foreign_key
+        if proxy_association.reflection.through_reflection
+          foreign_key = proxy_association.reflection.through_reflection.foreign_key
+        else
+          foreign_key = proxy_association.reflection.foreign_key
+        end
+
+        proxy_association.klass.define_indexes
+        (proxy_association.klass.sphinx_indexes || []).each do |index|
+          attribute = index.attributes.detect { |attrib|
+            attrib.columns.length == 1 &&
+            attrib.columns.first.__name  == foreign_key.to_sym ||
+            attrib.alias == foreign_key.to_sym
+          }
+          return attribute unless attribute.nil?
+        end
+
+        raise "Missing Attribute for Foreign Key #{foreign_key}"
+      end
+
+      def default_filter
+        {attribute_for_foreign_key.unique_name => proxy_association.owner.id}
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/active_record/collection_proxy_with_scopes.rb

@@ -0,0 +1,27 @@
+module ThinkingSphinx
+  module ActiveRecord
+    module CollectionProxyWithScopes
+      def self.included(base)
+        base.class_eval do
+          alias_method_chain :method_missing, :sphinx_scopes
+          alias_method_chain :respond_to?, :sphinx_scopes
+        end
+      end
+
+      def method_missing_with_sphinx_scopes(method, *args, &block)
+        klass = proxy_association.klass
+        if klass.respond_to?(:sphinx_scopes) && klass.sphinx_scopes.include?(method)
+          klass.search(:with => default_filter).send(method, *args, &block)
+        else
+          method_missing_without_sphinx_scopes(method, *args, &block)
+        end
+      end
+
+      def respond_to_with_sphinx_scopes?(method)
+        proxy_association.klass.respond_to?(:sphinx_scopes) &&
+        proxy_association.klass.sphinx_scopes.include?(method) ||
+        respond_to_without_sphinx_scopes?(method)
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/active_record/delta.rb

@@ -0,0 +1,67 @@
+module ThinkingSphinx
+  module ActiveRecord
+    # This module contains all the delta-related code for models. There isn't
+    # really anything you need to call manually in here - except perhaps
+    # index_delta, but not sure what reason why.
+    #
+    module Delta
+      # Code for after_commit callback is written by Eli Miller:
+      # http://elimiller.blogspot.com/2007/06/proper-cache-expiry-with-aftercommit.html
+      # with slight modification from Joost Hietbrink.
+      #
+      def self.included(base)
+        base.class_eval do
+          class << self
+            # Build the delta index for the related model. This won't be called
+            # if running in the test environment.
+            #
+            def index_delta(instance = nil)
+              delta_objects.each { |obj| obj.index(self, instance) }
+            end
+
+            def delta_objects
+              self.sphinx_indexes.collect(&:delta_object).compact
+            end
+          end
+
+          def toggled_delta?
+            self.class.delta_objects.any? { |obj| obj.toggled(self) }
+          end
+
+          private
+
+          # Set the delta value for the model to be true.
+          def toggle_delta
+            self.class.delta_objects.each { |obj|
+              obj.toggle(self)
+            } if should_toggle_delta?
+          end
+
+          # Build the delta index for the related model. This won't be called
+          # if running in the test environment.
+          #
+          def index_delta
+            self.class.index_delta(self) if self.class.delta_objects.any? { |obj|
+              obj.toggled(self)
+            }
+          end
+
+          def should_toggle_delta?
+            return fire_delta? if respond_to?(:fire_delta?)
+
+            self.new_record? || indexed_data_changed?
+          end
+
+          def indexed_data_changed?
+            sphinx_indexes.any? { |index|
+              index.fields.any? { |field| field.changed?(self) } ||
+              index.attributes.any? { |attrib|
+                attrib.public? && attrib.changed?(self) && !attrib.updatable?
+              }
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/active_record/has_many_association.rb

@@ -0,0 +1,44 @@
+module ThinkingSphinx
+  module ActiveRecord
+    module HasManyAssociation
+      def search(*args)
+        @reflection.klass.search(*association_args(args))
+      end
+
+      def facets(*args)
+        @reflection.klass.facets(*association_args(args))
+      end
+
+      private
+
+      def association_args(args)
+        options = args.extract_options!
+        options[:with] ||= {}
+        options[:with].merge! default_filter
+
+        args + [options]
+      end
+
+      def attribute_for_foreign_key
+        foreign_key = @reflection.primary_key_name
+        stack = [@reflection.options[:through]].compact
+        
+        @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 ||
+            attrib.alias == foreign_key.to_sym
+          }
+          return attribute unless attribute.nil?
+        end
+        
+        raise "Missing Attribute for Foreign Key #{foreign_key}"
+      end
+      
+      def default_filter
+        {attribute_for_foreign_key.unique_name => @owner.id}
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/active_record/has_many_association_with_scopes.rb

@@ -0,0 +1,21 @@
+module ThinkingSphinx
+  module ActiveRecord
+    module HasManyAssociationWithScopes
+      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 responds_to_scope(scope)
+        @reflection.klass.respond_to?(:sphinx_scopes)   &&
+        @reflection.klass.sphinx_scopes.include?(scope)
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/active_record/log_subscriber.rb

@@ -0,0 +1,61 @@
+require 'active_support/log_subscriber'
+
+module ThinkingSphinx
+  module ActiveRecord
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      def self.runtime=(value)
+        Thread.current['thinking_sphinx_query_runtime'] = value
+      end
+
+      def self.runtime
+        Thread.current['thinking_sphinx_query_runtime'] ||= 0
+      end
+
+      def self.reset_runtime
+        rt, self.runtime = runtime, 0
+        rt
+      end
+
+      def initialize
+        super
+        @odd_or_even = false
+      end
+
+      def query(event)
+        self.class.runtime += event.duration
+        return unless logger.debug?
+
+        identifier = color('Sphinx Query (%.1fms)' % event.duration, GREEN, true)
+        query = event.payload[:query]
+        query = color query, nil, true if odd?
+
+        debug "  #{identifier}  #{query}"
+      end
+
+      def message(event)
+        return unless logger.debug?
+
+        identifier = color 'Sphinx', GREEN, true
+        message = event.payload[:message]
+        message = color message, nil, true if odd?
+
+        debug "  #{identifier}  #{message}"
+      end
+
+      def odd?
+        @odd_or_even = !@odd_or_even
+      end
+
+      def logger
+        return @logger if defined? @logger
+        self.logger = ::ActiveRecord::Base.logger
+      end
+
+      def logger=(logger)
+        @logger = logger
+      end
+
+      attach_to :thinking_sphinx
+    end
+  end
+end

data/lib/thinking_sphinx/active_record/scopes.rb

@@ -0,0 +1,110 @@
+module ThinkingSphinx
+  module ActiveRecord
+    module Scopes
+      def self.included(base)
+        base.class_eval do
+          extend ThinkingSphinx::ActiveRecord::Scopes::ClassMethods
+        end
+      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)
+          add_sphinx_scopes_support_to_has_many_associations
+          @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)
+          add_sphinx_scopes_support_to_has_many_associations
+
+          @sphinx_scopes ||= []
+          @sphinx_scopes << method
+          
+          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|
+            singleton_class.send(:undef_method, scope)
+          end
+          
+          sphinx_scopes.clear
+        end
+
+        def add_sphinx_scopes_support_to_has_many_associations
+          mixin = sphinx_scopes_support_mixin
+          sphinx_scopes_support_classes.each do |klass|
+            klass.send(:include, mixin) unless klass.ancestors.include?(mixin)
+          end
+        end
+
+        def sphinx_scopes_support_classes
+          if ThinkingSphinx.rails_3_1?
+            [::ActiveRecord::Associations::CollectionProxy]
+          else
+            [::ActiveRecord::Associations::HasManyAssociation,
+             ::ActiveRecord::Associations::HasManyThroughAssociation]
+          end
+        end
+
+        def sphinx_scopes_support_mixin
+          if ThinkingSphinx.rails_3_1?
+            ::ThinkingSphinx::ActiveRecord::CollectionProxyWithScopes
+          else
+            ::ThinkingSphinx::ActiveRecord::HasManyAssociationWithScopes
+          end
+        end
+
+      end
+    end
+  end
+end