activerecord-filter 5.0.0.6 → 5.0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ebd77f99aa6b3919c780144570afccb9020e970
-  data.tar.gz: 9bb379f8e4148ca004c7b5823efcb56b95b2c952
+  metadata.gz: a17e5665d5d8476c382e7dca7ab1bcbb600da917
+  data.tar.gz: ac54d3aba9f451bd468a4e55943423307fc1e5cc
 SHA512:
-  metadata.gz: cafc7b16939a790e9a134e0a7266f14424ab1e9f5d18543c7edf1f7437254592b48c68bd0f85ccb87aee55eb03ad27ea4b24f252223b6ee617747beed216430d
-  data.tar.gz: f128d2aee5a42cdbb6c4f6dea4f772aaf30f7bfae9f407b0d60a950bf56fdb347389049e2adc7858734d919b0fd366bc00b2ee2e2d354c9c92f080867564940a
+  metadata.gz: 4c5a83ec75a1bd656fcdf8c4a4505f3013cf155e03b0b3d638c0807ecc520a656b362ba9c8f75fd135ece248e030b984a95c24784b7947fab46b8f78b68688df
+  data.tar.gz: 7ec0169479bfb8edf3b9767f4cd5daed9ce607ed0b3472a15cfceb2f6a59654654cb1a822a7502c0ecbcbac04c65854c8473b8437f27eaebe0be79d39dbc19f6

data/lib/active_record/filter.rb

@@ -7,321 +7,405 @@ end
 
 module ActiveRecord::Filter
 
+  delegate :filter, :filter_for, to: :all
+  
   def inherited(subclass)
     super
     subclass.instance_variable_set('@filters', HashWithIndifferentAccess.new)
   end
   
-  def filter_on(name, lambda)
-    @filters[name] = lambda
+  def filters
+    @filters
   end
   
-  def filter(filters, options={})
-    resource = all
-    return resource unless filters
-
-    case filters
-    when Hash, ActionController::Parameters
-      filters.each do |key, value|
-        if @filters[key]
-          #TODO add test for this... not sure how rails does this lambda call,
-          # do they run it in a context for merge?
-          resource = resource.merge( @filters[key].call(value) )
-        else
-          resource = resource.filter_for(key, value, options)
-        end
-      end
-    when Integer, Array
-      resource = resource.filter_for(:id, filters, options)
-    end
-
-    resource
+  def filter_on(name, dependent_joins=nil, &block)
+    @filters[name.to_s] = {
+      joins: dependent_joins,
+      block: block
+    }
   end
+  
+end
 
-  def filter_for(key, value, options={})
-    column = columns_hash[key.to_s]
+module ActiveRecord
+  class PredicateBuilder # :nodoc:
 
-    if column && column.array
-      all.filter_for_array(key, value, options)
-    elsif column
-      all.send("filter_for_#{column.type}", key, value, options)
-    elsif relation = reflect_on_association(key)
-      self.send("filter_for_#{relation.macro}", relation, value)
-    else
-      raise ActiveRecord::UnkownFilterError.new("Unkown filter \"#{key}\" for #{self}.")
+    def self.filter_joins(klass, filters)
+      build_filter_joins(klass, filters).inject(&:+)
     end
-  end
-
-  {
-    filter_for_geometry: :itself,
-    filter_for_datetime: :to_datetime,
-    filter_for_integer: :to_i,
-    filter_for_fixnum: :to_i,
-    filter_for_text: :itself,
-    filter_for_boolean: :itself,
-    filter_for_string: :itself,
-    filter_for_uuid: :itself,
-    filter_for_decimal: :to_f,
-    filter_for_float: :to_f
-  }.each_pair do |method_name, send_method|
-    define_method(method_name) do |column, value, options={}|
-      table = options[:table_alias] ? arel_table.alias(options[:table_alias]) : arel_table
-
-      if value.is_a?(Hash) || value.class.name == "ActionController::Parameters".freeze 
-        resource = all
-        value.each_pair do |key, value|
-          converted_value = if value.is_a?(Array)
-            value.map { |x| x.try(:send, send_method) }
-          else
-            value.try(:send, send_method)
+    
+    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?(Hash)
+                  relations << j
+                else
+                  custom << j
+                end
+              end
+            elsif js
+              relations << js
+            end
+          elsif reflection = klass._reflections[key.to_s]
+            if value.is_a?(Hash)
+              relations << {key => build_filter_joins(reflection.klass, value)}
+            elsif value != true && value != false && value != 'true' && value != 'false' && !value.nil?
+              relations << key
+            end
+          elsif key.to_s.ends_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].delegate_reflection.options[:through].to_s]
+            relations << {reflection.name => build_filter_joins(reflection.klass, value)}
           end
