activerecord-filter 6.0.0.4 → 6.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86c7f7cf36ec41fc4dae21d1460151fcf2a32a9813f13a8b0acec56ebdccfbdd
-  data.tar.gz: 9993953d4a401d46e1bfd60102162794fd6f13d496d2fcd3352534fa0601ef90
+  metadata.gz: 29fb0cf2e61a150f0ea6aaa4877961ccd58008daeb7af2bb9766f726f9b37e46
+  data.tar.gz: 7492a6050879102efac043637217972388f607af7c62a3b4a176b04d7695ea9b
 SHA512:
-  metadata.gz: 69ad9b34f9b0511a0e34d76ef819b147a5705b9d0731fdca7fdcd3b876a90d1685321386033354653c39d30d3fb96283a4e4443e5a330bc405736e3342c24e06
-  data.tar.gz: f466d0b394b040109ba460a24a1811c8f4550bdeb9ca17904a4906ee1c2f011e59bf38481e074c29e08b4f6af4ea81360352bebb65fa45e49a285377d798f291
+  metadata.gz: 9c2f00f35c2eeff0a93866024fbacaf5a24f14843d82ccf81e5b0eefb36918a3892424c00a3b5f01d8f42f176e63331b3ca90fb54be388900517572be44857d9
+  data.tar.gz: e3bd52216a2cbd41e9769cf7b813a5b69af63f03c45a7616e7cb0eea444711f746fd8a1bcb7b377b5b8c604463c011263f802473db072990d7a1559590c06e0d

data/README.md

@@ -5,7 +5,7 @@
 Installtion
 -----------
 
-- Add `gem 'activerecord-filter', require: 'active_record/filter'
+- Add `gem 'activerecord-filter', require: 'active_record/filter'`
 - Run `bundle install`
 
 Examples
@@ -14,48 +14,89 @@ Examples
 Normal columns:
 
 ```ruby
-Property.filter(:id => 5).to_sql
-# => "...WHERE properties.id = 5"
+Property.filter(id: 5).to_sql
+Property.filter(id: {eq: 5}).to_sql
+Property.filter(id: {equal_to: 5}).to_sql
+# => "... WHERE properties.id = 5 ..."
 
-Property.filter(:id => [5, 10, 15]).to_sql
-# => "...WHERE properties.id IN (5, 10, 15)"
+Property.filter(id: {not: 5}).to_sql
+Property.filter(id: {neq: 5}).to_sql
+Property.filter(id: {not_equal: 5}).to_sql
+# => "... WHERE properties.id != 5 ..."
 
-Property.filter(:id => {:gt => 5}).to_sql
-# => "...WHERE properties.id > 5"
+Property.filter(id: [5, 10, 15]).to_sql
+# => "... WHERE properties.id IN (5, 10, 15) ..."
 
-Property.filter(:id => {:gte => 5}).to_sql
-# => "...WHERE properties.id >= 5"
+Property.filter(id: {in: [5, 10, 15]}).to_sql
+# => "... WHERE properties.id IN (5, 10, 15) ..."
 
-Property.filter(:id => {:lt => 5}).to_sql
-# => "...WHERE properties.id < 5"
+Property.filter(id: {not_in: [5, 10, 15]}).to_sql
+# => "... WHERE properties.id NOT IN (5, 10, 15) ..."
 
-Property.filter(:id => {:lte => 5}).to_sql
-# => "...WHERE properties.id <= 5"
+Property.filter(id: {gt: 5}).to_sql
+Property.filter(id: {greater_than: 5}).to_sql
+# => "... WHERE properties.id > 5 ..."
 
-Property.filter(:address_id => nil).to_sql
-# => "...WHERE properties.address_id IS NULL..."
+Property.filter(id: {gte: 5}).to_sql
+Property.filter(id: {gteq: 5}).to_sql
+Property.filter(id: {greater_than_or_equal_to: 5}).to_sql
+# => "... WHERE properties.id >= 5 ..."
 
-Property.filter(:address_id => false).to_sql
-# => "...WHERE properties.address_id IS NULL..."
+Property.filter(id: {lt: 5}).to_sql
+Property.filter(id: {less_than: 5}).to_sql
+# => "... WHERE properties.id < 5 ..."
 
-Property.filter(:address_id => true).to_sql
-# => "...WHERE properties.address_id IS NOT NULL..."
+Property.filter(id: {lte: 5}).to_sql
+Property.filter(id: {lteq: 5}).to_sql
+Property.filter(id: {less_than_or_equal_to: 5}).to_sql
+# => "... WHERE properties.id <= 5 ..."
+
+Property.filter(address_id: nil).to_sql
+# => "... WHERE properties.address_id IS NULL ..."
+
+Property.filter(address_id: false).to_sql
+# => "... WHERE properties.address_id IS NULL ..."
+
+Property.filter(boolean_column: false).to_sql
+# => "... WHERE properties.boolean_column = FALSE ..."
+
+Property.filter(address_id: true).to_sql
+# => "... WHERE properties.address_id IS NOT NULL ..."
+
+Property.filter(boolean_column: true).to_sql
+# => "... WHERE properties.boolean_column = TRUE ..."
+```
+
+String columns:
+
+```ruby
+Property.filter(name: {like: 'nam%'}).to_sql
+# => "... WHERE properties.name LIKE 'nam%' ..."
+
+Property.filter(name: {ts_match: 'name'}).to_sql
+# => "... WHERE to_tsvector("properties"."name") @@ to_tsquery('name') ..."
 ```
 
 It can also work with array columns:
 
 ```ruby
