ransack 1.7.0 → 2.1.1

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

@@ -3,48 +3,51 @@ 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
+        def combinator_method
+          combinator === Constants::OR ? :or : :and
         end
 
-        def arel_predicate_for(predicates)
-          if predicates.size > 1
-            combinator_for(predicates)
-          else
-            format_predicate(predicates.first)
-          end
-        end
+        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)
 
-        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(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
+        end
+
+        def casted_array?(predicate)
+          predicate.respond_to?(:val) && predicate.val.is_a?(Array)
         end
 
         def format_values_for(predicate)

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.to_s.freeze
     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,35 @@ 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
     }
 
     def configure
@@ -61,12 +86,74 @@ 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
+
+    # 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,9 @@ module Ransack
     NOT_EQ_ALL          = 'not_eq_all'.freeze
     CONT                = 'cont'.freeze
 
-    RAILS_4_1           = '4.1'.freeze
+    RAILS_5_1           = '5.1'.freeze
+    RAILS_5_2           = '5.2'.freeze
+    RAILS_5_2_0         = '5.2.0'.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,13 +58,14 @@ 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
+      str ||= ''.freeze
 
-      if (segments = str.split(/_/)).size > 0
+      if (segments = str.split(Constants::UNDERSCORE)).size > 0
         remainder = []
         found_assoc = nil
         while !found_assoc && segments.size > 0 do
@@ -72,9 +76,8 @@ module Ransack
             )
           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
@@ -88,11 +91,11 @@ 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
+      if (segments = str.split(Constants::UNDERSCORE)).size > 0
         while segments.size > 0 &&
         !base.columns_hash[segments.join(Constants::UNDERSCORE)] &&
         association_parts << segments.shift do
@@ -118,6 +121,10 @@ 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)
@@ -128,18 +135,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

data/lib/ransack/helpers/form_builder.rb

@@ -6,8 +6,20 @@ module ActionView::Helpers::Tags
   # https://github.com/rails/rails/commit/c1a118a
   class Base
     private
-    def value(object)
-      object.send @method_name if object # use send instead of public_send
+    if defined? ::ActiveRecord
+      if ::ActiveRecord::VERSION::STRING < '5.2'
+        def value(object)
+          object.send @method_name if object # use send instead of public_send
+        end
+      else # rails/rails#29791
+        def value
+          if @allow_method_names_outside_object
+            object.send @method_name if object && object.respond_to?(@method_name, true)
+          else
+            object.send @method_name if object
+          end
+        end
+      end
     end
   end
 end
@@ -15,8 +27,7 @@ end
 RANSACK_FORM_BUILDER = 'RANSACK_FORM_BUILDER'.freeze
 
 require 'simple_form' if
-  (ENV[RANSACK_FORM_BUILDER] || Ransack::Constants::EMPTY)
-  .match('SimpleForm'.freeze)
+  (ENV[RANSACK_FORM_BUILDER] || ''.freeze).match('SimpleForm'.freeze)
 
 module Ransack
   module Helpers
@@ -47,7 +58,7 @@ module Ransack
         raise ArgumentError, formbuilder_error_message(
           "#{action}_select") unless object.respond_to?(:context)
         options[:include_blank] = true unless options.has_key?(:include_blank)
-        bases = [Constants::EMPTY] + association_array(options[:associations])
+        bases = [''.freeze].freeze + association_array(options[:associations])
         if bases.size > 1
           collection = attribute_collection_for_bases(action, bases)
           object.name ||= default if can_use_default?(
@@ -66,13 +77,13 @@ module Ransack
       def sort_direction_select(options = {}, html_options = {})
         unless object.respond_to?(:context)
           raise ArgumentError,
-          formbuilder_error_message(Constants::SORT_DIRECTION)
+          formbuilder_error_message('sort_direction'.freeze)
         end
         template_collection_select(:dir, sort_array, options, html_options)
       end
 
       def sort_select(options = {}, html_options = {})
-        attribute_select(options, html_options, Constants::SORT) +
+        attribute_select(options, html_options, 'sort'.freeze) +
         sort_direction_select(options, html_options)
       end
 
@@ -84,6 +95,10 @@ module Ransack
         @template.sort_link @object, attribute, *args
       end
 
+      def sort_url(attribute, *args)
+        @template.sort_url @object, attribute, *args
+      end
+
       def condition_fields(*args, &block)
         search_fields(:c, args, block)
       end
@@ -135,7 +150,7 @@ module Ransack
           else
             only = Array.wrap(only).map(&:to_s)
             keys = keys.select {
-              |k| only.include? k.sub(/_(any|all)$/, Constants::EMPTY)
+              |k| only.include? k.sub(/_(any|all)$/, ''.freeze)
             }
           end
         end
@@ -177,9 +192,9 @@ module Ransack
 
       def sort_array
         [
-          [Constants::ASC,  object.translate(Constants::ASC)],
-          [Constants::DESC, object.translate(Constants::DESC)]
-        ]
+          ['asc'.freeze,  object.translate('asc'.freeze)].freeze,
+          ['desc'.freeze, object.translate('desc'.freeze)].freeze
+        ].freeze
       end
 
       def combinator_choices
@@ -234,7 +249,7 @@ module Ransack
             Translate.association(base, :context => object.context),
             collection_for_base(action, base)
           ]
-        rescue UntraversableAssociationError => e
+        rescue UntraversableAssociationError
           nil
         end
       end