ransack 1.7.0 → 2.4.1

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

@@ -3,53 +3,63 @@ module Ransack
     class Condition
 
       def arel_predicate
-        arel_predicate_for(attributes_array)
+        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)
       end
 
       private
 
-        def attributes_array
-          attributes.map do |a|
-            a.attr.send(
-              arel_predicate_for_attribute(a), formatted_values_for_attribute(a)
-            )
-          end
-        end
-
-        def arel_predicate_for(predicates)
-          if predicates.size > 1
-            combinator_for(predicates)
-          else
-            format_predicate(predicates.first)
-          end
+        def combinator_method
+          combinator === Constants::OR ? :or : :and
         end
 
-        def combinator_for(predicates)
-          if combinator === Constants::AND
-            Arel::Nodes::Grouping.new(Arel::Nodes::And.new(predicates))
-          elsif combinator === Constants::OR
-            predicates.inject(&:or)
-          end
-        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)
 
-        def format_predicate(predicate)
-          predicate.tap do
-            if casted_array_with_in_predicate?(predicate)
-              predicate.right[0] = format_values_for(predicate.right[0])
+          if in_predicate?(predicate)
+            predicate.right = predicate.right.map do |pr|
+              casted_array?(pr) ? format_values_for(pr) : pr
             end
           end
+
+          predicate
         end
 
-        def casted_array_with_in_predicate?(predicate)
+        def in_predicate?(predicate)
           return unless defined?(Arel::Nodes::Casted)
-          predicate.class == Arel::Nodes::In &&
-          predicate.right[0].respond_to?(:val) &&
-          predicate.right[0].val.is_a?(Array)
+          predicate.class == Arel::Nodes::In || predicate.class == Arel::Nodes::NotIn
+        end
+
+        def casted_array?(predicate)
+          (predicate.respond_to?(:value) && predicate.value.is_a?(Array)) || # Rails 6.1
+            (predicate.respond_to?(:val) && predicate.val.is_a?(Array)) # Rails 5.2, 6.0
         end
 
         def format_values_for(predicate)
-          predicate.val.map do |value|
-            value.is_a?(String) ? Arel::Nodes.build_quoted(value) : value
+          value = if predicate.respond_to?(:value)
+                    predicate.value # Rails 6.1
+                  else
+                    predicate.val # Rails 5.2, 6.0
+                  end
+
+          value.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,11 +2,7 @@ module Ransack
   module Translate
 
     def self.i18n_key(klass)
-      if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0
-        klass.model_name.i18n_key.to_s.tr('.'.freeze, '/'.freeze)
-      else
-        klass.model_name.i18n_key.to_s.freeze
-      end
+      klass.model_name.i18n_key
     end
   end
 end

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

@@ -20,5 +20,28 @@ module Ransack
       end
     end
 
+    def visit_Ransack_Nodes_Sort(object)
+      if object.valid?
+        if object.attr.is_a?(Arel::Attributes::Attribute)
+          object.attr.send(object.dir)
+        else
+          ordered(object)
+        end
+      else
+        scope_name = :"sort_by_#{object.name}_#{object.dir}"
+        scope_name if object.context.object.respond_to?(scope_name)
+      end
+    end
+
+    private
+
+      def ordered(object)
+        case object.dir
+        when 'asc'.freeze
+          Arel::Nodes::Ascending.new(object.attr)
+        when 'desc'.freeze
+          Arel::Nodes::Descending.new(object.attr)
+        end
+      end
   end
 end

data/lib/ransack/adapters/active_record.rb

@@ -1,13 +1,14 @@
 require 'ransack/adapters/active_record/base'
-ActiveRecord::Base.extend Ransack::Adapters::ActiveRecord::Base
 
