ransack 5.0.1 → 6.0.0

data/lib/ransack/search.rb

@@ -22,6 +22,11 @@ module Ransack
 
     def initialize(object, params = {}, options = {})
       strip_whitespace = options.fetch(:strip_whitespace, Ransack.options[:strip_whitespace])
+      # Strong parameters carry whether the controller permitted them. Read
+      # that before the unwrap below discards it: a model with no allowlist
+      # of its own lets a permitted controller be the boundary, and a plain
+      # Hash never counts (#1403).
+      permitted = params.respond_to?(:permitted?) && params.permitted?
       params = params.to_unsafe_h if params.respond_to?(:to_unsafe_h)
       if params.is_a? Hash
         # deep_transform_values rebuilds every nested hash and array, which
@@ -36,7 +41,9 @@ module Ransack
       end
       @context = options[:context] || Context.for(object, options)
       @context.auth_object = options[:auth_object]
+      @context.permitted = permitted
       @context.ignore_unknown_conditions = options[:ignore_unknown_conditions]
+      @context.null_sentinel = options[:null_sentinel]
       @base = Nodes::Grouping.new(
         @context, options[:grouping] || Constants::AND
         )
@@ -65,7 +72,10 @@ module Ransack
       self
     end
 
+    # Replaces the sorts, so `search.sorts = []` clears them. Before 6.0 each
+    # assignment appended (#994); use `build_sort` to add one.
     def sorts=(args)
+      @sorts = [] unless args.is_a?(String)
       case args
       when Array
         args.each do |sort|
@@ -74,12 +84,11 @@ module Ransack
           else
             sort = Nodes::Sort.extract(@context, sort)
           end
-          self.sorts << sort if sort
+          add_sort(sort) if sort
         end
       when Hash
         args.each do |index, attrs|
-          sort = Nodes::Sort.new(@context).build(attrs)
-          self.sorts << sort
+          add_sort(Nodes::Sort.new(@context).build(attrs))
         end
       when String
         self.sorts = [args]
@@ -105,22 +114,35 @@ module Ransack
       Nodes::Sort.new(@context).build(opts)
     end
 
+    # A scope wins over an attribute of the same name, as it does when the
+    # params hash is built (#1472).
     def method_missing(method_id, *args)
       method_name = method_id.to_s
       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)
+      if @context.ransackable_scope?(getter_name, @context.object)
         if method_name =~ /=$/
-          add_scope getter_name, args
+          add_scope getter_name, args.size == 1 ? args.first : args
         else
           @scope_args[method_name]
         end
+      elsif base.attribute_method?(getter_name)
+        base.send(method_id, *args)
       else
         super
       end
     end
 
