ransack 4.4.0 → 5.0.0

data/lib/ransack/nodes/grouping.rb

@@ -1,8 +1,12 @@
 module Ransack
   module Nodes
     class Grouping < Node
-      attr_reader :conditions
-      attr_accessor :combinator
+      attr_reader :combinator
+
+      # The writer is inherited from Node, which normalises the value. Defining
+      # it here as well — or aliasing before the definition is in place — would
+      # bind `m=` to the plain attribute writer and skip that normalisation,
+      # which is how `g: [{ m: 'OR' }]` silently fell back to AND.
       alias :m :combinator
       alias :m= :combinator=
 
@@ -13,7 +17,7 @@ module Ransack
 
       def initialize(context, combinator = nil)
         super(context)
-        self.combinator = combinator.to_s if combinator
+        self.combinator = combinator if combinator
       end
 
       def persisted?
@@ -149,10 +153,14 @@ module Ransack
       def build(params)
         params.with_indifferent_access.each do |key, value|
           case key
-          when /^(g|c|m)$/
+          when /^(g|c|m|groupings|conditions|combinator)$/
             self.send("#{key}=", value)
           else
-            write_attribute(key.to_s, value)
+            if @context.ransackable_scope?(key, @context.object)
+              @context.chain_scope(key, @context.sanitize_scope_args(key, value))
+            else
+              write_attribute(key.to_s, value)
+            end
           end
         end
         self
@@ -178,6 +186,16 @@ module Ransack
       end
 
       def read_attribute(name)
+        # A field built from an aliased attribute writes its value under the real
+        # name but reads it back under the alias. Resolve the alias so the
+        # value survives a form round-trip (#689).
+        if self[name].nil?
+          stripped_name = name.dup
+          predicate = Predicate.detect_and_strip_from_string!(stripped_name)
+          aliased_attribute = context.ransackable_alias(stripped_name)
+          name = "#{aliased_attribute}_#{predicate}" unless aliased_attribute == stripped_name
+        end
+
         if self[name].respond_to?(:value)
           self[name].value
         else

data/lib/ransack/nodes/node.rb

@@ -29,6 +29,19 @@ module Ransack
         end
       end
 
+      # Every way of supplying a combinator — a top-level `combinator`/`m`,
+      # or an `m` inside any nested grouping or condition — ends up here, so
+      # 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
+        @combinator = Constants::AND_OR.detect { |v| v == normalised }
+
+        if @combinator.nil? && !normalised.empty? && context&.strict_conditions?
+          raise InvalidSearchError, "Invalid combinator #{val}"
+        end
+      end
+
     end
   end
 end

data/lib/ransack/nodes/sort.rb

@@ -26,8 +26,7 @@ module Ransack
 
       def valid?
         bound? && attr &&
-        context.klassify(parent).ransortable_attributes(context.auth_object)
-        .include?(attr_name)
+          context.ransortable_attribute?(attr_name.split('.').last, context.klassify(parent))
       end
 
       def name=(name)

data/lib/ransack/nodes/value.rb

@@ -24,9 +24,11 @@ module Ransack
 
       def cast(type)
         case type
+        when :enum
+          value
         when :date
           cast_to_date(value)
-        when :datetime, :timestamp, :time, :timestamptz
+        when :datetime, :timestamp, :time, :timestamptz, :datetimeoffset
           cast_to_time(value)
         when :boolean
           cast_to_boolean(value)
@@ -43,14 +45,6 @@ module Ransack
         end
       end
 
-      def cast_array
-        if value.is_a?(Array)
-          cast_to_date(value)
-        else
-          value
-        end
-      end
-
       def cast_to_date(val)
         if val.respond_to?(:to_date)
           val.to_date rescue nil

data/lib/ransack/predicate.rb

@@ -3,6 +3,17 @@ module Ransack
     attr_reader :name, :arel_predicate, :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
+    # initializer applies to the predicates registered before it ran.
+    DEFAULT_VALIDATOR = lambda do |v|
+      if Ransack.options[:ignore_blank_values]
+        v.respond_to?(:empty?) ? !v.empty? : !v.nil?
+      else
+        !v.nil?
+      end
+    end
+
     class << self
 
       def names
@@ -37,8 +48,7 @@ module Ransack
       @arel_predicate = opts[:arel_predicate]
       @type = opts[:type]
       @formatter = opts[:formatter]
