activerecord-filter 7.0.0 → 7.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d1644f69a43b55b39739e14afa9e43d907dde5046cd59f82d6b1984c03bc585
-  data.tar.gz: 21df3a894fb089c20894fde8b6119b6567bd1c3424b0147ef9aebe34b35356ac
+  metadata.gz: 48643ae6cc991c1dff7397b4d72c5f2f0c125809f06c03deda47557f9f5102d8
+  data.tar.gz: adcc3b342d478ad0802882041abf9ef583abd552d35d8ffccb574987f66d7a4b
 SHA512:
-  metadata.gz: cba77ac497ae138c663cbd7b797e81fe6f1ca8ca05b869f4a8c7e8d8c5c9321018623b5c611272b59bb5439c897d7c7363fb7f2a7169af7d65af29193171c72d
-  data.tar.gz: 892989bcf29310cbb657f22642e9f37c079c7d3f0f87e22a6e288e0ba2bd98ebb8179f87e49de3f07820b91a725d48fa28b0a50a8f31c8e791bdc987c2355b3e
+  metadata.gz: 464eae805db85247060f6553cf242a49f852ff5d04e4aed17d3613e6a155e4dbaa49c72dcca89c14449fa2aee70ee15ef39afefdce6ed29f18d4c6141e31c8f3
+  data.tar.gz: 116e8b496f68e08f8b6c350432cd806de28b7a830898c84a02c0b4da4d6968d42c2da870e585eeeb247116592ee3db66189f078b88f5cacdd777633971e73b5b

data/lib/active_record/filter/alias_tracker_extension.rb

@@ -0,0 +1,12 @@
+module ActiveRecord::Filter::AliasTrackerExtension
+
+  def initialize(*, **)
+    super
+    @relation_trail = {}
+  end
+  
+  def aliased_table_for_relation(trail, arel_table, &block)
+    @relation_trail[trail] ||= aliased_table_for(arel_table, &block)
+  end
+  
+end

data/lib/active_record/filter/filter_clause_factory.rb

@@ -0,0 +1,22 @@
+class ActiveRecord::Filter::FilterClauseFactory
+
+  def initialize(klass, predicate_builder)
+    @klass = klass
+    @predicate_builder = predicate_builder
+  end
+
+  def build(filters, alias_tracker)
+    if filters.is_a?(Hash) || filters.is_a?(Array)
+      parts = [predicate_builder.build_from_filter_hash(filters, [], alias_tracker)]
+    else
+      raise ArgumentError, "Unsupported argument type: #{filters.inspect} (#{filters.class})"
+    end
+
+    ActiveRecord::Relation::WhereClause.new(parts)
+  end
+
+  protected
+
+  attr_reader :klass, :predicate_builder
+
+end

data/lib/active_record/filter/predicate_builder_extension.rb

