ransack 6.0.1 → 6.1.0

data/lib/ransack/nodes/grouping.rb

@@ -99,7 +99,7 @@ module Ransack
             self.groupings << grouping_object if grouping_object.values.any?
           end
         else
-          raise ArgumentError,
+          raise InvalidSearchError,
             "Invalid argument (#{groupings.class}) supplied to groupings="
         end
       end
@@ -107,7 +107,7 @@ module Ransack
 
       def method_missing(method_id, *args)
         method_name = method_id.to_s.dup
-        writer = method_name.sub!(/\=$/, ''.freeze)
+        writer = method_name.sub!(/=\z/, ''.freeze)
         if attribute_method?(method_name)
           if writer
             write_attribute(method_name, *args)
@@ -126,7 +126,7 @@ module Ransack
         return true if @context.attribute_method?(stripped_name) ||
                        @context.attribute_method?(name)
         case stripped_name
-        when /^(g|c|m|groupings|conditions|combinator)=?$/
+        when /\A(g|c|m|groupings|conditions|combinator)=?\z/
           true
         else
           stripped_name
@@ -147,9 +147,9 @@ module Ransack
       end
 
       def build(params)
-        params.with_indifferent_access.each do |key, value|
+        indifferent_params(params, 'grouping').each do |key, value|
           case key
-          when /^(g|c|m|groupings|conditions|combinator)$/
+          when /\A(g|c|m|groupings|conditions|combinator)\z/
             self.send("#{key}=", value)
           else
             if @context.ransackable_scope?(key, @context.object)
@@ -214,25 +214,16 @@ module Ransack
       # A condition is dropped when it fails validation, as an unknown
       # attribute or predicate would be. One failure is worth naming: a
       # single-value predicate given several values. A strict search raises
-      # for it, so the caller learns why the filter vanished (#1724). The
-      # check only applies once the predicate and an attribute have resolved;
-      # a condition that is invalid for another reason keeps its behaviour.
+      # for it, so the caller learns why the filter vanished (#1724).
       def add_condition(attrs)
         condition = Condition.new(@context).build(attrs)
         if condition.valid?
           self.conditions << condition
-        elsif @context.strict_conditions? && arity_failure?(condition)
-          raise InvalidSearchError,
-            "Predicate #{condition.predicate_name} takes a single value, " \
-            "#{condition.values.size} given for #{condition.attributes.map(&:name).join(', ')}"
+        elsif @context.strict_conditions? && condition.arity_failure?
+          raise condition.arity_error
         end
       end
 
-      def arity_failure?(condition)
-        condition.predicate && condition.attributes.any?(&:valid?) &&
-          !condition.valid_arity?
-      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

data/lib/ransack/nodes/node.rb

@@ -34,7 +34,7 @@ module Ransack
       # this is the one place that normalises the spelling and, when the search
       # is strict, rejects a value it does not recognise.
       def combinator=(val)
-        normalised = val.to_s.downcase
+        normalised = scalar_param(val, 'combinator').to_s.downcase
         @combinator = Constants::AND_OR.detect { |v| v == normalised }
 
         if @combinator.nil? && !normalised.empty? && context&.strict_conditions?
@@ -42,6 +42,28 @@ module Ransack
         end
       end
 
+      private
+
+      # Search params usually come from the request, so a grouping, condition
+      # or sort given as something other than a hash (`q[g]=x`) is a malformed
+      # search, not a programming error, whether or not the search is strict.
+      def indifferent_params(params, node_name)
+        return params.with_indifferent_access if params.respond_to?(:with_indifferent_access)
+
+  raise InvalidSearchError,
+    "Invalid argument (#{params.class}) supplied for a #{node_name}"
+end
+
+# A name, predicate, direction or combinator is a single value. Given an
+# array or a hash (`q[s][0][dir][]=desc`), it used to be stringified and
+# then silently ignored or defaulted, so the search ran as something
+# other than what was asked for.
+def scalar_param(value, field)
+  return value unless value.is_a?(Enumerable) || value.respond_to?(:to_unsafe_h)
+
+  raise InvalidSearchError, "Invalid argument (#{value.class}) supplied for #{field}"
+end
+
     end
   end
 end

data/lib/ransack/nodes/sort.rb

@@ -15,11 +15,14 @@ module Ransack
       end
 
       def build(params)
