ransack 1.7.0 → 1.8.0

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

@@ -27,6 +27,8 @@ module Ransack
       @join_dependency = join_dependency(@object)
       @join_type = options[:join_type] || Polyamorous::OuterJoin
       @search_key = options[:search_key] || Ransack.options[:search_key]
+      @associations_pot = {}
+      @lock_associations = []
 
       if ::ActiveRecord::VERSION::STRING >= Constants::RAILS_4_1
         @base = @join_dependency.join_root
@@ -40,7 +42,7 @@ module Ransack
         @base.table_name, as: @base.aliased_table_name, type_caster: self
         )
       @bind_pairs = Hash.new do |hash, key|
-        parent, attr_name = get_parent_and_attribute_name(key.to_s)
+        parent, attr_name = get_parent_and_attribute_name(key)
         if parent && attr_name
           hash[key] = [parent, attr_name]
         end

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

@@ -3,41 +3,33 @@ 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)
+            query.where(format_predicate(attribute).not)
+            context.remove_association(association)
+            Arel::Nodes::NotIn.new(context.primary_key, Arel.sql(query.to_sql))
+          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
-        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
+        def combinator_method
+          combinator === Constants::OR ? :or : :and
         end
 
-        def format_predicate(predicate)
-          predicate.tap do
-            if casted_array_with_in_predicate?(predicate)
-              predicate.right[0] = format_values_for(predicate.right[0])
-            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)
+          if casted_array_with_in_predicate?(predicate)
+            predicate.right[0] = format_values_for(predicate.right[0])
           end
+          predicate
         end
 
         def casted_array_with_in_predicate?(predicate)

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

@@ -33,6 +33,14 @@ module Ransack
         end
 
         module ClassMethods
+          def _ransack_aliases
+            @_ransack_aliases ||= {}
+          end
+
+          def _ransack_aliases=(value)
+            @_ransack_aliases = value
+          end
+
           def _ransackers
             @_ransackers ||= {}
           end
@@ -49,13 +57,18 @@ module Ransack
 
           alias_method :search, :ransack
 
+          def ransack_alias(new_name, old_name)
+            self._ransack_aliases.store(new_name.to_s, old_name.to_s)
+          end
+
           def ransacker(name, opts = {}, &block)
             self._ransackers = _ransackers.merge name.to_s => Ransacker
               .new(self, name, opts, &block)
           end
 
           def all_ransackable_attributes
-            ['id'] + column_names.select { |c| c != '_id' } + _ransackers.keys
+            ['id'] + column_names.select { |c| c != '_id' } + _ransackers.keys +
+              _ransack_aliases.keys
           end
 
           def ransackable_attributes(auth_object = nil)
@@ -73,7 +86,9 @@ module Ransack
           end
 
           def reflect_on_all_associations_all
-            reflect_on_all_associations(:belongs_to, :has_one, :has_many, :embeds_many, :embedded_in)
+            reflect_on_all_associations(
+              :belongs_to, :has_one, :has_many, :embeds_many, :embedded_in
+              )
           end
 
           # For overriding with a whitelist of symbols
@@ -116,10 +131,10 @@ module Ransack
           end
 
           def table
-            name = ::Ransack::Adapters::Mongoid::Attributes::Attribute.new(self.criteria, :name)
-            {
-              :name => name
-            }
+            name = ::Ransack::Adapters::Mongoid::Attributes::Attribute.new(
+              self.criteria, :name
+              )
+            { :name => name }
           end
 
         end

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

@@ -6,10 +6,6 @@ module Ransack
     module Mongoid
       class Context < ::Ransack::Context
 
-        # Because the AR::Associations namespace is insane
-        # JoinDependency = ::Mongoid::Associations::JoinDependency
-        # JoinPart = JoinDependency::JoinPart
-
         def initialize(object, options = {})
           super
           # @arel_visitor = @engine.connection.visitor
@@ -100,6 +96,14 @@ module Ransack
           end
         end
 
+        def lock_association(association)
+          warn "lock_association is not implemented for Ransack mongoid adapter" if $DEBUG
+        end
+
+        def remove_association(association)
+          warn "remove_association is not implemented for Ransack mongoid adapter" if $DEBUG
+        end
+
       private
 
         def get_parent_and_attribute_name(str, parent = @base)
