activerecord-filter 6.0.0.1 → 6.0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09bb100ef828af898f984d813b053e52af5c0264e1f5991eb62062d641dce71d'
-  data.tar.gz: 97fbdfccc6e9dff58be2d37cb4a17cc292c458c4d60610d5d5e31330d4c516d7
+  metadata.gz: 3f64c71b3f52eecc00c0e0ba35bc824466a756ec0781ee87fae30b2cde539a34
+  data.tar.gz: c4efd0dd23d922090881e9f07ce2e091551795b6e21975fa76a92d07b5101799
 SHA512:
-  metadata.gz: 6d13276e0475e34a6232804118693ffa8e103f5bc34fa781a5a31444da88f968e17c8a81dc37753539681968605c3cbd79f16ef88ded994cb8a7db577c0f2f4a
-  data.tar.gz: 772aff1eba3e010a77783ba6e3a40942b20bd4f5a7d4a7c218e31780ac211e9ec6a7fe4b9810b802277f801c9b00cd8434873096e5b62573a6f8f8d4b6789a86
+  metadata.gz: 432f672949da926119e4d06ffbcc105daaf06dddae7d2f08349b1c6b950f8002b3fb839caf191b41da2afaa0139028e135136640c7a9fbb2b0aa8224fe55dff2
+  data.tar.gz: 42503928c6ff4ef0cd83e56b6c7258b480d87236da66db61fa79603da351788a7b201eb0d63f2a14bebb35b9377ee841adc55e513130e2885f61f1fd27a15782

data/README.md

@@ -56,8 +56,24 @@ Property.filter(:tags => {overlaps: ['Skyscraper', 'Brick']}).to_sql
 
 Property.filter(:tags => {contains: ['Skyscraper', 'Brick']}).to_sql
 # => "...WHERE accounts.tags @> '{"Skyscraper", "Brick"}')..."
+```
+
+And JSON columns:
+
+```ruby
+Property.filter(metadata: { eq: { key: 'value' } }).to_sql
+# => "...WHERE "properties"."metadata" = '{\"key\":\"value\"}'..."
 
+Property.filter(metadata: { contains: { key: 'value' } }).to_sql
+# => "...WHERE "properties"."metadata" @> '{\"key\":\"value\"}'..."
+
+Property.filter(metadata: { has_key: 'key' }).to_sql
+# => "...WHERE "properties"."metadata" ? 'key'..."
+
+Property.filter("metadata.key": { eq: 'value' }).to_sql
+# => "...WHERE "properties"."metadata" #> '{key}' = 'value'..."
 ```
+
 It can also sort on relations:
 
 ```ruby

data/lib/active_record/filter.rb

@@ -77,13 +77,13 @@ module ActiveRecord
       relations
     end
     
-    def build_from_filter_hash(attributes, join_dependency)
+    def build_from_filter_hash(attributes)
       if attributes.is_a?(Array)
-        node = build_from_filter_hash(attributes.shift, join_dependency)
+        node = build_from_filter_hash(attributes.shift)
 
         n = attributes.shift(2)
         while !n.empty?
-          n[1] = build_from_filter_hash(n[1], join_dependency)
+          n[1] = build_from_filter_hash(n[1])
           if n[0] == 'AND'
             if node.is_a?(Arel::Nodes::And)
               node.children.push(n[1])
@@ -100,26 +100,26 @@ module ActiveRecord
         
         node
       elsif attributes.is_a?(Hash)
-        expand_from_filter_hash(attributes, join_dependency)
+        expand_from_filter_hash(attributes)
       else
-        expand_from_filter_hash({id: attributes}, join_dependency)
+        expand_from_filter_hash({id: attributes})
       end
     end
     
-    def expand_from_filter_hash(attributes, join_dependency)
+    def expand_from_filter_hash(attributes)
       klass = table.send(:klass)
       
       children = attributes.flat_map do |key, value|
         if custom_filter = klass.filters[key]
-          self.instance_exec(klass, table, key, value, join_dependency, &custom_filter[:block])
+          self.instance_exec(klass, table, key, value, &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)
         elsif relation = klass.reflect_on_association(key)
-          expand_filter_for_relationship(relation, value, join_dependency)
+          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}, join_dependency)
+          expand_filter_for_relationship(relation, {id: value})
         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, join_dependency)
+          expand_filter_for_join_table(relation, value)
         else
           raise ActiveRecord::UnkownFilterError.new("Unkown filter \"#{key}\" for #{klass}.")
         end