-        params.with_indifferent_access.each do |key, value|
-          if key.match(/^(name|dir|ransacker_args)$/)
+        indifferent_params(params, 'sort').each do |key, value|
+          if key.match(/\A(name|dir|ransacker_args)\z/)
             self.send("#{key}=", value)
           end
         end
+        # A sort given without a direction is ascending, as it is from a
+        # string (`s: 'name'`).
+        self.dir = nil unless defined?(@dir)
 
         self
       end
@@ -30,12 +33,12 @@ module Ransack
       end
 
       def name=(name)
-        @name = context.resolve_aliases(name.to_s)
+        @name = context.resolve_aliases(scalar_param(name, 'a sort name').to_s)
         context.bind(self, @name)
       end
 
       def dir=(dir)
-        dir = dir.downcase if dir
+        dir = scalar_param(dir, 'a sort direction').to_s.downcase
         @dir =
           if dir == 'asc'.freeze || dir == 'desc'.freeze
             dir

data/lib/ransack/nodes/value.rb

@@ -4,6 +4,12 @@ module Ransack
       attr_accessor :value
       delegate :present?, :blank?, to: :value
 
+      # The types whose cast builds one value from an Array: a multiparameter
+      # date or time (`created_at(1i)`, `created_at(2i)`, ...) arrives as one.
+      ARRAY_CAST_TYPES = %i[
+        date datetime timestamp time timestamptz datetimeoffset
+      ].freeze
+
       def initialize(context, value = nil)
         super(context)
         @value = value

data/lib/ransack/predicate.rb

@@ -1,7 +1,7 @@
 module Ransack
   class Predicate
-    attr_reader :name, :arel_predicate, :type, :formatter, :validator,
-                :compound, :wants_array, :case_insensitive
+    attr_reader :name, :arel_predicate, :arel_node, :type, :formatter,
+                :validator, :compound, :wants_array, :case_insensitive
 
     # Consulted at search time rather than captured at predicate-definition
     # time, so that `Ransack.options[:ignore_blank_values]` set in an
@@ -28,14 +28,26 @@ module Ransack
         detect_from_string str, chomp: true
       end
 
+      # The longest registered predicate the key ends with, as `_<name>`.
+      # Only the tail a predicate name can fill is looked at, and each
+      # underscore there is one hash lookup, so the cost depends on neither
+      # the length of the key nor the number of predicates. The first
+      # underscore found gives the longest candidate, which is the one the
+      # longest-first scan this replaces would have picked.
       def detect_from_string(str, chomp: false)
         return unless str
 
-        Ransack.predicates.sorted_names_with_underscores.each do |predicate, underscored|
-          if str.end_with? underscored
-            str.chomp! underscored if chomp
-            return predicate
+        str = str.to_s unless chomp
+        predicates = Ransack.predicates
+        from = str.length - predicates.max_name_length - 1
+        underscore = str.index(Constants::UNDERSCORE, from.negative? ? 0 : from)
+        while underscore
+          name = str[(underscore + 1)..]
+          if predicates.has_key?(name)
+            str.slice!(underscore..) if chomp
+            return name
           end
+          underscore = str.index(Constants::UNDERSCORE, underscore + 1)
         end
 
         nil
@@ -46,6 +58,7 @@ module Ransack
     def initialize(opts = {})
       @name = opts[:name]
       @arel_predicate = opts[:arel_predicate]
+      @arel_node = opts[:arel_node]
       @type = opts[:type]
       @formatter = opts[:formatter]
       @validator = opts[:validator] || DEFAULT_VALIDATOR

data/lib/ransack/search.rb

@@ -7,7 +7,7 @@ require 'ransack/nodes/sort'
 require 'ransack/nodes/grouping'
 require 'ransack/context'
 require 'ransack/naming'
-require 'ransack/invalid_search_error'
+require 'ransack/errors'
 
 module Ransack
   class Search
@@ -57,14 +57,23 @@ module Ransack
       @context.evaluate(self, opts)
     end
 
+    GROUPING_KEYS = %w[g c m groupings conditions combinator].to_set.freeze
+    private_constant :GROUPING_KEYS
+
     def build(params)
       collapse_multiparameter_attributes!(params).each do |key, value|
         if ['s'.freeze, 'sorts'.freeze].freeze.include?(key)
           send("#{key}=", value)
         elsif @context.ransackable_scope?(key, @context.object)
           add_scope(key, value)