@@ -0,0 +1,328 @@
+require "active_support/concern"
+
+module ActiveRecord::Filter::PredicateBuilderExtension
+
+  extend ActiveSupport::Concern
+  
+  class_methods do
+    def filter_joins(klass, filters)
+      custom = []
+      [build_filter_joins(klass, filters, [], custom), custom]
+    end
+
+    def build_filter_joins(klass, filters, relations=[], custom=[])
+      if filters.is_a?(Array)
+        filters.each { |f| build_filter_joins(klass, f, relations, custom) }.compact
+      elsif filters.is_a?(Hash)
+        filters.each do |key, value|
+          if klass.filters.has_key?(key.to_sym)
+            js = klass.filters.dig(key.to_sym, :joins)
+
+            if js.is_a?(Array)
+              js.each do |j|
+                if j.is_a?(String)
+                  custom << j
+                else
+                  relations << j
+                end
+              end
+            elsif js
+              if js.is_a?(String)
+                custom << js
+              else
+                relations << js
+              end
+            end
+          elsif reflection = klass._reflections[key.to_s]
+            if value.is_a?(Hash)
+              relations << if reflection.polymorphic?
+                value = value.dup
+                join_klass = value.delete(:as).safe_constantize
+                right_table = join_klass.arel_table
+                left_table = reflection.active_record.arel_table
+
+                on = right_table[join_klass.primary_key].
+                  eq(left_table[reflection.foreign_key]).
+                  and(left_table[reflection.foreign_type].eq(join_klass.name))
+
+                cross_boundry_joins = join_klass.left_outer_joins(ActiveRecord::PredicateBuilder.filter_joins(join_klass, value).flatten).send(:build_joins, [])
+
+                [
+                  left_table.join(right_table, Arel::Nodes::OuterJoin).on(on).join_sources,
+                  cross_boundry_joins
+                ]
+              else
+                {
+                  key => build_filter_joins(reflection.klass, value, [], custom)
+                }
+              end
+            elsif value.is_a?(Array)
+              value.each do |v|
+                relations << {
+                  key => build_filter_joins(reflection.klass, v, [], custom)
+                }
+              end
+            elsif value != true && value != false && value != 'true' && value != 'false' && !value.nil?
+              relations << key
+            end
+          elsif !klass.columns_hash.has_key?(key.to_s) && key.to_s.end_with?('_ids') && reflection = klass._reflections[key.to_s.gsub(/_ids$/, 's')]
+            relations << reflection.name
+          elsif reflection = klass.reflect_on_all_associations(:has_and_belongs_to_many).find {|r| r.join_table == key.to_s && value.keys.first.to_s == r.association_foreign_key.to_s }
+            reflection = klass._reflections[klass._reflections[reflection.name.to_s].send(:delegate_reflection).options[:through].to_s]
+            relations << {reflection.name => build_filter_joins(reflection.klass, value)}
+          else
+            {key => value}
+          end
+        end
+      end
+
+      relations
+    end
+  end
+  
+  def build_from_filter_hash(attributes, relation_trail, alias_tracker)
+    if attributes.is_a?(Array)
+      node = build_from_filter_hash(attributes.shift, relation_trail, alias_tracker)
+
+      n = attributes.shift(2)
+      while !n.empty?
+        n[1] = build_from_filter_hash(n[1], relation_trail, alias_tracker)
+        if n[0] == 'AND'
+          if node.is_a?(Arel::Nodes::And)
+            node.children.push(n[1])
+          else
+            node = node.and(n[1])
+          end
+        elsif n[0] == 'OR'
+          node = Arel::Nodes::Grouping.new(node).or(Arel::Nodes::Grouping.new(n[1]))
+        elsif !n[0].is_a?(String)
+          n[0] = build_from_filter_hash(n[0], relation_trail, alias_tracker)
+          if node.is_a?(Arel::Nodes::And)
+            node.children.push(n[0])
+          else
+            node = node.and(n[0])
+          end
+        else
+          raise 'lll'
+        end
+        n = attributes.shift(2)
+      end
+
+      node
+    elsif attributes.is_a?(Hash)
+      expand_from_filter_hash(attributes, relation_trail, alias_tracker)
+    else
+      expand_from_filter_hash({id: attributes}, relation_trail, alias_tracker)
+    end
+  end
+
+  def expand_from_filter_hash(attributes, relation_trail, alias_tracker)
+    klass = table.send(:klass)
+
+    children = attributes.flat_map do |key, value|
+      if custom_filter = klass.filters[key]
+        self.instance_exec(klass, table, key, value, relation_trail, alias_tracker, &custom_filter[:block])
+      elsif column = klass.columns_hash[key.to_s] || klass.columns_hash[key.to_s.split('.').first]
+        expand_filter_for_column(key, column, value, relation_trail)
+      elsif relation = klass.reflect_on_association(key)
+        expand_filter_for_relationship(relation, value, relation_trail, alias_tracker)
+      elsif key.to_s.end_with?('_ids') && relation = klass.reflect_on_association(key.to_s.gsub(/_ids$/, 's'))
+        expand_filter_for_relationship(relation, {id: value}, relation_trail, alias_tracker)
+      elsif relation = klass.reflect_on_all_associations(:has_and_belongs_to_many).find {|r| r.join_table == key.to_s && value.keys.first.to_s == r.association_foreign_key.to_s }
+        expand_filter_for_join_table(relation, value, relation_trail, alias_tracker)
+      else
+        raise ActiveRecord::UnkownFilterError.new("Unkown filter \"#{key}\" for #{klass}.")
+      end
+    end
+
+    children.compact!
+    if children.size > 1
+      Arel::Nodes::And.new(children)
+    else
+      children.first
+    end
+  end
+
+  def expand_filter_for_column(key, column, value, relation_trail)
+    attribute = table.arel_table[column.name]
+    relation_trail.each do |rt|
+      attribute = Arel::Attributes::Relation.new(attribute, rt)
+    end
+
+    if column.type == :json || column.type == :jsonb
+      names = key.to_s.split('.')
+      names.shift
+      attribute = attribute.dig(names)
+    elsif column.type == :geometry
+      value = if value.is_a?(Hash)
+        value.transform_values { |v| geometry_from_value(v) }
+      else
+        geometry_from_value(value)
+      end
+    end
+    
+    if value.is_a?(Hash)
+      nodes = value.map do |subkey, subvalue|
+        expand_filter_for_arel_attribute(column, attribute, subkey, subvalue)
+      end
+      nodes.inject { |c, n| c.nil? ? n : c.and(n) }
+    elsif value == nil
+      attribute.eq(nil)
+    elsif value == true || value == 'true'
+      column.type == :boolean ? attribute.eq(true) : attribute.not_eq(nil)
+    elsif value == false || value == 'false'
+      column.type == :boolean ? attribute.eq(false) : attribute.eq(nil)
+    elsif value.is_a?(Array) && !column.array
+      attribute.in(value)
+    elsif column.type != :json && column.type != :jsonb
+      converted_value = column.array ? Array(value) : value
+      attribute.eq(converted_value)
+    else
+      raise ActiveRecord::UnkownFilterError.new("Unkown type for #{column}. (type #{value.class})")
+    end
+
+  end
+
+  # TODO determine if SRID sent and cast to correct SRID
+  def geometry_from_value(value)
+    if value.is_a?(Array)
+      value.map { |g| geometry_from_value(g) }
+    elsif value.is_a?(Hash)
+      Arel::Nodes::NamedFunction.new('ST_SetSRID', [Arel::Nodes::NamedFunction.new('ST_GeomFromGeoJSON', [Arel::Nodes.build_quoted(JSON.generate(value))]), 4326])
+    elsif value[0,1] == "\x00" || value[0,1] == "\x01"
+      Arel::Nodes::NamedFunction.new('ST_SetSRID', [Arel::Nodes::NamedFunction.new('ST_GeomFromEWKB', [Arel::Nodes::BinaryValue.new(value)]), 4326])
+    elsif value[0,4] =~ /[0-9a-fA-F]{4}/
+      Arel::Nodes::NamedFunction.new('ST_SetSRID', [Arel::Nodes::NamedFunction.new('ST_GeomFromEWKB', [Arel::Nodes::HexEncodedBinaryValue.new(value)]), 4326])
+    else
+      Arel::Nodes::NamedFunction.new('ST_SetSRID', [Arel::Nodes::NamedFunction.new('ST_GeomFromText', [Arel::Nodes.build_quoted(value)]), 4326])
+    end
+  end
+  
+  def expand_filter_for_arel_attribute(column, attribute, key, value)
+    case key.to_sym
+    when :contains
+      case column.type
+      when :geometry
+        Arel::Nodes::NamedFunction.new('ST_Contains', [attribute, value])
+      else
+        attribute.contains(Arel::Nodes::Casted.new(column.array ? Array(value) : value, attribute))
+      end
+    when :contained_by
+      attribute.contained_by(Arel::Nodes::Casted.new(column.array ? Array(value) : value, attribute))
+    when :equal_to, :eq
+      case column.type
+      when :geometry
+        Arel::Nodes::NamedFunction.new('ST_Equals', [attribute, value])
+      else
+        attribute.eq(value)
+      end
+    when :excludes
+      attribute.excludes(Arel::Nodes::Casted.new(column.array ? Array(value) : value, attribute))
+    when :greater_than, :gt
+      attribute.gt(value)
+    when :greater_than_or_equal_to, :gteq, :gte
+      attribute.gteq(value)
+    when :has_key
+      attribute.has_key(value)
+    when :has_keys
+      attribute.has_keys(*Array(value).map { |x| Arel::Nodes.build_quoted(x) })
+    when :has_any_key
+      attribute.has_any_key(*Array(value).map { |x| Arel::Nodes.build_quoted(x) })
+    when :in
+      attribute.in(value)
+    when :intersects
+      attribute.intersects(value)
+    when :less_than, :lt
+      attribute.lt(value)
+    when :less_than_or_equal_to, :lteq, :lte
+      attribute.lteq(value)
+    when :like
+      attribute.matches(value, nil, true)
+    when :ilike
+      attribute.matches(value, nil, false)
+    when :not, :not_equal, :neq
+      attribute.not_eq(value)
+    when :not_in
+      attribute.not_in(value)
+    when :overlaps
+      case column.type
+      in :geometry
+        attribute.overlaps(value)
+      else
+        attribute.overlaps(Arel::Nodes::Casted.new(column.array ? Array(value) : value, attribute))
+      end
+    when :not_overlaps
+      attribute.not_overlaps(value)
+    when :ts_match
+      if value.is_a?(Array)
+        attribute.ts_query(*value)
+      else
+        attribute.ts_query(value)
+      end
+    when :within
+      attribute.within(Arel::Nodes.build_quoted(value))
+    else
+      raise "Not Supported: #{key.to_sym} on column \"#{column.name}\" of type #{column.type}"
+    end
+  end
+
+  def expand_filter_for_relationship(relation, value, relation_trail, alias_tracker)
+    case relation.macro
+    when :has_many
+      if value == true || value == 'true'
+        counter_cache_column_name = relation.counter_cache_column || "#{relation.plural_name}_count"
+        if relation.active_record.column_names.include?(counter_cache_column_name.to_s)
+          return table.arel_table[counter_cache_column_name.to_sym].gt(0)
+        else
+          raise "Not Supported: #{relation.name}"
+        end
+      elsif value == false || value == 'false'
+        counter_cache_column_name = relation.counter_cache_column || "#{relation.plural_name}_count"
+        if relation.active_record.column_names.include?(counter_cache_column_name.to_s)
+          return table.arel_table[counter_cache_column_name.to_sym].eq(0)
+        else
+          raise "Not Supported: #{relation.name}"
+        end
+      end
+
+    when :belongs_to
+      if value == true || value == 'true'
+        return table.arel_table[relation.foreign_key].not_eq(nil)
+      elsif value == false || value == 'false' || value.nil?
+        return table.arel_table[relation.foreign_key].eq(nil)
+      end
+    end
+
+    if relation.polymorphic?
+      value = value.dup
+      klass = value.delete(:as).safe_constantize
+
+      builder = self.class.new(ActiveRecord::TableMetadata.new(
+        klass,          
+        alias_tracker.aliased_table_for_relation(relation_trail + ["#{klass.table_name}_as_#{relation.name}"], klass.arel_table) { klass.arel_table.name },
+        relation
+      ))
+      builder.build_from_filter_hash(value, relation_trail + ["#{klass.table_name}_as_#{relation.name}"], alias_tracker)
+    else
+      builder = self.class.new(ActiveRecord::TableMetadata.new(
+        relation.klass,
+        alias_tracker.aliased_table_for_relation(relation_trail + [relation.name], relation.klass.arel_table) { relation.alias_candidate(table.arel_table.name || relation.klass.arel_table) },
+        relation
+      ))
+      builder.build_from_filter_hash(value, relation_trail + [relation.name], alias_tracker)
+    end
+
+  end
+
+
+  def expand_filter_for_join_table(relation, value, relation_trail, alias_tracker)
+    relation = relation.active_record._reflections[relation.active_record._reflections[relation.name.to_s].send(:delegate_reflection).options[:through].to_s]
+    builder = self.class.new(ActiveRecord::TableMetadata.new(
+      relation.klass,
+      alias_tracker.aliased_table_for_relation(relation_trail + [relation.name], relation.klass.arel_table) { relation.alias_candidate(table.arel_table.name || relation.klass.arel_table) },
+      relation
+    ))
+    builder.build_from_filter_hash(value, relation_trail + [relation.name], alias_tracker)
+  end
+
+end

