obitum-searchlogic 2.4.28

data/lib/searchlogic/active_record/consistency.rb

@@ -0,0 +1,49 @@
+module Searchlogic
+  module ActiveRecord
+    # Active Record is pretty inconsistent with how their SQL is constructed. This
+    # method attempts to close the gap between the various inconsistencies.
+    module Consistency
+      def self.included(klass)
+        klass.class_eval do
+          alias_method_chain :merge_joins, :singularity
+          alias_method_chain :merge_joins, :consistent_conditions
+          alias_method_chain :merge_joins, :merged_duplicates
+        end
+      end
+      
+      # In AR multiple joins are sometimes in a single join query, and other times they
+      # are not. The merge_joins method in AR should account for this, but it doesn't.
+      # This fixes that problem. This way there is one join per string, which allows
+      # the merge_joins method to delete duplicates.
+      def merge_joins_with_singularity(*args)
+        joins = merge_joins_without_singularity(*args)
+        joins.collect { |j| j.is_a?(String) ? j.split("  ") : j }.flatten.uniq
+      end
+      
+      # This method ensures that the order of the conditions in the joins are the same.
+      # The strings of the joins MUST be exactly the same for AR to remove the duplicates.
+      # AR is not consistent in this approach, resulting in duplicate joins errors when
+      # combining scopes.
+      def merge_joins_with_consistent_conditions(*args)
+        joins = merge_joins_without_consistent_conditions(*args)
+        joins.collect do |j|
+          if j.is_a?(String) && (j =~ / (AND|OR) /i).nil?
+            j.gsub(/(.*) ON (.*) = (.*)/) do |m|
+              join, cond1, cond2 = $1, $2, $3
+              sorted = [cond1.gsub(/\(|\)/, ""), cond2.gsub(/\(|\)/, "")].sort
+              "#{join} ON #{sorted[0]} = #{sorted[1]}"
+            end
+          else
+            j
+          end
+        end.uniq
+      end
+      
+      
+      def merge_joins_with_merged_duplicates(*args)
+        args << "" if !Thread.current["searchlogic_delegation"]
+        joins = merge_joins_without_merged_duplicates(*args)
+      end
+    end
+  end
+end

data/lib/searchlogic/active_record/named_scope_tools.rb