-        elsif base.attribute_method?(key)
+        elsif GROUPING_KEYS.include?(key)
           base.send("#{key}=", value)
+        elsif base.attribute_method?(key)
+          # Straight to the writer: going through the grouping's
+          # method_missing would check the key a second time, and would
+          # send a key that happens to name one of its own writers
+          # (`i18n_words`) there instead of building a condition.
+          base.send(:write_attribute, key, value)
         elsif !Ransack.options[:ignore_unknown_conditions] || !@ignore_unknown_conditions
           raise InvalidSearchError, "Invalid search term #{key}"
         end
@@ -79,11 +88,12 @@ module Ransack
       case args
       when Array
         args.each do |sort|
-          if sort.kind_of? Hash
-            sort = Nodes::Sort.new(@context).build(sort)
-          else
-            sort = Nodes::Sort.extract(@context, sort)
-          end
+          sort =
+            case sort
+            when Hash then Nodes::Sort.new(@context).build(sort)
+            when String, Symbol, nil then Nodes::Sort.extract(@context, sort.to_s)
+            else raise InvalidSearchError, "Invalid argument (#{sort.class}) supplied to sorts="
+            end
           add_sort(sort) if sort
         end
       when Hash
@@ -118,9 +128,9 @@ module Ransack
     # params hash is built (#1472).
     def method_missing(method_id, *args)
       method_name = method_id.to_s
-      getter_name = method_name.sub(/=$/, ''.freeze)
+      getter_name = method_name.sub(/=\z/, ''.freeze)
       if @context.ransackable_scope?(getter_name, @context.object)
-        if method_name =~ /=$/
+        if method_name.end_with?('=')
           add_scope getter_name, args.size == 1 ? args.first : args
         else
           @scope_args[method_name]
@@ -137,7 +147,7 @@ module Ransack
     # before calling. Mirror method_missing so a search_form_with field is
     # pre-filled the same way a search_form_for one is.
     def respond_to_missing?(method_id, include_private = false)
-      getter_name = method_id.to_s.sub(/=$/, ''.freeze)
+      getter_name = method_id.to_s.sub(/=\z/, ''.freeze)
       base.attribute_method?(getter_name) ||
         @context.ransackable_scope?(getter_name, @context.object) ||
         super
@@ -202,6 +212,7 @@ module Ransack
           real_attribute, position = k.split(/\(|\)/)
           value = attrs.delete(k)
           next if position.nil?
+          next if value.is_a?(Array) || value.is_a?(Hash)
 
           cast = Constants::A_S_I.include?(position.last) ? position.last : nil
           position = position.to_i - 1

data/lib/ransack/translate.rb

@@ -72,80 +72,88 @@ module Ransack
 
       private
 
+      # The module is shared by every thread, so nothing here is kept between
+      # calls: each helper is handed what it needs. Storing the name being
+      # translated on the module let one request read another's while both
+      # rendered sort links.
+      AttributeName = Struct.new(:context, :name, :attr_name, :assoc_path,
+                                 :associated_class, :include_associated)
+      private_constant :AttributeName
+
       def attribute_name(context, name, include_associations = nil)
