ransack 2.1.1 → 2.5.0

data/lib/polyamorous/activerecord_6.1_ruby_2/join_association.rb

@@ -0,0 +1,74 @@
+module Polyamorous
+  module JoinAssociationExtensions
+    include SwappingReflectionClass
+    def self.prepended(base)
+      base.class_eval { attr_reader :join_type }
+    end
+
+    def initialize(reflection, children, polymorphic_class = nil, join_type = Arel::Nodes::InnerJoin)
+      @join_type = join_type
+      if polymorphic_class && ::ActiveRecord::Base > polymorphic_class
+        swapping_reflection_klass(reflection, polymorphic_class) do |reflection|
+          super(reflection, children)
+          self.reflection.options[:polymorphic] = true
+        end
+      else
+        super(reflection, children)
+      end
+    end
+
+    # Same as #join_constraints, but instead of constructing tables from the
+    # given block, uses the ones passed
+    def join_constraints_with_tables(foreign_table, foreign_klass, join_type, alias_tracker, tables)
+      joins = []
+      chain = []
+
+      reflection.chain.each.with_index do |reflection, i|
+        table = tables[i]
+
+        @table ||= table
+        chain << [reflection, table]
+      end
+
+      # The chain starts with the target table, but we want to end with it here (makes
+      # more sense in this context), so we reverse
+      chain.reverse_each do |reflection, table|
+        klass = reflection.klass
+
+        join_scope = reflection.join_scope(table, foreign_table, foreign_klass)
+
+        unless join_scope.references_values.empty?
+          join_dependency = join_scope.construct_join_dependency(
+            join_scope.eager_load_values | join_scope.includes_values, Arel::Nodes::OuterJoin
+          )
+          join_scope.joins!(join_dependency)
+        end
+
+        arel = join_scope.arel(alias_tracker.aliases)
+        nodes = arel.constraints.first
+
+        if nodes.is_a?(Arel::Nodes::And)
+          others = nodes.children.extract! do |node|
+            !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
+          end
+        end
+
+        joins << table.create_join(table, table.create_on(nodes), join_type)
+
+        if others && !others.empty?
+          joins.concat arel.join_sources
+          append_constraints(joins.last, others)
+        end
+
+        # The current table in this iteration becomes the foreign table in the next
+        foreign_table, foreign_klass = table, klass
+      end
+
+      joins
+    end
+
+    def ==(other)
+      base_klass == other.base_klass
+    end
+  end
+end

data/lib/polyamorous/activerecord_6.1_ruby_2/join_dependency.rb

@@ -0,0 +1,93 @@
+# active_record_6.1_ruby_2/join_dependency.rb
+module Polyamorous
+  module JoinDependencyExtensions
+    # Replaces ActiveRecord::Associations::JoinDependency#build
+    def build(associations, base_klass)
+      associations.map do |name, right|
+        if name.is_a? Join
+          reflection = find_reflection base_klass, name.name
+          reflection.check_validity!
+          reflection.check_eager_loadable!
+
+          klass = if reflection.polymorphic?
+            name.klass || base_klass
+          else
+            reflection.klass
+          end
+          JoinAssociation.new(reflection, build(right, klass), name.klass, name.type)
+        else
+          reflection = find_reflection base_klass, name
+          reflection.check_validity!
+          reflection.check_eager_loadable!
+
+          if reflection.polymorphic?
+            raise ActiveRecord::EagerLoadPolymorphicError.new(reflection)
+          end
+          JoinAssociation.new(reflection, build(right, reflection.klass))
+        end
+      end
+    end
+
+    def join_constraints(joins_to_add, alias_tracker, references)
+      @alias_tracker = alias_tracker
+      @joined_tables = {}
+      @references = {}
+
+      references.each do |table_name|
+        @references[table_name.to_sym] = table_name if table_name.is_a?(String)
+      end
+
+      joins = make_join_constraints(join_root, join_type)
+
+      joins.concat joins_to_add.flat_map { |oj|
+        if join_root.match?(oj.join_root) && join_root.table.name == oj.join_root.table.name
+          walk join_root, oj.join_root, oj.join_type
+        else
+          make_join_constraints(oj.join_root, oj.join_type)
+        end
+      }
+    end
+
+    def construct_tables_for_association!(join_root, association)
+      tables = table_aliases_for(join_root, association)
+      association.table = tables.first
+      tables
+    end
+
+    private
+
+    def table_aliases_for(parent, node)
+      node.reflection.chain.map { |reflection|
+        alias_tracker.aliased_table_for(reflection.klass.arel_table) do
+          root = reflection == node.reflection
+          name = reflection.alias_candidate(parent.table_name)
+          root ? name : "#{name}_join"
+        end
+      }
+    end
+
+    module ClassMethods
+      # Prepended before ActiveRecord::Associations::JoinDependency#walk_tree
+      #
+      def walk_tree(associations, hash)
+        case associations
+        when TreeNode
+          associations.add_to_tree(hash)
+        when Hash
+          associations.each do |k, v|
+            cache =
+              if TreeNode === k
+                k.add_to_tree(hash)
+              else
+                hash[k] ||= {}
+              end
+            walk_tree(v, cache)
+          end
+        else
+          super(associations, hash)
+        end
+      end
+    end
+
+  end
+end

