active_hash_relation 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fd3f17dc4f8f76b811c90453a566ff8356baf769
-  data.tar.gz: 3a2d2ed0091644d391fc8402879220fbd936c624
+  metadata.gz: a59228314ab4ecac89c7ba2f988514e453d2b434
+  data.tar.gz: 16316aba61f2ff203189607d69fd9e738649187d
 SHA512:
-  metadata.gz: f37a7bd401b3c5609d125ffdd669bdf41c75fb5b8b8e5e8f879ec9c5dacf66088afb692dfb3ca1e994927be2375a2a08867b7078b59203985fb90ebfe0da3441
-  data.tar.gz: e749fe442aef147137ef82991b06f70a62cf600762c7f6be420696736fcc824b26f1830197a847bda7c9b4cdac90db5b713ca42013c6304fd1fb10d7d66e1cf1
+  metadata.gz: 67342eb6d946bea38b57f1b3e1f99f389c815fef0f6c89445c806ccde2750b18b33810d8cf60ac7b982281de08ad3564f329147d9d6b18be31070345a64f445e
+  data.tar.gz: aa938f3c84a0054be00d9af1fe80cda17ef4a9e0f249bd4d91a23d065230d3052cb7f8da81a215171d54e4226c959bc0fe7cefad328be807ea0977f914e27998

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,15 @@
+language: ruby
+sudo: false
+rvm: 2.3.3
+cache:
+  bundler: true
+install:
+  - cd spec/dummy-rails4 && bundle install
+  - cd ../dummy-rails5 && bundle install
+script:
+  - echo $(pwd)
+  - cd ../dummy-rails4 && bundle exec rspec spec/
+  - echo $(pwd)
+  - cd ../dummy-rails5 && bundle exec rspec spec/
+notifications:
+  email: false

data/README.md

@@ -1,4 +1,5 @@
 # ActiveHashRelation