@@ -133,17 +133,21 @@ module ActiveRecord
       end
     end
     
-    def convert_filter_value(column, value)
-      caster = table.send(:klass).attribute_types[column.name]
-      if value.is_a?(Array) && !column.array
-        value.map {|v| caster.cast(v) }
+    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
-        caster.cast(value)
+        table.send(:arel_table)[column.name]
       end
-    end
-    
-    def expand_filter_for_column(key, column, value)
-      attribute = table.arel_attribute(column.name)
+
       if column.type == :json || column.type == :jsonb
         names = key.to_s.split('.')
         names.shift
@@ -162,9 +166,9 @@ module ActiveRecord
       elsif value == false || value == 'false'
         column.type == :boolean ? attribute.eq(false) : attribute.eq(nil)
       elsif value.is_a?(Array) && !column.array
-        attribute.in(convert_filter_value(column, value))
+        attribute.in(value)
       elsif column.type != :json && column.type != :jsonb
-        converted_value = convert_filter_value(column, column.array ? Array(value) : value)
+        converted_value = column.array ? Array(value) : value
         attribute.eq(converted_value)
       else
         raise ActiveRecord::UnkownFilterError.new("Unkown type for #{column}. (type #{value.class})")
@@ -175,17 +179,17 @@ module ActiveRecord
     def expand_filter_for_arel_attribute(column, attribute, key, value)
       case key.to_sym
       when :contains
-        attribute.contains(column.array ? convert_filter_value(column, Array(value)) : convert_filter_value(column, value))
+        attribute.contains(column.array ? Array(value) : value)
       when :contained_by
-        attribute.contained_by(column.array ? convert_filter_value(column, Array(value)) : convert_filter_value(column, value))
+        attribute.contained_by(column.array ? Array(value) : value)
       when :equal_to, :eq
-        attribute.eq(convert_filter_value(column, value))
+        attribute.eq(value)
       when :excludes
-        attribute.excludes(convert_filter_value(column, Array(value)))
+        attribute.excludes(Array(value))
       when :greater_than, :gt
-        attribute.gt(convert_filter_value(column, value))
+        attribute.gt(value)
       when :greater_than_or_equal_to, :gteq, :gte
-        attribute.gteq(convert_filter_value(column, value))
+        attribute.gteq(value)
       when :has_key
         attribute.has_key(value)
       when :has_keys
@@ -193,7 +197,7 @@ module ActiveRecord
       when :has_any_key
         attribute.has_any_key(*Array(value).map { |x| Arel::Nodes.build_quoted(x) })
       when :in
-        attribute.in(convert_filter_value(column, value))
+        attribute.in(value)
       when :intersects
         # geometry_value = if value.is_a?(Hash) # GeoJSON
         #   Arel::Nodes::NamedFunction.new('ST_GeomFromGeoJSON', [JSON.generate(value)])
@@ -214,24 +218,24 @@ module ActiveRecord
 
         Arel::Nodes::NamedFunction.new('ST_Intersects', [attribute, geometry_value])
       when :less_than, :lt
-        attribute.lt(convert_filter_value(column, value))
+        attribute.lt(value)
       when :less_than_or_equal_to, :lteq, :lte
-        attribute.lteq(convert_filter_value(column, value))
+        attribute.lteq(value)
       when :like, :ilike
-        attribute.matches(convert_filter_value(column, value))
+        attribute.matches(value)
       when :not, :not_equal, :neq
-        attribute.not_eq(convert_filter_value(column, value))
+        attribute.not_eq(value)
       when :not_in
-        attribute.not_in(convert_filter_value(column, value))
+        attribute.not_in(value)
       when :overlaps
-        attribute.overlaps(convert_filter_value(column, value))
+        attribute.overlaps(value)
       when :not_overlaps
-        attribute.not_overlaps(convert_filter_value(column, value))
+        attribute.not_overlaps(value)
       when :ts_match
         if value.is_a?(Array)
-          attribute.ts_query(*convert_filter_value(column, value))
+          attribute.ts_query(*value)
         else
-          attribute.ts_query(convert_filter_value(column, value))
+          attribute.ts_query(value)
         end
       when :within
         if value.is_a?(String)
@@ -250,7 +254,7 @@ module ActiveRecord
       end
     end
     
-    def expand_filter_for_relationship(relation, value, join_dependency)
+    def expand_filter_for_relationship(relation, value)
       case relation.macro
       when :has_many
         if value == true || value == 'true'