data/lib/polyamorous/activerecord_6.1_ruby_2/reflection.rb

@@ -0,0 +1 @@
+require 'polyamorous/activerecord_6.0_ruby_2/reflection'

data/lib/polyamorous/activerecord_7.0_ruby_2/join_association.rb

@@ -0,0 +1 @@
+require 'polyamorous/activerecord_6.1_ruby_2/join_association'

data/lib/polyamorous/activerecord_7.0_ruby_2/join_dependency.rb

@@ -0,0 +1 @@
+require 'polyamorous/activerecord_6.1_ruby_2/join_dependency'

data/lib/polyamorous/activerecord_7.0_ruby_2/reflection.rb

@@ -0,0 +1 @@
+require 'polyamorous/activerecord_6.1_ruby_2/reflection'

data/lib/polyamorous/polyamorous.rb

@@ -0,0 +1,24 @@
+if defined?(::ActiveRecord)
+  module Polyamorous
+    InnerJoin = Arel::Nodes::InnerJoin
+    OuterJoin = Arel::Nodes::OuterJoin
+
+    JoinDependency  = ::ActiveRecord::Associations::JoinDependency
+    JoinAssociation = ::ActiveRecord::Associations::JoinDependency::JoinAssociation
+  end
+
+  require 'polyamorous/tree_node'
+  require 'polyamorous/join'
+  require 'polyamorous/swapping_reflection_class'
+
+  ar_version = ::ActiveRecord::VERSION::STRING[0, 3]
+  %w(join_association join_dependency reflection).each do |file|
+    require "polyamorous/activerecord_#{ar_version}_ruby_2/#{file}"
+  end
+
+  ActiveRecord::Reflection::AbstractReflection.send(:prepend, Polyamorous::ReflectionExtensions)
+
+  Polyamorous::JoinDependency.send(:prepend, Polyamorous::JoinDependencyExtensions)
+  Polyamorous::JoinDependency.singleton_class.send(:prepend, Polyamorous::JoinDependencyExtensions::ClassMethods)
+  Polyamorous::JoinAssociation.send(:prepend, Polyamorous::JoinAssociationExtensions)
+end

data/lib/polyamorous.rb

@@ -1,25 +1 @@
-if defined?(::ActiveRecord)
-  module Polyamorous
-    InnerJoin = Arel::Nodes::InnerJoin
-    OuterJoin = Arel::Nodes::OuterJoin
-
-    JoinDependency  = ::ActiveRecord::Associations::JoinDependency
-    JoinAssociation = ::ActiveRecord::Associations::JoinDependency::JoinAssociation
-  end
-
-  require 'polyamorous/tree_node'
-  require 'polyamorous/join'
-  require 'polyamorous/swapping_reflection_class'
-
-  ar_version = ::ActiveRecord::VERSION::STRING[0,3]
-  ar_version = ::ActiveRecord::VERSION::STRING[0,5] if ar_version >= "5.2"
-  ar_version = "5.2.1" if ::ActiveRecord::VERSION::STRING >= "5.2.1"
-
-  %w(join_association join_dependency).each do |file|
-    require "polyamorous/activerecord_#{ar_version}_ruby_2/#{file}"
-  end
-
-  Polyamorous::JoinDependency.send(:prepend, Polyamorous::JoinDependencyExtensions)
-  Polyamorous::JoinDependency.singleton_class.send(:prepend, Polyamorous::JoinDependencyExtensions::ClassMethods)
-  Polyamorous::JoinAssociation.send(:prepend, Polyamorous::JoinAssociationExtensions)
-end
+require 'polyamorous/polyamorous'

data/lib/ransack/adapters/active_record/base.rb

