yoomee-searchlogic 2.4.27

data/lib/searchlogic/named_scopes/conditions.rb

@@ -0,0 +1,232 @@
+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],
+        :between => [:is_between, :in_range],
+        :between_inclusive => [:is_between_inclusive, :in_range_inclusive]
+      }
+
+      WILDCARD_CONDITIONS = {
+        :like => [:contains, :includes],
+        :not_like => [:does_not_include],
+        :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]
+      }
+
+      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_all] = CONDITIONS[:does_not_equal_all] + [:not_in]
+
+      BOOLEAN_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(method_name)
+          column_name_matcher = column_names.join("|")
+          conditions_matcher = (PRIMARY_CONDITIONS + ALIAS_CONDITIONS).join("|")
+
+          if method_name.to_s =~ /^(#{column_name_matcher})_(#{conditions_matcher})$/
+            {: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
+          skip_conversion = skip_time_zone_conversion_for_attributes.include?(columns_hash[column.to_s].name.to_sym)
+          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) }, :skip_conversion => skip_conversion)
+          when /^does_not_equal/
+            scope_options(condition, column_type, "#{table_name}.#{column} != ?", :skip_conversion => skip_conversion)
+          when /^less_than_or_equal_to/
+            scope_options(condition, column_type, "#{table_name}.#{column} <= ?", :skip_conversion => skip_conversion)
+          when /^less_than/
+            scope_options(condition, column_type, "#{table_name}.#{column} < ?", :skip_conversion => skip_conversion)
+          when /^greater_than_or_equal_to/
+            scope_options(condition, column_type, "#{table_name}.#{column} >= ?", :skip_conversion => skip_conversion)
+          when /^greater_than/
+            scope_options(condition, column_type, "#{table_name}.#{column} > ?", :skip_conversion => skip_conversion)
+          when /^between_inclusive/
+            scope_options(condition, column_type, "#{table_name}.#{column} >= ? AND #{table_name}.#{column} <= ?", :skip_conversion => skip_conversion)
+          when /^between/
+            scope_options(condition, column_type, "#{table_name}.#{column} > ? AND #{table_name}.#{column} < ?", :skip_conversion => skip_conversion)
+          when /^like/
+            scope_options(condition, column_type, "#{table_name}.#{column} #{match_keyword} ?", :skip_conversion => skip_conversion, :value_modifier => :like)
+          when /^not_like/
+            scope_options(condition, column_type, "#{table_name}.#{column} NOT #{match_keyword} ?", :skip_conversion => skip_conversion, :value_modifier => :like)
+          when /^begins_with/
+            scope_options(condition, column_type, "#{table_name}.#{column} #{match_keyword} ?", :skip_conversion => skip_conversion, :value_modifier => :begins_with)
+          when /^not_begin_with/
+            scope_options(condition, column_type, "#{table_name}.#{column} NOT #{match_keyword} ?", :skip_conversion => skip_conversion, :value_modifier => :begins_with)
+          when /^ends_with/
+            scope_options(condition, column_type, "#{table_name}.#{column} #{match_keyword} ?", :skip_conversion => skip_conversion, :value_modifier => :ends_with)
+          when /^not_end_with/
+            scope_options(condition, column_type, "#{table_name}.#{column} NOT #{match_keyword} ?", :skip_conversion => skip_conversion, :value_modifier => :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, options = {})
+          case condition.to_s
+          when /_(any|all)$/
+            searchlogic_lambda(column_type, :skip_conversion => options[:skip_conversion]) { |*values|
+              unless values.empty?
+                values.flatten!
+                values.collect! { |value| value_with_modifier(value, options[: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
+                {}
+              end
+            }
+          else
+            searchlogic_lambda(column_type, :skip_conversion => options[:skip_conversion]) { |*values|
+              values.collect! { |value| value_with_modifier(value, options[: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

data/lib/searchlogic/named_scopes/or_conditions.rb

@@ -0,0 +1,141 @@
+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
+      
+      def named_scope_options(name) # :nodoc:
+        super || super(or_conditions(name).try(:join, "_or_"))
+      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 association_details = association_condition_details(part, last_condition)
+              path = full_association_path(part, last_condition, association_details[:association])
+              conditions << "#{path[:path].join("_").to_sym}_#{path[:column]}_#{path[:condition]}"
+              last_condition = path[:condition] || nil
+            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.reverse
+        end
+
+        def full_association_path(part, last_condition, given_assoc)
+            path = [given_assoc.name]
+            part.sub!(/^#{given_assoc.name}_/, "")
+            klass = self
+            while klass = klass.send(:reflect_on_association, given_assoc.name)
+              klass = klass.klass
+              if details = klass.send(:association_condition_details, part, last_condition)
+                path << details[:association]
+                part = details[:condition]
+                given_assoc = details[:association]
+              elsif details = klass.send(:condition_details, part)
+                return { :path => path, :column => details[:column], :condition => details[:condition] }
+              end
+            end
+            { :path => path, :column => part, :condition => last_condition }
+        end
+        
+        def create_or_condition(scopes, args)
+          scopes_options = scopes.collect { |scope, *args| send(scope, *args).proxy_options }
+          # We're using first scope to determine column's type
+          scope = named_scope_options(scopes.first)
+          column_type = scope.respond_to?(:searchlogic_options) ? scope.searchlogic_options[:type] : :string
+          named_scope scopes.join("_or_"), searchlogic_lambda(column_type) { |*args|
+            merge_scopes_with_or(scopes.collect { |scope| clone.send(scope, *args) })
+          }
+        end
+        
+        def merge_scopes_with_or(scopes)
+          scopes_options = scopes.collect { |scope| scope.scope(:find) }
+          conditions = scopes_options.reject { |o| o[:conditions].nil? }.collect { |o| sanitize_sql(o[:conditions]) }
+          scope = scopes_options.inject(scoped({})) { |current_scope, options| current_scope.scoped(options) }
+          options = {}
+          in_searchlogic_delegation { options = scope.scope(:find) }
+          options.delete(:readonly) unless scopes.any? { |scope| scope.proxy_options.key?(:readonly) }
+          options.merge(:conditions => "(" + conditions.join(") OR (") + ")")
+        end
+    end
+  end
+end

data/lib/searchlogic/named_scopes/ordering.rb

@@ -0,0 +1,48 @@
+module Searchlogic
+  module NamedScopes
+    # 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 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 !condition?(scope_name)
+              send(scope_name).proxy_options
+            }
+            send(name, *args)
+          elsif details = ordering_condition_details(name)
+            create_ordering_conditions(details[:column])
+            send(name, *args)
+          else
+            super
+          end
+        end
+        
+        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$/
+            {}
+          end
+        end
+        
+        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
+    end
+  end
+end

data/lib/searchlogic/rails_helpers.rb

@@ -0,0 +1,79 @@
+module Searchlogic
+  module RailsHelpers
+    # Creates a link that alternates between acending and descending. It basically
+    # alternates between calling 2 named scopes: "ascend_by_*" and "descend_by_*"
+    #
+    # By default Searchlogic gives you these named scopes for all of your columns, but
+    # if you wanted to create your own, it will work with those too.
+    #
+    # Examples:
+    #
+    #   order @search, :by => :username
+    #   order @search, :by => :created_at, :as => "Created"
+    #
+    # This helper accepts the following options:
+    #
+    # * <tt>:by</tt> - the name of the named scope. This helper will prepend this value with "ascend_by_" and "descend_by_"
+    # * <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
+      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]
+      new_scope = ascending ? options[:descend_scope] : options[:ascend_scope]
+      selected = [options[:ascend_scope], options[:descend_scope]].include?(search.order.to_s)
+      if selected
+        css_classes = html_options[:class] ? html_options[:class].split(" ") : []
+        if ascending
+          options[:as] = "&#9650;&nbsp;#{options[:as]}"
+          css_classes << "ascending"
+        else
+          options[:as] = "&#9660;&nbsp;#{options[:as]}"
+          css_classes << "descending"
+        end
+        html_options[:class] = css_classes.join(" ")
+      end
+      url_options = {
+        options[:params_scope] => search.conditions.merge( { :order => new_scope } )
+      }.deep_merge(options[:params] || {})
+
+      options[:as] = raw(options[:as]) if defined?(RailsXss)
+
+      link_to options[:as], url_for(url_options), html_options
+    end
+
+    # Automatically makes the form method :get if a Searchlogic::Search and sets
+    # the params scope to :search
+    def form_for(*args, &block)
+      if search_obj = args.find { |arg| arg.is_a?(Searchlogic::Search) }
+        options = args.extract_options!
+        options[:html] ||= {}
+        options[:html][:method] ||= :get
+        options[:url] ||= url_for
+        args.unshift(:search) if args.first == search_obj
+        args << options
+      end
+      super
+    end
+
+    # Automatically adds an "order" hidden field in your form to preserve how the data
+    # is being ordered.
+    def fields_for(*args, &block)
+      if search_obj = args.find { |arg| arg.is_a?(Searchlogic::Search) }
+        args.unshift(:search) if args.first == search_obj
+        concat(content_tag("div", hidden_field_tag("#{args.first}[order]", search_obj.order)))
+        super
+      else
+        super
+      end
+    end
+  end
+end