+[ ![Codeship Status for kollegorna/active_hash_relation](https://app.codeship.com/projects/02f08850-cc66-0134-028f-5ad72e690a75/status?branch=master)](https://app.codeship.com/projects/200194)
 
 ## Introduction
 Simple gem that allows you to manipulate ActiveRecord::Relation using JSON. For instance:
@@ -11,7 +12,7 @@ apply_filters(resource, {updated_at: { geq: "2014-11-2 14:25:04"}, unit: {id: 9}
 ```
 or even filter a resource based on it's associations' associations:
 ```ruby
-apply_filters(resource, {updated_at: { geq: "2014-11-2 14:25:04"}, unit: {id: 9, areas: {id: 22} }})
+apply_filters(resource, {updated_at: { geq: "2014-11-2 14:25:04"}, unit: {id: 9, areas: {or: [{id: 22}, {id: 21}]} }})
 ```
 and the list could go on.. Basically your whole db is exposed\* there. It's perfect for filtering a collection of resources on APIs.
 
@@ -29,7 +30,7 @@ which might or might not be a security issue. If you don't like that check
 
 Add this line to your application's Gemfile:
 
-    gem 'active_hash_relation'
+    gem 'active_hash_relation', '~> 1.2.0
 
 And then execute:
 
@@ -38,8 +39,10 @@ And then execute:
 Or install it yourself as:
 
     $ gem install active_hash_relation
+
 ## How to use
-The gem exposes only one method: `apply_filters(resource, hash_params, include_associations: true, model: nil)`. `resource` is expected to be an ActiveRecord::Relation.
+The gem exposes only one method: `apply_filters(resource, hash_params, include_associations: true, model: nil)`.
+`resource` is expected to be an ActiveRecord::Relation.
 That way, you can add your custom filters before passing the `Relation` to `ActiveHashRelation`.
 
 In order to use it you have to include ActiveHashRelation module in your class. For instance in a Rails API controller you would do:
@@ -58,21 +61,40 @@ class Api::V1::ResourceController < Api::V1::BaseController
 end
 ```
 
+If you **need to enable filtering on scopes**, you need to specify that explicitly from the initializer. For instance:
+
+```ruby
+ActiveHashRelation.configure do |config|
+  #override default scope when accessing associations
+  config.use_unscoped = true
+  #set true to be able to filter scopes (with params)
+  #please note that unfortunately (:/) rails does not provide any way
+  #to iterate through scopes so it uses a monkey patch.
+  #The monkey patch is as gentle as it can be by aliasing the method, adds some
+  #sugar and calls it,
+  #You need to run `initialize!` to actually include the required files
+  config.filter_active_record_scopes = true
+end
+
+  #requires monkeyparched scopes, optional if you don't enable them
+  ActiveHashRelation.initialize!
+```
+
 ## The API
 ### Columns
-For each param, `apply_filters` method will search in the model's (derived from the first param, or explicitly defined as the last param) all the record's column names and associations. (filtering based on scopes are not working at the moment but will be supported soon). For each column, if there is such a param, it will apply the filter based on the column type. The following column types are supported:
+For each param, `apply_filters` method will search in the model's (derived from the
+first param, or explicitly defined as the last param) all the record's column names
+and associations. (filtering based on scopes are not working at the moment but
+will be supported soon). For each column, if there is such a param, it will
+apply the filter based on the column type. The following column types are supported:
 
-#### Primary
-You can apply a filter a column which is a primary key by value or using an array like:
-* `{primary_key_column: 5}`
-* `{primary_key_column: [1,3,4,5,6,7]}`
 
 #### Integer, Float, Decimal, Date, Time or Datetime/Timestamp
 You can apply an equality filter:
 
 * `{example_column: 500}`
 
-or using an array
+or using an array (`ActiveRecord` translates that internally to an `IN` query)
 * `{example_column: [500, 40]}`
 
 or using a hash as a value you get more options:
@@ -100,7 +122,13 @@ or using a hash as a value you get more options:
 * `{example_column: {eq: 'exact value'}}` `#runs: EXAMPLE_COLUMN = 'test'`
 * `{example_column: {starts_with: 'exac'}}` `#runs: EXAMPLE_COLUMN LIKE 'test%'`
 * `{example_column: {ends_with: 'alue'}}` `#runs: EXAMPLE_COLUMN LIKE '%test'`
-* `{example_column: {like: 'ct_va}}` `#runs: EXAMPLE_COLUMN LIKE '%test%'`
+* `{example_column: {like: 'ct_va'}}` `#runs: EXAMPLE_COLUMN LIKE '%test%'`
+
+If you want to filter using `ILIKE` you can pass an `with_ilike` param:
+
+* `{example_column: {like: 'ct_va', with_ilike: true}}` `#runs: EXAMPLE_COLUMN ILIKE '%test%'`
+* `{example_column: {like: 'ct_va', with_ilike: true}}` `#runs: EXAMPLE_COLUMN ILIKE '%test%'`
+
 
 **Please note that ILIKE and especially LIKE are quite slow if you have millions of records in the db even with an index.**
 
@@ -129,12 +157,41 @@ micropost_filter = Micropost.all.where("CREATED_AT =< ?", '12-9-2014'.to_datetim
 User.where(email: 'test@user.com').joins(:microposts).merge(micropost_filter)
 ```
 
+### NULL Filter
+You can apply null filter for generate query like this `"users.name IS NULL"` or `"users.name IS NOT NULL"` with this following code:
+`{ name: { null: true } }` for is null filter and `{ name: { null: false } }` for not null filter.
+
+this can be used also for relations tables, so you can write like this `{ books: {title: {null: false }} }`
+
+
+### OR Filter
+You can apply an SQL `OR` (for ActiveRecord 5+) using the following syntax:
+`{or: [{name: 'Filippos'}, {name: 'Vasilis'}]}`
+
+It will generate: `WHERE ((users.name = 'Filippos') OR (users.name = 'Vasilis'))`
+
+You can apply an `OR` on associations as well or even nested ones, there isn't much limitation on that.
+I suggest you though to take a look on the [tests](spec/tests/or_filter_spec.rb), cause the syntax gets a bit complex after a while ;)
+
+
 ### Scopes
-Scopes are supported via a tiny monkeypatch in the ActiveRecord's scope class method which holds the name of each scope. Only scopes that don't accept arguments are supported. The rest could also be supported but it wouldn't make much sense.. If you want to filter based on a scope in a model, the scope names should go under `scopes` sub-hash. For instance the following:
+**Filtering on scopes is not enabled by default**.
+
+Scopes are supported via a tiny monkeypatch in the ActiveRecord's scope class method which holds the name of each scope.
+The monkey patch is as gentle as it can be: it aliases the method, adds some sugar and executes it.
+
+Scopes with arguments are also supported but not tested much. Probably they will work fine unless your arguments expect
+complex objects.
+
+If you want to filter based on a scope in a model, the scope names should go under `scopes` sub-hash. For instance the following:
 * `{ scopes: { planned: true } }`
 
 will run the `.planned` scope on the resource.
 
+* `{scopes: {created_between: [1988, 2018]}}`
+
+will run the `.created_on(1988, 2018)` scope on the resource.
+
 ### Unscoped assotiations
 If you have a default scope in your models and you have a good reason to keep that, `active_hash_relation` provides an option to override it when filtering associations:
 

data/active_hash_relation.gemspec

@@ -18,6 +18,19 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_runtime_dependency "activerecord"
+
+  spec.add_development_dependency "activerecord"
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency "factory_girl_rails", "~> 4.0"
+  spec.add_development_dependency 'faker'
+  spec.add_development_dependency 'database_cleaner'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'pg'
+  spec.add_development_dependency 'rails'
+  spec.add_development_dependency 'rspec-rails'
 end

data/lib/active_hash_relation.rb

@@ -1,14 +1,13 @@
-require "active_record/scope_names"
-require "active_hash_relation/version"
-require "active_hash_relation/helpers"
-require "active_hash_relation/column_filters"
-require "active_hash_relation/scope_filters"
-require "active_hash_relation/sort_filters"
-require "active_hash_relation/limit_filters"
-require "active_hash_relation/association_filters"
-require "active_hash_relation/filter_applier"
-
-require "active_hash_relation/aggregation"
+require_relative "active_hash_relation/version"
+require_relative "active_hash_relation/helpers"
+require_relative "active_hash_relation/column_filters"
+require_relative "active_hash_relation/scope_filters"
+require_relative "active_hash_relation/sort_filters"
+require_relative "active_hash_relation/limit_filters"
+require_relative "active_hash_relation/association_filters"
+require_relative "active_hash_relation/filter_applier"
+
+require_relative "active_hash_relation/aggregation"
 
 module ActiveHashRelation
   class << self
@@ -23,6 +22,13 @@ module ActiveHashRelation
   def self.configuration
     @configuration ||= Configuration.new do
       self.has_filter_classes = false
+      self.filter_active_record_scopes = false
+    end
+  end
+
+  def self.initialize!
+    if self.configuration.filter_active_record_scopes
+      require_relative "active_record/scope_names"
     end
   end
 
@@ -41,6 +47,6 @@ module ActiveHashRelation
 
   class Configuration
     attr_accessor :has_filter_classes, :filter_class_prefix, :filter_class_suffix,
-      :use_unscoped
+      :use_unscoped, :filter_active_record_scopes
   end
 end

data/lib/active_hash_relation/aggregation.rb

@@ -12,6 +12,9 @@ module ActiveHashRelation
 
       unless @model
         @model = model_class_name(@resource)
+        if @model.nil? || engine_name == @model.to_s
+          @model = model_class_name(@resource, true)
+        end
       end
     end
 

data/lib/active_hash_relation/association_filters.rb

@@ -2,6 +2,9 @@ module ActiveHashRelation::AssociationFilters
   def filter_associations(resource, params, model = nil)
     unless model
       model = model_class_name(resource)
+      if model.nil? || engine_name == model.to_s
+        model = model_class_name(resource, true)
+      end
     end
 
     model.reflect_on_all_associations.map(&:name).each do |association|

data/lib/active_hash_relation/column_filters.rb

@@ -1,14 +1,14 @@
 module ActiveHashRelation::ColumnFilters
-  def filter_primary(resource, column, param)
-    resource = resource.where(id: param)
-  end
-
   def filter_integer(resource, column, table_name, param)
     if param.is_a? Array
       n_param = param.to_s.gsub("\"","'").gsub("[","").gsub("]","") #fix this!
       return resource.where("#{table_name}.#{column} IN (#{n_param})")
     elsif param.is_a? Hash
-      return apply_leq_geq_le_ge_filters(resource, table_name, column, param)
+      if !param[:null].nil?
+        return null_filters(resource, table_name, column, param)
+      else
+        return apply_leq_geq_le_ge_filters(resource, table_name, column, param)
+      end
     else
       return resource.where("#{table_name}.#{column} = ?", param)
     end
@@ -27,7 +27,11 @@ module ActiveHashRelation::ColumnFilters
       n_param = param.to_s.gsub("\"","'").gsub("[","").gsub("]","") #fix this!
       return resource.where("#{table_name}.#{column} IN (#{n_param})")
     elsif param.is_a? Hash
-      return apply_like_filters(resource, table_name, column, param)
+      if !param[:null].nil?
+        return null_filters(resource, table_name, column, param)
+      else
+        return apply_like_filters(resource, table_name, column, param)
+      end
     else
       return resource.where("#{table_name}.#{column} = ?", param)
     end
@@ -42,7 +46,11 @@ module ActiveHashRelation::ColumnFilters
       n_param = param.to_s.gsub("\"","'").gsub("[","").gsub("]","") #fix this!
       return resource.where("#{table_name}.#{column} IN (#{n_param})")
     elsif param.is_a? Hash
-      return apply_leq_geq_le_ge_filters(resource, table_name, column, param)
+      if !param[:null].nil?
+        return null_filters(resource, table_name, column, param)
+      else
+        return apply_leq_geq_le_ge_filters(resource, table_name, column, param)
+      end
     else
       resource = resource.where(column => param)
     end
@@ -55,7 +63,11 @@ module ActiveHashRelation::ColumnFilters
       n_param = param.to_s.gsub("\"","'").gsub("[","").gsub("]","") #fix this!
       return resource = resource.where("#{table_name}.#{column} IN (#{n_param})")
     elsif param.is_a? Hash
-      return apply_leq_geq_le_ge_filters(resource, table_name, column, param)
+      if !param[:null].nil?
+        return null_filters(resource, table_name, column, param)
+      else
+        return apply_leq_geq_le_ge_filters(resource, table_name, column, param)
+      end
     else
       resource = resource.where(column => param)
     end
@@ -63,15 +75,25 @@ module ActiveHashRelation::ColumnFilters
     return resource
   end
 
-  def filter_boolean(resource, column, param)
-    b_param = ActiveRecord::Type::Boolean.new.type_cast_from_database(param)
+  def filter_boolean(resource, column, table_name, param)
+    if param.is_a?(Hash) && !param[:null].nil?
+      return null_filters(resource, table_name, column, param)
+    else
+      if ActiveRecord::VERSION::MAJOR >= 5
+        b_param = ActiveRecord::Type::Boolean.new.cast(param)
+      else
+        b_param = ActiveRecord::Type::Boolean.new.type_cast_from_database(param)
+      end
 
-    resource = resource.where(column => b_param)
+      resource = resource.where(column => b_param)
+    end
   end
 
   private
 
   def apply_leq_geq_le_ge_filters(resource, table_name, column, param)
+    return resource.where("#{table_name}.#{column} = ?", param[:eq]) if param[:eq]
+
     if !param[:leq].blank?
       resource = resource.where("#{table_name}.#{column} <= ?", param[:leq])
     elsif !param[:le].blank?
@@ -109,4 +131,16 @@ module ActiveHashRelation::ColumnFilters
 
     return resource
   end
+  
+  def null_filters(resource, table_name, column, param)
+    if param[:null] == true
+      resource = resource.where("#{table_name}.#{column} IS NULL")
+    end
+    
+    if param[:null] == false
+      resource = resource.where("#{table_name}.#{column} IS NOT NULL")
+    end
+    
+    return resource
+  end
 end

data/lib/active_hash_relation/filter_applier.rb

@@ -9,36 +9,26 @@ module ActiveHashRelation
 
     attr_reader :configuration
 
-    def initialize(resource, params, include_associations: true, model: nil)
+    def initialize(resource, params, include_associations: false, model: nil)
       @configuration = Module.nesting.last.configuration
       @resource = resource
-      @params = HashWithIndifferentAccess.new(params)
+      if params.respond_to?(:to_unsafe_h)
+        @params = HashWithIndifferentAccess.new(params.to_unsafe_h)
+      else
+        @params = HashWithIndifferentAccess.new(params)
+      end
       @include_associations = include_associations
-      @model = model
+      @model = find_model(model)
     end
 
-
     def apply_filters
-      unless @model
-        @model = model_class_name(@resource)
-      end
+      run_or_filters
+
       table_name = @model.table_name
       @model.columns.each do |c|
         next if @params[c.name.to_s].nil?
         next if @params[c.name.to_s].is_a?(String) && @params[c.name.to_s].blank?
 
-        if c.respond_to?(:primary)
-          if c.primary
-            @resource = filter_primary(@resource, c.name, @params[c.name])
-            next
-          end
-        else #rails 4.2
-          if @model.primary_key == c.name
-            @resource = filter_primary(@resource, c.name, @params[c.name])
-            next
-          end
-        end
-
         case c.type
         when :integer
           @resource = filter_integer(@resource, c.name, table_name, @params[c.name])
@@ -46,19 +36,24 @@ module ActiveHashRelation
           @resource = filter_float(@resource, c.name, table_name, @params[c.name])
         when :decimal
           @resource = filter_decimal(@resource, c.name, table_name, @params[c.name])
-        when :string
+        when :string, :uuid, :text
           @resource = filter_string(@resource, c.name, table_name, @params[c.name])
         when :date
           @resource = filter_date(@resource, c.name, table_name, @params[c.name])
         when :datetime, :timestamp
           @resource = filter_datetime(@resource, c.name, table_name, @params[c.name])
         when :boolean
-          @resource = filter_boolean(@resource, c.name, @params[c.name])
+          @resource = filter_boolean(@resource, c.name, table_name, @params[c.name])
         end
       end
 
-
-      @resource = filter_scopes(@resource, @params[:scopes], @model) if @params.include?(:scopes)
+      if @params.include?(:scopes)
+        if ActiveHashRelation.configuration.filter_active_record_scopes
+          @resource = filter_scopes(@resource, @params[:scopes], @model)
+        else
+          Rails.logger.warn('Ignoring ActiveRecord scope filters because they are not enabled')
+        end
+      end
       @resource = filter_associations(@resource, @params, @model) if @include_associations
       @resource = apply_limit(@resource, @params[:limit]) if @params.include?(:limit)
       @resource = apply_sort(@resource, @params[:sort], @model) if @params.include?(:sort)
@@ -69,5 +64,24 @@ module ActiveHashRelation
     def filter_class(resource_name)
       "#{configuration.filter_class_prefix}#{resource_name.pluralize}#{configuration.filter_class_suffix}".constantize
     end
+
+    def run_or_filters
+      if @params[:or].is_a?(Array)
+        if ActiveRecord::VERSION::MAJOR < 5
+          return Rails.logger.warn("OR query is supported on ActiveRecord 5+") 
+        end
+
+        if @params[:or].length >= 2
+          array = @params[:or].map do |or_param|
+            self.class.new(@resource, or_param, include_associations: @include_associations).apply_filters
+          end
+
+          @resource = @resource.merge(array[0])
+          array[1..-1].each{|query| @resource = @resource.or(query)}
+        else
+          Rails.logger.warn("Can't run an OR with 1 element!")
+        end
+      end
+    end
   end
 end