@@ -18,6 +18,10 @@ module Ransack
           Search.new(self, params, options)
         end
 
+        def ransack!(params = {}, options = {})
+          ransack(params, options.merge(ignore_unknown_conditions: false))
+        end
+
         def ransacker(name, opts = {}, &block)
           self._ransackers = _ransackers.merge name.to_s => Ransacker
             .new(self, name, opts, &block)
@@ -66,7 +70,7 @@ module Ransack
         end
 
         # ransack_scope_skip_sanitize_args, by default, returns an empty array.
-        # i.e. use the sanitize_scope_args setting to determin if args should be converted.
+        # i.e. use the sanitize_scope_args setting to determine if args should be converted.
         # For overriding with a list of scopes which should be passed the args as-is.
         #
         def ransackable_scopes_skip_sanitize_args

data/lib/ransack/adapters/active_record/context.rb

@@ -1,18 +1,11 @@
 require 'ransack/context'
-require 'polyamorous'
+require 'polyamorous/polyamorous'
 
 module Ransack
   module Adapters
     module ActiveRecord
       class Context < ::Ransack::Context
 
-        def initialize(object, options = {})
-          super
-          if ::ActiveRecord::VERSION::STRING < Constants::RAILS_5_2
-            @arel_visitor = @engine.connection.visitor
-          end
-        end
-
         def relation_for(object)
           object.all
         end
@@ -49,6 +42,17 @@ module Ransack
               if scope_or_sort.is_a?(Symbol)
                 relation = relation.send(scope_or_sort)
               else
+                case Ransack.options[:postgres_fields_sort_option]
+                when :nulls_first
+                  scope_or_sort = scope_or_sort.direction == :asc ? Arel.sql("#{scope_or_sort.to_sql} NULLS FIRST") : Arel.sql("#{scope_or_sort.to_sql} NULLS LAST")
+                when :nulls_last
+                  scope_or_sort = scope_or_sort.direction == :asc ? Arel.sql("#{scope_or_sort.to_sql} NULLS LAST") : Arel.sql("#{scope_or_sort.to_sql} NULLS FIRST")
+                when :nulls_always_first
+                  scope_or_sort = Arel.sql("#{scope_or_sort.to_sql} NULLS FIRST")
+                when :nulls_always_last
+                  scope_or_sort = Arel.sql("#{scope_or_sort.to_sql} NULLS LAST")
+                end
+
                 relation = relation.order(scope_or_sort)
               end
             end
@@ -104,20 +108,21 @@ module Ransack
         # JoinDependency to track table aliases.
         #
         def join_sources
-          base, joins =
-          if ::ActiveRecord::VERSION::STRING > Constants::RAILS_5_2_0
+          base, joins = begin
             alias_tracker = ::ActiveRecord::Associations::AliasTracker.create(self.klass.connection, @object.table.name, [])
-            [
-              Arel::SelectManager.new(@object.table),
+            constraints   = if ::Gem::Version.new(::ActiveRecord::VERSION::STRING) >= ::Gem::Version.new(Constants::RAILS_6_1)
+              @join_dependency.join_constraints(@object.joins_values, alias_tracker, @object.references_values)
+            elsif ::Gem::Version.new(::ActiveRecord::VERSION::STRING) >= ::Gem::Version.new(Constants::RAILS_6_0)
+              @join_dependency.join_constraints(@object.joins_values, alias_tracker)
+            else
               @join_dependency.join_constraints(@object.joins_values, @join_type, alias_tracker)
-            ]
-          else
+            end
+
             [
               Arel::SelectManager.new(@object.table),
-              @join_dependency.join_constraints(@object.joins_values, @join_type)
+              constraints
             ]
           end
-          joins = joins.collect(&:joins).flatten if ::ActiveRecord::VERSION::STRING < Constants::RAILS_5_2
           joins.each do |aliased_join|
             base.from(aliased_join)
           end
@@ -163,7 +168,7 @@ module Ransack
         def build_correlated_subquery(association)
           join_constraints = extract_joins(association)
           join_root = join_constraints.shift
-          correlated_key = join_root.right.expr.left
+          correlated_key = extract_correlated_key(join_root)
           subquery = Arel::SelectManager.new(association.base_klass)
           subquery.from(join_root.left)
           subquery.project(correlated_key)
@@ -179,6 +184,35 @@ module Ransack
 
         private
 