+        end
+      end
+      [relations, custom]
+    end
+    
+    def build_from_filter_hash(attributes, join_dependency)
+      if attributes.is_a?(Array)
+        node = build_from_filter_hash(attributes.shift, join_dependency)
 
-          resource = case key.to_sym
-          when :equal_to, :eq
-            resource.where(table[column].eq(converted_value))
-          when :greater_than, :gt
-            resource.where(table[column].gt(converted_value))
-          when :less_than, :lt
-            resource.where(table[column].lt(converted_value))
-          when :greater_than_or_equal_to, :gteq, :gte
-            resource.where(table[column].gteq(converted_value))
-          when :less_than_or_equal_to, :lteq, :lte
-            resource.where(table[column].lteq(converted_value))
-          when :in
-            resource.where(table[column].in(converted_value))
-          when :not
-            resource.where(table[column].not_eq(converted_value))
-          when :not_in
-            resource.where(table[column].not_in(converted_value))
-          when :like, :ilike
-            resource.where(table[column].matches(converted_value))
-          when :ts_match
-            if converted_value.is_a?(Array)
-              resource.where(table[column].ts_query(*converted_value))
-            else
-              resource.where(table[column].ts_query(converted_value))
-            end
-          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) || value.class.name == "ActionController::Parameters".freeze
-              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" || value[0,4] =~ /[0-9a-fA-F]{4}/
-              Arel::Nodes::NamedFunction.new('ST_SetSRID', [Arel::Nodes::NamedFunction.new('ST_GeomFromEWKB', [Arel::Nodes.build_quoted(value)]), 4326])
+        n = attributes.shift(2)
+        while !n.empty?
+          n[1] = build_from_filter_hash(n[1], join_dependency)
+          if n[0] == 'AND'
+            if node.is_a?(Arel::Nodes::And)
+              node.children.push(n[1])
             else
-              Arel::Nodes::NamedFunction.new('ST_SetSRID', [Arel::Nodes::NamedFunction.new('ST_GeomFromText', [Arel::Nodes.build_quoted(value)]), 4326])
+              node = node.and(n[1])
             end
-
-            resource.where(Arel::Nodes::NamedFunction.new('ST_Intersects', [table[column], geometry_value]))
+          elsif n[0] == 'OR'
+            node = Arel::Nodes::Grouping.new(node).or(Arel::Nodes::Grouping.new(n[1]))
           else
-            raise "Not Supported: #{key.to_sym}"
+            raise 'lll'
           end
+          n = attributes.shift(2)
         end
-        resource
-      elsif value.is_a?(Array)
-        where(table[column].in(value.map { |x| x.send(send_method) }))
-      elsif value == true || value == 'true'
-        case method_name # columns_hash[column.to_s].try(:type)
-        when :filter_for_boolean then where(table[column].eq(value.try(:send, send_method)))
-        else where(table[column].not_eq(nil))
+        
+        node
+      elsif attributes.is_a?(Hash)
+        expand_from_filter_hash(attributes, join_dependency)
+      else
+        expand_from_filter_hash({id: attributes}, join_dependency)
+      end
+    end
+    
+    def expand_from_filter_hash(attributes, join_dependency)
+      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])
+        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)
+        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)
+        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)
+        else
+          raise ActiveRecord::UnkownFilterError.new("Unkown filter \"#{key}\" for #{klass}.")
         end
-      elsif value == false || value == 'false'
-        case method_name # columns_hash[column.to_s].try(:type)
-        when :filter_for_boolean then where(table[column].eq(value.try(:send, send_method)))
-        else where(table[column].eq(nil))
+      end
+      
+      children.compact!
+      if children.size > 1
+        Arel::Nodes::And.new(children)
+      else
+        children.first
+      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) }
+      else
+        caster.cast(value)
+      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
+        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
-        where(table[column].eq(nil))
-      # when ''
-      #   # TODO support nil. Currently rails params encode nil as empty strings,
-      #   # and we can't tell which is desired, so do both
-      #   where(table[column].eq(value).or(table[column].eq(nil)))
-      elsif value.respond_to?(send_method)
-        where(table[column].eq(value.try(:send, send_method)))
+        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(convert_filter_value(column, value))
+      elsif column.type != :json && column.type != :jsonb
+        converted_value = convert_filter_value(column, column.array ? Array(value) : value)
+        attribute.eq(converted_value)
       else
         raise ActiveRecord::UnkownFilterError.new("Unkown type for #{column}. (type #{value.class})")
       end
