activerecord-filter 5.0.0.beta1 → 5.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0ad1d6c4fde489d32e18e7a09fded1dc6f885733
-  data.tar.gz: 90ad1edbedee643cb629ceb2d6a65181f535fc7e
+  metadata.gz: 70a1e7037c74baea87037f1a7e6bf7dc7a581754
+  data.tar.gz: 09391e5064f066076c345556c521e08016deebf2
 SHA512:
-  metadata.gz: f5bda8ea3d34ad175787b16981fc9d9cd6048aa885e97b09e29714a1b3f1b20fe3d0786333e82f50eaeb9db901f48c13e8ea2ef4b0a16ea8cd5c83ba8fdaf5a7
-  data.tar.gz: f36d565425a76172ab801cc3c84540daebaf579241c92e84bb8154deb6a3e6dcc192c68d369f4d8a9e059935097c6ece203ea009a78a12f140a72cfb5dd5a735
+  metadata.gz: 0e84af9fa5d6fbb5ed2e16cfa473af1f117d67c9d108c7200cd0a6331773bb6e9e331fc7079f257958c148678ef0034e3353c08acebca85f8a0514cb38453703
+  data.tar.gz: d66507821b1dc004c496f34c5565899377869725474cba87a83d5481e995734811e77f03e672dad3501ebab7b9d2877e8d491b310f8d85d2cadf0a699722b9f5

data/lib/active_record/filter.rb

@@ -1,9 +1,323 @@
 require 'active_record'
+require 'arel/extensions'
 
-require File.expand_path(File.join(__FILE__, '../../../ext/arel/attributes/array'))
-require File.expand_path(File.join(__FILE__, '../../../ext/arel/nodes/contains'))
-require File.expand_path(File.join(__FILE__, '../../../ext/arel/nodes/overlaps'))
-require File.expand_path(File.join(__FILE__, '../../../ext/arel/visitors/postgresql'))
-require File.expand_path(File.join(__FILE__, '../../../ext/active_record/unkown_filter_error'))
-require File.expand_path(File.join(__FILE__, '../../../ext/active_record/base'))
-require File.expand_path(File.join(__FILE__, '../../../ext/active_record/query_methods'))
+class ActiveRecord::UnkownFilterError < NoMethodError
+  attr_reader :klass, :filter
+
+  def initialize(klass, filter)
+    @klass = klass
+    @filter = filter.to_s
+    super("unkown filter #{filter.inspect} for #{klass}.")
+  end
+end
+
+module ActiveRecord::Filter
+
+  def inherited(subclass)
+    super
+    subclass.instance_variable_set('@filters', HashWithIndifferentAccess.new)
+  end
+  
+  def filter_on(name, lambda)
+    @filters[name] = lambda
+  end
+  
+  def filter(filters, options={})
+    resource = all
+    return resource unless filters
+
+    if filters.is_a?(Hash) || filters.class.name == "ActionController::Parameters".freeze 
+      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
+    elsif filters.is_a?(Array) || filters.is_a?(Integer)
+      resource = resource.filter_for(:id, filters, options)
+    end
+
+    resource
+  end
+
+  def filter_for(key, value, options={})
+    column = columns_hash[key.to_s]
+    if column && column.array
+      all.filter_for_array(key, value, options)
+    elsif column
+      all.send("filter_for_#{column.type}", key, value, options)
+    else
+      if relation = reflect_on_association(key)
+        self.send("filter_for_#{relation.macro}", relation, value)
+      else
+        # Custome filter, try to guess based on value
+        # raise ActiveRecord::UnkownFilterError.new(self, key)
+        if value.is_a?(Hash) || value.class.name == "ActionController::Parameters".freeze 
+          all.send("filter_for_#{value.values.first.class.to_s.downcase}", key, value, options)
+        else
+          all.send("filter_for_#{value.class.to_s.downcase}", key, value, options)
+        end
+      end
+    end
+  end
+
+  {
+    filter_for_geometry: :itself,
+    filter_for_datetime: :to_datetime,
+    filter_for_integer: :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)
+          end
+
+          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).or(table[column].eq(nil)))
+          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])
+            else
+              Arel::Nodes::NamedFunction.new('ST_SetSRID', [Arel::Nodes::NamedFunction.new('ST_GeomFromText', [Arel::Nodes.build_quoted(value)]), 4326])
+            end
+
+            resource.where(Arel::Nodes::NamedFunction.new('ST_Intersects', [table[column], geometry_value]))
+          else
+            raise "Not Supported: #{key.to_sym}"
+          end
+        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))
+        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
+      # 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)))
+      else
+        where(table[column].eq(value.try(:send, send_method)))
+      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)
+  end
+  alias :filter_for_json :filter_for_jsonb
+  
+  def drill_for_json(column, drill, resource)
+    if cast = drill.delete(:cast)
+      column = column.cast_as(cast)
+    end
+
+    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)
+      else
+        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).or(column.eq(nil)))
+        else
+          raise 'Not supported'
+        end
+      end
+    end
+    resource
+  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))))
+        else
+          raise "Not Supported: #{key.to_sym}"
+        end
+      end
+      resource
+    else
+      where(table[column].contains(value))
+    end
+  end
+
+  def filter_for_has_and_belongs_to_many(relation, value)
+    resource = all
+  
+    options = {}
+    if resource.klass == relation.klass
+      options[:table_alias] = "#{relation.name}_#{relation.klass.table_name}"
+    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'
+    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'
+      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))
+      else
+        raise 'Not supported'
+      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
+
+    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))
+      else
+        resource = resource.joins(relation.name) # if !resource.references?(relation.name)
+        resource = resource.merge(relation.klass.filter(value))
+      end
+    else
+      if value.is_a?(String) && value =~ /\A\d+\Z/
+        resource = resource.where(:"#{relation.foreign_key}" => value.to_i)
+      else
+        raise 'Not supported'
+      end
+    end
+    resource
+  end
+
+end
+
+ActiveRecord::Base.extend(ActiveRecord::Filter)