@@ -0,0 +1,101 @@
+module Searchlogic
+  module ActiveRecord
+    # Adds methods that give extra information about a classes named scopes.
+    module NamedScopeTools
+      # Retrieves the options passed when creating the respective named scope. Ex:
+      #
+      #   named_scope :whatever, :conditions => {:column => value}
+      #
+      # This method will return:
+      #
+      #   :conditions => {:column => value}
+      #
+      # ActiveRecord hides this internally in a Proc, so we have to try and pull it out with this
+      # method.
+      def named_scope_options(name)
+        key = scopes.key?(name.to_sym) ? name.to_sym : condition_scope_name(name)
+        
+        if key
+          eval("options", scopes[key].binding)
+        else
+          nil
+        end
+      end
+      
+      # The arity for a named scope's proc is important, because we use the arity
+      # to determine if the condition should be ignored when calling the search method.
+      # If the condition is false and the arity is 0, then we skip it all together. Ex:
+      #
+      #   User.named_scope :age_is_4, :conditions => {:age => 4}
+      #   User.search(:age_is_4 => false) == User.all
+      #   User.search(:age_is_4 => true) == User.all(:conditions => {:age => 4})
+      #
+      # We also use it when trying to "copy" the underlying named scope for association
+      # conditions. This way our aliased scope accepts the same number of parameters for
+      # the underlying scope.
+      def named_scope_arity(name)
+        options = named_scope_options(name)
+        options.respond_to?(:arity) ? options.arity : nil
+      end
+      
+      # When searchlogic calls a named_scope on a foreigh model it will execute that scope and then call scope(:find).
+      # When we get these options we want this to be in an exclusive scope, especially if we are calling a condition on
+      # the same originating model:
+      #
+      #   Company.users_company_name_equals("name")
+      #
+      # If we aren't in an exclusive scope we will get unexpected results for the :joins option. Lastly, we want the named_scopes
+      # generated by searchlogic to be symbols whenever possible. The reason for this is so that we can allow
+      # ActiveRecord to leverage its joins library that automatically aliases joins if they appear more than once in a query.
+      # If the joins are strings, AtiveRecord can't do anything. Because the code that does this in ActiveRecord is pretty bad
+      # when it comes to being consisitent, searchlogic had to fix this in Searchloigc::ActiveRecord::Consistency. That said,
+      # part of this fix is to normalize joins into strings. We do not want to do this if we are calling scopes on foreigh models.
+      # Only when we are performing an action on it. This is what the searchlogic_delegation thread variable is all about. A
+      # flag to let search logic know not to convert joins to strings.
+      def in_searchlogic_delegation(&block)
+        old = Thread.current["searchlogic_delegation"]
+        Thread.current["searchlogic_delegation"] = true
+        with_exclusive_scope(&block)
+        Thread.current["searchlogic_delegation"] = old
+      end
+      
+      # A convenience method for creating inner join sql to that your inner joins
+      # are consistent with how Active Record creates them. Basically a tool for
+      # you to use when writing your own named scopes. This way you know for sure
+      # that duplicate joins will be removed when chaining scopes together that
+      # use the same join.
+      #
+      # Also, don't worry about breaking up the joins or retriving multiple joins.
+      # ActiveRecord will remove dupilicate joins and Searchlogic assists ActiveRecord in
+      # breaking up your joins so that they are unique.
+      def inner_joins(association_name)
+        ::ActiveRecord::Associations::ClassMethods::InnerJoinDependency.new(self, association_name, nil).join_associations.collect { |assoc| assoc.association_join }
+      end
+      
+      # A convenience methods to create a join on a polymorphic associations target.
+      # Ex:
+      #
+      # Audit.belong_to :auditable, :polymorphic => true
+      # User.has_many :audits, :as => :auditable
+      #
+      # Audit.inner_polymorphic_join(:user, :as => :auditable) # =>
+      #   "INNER JOINER users ON users.id = audits.auditable_id AND audits.auditable_type = 'User'"
+      #
+      # This is used internally by searchlogic to handle accessing conditions on polymorphic associations.
+      def inner_polymorphic_join(target, options = {})
+        options[:on] ||= table_name
+        options[:on_table_name] ||= connection.quote_table_name(options[:on])
+        options[:target_table] ||= connection.quote_table_name(target.to_s.pluralize)
+        options[:as] ||= "owner"
+        postgres = ::ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+        "INNER JOIN #{options[:target_table]} ON #{options[:target_table]}.id = #{options[:on_table_name]}.#{options[:as]}_id AND " +
+          "#{options[:on_table_name]}.#{options[:as]}_type = #{postgres ? "E" : ""}'#{target.to_s.camelize}'"
+      end
+      
+      # See inner_joins. Does the same thing except creates LEFT OUTER joins.
+      def left_outer_joins(association_name)
+        ::ActiveRecord::Associations::ClassMethods::JoinDependency.new(self, association_name, nil).join_associations.collect { |assoc| assoc.association_join }
+      end
+    end
+  end
+end

data/lib/searchlogic/core_ext/object.rb

@@ -0,0 +1,43 @@
+module Searchlogic
+  module CoreExt
+    # Contains extensions for the Object class that Searchlogic uses.
+    module Object
+      # Searchlogic needs to know the expected type of the condition value so that it can properly cast
+      # the value in the Searchlogic::Search object. For example:
+      #
+      #   search = User.search(:id_gt => "1")
+      #
+      # You would expect this:
+      #
+      #   search.id_gt => 1
+      #
+      # Not this:
+      #
+      #   search.id_gt => "1"
+      #
+      # Parameter values from forms are ALWAYS strings, so we have to cast them. Just like ActiveRecord
+      # does when you instantiate a new User object.
+      #
+      # The problem is that ruby has no variable types, so Searchlogic needs to know what type you are expecting
+      # for your named scope. So instead of this:
+      #
+      #   named_scope :id_gt, lambda { |value| {:conditions => ["id > ?", value]} }
+      #
+      # You need to do this:
+      #
+      #   named_scope :id_gt, searchlogic_lambda(:integer) { |value| {:conditions => ["id > ?", value]} }
+      #
+      # If you are wanting a string, you don't have to do anything, because Searchlogic assumes you want a string.
+      # If you want something else, you need to specify it as I did in the above example. Comments are appreciated
+      # on this, if you know of a better solution please let me know. But this is the best I could come up with,
+      # without being intrusive and altering default behavior.
+      def searchlogic_lambda(type = :string, options = {}, &block)
+        proc = lambda(&block)
+        proc.searchlogic_options ||= {}
+        proc.searchlogic_options[:type] = type
+        proc.searchlogic_options.merge!(options)
+        proc
+      end
+    end
+  end
+end

data/lib/searchlogic/core_ext/proc.rb

@@ -0,0 +1,17 @@
+module Searchlogic
+  module CoreExt
+    module Proc # :nodoc:
+      def self.included(klass)
+        klass.class_eval do
+          attr_accessor :searchlogic_options
+          
+          def searchlogic_options
+            @searchlogic_options ||= {}
+            @searchlogic_options[:type] ||= :string
+            @searchlogic_options
+          end
+        end
+      end
+    end
+  end
+end