+    # Rails' form helpers only read a field's value back when the object
+    # says it responds to the reader; `form_with` in particular checks
+    # 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)
+      base.attribute_method?(getter_name) ||
+        @context.ransackable_scope?(getter_name, @context.object) ||
+        super
+    end
+
     def inspect
       details = [
         [:class, klass.name],
@@ -136,6 +158,22 @@ module Ransack
 
     private
 
+    # A sort that names neither a sortable attribute nor a `sort_by_<name>_<dir>`
+    # scope produces no ORDER BY. Under a strict search that is an error, the
+    # same as an unknown attribute in a condition (#1427); otherwise it is
+    # dropped as before.
+    def add_sort(sort)
+      if @context.strict_conditions? && !sort.valid? && !sort_scope?(sort)
+        raise InvalidSearchError, "Invalid sort term #{sort.name}"
+      end
+
+      self.sorts << sort
+    end
+
+    def sort_scope?(sort)
+      @context.object.respond_to?(:"sort_by_#{sort.name}_#{sort.dir}")
+    end
+
     def add_scope(key, args)
       sanitized_args = @context.sanitize_scope_args(key, args)
 
@@ -242,9 +280,14 @@ module Ransack
     end
 
     # Values in the `c:` API may be given bare or wrapped in a `{ value: ... }`
-    # envelope, the same two forms `Condition#values=` accepts.
+    # envelope, the same two forms `Condition#values=` accepts. The envelope is
+    # opened by key rather than by truthiness: `false` is a value to search
+    # for, and `value[:value] || value['value']` read it as nil, which the
+    # pruning above then dropped (#1736).
     def unwrap_value(value)
-      value.is_a?(Hash) ? (value[:value] || value['value']) : value
+      return value unless value.is_a?(Hash)
+
+      value.key?(:value) ? value[:value] : value['value']
     end
   end
 end

data/lib/ransack/version.rb

@@ -1,3 +1,3 @@
 module Ransack
-  VERSION = '5.0.1'
+  VERSION = '6.0.0'
 end

data/lib/ransack.rb

@@ -4,11 +4,14 @@ require 'active_support/deprecator'
 
 require 'active_support/core_ext'
 require 'ransack/configuration'
-require 'polyamorous/polyamorous'
 
 module Ransack
   extend Configuration
   class UntraversableAssociationError < StandardError; end
+
+  def self.deprecator
+    @deprecator ||= ActiveSupport::Deprecation.new('7.0', 'Ransack')
+  end
 end
 
 Ransack.configure do |config|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ransack
 version: !ruby/object:Gem::Version
-  version: 5.0.1
+  version: 6.0.0
 platform: ruby
 authors:
 - Ernie Miller
@@ -62,25 +62,23 @@ email:
 - ernie@erniemiller.org
 - radarlistener@gmail.com
 - jonnyatack@gmail.com
-- magma.craters2h@icloud.com
+- sean@immersive-app.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
-- lib/polyamorous/activerecord/join_association.rb
-- lib/polyamorous/activerecord/join_association_7_2.rb
-- lib/polyamorous/activerecord/join_dependency.rb
-- lib/polyamorous/activerecord/reflection.rb
-- lib/polyamorous/join.rb
-- lib/polyamorous/polyamorous.rb
-- lib/polyamorous/swapping_reflection_class.rb
-- lib/polyamorous/tree_node.rb
 - lib/ransack.rb
 - lib/ransack/active_record.rb
-- lib/ransack/adapters/active_record/base.rb
-- lib/ransack/adapters/active_record/context.rb
+- lib/ransack/active_record/base.rb
+- lib/ransack/active_record/context.rb
+- lib/ransack/active_record/dialect.rb
+- lib/ransack/active_record/join.rb
+- lib/ransack/active_record/join_association.rb
+- lib/ransack/active_record/join_dependency.rb
+- lib/ransack/active_record/reflection.rb
+- lib/ransack/active_record/tree_node.rb
 - lib/ransack/configuration.rb
 - lib/ransack/constants.rb
 - lib/ransack/context.rb
@@ -142,7 +140,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/polyamorous/activerecord/join_association.rb

@@ -1,70 +0,0 @@
-module Polyamorous
-  module JoinAssociationExtensions
-    include SwappingReflectionClass
-    def self.prepended(base)
-      base.class_eval { attr_reader :join_type }
-    end
-
-    def initialize(reflection, children, polymorphic_class = nil, join_type = Arel::Nodes::InnerJoin)
-      @join_type = join_type
-      if polymorphic_class && ::ActiveRecord::Base > polymorphic_class
-        swapping_reflection_klass(reflection, polymorphic_class) do |reflection|
-          super(reflection, children)
-          self.reflection.options[:polymorphic] = true
-        end
-      else
-        super(reflection, children)
-      end
-    end
-
-    # Same as #join_constraints, but instead of constructing tables from the
-    # given block, uses the ones passed
-    def join_constraints_with_tables(foreign_table, foreign_klass, join_type, alias_tracker, tables)
-      joins = []
-      chain = []
-
-      reflection.chain.each.with_index do |reflection, i|
-        table = tables[i]
-
-        @table ||= table
-        chain << [reflection, table]
-      end
-
-      # The chain starts with the target table, but we want to end with it here (makes
-      # more sense in this context), so we reverse
-      chain.reverse_each do |reflection, table|
-        klass = reflection.klass
-
-        join_scope = reflection.join_scope(table, foreign_table, foreign_klass)
-
-        unless join_scope.references_values.empty?
-          join_dependency = join_scope.construct_join_dependency(
-            join_scope.eager_load_values | join_scope.includes_values, Arel::Nodes::OuterJoin
-          )
-          join_scope.joins!(join_dependency)
-        end
-
-        arel = join_scope.arel(alias_tracker.aliases)
-        nodes = arel.constraints.first
-
-        if nodes.is_a?(Arel::Nodes::And)
-          others = nodes.children.extract! do |node|
-            !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
-          end
-        end
-
-        joins << table.create_join(table, table.create_on(nodes), join_type)
-
-        if others && !others.empty?
-          joins.concat arel.join_sources
-          append_constraints(joins.last, others)
-        end
-
-        # The current table in this iteration becomes the foreign table in the next
-        foreign_table, foreign_klass = table, klass
-      end
-
-      joins
-    end
-  end
-end

data/lib/polyamorous/activerecord/join_association_7_2.rb

@@ -1,55 +0,0 @@
-module Polyamorous
-  module JoinAssociationExtensions
-    # Same as #join_constraints, but instead of constructing tables from the
-    # given block, uses the ones passed
-    def join_constraints_with_tables(foreign_table, foreign_klass, join_type, alias_tracker, tables)
-      joins = []
-      chain = []
-
-      reflection.chain.each.with_index do |reflection, i|
-        table = tables[i]
-
-        @table ||= table
-        chain << [reflection, table]
-      end
-
-      base_klass.with_connection do |connection|
-        # The chain starts with the target table, but we want to end with it here (makes
-        # more sense in this context), so we reverse
-        chain.reverse_each do |reflection, table|
-          klass = reflection.klass
-
-          join_scope = reflection.join_scope(table, foreign_table, foreign_klass)
-
-          unless join_scope.references_values.empty?
-            join_dependency = join_scope.construct_join_dependency(
-              join_scope.eager_load_values | join_scope.includes_values, Arel::Nodes::OuterJoin
-            )
-            join_scope.joins!(join_dependency)
-          end
-
-          arel = join_scope.arel(alias_tracker.aliases)
-          nodes = arel.constraints.first
-
-          if nodes.is_a?(Arel::Nodes::And)
-            others = nodes.children.extract! do |node|
-              !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
-            end
-          end
-
-          joins << table.create_join(table, table.create_on(nodes), join_type)
-
-          if others && !others.empty?
-            joins.concat arel.join_sources
-            append_constraints(connection, joins.last, others)
-          end
-
-          # The current table in this iteration becomes the foreign table in the next
-          foreign_table, foreign_klass = table, klass
-        end
-
-        joins
-      end
-    end
-  end
-end

data/lib/polyamorous/activerecord/join_dependency.rb

@@ -1,102 +0,0 @@
-module Polyamorous
-  module JoinDependencyExtensions
-    # Replaces ActiveRecord::Associations::JoinDependency#build
-    def build(associations, base_klass)
-      associations.map do |name, right|
-        if name.is_a? Join
-          reflection = find_reflection base_klass, name.name
-          reflection.check_validity!
-          reflection.check_eager_loadable!
-
-          klass = if reflection.polymorphic?
-            name.klass || base_klass
-          else
-            reflection.klass
-          end
-          JoinAssociation.new(reflection, build(right, klass), name.klass, name.type)
-        else
-          reflection = find_reflection base_klass, name
-          reflection.check_validity!
-          reflection.check_eager_loadable!
-
-          if reflection.polymorphic?
-            raise ActiveRecord::EagerLoadPolymorphicError.new(reflection)
-          end
-          JoinAssociation.new(reflection, build(right, reflection.klass))
-        end
-      end
-    end
-
-    def join_constraints(joins_to_add, alias_tracker, references)
-      @alias_tracker = alias_tracker
-      @joined_tables = {}
-      @references = {}
-
-      references.each do |table_name|
-        @references[table_name.to_sym] = table_name if table_name.is_a?(String)
-      end
-
-      joins = make_join_constraints(join_root, join_type)
-
-      joins.concat joins_to_add.flat_map { |oj|
-        if join_root.match?(oj.join_root) && join_root.table.name == oj.join_root.table.name
-          walk join_root, oj.join_root, oj.join_type
-        else
-          make_join_constraints(oj.join_root, oj.join_type)
-        end
-      }
-    end
-
-    def construct_tables_for_association!(join_root, association)
-      tables = table_aliases_for(join_root, association)
-      association.table = tables.first
-      tables
-    end
-
-    private
-
-    def table_aliases_for(parent, node)
-      @joined_tables ||= {}
-      node.reflection.chain.map { |reflection|
-        table, terminated = @joined_tables[reflection]
-        root = reflection == node.reflection
-
-        if table && (!root || !terminated)
-          @joined_tables[reflection] = [table, true] if root
-          table
-        else
-          table = alias_tracker.aliased_table_for(reflection.klass.arel_table) do
-            name = reflection.alias_candidate(parent.table_name)
-            root ? name : "#{name}_join"
-          end
-          @joined_tables[reflection] ||= [table, root] if join_type == Arel::Nodes::OuterJoin
-          table
-        end
-      }
-    end
-
-    module ClassMethods
-      # Prepended before ActiveRecord::Associations::JoinDependency#walk_tree
-      #
-      def walk_tree(associations, hash)
-        case associations
-        when TreeNode
-          associations.add_to_tree(hash)
-        when Hash
-          associations.each do |k, v|
-            cache =
-              if TreeNode === k
-                k.add_to_tree(hash)
-              else
-                hash[k] ||= {}
-              end
-            walk_tree(v, cache)
-          end
-        else
-          super(associations, hash)
-        end
-      end
-    end
-
-  end
-end

data/lib/polyamorous/activerecord/reflection.rb

@@ -1,11 +0,0 @@
-module Polyamorous
-  module ReflectionExtensions
-    def join_scope(table, foreign_table, foreign_klass)
-     if respond_to?(:polymorphic?) && polymorphic?
-        super.where!(foreign_table[foreign_type].eq(klass.name))
-      else
-        super
-      end
-    end
-  end
-end

data/lib/polyamorous/join.rb

@@ -1,70 +0,0 @@
-module Polyamorous
-  class Join
-    include TreeNode
-
-    attr_accessor :name
-    attr_reader :type, :klass
-
-    def initialize(name, type = InnerJoin, klass = nil)
-      @name = name
-      @type = convert_to_arel_join_type(type)
-      @klass = convert_to_class(klass) if klass
-    end
-
-    def klass=(klass)
-      @klass = convert_to_class(klass) if klass
-    end
-
-    def type=(type)
-      @type = convert_to_arel_join_type(type) if type
-    end
-
-    def hash
-      [@name, @type, @klass].hash
-    end
-
-    def eql?(other)
-      self.class == other.class &&
-      self.name  == other.name &&
-      self.type  == other.type &&
-      self.klass == other.klass
-    end
-
-    alias :== :eql?
-
-    def add_to_tree(hash)
-      hash[self] ||= {}
-    end
-
-    private
-
-    def convert_to_arel_join_type(type)
-      case type
-      when 'inner', :inner
-        InnerJoin
-      when 'outer', :outer
-        OuterJoin
-      when Class
-        if [InnerJoin, OuterJoin].include? type
-          type
-        else
-          raise ArgumentError, "#{type} cannot be converted to an ARel join type"
-        end
-      else
-        raise ArgumentError, "#{type} cannot be converted to an ARel join type"
-      end
-    end
-
-    def convert_to_class(value)
-      case value
-      when String, Symbol
-        Kernel.const_get(value)
-      when Class
-        value
-      else
-        raise ArgumentError, "#{value} cannot be converted to a Class"
-      end
-    end
-
-  end
-end

data/lib/polyamorous/polyamorous.rb

@@ -1,27 +0,0 @@
-ActiveSupport.on_load(:active_record) do
-  module Polyamorous
-    InnerJoin = Arel::Nodes::InnerJoin
-    OuterJoin = Arel::Nodes::OuterJoin
-
-    JoinDependency  = ::ActiveRecord::Associations::JoinDependency
-    JoinAssociation = ::ActiveRecord::Associations::JoinDependency::JoinAssociation
-  end
-
-  require 'polyamorous/tree_node'
-  require 'polyamorous/join'
-  require 'polyamorous/swapping_reflection_class'
-
-  require 'polyamorous/activerecord/join_association'
-  require 'polyamorous/activerecord/join_dependency'
-  require 'polyamorous/activerecord/reflection'
-
-  if ::ActiveRecord.version >= ::Gem::Version.new("7.2") && ::ActiveRecord.version < ::Gem::Version.new("7.2.2.1")
-    require "polyamorous/activerecord/join_association_7_2"
-  end
-
-  ActiveRecord::Reflection::AbstractReflection.send(:prepend, Polyamorous::ReflectionExtensions)
-
-  Polyamorous::JoinDependency.send(:prepend, Polyamorous::JoinDependencyExtensions)
-  Polyamorous::JoinDependency.singleton_class.send(:prepend, Polyamorous::JoinDependencyExtensions::ClassMethods)
-  Polyamorous::JoinAssociation.send(:prepend, Polyamorous::JoinAssociationExtensions)
-end

data/lib/polyamorous/swapping_reflection_class.rb

@@ -1,11 +0,0 @@
-module Polyamorous
-  module SwappingReflectionClass
-    def swapping_reflection_klass(reflection, klass)
-      new_reflection = reflection.clone
-      new_reflection.instance_variable_set(:@options, reflection.options.clone)
-      new_reflection.options.delete(:polymorphic)
-      new_reflection.instance_variable_set(:@klass, klass)
-      yield new_reflection
-    end
-  end
-end

data/lib/polyamorous/tree_node.rb

@@ -1,7 +0,0 @@
-module Polyamorous
-  module TreeNode
-    def add_to_tree(hash)
-      raise NotImplementedError
-    end
-  end
-end