data/lib/active_record/filter/query_methods_extension.rb

@@ -0,0 +1,65 @@
+module ActiveRecord::Filter::QueryMethodsExtension
+private
+  def build_join_buckets
+    buckets = Hash.new { |h, k| h[k] = [] }
+
+    unless left_outer_joins_values.empty?
+      stashed_left_joins = []
+      left_joins = select_named_joins(left_outer_joins_values, stashed_left_joins) do |left_join|
+        if left_join.is_a?(ActiveRecord::QueryMethods::CTEJoin)
+          buckets[:join_node] << build_with_join_node(left_join.name, Arel::Nodes::OuterJoin)
+# Add this elsif becasuse PR https://github.com/rails/rails/pull/46843
+# Changed a line https://github.com/rails/rails/blob/ae2983a75ca658d84afa414dea8eaf1cca87aa23/activerecord/lib/active_record/relation/query_methods.rb#L1769
+# that was probably a bug beforehand but allowed nodes to be joined
+# which I think was and still is supported?
+        elsif left_join.is_a?(Arel::Nodes::OuterJoin)
+          buckets[:join_node] << left_join
+        else
+          raise ArgumentError, "only Hash, Symbol and Array are allowed"
+        end
+      end
+
+      if joins_values.empty?
+        buckets[:named_join] = left_joins
+        buckets[:stashed_join] = stashed_left_joins
+        return buckets, Arel::Nodes::OuterJoin
+      else
+        stashed_left_joins.unshift construct_join_dependency(left_joins, Arel::Nodes::OuterJoin)
+      end
+    end
+
+    joins = joins_values.dup
+    if joins.last.is_a?(ActiveRecord::Associations::JoinDependency)
+      stashed_eager_load = joins.pop if joins.last.base_klass == klass
+    end
+
+    joins.each_with_index do |join, i|
+      joins[i] = Arel::Nodes::StringJoin.new(Arel.sql(join.strip)) if join.is_a?(String)
+    end
+
+    while joins.first.is_a?(Arel::Nodes::Join)
+      join_node = joins.shift
+      if !join_node.is_a?(Arel::Nodes::LeadingJoin) && (stashed_eager_load || stashed_left_joins)
+        buckets[:join_node] << join_node
+      else
+        buckets[:leading_join] << join_node
+      end
+    end
+
+    buckets[:named_join] = select_named_joins(joins, buckets[:stashed_join]) do |join|
+      if join.is_a?(Arel::Nodes::Join)
+        buckets[:join_node] << join
+      elsif join.is_a?(CTEJoin)
+        buckets[:join_node] << build_with_join_node(join.name)
+      else
+        raise "unknown class: %s" % join.class.name
+      end
+    end
+
+    buckets[:stashed_join].concat stashed_left_joins if stashed_left_joins
+    buckets[:stashed_join] << stashed_eager_load if stashed_eager_load
+
+    return buckets, Arel::Nodes::InnerJoin
+  end
+  
+end