+        def extract_correlated_key(join_root)
+          case join_root
+          when Arel::Nodes::OuterJoin
+            # one of join_root.right/join_root.left is expected to be Arel::Nodes::On
+            if join_root.right.is_a?(Arel::Nodes::On)
+              extract_correlated_key(join_root.right.expr)
+            elsif join_root.left.is_a?(Arel::Nodes::On)
+              extract_correlated_key(join_root.left.expr)
+            else
+              raise 'Ransack encountered an unexpected arel structure'
+            end
+          when Arel::Nodes::Equality
+            pk = primary_key
+            if join_root.left == pk
+              join_root.right
+            elsif join_root.right == pk
+              join_root.left
+            else
+              nil
+            end
+          when Arel::Nodes::And
+            extract_correlated_key(join_root.left) || extract_correlated_key(join_root.right)
+          else
+            # eg parent was Arel::Nodes::And and the evaluated side was one of
+            # Arel::Nodes::Grouping or MultiTenant::TenantEnforcementClause
+            nil
+          end
+        end
+
         def get_parent_and_attribute_name(str, parent = @base)
           attr_name = nil
 
@@ -248,24 +282,15 @@ module Ransack
 
           join_list = join_nodes + convert_join_strings_to_ast(relation.table, string_joins)
 
-          if ::ActiveRecord::VERSION::STRING < Constants::RAILS_5_2_0
-            join_dependency = Polyamorous::JoinDependency.new(relation.klass, association_joins, join_list)
-            join_nodes.each do |join|
-              join_dependency.send(:alias_tracker).aliases[join.left.name.downcase] = 1
-            end
-          elsif ::ActiveRecord::VERSION::STRING == Constants::RAILS_5_2_0
-            alias_tracker = ::ActiveRecord::Associations::AliasTracker.create(self.klass.connection, relation.table.name, join_list)
-            join_dependency = Polyamorous::JoinDependency.new(relation.klass, relation.table, association_joins, alias_tracker)
-            join_nodes.each do |join|
-              join_dependency.send(:alias_tracker).aliases[join.left.name.downcase] = 1
-            end
+          alias_tracker = ::ActiveRecord::Associations::AliasTracker.create(self.klass.connection, relation.table.name, join_list)
+          join_dependency = if ::Gem::Version.new(::ActiveRecord::VERSION::STRING) >= ::Gem::Version.new(Constants::RAILS_6_0)
+            Polyamorous::JoinDependency.new(relation.klass, relation.table, association_joins, Arel::Nodes::OuterJoin)
           else
-            alias_tracker = ::ActiveRecord::Associations::AliasTracker.create(self.klass.connection, relation.table.name, join_list)
-            join_dependency = Polyamorous::JoinDependency.new(relation.klass, relation.table, association_joins)
-            join_dependency.instance_variable_set(:@alias_tracker, alias_tracker)
-            join_nodes.each do |join|
-              join_dependency.send(:alias_tracker).aliases[join.left.name.downcase] = 1
-            end
+            Polyamorous::JoinDependency.new(relation.klass, relation.table, association_joins)
+          end
+          join_dependency.instance_variable_set(:@alias_tracker, alias_tracker)
+          join_nodes.each do |join|
+            join_dependency.send(:alias_tracker).aliases[join.left.name.downcase] = 1
           end
           join_dependency
         end
@@ -289,32 +314,23 @@ module Ransack
         end
 
         def build_association(name, parent = @base, klass = nil)
-          if ::ActiveRecord::VERSION::STRING < Constants::RAILS_5_2_0
-            jd = Polyamorous::JoinDependency.new(
-              parent.base_klass,
-              Polyamorous::Join.new(name, @join_type, klass),
-              []
-            )
-            found_association = jd.join_root.children.last
-          elsif ::ActiveRecord::VERSION::STRING == Constants::RAILS_5_2_0
-            alias_tracker = ::ActiveRecord::Associations::AliasTracker.create(self.klass.connection, parent.table.name, [])
+          if ::Gem::Version.new(::ActiveRecord::VERSION::STRING) >= ::Gem::Version.new(Constants::RAILS_6_0)
             jd = Polyamorous::JoinDependency.new(
               parent.base_klass,
-              parent.base_klass.arel_table,
+              parent.table,
               Polyamorous::Join.new(name, @join_type, klass),
-              alias_tracker
+              @join_type
             )
             found_association = jd.instance_variable_get(:@join_root).children.last
           else
             jd = Polyamorous::JoinDependency.new(
               parent.base_klass,
-              parent.base_klass.arel_table,
-              Polyamorous::Join.new(name, @join_type, klass),
+              parent.table,
+              Polyamorous::Join.new(name, @join_type, klass)
             )
             found_association = jd.instance_variable_get(:@join_root).children.last
           end
 