-case ActiveRecord::VERSION::STRING
-when /^3\.0\./
-  require 'ransack/adapters/active_record/3.0/context'
-when /^3\.1\./
-  require 'ransack/adapters/active_record/3.1/context'
-when /^3\.2\./
-  require 'ransack/adapters/active_record/3.2/context'
-else
-  require 'ransack/adapters/active_record/context'
+ActiveSupport.on_load(:active_record) do
+  extend Ransack::Adapters::ActiveRecord::Base
+
+  Ransack::SUPPORTS_ATTRIBUTE_ALIAS =
+  begin
+    ActiveRecord::Base.respond_to?(:attribute_aliases)
+  rescue NameError
+    false
+  end
 end
+
+require 'ransack/adapters/active_record/context'

data/lib/ransack/adapters.rb

@@ -1,42 +1,64 @@
 module Ransack
   module Adapters
 
-    def self.current_adapters
-      @current_adapters ||= {
-        :active_record => defined?(::ActiveRecord::Base),
-        :mongoid => defined?(::Mongoid) && !defined?(::ActiveRecord::Base)
-      }
+    def self.object_mapper
+      @object_mapper ||= instantiate_object_mapper
     end
-    def self.require_constants
-      require 'ransack/adapters/mongoid/ransack/constants' if current_adapters[:mongoid]
-      require 'ransack/adapters/active_record/ransack/constants' if current_adapters[:active_record]
+
+    def self.instantiate_object_mapper
+      if defined?(::ActiveRecord::Base)
+        ActiveRecordAdapter.new
+      elsif defined?(::Mongoid)
+        MongoidAdapter.new
+      else
+        raise "Unsupported adapter"
+      end
     end
 
-    def self.require_adapter
-      if current_adapters[:active_record]
+    class ActiveRecordAdapter
+      def require_constants
+        require 'ransack/adapters/active_record/ransack/constants'
+      end
+
+      def require_adapter
         require 'ransack/adapters/active_record/ransack/translate'
         require 'ransack/adapters/active_record'
       end
 
-      if current_adapters[:mongoid]
+      def require_context
+        require 'ransack/adapters/active_record/ransack/visitor'
+      end
+
+      def require_nodes
+        require 'ransack/adapters/active_record/ransack/nodes/condition'
+      end
+
+      def require_search
+        require 'ransack/adapters/active_record/ransack/context'
+      end
+    end
+
+    class MongoidAdapter
+      def require_constants
+        require 'ransack/adapters/mongoid/ransack/constants'
+      end
+
+      def require_adapter
         require 'ransack/adapters/mongoid/ransack/translate'
         require 'ransack/adapters/mongoid'
       end
-    end
 
-    def self.require_context
-      require 'ransack/adapters/active_record/ransack/visitor' if current_adapters[:active_record]
-      require 'ransack/adapters/mongoid/ransack/visitor' if current_adapters[:mongoid]
-    end
+      def require_context
+        require 'ransack/adapters/mongoid/ransack/visitor'
+      end
 
-    def self.require_nodes
-      require 'ransack/adapters/active_record/ransack/nodes/condition' if current_adapters[:active_record]
-      require 'ransack/adapters/mongoid/ransack/nodes/condition' if current_adapters[:mongoid]
-    end
+      def require_nodes
+        require 'ransack/adapters/mongoid/ransack/nodes/condition'
+      end
 
-    def self.require_search
-      require 'ransack/adapters/active_record/ransack/context' if current_adapters[:active_record]
-      require 'ransack/adapters/mongoid/ransack/context' if current_adapters[:mongoid]
+      def require_search
+        require 'ransack/adapters/mongoid/ransack/context'
+      end
     end
   end
 end

data/lib/ransack/configuration.rb

@@ -5,10 +5,36 @@ module Ransack
   module Configuration
 
     mattr_accessor :predicates, :options