-        @context, @name = context, name
-        @assoc_path = context.association_path(name)
-        @attr_name = @name.sub(/^#{@assoc_path}_/, ''.freeze)
-        associated_class = @context.traverse(@assoc_path) if @assoc_path.present?
-        @include_associated = include_associations && associated_class
+        assoc_path = context.association_path(name)
+        associated_class = context.traverse(assoc_path) if assoc_path.present?
+        part = AttributeName.new(
+          context, name, name.sub(/\A#{Regexp.escape(assoc_path)}_/, ''.freeze),
+          assoc_path, associated_class, include_associations && associated_class
+        )
 
-        defaults = default_attribute_name << fallback_args
+        defaults = default_attribute_name(part) << fallback_args(part)
         options = { count: 1, default: defaults }
-        interpolations = build_interpolations(associated_class)
+        interpolations = build_interpolations(part)
 
         I18n.translate(defaults.shift, **options.merge(interpolations))
       end
 
-      def default_attribute_name
-        ["ransack.attributes.#{i18n_key(@context.klass)}.#{@name}".to_sym]
+      def default_attribute_name(part)
+        ["ransack.attributes.#{i18n_key(part.context.klass)}.#{part.name}".to_sym]
       end
 
-      def fallback_args
-        if @include_associated
+      def fallback_args(part)
+        if part.include_associated
           '%{association_name} %{attr_fallback_name}'.freeze
         else
           '%{attr_fallback_name}'.freeze
         end
       end
 
-      def build_interpolations(associated_class)
+      def build_interpolations(part)
         {
-          attr_fallback_name: attr_fallback_name(associated_class),
-          association_name: association_name
+          attr_fallback_name: attr_fallback_name(part),
+          association_name: association_name(part)
         }.reject { |_, value| value.nil? }
       end
 
-      def attr_fallback_name(associated_class)
+      def attr_fallback_name(part)
         I18n.t(
-          :"ransack.attributes.#{fallback_class(associated_class)}.#{@attr_name}",
-          default: default_interpolation(associated_class)
+          :"ransack.attributes.#{fallback_class(part)}.#{part.attr_name}",
+          default: default_interpolation(part)
         )
       end
 
-      def fallback_class(associated_class)
-        i18n_key(associated_class || @context.klass)
+      def fallback_class(part)
+        i18n_key(part.associated_class || part.context.klass)
       end
 
-      def association_name
-        association(@assoc_path, context: @context) if @include_associated
+      def association_name(part)
+        association(part.assoc_path, context: part.context) if part.include_associated
       end
 
-      def default_interpolation(associated_class)
+      def default_interpolation(part)
         [
-          associated_attribute(associated_class),
-          ".attributes.#{@attr_name}".to_sym,
-          @attr_name.humanize
+          associated_attribute(part),
+          ".attributes.#{part.attr_name}".to_sym,
+          part.attr_name.humanize
         ].flatten
       end
 
-      def associated_attribute(associated_class)
-        if associated_class
-          translated_attribute(associated_class)
+      def associated_attribute(part)
+        if part.associated_class
+          translated_attribute(part.associated_class, part.attr_name)
         else
-          translated_ancestor_attributes
+          translated_ancestor_attributes(part)
         end
       end
 
-      def translated_attribute(associated_class)
-        key = "#{associated_class.i18n_scope}.attributes.#{
-        i18n_key(associated_class)}.#{@attr_name}"
+      def translated_attribute(klass, attr_name)
+        key = "#{klass.i18n_scope}.attributes.#{i18n_key(klass)}.#{attr_name}"
         ["#{key}.one".to_sym, key.to_sym]
       end
 
-      def translated_ancestor_attributes
-        @context.klass.ancestors
+      def translated_ancestor_attributes(part)
+        part.context.klass.ancestors
           .select { |ancestor| ancestor.respond_to?(:model_name) }
-          .map { |ancestor| translated_attribute(ancestor) }
+          .map { |ancestor| translated_attribute(ancestor, part.attr_name) }
       end
 
       def i18n_key(klass)

data/lib/ransack/version.rb

@@ -1,3 +1,3 @@
 module Ransack
-  VERSION = '6.0.1'
+  VERSION = '6.1.0'
 end

data/lib/ransack.rb

@@ -2,12 +2,13 @@ require 'active_support/dependencies/autoload'
 require 'active_support/deprecation'
 require 'active_support/deprecator'
 
+require 'active_support'
 require 'active_support/core_ext'
+require 'ransack/errors'
 require 'ransack/configuration'
 
 module Ransack
   extend Configuration
-  class UntraversableAssociationError < StandardError; end
 
   def self.deprecator
     @deprecator ||= ActiveSupport::Deprecation.new('7.0', 'Ransack')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ransack
 version: !ruby/object:Gem::Version
-  version: 6.0.1
+  version: 6.1.0
 platform: ruby
 authors:
 - Ernie Miller
@@ -19,28 +19,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.2'
+        version: '8.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.2'
+        version: '8.1'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.2'
+        version: '8.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.2'
+        version: '8.1'
 - !ruby/object:Gem::Dependency
   name: i18n
   requirement: !ruby/object:Gem::Requirement
@@ -82,6 +82,7 @@ files:
 - lib/ransack/configuration.rb
 - lib/ransack/constants.rb
 - lib/ransack/context.rb
+- lib/ransack/errors.rb
 - lib/ransack/helpers.rb
 - lib/ransack/helpers/form_builder.rb
 - lib/ransack/helpers/form_helper.rb
@@ -140,7 +141,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="