ransack 2.3.2 → 4.1.1

data/lib/ransack/constants.rb

@@ -36,7 +36,7 @@ module Ransack
       'lt'.freeze, 'lteq'.freeze,
       'gt'.freeze, 'gteq'.freeze,
       'in'.freeze, 'not_in'.freeze
-      ].freeze
+    ].freeze
     A_S_I               = ['a'.freeze, 's'.freeze, 'i'.freeze].freeze
 
     EQ                  = 'eq'.freeze
@@ -45,10 +45,132 @@ module Ransack
     NOT_EQ_ALL          = 'not_eq_all'.freeze
     CONT                = 'cont'.freeze
 
-    RAILS_6_0           = '6.0.0'.freeze
-
     RANSACK_SLASH_SEARCHES = 'ransack/searches'.freeze
     RANSACK_SLASH_SEARCHES_SLASH_SEARCH = 'ransack/searches/search'.freeze
+
+    DISTINCT = 'DISTINCT '.freeze
+
+    DERIVED_PREDICATES = [
+      [CONT, {
+        arel_predicate: 'matches'.freeze,
+        formatter: proc { |v| "%#{escape_wildcards(v)}%" }
+        }
+      ],
+      ['not_cont'.freeze, {
+        arel_predicate: 'does_not_match'.freeze,
+        formatter: proc { |v| "%#{escape_wildcards(v)}%" }
+        }
+      ],
+      ['i_cont'.freeze, {
+        arel_predicate: 'matches'.freeze,
+        formatter: proc { |v| "%#{escape_wildcards(v.downcase)}%" },
+        case_insensitive: true
+        }
+      ],
+      ['not_i_cont'.freeze, {
+        arel_predicate: 'does_not_match'.freeze,
+        formatter: proc { |v| "%#{escape_wildcards(v.downcase)}%" },
+        case_insensitive: true
+        }
+      ],
+      ['start'.freeze, {
+        arel_predicate: 'matches'.freeze,
+        formatter: proc { |v| "#{escape_wildcards(v)}%" }
+        }
+      ],
+      ['not_start'.freeze, {
+        arel_predicate: 'does_not_match'.freeze,
+        formatter: proc { |v| "#{escape_wildcards(v)}%" }
+        }
+      ],
+      ['end'.freeze, {
+        arel_predicate: 'matches'.freeze,
+        formatter: proc { |v| "%#{escape_wildcards(v)}" }
+        }
+      ],
+      ['not_end'.freeze, {
+        arel_predicate: 'does_not_match'.freeze,
+        formatter: proc { |v| "%#{escape_wildcards(v)}" }
+        }
+      ],
+      ['true'.freeze, {
+        arel_predicate: proc { |v| v ? EQ : NOT_EQ },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| true }
+        }
+      ],
+      ['not_true'.freeze, {
+        arel_predicate: proc { |v| v ? NOT_EQ : EQ },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| true }
+        }
+      ],
+      ['false'.freeze, {
+        arel_predicate: proc { |v| v ? EQ : NOT_EQ },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| false }
+        }
+      ],
+      ['not_false'.freeze, {
+        arel_predicate: proc { |v| v ? NOT_EQ : EQ },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| false }
+        }
+      ],
+      ['present'.freeze, {
+        arel_predicate: proc { |v| v ? NOT_EQ_ALL : EQ_ANY },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| [nil, ''.freeze].freeze }
+        }
+      ],
+      ['blank'.freeze, {
+        arel_predicate: proc { |v| v ? EQ_ANY : NOT_EQ_ALL },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| [nil, ''.freeze].freeze }
+        }
+      ],
+      ['null'.freeze, {
+        arel_predicate: proc { |v| v ? EQ : NOT_EQ },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| nil }
+        }
+      ],
+      ['not_null'.freeze, {
+        arel_predicate: proc { |v| v ? NOT_EQ : EQ },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| nil } }
+      ]
+    ].freeze
+
+  module_function
+    # replace % \ to \% \\
+    def escape_wildcards(unescaped)
+      case ActiveRecord::Base.connection.adapter_name
+      when "Mysql2".freeze
+        # Necessary for MySQL
+        unescaped.to_s.gsub(/([\\%_])/, '\\\\\\1')
+      when "PostgreSQL".freeze
+        # Necessary for PostgreSQL
+        unescaped.to_s.gsub(/([\\%_.])/, '\\\\\\1')
+      else
+        unescaped
+      end
+    end
   end
 end
-

data/lib/ransack/context.rb

@@ -1,19 +1,24 @@
 require 'ransack/visitor'