data/lib/active_record/filter/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Filter
-    VERSION = '5.0.0.beta1'
+    VERSION = '5.0.0.rc1'
   end
 end

metadata

@@ -1,17 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-filter
 version: !ruby/object:Gem::Version
-  version: 5.0.0.beta1
+  version: 5.0.0.rc1
 platform: ruby
 authors:
 - Jon Bracy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-22 00:00:00.000000000 Z
+date: 2016-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: pg
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0.rc1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0.rc1
+- !ruby/object:Gem::Dependency
+  name: arel-extensions
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -25,19 +39,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: activerecord
+  name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.0.beta1
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.0.beta1
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -108,20 +122,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0.rc1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0.rc1
 - !ruby/object:Gem::Dependency
   name: factory_girl_rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.6.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.6.0
 - !ruby/object:Gem::Dependency
   name: faker
   requirement: !ruby/object:Gem::Requirement
@@ -146,13 +174,6 @@ extra_rdoc_files:
 - README.md
 files:
 - README.md
-- ext/active_record/base.rb
-- ext/active_record/query_methods.rb
-- ext/active_record/unkown_filter_error.rb
-- ext/arel/attributes/array.rb
-- ext/arel/nodes/contains.rb
-- ext/arel/nodes/overlaps.rb
-- ext/arel/visitors/postgresql.rb
 - lib/active_record/filter.rb
 - lib/active_record/filter/version.rb
 homepage: https://github.com/malomalo/activerecord-filter

data/ext/active_record/base.rb

