activerecord-filter 1.0.0.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bf2f420a770b315c9c5447527d2f54b0f3345e3f
+  data.tar.gz: 1bf8eb361be7b60ffddf0ca081a88dd8cb0b485c
+SHA512:
+  metadata.gz: acdd1fdab608afd088bdc97a71f1f2cfa5cc22066790ec32d1edba9007264ef5e2307a48bce8b157c2283c1feffc527e6a531928219e0cb9dc2c8790b8d616f4
+  data.tar.gz: 908e00ea9062f1157be09479244c4ec401df5d836017e3a6acba87451649c9438171ca3f1c7ca06cadc015c5d8910860627ee607b89c7ce73c9d4cea0777559e

data/README.md

@@ -0,0 +1,2 @@
+# activerecord-filter
+A safe way to accept user parameters and query against your ActiveRecord Models

data/ext/active_record/base.rb

@@ -0,0 +1,251 @@
+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.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_decimal: :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
+          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)
+                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
+        puts value.inspect
+        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 Array
+        where(Arel::Nodes::Overlaps.new(table[column], Arel::Attributes::Array.new(value)))
+      else
+        any_column = Arel::Nodes::NamedFunction.new('ANY', [table[column]])
+        predicate = Arel::Nodes::Equality.new(Arel::Nodes.build_quoted(value), any_column)
+        where(predicate)
+      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
+        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
+        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
+        if relation.polymorphic?
+          raise 'no :as' if !value[:as]
+          klass = value.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(value))
+        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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,9 @@
+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

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

data/ext/arel/nodes/contains.rb

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

data/ext/arel/nodes/overlaps.rb

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

data/ext/arel/visitors/postgresql.rb

@@ -0,0 +1,30 @@
+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
+          ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.new("ActiveRecord::Type::#{o.relation[0].class}".constantize.new)
+        end
+
+        collector << quote(type.type_cast_for_database(o.relation))
+      end
+      
+    end
+  end
+end

data/lib/active_record/filter.rb

@@ -0,0 +1,9 @@
+require 'active_record'
+
+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'))

data/lib/active_record/filter/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module Filter
+    VERSION = '1.0.0.alpha'
+  end
+end

metadata

@@ -0,0 +1,199 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-filter
+version: !ruby/object:Gem::Version
+  version: 1.0.0.alpha
+platform: ruby
+authors:
+- Jon Bracy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl_rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A safe way to accept user parameters and query against your ActiveRecord
+  Models
+email:
+- jonbracy@gmail.com
+executables: []
+extensions: []
+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
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A safe way to accept user parameters and query against your ActiveRecord
+  Models
+test_files: []