+      
     end
-  end
     
-  def filter_for_jsonb(column, value, options = {})
-    table = options[:table_alias] ? arel_table.alias(options[:table_alias]) : arel_table
-    column = table[column]
-  
-    drill_for_json(column, value, all, 'jsonb')
-  end
-  
-  def filter_for_json(column, value, options = {})
-    table = options[:table_alias] ? arel_table.alias(options[:table_alias]) : arel_table
-    column = table[column]
-  
-    drill_for_json(column, value, all, 'json')
-  end
-  
-  def drill_for_json(column, drill, resource, cast)
-    drill.each do |key, value|
-      if value.is_a?(Hash) || value.class.name == "ActionController::Parameters".freeze
-        resource = drill_for_json(column.key(key), value, resource, cast)
-      else
-        value = Arel::Attributes::Cast.new(Arel::Nodes::Quoted.new(value.to_s), cast)
-        
-        resource = case key.to_sym
-        when :equal, :eq
-          resource.where(column.eq(value))
-        when :greater_than, :gt
-          resource.where(column.gt(value))
-        when :less_than, :lt
-          resource.where(column.lt(value))
-        when :greater_than_or_equal_to, :gteq, :gte
-          resource.where(column.gteq(value))
-        when :less_than_or_equal_to, :lteq, :lte
-          resource.where(column.lteq(value))
-        when :not
-          resource.where(column.not_eq(value))
-        when :has_key
-          resource.where(column.has_key(value))
-        when :not_in
-          resource.where(column.not_in(value))
+    def expand_filter_for_arel_attribute(column, attribute, key, value)
+      case key.to_sym
+      when :contains
+        attribute.contains(column.array ? Array(convert_filter_value(column, value)) : convert_filter_value(column, value))
+      when :contained_by
+        attribute.contained_by(column.array ? Array(convert_filter_value(column, value)) : convert_filter_value(column, value))
+      when :equal_to, :eq
+        attribute.eq(convert_filter_value(column, value))
+      when :excludes
+        attribute.excludes(convert_filter_value(column, Array(value)))
+      when :greater_than, :gt
+        attribute.gt(convert_filter_value(column, value))
+      when :greater_than_or_equal_to, :gteq, :gte
+        attribute.gteq(convert_filter_value(column, value))
+      when :has_key
+        attribute.has_key(convert_filter_value(column, value))
+      when :in
+        attribute.in(convert_filter_value(column, 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 subvalue.is_a?(Hash)
+          Arel::Nodes::NamedFunction.new('ST_SetSRID', [Arel::Nodes::NamedFunction.new('ST_GeomFromGeoJSON', [Arel::Nodes.build_quoted(JSON.generate(subvalue))]), 4326])
+        elsif subvalue[0,1] == "\x00" || subvalue[0,1] == "\x01" || subvalue[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
-          raise 'Not supported'
+          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(convert_filter_value(column, value))
+      when :less_than_or_equal_to, :lteq, :lte
+        attribute.lteq(convert_filter_value(column, value))
+      when :like, :ilike
+        attribute.matches(convert_filter_value(column, value))
+      when :not, :not_equal, :neq
+        attribute.not_eq(convert_filter_value(column, value))
+      when :not_in
+        attribute.not_in(convert_filter_value(column, value))
+      when :overlaps
+        attribute.overlaps(convert_filter_value(column, value))
+      when :ts_match
+        if value.is_a?(Array)
+          attribute.ts_query(*convert_filter_value(column, value))
+        else
+          attribute.ts_query(convert_filter_value(column, value))
+        end
+      when :within
+        attribute.within(value)
+      else
+        raise "Not Supported: #{key.to_sym}"
       end
     end
-    resource
+    
+    def expand_filter_for_relationship(relation, value, join_dependency)
+      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)
+          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)
+          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)
+        elsif value == false || value == 'false' || value.nil?
+          return table.arel_attribute(relation.foreign_key).eq(nil)
+        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.table.instance_variable_set(:@arel_table, join_dependency.tables.first)
+      end
+      
+      builder.build_from_filter_hash(value, join_dependency)
+    end
+    
+    def expand_filter_for_join_table(relation, value, join_dependency)
+      relation = relation.active_record._reflections[relation.active_record._reflections[relation.name.to_s].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.table.instance_variable_set(:@arel_table, join_dependency.tables.first)
+      end
+      builder.build_from_filter_hash(value, join_dependency)
+    end
+
   end
+end
 
-  def filter_for_array(column, value, options={})
-    table = options[:table_alias] ? arel_table.alias(options[:table_alias]) : arel_table
 
-    if value.is_a?(Hash) || value.class.name == "ActionController::Parameters".freeze
-      resource = all
-      value.each_pair do |key, value|
-        resource = case key.to_sym
-        when :contains
-          resource.where(table[column].contains(value))
-        when :overlaps
-          resource.where(table[column].overlaps(value))
-        when :excludes
-          resource.where.not(table[column].contains(value))
-        # when :not_overlaps
-        #   resource.where.not(Arel::Nodes::Overlaps.new(table[column], Arel::Attributes::Array.new(Array(value))))
+module ActiveRecord
+  class Relation
+    class FilterClauseFactory # :nodoc:
+      def initialize(klass, predicate_builder)
+        @klass = klass
+        @predicate_builder = predicate_builder
+      end
+
+      def build(filters, join_dependency)
+        binds = []
+
+        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)]
         else
