ransack 1.7.0 → 2.1.1

data/lib/ransack/nodes/condition.rb

@@ -9,9 +9,10 @@ module Ransack
 
       class << self
         def extract(context, key, values)
-          attributes, predicate = extract_attributes_and_predicate(key, context)
+          attributes, predicate, combinator =
+            extract_values_for_condition(key, context)
+
           if attributes.size > 0 && predicate
-            combinator = key.match(/_(or|and)_/) ? $1 : nil
             condition = self.new(context)
             condition.build(
               :a => attributes,
@@ -31,20 +32,34 @@ module Ransack
 
         private
 
-        def extract_attributes_and_predicate(key, context = nil)
-          str = key.dup
-          name = Predicate.detect_and_strip_from_string!(str)
-          predicate = Predicate.named(name)
-          unless predicate || Ransack.options[:ignore_unknown_conditions]
-            raise ArgumentError, "No valid predicate for #{key}"
-          end
-          if context.present? && context.attribute_method?(str)
-            attributes = [str]
-          else
-            attributes = str.split(/_and_|_or_/)
+          def extract_values_for_condition(key, context = nil)
+            str = key.dup
+            name = Predicate.detect_and_strip_from_string!(str)
+            predicate = Predicate.named(name)
+
+            unless predicate || Ransack.options[:ignore_unknown_conditions]
+              raise ArgumentError, "No valid predicate for #{key}"
+            end
+
+            if context.present?
+              str = context.ransackable_alias(str)
+            end
+
+            combinator =
+            if str.match(/_(or|and)_/)
+              $1
+            else
+              nil
+            end
+
+            if context.present? && context.attribute_method?(str)
+              attributes = [str]
+            else
+              attributes = str.split(/_and_|_or_/)
+            end
+
+            [attributes, predicate, combinator]
           end
-          [attributes, predicate]
-        end
       end
 
       def valid?
@@ -64,14 +79,12 @@ module Ransack
       def attributes=(args)
         case args
         when Array
-          args.each do |attr|
-            attr = Attribute.new(@context, attr)
-            self.attributes << attr if attr.valid?
+          args.each do |name|
+            build_attribute(name)
           end
         when Hash
           args.each do |index, attrs|
-            attr = Attribute.new(@context, attrs[:name], attrs[:ransacker_args])
-            self.attributes << attr if attr.valid?
+            build_attribute(attrs[:name], attrs[:ransacker_args])
           end
         else
           raise ArgumentError,
@@ -114,9 +127,32 @@ module Ransack
       alias :m= :combinator=
       alias :m :combinator
 
-      def build_attribute(name = nil)
-        Attribute.new(@context, name).tap do |attribute|
-          self.attributes << attribute
+
+      # == build_attribute
+      #
+      #  This method was originally called from Nodes::Grouping#new_condition
+      #  only, without arguments, without #valid? checking, to build a new
+      #  grouping condition.
+      #
+      #  After refactoring in 235eae3, it is now called from 2 places:
+      #
+      #  1. Nodes::Condition#attributes=, with +name+ argument passed or +name+
+      #     and +ransacker_args+. Attributes are included only if #valid?.
+      #
+      #  2. Nodes::Grouping#new_condition without arguments. In this case, the
+      #     #valid? conditional needs to be bypassed, otherwise nothing is
+      #     built. The `name.nil?` conditional below currently does this.
+      #
+      #  TODO: Add test coverage for this behavior and ensure that `name.nil?`
+      #  isn't fixing issue #701 by introducing untested regressions.
+      #
+      def build_attribute(name = nil, ransacker_args = [])
+        Attribute.new(@context, name, ransacker_args).tap do |attribute|
+          @context.bind(attribute, attribute.name)
+          self.attributes << attribute if name.nil? || attribute.valid?
+          if predicate && !negative?
+            @context.lock_association(attribute.parent)
+          end
         end
       end
 
@@ -168,6 +204,10 @@ module Ransack
 
       def predicate_name=(name)
         self.predicate = Predicate.named(name)
+        unless negative?
+          attributes.each { |a| context.lock_association(a.parent) }
+        end
+        @predicate
       end
       alias :p= :predicate_name=
 
@@ -196,15 +236,20 @@ module Ransack
           val = predicate.format(val)
           val
         end
-        predicate.wants_array ? formatted : formatted.first
+        if predicate.wants_array
+          formatted
+        else
+          formatted.first
+        end
       end
 
       def arel_predicate_for_attribute(attr)
         if predicate.arel_predicate === Proc
           values = casted_values_for_attribute(attr)
-          predicate.arel_predicate.call(
-            predicate.wants_array ? values : values.first
-            )
+          unless predicate.wants_array
+            values = values.first
+          end
+          predicate.arel_predicate.call(values)
         else
           predicate.arel_predicate
         end
@@ -224,10 +269,14 @@ module Ransack
         ]
         .reject { |e| e[1].blank? }
         .map { |v| "#{v[0]}: #{v[1]}" }
