active_hash_relation 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4b491ebb86ce76c8bd1380597b0c1fcba6c787b5
-  data.tar.gz: 59ce2d3323cfe3b85aa5fc50b9fc81c9414cd666
+  metadata.gz: 60eec7b209bc819b5c4c678f9350022252ddb7f8
+  data.tar.gz: 157845010e5961cdc7f12adf04fadb40f5369541
 SHA512:
-  metadata.gz: 6580c8a889a299e994b2af5dd32d937281afce27c9583838fc793b0d93c0ef9638f7ea0e89bb283bd2bb699aae8fe1dc804953e6e7ef284890b5da0c063c220c
-  data.tar.gz: e63134ea30cec6c28cc92dfbf46bd0689465464542c6b2d87d36d90c7fe5a57491ea0211fc3f948a17530589baa8a809af0a0191413fb1179528494ca2b236e0
+  metadata.gz: c357b72169fff0f28b4d9cb4b4a61941d8ebc478b80676a161ad176dbe741583b96582af699421389569816397a6487a589c070109ed4d9ab747db029b19fd52
+  data.tar.gz: f614659c194e246c597a9dd4a780ac13f6eb2370101a0a0239191baa09275caacee53eddea951212560738ab6eeb0b3aefc6d372aa13f0ae9c1d94984dd77683

data/README.md