-    self.predicates = {}
+
+    class PredicateCollection
+      attr_reader :sorted_names_with_underscores
+
+      def initialize
+        @collection = {}
+        @sorted_names_with_underscores = []
+      end
+
+      delegate :[], :keys, :has_key?, to: :@collection
+
+      def []=(key, value)
+        @sorted_names_with_underscores << [key, '_' + key]
+        @sorted_names_with_underscores.sort! { |(a, _), (b, _)| b.length <=> a.length }
+
+        @collection[key] = value
+      end
+    end
+
+    self.predicates = PredicateCollection.new
+
     self.options = {
       :search_key => :q,
-      :ignore_unknown_conditions => true
+      :ignore_unknown_conditions => true,
+      :hide_sort_order_indicators => false,
+      :up_arrow => '&#9660;'.freeze,
+      :down_arrow => '&#9650;'.freeze,
+      :default_arrow => nil,
+      :sanitize_scope_args => true,
+      :postgres_fields_sort_option => nil
     }
 
     def configure
@@ -61,12 +87,89 @@ module Ransack
       self.options[:search_key] = name
     end
 
-    # Raise an error if an unknown predicate, condition or attribute is passed
-    # into a search.
+    # By default Ransack ignores errors if an unknown predicate, condition or
+    # attribute is passed into a search. The default may be overridden in an
+    # initializer file like `config/initializers/ransack.rb` as follows:
+    #
+    # Ransack.configure do |config|
+    #   # Raise if an unknown predicate, condition or attribute is passed
+    #   config.ignore_unknown_conditions = false
+    # end
+    #
     def ignore_unknown_conditions=(boolean)
       self.options[:ignore_unknown_conditions] = boolean
     end
 
+    # By default, Ransack displays sort order indicator arrows with HTML codes:
+    #
+    #   up_arrow:   '&#9660;'
+    #   down_arrow: '&#9650;'
+    #
+    # There is also a default arrow which is displayed if a column is not sorted.
+    # By default this is nil so nothing will be displayed.
+    #
+    # Any of the defaults may be globally overridden in an initializer file
+    # like `config/initializers/ransack.rb` as follows:
+    #
+    # Ransack.configure do |config|
+    #   # Globally set the up arrow to an icon, and the down and default arrows to unicode.
+    #   config.custom_arrows = {
+    #     up_arrow:   '<i class="fa fa-long-arrow-up"></i>',
+    #     down_arrow: 'U+02193',
+    #     default_arrow: 'U+11047'
+    #   }
+    # end
+    #
+    def custom_arrows=(opts = {})
+      self.options[:up_arrow] = opts[:up_arrow].freeze if opts[:up_arrow]
+      self.options[:down_arrow] = opts[:down_arrow].freeze if opts[:down_arrow]
+      self.options[:default_arrow] = opts[:default_arrow].freeze if opts[:default_arrow]
+    end
+
+    # Ransack sanitizes many values in your custom scopes into booleans.
+    # [1, '1', 't', 'T', 'true', 'TRUE'] all evaluate to true.
+    # [0, '0', 'f', 'F', 'false', 'FALSE'] all evaluate to false.
+    #
+    # This default may be globally overridden in an initializer file like
+    # `config/initializers/ransack.rb` as follows:
+    #
+    # Ransack.configure do |config|
+    #   # Accept my custom scope values as what they are.
+    #   config.sanitize_custom_scope_booleans = false
+    # end
+    #
+    def sanitize_custom_scope_booleans=(boolean)
+      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 :nulls_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:
+    #
+    # Ransack.configure do |config|
+    #   # Hide sort link order indicators globally across the application
+    #   config.hide_sort_order_indicators = true
+    # end
+    #
+    def hide_sort_order_indicators=(boolean)
+      self.options[:hide_sort_order_indicators] = 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

@@ -1,19 +1,7 @@
 module Ransack
   module Constants
-    ASC                 = 'asc'.freeze
-    DESC                = 'desc'.freeze
-    ASC_DESC            = [ASC, DESC].freeze
-
-    ASC_ARROW           = '▲'.freeze
-    DESC_ARROW          = '▼'.freeze
-
     OR                  = 'or'.freeze
     AND                 = 'and'.freeze
-    SPACED_AND          = ' AND '.freeze
-
-    SORT                = 'sort'.freeze
-    SORT_LINK           = 'sort_link'.freeze
-    SORT_DIRECTION      = 'sort_direction'.freeze
 
     CAP_SEARCH          = 'Search'.freeze
     SEARCH              = 'search'.freeze