-Property.filter(:tags => 'Skyscraper').to_sql
+Property.filter(tags: 'Skyscraper').to_sql
 # => "...WHERE properties.tags = '{'Skyscraper'}'..."
 
-Property.filter(:tags => ['Skyscraper', 'Brick']).to_sql
-# => "...WHERE (properties.tags = '{"Skyscraper", "Brick"}')..."
+Property.filter(tags: ['Skyscraper', 'Brick']).to_sql
+# => "...WHERE properties.tags = '{"Skyscraper", "Brick"}'..."
+
+Property.filter(tags: {overlaps: ['Skyscraper', 'Brick']}).to_sql
+# => "...WHERE properties.tags && '{"Skyscraper", "Brick"}'..."
+
+Property.filter(tags: {contains: ['Skyscraper', 'Brick']}).to_sql
+# => "...WHERE accounts.tags @> '{"Skyscraper", "Brick"}'..."
 
-Property.filter(:tags => {overlaps: ['Skyscraper', 'Brick']}).to_sql
-# => "...WHERE properties.tags && '{"Skyscraper", "Brick"}')..."
+Property.filter(tags: {excludes: ['Skyscraper', 'Brick']}).to_sql
+# => "...WHERE NOT (accounts.tags @> '{"Skyscraper", "Brick"}')..."
 
-Property.filter(:tags => {contains: ['Skyscraper', 'Brick']}).to_sql
-# => "...WHERE accounts.tags @> '{"Skyscraper", "Brick"}')..."
+Property.filter(tags: {contained_by: ['Skyscraper', 'Brick']}).to_sql
+# => "...WHERE accounts.tags <@ '{"Skyscraper", "Brick"}'..."
 ```
 
 And JSON columns:
@@ -70,6 +111,12 @@ Property.filter(metadata: { contains: { key: 'value' } }).to_sql
 Property.filter(metadata: { has_key: 'key' }).to_sql
 # => "...WHERE "properties"."metadata" ? 'key'..."
 
+Property.filter(metadata: { has_keys: ['key1', 'key2'] }).to_sql
+# => "...WHERE "properties"."metadata" ?& array['key1', 'key2']..."
+
+Property.filter(metadata: { has_any_key: ['key1', 'key2'] }).to_sql
+# => "...WHERE "properties"."metadata" ?| array['key1', 'key2']..."
+
 Property.filter("metadata.key": { eq: 'value' }).to_sql
 # => "...WHERE "properties"."metadata" #> '{key}' = 'value'..."
 ```