@@ -132,7 +136,7 @@ module Ransack
         end
 
         def join_dependency(relation)
-          if relation.respond_to?(:join_dependency) # Squeel will enable this
+          if relation.respond_to?(:join_dependency) # Polyamorous enables this
             relation.join_dependency
           else
             build_join_dependency(relation)

data/lib/ransack/configuration.rb

@@ -8,7 +8,8 @@ module Ransack
     self.predicates = {}
     self.options = {
       :search_key => :q,
-      :ignore_unknown_conditions => true
+      :ignore_unknown_conditions => true,
+      :hide_sort_order_indicators => false
     }
 
     def configure
@@ -61,12 +62,32 @@ 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 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,10 @@
 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 +14,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 +30,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

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
@@ -55,11 +58,12 @@ module Ransack
     end
 
     def bind(object, str)
+      return nil unless str
       object.parent, object.attr_name = @bind_pairs[str]
     end
 
     def traverse(str, base = @base)
-      str ||= Constants::EMPTY
+      str ||= ''.freeze
 
       if (segments = str.split(/_/)).size > 0
         remainder = []
@@ -68,13 +72,12 @@ module Ransack
           # 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)
+            segments.join('_'.freeze)
             )
           if found_assoc = get_association(assoc, base)
             base = traverse(
-              remainder.join(
-                Constants::UNDERSCORE), klass || found_assoc.klass
-                )
+              remainder.join('_'.freeze), klass || found_assoc.klass
+              )
           end
 
           remainder.unshift segments.pop
@@ -88,7 +91,7 @@ module Ransack
 
     def association_path(str, base = @base)
       base = klassify(base)
-      str ||= Constants::EMPTY
+      str ||= ''.freeze
       path = []
       segments = str.split(/_/)
       association_parts = []
@@ -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)
@@ -131,15 +138,15 @@ module Ransack
       klass.ransackable_scopes(auth_object).any? { |s| s.to_s == str }
     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

@@ -15,8 +15,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 +46,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 +65,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
 
@@ -135,7 +134,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

data/lib/ransack/helpers/form_helper.rb

@@ -38,43 +38,41 @@ module Ransack
       #
       #   <%= sort_link(@q, :name, [:name, 'kind ASC'], 'Player Name') %>
       #
-      def sort_link(search_object, attribute, *args)
+      #   You can also use a block:
+      #
+      #   <%= sort_link(@q, :name, [:name, 'kind ASC']) do %>
+      #     <strong>Player Name</strong>
+      #   <% end %>
+      #
+      def sort_link(search_object, attribute, *args, &block)
         search, routing_proxy = extract_search_and_routing_proxy(search_object)
         unless Search === search
           raise TypeError, 'First argument must be a Ransack::Search!'
         end
-        s = SortLink.new(search, attribute, args, params)
+        args.unshift(capture(&block)) if block_given?
+        s = SortLink.new(search, attribute, args, params, &block)
         link_to(s.name, url(routing_proxy, s.url_options), s.html_options(args))
       end
 
       private
 
         def options_for(record)
-          record.map &method(:parse_record)
+          record.map { |r| parse_record(r) }
         end
 
         def parse_record(object)
-          if object.is_a?(Ransack::Search)
-            object.klass
-          else
-            object
-          end
+          return object.klass if object.is_a?(Ransack::Search)
+          object
         end
 
         def html_option_for(option, search)
-          if option.present?
-            option.to_s
-          else
-            "#{search.klass.to_s.underscore}_search"
-          end
+          return option.to_s if option.present?
+          "#{search.klass.to_s.underscore}_search"
         end
 
         def extract_search_and_routing_proxy(search)
-          if search.is_a? Array
-            [search.second, search.first]
-          else
-            [search, nil]
-          end
+          return [search[1], search[0]] if search.is_a?(Array)
+          [search, nil]
         end
 
         def url(routing_proxy, options_for_url)
@@ -88,20 +86,21 @@ module Ransack
       class SortLink
         def initialize(search, attribute, args, params)
           @search         = search
-          @params         = params
+          @params         = parameters_hash(params)
           @field          = attribute.to_s
           @sort_fields    = extract_sort_fields_and_mutate_args!(args).compact
           @current_dir    = existing_sort_direction
           @label_text     = extract_label_and_mutate_args!(args)
           @options        = extract_options_and_mutate_args!(args)