-Ransack::Adapters.object_mapper.require_context
 
 module Ransack
   class Context
     attr_reader :search, :object, :klass, :base, :engine, :arel_visitor
     attr_accessor :auth_object, :search_key
+    attr_reader :arel_visitor
 
     class << self
 
       def for_class(klass, options = {})
-        raise "not implemented"
+        if klass < ActiveRecord::Base
+          Adapters::ActiveRecord::Context.new(klass, options)
+        end
       end
 
       def for_object(object, options = {})
-        raise "not implemented"
+        case object
+        when ActiveRecord::Relation
+          Adapters::ActiveRecord::Context.new(object.klass, options)
+        end
       end
 
       def for(object, options = {})
@@ -30,11 +35,35 @@ module Ransack
     end # << self
 
     def initialize(object, options = {})
-      raise "not implemented"
+      @object = relation_for(object)
+      @klass = @object.klass
+      @join_dependency = join_dependency(@object)
+      @join_type = options[:join_type] || Polyamorous::OuterJoin
+      @search_key = options[:search_key] || Ransack.options[:search_key]
+      @associations_pot = {}
+      @tables_pot = {}
+      @lock_associations = []
+
+      @base = @join_dependency.instance_variable_get(:@join_root)
+    end
+
+    def bind_pair_for(key)
+      @bind_pairs ||= {}
+
+      @bind_pairs[key] ||= begin
+        parent, attr_name = get_parent_and_attribute_name(key.to_s)
+        [parent, attr_name] if parent && attr_name
+      end
     end
 
     def klassify(obj)
-      raise "not implemented"
+      if Class === obj && ::ActiveRecord::Base > obj
+        obj
+      elsif obj.respond_to? :klass
+        obj.klass
+      else
+        raise ArgumentError, "Don't know how to klassify #{obj.inspect}"
+      end
     end
 
     # Convert a string representing a chain of associations and an attribute

data/lib/ransack/helpers/form_builder.rb

@@ -33,7 +33,7 @@ module Ransack
         text = args.first
         i18n = options[:i18n] || {}
         text ||= object.translate(
-          method, i18n.reverse_merge(:include_associations => true)
+          method, i18n.reverse_merge(include_associations: true)
           ) if object.respond_to? :translate
         super(method, text, options, &block)
       end
@@ -45,9 +45,9 @@ module Ransack
       end
 
       def attribute_select(options = nil, html_options = nil, action = nil)
-        options = options || {}
-        html_options = html_options || {}
-        action = action || Constants::SEARCH
+        options ||= {}
+        html_options ||= {}
+        action ||= Constants::SEARCH
         default = options.delete(:default)
         raise ArgumentError, formbuilder_error_message(
           "#{action}_select") unless object.respond_to?(:context)
@@ -240,7 +240,7 @@ module Ransack
       def get_attribute_element(action, base)
         begin
           [
-            Translate.association(base, :context => object.context),
+            Translate.association(base, context: object.context),
             collection_for_base(action, base)
           ]
         rescue UntraversableAssociationError
@@ -253,7 +253,7 @@ module Ransack
           [
             attr_from_base_and_column(base, c),
             Translate.attribute(
-              attr_from_base_and_column(base, c), :context => object.context
+              attr_from_base_and_column(base, c), context: object.context
             )
           ]
         end

data/lib/ransack/helpers/form_helper.rb

@@ -129,13 +129,21 @@ module Ransack
         end
 
         def url_options