data/lib/active_record/filter/relation_extension.rb

@@ -0,0 +1,65 @@
+module ActiveRecord::Filter::RelationExtension
+
+  def initialize(klass, table: klass.arel_table, predicate_builder: klass.predicate_builder, values: {})
+    @filters = []
+    super
+  end
+
+  def initialize_copy(other)
+    @filters = @filters.deep_dup
+    super
+  end
+
+  def clean_filters(value)
+    if value.class.name == 'ActionController::Parameters'.freeze
+      value.to_unsafe_h
+    elsif value.is_a?(Array)
+      value.map { |v| clean_filters(v) }
+    else
+      value
+    end
+  end
+
+  def filter(filters)
+    filters = clean_filters(filters)
+
+    if filters.nil? || filters.empty?
+      self
+    else
+      spawn.filter!(filters)
+    end
+  end
+
+  def filter!(filters)
+    js = ActiveRecord::PredicateBuilder.filter_joins(klass, filters)
+    js.flatten.each do |j|
+      if j.is_a?(String)
+        joins!(j)
+      elsif j.is_a?(Arel::Nodes::Join)
+        joins!(j)
+      elsif j.present?
+        left_outer_joins!(j)
+      end
+    end
+    @filters << filters
+    self
+  end
+
+  def filter_clause_factory
+    @filter_clause_factory ||= ActiveRecord::Filter::FilterClauseFactory.new(klass, predicate_builder)
+  end
+
+  def build_arel(aliases = nil)
+    arel = super
+    my_alias_tracker = ActiveRecord::Associations::AliasTracker.create(connection, table.name, [])
+    build_filters(arel, my_alias_tracker)
+    arel
+  end
+
+  def build_filters(manager, alias_tracker)
+    @filters.each do |filters|
+      manager.where(filter_clause_factory.build(filters, alias_tracker).ast)
+    end
+  end
+
+end