@@ -1,268 +0,0 @@
-class ActiveRecord::Base
-  class << self
-
-    def inherited_with_filter(subclass)
-      inherited_without_filter(subclass)
-      subclass.instance_variable_set('@filters', HashWithIndifferentAccess.new)
-    end
-    alias_method_chain :inherited, :filter
-
-    def filter_on(name, lambda)
-      @filters[name] = lambda
-    end
-    
-    def filter(filters, options={})
-      resource = all
-      return resource unless filters
-
-      if filters.is_a?(Hash) || filters.is_a?(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
-      elsif filters.is_a?(Array) || filters.is_a?(Integer)
-        resource = resource.filter_for(:id, filters, options)
-      end
-
-      resource
-    end
-
-    def filter_for(key, value, options={})
-      column = columns_hash[key.to_s]
-      if column && column.array
-        all.filter_for_array(key, value, options)
-      elsif column
-        all.send("filter_for_#{column.type}", key, value, options)
-      else
-        if relation = reflect_on_association(key)
-          self.send("filter_for_#{relation.macro}", relation, value)
-        else
-          raise ActiveRecord::UnkownFilterError.new(self, key)
-        end
-      end
-    end
-
-    {
-      filter_for_geometry: :itself,
-      filter_for_datetime: :to_datetime,
-      filter_for_integer: :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
-
-        case value
-        when Hash, ActionController::Parameters
-          resource = all
-          value.each_pair do |key, value|
-            converted_value = value.try(:send, send_method)
-            resource = case key.to_sym
-            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 :not
-              resource.where(table[column].not_eq(converted_value))
-            when :not_in
-              resource.where(table[column].not_in(value).or(table[column].eq(nil)))
-            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.is_a?(ActionController::Parameters)
-                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])
-              else
-                Arel::Nodes::NamedFunction.new('ST_SetSRID', [Arel::Nodes::NamedFunction.new('ST_GeomFromText', [Arel::Nodes.build_quoted(value)]), 4326])
-              end
-
-              resource.where(Arel::Nodes::NamedFunction.new('ST_Intersects', [table[column], geometry_value]))
-            else
-              raise "Not Supported: #{key.to_sym}"
-            end
-          end
-          resource
-        when Array
-          where(table[column].in(value.map { |x| x.send(send_method) }))
-        when true, '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))
-          end
-        when false, '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
-        # 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)))
-        else
-          where(table[column].eq(value.try(:send, send_method)))
-        end
-      end
-    end
-    
-    def filter_for_jsonb(column, value, options = {})
-      table = options[:table_alias] ? arel_table.alias(options[:table_alias]) : arel_table
-      
-      case value
-      when true, 'true'
-        where(table[column].not_eq(nil))
-      when false, 'false'
-        where(table[column].eq(nil))
-      when nil
-        where(table[column].eq(nil))
-      else
-        raise 'Not supported'
-      end
-    end
-
-    def filter_for_array(column, value, options={})
-      table = options[:table_alias] ? arel_table.alias(options[:table_alias]) : arel_table
-
-      case value
-      when Hash, ActionController::Parameters
-        resource = all
-        value.each_pair do |key, value|
-          resource = case key.to_sym
-          when :contains
-            resource.where(Arel::Nodes::Contains.new(table[column], Arel::Attributes::Array.new(Array(value))))
-          when :overlaps
-            resource.where(Arel::Nodes::Overlaps.new(table[column], Arel::Attributes::Array.new(Array(value))))
-          when :not_overlaps
-            resource.where.not(Arel::Nodes::Overlaps.new(table[column], Arel::Attributes::Array.new(Array(value))))
-          when :not_contains
-            resource.where.not(Arel::Nodes::Contains.new(table[column], Arel::Attributes::Array.new(Array(value))))
-          else
-            raise "Not Supported: #{key.to_sym}"
-          end
-        end
-        resource
-      when Array
-        where(Arel::Nodes::Contains.new(table[column], Arel::Attributes::Array.new(value)))
-      else
-        where(Arel::Nodes::Contains.new(table[column], Arel::Attributes::Array.new([value])))
-      end
-    end
-
-    def filter_for_has_and_belongs_to_many(relation, value)
-      resource = all
-      
-      options = {}
-      if resource.klass == relation.klass
-        options[:table_alias] = "#{relation.name}_#{relation.klass.table_name}"
-      end
-      
-      case value
-      when Hash, ActionController::Parameters
-        resource = resource.joins(relation.name) if !resource.references?(relation.name)
-        resource = resource.merge(relation.klass.filter(value, options))
-      when Integer
-        resource = resource.joins(relation.name) if !resource.references?(relation.name)
-        resource = resource.merge(relation.klass.filter(value, options))
-      when Array
-        resource = resource.joins(relation.name) if !resource.references?(relation.name)
-        resource = resource.merge(relation.klass.filter(value, options))
-      else
-        raise 'Not supported'
-      end
-
-      resource
-    end
-
-    def filter_for_has_many(relation, value)
-      resource = all
-
-      case value
-      when Hash, ActionController::Parameters
-        if relation.options[:through]
-          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))
-      when Array, Integer
-        resource = filter_for_has_many(relation, {:id => value})
-      when true, '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'
-        end
-      when false, '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))
-        else
-          raise 'Not supported'
-        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
-
-      case value
-      when Array, Integer, NilClass
-        resource = resource.where(:"#{relation.foreign_key}" => value)
-      when true, 'true'
-        resource = resource.where(resource.arel_table[:"#{relation.foreign_key}"].not_eq(nil))
-      when false, 'false'
-        resource = resource.where(resource.arel_table[:"#{relation.foreign_key}"].eq(nil))
-      when Hash, ActionController::Parameters
-        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))
-        else
-          resource = resource.joins(relation.name) # if !resource.references?(relation.name)
-          resource = resource.merge(relation.klass.filter(value))
-        end
-      else
-        if value.is_a?(String) && value =~ /\A\d+\Z/
-          resource = resource.where(:"#{relation.foreign_key}" => value.to_i)
-        else
-          raise 'Not supported'
-        end
-      end
-      resource
-    end
-
-  end
-end