@@ -77,7 +124,7 @@ Property.filter("metadata.key": { eq: 'value' }).to_sql
 It can also sort on relations:
 
 ```ruby
-Photo.filter(:property => {name: 'Empire State'}).to_sql
-# => "...INNER JOIN properties ON properties.id = photos.property_id
-# => "   WHERE properties.name = 'Empire State'"
-```
+Photo.filter(property: {name: 'Empire State'}).to_sql
+# => "... INNER JOIN properties ON properties.id = photos.property_id ...
+# => "... WHERE properties.name = 'Empire State'"
+```

data/lib/active_record/filter.rb

@@ -4,26 +4,40 @@ 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
+
 module ActiveRecord::Filter
 
   delegate :filter, :filter_for, to: :all
-  
+
   def inherited(subclass)
     super
     subclass.instance_variable_set('@filters', HashWithIndifferentAccess.new)
   end
-  
+
   def filters
     @filters
   end
-  
+
   def filter_on(name, dependent_joins=nil, &block)
     @filters[name.to_s] = {
       joins: dependent_joins,
       block: block
     }
   end
-  
+
 end
 
 module ActiveRecord
@@ -33,7 +47,7 @@ module ActiveRecord
       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
@@ -41,7 +55,7 @@ module ActiveRecord
         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)
@@ -59,13 +73,37 @@ module ActiveRecord
             end
           elsif reflection = klass._reflections[key.to_s]
             if value.is_a?(Hash)
-              relations << {
-                key => build_filter_joins(reflection.klass, value, [], custom)
-              }
+              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.ends_with?('_ids') && reflection = klass._reflections[key.to_s.gsub(/_ids$/, 's')]
+          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]
@@ -73,10 +111,10 @@ module ActiveRecord
           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)
@@ -92,12 +130,19 @@ module ActiveRecord
             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)
@@ -105,10 +150,10 @@ module ActiveRecord
         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])
@@ -116,7 +161,7 @@ module ActiveRecord
           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.ends_with?('_ids') && relation = klass.reflect_on_association(key.to_s.gsub(/_ids$/, 's'))
+        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)
@@ -124,7 +169,7 @@ module ActiveRecord
           raise ActiveRecord::UnkownFilterError.new("Unkown filter \"#{key}\" for #{klass}.")
         end
       end
-      
+
       children.compact!
       if children.size > 1
         Arel::Nodes::And.new(children)
@@ -132,19 +177,19 @@ module ActiveRecord
         children.first
       end
     end
-    
+
     def expand_filter_for_column(key, column, value, relation_trail)
-      attribute = table.arel_attribute(column.name)
+      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)
@@ -164,19 +209,19 @@ module ActiveRecord
       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(column.array ? Array(value) : value)
+        attribute.contains(Arel::Nodes::Casted.new(column.array ? Array(value) : value, attribute))
       when :contained_by
-        attribute.contained_by(column.array ? Array(value) : value)
+        attribute.contained_by(Arel::Nodes::Casted.new(column.array ? Array(value) : value, attribute))
       when :equal_to, :eq
         attribute.eq(value)
       when :excludes
-        attribute.excludes(Array(value))
+        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
@@ -197,7 +242,7 @@ module ActiveRecord
         # 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])
@@ -219,7 +264,7 @@ module ActiveRecord
       when :not_in
         attribute.not_in(value)
       when :overlaps
-        attribute.overlaps(value)
+        attribute.overlaps(Arel::Nodes::Casted.new(column.array ? Array(value) : value, attribute))
       when :not_overlaps
         attribute.not_overlaps(value)
       when :ts_match
@@ -244,60 +289,61 @@ module ActiveRecord
         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_attribute(counter_cache_column_name.to_sym).gt(0)
+            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_attribute(counter_cache_column_name.to_sym).eq(0)
+            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_attribute(relation.foreign_key).not_eq(nil)
+          return table.arel_table[relation.foreign_key].not_eq(nil)
         elsif value == false || value == 'false' || value.nil?
-          return table.arel_attribute(relation.foreign_key).eq(nil)
+          return table.arel_table[relation.foreign_key].eq(nil)
         end
       end
 
-      builder = self.class.new(TableMetadata.new(
-        relation.klass,
-        alias_tracker.aliased_table_for(
-          relation.table_name,
-          relation.alias_candidate(table.send(:arel_table).name),
-          relation.klass.type_caster
-        ),
-        relation
-      ))
-      builder.build_from_filter_hash(value, relation_trail + [relation.name], alias_tracker)
+      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]
-      STDOUT.puts [
-        relation.table_name,
-        relation.alias_candidate(table.send(:arel_table).name)
-        
-      ].inspect
       builder = self.class.new(TableMetadata.new(
         relation.klass,
-        alias_tracker.aliased_table_for(
-          relation.table_name,
-          relation.alias_candidate(table.send(:arel_table).name),
-          relation.klass.type_caster
-        ),
+        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)
@@ -321,7 +367,7 @@ module ActiveRecord
         else
           raise ArgumentError, "Unsupported argument type: #{filters.inspect} (#{filters.class})"
         end
-        
+
         WhereClause.new(parts)
       end
 
@@ -339,12 +385,12 @@ class ActiveRecord::Relation
       @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
@@ -357,33 +403,41 @@ class ActiveRecord::Relation
 
     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.each { |j| joins!(j) if j.present? }
+      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)
       arel = super
       my_alias_tracker = ActiveRecord::Associations::AliasTracker.create(connection, table.name, [])
       build_filters(arel, my_alias_tracker)
       arel
     end
-    
-    def build_filters(manager, aliases)
+
+    def build_filters(manager, alias_tracker)
       @filters.each do |filters|
         manager.where(filter_clause_factory.build(filters, alias_tracker).ast)
       end

data/lib/active_record/filter/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Filter
-    VERSION = '6.0.0.4'
+    VERSION = '6.1.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-filter
 version: !ruby/object:Gem::Version
-  version: 6.0.0.4
+  version: 6.1.0
 platform: ruby
 authors:
 - Jon Bracy
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-09-18 00:00:00.000000000 Z
+date: 2021-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 6.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 6.1.0
 - !ruby/object:Gem::Dependency
   name: arel-extensions
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0.5
+        version: 6.1.0.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0.5
+        version: 6.1.0.rc2
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 6.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 6.1.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -142,14 +142,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 6.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 6.1.0
 - !ruby/object:Gem::Dependency
   name: faker
   requirement: !ruby/object:Gem::Requirement
@@ -194,7 +194,7 @@ homepage: https://github.com/malomalo/activerecord-filter
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--main"
 - README.md
@@ -211,8 +211,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: A safe way to accept user parameters and query against your ActiveRecord
   Models