searchlogic-donotuse 2.3.9

data/lib/searchlogic/core_ext/object.rb

@@ -0,0 +1,41 @@
+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, &block)
+        proc = lambda(&block)
+        proc.searchlogic_arg_type = type
+        proc
+      end
+    end
+  end
+end

data/lib/searchlogic/core_ext/proc.rb

@@ -0,0 +1,11 @@
+module Searchlogic
+  module CoreExt
+    module Proc # :nodoc:
+      def self.included(klass)
+        klass.class_eval do
+          attr_accessor :searchlogic_arg_type
+        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:
+        @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,102 @@
+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)
+            send(name, *args)
+          else
+            super
+          end
+        end
+        
+        def association_condition_details(name, last_condition = nil)
+          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 assocs.empty?
+          
+          name_with_condition = [name, last_condition].compact.join('_')
+          if name_with_condition.to_s =~ /^(#{assocs.collect(&:name).join("|")})_(\w+)$/
+            association_name = $1
+            condition = $2
+            association = reflect_on_association(association_name.to_sym)
+            klass = association.klass
+            if klass.condition?(condition)
+              {:association => $1, :condition => $2}
+            else
+              nil
+            end
+          end
+        end
+        
+        def create_association_condition(association, condition, args)
+          named_scope("#{association}_#{condition}", association_condition_options(association, condition, args))
+        end
+        
+        def association_condition_options(association_name, association_condition, args)
+          association = reflect_on_association(association_name.to_sym)
+          scope = association.klass.send(association_condition, *args)
+          scope_options = association.klass.named_scope_options(association_condition)
+          arity = association.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 = scope.scope(:find)
+            prepare_named_scope_options(options, association)
+            options
+          else
+            proc_args = arity_args(arity)
+            arg_type = (scope_options.respond_to?(:searchlogic_arg_type) && scope_options.searchlogic_arg_type) || :string
+            
+            eval <<-"end_eval"
+              searchlogic_lambda(:#{arg_type}) { |#{proc_args.join(",")}|
+                scope = association.klass.send(association_condition, #{proc_args.join(",")})
+                options = scope ? scope.scope(:find) : {}
+                prepare_named_scope_options(options, association)
+                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)
+          options.delete(:readonly) # AR likes to set :readonly to true when using the :joins option, we don't want that
+          
+          if options[:joins].is_a?(String) || array_of_strings?(options[:joins])
+            options[:joins] = [inner_joins(association.name), options[:joins]].flatten
+          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,43 @@
+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.collect { |assoc| assoc.name }
+          if name.to_s =~ /^(ascend|descend)_by_(#{associations.join("|")})_(\w+)$/
+            {:order_as => $1, :association => $2, :condition => $3}
+          end
+        end
+        
+        def create_association_ordering_condition(association, order_as, condition, args)
+          named_scope("#{order_as}_by_#{association}_#{condition}", association_condition_options(association, "#{order_as}_by_#{condition}", args))
+        end
+    end
+  end
+end

data/lib/searchlogic/named_scopes/conditions.rb

@@ -0,0 +1,229 @@
+module Searchlogic
+  module NamedScopes
+    # Handles dynamically creating named scopes for columns. It allows you to do things like:
+    #
+    #   User.first_name_like("ben")
+    #   User.id_lt(10)
+    #
+    # Notice the constants in this class, they define which conditions Searchlogic provides.
+    #
+    # See the README for a more detailed explanation.
+    module Conditions
+      COMPARISON_CONDITIONS = {
+        :equals => [:is, :eq],
+        :does_not_equal => [:not_equal_to, :is_not, :not, :ne],
+        :less_than => [:lt, :before],
+        :less_than_or_equal_to => [:lte],
+        :greater_than => [:gt, :after],
+        :greater_than_or_equal_to => [:gte],
+      }
+      
+      WILDCARD_CONDITIONS = {
+        :like => [:contains, :includes],
+        :not_like => [],
+        :begins_with => [:bw],
+        :not_begin_with => [:does_not_begin_with],
+        :ends_with => [:ew],
+        :not_end_with => [:does_not_end_with]
+      }
+      
+      BOOLEAN_CONDITIONS = {
+        :null => [:nil],
+        :not_null => [:not_nil],
+        :empty => [],
+        :blank => [],
+        :not_blank => [:present]
+      }
+      
+      GROUP_CONDITIONS = {
+        :in => [],
+        :not_in => []
+      }
+      
+      CONDITIONS = {}
+      
+      # Add any / all variations to every comparison and wildcard condition
+      COMPARISON_CONDITIONS.merge(WILDCARD_CONDITIONS).each do |condition, aliases|
+        CONDITIONS[condition] = aliases
+        CONDITIONS["#{condition}_any".to_sym] = aliases.collect { |a| "#{a}_any".to_sym }
+        CONDITIONS["#{condition}_all".to_sym] = aliases.collect { |a| "#{a}_all".to_sym }
+      end
+      
+      CONDITIONS[:equals_any] = CONDITIONS[:equals_any] + [:in]
+      CONDITIONS[:does_not_equal_any] = CONDITIONS[:equals_any] + [:not_in]
+      
+      BOOLEAN_CONDITIONS.each { |condition, aliases| CONDITIONS[condition] = aliases }
+      
+      GROUP_CONDITIONS.each { |condition, aliases| CONDITIONS[condition] = aliases }
+      
+      PRIMARY_CONDITIONS = CONDITIONS.keys
+      ALIAS_CONDITIONS = CONDITIONS.values.flatten
+      
+      # Is the name of the method a valid condition that can be dynamically created?
+      def condition?(name)
+        local_condition?(name)
+      end
+      
+      private
+        def local_condition?(name)
+          return false if name.blank?
+          scope_names = scopes.keys.reject { |k| k == :scoped }
+          scope_names.include?(name.to_sym) || !condition_details(name).nil? || boolean_condition?(name)
+        end
+        
+        def boolean_condition?(name)
+          column = columns_hash[name.to_s] || columns_hash[name.to_s.gsub(/^not_/, "")]
+          column && column.type == :boolean
+        end
+        
+        def method_missing(name, *args, &block)
+          if details = condition_details(name)
+            create_condition(details[:column], details[:condition], args)
+            send(name, *args)
+          elsif boolean_condition?(name)
+            column = name.to_s.gsub(/^not_/, "")
+            named_scope name, :conditions => {column => (name.to_s =~ /^not_/).nil?}
+            send(name)
+          else
+            super
+          end
+        end
+        
+        def condition_details(name, *args)
+          if args.size > 0 and !args.first.nil?
+            assoc = reflect_on_association(args.first.to_sym)
+            klass = assoc.klass
+            name.to_s =~ /^(#{klass.column_names.join("|")})_(#{(PRIMARY_CONDITIONS + ALIAS_CONDITIONS).join("|")})$/
+            {:column => $1, :condition => $2}
+          elsif name.to_s =~ /^(#{column_names.join("|")})_(#{(PRIMARY_CONDITIONS + ALIAS_CONDITIONS).join("|")})$/
+            {:column => $1, :condition => $2}
+          end
+        end
+        
+        def create_condition(column, condition, args)
+          if PRIMARY_CONDITIONS.include?(condition.to_sym)
+            create_primary_condition(column, condition)
+          elsif ALIAS_CONDITIONS.include?(condition.to_sym)
+            create_alias_condition(column, condition, args)
+          end
+        end
+        
+        def create_primary_condition(column, condition)
+          column_type = columns_hash[column.to_s].type
+          match_keyword = ::ActiveRecord::Base.connection.adapter_name == "PostgreSQL" ? "ILIKE" : "LIKE"
+          
+          scope_options = case condition.to_s
+          when /^equals/
+            scope_options(condition, column_type, lambda { |a| attribute_condition("#{table_name}.#{column}", a) })
+          when /^does_not_equal/
+            scope_options(condition, column_type, "#{table_name}.#{column} != ?")
+          when /^less_than_or_equal_to/
+            scope_options(condition, column_type, "#{table_name}.#{column} <= ?")
+          when /^less_than/
+            scope_options(condition, column_type, "#{table_name}.#{column} < ?")
+          when /^greater_than_or_equal_to/
+            scope_options(condition, column_type, "#{table_name}.#{column} >= ?")
+          when /^greater_than/
+            scope_options(condition, column_type, "#{table_name}.#{column} > ?")
+          when /^like/
+            scope_options(condition, column_type, "#{table_name}.#{column} #{match_keyword} ?", :like)
+          when /^not_like/
+            scope_options(condition, column_type, "#{table_name}.#{column} NOT #{match_keyword} ?", :like)
+          when /^begins_with/
+            scope_options(condition, column_type, "#{table_name}.#{column} #{match_keyword} ?", :begins_with)
+          when /^not_begin_with/
+            scope_options(condition, column_type, "#{table_name}.#{column} NOT #{match_keyword} ?", :begins_with)
+          when /^ends_with/
+            scope_options(condition, column_type, "#{table_name}.#{column} #{match_keyword} ?", :ends_with)
+          when /^not_end_with/
+            scope_options(condition, column_type, "#{table_name}.#{column} NOT #{match_keyword} ?", :ends_with)
+          when "null"
+            {:conditions => "#{table_name}.#{column} IS NULL"}
+          when "not_null"
+            {:conditions => "#{table_name}.#{column} IS NOT NULL"}
+          when "empty"
+            {:conditions => "#{table_name}.#{column} = ''"}
+          when "blank"
+            {:conditions => "#{table_name}.#{column} = '' OR #{table_name}.#{column} IS NULL"}
+          when "not_blank"
+            {:conditions => "#{table_name}.#{column} != '' AND #{table_name}.#{column} IS NOT NULL"}
+          end
+          
+          named_scope("#{column}_#{condition}".to_sym, scope_options)
+        end
+        
+        # This method helps cut down on defining scope options for conditions that allow *_any or *_all conditions.
+        # Kepp in mind that the lambdas get cached in a method, so you want to keep the contents of the lambdas as
+        # fast as possible, which is why I didn't do the case statement inside of the lambda.
+        def scope_options(condition, column_type, sql, value_modifier = nil)
+          case condition.to_s
+          when /_(any|all)$/
+            searchlogic_lambda(column_type) { |*values|
+              return {} if values.empty?
+              values.flatten!
+              values.collect! { |value| value_with_modifier(value, value_modifier) }
+              
+              join = $1 == "any" ? " OR " : " AND "
+              scope_sql = values.collect { |value| sql.is_a?(Proc) ? sql.call(value) : sql }.join(join)
+              
+              {:conditions => [scope_sql, *expand_range_bind_variables(values)]}
+            }
+          else
+            searchlogic_lambda(column_type) { |*values|
+              values.collect! { |value| value_with_modifier(value, value_modifier) }
+              
+              scope_sql = sql.is_a?(Proc) ? sql.call(*values) : sql
+              
+              {:conditions => [scope_sql, *expand_range_bind_variables(values)]}
+            }
+          end
+        end
+        
+        def value_with_modifier(value, modifier)
+          case modifier
+          when :like
+            "%#{value}%"
+          when :begins_with
+            "#{value}%"
+          when :ends_with
+            "%#{value}"
+          else
+            value
+          end
+        end
+        
+        def create_alias_condition(column, condition, args)
+          primary_condition = primary_condition(condition)
+          alias_name = "#{column}_#{condition}"
+          primary_name = "#{column}_#{primary_condition}"
+          send(primary_name, *args) # go back to method_missing and make sure we create the method
+          (class << self; self; end).class_eval { alias_method alias_name, primary_name }
+        end
+        
+        # Returns the primary condition for the given alias. Ex:
+        #
+        #   primary_condition(:gt) => :greater_than
+        def primary_condition(alias_condition)
+          CONDITIONS.find { |k, v| k == alias_condition.to_sym || v.include?(alias_condition.to_sym) }.first
+        end
+
+        # Returns the primary name for any condition on a column. You can pass it
+        # a primary condition, alias condition, etc, and it will return the proper
+        # primary condition name. This helps simply logic throughout Searchlogic. Ex:
+        #
+        #   condition_scope_name(:id_gt) => :id_greater_than
+        #   condition_scope_name(:id_greater_than) => :id_greater_than
+        def condition_scope_name(name)
+          if details = condition_details(name)
+            if PRIMARY_CONDITIONS.include?(name.to_sym)
+              name
+            else
+              "#{details[:column]}_#{primary_condition(details[:condition])}".to_sym
+            end
+          else
+            nil
+          end
+        end
+    end
+  end
+end