-
           @associations_pot[found_association] = parent
 
           # TODO maybe we dont need to push associations here, we could loop
@@ -322,40 +338,27 @@ module Ransack
           @join_dependency.instance_variable_get(:@join_root).children.push found_association
 
           # Builds the arel nodes properly for this association
-          if ::ActiveRecord::VERSION::STRING > Constants::RAILS_5_2_0
-            @join_dependency.send(:construct_tables!, jd.instance_variable_get(:@join_root))
+          if ::Gem::Version.new(::ActiveRecord::VERSION::STRING) >= ::Gem::Version.new(Constants::RAILS_6_1)
+            @tables_pot[found_association] = @join_dependency.construct_tables_for_association!(jd.instance_variable_get(:@join_root), found_association)
           else
-            @join_dependency.send(
-              :construct_tables!, jd.instance_variable_get(:@join_root), found_association
-            )
+            @join_dependency.send(:construct_tables!, jd.instance_variable_get(:@join_root))
           end
 
           # Leverage the stashed association functionality in AR
           @object = @object.joins(jd)
-
           found_association
         end
 
         def extract_joins(association)
           parent = @join_dependency.instance_variable_get(:@join_root)
           reflection = association.reflection
-          join_constraints = if ::ActiveRecord::VERSION::STRING < Constants::RAILS_5_1
-                               association.join_constraints(
-                                 parent.table,
-                                 parent.base_klass,
-                                 association,
-                                 Arel::Nodes::OuterJoin,
-                                 association.tables,
-                                 reflection.scope_chain,
-                                 reflection.chain
-                               )
-                             elsif ::ActiveRecord::VERSION::STRING <= Constants::RAILS_5_2_0
-                               association.join_constraints(
+          join_constraints = if ::Gem::Version.new(::ActiveRecord::VERSION::STRING) >= ::Gem::Version.new(Constants::RAILS_6_1)
+                               association.join_constraints_with_tables(
                                  parent.table,
                                  parent.base_klass,
                                  Arel::Nodes::OuterJoin,
-                                 association.tables,
-                                 reflection.chain
+                                 @join_dependency.instance_variable_get(:@alias_tracker),
+                                 @tables_pot[association]
                                )
                              else
                                association.join_constraints(

data/lib/ransack/adapters/active_record/ransack/constants.rb

@@ -13,6 +13,18 @@ module Ransack
         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)}%" }
@@ -85,7 +97,7 @@ module Ransack
         arel_predicate: proc { |v| v ? EQ : NOT_EQ },
         compounds: false,
         type: :boolean,
-        validator: proc { |v| BOOLEAN_VALUES.include?(v)},
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
         formatter: proc { |v| nil }
         }
       ],
@@ -102,8 +114,11 @@ module Ransack
     # replace % \ to \% \\
     def escape_wildcards(unescaped)
       case ActiveRecord::Base.connection.adapter_name
-      when "Mysql2".freeze, "PostgreSQL".freeze
-        # Necessary for PostgreSQL and MySQL
+      when "Mysql2".freeze
+        # Necessary for MySQL
+        unescaped.to_s.gsub(/([\\%_])/, '\\\\\\1')
+      when "PostgreSQL".freeze
+        # Necessary for PostgreSQL
         unescaped.to_s.gsub(/([\\%_.])/, '\\\\\\1')
       else
         unescaped

data/lib/ransack/adapters/active_record/ransack/context.rb

@@ -28,14 +28,10 @@ module Ransack
       @join_type = options[:join_type] || Polyamorous::OuterJoin
       @search_key = options[:search_key] || Ransack.options[:search_key]
       @associations_pot = {}
+      @tables_pot = {}
       @lock_associations = []
 
-      if ::ActiveRecord::VERSION::STRING >= Constants::RAILS_5_2
-        @base = @join_dependency.instance_variable_get(:@join_root)
-      else
-        @base = @join_dependency.join_root
-        @engine = @base.base_klass.arel_engine
-      end
+      @base = @join_dependency.instance_variable_get(:@join_root)
     end
 
     def bind_pair_for(key)

data/lib/ransack/adapters/active_record/ransack/nodes/condition.rb