data/lib/active_record/filter/spawn_methods_extension.rb

@@ -0,0 +1,11 @@
+module ActiveRecord::Filter::SpawnMethodsExtension
+
+  def except(*skips)
+    r = relation_with values.except(*skips)
+    if !skips.include?(:where)
+      r.instance_variable_set(:@filters, instance_variable_get(:@filters))
+    end
+    r
+  end
+
+end

data/lib/active_record/filter/unkown_filter_error.rb

@@ -0,0 +1,2 @@
+class ActiveRecord::UnkownFilterError < NoMethodError
+end

data/lib/active_record/filter/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Filter
-    VERSION = '7.0.0'
+    VERSION = '7.0.1'
   end
 end

data/lib/active_record/filter.rb

@@ -1,25 +1,16 @@
 require 'active_record'
 require 'arel/extensions'
-
-class ActiveRecord::UnkownFilterError < NoMethodError
-end
-
-class ActiveRecord::Associations::AliasTracker
-
-  def initialize(connection, aliases)
-    @aliases    = aliases
-    @connection = connection
-    @relation_trail = {}
-  end
-  
-  def aliased_table_for_relation(trail, arel_table, &block)
-    @relation_trail[trail] ||= aliased_table_for(arel_table, &block)
-  end
-  
-end
+require 'active_record/filter/unkown_filter_error'
 
 module ActiveRecord::Filter
 
+  autoload :QueryMethodsExtension, 'active_record/filter/query_methods_extension'
+  autoload :AliasTrackerExtension, 'active_record/filter/alias_tracker_extension'
+  autoload :FilterClauseFactory, 'active_record/filter/filter_clause_factory'
+  autoload :RelationExtension, 'active_record/filter/relation_extension'
+  autoload :PredicateBuilderExtension, 'active_record/filter/predicate_builder_extension'
+  autoload :SpawnMethodsExtension, 'active_record/filter/spawn_methods_extension'
+  
   delegate :filter, :filter_for, to: :all
 
   def inherited(subclass)
@@ -32,431 +23,15 @@ module ActiveRecord::Filter
   end
 
   def filter_on(name, dependent_joins=nil, &block)