-          raise "Not Supported: #{key.to_sym}"
+          raise ArgumentError, "Unsupported argument type: #{filters.inspect} (#{filters.class})"
         end
+        
+        WhereClause.new(parts, binds)
       end
-      resource
-    else
-      where(table[column].contains(value))
+
+      protected
+
+      attr_reader :klass, :predicate_builder
     end
   end
+end
 
-  def filter_for_has_and_belongs_to_many(relation, value)
-    resource = all
-  
-    options = {}
-    if connection.class.name == 'ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter'
-      options[:table_alias] = relation.name
-    elsif resource.klass == relation.klass
-      options[:table_alias] = "#{relation.name}_#{relation.klass.table_name}"
+class ActiveRecord::Relation
+  module Filter
+
+    def initialize(klass, table, predicate_builder, values = {})
+      @filters = []
+      super
     end
     
-    if value.is_a?(Hash) || value.class.name == "ActionController::Parameters".freeze
-      resource = resource.joins(relation.name) #if !resource.references?(relation.name)
-      resource = resource.merge(relation.klass.filter(value, options))
-    elsif value.is_a?(Integer)
-      resource = resource.joins(relation.name) #if !resource.references?(relation.name)
-      resource = resource.merge(relation.klass.filter(value, options))
-    elsif value.is_a?(Array)
-      resource = resource.joins(relation.name) #if !resource.references?(relation.name)
-      resource = resource.merge(relation.klass.filter(value, options))
-    else
-      raise 'Not supported'
+    def initialize_copy(other)
+      @filters = @filters.deep_dup
+      super
     end
-
-    resource
-  end
-
-  def filter_for_has_many(relation, value)
-    resource = all
-
-    if value.is_a?(Hash) || value.class.name == "ActionController::Parameters".freeze 
-      if relation.options[:through] && !relation.options[:source_type]
-        resource = resource.joins(relation.options[:through] => relation.source_reflection_name)
-      else
-        resource = resource.joins(relation.name) # if !resource.joined?(relation.name)
-      end
-      resource = resource.merge(relation.klass.filter(value))
-    elsif value.is_a?(Array) || value.is_a?(Integer)
-      resource = filter_for_has_many(relation, {:id => value})
-    elsif value == true || value == 'true'
-      counter_cache_column_name = relation.counter_cache_column || "#{relation.plural_name}_count"
-      if resource.column_names.include?(counter_cache_column_name)
-        resource = resource.where(resource.arel_table[counter_cache_column_name.to_sym].gt(0))
-      else
-        raise 'Not supported'
+    
+    def filter(filters)
+      if filters.is_a?(ActionController::Parameters)
+        filters = filters.to_unsafe_h 
+      elsif filters.is_a?(Array)
+        filters.map! do |f|
+          f.is_a?(ActionController::Parameters) ? f.to_unsafe_h : f
+        end
       end