data/lib/searchlogic/named_scopes/alias_scope.rb

@@ -0,0 +1,67 @@
+module Searchlogic
+  module NamedScopes
+    # Adds the ability to create alias scopes that allow you to alias a named
+    # scope or create a named scope procedure. See the alias_scope method for a more
+    # detailed explanation.
+    module AliasScope
+      # In some instances you might create a class method that essentially aliases a named scope
+      # or represents a named scope procedure. Ex:
+      #
+      #   class User
+      #     def teenager
+      #       age_gte(13).age_lte(19)
+      #     end
+      #   end
+      #
+      # This is obviously a very basic example, but notice how we are utilizing already existing named
+      # scopes so that we do not have to repeat ourself. This method makes a lot more sense when you are
+      # dealing with complicated named scope.
+      #
+      # There is a problem though. What if you want to use this in your controller's via the 'search' method:
+      #
+      #   User.search(:teenager => true)
+      #
+      # You would expect that to work, but how does Searchlogic::Search tell the difference between your
+      # 'teenager' method and the 'destroy_all' method. It can't, there is no way to tell unless we actually
+      # call the method, which we obviously can not do.
+      #
+      # The being said, we need a way to tell searchlogic that this is method is safe. Here's how you do that:
+      #
+      #   User.alias_scope :teenager, lambda { age_gte(13).age_lte(19) }
+      #
+      # This feels better, it feels like our other scopes, and it provides a way to tell Searchlogic that this
+      # is a safe method.
+      def alias_scope(name, options = nil)
+        alias_scopes[name.to_sym] = options
+        (class << self; self end).instance_eval do
+          define_method name do |*args|
+            case options
+            when Symbol
+              send(options)
+            else
+              options.call(*args)
+            end
+          end
+        end
+      end
+      alias_method :scope_procedure, :alias_scope
+      
+      def alias_scopes # :nodoc:
+        read_inheritable_attribute(:alias_scopes) || write_inheritable_attribute(:alias_scopes, {})
+      end
+      
+      def alias_scope?(name) # :nodoc:
+        return false if name.blank?
+        alias_scopes.key?(name.to_sym)
+      end
+      
+      def condition?(name) # :nodoc:
+        super || alias_scope?(name)
+      end
+      
+      def named_scope_options(name) # :nodoc:
+        super || alias_scopes[name.to_sym]
+      end
+    end
+  end
+end

data/lib/searchlogic/named_scopes/association_conditions.rb