-    @filters[name.to_s] = {
-      joins: dependent_joins,
-      block: block
-    }
-  end
-
-end
-
-module ActiveRecord
-  class PredicateBuilder # :nodoc:
-
-    def self.filter_joins(klass, filters)
-      custom = []
-      [build_filter_joins(klass, filters, [], custom), custom]
-    end
-
-    def self.build_filter_joins(klass, filters, relations=[], custom=[])
-      if filters.is_a?(Array)
-        filters.each { |f| build_filter_joins(klass, f, relations, custom) }.compact
-      elsif filters.is_a?(Hash)
-        filters.each do |key, value|
-          if klass.filters.has_key?(key.to_sym)
-            js = klass.filters.dig(key.to_sym, :joins)
-
-            if js.is_a?(Array)
-              js.each do |j|
-                if j.is_a?(String)
-                  custom << j
-                else
-                  relations << j
-                end
-              end
-            elsif js
-              if js.is_a?(String)
-                custom << js
-              else
-                relations << js
-              end
-            end
-          elsif reflection = klass._reflections[key.to_s]
-            if value.is_a?(Hash)
-              relations << if reflection.polymorphic?
-                value = value.dup
-                join_klass = value.delete(:as).safe_constantize
-                right_table = join_klass.arel_table
-                left_table = reflection.active_record.arel_table
-
-                on = right_table[join_klass.primary_key].
-                  eq(left_table[reflection.foreign_key]).
-                  and(left_table[reflection.foreign_type].eq(join_klass.name))
-
-                cross_boundry_joins = join_klass.left_outer_joins(ActiveRecord::PredicateBuilder.filter_joins(join_klass, value).flatten).send(:build_joins, [])
-
-                [
-                  left_table.join(right_table, Arel::Nodes::OuterJoin).on(on).join_sources,
-                  cross_boundry_joins
-                ]
-              else
-                {
-                  key => build_filter_joins(reflection.klass, value, [], custom)
-                }
-              end
-            elsif value.is_a?(Array)
-              value.each do |v|
-                relations << {
-                  key => build_filter_joins(reflection.klass, v, [], custom)
-                }
-              end
-            elsif value != true && value != false && value != 'true' && value != 'false' && !value.nil?
-              relations << key
-            end
-          elsif !klass.columns_hash.has_key?(key.to_s) && key.to_s.end_with?('_ids') && reflection = klass._reflections[key.to_s.gsub(/_ids$/, 's')]
-            relations << reflection.name
-          elsif reflection = klass.reflect_on_all_associations(:has_and_belongs_to_many).find {|r| r.join_table == key.to_s && value.keys.first.to_s == r.association_foreign_key.to_s }
-            reflection = klass._reflections[klass._reflections[reflection.name.to_s].send(:delegate_reflection).options[:through].to_s]
-            relations << {reflection.name => build_filter_joins(reflection.klass, value)}
-          end
-        end
-      end
-
-      relations
-    end
-
-    def build_from_filter_hash(attributes, relation_trail, alias_tracker)
-      if attributes.is_a?(Array)
-        node = build_from_filter_hash(attributes.shift, relation_trail, alias_tracker)
-
-        n = attributes.shift(2)
-        while !n.empty?
-          n[1] = build_from_filter_hash(n[1], relation_trail, alias_tracker)
-          if n[0] == 'AND'
-            if node.is_a?(Arel::Nodes::And)
-              node.children.push(n[1])
-            else
-              node = node.and(n[1])
-            end
-          elsif n[0] == 'OR'
-            node = Arel::Nodes::Grouping.new(node).or(Arel::Nodes::Grouping.new(n[1]))
-          elsif !n[0].is_a?(String)
-            n[0] = build_from_filter_hash(n[0], relation_trail, alias_tracker)
-            if node.is_a?(Arel::Nodes::And)
-              node.children.push(n[0])
-            else
-              node = node.and(n[0])
-            end
-          else
-            raise 'lll'
-          end
-          n = attributes.shift(2)
-        end
-
-        node
-      elsif attributes.is_a?(Hash)
-        expand_from_filter_hash(attributes, relation_trail, alias_tracker)
-      else
-        expand_from_filter_hash({id: attributes}, relation_trail, alias_tracker)
-      end
-    end
-
-    def expand_from_filter_hash(attributes, relation_trail, alias_tracker)
-      klass = table.send(:klass)
-
-      children = attributes.flat_map do |key, value|
-        if custom_filter = klass.filters[key]
-          self.instance_exec(klass, table, key, value, relation_trail, alias_tracker, &custom_filter[:block])
-        elsif column = klass.columns_hash[key.to_s] || klass.columns_hash[key.to_s.split('.').first]
-          expand_filter_for_column(key, column, value, relation_trail)
-        elsif relation = klass.reflect_on_association(key)
-          expand_filter_for_relationship(relation, value, relation_trail, alias_tracker)
-        elsif key.to_s.end_with?('_ids') && relation = klass.reflect_on_association(key.to_s.gsub(/_ids$/, 's'))
-          expand_filter_for_relationship(relation, {id: value}, relation_trail, alias_tracker)
-        elsif relation = klass.reflect_on_all_associations(:has_and_belongs_to_many).find {|r| r.join_table == key.to_s && value.keys.first.to_s == r.association_foreign_key.to_s }
-          expand_filter_for_join_table(relation, value, relation_trail, alias_tracker)
-        else
-          raise ActiveRecord::UnkownFilterError.new("Unkown filter \"#{key}\" for #{klass}.")
-        end
-      end
-
-      children.compact!
-      if children.size > 1
-        Arel::Nodes::And.new(children)
-      else
-        children.first
-      end
-    end
-
-    def expand_filter_for_column(key, column, value, relation_trail)
-      attribute = table.arel_table[column.name]
-      relation_trail.each do |rt|
-        attribute = Arel::Attributes::Relation.new(attribute, rt)
-      end
-
-      if column.type == :json || column.type == :jsonb
-        names = key.to_s.split('.')
-        names.shift
-        attribute = attribute.dig(names)
-      end
-
-      if value.is_a?(Hash)
-        nodes = value.map do |subkey, subvalue|
-          expand_filter_for_arel_attribute(column, attribute, subkey, subvalue)
-        end
-        nodes.inject { |c, n| c.nil? ? n : c.and(n) }
-      elsif value == nil
-        attribute.eq(nil)
-      elsif value == true || value == 'true'
-        column.type == :boolean ? attribute.eq(true) : attribute.not_eq(nil)
-      elsif value == false || value == 'false'
-        column.type == :boolean ? attribute.eq(false) : attribute.eq(nil)
-      elsif value.is_a?(Array) && !column.array
-        attribute.in(value)
-      elsif column.type != :json && column.type != :jsonb
-        converted_value = column.array ? Array(value) : value
-        attribute.eq(converted_value)
-      else
-        raise ActiveRecord::UnkownFilterError.new("Unkown type for #{column}. (type #{value.class})")
-      end
-
-    end
-
-    def expand_filter_for_arel_attribute(column, attribute, key, value)
-      case key.to_sym
-      when :contains
-        attribute.contains(Arel::Nodes::Casted.new(column.array ? Array(value) : value, attribute))
-      when :contained_by
-        attribute.contained_by(Arel::Nodes::Casted.new(column.array ? Array(value) : value, attribute))
-      when :equal_to, :eq
-        attribute.eq(value)
-      when :excludes
-        attribute.excludes(Arel::Nodes::Casted.new(column.array ? Array(value) : value, attribute))
-      when :greater_than, :gt
-        attribute.gt(value)
-      when :greater_than_or_equal_to, :gteq, :gte
-        attribute.gteq(value)
-      when :has_key
-        attribute.has_key(value)
-      when :has_keys
-        attribute.has_keys(*Array(value).map { |x| Arel::Nodes.build_quoted(x) })
-      when :has_any_key
-        attribute.has_any_key(*Array(value).map { |x| Arel::Nodes.build_quoted(x) })
-      when :in
-        attribute.in(value)
-      when :intersects
-        # geometry_value = if value.is_a?(Hash) # GeoJSON
-        #   Arel::Nodes::NamedFunction.new('ST_GeomFromGeoJSON', [JSON.generate(value)])
-        # elsif # EWKB
-        # elsif # WKB
-        # elsif # EWKT
-        # elsif # WKT
-        # end
-
-        # TODO us above if to determin if SRID sent
-        geometry_value = if value.is_a?(Hash)
-          Arel::Nodes::NamedFunction.new('ST_SetSRID', [Arel::Nodes::NamedFunction.new('ST_GeomFromGeoJSON', [Arel::Nodes.build_quoted(JSON.generate(subvalue))]), 4326])
-        elsif value[0,1] == "\x00" || value[0,1] == "\x01" || value[0,4] =~ /[0-9a-fA-F]{4}/
-          Arel::Nodes::NamedFunction.new('ST_SetSRID', [Arel::Nodes::NamedFunction.new('ST_GeomFromEWKB', [Arel::Nodes.build_quoted(subvalue)]), 4326])
-        else
-          Arel::Nodes::NamedFunction.new('ST_SetSRID', [Arel::Nodes::NamedFunction.new('ST_GeomFromText', [Arel::Nodes.build_quoted(subvalue)]), 4326])
-        end
-
-        Arel::Nodes::NamedFunction.new('ST_Intersects', [attribute, geometry_value])
-      when :less_than, :lt
-        attribute.lt(value)
-      when :less_than_or_equal_to, :lteq, :lte
-        attribute.lteq(value)
-      when :like
-        attribute.matches(value, nil, true)
-      when :ilike
-        attribute.matches(value, nil, false)
-      when :not, :not_equal, :neq
-        attribute.not_eq(value)
-      when :not_in
-        attribute.not_in(value)
-      when :overlaps
-        attribute.overlaps(Arel::Nodes::Casted.new(column.array ? Array(value) : value, attribute))
-      when :not_overlaps
-        attribute.not_overlaps(value)
-      when :ts_match
-        if value.is_a?(Array)
-          attribute.ts_query(*value)
-        else
-          attribute.ts_query(value)
-        end
-      when :within
-        if value.is_a?(String)
-          if /\A[0-9A-F]*\Z/i.match?(value) && (value.start_with?('00') || value.start_with?('01'))
-            attribute.within(Arel::Nodes::HexEncodedBinary.new(value))
-          else
-            attribute.within(Arel::Nodes.build_quoted(value))
-          end
-        elsif value.is_a?(Hash)
-          attribute.within(Arel::Nodes.build_quoted(value))
-        else
-          raise "Not Supported value for within: #{value.inspect}"
-        end
-      else
-        raise "Not Supported: #{key.to_sym} on column \"#{column.name}\" of type #{column.type}"
-      end
-    end
-
-    def expand_filter_for_relationship(relation, value, relation_trail, alias_tracker)
-      case relation.macro
-      when :has_many
-        if value == true || value == 'true'
-          counter_cache_column_name = relation.counter_cache_column || "#{relation.plural_name}_count"
-          if relation.active_record.column_names.include?(counter_cache_column_name.to_s)
-            return table.arel_table[counter_cache_column_name.to_sym].gt(0)
-          else
-            raise "Not Supported: #{relation.name}"
-          end
-        elsif value == false || value == 'false'
-          counter_cache_column_name = relation.counter_cache_column || "#{relation.plural_name}_count"
-          if relation.active_record.column_names.include?(counter_cache_column_name.to_s)
-            return table.arel_table[counter_cache_column_name.to_sym].eq(0)
-          else
-            raise "Not Supported: #{relation.name}"
-          end
-        end
-
-      when :belongs_to
-        if value == true || value == 'true'
-          return table.arel_table[relation.foreign_key].not_eq(nil)
-        elsif value == false || value == 'false' || value.nil?
-          return table.arel_table[relation.foreign_key].eq(nil)
-        end
-      end
-
-      if relation.polymorphic?
-        value = value.dup
-        klass = value.delete(:as).safe_constantize
-
-        builder = self.class.new(TableMetadata.new(
-          klass,          
-          alias_tracker.aliased_table_for_relation(relation_trail + ["#{klass.table_name}_as_#{relation.name}"], klass.arel_table) { klass.arel_table.name },
-          relation
-        ))
-        builder.build_from_filter_hash(value, relation_trail + ["#{klass.table_name}_as_#{relation.name}"], alias_tracker)
-      else
-        builder = self.class.new(TableMetadata.new(
-          relation.klass,
-          alias_tracker.aliased_table_for_relation(relation_trail + [relation.name], relation.klass.arel_table) { relation.alias_candidate(table.arel_table.name || relation.klass.arel_table) },
-          relation
-        ))
-        builder.build_from_filter_hash(value, relation_trail + [relation.name], alias_tracker)
-      end
-
-    end
-
-
-    def expand_filter_for_join_table(relation, value, relation_trail, alias_tracker)
-      relation = relation.active_record._reflections[relation.active_record._reflections[relation.name.to_s].send(:delegate_reflection).options[:through].to_s]
-      builder = self.class.new(TableMetadata.new(
-        relation.klass,
-        alias_tracker.aliased_table_for_relation(relation_trail + [relation.name], relation.klass.arel_table) { relation.alias_candidate(table.arel_table.name || relation.klass.arel_table) },
-        relation
-      ))
-      builder.build_from_filter_hash(value, relation_trail + [relation.name], alias_tracker)
-    end
-
-  end
-end
-
-
-module ActiveRecord
-  class Relation
-    class FilterClauseFactory # :nodoc:
-      def initialize(klass, predicate_builder)
-        @klass = klass
-        @predicate_builder = predicate_builder
-      end
-
-      def build(filters, alias_tracker)
-        if filters.is_a?(Hash) || filters.is_a?(Array)
-          parts = [predicate_builder.build_from_filter_hash(filters, [], alias_tracker)]
-        else
-          raise ArgumentError, "Unsupported argument type: #{filters.inspect} (#{filters.class})"
-        end
-
-        WhereClause.new(parts)
-      end
-
-      protected
-
-      attr_reader :klass, :predicate_builder
-    end
+    @filters[name.to_s] = { joins: dependent_joins, block: block }
   end