-          @params.merge(
-            @options.merge(
+          @params.except(:host).merge(
+            @options.except(:class, :data, :host).merge(
               @search.context.search_key => search_and_sort_params))
         end
 
         def html_options(args)
-          html_options = extract_options_and_mutate_args!(args)
+          if args.empty?
+            html_options = @options
+          else
+            deprecation_message = "Passing two trailing hashes to `sort_link` is deprecated, merge the trailing hashes into a single one."
+            caller_location = caller_locations(2, 2).first
+            warn "#{deprecation_message} (called at #{caller_location.path}:#{caller_location.lineno})"
+            html_options = extract_options_and_mutate_args!(args)
+          end
+
           html_options.merge(
             class: [['sort_link'.freeze, @current_dir], html_options[:class]]
                    .compact.join(' '.freeze)
@@ -145,7 +153,7 @@ module Ransack
         private
 
           def parameters_hash(params)
-            if ::ActiveRecord::VERSION::MAJOR >= 5 && params.respond_to?(:to_unsafe_h)
+            if params.respond_to?(:to_unsafe_h)
               params.to_unsafe_h
             else
               params
@@ -172,7 +180,8 @@ module Ransack
           end
 
           def search_params
-            @params[@search.context.search_key].presence || {}
+            query_params = @params[@search.context.search_key]
+            query_params.is_a?(Hash) ? query_params : {}
           end
 
           def sort_params

data/lib/ransack/helpers.rb

@@ -1,2 +1,2 @@
 require 'ransack/helpers/form_builder'
-require 'ransack/helpers/form_helper'
+require 'ransack/helpers/form_helper'

data/lib/ransack/locale/sv.yml

@@ -0,0 +1,70 @@
+sv:
+  ransack:
+    search: "sök"
+    predicate: "predikat"
+    and: "och"
+    or: "eller"
+    any: "vilken som"
+    all: "alla"
+    combinator: "kombinator"
+    attribute: "attribut"
+    value: "värde"
+    condition: "villkor"
+    sort: "sortera"
+    asc: "stigande"
+    desc: "fallande"
+    predicates:
+      eq: "lika med"
+      eq_any: "lika med vilket som"
+      eq_all: "lika med alla"
+      not_eq: "inte lika med"
+      not_eq_any: "inte lika med någon"
+      not_eq_all: "inte lika med alla"
+      matches: "matchar"
+      matches_any: "matchar någon"
+      matches_all: "matchar alla"
+      does_not_match: "matchar inte"
+      does_not_match_any: "matchar inte någon"
+      does_not_match_all: "matchar inte alla"
+      lt: "mindre än"
+      lt_any: "mindre än någon"
+      lt_all: "mindre än alla"
+      lteq: "mindre än eller lika med"
+      lteq_any: "mindre än eller lika med någon"
+      lteq_all: "mindre än eller lika med alla"
+      gt: "större än"
+      gt_any: "större än någon"
+      gt_all: "större än alla"
+      gteq: "större än eller lika med"
+      gteq_any: "större än eller lika med någon"
+      gteq_all: "större än eller lika med alla"
+      in: "i"
+      in_any: "i någon"
+      in_all: "i alla"
+      not_in: "inte i"
+      not_in_any: "inte i någon"
+      not_in_all: "inte i alla"
+      cont: "innehåller"
+      cont_any: "innehåller någon"
+      cont_all: "innehåller alla"
+      not_cont: "innehåller inte"
+      not_cont_any: "innehåller inte någon"
+      not_cont_all: "innehåller inte alla"
+      start: "börjar med"
+      start_any: "börjar med någon"
+      start_all: "börjar med alla"
+      not_start: "börjar inte med"
+      not_start_any: "börjar inte med någon"
+      not_start_all: "börjar inte med alla"
+      end: "slutar med"
+      end_any: "slutar med någon"
+      end_all: "slutar med alla"
+      not_end: "slutar inte med"
+      not_end_any: "slutar inte med någon"
+      not_end_all: "slutar inte med alla"
+      'true': "är sant"
+      'false': "är falskt"
+      present: "existerar"
+      blank: "är tom"
+      'null': "är null"
+      not_null: "är inte null"

data/lib/ransack/nodes/attribute.rb

@@ -5,8 +5,8 @@ module Ransack
 
       attr_reader :name, :ransacker_args
 
-      delegate :blank?, :present?, :to => :name
-      delegate :engine, :to => :context
+      delegate :blank?, :present?, to: :name
+      delegate :engine, to: :context
 
       def initialize(context, name = nil, ransacker_args = [])
         super(context)
@@ -30,7 +30,7 @@ module Ransack
 
       def type
         if ransacker
-          return ransacker.type
+          ransacker.type
         else
           context.type_for(self)
         end

data/lib/ransack/nodes/condition.rb

@@ -2,8 +2,8 @@ module Ransack
   module Nodes
     class Condition < Node
       i18n_word :attribute, :predicate, :combinator, :value
-      i18n_alias :a => :attribute, :p => :predicate,
-                 :m => :combinator, :v => :value
+      i18n_alias a: :attribute, p: :predicate,
+                 m: :combinator, v: :value
 
       attr_accessor :predicate
 
@@ -15,10 +15,10 @@ module Ransack
           if attributes.size > 0 && predicate
             condition = self.new(context)
             condition.build(
-              :a => attributes,
-              :p => predicate.name,
-              :m => combinator,
-              :v => predicate.wants_array ? Array(values) : [values]
+              a: attributes,
+              p: predicate.name,
+              m: combinator,
+              v: predicate.wants_array ? Array(values) : [values]
             )
             # TODO: Figure out what to do with multiple types of attributes,
             # if anything. Tempted to go with "garbage in, garbage out" here.
@@ -127,7 +127,6 @@ module Ransack
       alias :m= :combinator=
       alias :m :combinator
 
-
       # == build_attribute
       #
       #  This method was originally called from Nodes::Grouping#new_condition
@@ -263,7 +262,6 @@ module Ransack
         attr.attr
       end
 
-
       def default_type
         predicate.type || (attributes.first && attributes.first.type)
       end
@@ -285,12 +283,85 @@ module Ransack
         predicate.negative?
       end
 
+      def arel_predicate
+        predicate = attributes.map { |attribute|
+          association = attribute.parent
+          if negative? && attribute.associated_collection?
+            query = context.build_correlated_subquery(association)
+            context.remove_association(association)
+            if self.predicate_name == 'not_null' && self.value
+              query.where(format_predicate(attribute))
+              Arel::Nodes::In.new(context.primary_key, Arel.sql(query.to_sql))
+            else
+              query.where(format_predicate(attribute).not)
+              Arel::Nodes::NotIn.new(context.primary_key, Arel.sql(query.to_sql))
+            end
+          else
+            format_predicate(attribute)
+          end
+        }.reduce(combinator_method)
+
+        if replace_right_node?(predicate)
+          # Replace right node object to plain integer value in order to avoid
+          # ActiveModel::RangeError from Arel::Node::Casted.
+          # The error can be ignored here because RDBMSs accept large numbers
+          # in condition clauses.
+          plain_value = predicate.right.value
+          predicate.right = plain_value
+        end
+
+        predicate
+      end
+
       private
 
+      def combinator_method
+        combinator === Constants::OR ? :or : :and
+      end
+
+      def format_predicate(attribute)
+        arel_pred = arel_predicate_for_attribute(attribute)
+        arel_values = formatted_values_for_attribute(attribute)
+        predicate = attr_value_for_attribute(attribute).public_send(arel_pred, arel_values)
+
+        if in_predicate?(predicate)
+          predicate.right = predicate.right.map do |pr|
+            casted_array?(pr) ? format_values_for(pr) : pr
+          end
+        end
+
+        predicate
+      end
+
+      def in_predicate?(predicate)
+        return unless defined?(Arel::Nodes::Casted)
+        predicate.class == Arel::Nodes::In || predicate.class == Arel::Nodes::NotIn
+      end
+
+      def casted_array?(predicate)
+        predicate.value.is_a?(Array) && predicate.is_a?(Arel::Nodes::Casted)
+      end
+
+      def format_values_for(predicate)
+        predicate.value.map do |val|
+          val.is_a?(String) ? Arel::Nodes.build_quoted(val) : val
+        end
+      end
+
+      def replace_right_node?(predicate)
+        return false unless predicate.is_a?(Arel::Nodes::Binary)
+
+        arel_node = predicate.right
+        return false unless arel_node.is_a?(Arel::Nodes::Casted)
+
+        relation, name = arel_node.attribute.values
+        attribute_type = relation.type_for_attribute(name).type
+        attribute_type == :integer && arel_node.value.is_a?(Integer)
+      end
+
       def valid_combinator?
         attributes.size < 2 || Constants::AND_OR.include?(combinator)
       end
-
     end
   end
 end

data/lib/ransack/nodes/grouping.rb

@@ -7,9 +7,9 @@ module Ransack
       alias :m= :combinator=
 
       i18n_word :condition, :and, :or
-      i18n_alias :c => :condition, :n => :and, :o => :or
+      i18n_alias c: :condition, n: :and, o: :or
 
-      delegate :each, :to => :values
+      delegate :each, to: :values
 
       def initialize(context, combinator = nil)
         super(context)
@@ -22,7 +22,7 @@ module Ransack
 
       def translate(key, options = {})
         super or Translate.attribute(
-          key.to_s, options.merge(:context => context)
+          key.to_s, options.merge(context: context)
         )
       end
 
@@ -108,7 +108,7 @@ module Ransack
       alias :g= :groupings=
 
       def method_missing(method_id, *args)
-        method_name = method_id.to_s
+        method_name = method_id.to_s.dup
         writer = method_name.sub!(/\=$/, ''.freeze)
         if attribute_method?(method_name)
           if writer

data/lib/ransack/nodes/node.rb

@@ -2,7 +2,7 @@ module Ransack
   module Nodes
     class Node
       attr_reader :context
-      delegate :contextualize, :to => :context
+      delegate :contextualize, to: :context
       class_attribute :i18n_words
       class_attribute :i18n_aliases
       self.i18n_words = []

data/lib/ransack/nodes/sort.rb

@@ -9,7 +9,7 @@ module Ransack
       class << self
         def extract(context, str)
           return unless str
-          attr, direction = str.split(/\s+/,2)
+          attr, direction = str.split(/\s+/, 2)
           self.new(context).build(name: attr, dir: direction)
         end
       end
@@ -31,8 +31,8 @@ module Ransack
       end
 
       def name=(name)
-        @name = name
-        context.bind(self, name)
+        @name = context.ransackable_alias(name) || name
+        context.bind(self, @name)
       end
 
       def dir=(dir)

data/lib/ransack/nodes/value.rb

@@ -2,7 +2,7 @@ module Ransack
   module Nodes
     class Value < Node
       attr_accessor :value
-      delegate :present?, :blank?, :to => :value
+      delegate :present?, :blank?, to: :value
 
       def initialize(context, value = nil)
         super(context)
@@ -26,7 +26,7 @@ module Ransack
         case type
         when :date
           cast_to_date(value)
-        when :datetime, :timestamp, :time
+        when :datetime, :timestamp, :time, :timestamptz
           cast_to_time(value)
         when :boolean
           cast_to_boolean(value)
@@ -50,7 +50,7 @@ module Ransack
           y, m, d = *[val].flatten
           m ||= 1
           d ||= 1
-          Date.new(y,m,d) rescue nil
+          Date.new(y, m, d) rescue nil
         end
       end
 

data/lib/ransack/predicate.rb

@@ -10,7 +10,7 @@ module Ransack
       end
 
       def named(name)
-        Ransack.predicates[name.to_s]
+        Ransack.predicates[(name || Ransack.options[:default_predicate]).to_s]
       end
 
       def detect_and_strip_from_string!(str)

data/lib/ransack/ransacker.rb

@@ -3,7 +3,7 @@ module Ransack
 
     attr_reader :name, :type, :formatter, :args
 
-    delegate :call, :to => :@callable
+    delegate :call, to: :@callable
 
     def initialize(klass, name, opts = {}, &block)
       @klass, @name = klass, name

data/lib/ransack/search.rb

@@ -1,6 +1,11 @@
-require 'ransack/nodes'
+require 'ransack/nodes/bindable'
+require 'ransack/nodes/node'
+require 'ransack/nodes/attribute'
+require 'ransack/nodes/value'
+require 'ransack/nodes/condition'
+require 'ransack/nodes/sort'
+require 'ransack/nodes/grouping'
 require 'ransack/context'
-Ransack::Adapters.object_mapper.require_search
 require 'ransack/naming'
 
 module Ransack
@@ -9,15 +14,17 @@ module Ransack
 
     attr_reader :base, :context
 
-    delegate :object, :klass, :to => :context
+    delegate :object, :klass, to: :context
     delegate :new_grouping, :new_condition,
              :build_grouping, :build_condition,
-             :translate, :to => :base
+             :translate, to: :base
 
     def initialize(object, params = {}, options = {})
+      strip_whitespace = options.fetch(:strip_whitespace, Ransack.options[:strip_whitespace])
       params = params.to_unsafe_h if params.respond_to?(:to_unsafe_h)
       if params.is_a? Hash
         params = params.dup
+        params = params.transform_values { |v| v.is_a?(String) && strip_whitespace ? v.strip : v }
         params.delete_if { |k, v| [*v].all?{ |i| i.blank? && i != false } }
       else
         params = {}
@@ -29,6 +36,7 @@ module Ransack
         )
       @scope_args = {}
       @sorts ||= []
+      @ignore_unknown_conditions = options[:ignore_unknown_conditions] == false ? false : true
       build(params.with_indifferent_access)
     end
 
@@ -40,11 +48,11 @@ module Ransack
       collapse_multiparameter_attributes!(params).each do |key, value|
         if ['s'.freeze, 'sorts'.freeze].freeze.include?(key)
           send("#{key}=", value)
-        elsif base.attribute_method?(key)
-          base.send("#{key}=", value)
         elsif @context.ransackable_scope?(key, @context.object)
           add_scope(key, value)
-        elsif !Ransack.options[:ignore_unknown_conditions]
+        elsif base.attribute_method?(key)
+          base.send("#{key}=", value)
+        elsif !Ransack.options[:ignore_unknown_conditions] || !@ignore_unknown_conditions
           raise ArgumentError, "Invalid search term #{key}"
         end
       end