activerecord-filter 6.0.0.3 → 6.1.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d5c6eebcaf0ce67328ce60b589d3db745379c3e1f9e167a72b6d529c12dd242
-  data.tar.gz: 12e0734ef2c953958cdbef7725e71273d7f6173abeb9e2155c81eb5096e93f87
+  metadata.gz: 0a22c93c0080f2e92aaf6b427e89eb6ac73210bc40304941e7e17373b70c987c
+  data.tar.gz: 7180d339c3fed586489cd65a4de59e34d5edaf7860584c12683f144134844470
 SHA512:
-  metadata.gz: 4faa92743587408661292c04b9100929519354d194a583a0ba9fadb51e208d895ee0d79c2d188563479ce8dc51892d6678f039644ae41cccdafc53eae28c226d
-  data.tar.gz: 15acb3d28304602f7c24b2ac966f37cd809a31bd36ba4d0fed0f2a8c8d3cdfebe16eb2ea536309d05a458146b31cde62b8fd9e6c6ee1ff7b82e924c44351ff41
+  metadata.gz: 4950a8448ea79f7a1ea671889e1353b28657722b3eab8ba202d6c80b02f0d16a2ee9ca4c7893fd24b9b3a436e7a95c7c7a87568345ae6b565a22e8791cec5b51
+  data.tar.gz: a061d579c68764f56729d2afba8a979f67804d285b6e1ac895e6ce20722d382e4a636b583b9598607f57340535baae2b369b4d4fcb67e28e8b0599de46c5adbd

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,17 +111,17 @@ module ActiveRecord
           end
         end
       end
-      
+
       relations
     end
-    
-    def build_from_filter_hash(attributes)
+
+    def build_from_filter_hash(attributes, relation_trail, alias_tracker)
       if attributes.is_a?(Array)
-        node = build_from_filter_hash(attributes.shift)
+        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])
+          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])
@@ -92,39 +130,46 @@ 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)
+        expand_from_filter_hash(attributes, relation_trail, alias_tracker)
       else
-        expand_from_filter_hash({id: attributes})
+        expand_from_filter_hash({id: attributes}, relation_trail, alias_tracker)
       end
     end
-    
-    def expand_from_filter_hash(attributes)
+
+    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, &custom_filter[:block])
+          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)
+          expand_filter_for_column(key, column, value, relation_trail)
         elsif relation = klass.reflect_on_association(key)
-          expand_filter_for_relationship(relation, value)
-        elsif key.to_s.ends_with?('_ids') && relation = klass.reflect_on_association(key.to_s.gsub(/_ids$/, 's'))
-          expand_filter_for_relationship(relation, {id: value})
+          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)
+          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)
@@ -132,20 +177,11 @@ module ActiveRecord
         children.first
       end
     end
-    
-    def expand_filter_for_column(key, column, value)
-      # Not sure why
-      # activerecord/lib/active_record/table_metadata.rb#arel_attribute
-      # doesn't work here, something's not working with a
-      # Arel::Nodes::TableAlias, would like to go back to it one day
-      attribute = if klass = table.send(:klass)
-        if Arel::Nodes::TableAlias === table.send(:arel_table)
-          klass.arel_attribute(column.name, table.send(:arel_table).left)
-        else
-          klass.arel_attribute(column.name, table.send(:arel_table))
-        end
-      else
-        table.send(:arel_table)[column.name]
+
+    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
@@ -153,7 +189,7 @@ module ActiveRecord
         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)
@@ -173,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
@@ -206,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])
@@ -228,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
@@ -250,45 +286,67 @@ module ActiveRecord
           raise "Not Supported value for within: #{value.inspect}"
         end
       else
-        raise "Not Supported: #{key.to_sym}"
+        raise "Not Supported: #{key.to_sym} on column \"#{column.name}\" of type #{column.type}"
       end
     end
-    
-    def expand_filter_for_relationship(relation, value)
+
+    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 = associated_predicate_builder(relation.name.to_sym)
-      builder.build_from_filter_hash(value)
+
+      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 = relation.active_record._reflections[relation.active_record._reflections[relation.name.to_s].send(:delegate_reflection).options[:through].to_s]
 
-      builder = associated_predicate_builder(relation.name.to_sym)
-      builder.build_from_filter_hash(value)
+
+    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
@@ -303,18 +361,13 @@ module ActiveRecord
         @predicate_builder = predicate_builder
       end
 
-      def build(filters)
+      def build(filters, alias_tracker)
         if filters.is_a?(Hash) || filters.is_a?(Array)
-          # attributes = predicate_builder.resolve_column_aliases(filters)
-          # attributes = klass.send(:expand_hash_conditions_for_aggregates, attributes)
-          # attributes.stringify_keys!
-          #
-          # attributes, binds = predicate_builder.create_binds(attributes)
-          parts = [predicate_builder.build_from_filter_hash(filters)]
+          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
 
@@ -332,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
@@ -350,34 +403,43 @@ 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
-      build_filters(arel)
+      my_alias_tracker = ActiveRecord::Associations::AliasTracker.create(connection, table.name, [])
+      build_filters(arel, my_alias_tracker)
       arel
     end
-    
-    def build_filters(manager)
+
+    def build_filters(manager, alias_tracker)
       @filters.each do |filters|
-        manager.where(filter_clause_factory.build(filters).ast)
+        manager.where(filter_clause_factory.build(filters, alias_tracker).ast)
       end
     end
 

data/lib/active_record/filter/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Filter
-    VERSION = '6.0.0.3'
+    VERSION = '6.1.0.rc1'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-filter
 version: !ruby/object:Gem::Version
-  version: 6.0.0.3
+  version: 6.1.0.rc1
 platform: ruby
 authors:
 - Jon Bracy
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-08-16 00:00:00.000000000 Z
+date: 2020-12-28 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
+        version: 6.1.0.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        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
@@ -207,12 +207,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: A safe way to accept user parameters and query against your ActiveRecord
   Models