-      @validator = opts[:validator] ||
-        lambda { |v| v.respond_to?(:empty?) ? !v.empty? : !v.nil? }
+      @validator = opts[:validator] || DEFAULT_VALIDATOR
       @compound = opts[:compound]
       @wants_array = opts.fetch(:wants_array,
         @compound || Constants::IN_NOT_IN.include?(@arel_predicate))
@@ -64,7 +74,18 @@ module Ransack
     end
 
     def validate(vals, type = @type)
-      vals.any? { |v| validator.call(type ? v.cast(type) : v.value) }
+      # An explicitly empty array is a meaningful filter (matching nothing)
+      # rather than an absent one, but only when blank values are not ignored.
+      return true if vals.empty? && wants_array &&
+                     !Ransack.options[:ignore_blank_values]
+
+      # When blank values are meaningful, validate the value as given. Casting
+      # first would turn '' into nil for an integer or boolean column and the
+      # explicit blank would be dropped — leaving no condition at all.
+      vals.any? do |v|
+        value = type && Ransack.options[:ignore_blank_values] ? v.cast(type) : v.value
+        validator.call(value)
+      end
     end
 
     def negative?

data/lib/ransack/search.rb

@@ -24,14 +24,19 @@ module Ransack
       strip_whitespace = options.fetch(:strip_whitespace, Ransack.options[:strip_whitespace])
       params = params.to_unsafe_h if params.respond_to?(:to_unsafe_h)
       if params.is_a? Hash
-        params = params.dup
-        params = params.transform_values { |v| v.is_a?(String) && strip_whitespace ? v.strip : v }
-        params.delete_if { |k, v| [*v].all?{ |i| i.blank? && i != false } }
+        # deep_transform_values rebuilds every nested hash and array, which
+        # also gives the pruning below a private copy to edit — the caller's
+        # params come back untouched. Values nested inside `g:` groupings and
+        # `c:` conditions are stripped too, not just the top level.
+        params = params.deep_transform_values { |v| v.is_a?(String) && strip_whitespace ? v.strip : v }
+        params.delete_if { |_k, v| blank_condition_value?(v) }
+        prune_blank_advanced_conditions!(params)
       else
         params = {}
       end
       @context = options[:context] || Context.for(object, options)
       @context.auth_object = options[:auth_object]
+      @context.ignore_unknown_conditions = options[:ignore_unknown_conditions]
       @base = Nodes::Grouping.new(
         @context, options[:grouping] || Constants::AND
         )
@@ -132,11 +137,7 @@ 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
+      sanitized_args = @context.sanitize_scope_args(key, args)
 
       if @context.scope_arity(key) == 1
         @scope_args[key] = args.is_a?(Array) ? args[0] : args
@@ -146,20 +147,6 @@ module Ransack
       @context.chain_scope(key, sanitized_args)
     end
 
-    def sanitized_scope_args(args)
-      if args.is_a?(Array)
-        args = args.map(&method(:sanitized_scope_args))
-      end
-
-      if Constants::TRUE_VALUES.include? args
-        true
-      elsif Constants::FALSE_VALUES.include? args
-        false
-      else
-        args
-      end
-    end
-
     def collapse_multiparameter_attributes!(attrs)
       attrs.keys.each do |k|
         if k.include?(Constants::LEFT_PARENTHESIS)
@@ -191,5 +178,61 @@ module Ransack
       attrs
     end
 
