activerecord-filter 6.0.0.2 → 6.0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f64c71b3f52eecc00c0e0ba35bc824466a756ec0781ee87fae30b2cde539a34
-  data.tar.gz: c4efd0dd23d922090881e9f07ce2e091551795b6e21975fa76a92d07b5101799
+  metadata.gz: f04e35c30cfd4a96db7ba90fa1221a808121bacde16bdb70080e105274ae33d5
+  data.tar.gz: 5aabf016e7b0cec65b87b09f191fd0da5eb55b0f48cdf94cf4f1727b2c0867af
 SHA512:
-  metadata.gz: 432f672949da926119e4d06ffbcc105daaf06dddae7d2f08349b1c6b950f8002b3fb839caf191b41da2afaa0139028e135136640c7a9fbb2b0aa8224fe55dff2
-  data.tar.gz: 42503928c6ff4ef0cd83e56b6c7258b480d87236da66db61fa79603da351788a7b201eb0d63f2a14bebb35b9377ee841adc55e513130e2885f61f1fd27a15782
+  metadata.gz: af710f6e3adfd0b3dab81c34a9ae1b2578e9d6047f81c0fed362e30dd97a06ee110eb189eb670bd3e0875792196a36f574e35051585aef37ec0eaca4b4849b69
+  data.tar.gz: 869eab8791079a03a395f45ce510d31f05fb0399914ab6996cf8ef4ff4f3450da6a70941cd6068c24a193d4923ac12a539aea4620f16da292c9ae610b77a4419

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

@@ -7,23 +7,23 @@ 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 +33,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 +41,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,9 +59,28 @@ 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?
+                join_klass = value[:as].safe_constantize
+
+                right_table = join_klass.arel_table.alias("#{join_klass.table_name}_as_#{reflection.name}")
+                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))
+
+                left_table.join(right_table, Arel::Nodes::OuterJoin).on(on).join_sources
+              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
@@ -73,17 +92,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 +111,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)
+          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'))
-          expand_filter_for_relationship(relation, {id: value})
+          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 +158,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_attribute(column.name)
+      relation_trail.each do |rt|
+        attribute = Arel::Attributes::Relation.new(attribute, rt)
       end
 
       if column.type == :json || column.type == :jsonb
@@ -153,7 +170,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,9 +190,9 @@ 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
@@ -206,7 +223,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])
@@ -250,11 +267,11 @@ 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'
@@ -272,6 +289,7 @@ module ActiveRecord
             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)
@@ -279,16 +297,43 @@ module ActiveRecord
           return table.arel_attribute(relation.foreign_key).eq(nil)
         end
       end
-      
-      builder = associated_predicate_builder(relation.name.to_sym)
-      builder.build_from_filter_hash(value)
+
+      builder = if relation.polymorphic?
+        value = value.dup
+        klass = value.delete(:as).safe_constantize
+
+        self.class.new(TableMetadata.new(
+          klass,
+          Arel::Table.new("#{klass.table_name}_as_#{relation.name}", type_caster: klass.type_caster),
+          relation
+        ))
+      else
+        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
+        ))
+      end
+      builder.build_from_filter_hash(value, relation_trail + [relation.name], alias_tracker)
     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.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)
     end
 
   end
@@ -303,18 +348,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 +372,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 +390,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, aliases)
       @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.2'
+    VERSION = '6.0.0.7'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-filter
 version: !ruby/object:Gem::Version
-  version: 6.0.0.2
+  version: 6.0.0.7
 platform: ruby
 authors:
 - Jon Bracy
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-08-16 00:00:00.000000000 Z
+date: 2020-06-26 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.rc2
+        version: 6.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0.rc2
+        version: 6.0.0
 - !ruby/object:Gem::Dependency
   name: arel-extensions
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 6.0.0.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 6.0.0.8
 - !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.rc2
+        version: 6.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0.rc2
+        version: 6.0.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.rc2
+        version: 6.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0.rc2
+        version: 6.0.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.1.2
+signing_key:
 specification_version: 4
 summary: A safe way to accept user parameters and query against your ActiveRecord
   Models