-          @hide_indicator = @options.delete :hide_indicator
+          @hide_indicator = @options.delete(:hide_indicator) ||
+                            Ransack.options[:hide_sort_order_indicators]
           @default_order  = @options.delete :default_order
         end
 
         def name
           [ERB::Util.h(@label_text), order_indicator]
           .compact
-          .join(Constants::NON_BREAKING_SPACE)
+          .join('&nbsp;'.freeze)
           .html_safe
         end
 
@@ -114,35 +113,34 @@ module Ransack
         def html_options(args)
           html_options = extract_options_and_mutate_args!(args)
           html_options.merge(
-            class: [[Constants::SORT_LINK, @current_dir], html_options[:class]]
-                   .compact.join(Constants::SPACE)
+            class: [['sort_link'.freeze, @current_dir], html_options[:class]]
+                   .compact.join(' '.freeze)
           )
         end
 
         private
 
-          def extract_sort_fields_and_mutate_args!(args)
-            if args.first.is_a? Array
-              args.shift
+          def parameters_hash(params)
+            if ::ActiveRecord::VERSION::MAJOR == 5 && params.respond_to?(:to_unsafe_h)
+              params.to_unsafe_h
             else
-              [@field]
+              params
             end
           end
 
+          def extract_sort_fields_and_mutate_args!(args)
+            return args.shift if args[0].is_a?(Array)
+            [@field]
+          end
+
           def extract_label_and_mutate_args!(args)
-            if args.first.is_a? String
-              args.shift
-            else
-              Translate.attribute(@field, context: @search.context)
-            end
+            return args.shift if args[0].is_a?(String)
+            Translate.attribute(@field, context: @search.context)
           end
 
           def extract_options_and_mutate_args!(args)
-            if args.first.is_a? Hash
-              args.shift.with_indifferent_access
-            else
-              {}
-            end
+            return args.shift.with_indifferent_access if args[0].is_a?(Hash)
+            {}
           end
 
           def search_and_sort_params
@@ -155,11 +153,8 @@ module Ransack
 
           def sort_params
             sort_array = recursive_sort_params_build(@sort_fields)
-            if sort_array.size == 1
-              sort_array.first
-            else
-              sort_array
-            end
+            return sort_array[0] if sort_array.length == 1
+            sort_array
           end
 
           def recursive_sort_params_build(fields)
@@ -179,52 +174,38 @@ module Ransack
             if sort_dir = existing_sort_direction(attr_name)
               direction_text(sort_dir)
             else
-              default_sort_order(attr_name) || Constants::ASC
+              default_sort_order(attr_name) || 'asc'.freeze
             end
           end
 
-          def existing_sort_direction(attr_name = @field)
-            if sort = @search.sorts.detect { |s| s && s.name == attr_name }
-              sort.dir
-            end
+          def existing_sort_direction(f = @field)
+            return unless sort = @search.sorts.detect { |s| s && s.name == f }
+            sort.dir
           end
 
           def default_sort_order(attr_name)
-            if Hash === @default_order
-              @default_order[attr_name]
-            else
-              @default_order
-            end
+            return @default_order[attr_name] if Hash === @default_order
+            @default_order
           end
 
           def order_indicator
-            if @hide_indicator || no_sort_direction_specified?
-              nil
-            else
-              direction_arrow
-            end
+            return if @hide_indicator || no_sort_direction_specified?
+            direction_arrow
           end
 
           def no_sort_direction_specified?(dir = @current_dir)
-            !Constants::ASC_DESC.include?(dir)
+            !['asc'.freeze, 'desc'.freeze].freeze.include?(dir)
           end
 
           def direction_arrow
-            if @current_dir == Constants::DESC
-              Constants::DESC_ARROW
-            else
-              Constants::ASC_ARROW
-            end
+            return Constants::DESC_ARROW if @current_dir == 'desc'.freeze
+            Constants::ASC_ARROW
           end
 
           def direction_text(dir)
-            if dir == Constants::DESC
-              Constants::ASC
-            else
-              Constants::DESC
-            end
+            return 'asc'.freeze if dir == 'desc'.freeze
+            'desc'.freeze
           end
-
       end
     end
   end