kazjote-searchlogic 2.1.9.3 → 2.3.4

data/lib/searchlogic/named_scopes/association_ordering.rb

@@ -1,11 +1,27 @@
 module Searchlogic
   module NamedScopes
-    # Handles dynamically creating named scopes for associations.
+    # 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[:column], args)
+            create_association_ordering_condition(details[:association], details[:order_as], details[:condition], args)
             send(name, *args)
           else
             super
@@ -14,13 +30,13 @@ module Searchlogic
         
         def association_ordering_condition_details(name)
           associations = reflect_on_all_associations.collect { |assoc| assoc.name }
-          if !local_condition?(name) && name.to_s =~ /^(ascend|descend)_by_(#{associations.join("|")})_(\w+)$/
-            {:order_as => $1, :association => $2, :column => $3}
+          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_name, order_as, column, args)
-          named_scope("#{order_as}_by_#{association_name}_#{column}", association_condition_options(association_name, "#{order_as}_by_#{column}", args))
+        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

data/lib/searchlogic/named_scopes/conditions.rb

@@ -1,6 +1,13 @@
 module Searchlogic
   module NamedScopes
-    # Handles dynamically creating named scopes for columns.
+    # 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],
@@ -23,11 +30,14 @@ module Searchlogic
       BOOLEAN_CONDITIONS = {
         :null => [:nil],
         :not_null => [:not_nil],
-        :empty => []
+        :empty => [],
+        :blank => [],
+        :not_blank => [:present]
       }
 
       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 }
@@ -39,112 +49,48 @@ module Searchlogic
       PRIMARY_CONDITIONS = CONDITIONS.keys
       ALIAS_CONDITIONS = CONDITIONS.values.flatten
 
-      # 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, 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 : primary_condition_name(name)
-
-        if key
-          eval("options", scopes[key])
-        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.
-      def named_scope_arity(name)
-        options = named_scope_options(name)
-        options.respond_to?(:arity) ? options.arity : nil
-      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:
-      #
-      #   primary_condition_name(:id_gt) => :id_greater_than
-      #   primary_condition_name(:id_greater_than) => :id_greater_than
-      def primary_condition_name(name)
-        if primary_condition?(name)
-          name.to_sym
-        elsif details = alias_condition_details(name)
-          "#{details[:column]}_#{primary_condition(details[:condition])}".to_sym
-        else
-          nil
-        end
-      end
-
       # Is the name of the method a valid condition that can be dynamically created?
       def condition?(name)
         local_condition?(name)
       end
 
-      # Is the condition for a local column, not an association
-      def local_condition?(name)
-        primary_condition?(name) || alias_condition?(name)
-      end
-
-      # Is the name of the method a valid condition that can be dynamically created,
-      # AND is it a primary condition (not an alias). "greater_than" not "gt".
-      def primary_condition?(name)
-        !primary_condition_details(name).nil?
-      end
-
-      # Is the name of the method a valid condition that can be dynamically created,
-      # AND is it an alias condition. "gt" not "greater_than".
-      def alias_condition?(name)
-        !alias_condition_details(name).nil?
-      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?
+        end
+        
         def method_missing(name, *args, &block)
-          if details = primary_condition_details(name)
-            create_primary_condition(details[:column], details[:condition])
-            send(name, *args)
-          elsif details = alias_condition_details(name)
-            create_alias_condition(details[:column], details[:condition], args)
+          if details = condition_details(name)
+            create_condition(details[:column], details[:condition], args)
             send(name, *args)
           else
             super
           end
         end
 