-end
-
-class ActiveRecord::Relation
-  module Filter
-
-    def initialize(klass, table: klass.arel_table, predicate_builder: klass.predicate_builder, values: {})
-      @filters = []
-      super
-    end
-
-    def initialize_copy(other)
-      @filters = @filters.deep_dup
-      super
-    end
-
-    def clean_filters(value)
-      if value.class.name == 'ActionController::Parameters'.freeze
-        value.to_unsafe_h
-      elsif value.is_a?(Array)
-        value.map { |v| clean_filters(v) }
-      else
-        value
-      end
-    end
-
-    def filter(filters)
-      filters = clean_filters(filters)
 
-      if filters.nil? || filters.empty?
-        self
-      else
-        spawn.filter!(filters)
-      end
-    end
-
-    def filter!(filters)
-      js = ActiveRecord::PredicateBuilder.filter_joins(klass, filters)
-      js.flatten.each do |j|
-        if j.is_a?(String)
-          joins!(j)
-        elsif j.is_a?(Arel::Nodes::Join)
-          joins!(j)
-        elsif j.present?
-          left_outer_joins!(j)
-        end
-      end
-      @filters << filters
-      self
-    end
-
-    def filter_clause_factory
-      @filter_clause_factory ||= FilterClauseFactory.new(klass, predicate_builder)
-    end
-
-    def build_arel(aliases = nil)
-      arel = super
-      my_alias_tracker = ActiveRecord::Associations::AliasTracker.create(connection, table.name, [])
-      build_filters(arel, my_alias_tracker)
-      arel
-    end
-
-    def build_filters(manager, alias_tracker)
-      @filters.each do |filters|
-        manager.where(filter_clause_factory.build(filters, alias_tracker).ast)
-      end
-    end
-
-  end
 end
 