@@ -23,17 +11,12 @@ module Ransack
     ATTRIBUTES          = 'attributes'.freeze
     COMBINATOR          = 'combinator'.freeze
 
-    SPACE               = ' '.freeze
-    COMMA_SPACE         = ', '.freeze
-    COLON_SPACE         = ': '.freeze
     TWO_COLONS          = '::'.freeze
     UNDERSCORE          = '_'.freeze
     LEFT_PARENTHESIS    = '('.freeze
     Q                   = 'q'.freeze
     I                   = 'i'.freeze
-    NON_BREAKING_SPACE  = ' '.freeze
     DOT_ASTERIX         = '.*'.freeze
-    EMPTY               = ''.freeze
 
     STRING_JOIN         = 'string_join'.freeze
     ASSOCIATION_JOIN    = 'association_join'.freeze
@@ -44,14 +27,17 @@ module Ransack
     FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE'].to_set
     BOOLEAN_VALUES = (TRUE_VALUES + FALSE_VALUES).freeze
 
-    S_SORTS             = %w(s sorts).freeze
-    AND_OR              = %w(and or).freeze
-    IN_NOT_IN           = %w(in not_in).freeze
-    SUFFIXES            = %w(_any _all).freeze
-    AREL_PREDICATES     = %w(
-      eq not_eq matches does_not_match lt lteq gt gteq in not_in
-    ).freeze
-    A_S_I               = %w(a s i).freeze
+    AND_OR              = ['and'.freeze, 'or'.freeze].freeze
+    IN_NOT_IN           = ['in'.freeze, 'not_in'.freeze].freeze
+    SUFFIXES            = ['_any'.freeze, '_all'.freeze].freeze
+    AREL_PREDICATES     = [
+      'eq'.freeze, 'not_eq'.freeze,
+      'matches'.freeze, 'does_not_match'.freeze,
+      'lt'.freeze, 'lteq'.freeze,
+      'gt'.freeze, 'gteq'.freeze,
+      'in'.freeze, 'not_in'.freeze
+      ].freeze
+    A_S_I               = ['a'.freeze, 's'.freeze, 'i'.freeze].freeze
 
     EQ                  = 'eq'.freeze
     NOT_EQ              = 'not_eq'.freeze
@@ -59,7 +45,8 @@ module Ransack
     NOT_EQ_ALL          = 'not_eq_all'.freeze
     CONT                = 'cont'.freeze
 
-    RAILS_4_1           = '4.1'.freeze
+    RAILS_6_0           = '6.0.0'.freeze
+    RAILS_6_1_ALPHA     = '6.1.0.alpha'.freeze
 
     RANSACK_SLASH_SEARCHES = 'ransack/searches'.freeze
     RANSACK_SLASH_SEARCHES_SLASH_SEARCH = 'ransack/searches/search'.freeze

data/lib/ransack/context.rb

@@ -1,5 +1,5 @@
 require 'ransack/visitor'
-Ransack::Adapters.require_context
+Ransack::Adapters.object_mapper.require_context
 
 module Ransack
   class Context
@@ -17,9 +17,12 @@ module Ransack
       end
 
       def for(object, options = {})
-        context = Class === object ?
-          for_class(object, options) :
-          for_object(object, options)
+        context =
+          if Class === object
+            for_class(object, options)
+          else
+            for_object(object, options)
+          end
         context or raise ArgumentError,
           "Don't know what context to use for #{object}"
       end
@@ -37,7 +40,7 @@ module Ransack
     # Convert a string representing a chain of associations and an attribute
     # into the attribute itself
     def contextualize(str)
-      parent, attr_name = @bind_pairs[str]
+      parent, attr_name = bind_pair_for(str)
       table_for(parent)[attr_name]
     end
 
@@ -55,32 +58,34 @@ module Ransack
     end
 
     def bind(object, str)