-        .join(Constants::COMMA_SPACE)
+        .join(', '.freeze)
         "Condition <#{data}>"
       end
 
+      def negative?
+        predicate.negative?
+      end
+
       private
 
       def valid_combinator?

data/lib/ransack/nodes/grouping.rb

@@ -44,16 +44,12 @@ module Ransack
             self.conditions << condition if condition.valid?
           end
         end
-        self.conditions.uniq!
+        remove_duplicate_conditions!
       end
       alias :c= :conditions=
 
       def [](key)
-        if condition = conditions.detect { |c| c.key == key.to_s }
-          condition
-        else
-          nil
-        end
+        conditions.detect { |c| c.key == key.to_s }
       end
 
       def []=(key, value)
@@ -68,7 +64,6 @@ module Ransack
       def respond_to?(method_id)
         super or begin
           method_name = method_id.to_s
-          writer = method_name.sub!(/\=$/, Constants::EMPTY)
           attribute_method?(method_name) ? true : false
         end
       end
@@ -114,7 +109,7 @@ module Ransack
 
       def method_missing(method_id, *args)
         method_name = method_id.to_s
-        writer = method_name.sub!(/\=$/, Constants::EMPTY)
+        writer = method_name.sub!(/\=$/, ''.freeze)
         if attribute_method?(method_name)
           if writer
             write_attribute(method_name, *args)
@@ -169,7 +164,7 @@ module Ransack
         ]
         .reject { |e| e[1].blank? }
         .map { |v| "#{v[0]}: #{v[1]}" }
-        .join(Constants::COMMA_SPACE)
+        .join(', '.freeze)
         "Grouping <#{data}>"
       end
 
@@ -191,10 +186,21 @@ module Ransack
       end
 
       def strip_predicate_and_index(str)