-module ActiveRecord::SpawnMethods
-  def except(*skips)
-    r = relation_with values.except(*skips)
-    if !skips.include?(:where)
-      r.instance_variable_set(:@filters, instance_variable_get(:@filters))
-    end
-    r
-  end
-end
 
-ActiveRecord::Relation.prepend(ActiveRecord::Relation::Filter)
+ActiveRecord::QueryMethods.prepend(ActiveRecord::Filter::QueryMethodsExtension)
 ActiveRecord::Base.extend(ActiveRecord::Filter)
+ActiveRecord::Relation.prepend(ActiveRecord::Filter::RelationExtension)
+ActiveRecord::SpawnMethods.extend(ActiveRecord::Filter::SpawnMethodsExtension)
+ActiveRecord::PredicateBuilder.include(ActiveRecord::Filter::PredicateBuilderExtension)
+ActiveRecord::Associations::AliasTracker.prepend(ActiveRecord::Filter::AliasTrackerExtension)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-filter
 version: !ruby/object:Gem::Version
-  version: 7.0.0
+  version: 7.0.1
 platform: ruby
 authors:
 - Jon Bracy
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-07 00:00:00.000000000 Z
+date: 2024-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 7.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 7.0.3
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -178,6 +178,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord-postgis-adapter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A safe way to accept user parameters and query against your ActiveRecord
   Models
 email:
@@ -189,6 +203,13 @@ extra_rdoc_files:
 files:
 - README.md
 - lib/active_record/filter.rb
+- lib/active_record/filter/alias_tracker_extension.rb
+- lib/active_record/filter/filter_clause_factory.rb
+- lib/active_record/filter/predicate_builder_extension.rb
+- lib/active_record/filter/query_methods_extension.rb
+- lib/active_record/filter/relation_extension.rb
+- lib/active_record/filter/spawn_methods_extension.rb
+- lib/active_record/filter/unkown_filter_error.rb
 - lib/active_record/filter/version.rb
 homepage: https://github.com/malomalo/activerecord-filter
 licenses:
@@ -211,7 +232,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: A safe way to accept user parameters and query against your ActiveRecord