+    # True when a condition's value should be dropped before building. With
+    # `ignore_blank_values` on (the default) a blank value means "this form
+    # field was left empty"; with it off, only nil is treated that way and a
+    # blank value is a value to search for. `false` is always a real value, and
+    # an explicit nil inside an array is kept so `name_in: [nil]` still reaches
+    # the query. The `c:` pruning below shares this, so it follows the option.
+    def blank_condition_value?(value)
+      if Ransack.options[:ignore_blank_values]
+        [*value].all? { |i| i.blank? && i != false && !i.nil? }
+      else
+        value.nil? || (value.is_a?(Array) && !value.empty? && value.all?(&:nil?))
+      end
+    end
+
+    # The low-level `c:` API nests its values a level deeper than the shorthand
+    # form, so the filter above never sees them. Left in place, a condition with
+    # an empty value still builds its attribute and contributes a join, giving a
+    # LEFT OUTER JOIN with no WHERE clause to go with it.
+    def prune_blank_advanced_conditions!(node)
+      return unless node.is_a?(Hash)
+
+      conditions = fetch_either(node, :c, :conditions)
+      case conditions
+      when Array then conditions.delete_if { |c| blank_advanced_condition?(c) }
+      when Hash  then conditions.delete_if { |_k, c| blank_advanced_condition?(c) }
+      end
+
+      # Groupings nest to any depth and carry their own conditions, so descend
+      # into each of them too.
+      groupings = fetch_either(node, :g, :groupings)
+      groupings = groupings.values if groupings.is_a?(Hash)
+      Array(groupings).each { |grouping| prune_blank_advanced_conditions!(grouping) }
+    end
+
+    # Params are not yet indifferent-access here, so look under both spellings
+    # of a key and both its short and long forms.
+    def fetch_either(hash, short, long)
+      hash[short] || hash[short.to_s] || hash[long] || hash[long.to_s]
+    end
+
+    def blank_advanced_condition?(condition)
+      return false unless condition.is_a?(Hash)
+
+      values = condition[:v] || condition['v']
+
+      case values
+      when Array then values.all? { |v| blank_condition_value?(unwrap_value(v)) }
+      when Hash  then values.all? { |_k, v| blank_condition_value?(unwrap_value(v)) }
+      end
+    end
+
+    # Values in the `c:` API may be given bare or wrapped in a `{ value: ... }`
+    # envelope, the same two forms `Condition#values=` accepts.
+    def unwrap_value(value)
+      value.is_a?(Hash) ? (value[:value] || value['value']) : value
+    end
   end
 end

data/lib/ransack/version.rb

@@ -1,3 +1,3 @@
 module Ransack
-  VERSION = '4.4.0'
+  VERSION = '5.0.0'
 end

data/lib/ransack.rb

@@ -1,10 +1,6 @@
 require 'active_support/dependencies/autoload'
 require 'active_support/deprecation'
-require 'active_support/version'
-
-if ::ActiveSupport.version >= ::Gem::Version.new("7.1")
-  require 'active_support/deprecator'
-end
+require 'active_support/deprecator'
 
 require 'active_support/core_ext'
 require 'ransack/configuration'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ransack
 version: !ruby/object:Gem::Version
-  version: 4.4.0
+  version: 5.0.0
 platform: ruby
 authors:
 - Ernie Miller
@@ -11,7 +11,7 @@ authors:
 - David Rodríguez
 bindir: bin
 cert_chain: []
-date: 2025-09-25 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -19,28 +19,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
 - !ruby/object:Gem::Dependency
   name: i18n
   requirement: !ruby/object:Gem::Requirement
@@ -130,32 +130,6 @@ files:
 - lib/ransack/translate.rb
 - lib/ransack/version.rb
 - lib/ransack/visitor.rb
-- spec/blueprints/articles.rb
-- spec/blueprints/comments.rb
-- spec/blueprints/notes.rb
-- spec/blueprints/people.rb
-- spec/blueprints/tags.rb
-- spec/console.rb
-- spec/helpers/polyamorous_helper.rb
-- spec/helpers/ransack_helper.rb
-- spec/polyamorous/activerecord_compatibility_spec.rb
-- spec/polyamorous/join_association_spec.rb
-- spec/polyamorous/join_dependency_spec.rb
-- spec/polyamorous/join_spec.rb
-- spec/ransack/adapters/active_record/base_spec.rb
-- spec/ransack/adapters/active_record/context_spec.rb
-- spec/ransack/configuration_spec.rb
-- spec/ransack/helpers/form_builder_spec.rb
-- spec/ransack/helpers/form_helper_spec.rb
-- spec/ransack/nodes/condition_spec.rb
-- spec/ransack/nodes/grouping_spec.rb
-- spec/ransack/nodes/value_spec.rb
-- spec/ransack/predicate_spec.rb
-- spec/ransack/search_spec.rb
-- spec/ransack/translate_spec.rb
-- spec/spec_helper.rb
-- spec/support/en.yml
-- spec/support/schema.rb
 homepage: https://github.com/activerecord-hackery/ransack
 licenses:
 - MIT