-        def primary_condition_details(name)
-          if name.to_s =~ /^(#{column_names.join("|")})_(#{PRIMARY_CONDITIONS.join("|")})$/
+        def condition_details(name)
+          if 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"
+          match_keyword = ::ActiveRecord::Base.connection.adapter_name == "PostgreSQL" ? "ILIKE" : "LIKE"
+          
           scope_options = case condition.to_s
           when /^equals/
-            scope_options(condition, column_type, "#{table_name}.#{column} = ?")
+            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/
@@ -173,6 +119,10 @@ module Searchlogic
             {: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)
@@ -186,20 +136,22 @@ module Searchlogic
           when /_(any|all)$/
             searchlogic_lambda(column_type) { |*values|
               return {} if values.empty?
-              values = values.flatten
-
-              values_to_sub = nil
-              if value_modifier.nil?
-                values_to_sub = values
-              else
-                values_to_sub = values.collect { |value| value_with_modifier(value, value_modifier) }
-              end
+              values.flatten!
+              values.collect! { |value| value_with_modifier(value, value_modifier) }
 
               join = $1 == "any" ? " OR " : " AND "
-              {:conditions => [values.collect { |value| sql }.join(join), *values_to_sub]}
+              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) { |value| {:conditions => [sql, value_with_modifier(value, value_modifier)]} }
+            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
 
@@ -216,12 +168,6 @@ module Searchlogic
           end
         end
 
-        def alias_condition_details(name)
-          if name.to_s =~ /^(#{column_names.join("|")})_(#{ALIAS_CONDITIONS.join("|")})$/
-            {:column => $1, :condition => $2}
-          end
-        end
-
         def create_alias_condition(column, condition, args)
           primary_condition = primary_condition(condition)
           alias_name = "#{column}_#{condition}"
@@ -229,6 +175,31 @@ module Searchlogic
           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:
+        #
+        #   primary_condition_name(:id_gt) => :id_greater_than
+        #   primary_condition_name(:id_greater_than) => :id_greater_than
+        def primary_condition_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

data/lib/searchlogic/named_scopes/or_conditions.rb

@@ -0,0 +1,116 @@
+module Searchlogic
+  module NamedScopes
+    # Handles dynamically creating named scopes for 'OR' conditions. Please see the README for a more
+    # detailed explanation.
+    module OrConditions
+      class NoConditionSpecifiedError < StandardError; end
+      class UnknownConditionError < StandardError; end
+      
+      def condition?(name) # :nodoc:
+        super || or_condition?(name)
+      end
+      
+      private
+        def or_condition?(name)
+          !or_conditions(name).nil?
+        end
+        
+        def method_missing(name, *args, &block)
+          if conditions = or_conditions(name)
+            create_or_condition(conditions, args)
+            (class << self; self; end).class_eval { alias_method name, conditions.join("_or_") } if !respond_to?(name)
+            send(name, *args)
+          else
+            super
+          end
+        end
+        
+        def or_conditions(name)
+          # First determine if we should even work on the name, we want to be as quick as possible
+          # with this.
+          if (parts = split_or_condition(name)).size > 1
+            conditions = interpolate_or_conditions(parts)
+            if conditions.any?
+              conditions
+            else
+              nil
+            end
+          end
+        end
+        
+        def split_or_condition(name)
+          parts = name.to_s.split("_or_")
+          new_parts = []
+          parts.each do |part|
+            if part =~ /^equal_to(_any|_all)?$/
+              new_parts << new_parts.pop + "_or_equal_to"
+            else
+              new_parts << part
+            end
+          end
+          new_parts
+        end
+        
+        # The purpose of this method is to convert the method name parts into actual condition names.
+        #
+        # Example:
+        #
+        #   ["first_name", "last_name_like"]
+        #   => ["first_name_like", "last_name_like"]
+        #
+        #   ["id_gt", "first_name_begins_with", "last_name", "middle_name_like"]
+        #   => ["id_gt", "first_name_begins_with", "last_name_like", "middle_name_like"]
+        #
+        # Basically if a column is specified without a condition the next condition in the list
+        # is what will be used. Once we are able to get a consistent list of conditions we can easily
+        # create a scope for it.
+        def interpolate_or_conditions(parts)
+          conditions = []
+          last_condition = nil
+          
+          parts.reverse.each do |part|
+            if details = condition_details(part)
+              # We are a searchlogic defined scope
+              conditions << "#{details[:column]}_#{details[:condition]}"
+              last_condition = details[:condition]
+            elsif details = association_condition_details(part)
+              # pending, need to find the last condition
+            elsif local_condition?(part)
+              # We are a custom scope
+              conditions << part
+            elsif column_names.include?(part)
+              # we are a column, use the last condition
+              if last_condition.nil?
+                raise NoConditionSpecifiedError.new("The '#{part}' column doesn't know which condition to use, if you use an exact column " +
+                  "name you need to specify a condition sometime after (ex: id_or_created_at_lt), where id would use the 'lt' condition.")
+              end
+              
+              conditions << "#{part}_#{last_condition}"
+            else
+              raise UnknownConditionError.new("The condition '#{part}' is not a valid condition, we could not find any scopes that match this.")
+            end
+          end
+          
+          conditions
+        end
+        
+        def create_or_condition(scopes, args)
+          named_scope scopes.join("_or_"), lambda { |*args|
+            merge_scopes_with_or(scopes.collect { |scope| [scope, *args] })
+          }
+        end
+        
+        def merge_scopes_with_or(scopes)
+          scopes_options = scopes.collect { |scope, *args| send(scope, *args).proxy_options }
+          conditions = scopes_options.reject { |o| o[:conditions].nil? }.collect { |o| sanitize_sql(o[:conditions]) }
+          
+          scope = scopes.inject(scoped({})) do |scope, info|
+            scope_name, *args = info
+            scope.send(scope_name, *args)
+          end
+          
+          scope.scope(:find).merge(:conditions => "(" + conditions.join(") OR (") + ")")
+        end
+    end
+  end
+end

data/lib/searchlogic/named_scopes/ordering.rb

@@ -1,42 +1,37 @@
 module Searchlogic
   module NamedScopes
-    # Handles dynamically creating named scopes for orderin by columns.
+    # Handles dynamically creating named scopes for ordering by columns. Example:
+    #
+    #   User.ascend_by_id
+    #   User.descend_by_username
+    #
+    # See the README for a more detailed explanation.
     module Ordering
-      def local_condition?(name) # :nodoc:
-        super || order_condition?(name)
-      end
-      
-      def primary_condition_name(name) # :nodoc
-        if result = super
-          result
-        elsif order_condition?(name)
-          name.to_sym
-        else
-          nil
-        end
-      end
-      
-      def order_condition?(name) # :nodoc:
-        !order_condition_details(name).nil?
+      def condition?(name) # :nodoc:
+        super || ordering_condition?(name)
       end
       
       private
+        def ordering_condition?(name) # :nodoc:
+          !ordering_condition_details(name).nil?
+        end
+        
         def method_missing(name, *args, &block)
           if name == :order
             named_scope name, lambda { |scope_name|
-              return {} if !order_condition?(scope_name)
+              return {} if !condition?(scope_name)
               send(scope_name).proxy_options
             }
             send(name, *args)
-          elsif details = order_condition_details(name)
-            create_order_conditions(details[:column])
+          elsif details = ordering_condition_details(name)
+            create_ordering_conditions(details[:column])
             send(name, *args)
           else
             super
           end
         end
         
-        def order_condition_details(name)
+        def ordering_condition_details(name)
           if name.to_s =~ /^(ascend|descend)_by_(#{column_names.join("|")})$/
             {:order_as => $1, :column => $2}
           elsif name.to_s =~ /^order$/
@@ -44,7 +39,7 @@ module Searchlogic
           end
         end
         
-        def create_order_conditions(column)
+        def create_ordering_conditions(column)
           named_scope("ascend_by_#{column}".to_sym, {:order => "#{table_name}.#{column} ASC"})
           named_scope("descend_by_#{column}".to_sym, {:order => "#{table_name}.#{column} DESC"})
         end

data/lib/searchlogic/rails_helpers.rb

@@ -17,10 +17,14 @@ module Searchlogic
     # * <tt>:as</tt> - the text used in the link, defaults to whatever is passed to :by
     # * <tt>:ascend_scope</tt> - what scope to call for ascending the data, defaults to "ascend_by_:by"
     # * <tt>:descend_scope</tt> - what scope to call for descending the data, defaults to "descend_by_:by"
+    # * <tt>:params</tt> - hash with additional params which will be added to generated url
     # * <tt>:params_scope</tt> - the name of the params key to scope the order condition by, defaults to :search
     def order(search, options = {}, html_options = {})
       options[:params_scope] ||= :search
-      options[:as] ||= options[:by].to_s.humanize
+      if !options[:as]
+        id = options[:by].to_s.downcase == "id"
+        options[:as] = id ? options[:by].to_s.upcase : options[:by].to_s.humanize
+      end
       options[:ascend_scope] ||= "ascend_by_#{options[:by]}"
       options[:descend_scope] ||= "descend_by_#{options[:by]}"
       ascending = search.order.to_s == options[:ascend_scope]

data/lib/searchlogic/search.rb

@@ -17,7 +17,7 @@ module Searchlogic
   class Search
     # Responsible for adding a "search" method into your models.
     module Implementation
-      # Additional method, gets aliases as "search" if that method
+      # Additional method, gets aliased as "search" if that method
       # is available. A lot of other libraries like to use "search"
       # as well, so if you have a conflict like this, you can use
       # this method directly.
@@ -25,7 +25,7 @@ module Searchlogic
         Search.new(self, scope(:find), conditions)
       end
     end
-    
+
     # Is an invalid condition is used this error will be raised. Ex:
     #
     #   User.search(:unkown => true)
@@ -37,28 +37,32 @@ module Searchlogic
         super(msg)
       end
     end
-    
-    attr_accessor :klass, :current_scope, :conditions
+
+    attr_accessor :klass, :current_scope, :conditions, :default_order
     undef :id if respond_to?(:id)
-    
+
     # Creates a new search object for the given class. Ex:
     #
     #   Searchlogic::Search.new(User, {}, {:username_like => "bjohnson"})
     def initialize(klass, current_scope, conditions = {})
       self.klass = klass
-      self.current_scope = current_scope
+      if current_scope
+        current_scope = current_scope.dup
+        self.default_order = current_scope.delete(:order)
+        self.current_scope = current_scope
+      end
       self.conditions = conditions if conditions.is_a?(Hash)
     end
-    
+
     def clone
       self.class.new(klass, current_scope && current_scope.clone, conditions.clone)
     end
-    
+
     # Returns a hash of the current conditions set.
     def conditions
       @conditions ||= {}
     end
-    
+
     # Accepts a hash of conditions.
     def conditions=(values)
       values.each do |condition, value|
@@ -67,7 +71,7 @@ module Searchlogic
         send("#{condition}=", value)
       end
     end
-    
+
     # Delete a condition from the search. Since conditions map to named scopes,
     # if a named scope accepts a parameter there is no way to actually delete
     # the scope if you do not want it anymore. A nil value might be meaningful
@@ -76,23 +80,24 @@ module Searchlogic
       names.each { |name| @conditions.delete(name.to_sym) }
       self
     end
-    
+
     private
       def method_missing(name, *args, &block)
-        if name.to_s =~ /(\w+)=$/
-          condition = $1.to_sym
-          scope_name = normalize_scope_name($1)
+        condition_name = condition_name(name)
+        scope_name = scope_name(condition_name)
+
+        if setter?(name)
           if scope?(scope_name)
-            conditions[condition] = type_cast(args.first, cast_type(scope_name))
+            conditions[condition_name] = type_cast(args.first, cast_type(scope_name))
           else
-            raise UnknownConditionError.new(name)
+            raise UnknownConditionError.new(condition_name)
           end
-        elsif scope?(normalize_scope_name(name))
+        elsif scope?(scope_name)
           if args.size > 0
-            send("#{name}=", *args)
+            send("#{condition_name}=", *args)
             self
           else
-            conditions[name]
+            conditions[condition_name]
           end
         else
           scope = conditions.inject(klass.scoped(current_scope)) do |scope, condition|
@@ -100,7 +105,7 @@ module Searchlogic
             scope_name = normalize_scope_name(scope_name)
             klass.send(scope_name, value) if !klass.respond_to?(scope_name)
             arity = klass.named_scope_arity(scope_name)
-            
+
             if !arity || arity == 0
               if value == true
                 scope.send(scope_name)
@@ -111,18 +116,33 @@ module Searchlogic
               scope.send(scope_name, value)
             end
           end
+          scope = scope.scoped(:order => default_order) if
+            default_order && !scope.proxy_options.has_key?(:order)
           scope.send(name, *args, &block)
         end
       end
-      
+
       def normalize_scope_name(scope_name)
         klass.column_names.include?(scope_name.to_s) ? "#{scope_name}_equals".to_sym : scope_name.to_sym
       end
-      
+
+      def setter?(name)
+        !(name.to_s =~ /=$/).nil?
+      end
+
+      def condition_name(name)
+        condition = name.to_s.match(/(\w+)=?$/)[1]
+        condition ? condition.to_sym : nil
+      end
+
+      def scope_name(condition_name)
+        condition_name && normalize_scope_name(condition_name)
+      end
+
       def scope?(scope_name)
         klass.scopes.key?(scope_name) || klass.condition?(scope_name)
       end
-      
+
       def cast_type(name)
         klass.send(name, nil) if !klass.respond_to?(name) # We need to set up the named scope if it doesn't exist, so we can get a value for named_ssope_options
         named_scope_options = klass.named_scope_options(name)
@@ -133,7 +153,7 @@ module Searchlogic
           named_scope_options.respond_to?(:searchlogic_arg_type) ? named_scope_options.searchlogic_arg_type : :string
         end
       end
-      
+
       def type_cast(value, type)
         case value
         when Array
@@ -141,11 +161,12 @@ module Searchlogic
         else
           # Let's leverage ActiveRecord's type casting, so that casting is consistent
           # with the other models.
-          column_for_type_cast = ActiveRecord::ConnectionAdapters::Column.new("", nil)
+          column_for_type_cast = ::ActiveRecord::ConnectionAdapters::Column.new("", nil)
           column_for_type_cast.instance_variable_set(:@type, type)
           value = column_for_type_cast.type_cast(value)
           Time.zone && value.is_a?(Time) ? value.in_time_zone : value
         end
       end
   end
-end
+end
+