@@ -0,0 +1,132 @@
+module Searchlogic
+  module NamedScopes
+    # Handles dynamically creating named scopes for associations. See the README for a detailed explanation.
+    module AssociationConditions
+      def condition?(name) # :nodoc:
+        super || association_condition?(name)
+      end
+      
+      private
+        def association_condition?(name)
+          !association_condition_details(name).nil? unless name.to_s.downcase.match("_or_")
+        end
+        
+        def method_missing(name, *args, &block)
+          if !local_condition?(name) && details = association_condition_details(name)
+            create_association_condition(details[:association], details[:condition], args, details[:poly_class])
+            send(name, *args)
+          else
+            super
+          end
+        end
+        
+        def association_condition_details(name, last_condition = nil)
+          non_poly_assocs = reflect_on_all_associations.reject { |assoc| assoc.options[:polymorphic] }.sort { |a, b| b.name.to_s.size <=> a.name.to_s.size }
+          poly_assocs = reflect_on_all_associations.reject { |assoc| !assoc.options[:polymorphic] }.sort { |a, b| b.name.to_s.size <=> a.name.to_s.size }
+          return nil if non_poly_assocs.empty? && poly_assocs.empty?
+        
+          name_with_condition = [name, last_condition].compact.join('_')
+          
+          association_name = nil
+          poly_type = nil
+          condition = nil
+          
+          if name_with_condition.to_s =~ /^(#{non_poly_assocs.collect(&:name).join("|")})_(\w+)$/
+            association_name = $1
+            condition = $2
+          elsif name_with_condition.to_s =~ /^(#{poly_assocs.collect(&:name).join("|")})_(\w+?)_type_(\w+)$/
+            association_name = $1
+            poly_type = $2
+            condition = $3
+          end
+          
+          if association_name && condition
+            association = reflect_on_association(association_name.to_sym)
+            klass = poly_type ? poly_type.camelcase.constantize : association.klass
+            if klass.condition?(condition)
+              {:association => association, :poly_class => poly_type && klass, :condition => condition}
+            else
+              nil
+            end
+          end
+        end
+        
+        def create_association_condition(association, condition_name, args, poly_class = nil)
+          name = [association.name, poly_class && "#{poly_class.name.underscore}_type", condition_name].compact.join("_")
+          named_scope(name, association_condition_options(association, condition_name, args, poly_class))
+        end
+        
+        def association_condition_options(association, association_condition, args, poly_class = nil)
+          klass = poly_class ? poly_class : association.klass
+          scope = klass.send(association_condition, *args)
+          scope_options = klass.named_scope_options(association_condition)
+          arity = klass.named_scope_arity(association_condition)
+          
+          if !arity || arity == 0
+            # The underlying condition doesn't require any parameters, so let's just create a simple
+            # named scope that is based on a hash.
+            options = {}
+            in_searchlogic_delegation { options = scope.scope(:find) }
+            prepare_named_scope_options(options, association, poly_class)
+            options
+          else
+            proc_args = arity_args(arity)
+            scope_options = scope_options.respond_to?(:searchlogic_options) ? scope_options.searchlogic_options.clone : {}
+            arg_type = scope_options.delete(:type) || :string
+            
+            eval <<-"end_eval"
+              searchlogic_lambda(:#{arg_type}, #{scope_options.inspect}) { |#{proc_args.join(",")}|
+                options = {}
+                
+                in_searchlogic_delegation do
+                  scope = klass.send(association_condition, #{proc_args.join(",")})
+                  options = scope.scope(:find) if scope
+                end
+                
+                
+                prepare_named_scope_options(options, association, poly_class)
+                options
+              }
+            end_eval
+          end
+        end
+        
+        # Used to match the new scopes parameters to the underlying scope. This way we can disguise the
+        # new scope as best as possible instead of taking the easy way out and using *args.
+        def arity_args(arity)
+          args = []
+          if arity > 0
+            arity.times { |i| args << "arg#{i}" }
+          else
+            positive_arity = arity * -1
+            positive_arity.times do |i|
+              if i == (positive_arity - 1)
+                args << "*arg#{i}"
+              else
+                args << "arg#{i}"
+              end
+            end
+          end
+          args
+        end
+        
+        def prepare_named_scope_options(options, association, poly_class = nil)
+          options.delete(:readonly) # AR likes to set :readonly to true when using the :joins option, we don't want that
+          
+          klass = poly_class || association.klass
+          # sanitize the conditions locally so we get the right table name, otherwise the conditions will be evaluated on the original model
+          options[:conditions] = klass.sanitize_sql_for_conditions(options[:conditions]) if options[:conditions].is_a?(Hash)
+          
+          poly_join = poly_class && inner_polymorphic_join(poly_class.name.underscore, :as => association.name)
+          
+          if options[:joins].is_a?(String) || array_of_strings?(options[:joins])
+            options[:joins] = [poly_class ? poly_join : inner_joins(association.name), options[:joins]].flatten
+          elsif poly_class
+            options[:joins] = options[:joins].blank? ? poly_join : ([poly_join] + klass.inner_joins(options[:joins]))
+          else
+            options[:joins] = options[:joins].blank? ? association.name : {association.name => options[:joins]}
+          end
+        end
+    end
+  end
+end

data/lib/searchlogic/named_scopes/association_ordering.rb

@@ -0,0 +1,44 @@
+module Searchlogic
+  module NamedScopes
+    # Handles dynamically creating order named scopes for associations:
+    #
+    #   User.has_many :orders
+    #   Order.has_many :line_items
+    #   LineItem
+    #
+    #   User.ascend_by_orders_line_items_id
+    #
+    # See the README for a more detailed explanation.
+    module AssociationOrdering
+      def condition?(name) # :nodoc:
+        super || association_ordering_condition?(name)
+      end
+      
+      private
+        def association_ordering_condition?(name)
+          !association_ordering_condition_details(name).nil?
+        end
+        
+        def method_missing(name, *args, &block)
+          if details = association_ordering_condition_details(name)
+            create_association_ordering_condition(details[:association], details[:order_as], details[:condition], args)
+            send(name, *args)
+          else
+            super
+          end
+        end
+        
+        def association_ordering_condition_details(name)
+          associations = reflect_on_all_associations
+          association_names = associations.collect { |assoc| assoc.name }
+          if name.to_s =~ /^(ascend|descend)_by_(#{association_names.join("|")})_(\w+)$/
+            {:order_as => $1, :association => associations.find { |a| a.name == $2.to_sym }, :condition => $3}
+          end
+        end
+        
+        def create_association_ordering_condition(association, order_as, condition, args)
+          named_scope("#{order_as}_by_#{association.name}_#{condition}", association_condition_options(association, "#{order_as}_by_#{condition}", args))
+        end
+    end
+  end
+end