@@ -168,40 +142,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Object-based searching for Active Record.
-test_files:
-- spec/blueprints/articles.rb
-- spec/blueprints/comments.rb
-- spec/blueprints/notes.rb
-- spec/blueprints/people.rb
-- spec/blueprints/tags.rb
-- spec/console.rb
-- spec/helpers/polyamorous_helper.rb
-- spec/helpers/ransack_helper.rb
-- spec/polyamorous/activerecord_compatibility_spec.rb
-- spec/polyamorous/join_association_spec.rb
-- spec/polyamorous/join_dependency_spec.rb
-- spec/polyamorous/join_spec.rb
-- spec/ransack/adapters/active_record/base_spec.rb
-- spec/ransack/adapters/active_record/context_spec.rb
-- spec/ransack/configuration_spec.rb
-- spec/ransack/helpers/form_builder_spec.rb
-- spec/ransack/helpers/form_helper_spec.rb
-- spec/ransack/nodes/condition_spec.rb
-- spec/ransack/nodes/grouping_spec.rb
-- spec/ransack/nodes/value_spec.rb
-- spec/ransack/predicate_spec.rb
-- spec/ransack/search_spec.rb
-- spec/ransack/translate_spec.rb
-- spec/spec_helper.rb
-- spec/support/en.yml
-- spec/support/schema.rb
+test_files: []

data/spec/blueprints/articles.rb

@@ -1,5 +0,0 @@
-Article.blueprint do
-  person
-  title
-  body
-end

data/spec/blueprints/comments.rb

@@ -1,5 +0,0 @@
-Comment.blueprint do
-  article
-  person
-  body
-end

data/spec/blueprints/notes.rb

@@ -1,5 +0,0 @@
-Note.blueprint do
-  note
-  notable_type { "Article" }
-  notable_id
-end

data/spec/blueprints/people.rb

@@ -1,8 +0,0 @@
-Person.blueprint do
-  name
-  email { "test@example.com" }
-  salary
-  only_sort
-  only_search
-  only_admin
-end

data/spec/blueprints/tags.rb

@@ -1,3 +0,0 @@
-Tag.blueprint do
-  name    { Sham.tag_name }
-end

data/spec/console.rb

@@ -1,25 +0,0 @@
-Bundler.setup
-require 'machinist/active_record'
-require 'sham'
-require 'faker'
-require 'ransack'
-
-Dir[File.expand_path('../../spec/{helpers,support,blueprints}/*.rb', __FILE__)]
-.each do |f|
-  require f
-end
-
-Sham.define do
-  name     { Faker::Name.name }
-  title    { Faker::Lorem.sentence }
-  body     { Faker::Lorem.paragraph }
-  salary   { |index| 30000 + (index * 1000) }
-  tag_name { Faker::Lorem.words(number: 3).join(' ') }
-  note     { Faker::Lorem.words(number: 7).join(' ') }
-  only_admin  { Faker::Lorem.words(number: 3).join(' ') }
-  only_search { Faker::Lorem.words(number: 3).join(' ') }
-  only_sort   { Faker::Lorem.words(number: 3).join(' ') }
-  notable_id  { |id| id }
-end
-
-Schema.create

data/spec/helpers/polyamorous_helper.rb

@@ -1,13 +0,0 @@
-module PolyamorousHelper
-  def new_join_association(reflection, children, klass)
-    Polyamorous::JoinAssociation.new reflection, children, klass
-  end
-
-  def new_join_dependency(klass, associations = {})
-    Polyamorous::JoinDependency.new klass, klass.arel_table, associations, Polyamorous::InnerJoin
-  end
-
-  def new_join(name, type = Polyamorous::InnerJoin, klass = nil)
-    Polyamorous::Join.new name, type, klass
-  end
-end

data/spec/helpers/ransack_helper.rb

@@ -1,9 +0,0 @@
-module RansackHelper
-  def quote_table_name(table)
-    ActiveRecord::Base.connection.quote_table_name(table)
-  end
-
-  def quote_column_name(column)
-    ActiveRecord::Base.connection.quote_column_name(column)
-  end
-end

data/spec/polyamorous/activerecord_compatibility_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-module Polyamorous
-  describe "ActiveRecord Compatibility" do
-    it 'works with self joins and includes' do
-      trade_account = Account.create!
-      Account.create!(trade_account: trade_account)
-
-      accounts = Account.joins(:trade_account).includes(:trade_account, :agent_account)
-      account = accounts.first
-
-      expect(account.agent_account).to be_nil
-    end
-  end
-end

data/spec/polyamorous/join_association_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-module Polyamorous
-  describe JoinAssociation do
-    let(:join_dependency) { new_join_dependency Note, {} }
-    let(:reflection) { Note.reflect_on_association(:notable) }
-    let(:parent) { join_dependency.send(:join_root) }
-    let(:join_association) {
-      new_join_association(reflection, parent.children, Article)
-    }
-
-    subject { new_join_association(reflection, parent.children, Person) }
-
-    it 'leaves the original reflection intact for thread safety' do
-      reflection.instance_variable_set(:@klass, Article)
-      join_association
-      .swapping_reflection_klass(reflection, Person) do |new_reflection|
-        expect(new_reflection.options).not_to equal reflection.options
-        expect(new_reflection.options).not_to have_key(:polymorphic)
-        expect(new_reflection.klass).to eq(Person)
-        expect(reflection.klass).to eq(Article)
-      end
-    end
-
-    it 'sets the polymorphic option to true after initializing' do
-      expect(join_association.reflection.options[:polymorphic]).to be true
-    end
-  end
-end