-        string = str.split(/\(/).first
+        string = str[/(.+?)\(/, 1] || str.dup
         Predicate.detect_and_strip_from_string!(string)
         string
       end
+
+      def remove_duplicate_conditions!
+        # If self.conditions.uniq! is called without passing a block, then
+        # conditions differing only by ransacker_args within attributes are
+        # wrongly considered equal and are removed.
+        self.conditions.uniq! do |c|
+          c.attributes.map { |a| [a.name, a.ransacker_args] }.flatten +
+          [c.predicate.name] +
+          c.values.map { |v| v.value }
+        end
+      end
     end
   end
 end

data/lib/ransack/nodes/sort.rb

@@ -3,7 +3,7 @@ module Ransack
     class Sort < Node
       include Bindable
 
-      attr_reader :name, :dir
+      attr_reader :name, :dir, :ransacker_args
       i18n_word :asc, :desc
 
       class << self
@@ -16,7 +16,7 @@ module Ransack
 
       def build(params)
         params.with_indifferent_access.each do |key, value|
-          if key.match(/^(name|dir)$/)
+          if key.match(/^(name|dir|ransacker_args)$/)
             self.send("#{key}=", value)
           end
         end
@@ -32,19 +32,23 @@ module Ransack
 
       def name=(name)
         @name = name
-        context.bind(self, name) unless name.blank?
+        context.bind(self, name)
       end
 
       def dir=(dir)
         dir = dir.downcase if dir
         @dir =
-          if Constants::ASC_DESC.include?(dir)
+          if dir == 'asc'.freeze || dir == 'desc'.freeze
             dir
           else
-            Constants::ASC
+            'asc'.freeze
           end
       end
 
+      def ransacker_args=(ransack_args)
+        @ransacker_args = ransack_args
+      end
+
     end
   end
 end

data/lib/ransack/nodes/value.rb

@@ -23,87 +23,93 @@ module Ransack
       end
 
       def cast(type)
-         case type
-         when :date
-           cast_to_date(value)
-         when :datetime, :timestamp, :time
-           cast_to_time(value)
-         when :boolean
-           cast_to_boolean(value)
-         when :integer
-           cast_to_integer(value)
-         when :float
-           cast_to_float(value)
-         when :decimal
-           cast_to_decimal(value)
-         else
-           cast_to_string(value)
-         end
-       end
+        case type
+        when :date
+          cast_to_date(value)
+        when :datetime, :timestamp, :time
+          cast_to_time(value)
+        when :boolean
+          cast_to_boolean(value)
+        when :integer
+          cast_to_integer(value)
+        when :float
+          cast_to_float(value)
+        when :decimal
+          cast_to_decimal(value)
+        when :money
+          cast_to_money(value)
+        else
+          cast_to_string(value)
+        end
+      end
 
-       def cast_to_date(val)
-         if val.respond_to?(:to_date)
-           val.to_date rescue nil
-         else
-           y, m, d = *[val].flatten
-           m ||= 1
-           d ||= 1
-           Date.new(y,m,d) rescue nil
-         end
-       end
+      def cast_to_date(val)
+        if val.respond_to?(:to_date)
+          val.to_date rescue nil
+        else
+          y, m, d = *[val].flatten
+          m ||= 1
+          d ||= 1
+          Date.new(y,m,d) rescue nil
+        end
+      end
 
-       def cast_to_time(val)
-         if val.is_a?(Array)
-           Time.zone.local(*val) rescue nil
-         else
-           unless val.acts_like?(:time)
-             val = val.is_a?(String) ? Time.zone.parse(val) : val.to_time rescue val
-           end
-           val.in_time_zone rescue nil
-         end
-       end
+      def cast_to_time(val)
+        if val.is_a?(Array)
+          Time.zone.local(*val) rescue nil
+        else
+          unless val.acts_like?(:time)
+            val = val.is_a?(String) ? Time.zone.parse(val) : val.to_time rescue val
+          end
+          val.in_time_zone rescue nil
+        end
+      end
 
-       def cast_to_boolean(val)
-         if Constants::TRUE_VALUES.include?(val)
-           true
-         elsif Constants::FALSE_VALUES.include?(val)
-           false
-         else
-           nil
-         end
-       end
+      def cast_to_boolean(val)
+        if Constants::TRUE_VALUES.include?(val)
+          true
+        elsif Constants::FALSE_VALUES.include?(val)
+          false
+        else
+          nil
+        end
+      end
 
-       def cast_to_string(val)
-         val.respond_to?(:to_s) ? val.to_s : String.new(val)
-       end
+      def cast_to_string(val)
+        val.respond_to?(:to_s) ? val.to_s : String.new(val)
+      end
 
-       def cast_to_integer(val)
-         val.blank? ? nil : val.to_i
-       end
+      def cast_to_integer(val)
+        val.blank? ? nil : val.to_i
+      end
 
-       def cast_to_float(val)
-         val.blank? ? nil : val.to_f
-       end
+      def cast_to_float(val)
+        val.blank? ? nil : val.to_f
+      end
 
-       def cast_to_decimal(val)
-         if val.blank?
-           nil
-         elsif val.class == BigDecimal
-           val
-         elsif val.respond_to?(:to_d)
-           val.to_d
-         else
-           val.to_s.to_d
-         end
+      def cast_to_decimal(val)
+       if val.blank?
+         nil
+       elsif val.class == BigDecimal
+         val
+       elsif val.respond_to?(:to_d)
+         val.to_d
+       else
+         val.to_s.to_d
        end
+      end
+
+      def cast_to_money(val)
+        val.blank? ? nil : val.to_f.to_s
+      end
 
       def inspect
         "Value <#{value}>"
       end
 
-       def array_of_arrays?(val)
-         Array === val && Array === val.first
-       end
+      def array_of_arrays?(val)
+        Array === val && Array === val.first
+      end
     end
   end
 end

data/lib/ransack/nodes.rb

@@ -3,6 +3,6 @@ require 'ransack/nodes/node'
 require 'ransack/nodes/attribute'
 require 'ransack/nodes/value'
 require 'ransack/nodes/condition'
-Ransack::Adapters.require_nodes
+Ransack::Adapters.object_mapper.require_nodes
 require 'ransack/nodes/sort'
 require 'ransack/nodes/grouping'

data/lib/ransack/predicate.rb

@@ -9,34 +9,26 @@ module Ransack
         Ransack.predicates.keys
       end
 
-      def names_by_decreasing_length
-        names.sort { |a,b| b.length <=> a.length }
-      end
-
       def named(name)
         Ransack.predicates[name.to_s]
       end
 
       def detect_and_strip_from_string!(str)
-        if p = detect_from_string(str)
-          str.sub! /_#{p}$/, Constants::EMPTY
-          p
-        end
+        detect_from_string str, chomp: true
       end
 
-      def detect_from_string(str)
-        names_by_decreasing_length.detect { |p| str.end_with?("_#{p}") }
-      end
+      def detect_from_string(str, chomp: false)
+        return unless str
 
-#      def name_from_attribute_name(attribute_name)
-#        names_by_decreasing_length.detect {
-#          |p| attribute_name.to_s.match(/_#{p}$/)
-#        }
-#      end
+        Ransack.predicates.sorted_names_with_underscores.each do |predicate, underscored|
+          if str.end_with? underscored
+            str.chomp! underscored if chomp
+            return predicate
+          end
+        end
 
-#      def for_attribute_name(attribute_name)
-#        self.named(detect_from_string(attribute_name.to_s))
-#      end
+        nil
+      end
 
     end
 
@@ -74,5 +66,9 @@ module Ransack
       vals.any? { |v| validator.call(type ? v.cast(type) : v.value) }
     end
 
+    def negative?
+      @name.include?("not_".freeze)
+    end
+
   end
 end

data/lib/ransack/search.rb

@@ -1,6 +1,6 @@
 require 'ransack/nodes'
 require 'ransack/context'
-Ransack::Adapters.require_search
+Ransack::Adapters.object_mapper.require_search
 require 'ransack/naming'
 
 module Ransack
@@ -15,6 +15,7 @@ module Ransack
              :translate, :to => :base
 
     def initialize(object, params = {}, options = {})
+      params = params.to_unsafe_h if params.respond_to?(:to_unsafe_h)
       if params.is_a? Hash
         params = params.dup
         params.delete_if { |k, v| [*v].all?{ |i| i.blank? && i != false } }
@@ -37,7 +38,7 @@ module Ransack
 
     def build(params)
       collapse_multiparameter_attributes!(params).each do |key, value|
-        if Constants::S_SORTS.include?(key)
+        if ['s'.freeze, 'sorts'.freeze].freeze.include?(key)
           send("#{key}=", value)
         elsif base.attribute_method?(key)
           base.send("#{key}=", value)
@@ -92,7 +93,7 @@ module Ransack
 
     def method_missing(method_id, *args)
       method_name = method_id.to_s
-      getter_name = method_name.sub(/=$/, Constants::EMPTY)
+      getter_name = method_name.sub(/=$/, ''.freeze)
       if base.attribute_method?(getter_name)
         base.send(method_id, *args)
       elsif @context.ransackable_scope?(getter_name, @context.object)
@@ -113,8 +114,8 @@ module Ransack
         [:base, base.inspect]
       ]
       .compact
-      .map { |d| d.join(Constants::COLON_SPACE) }
-      .join(Constants::COMMA_SPACE)
+      .map { |d| d.join(': '.freeze) }
+      .join(', '.freeze)
 
       "Ransack::Search<#{details}>"
     end
@@ -122,12 +123,18 @@ module Ransack
     private
 
     def add_scope(key, args)
+      sanitized_args = if Ransack.options[:sanitize_scope_args] && !@context.ransackable_scope_skip_sanitize_args?(key, @context.object)
+        sanitized_scope_args(args)
+      else
+        args
+      end
+
       if @context.scope_arity(key) == 1
         @scope_args[key] = args.is_a?(Array) ? args[0] : args
       else
-        @scope_args[key] = args.is_a?(Array) ? sanitized_scope_args(args) : args
+        @scope_args[key] = args.is_a?(Array) ? sanitized_args : args
       end
-      @context.chain_scope(key, sanitized_scope_args(args))
+      @context.chain_scope(key, sanitized_args)
     end
 
     def sanitized_scope_args(args)

data/lib/ransack/translate.rb

@@ -24,8 +24,8 @@ module Ransack
       base_ancestors = base_class.ancestors.select {
         |x| x.respond_to?(:model_name)
       }
-      predicate = Predicate.detect_from_string(original_name)
-      attributes_str = original_name.sub(/_#{predicate}$/, Constants::EMPTY)
+      attributes_str = original_name.dup # will be modified by ⬇
+      predicate = Predicate.detect_and_strip_from_string!(attributes_str)
       attribute_names = attributes_str.split(/_and_|_or_/)
       combinator = attributes_str.match(/_and_/) ? :and : :or
       defaults = base_ancestors.map do |klass|
@@ -74,7 +74,7 @@ module Ransack
     def self.attribute_name(context, name, include_associations = nil)
       @context, @name = context, name
       @assoc_path = context.association_path(name)
-      @attr_name = @name.sub(/^#{@assoc_path}_/, Constants::EMPTY)
+      @attr_name = @name.sub(/^#{@assoc_path}_/, ''.freeze)
       associated_class = @context.traverse(@assoc_path) if @assoc_path.present?
       @include_associated = include_associations && associated_class
 

data/lib/ransack/version.rb

@@ -1,3 +1,3 @@
 module Ransack
-  VERSION = '1.7.0'
+  VERSION = '2.1.1'
 end

data/lib/ransack/visitor.rb

@@ -31,17 +31,7 @@ module Ransack
 
     def visit_or(object)
       nodes = object.values.map { |o| accept(o) }.compact
-      return nil unless nodes.size > 0
-
-      if nodes.size > 1
-        nodes.inject(&:or)
-      else
-        nodes.first
-      end
-    end
-
-    def visit_Ransack_Nodes_Sort(object)
-      object.attr.send(object.dir) if object.valid?
+      nodes.inject(&:or)
     end
 
     def quoted?(object)
@@ -57,6 +47,5 @@ module Ransack
         klass.name.gsub(Constants::TWO_COLONS, Constants::UNDERSCORE)
         }"
     end
-
   end
 end

data/lib/ransack.rb

@@ -1,9 +1,8 @@
 require 'active_support/core_ext'
-
 require 'ransack/configuration'
-
 require 'ransack/adapters'
-Ransack::Adapters.require_constants
+
+Ransack::Adapters.object_mapper.require_constants
 
 module Ransack
   extend Configuration
@@ -15,7 +14,7 @@ Ransack.configure do |config|
     config.add_predicate name, :arel_predicate => name
   end
   Ransack::Constants::DERIVED_PREDICATES.each do |args|
-    config.add_predicate *args
+    config.add_predicate(*args)
   end
 end
 
@@ -23,9 +22,10 @@ require 'ransack/search'
 require 'ransack/ransacker'
 require 'ransack/helpers'
 require 'action_controller'
-
 require 'ransack/translate'
 
-Ransack::Adapters.require_adapter
+Ransack::Adapters.object_mapper.require_adapter
 
-ActionController::Base.helper Ransack::Helpers::FormHelper
+ActiveSupport.on_load(:action_controller) do
+  ActionController::Base.helper Ransack::Helpers::FormHelper
+end