@@ -276,27 +280,15 @@ module ActiveRecord
         end
       end
       
-      
-      
       builder = associated_predicate_builder(relation.name.to_sym)
-      
-      if join_dependency
-        join_dependency = join_dependency.children.find { |c| c.reflection.name == relation.name }
-        builder.send(:table).instance_variable_set(:@arel_table, join_dependency.tables.first)
-      end
-      
-      builder.build_from_filter_hash(value, join_dependency)
+      builder.build_from_filter_hash(value)
     end
     
-    def expand_filter_for_join_table(relation, value, join_dependency)
+    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)
-      if join_dependency
-        join_dependency = join_dependency.children.find { |c| c.reflection.name == relation.name }
-        builder.send(:table).instance_variable_set(:@arel_table, join_dependency.tables.first)
-      end
-      builder.build_from_filter_hash(value, join_dependency)
+      builder.build_from_filter_hash(value)
     end
 
   end
@@ -311,14 +303,14 @@ module ActiveRecord
         @predicate_builder = predicate_builder
       end
 
-      def build(filters, join_dependency)
+      def build(filters)
         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, join_dependency)]
+          parts = [predicate_builder.build_from_filter_hash(filters)]
         else
           raise ArgumentError, "Unsupported argument type: #{filters.inspect} (#{filters.class})"
         end
@@ -338,7 +330,6 @@ class ActiveRecord::Relation
 
     def initialize(klass, table: klass.arel_table, predicate_builder: klass.predicate_builder, values: {})
       @filters = []
-      @join_dependency = nil
       super
     end
     
@@ -369,9 +360,7 @@ class ActiveRecord::Relation
     
     def filter!(filters)
       js = ActiveRecord::PredicateBuilder.filter_joins(klass, filters)
-      js.each do |j|
-        joins!(j) if j.present?
-      end
+      js.each { |j| joins!(j) if j.present? }
       @filters << filters
       self
     end
@@ -385,45 +374,10 @@ class ActiveRecord::Relation
       build_filters(arel)
       arel
     end
-
-    def build_join_query(manager, buckets, join_type, aliases)
-      buckets.default = []
-
-      association_joins         = buckets[:association_join]
-      stashed_joins             = buckets[:stashed_join]
-      join_nodes                = buckets[:join_node].uniq
-      string_joins              = buckets[:string_join].map(&:strip).uniq
-
-      join_list = join_nodes + convert_join_strings_to_ast(string_joins)
-      alias_tracker = alias_tracker(join_list, aliases)
-
-      join_dependency = ActiveRecord::Associations::JoinDependency.new(
-        klass, table, association_joins
-      )
-      
-      joins = join_dependency.join_constraints(stashed_joins, join_type, alias_tracker)
-      joins.each { |join| manager.from(join) }
-      # join_infos = join_dependency.join_constraints stashed_association_joins, join_type
-
-      # join_infos.each do |info|
-      #   info.joins.each { |join| manager.from(join) }
-      #   manager.bind_values.concat info.binds
-      # end
-
-      # manager.join_sources.concat(join_list)
-
-      manager.join_sources.concat(join_list)
-
-      if klass.connection.class.name != 'ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter'
-        @join_dependency = join_dependency
-      end
-      
-      alias_tracker.aliases
-    end
     
     def build_filters(manager)
       @filters.each do |filters|
-        manager.where(filter_clause_factory.build(filters, @join_dependency&.send(:join_root)).ast)
+        manager.where(filter_clause_factory.build(filters).ast)
       end
     end
 

data/lib/active_record/filter/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Filter
-    VERSION = '6.0.0.1'
+    VERSION = '6.0.0.2'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-filter
 version: !ruby/object:Gem::Version
-  version: 6.0.0.1
+  version: 6.0.0.2
 platform: ruby
 authors:
 - Jon Bracy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-11 00:00:00.000000000 Z
+date: 2019-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0.rc1
+        version: 6.0.0.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0.rc1
+        version: 6.0.0.rc2
 - !ruby/object:Gem::Dependency
   name: arel-extensions
   requirement: !ruby/object:Gem::Requirement
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0.rc1
+        version: 6.0.0.rc2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0.rc1
+        version: 6.0.0.rc2
 - !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.rc1
+        version: 6.0.0.rc2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0.rc1
+        version: 6.0.0.rc2
 - !ruby/object:Gem::Dependency
   name: faker
   requirement: !ruby/object:Gem::Requirement