-      object.parent, object.attr_name = @bind_pairs[str]
+      return nil unless str
+      object.parent, object.attr_name = bind_pair_for(str)
     end
 
     def traverse(str, base = @base)
-      str ||= Constants::EMPTY
-
-      if (segments = str.split(/_/)).size > 0
+      str ||= ''.freeze
+      segments = str.split(Constants::UNDERSCORE)
+      unless segments.empty?
         remainder = []
         found_assoc = nil
-        while !found_assoc && segments.size > 0 do
+        until found_assoc || segments.empty?
           # Strip the _of_Model_type text from the association name, but hold
           # onto it in klass, for use as the next base
           assoc, klass = unpolymorphize_association(
             segments.join(Constants::UNDERSCORE)
-            )
+          )
           if found_assoc = get_association(assoc, base)
             base = traverse(
-              remainder.join(
-                Constants::UNDERSCORE), klass || found_assoc.klass
-                )
+              remainder.join(Constants::UNDERSCORE), klass || found_assoc.klass
+            )
           end
 
           remainder.unshift segments.pop
         end
-        raise UntraversableAssociationError,
-          "No association matches #{str}" unless found_assoc
+        unless found_assoc
+          raise(UntraversableAssociationError,
+                "No association matches #{str}")
+        end
       end
 
       klassify(base)
@@ -88,22 +93,21 @@ module Ransack
 
     def association_path(str, base = @base)
       base = klassify(base)
-      str ||= Constants::EMPTY
+      str ||= ''.freeze
       path = []
-      segments = str.split(/_/)
+      segments = str.split(Constants::UNDERSCORE)
       association_parts = []
-      if (segments = str.split(/_/)).size > 0
-        while segments.size > 0 &&
-        !base.columns_hash[segments.join(Constants::UNDERSCORE)] &&
-        association_parts << segments.shift do
+      unless segments.empty?
+        while !segments.empty? &&
+              !base.columns_hash[segments.join(Constants::UNDERSCORE)] &&
+              association_parts << segments.shift
           assoc, klass = unpolymorphize_association(
             association_parts.join(Constants::UNDERSCORE)
-            )
-          if found_assoc = get_association(assoc, base)
-            path += association_parts
-            association_parts = []
-            base = klassify(klass || found_assoc)
-          end
+          )
+          next unless found_assoc = get_association(assoc, base)
+          path += association_parts
+          association_parts = []
+          base = klassify(klass || found_assoc)
         end
       end
 
@@ -118,9 +122,13 @@ module Ransack
       end
     end
 
+    def ransackable_alias(str)
+      klass._ransack_aliases.fetch(str, str)
+    end
+
     def ransackable_attribute?(str, klass)
       klass.ransackable_attributes(auth_object).include?(str) ||
-      klass.ransortable_attributes(auth_object).include?(str)
+        klass.ransortable_attributes(auth_object).include?(str)
     end
 
     def ransackable_association?(str, klass)
@@ -128,18 +136,22 @@ module Ransack
     end
 
     def ransackable_scope?(str, klass)
-      klass.ransackable_scopes(auth_object).any? { |s| s.to_s == str }
+      klass.ransackable_scopes(auth_object).any? { |s| s.to_sym == str.to_sym }
+    end
+
+    def ransackable_scope_skip_sanitize_args?(str, klass)
+      klass.ransackable_scopes_skip_sanitize_args.any? { |s| s.to_sym == str.to_sym }
     end
 
-    def searchable_attributes(str = Constants::EMPTY)
+    def searchable_attributes(str = ''.freeze)
       traverse(str).ransackable_attributes(auth_object)
     end
 
-    def sortable_attributes(str = Constants::EMPTY)
+    def sortable_attributes(str = ''.freeze)
       traverse(str).ransortable_attributes(auth_object)
     end
 
-    def searchable_associations(str = Constants::EMPTY)
+    def searchable_associations(str = ''.freeze)
       traverse(str).ransackable_associations(auth_object)
     end
   end