@@ -30,7 +30,7 @@ module Ransack
         def format_predicate(attribute)
           arel_pred = arel_predicate_for_attribute(attribute)
           arel_values = formatted_values_for_attribute(attribute)
-          predicate = attribute.attr.public_send(arel_pred, arel_values)
+          predicate = attr_value_for_attribute(attribute).public_send(arel_pred, arel_values)
 
           if in_predicate?(predicate)
             predicate.right = predicate.right.map do |pr|
@@ -43,16 +43,24 @@ module Ransack
 
         def in_predicate?(predicate)
           return unless defined?(Arel::Nodes::Casted)
-          predicate.class == Arel::Nodes::In
+          predicate.class == Arel::Nodes::In || predicate.class == Arel::Nodes::NotIn
         end
 
         def casted_array?(predicate)
-          predicate.respond_to?(:val) && predicate.val.is_a?(Array)
+          value_from(predicate).is_a?(Array) && predicate.is_a?(Arel::Nodes::Casted)
+        end
+
+        def value_from(predicate)
+          if predicate.respond_to?(:value)
+            predicate.value # Rails 6.1
+          elsif predicate.respond_to?(:val)
+            predicate.val # Rails 5.2, 6.0
+          end
         end
 
         def format_values_for(predicate)
-          predicate.val.map do |value|
-            value.is_a?(String) ? Arel::Nodes.build_quoted(value) : value
+          value_from(predicate).map do |val|
+            val.is_a?(String) ? Arel::Nodes.build_quoted(val) : val
           end
         end
 

data/lib/ransack/adapters/active_record/ransack/translate.rb

@@ -2,7 +2,7 @@ module Ransack
   module Translate
 
     def self.i18n_key(klass)
-      klass.model_name.i18n_key.to_s.freeze
+      klass.model_name.i18n_key
     end
   end
 end

data/lib/ransack/configuration.rb

@@ -33,7 +33,9 @@ module Ransack
       :up_arrow => '▼'.freeze,
       :down_arrow => '▲'.freeze,
       :default_arrow => nil,
-      :sanitize_scope_args => true
+      :sanitize_scope_args => true,
+      :postgres_fields_sort_option => nil,
+      :strip_whitespace => true
     }
 
     def configure
@@ -141,6 +143,21 @@ module Ransack
       self.options[:sanitize_scope_args] = boolean
     end
 
+    # The `NULLS FIRST` and `NULLS LAST` options can be used to determine
+    # whether nulls appear before or after non-null values in the sort ordering.
+    #
+    # User may want to configure it like this:
+    #
+    # Ransack.configure do |c|
+    #   c.postgres_fields_sort_option = :nulls_first # or e.g. :nulls_always_last
+    # end
+    #
+    # See this feature: https://www.postgresql.org/docs/13/queries-order.html
+    #
+    def postgres_fields_sort_option=(setting)
+      self.options[:postgres_fields_sort_option] = setting
+    end
+
     # By default, Ransack displays sort order indicator arrows in sort links.
     # The default may be globally overridden in an initializer file like
     # `config/initializers/ransack.rb` as follows:
@@ -154,6 +171,19 @@ module Ransack
       self.options[:hide_sort_order_indicators] = boolean
     end
 
+    # By default, Ransack displays strips all whitespace when searching for a string.
+    # The default may be globally changed in an initializer file like
+    # `config/initializers/ransack.rb` as follows:
+    #
+    # Ransack.configure do |config|
+    #   # Enable whitespace stripping for string searches
+    #   config.strip_whitespace = true
+    # end
+    #
+    def strip_whitespace=(boolean)
+      self.options[:strip_whitespace] = boolean
+    end
+
     def arel_predicate_with_suffix(arel_predicate, suffix)
       if arel_predicate === Proc
         proc { |v| "#{arel_predicate.call(v)}#{suffix}" }

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,12 +45,10 @@ module Ransack
     NOT_EQ_ALL          = 'not_eq_all'.freeze
     CONT                = 'cont'.freeze
 
-    RAILS_5_1           = '5.1'.freeze
-    RAILS_5_2           = '5.2'.freeze
-    RAILS_5_2_0         = '5.2.0'.freeze
+    RAILS_6_0           = '6.0.0'.freeze
+    RAILS_6_1           = '6.1.0'.freeze
 
     RANSACK_SLASH_SEARCHES = 'ransack/searches'.freeze
     RANSACK_SLASH_SEARCHES_SLASH_SEARCH = 'ransack/searches/search'.freeze
   end
 end
-