data/ext/active_record/query_methods.rb

@@ -1,27 +0,0 @@
-# module ActiveRecord::QueryMethods
-#
-#   # # TODO: testme and rename to joins?
-#   # def joined?(assoc)
-#   #   joined_assocs = joins_values.map{ |i| i.is_a?(Hash) ? i.keys : i.to_sym }.flatten
-#   #   joined_assocs.include?(assoc)
-#   # end
-#   #
-#   # # TODO: testme and rename to includes?
-#   # def included?(assoc)
-#   #   included_assocs = includes_values.map{ |i| i.is_a?(Hash) ? i.keys : i.to_sym }.flatten
-#   #   included_assocs.include?(assoc)
-#   # end
-#
-#   # TODO: testme and rename to
-#   def references?(assoc)
-#     references_assocs = references_values.map{ |i| i.is_a?(Hash) ? i.keys : i.to_sym }.flatten
-#     references_assocs.include?(assoc)
-#   end
-#
-# end
-
-module ActiveRecord::Querying
-  # delegate :joined?, :to => :all
-  # delegate :included?, :to => :all
-  delegate :references?, :to => :all
-end

data/ext/active_record/unkown_filter_error.rb

@@ -1,9 +0,0 @@
-class ActiveRecord::UnkownFilterError < NoMethodError
-  attr_reader :klass, :filter
-
-  def initialize(klass, filter)
-    @klass = klass
-    @filter = filter.to_s
-    super("unkown filter #{filter.inspect} for #{klass}.")
-  end
-end

data/ext/arel/attributes/array.rb

@@ -1,5 +0,0 @@
-module Arel
-  module Attributes
-    class Array < Attribute; end
-  end
-end

data/ext/arel/nodes/contains.rb

@@ -1,6 +0,0 @@
-module Arel
-  module Nodes
-    class Contains < Binary
-    end
-  end
-end

data/ext/arel/nodes/overlaps.rb

@@ -1,6 +0,0 @@
-module Arel
-  module Nodes
-    class Overlaps < Binary
-    end
-  end
-end

data/ext/arel/visitors/postgresql.rb

@@ -1,37 +0,0 @@
-module Arel
-  module Visitors
-    class PostgreSQL
-      private
-      
-      def visit_Arel_Nodes_Contains o, collector
-        visit o.left, collector
-        collector << ' @> '
-        visit o.right, collector
-      end
-
-      def visit_Arel_Nodes_Overlaps o, collector
-        visit o.left, collector
-        collector << ' && '
-        visit o.right, collector
-      end
-      
-      def visit_Arel_Attributes_Array o, collector
-        type = if !o.relation[0]
-          ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.new(nil)
-        else
-          # TODO: temp fix, need to figure out how to look up ruby type ->
-          # postgres type or use the column we're quering on...
-          dt = if o.relation[0].class == Fixnum
-            dt = "Integer"
-          else
-            o.relation[0].class
-          end
-          ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.new("ActiveRecord::Type::#{dt}".constantize.new)
-        end
-
-        collector << quote(type.serialize(o.relation))
-      end
-      
-    end
-  end
-end