@@ -13,7 +13,15 @@ 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} }})
 ```
-and the list could go on.. Basically your whole db is exposed there. It's perfect for filtering a collection of resources on APIs.
+and the list could go on.. Basically your whole db is exposed\* there. It's perfect for filtering a collection of resources on APIs.
+
+It should be noted that `apply_filters` calls `ActiveHashRelation::FilterApplier` class
+underneath with the same params.
+
+_\*Actually nothing is exposed, but a user could retrieve resources based
+on unknown attributes (attributes not returned from the API) by brute forcing
+which might or might not be a security issue. If you don't like that check
+[whitelisting](https://github.com/kollegorna/active_hash_relation#whitelisting)._
 
 ## Installation
 
@@ -82,6 +90,19 @@ You can apply an incensitive matching filter (currently working only for Postgre
 
 The above filter will search all records that include `test` in the `example_column` field. A better would be nice here, for instance, setting the search sensitive or insensitive, start or end with a string etch
 
+### Limit
+A limit param defines the number of returned resources. For instance:
+* `{limit: 10}`
+
+However I would strongly advice you to use a pagination gem like Kaminari, and use `page` and `per_page` params.
+
+
+### Sorting
+You can apply sorting using the `property` and `order` attributes. For instance:
+* `{property: 'created_at', order: 'desc'}`
+
+If there is no column named after the property value, sorting is skipped.
+
 
 ### Associations
 If the association is a `belongs_to` or `has_one`, then the hash key name must be in singular. If the association is `has_many` the attribute must be in plural reflecting the association type. When you have, in your hash, filters for an association, the sub-hash is passed in the association's model. For instance, let's say a user has many microposts and the following filter is applied (could be through an HTTP GET request on controller's index method):
@@ -103,6 +124,27 @@ will run the `.planned` scope on the resource.
 ### Whitelisting
 If you don't want to allow a column/association/scope just remove it from the params hash.
 
+#### Filter Classes
+Sometimes, especially on larger projects, you have specific classes that handle
+the input params outside the controllers. You can configure the gem to look for
+those classes and call `apply_filters` which will apply the necessary filters when
+iterating over associations.
+
+In an initializer:
+```ruby
+#config/initializers/active_hash_relation.rb
+ActiveHashRelation.configure do |config|
+  config.has_filter_classes = true
+  config.filter_class_prefix = 'Api::V1::'
+  config.filter_class_suffix = 'Filter'
+end
+```
+With the above settings, when the association name is `resource`,
+`Api::V1::ResourceFilter.new(resource, params[resource]).apply_filters` will be
+called to apply the filters in resource association.
+
+
+
 ## Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/active_hash_relation/fork )

data/lib/active_hash_relation.rb

@@ -2,10 +2,27 @@ require "active_record/scope_names"
 require "active_hash_relation/version"
 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"
 
 module ActiveHashRelation
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration
+    yield(configuration)
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new do
+      self.has_filter_classes = false
+    end
+  end
+
   def apply_filters(resource, params, include_associations: false, model: nil)
     FilterApplier.new(
       resource,
@@ -14,4 +31,9 @@ module ActiveHashRelation
       model: model
     ).apply_filters
   end
+
+  class Configuration
+    attr_accessor :has_filter_classes, :filter_class_prefix, :filter_class_suffix
+  end
+
 end

data/lib/active_hash_relation/association_filters.rb

@@ -7,11 +7,19 @@ module ActiveHashRelation::AssociationFilters
     model.reflect_on_all_associations.map(&:name).each do |association|
       if params[association]
         association_name = association.to_s.titleize.split.join
-        association_filters = ActiveHashRelation::FilterApplier.new(
-          association_name.singularize.constantize.all,
-          params[association],
-          include_associations: true
-        ).apply_filters
+        if self.configuration.has_filter_classes
+          puts self.filter_class(association_name)
+          association_filters = self.filter_class(association_name).new(
+            association_name.singularize.constantize.all,
+            params[association]
+          ).apply_filters
+        else
+          association_filters = ActiveHashRelation::FilterApplier.new(
+            association_name.singularize.constantize.all,
+            params[association],
+            include_associations: true
+          ).apply_filters
+        end
         resource = resource.joins(association).merge(association_filters)
       end
     end

data/lib/active_hash_relation/column_filters.rb

@@ -63,13 +63,13 @@ module ActiveHashRelation::ColumnFilters
     if param[:leq]
       resource = resource.where("#{table_name}.#{column} <= ?", param[:leq])
     elsif param[:le]
-      resource = resource.where("#{table_name}.#{column} < ?", param[:leq])
+      resource = resource.where("#{table_name}.#{column} < ?", param[:le])
     end
 
     if param[:geq]
       resource = resource.where("#{table_name}.#{column} >= ?", param[:geq])
     elsif param[:ge]
-      resource = resource.where("#{table_name}.#{column} > ?", param[:geq])
+      resource = resource.where("#{table_name}.#{column} > ?", param[:ge])
     end
 
     return resource

data/lib/active_hash_relation/filter_applier.rb

@@ -3,8 +3,13 @@ module ActiveHashRelation
     include ColumnFilters
     include AssociationFilters
     include ScopeFilters
+    include SortFilters
+    include LimitFilters
 
-    def initialize(resource, params, include_associations: false, model: nil)
+    attr_reader :configuration
+
+    def initialize(resource, params, include_associations: true, model: nil)
+      @configuration = Module.nesting.last.configuration
       @resource = resource
       @params = HashWithIndifferentAccess.new(params)
       @include_associations = include_associations
@@ -20,7 +25,18 @@ module ActiveHashRelation
       @model.columns.each do |c|
         next if @params[c.name.to_s].nil?
 
-        @resource = filter_primary(@resource, c.name, @params[c.name]) and next if c.primary
+        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])
@@ -41,10 +57,15 @@ module ActiveHashRelation
 
 
       @resource = filter_scopes(@resource, @params[:scopes]) if @params.include?(:scopes)
-      @resource = filter_associations(@resource, @params)
+      @resource = filter_associations(@resource, @params) if @include_associations
+      @resource = apply_limit(@resource, @params[:limit]) if @params.include?(:limit)
+      @resource = apply_sort(@resource, @params[:sort], @model) if @params.include?(:sort)
 
       return @resource
     end
 
+    def filter_class(resource_name)
+      "#{configuration.filter_class_prefix}#{resource_name.pluralize}#{configuration.filter_class_suffix}".constantize
+    end
   end
 end

data/lib/active_hash_relation/limit_filters.rb

@@ -0,0 +1,5 @@
+module ActiveHashRelation::LimitFilters
+  def apply_limit(resource, limit)
+    return resource.limit(limit)
+  end
+end

data/lib/active_hash_relation/sort_filters.rb

@@ -0,0 +1,9 @@
+module ActiveHashRelation::SortFilters
+  def apply_sort(resource, params, model = nil)
+    if model.columns.map(&:name).include?(params[:property])
+      resource = resource.order(params[:property] => (params[:order] || :desc) )
+    end
+
+    return resource
+  end
+end

data/lib/active_hash_relation/version.rb

@@ -1,3 +1,3 @@
 module ActiveHashRelation
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_hash_relation
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Filippos Vasilakis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-26 00:00:00.000000000 Z
+date: 2015-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -56,7 +56,9 @@ files:
 - lib/active_hash_relation/association_filters.rb
 - lib/active_hash_relation/column_filters.rb
 - lib/active_hash_relation/filter_applier.rb
+- lib/active_hash_relation/limit_filters.rb
 - lib/active_hash_relation/scope_filters.rb
+- lib/active_hash_relation/sort_filters.rb
 - lib/active_hash_relation/version.rb
 - lib/active_record/scope_names.rb
 homepage: https://www.kollegorna.se