data/spec/polyamorous/join_dependency_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-
-module Polyamorous
-  describe JoinDependency do
-    context 'with symbol joins' do
-      subject { new_join_dependency Person, articles: :comments }
-
-      specify { expect(subject.send(:join_root).drop(1).size)
-        .to eq(2) }
-      specify { expect(subject.send(:join_root).drop(1).map(&:join_type).uniq)
-        .to eq [Polyamorous::InnerJoin] }
-    end
-
-    context 'with has_many :through association' do
-      subject { new_join_dependency Person, :authored_article_comments }
-
-      specify { expect(subject.send(:join_root).drop(1).size)
-        .to eq 1 }
-      specify { expect(subject.send(:join_root).drop(1).first.table_name)
-        .to eq 'comments' }
-    end
-
-    context 'with outer join' do
-      subject { new_join_dependency Person, new_join(:articles, :outer) }
-
-      specify { expect(subject.send(:join_root).drop(1).size)
-        .to eq 1 }
-      specify { expect(subject.send(:join_root).drop(1).first.join_type)
-        .to eq Polyamorous::OuterJoin }
-    end
-
-    context 'with nested outer joins' do
-      subject { new_join_dependency Person,
-        new_join(:articles, :outer) => new_join(:comments, :outer) }
-
-      specify { expect(subject.send(:join_root).drop(1).size)
-        .to eq 2 }
-      specify { expect(subject.send(:join_root).drop(1).map(&:join_type))
-        .to eq [Polyamorous::OuterJoin, Polyamorous::OuterJoin] }
-      specify { expect(subject.send(:join_root).drop(1).map(&:join_type).uniq)
-        .to eq [Polyamorous::OuterJoin] }
-    end
-
-    context 'with polymorphic belongs_to join' do
-      subject { new_join_dependency Note, new_join(:notable, :inner, Person) }
-
-      specify { expect(subject.send(:join_root).drop(1).size)
-        .to eq 1 }
-      specify { expect(subject.send(:join_root).drop(1).first.join_type)
-        .to eq Polyamorous::InnerJoin }
-      specify { expect(subject.send(:join_root).drop(1).first.table_name)
-        .to eq 'people' }
-    end
-
-    context 'with polymorphic belongs_to join and nested symbol join' do
-      subject { new_join_dependency Note,
-        new_join(:notable, :inner, Person) => :comments }
-
-      specify { expect(subject.send(:join_root).drop(1).size)
-        .to eq 2 }
-      specify { expect(subject.send(:join_root).drop(1).map(&:join_type).uniq)
-        .to eq [Polyamorous::InnerJoin] }
-      specify { expect(subject.send(:join_root).drop(1).first.table_name)
-        .to eq 'people' }
-      specify { expect(subject.send(:join_root).drop(1)[1].table_name)
-        .to eq 'comments' }
-    end
-
-    context 'with polymorphic belongs_to join and nested join' do
-      subject { new_join_dependency Note,
-        new_join(:notable, :outer, Person) => :comments }
-      specify { expect(subject.send(:join_root).drop(1).size).to eq 2 }
-      specify { expect(subject.send(:join_root).drop(1).map(&:join_type)).to eq [Polyamorous::OuterJoin, Polyamorous::InnerJoin] }
-      specify { expect(subject.send(:join_root).drop(1).first.table_name)
-        .to eq 'people' }
-      specify { expect(subject.send(:join_root).drop(1)[1].table_name)
-        .to eq 'comments' }
-    end
-  end
-end

data/spec/polyamorous/join_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-module Polyamorous
-  describe Join do
-    it 'is a tree node' do
-      join = new_join(:articles, :outer)
-      expect(join).to be_kind_of(TreeNode)
-    end
-
-    it 'can be added to a tree' do
-      join = new_join(:articles, :outer)
-
-      tree_hash = {}
-      join.add_to_tree(tree_hash)
-
-      expect(tree_hash[join]).to be {}
-    end
-  end
-end