-    elsif value == false || value == 'false'
-      # TODO if the has_many relationship has counter_cache true can just use counter_cache_column method
-      counter_cache_column_name = relation.counter_cache_column || "#{relation.plural_name}_count"
-      if resource.column_names.include?(counter_cache_column_name)
-        resource = resource.where(resource.arel_table[counter_cache_column_name.to_sym].eq(0))
+      
+      if filters.nil? || filters.empty?
+        self
       else
-        raise 'Not supported'
+        spawn.filter!(filters)
       end
-    else
-      raise 'Not supported'
     end
-
-    resource
-  end
-  alias_method :filter_for_has_one, :filter_for_has_many
-
-  def filter_for_belongs_to(relation, value)
-    resource = all
     
-    options = {}
-    if connection.class.name == 'ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter'
-      options[:table_alias] = relation.name
+    def filter!(filters)
+      joins!(ActiveRecord::PredicateBuilder.filter_joins(klass, filters))
+      @filters << filters
+      self
+    end
+    
+    def filter_clause_factory
+      @filter_clause_factory ||= FilterClauseFactory.new(klass, predicate_builder)
+    end
+    
+    def build_arel
+      arel = super
+      build_filters(arel)
+      arel
     end
 
-    if value.is_a?(Array) || value.is_a?(Integer) || value.is_a?(NilClass)
-      resource = resource.where(:"#{relation.foreign_key}" => value)
-    elsif value == true || value == 'true'
-      resource = resource.where(resource.arel_table[:"#{relation.foreign_key}"].not_eq(nil))
-    elsif value == false || value == 'false'
-      resource = resource.where(resource.arel_table[:"#{relation.foreign_key}"].eq(nil))
-    elsif value.is_a?(Hash) || value.class.name == "ActionController::Parameters".freeze 
-      if relation.polymorphic?
-        raise 'no :as' if !value[:as]
-        v = value.dup
-        klass = v.delete(:as).classify.constantize
-        t1 = resource.arel_table
-        t2 = klass.arel_table
-        resource = resource.joins(t1.join(t2).on(
-          t2[:id].eq(t1["#{relation.name}_id"]).and(t1["#{relation.name}_type"].eq(klass.name))
-        ).join_sources.first)
-        resource = resource.merge(klass.filter(v, options))
-      else
-        resource = resource.joins(relation.name) # if !resource.references?(relation.name)
-        resource = resource.merge(relation.klass.filter(value, options))
+    def build_join_query(manager, buckets, join_type)
+      buckets.default = []
+
+      association_joins         = buckets[:association_join]
+      stashed_association_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(manager, string_joins)
+
+      join_dependency = ActiveRecord::Associations::JoinDependency.new(
+        @klass,
+        association_joins,
+        join_list
+      )
+      
+      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
-    else
-      if value.is_a?(String) && value =~ /\A\d+\Z/
-        resource = resource.where(:"#{relation.foreign_key}" => value.to_i)
-      else
-        raise 'Not supported'
+
+      manager.join_sources.concat(join_list)
+
+      if @klass.connection.class.name != 'ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter'
+        @join_dependency = join_dependency
       end
+      
+      manager
     end
-    resource
+    
+    def build_filters(manager)
+      @filters.each do |filters|
+        manager.where(filter_clause_factory.build(filters, @join_dependency&.join_root).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::Base.extend(ActiveRecord::Filter)
+ActiveRecord::Relation.prepend(ActiveRecord::Relation::Filter)
+ActiveRecord::Base.extend(ActiveRecord::Filter)

data/lib/active_record/filter/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Filter
-    VERSION = '5.0.0.6'
+    VERSION = '5.0.0.7'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-filter
 version: !ruby/object:Gem::Version
-  version: 5.0.0.6
+  version: 5.0.0.7
 platform: ruby
 authors:
 - Jon Bracy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-22 00:00:00.000000000 Z
+date: 2017-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -59,7 +59,7 @@ dependencies:
         version: '1.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.5.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -69,27 +69,21 @@ dependencies:
         version: '1.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.5.2
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.18'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.18.4
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.18'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.18.4
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -181,21 +175,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 5.0.0
 - !ruby/object:Gem::Dependency
-  name: factory_girl_rails
+  name: faker
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.7.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.7.0
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: faker
+  name: byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="