jsonapi-utils 0.5.0.beta1 → 0.5.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e739a959755e7910791783ee16583499f32c06a6
-  data.tar.gz: 817a8fb3526e0fc8f15e4081a277a9e81d557340
+  metadata.gz: 96d7f50884d79e1dbb367adf611cb2f52d7ebf27
+  data.tar.gz: 67b77e50094f0a223c4bb1220108fcd8f890dcb6
 SHA512:
-  metadata.gz: 3307a7571da692f2606d056cb0d7c8b28acc3abcd9cd53b39e521d5a979ef4b95c4499f5eb41b4b816417cb47e59b31548cf19fd262c214844c3d81941deee2a
-  data.tar.gz: a210faeb4ea1aa675d236ef1e8993c81bcc2f273392f0fa80dd983d322ebdba6846019556cc2ccddcb1ae6afbc11bafe483ce75b95da12c19e46e4ffb5a1f30b
+  metadata.gz: 06fe4857feebe4f2fda0419c6b83cb5d85335f069c63e997d5c63746b989dcd251360f765d60047e525d97a15dac0c0ab41f78f7b131f3353299251598e804c0
+  data.tar.gz: e024c8a81831e7a329fb001f676cf24dbec54488514700788bc13a90eb41f0e0c925c629eff0ca09e07e47e8534a1731c7346195e8e526c453eaf523e712756d

data/README.md

@@ -1,14 +1,14 @@
 # JSONAPI::Utils
 
-[![Code Climate](https://codeclimate.com/github/b2beauty/jsonapi-utils/badges/gpa.svg)](https://codeclimate.com/github/b2beauty/jsonapi-utils)
+[![Code Climate](https://codeclimate.com/github/tiagopog/jsonapi-utils/badges/gpa.svg)](https://codeclimate.com/github/tiagopog/jsonapi-utils)
 [![Gem Version](https://badge.fury.io/rb/jsonapi-utils.svg)](https://badge.fury.io/rb/jsonapi-utils)
-[![Build Status](https://travis-ci.org/b2beauty/jsonapi-utils.svg?branch=master)](https://travis-ci.org/b2beauty/jsonapi-utils)
+[![Build Status](https://travis-ci.org/tiagopog/jsonapi-utils.svg?branch=master)](https://travis-ci.org/tiagopog/jsonapi-utils)
 
 Simple yet powerful way to get your Rails API compliant with [JSON API](http://jsonapi.org).
 
-JSONAPI::Utils (JU) is built on top of [JSONAPI::Resources](https://github.com/cerebris/jsonapi-resources) taking advantage of its resource-driven style and bringing a Rails way to build modern APIs with no or less learning curve.
+`JSONAPI::Utils` (JU) is built on top of [JSONAPI::Resources](https://github.com/cerebris/jsonapi-resources) taking advantage of its resource-driven style and bringing an easy way to build modern JSON APIs with no or less learning curve.
 
-## Contents
+## Table of Contents
 
 * [Installation](#installation)
 * [How does it work?](#how-does-it-work)
@@ -21,9 +21,9 @@ JSONAPI::Utils (JU) is built on top of [JSONAPI::Resources](https://github.com/c
 * [Full example](#full-example)
   * [Models](#models)
   * [Resources](#resources)
-  * [Routes & Controllers](routes--controllers)
+  * [Routes & Controllers](#routes--controllers)
   * [Initializer](#initializer)
-  * [Requests & Responses](requests--responses)
+  * [Requests & Responses](#requests--responses)
     * [Index](#index)
     * [Index (options)](#index-options)
     * [Show](#show)
@@ -36,17 +36,23 @@ JSONAPI::Utils (JU) is built on top of [JSONAPI::Resources](https://github.com/c
 
 ## Installation
 
-For:
+Support:
 
-* Ruby ~> 2.0 with Rails ~> 4.0, use JU's `0.4.6` version (stable);
-* Ruby ~> 2.1 with Rails 5, use JU's `0.5.0.beta1` version.
+* Ruby 2.x with Rails 4.x
+* Ruby 2.2.2+ with Rails 5
 
-Add these lines to your application's Gemfile:
+For Rails 4.x add this to your application's Gemfile:
 
 ```ruby
 gem 'jsonapi-utils', '~> 0.4.6'
 ```
 
+For Rails 5, specify the beta version in the Gemfile:
+
+```ruby
+gem 'jsonapi-utils', '0.5.0.beta2'
+```
+
 And then execute:
 
 ```shell
@@ -55,9 +61,9 @@ $ bundle
 
 ## How does it work?
 
-One of the main motivations behind `JSONAPI::Utils` is to keep things explicit in your controller actions so that developers can easily understand and maintain code. With this principle in mind, JU doesn't care about your controller operations and it deals only with the request and response layers thus letting the developer decides how to actually operate the actions (service objects, interactors or something).
+One of the main motivations behind `JSONAPI::Utils` is to keep things explicit in controllers so that developers can easily understand and maintain code. Unlike `JSONAPI::Resources` (JR), JU doesn't care about controller operations – what happens with resources within actions – dealing only with the request validation and response rendering and providing some useful helpers. This way developers can decide how to actually operate their actions (service objects, interactors etc).
 
-In both layers (request and response) JU communicates with some `JSONAPI::Resources`' objects in order to validate requests and render responses properly.
+In both layers (request and response) JU communicates with some JR's objects in order to validate requests and render responses properly.
 
 ## Usage
 
@@ -150,13 +156,13 @@ jsonapi_render_errors json: errors, status: :unprocessable_entity
 
 #### Formatters
 
-In the backstage those are the guys which actually parse ActiveRecord/Hash objects and build a new Hash compliant with JSON API. They can be called anywhere in controllers being very useful if you need to generate the response body and do some work with it before actually rendering the response.
+In the backstage those are the guys which actually parse ActiveRecord/Hash objects and build a new Hash compliant with JSON API. They can be called anywhere in controllers being very useful if you need to do some work with the response's body before rendering the response.
 
-Note: the resulting Hash from those methods can not be passed as argument to `JSONAPI::Utils#jsonapi_render` or  `JSONAPI::Utils#jsonapi_render_error`, instead it needs to be rendered by the usual `ActionController#render`.
+> Note: the resulting Hash from those methods can not be passed as argument to `JSONAPI::Utils#jsonapi_render` or  `JSONAPI::Utils#jsonapi_render_error`, instead it needs to be rendered by the usual `ActionController#render`.
 
 **jsonapi_format**
 
-*Because of semantic reasons `JSONAPI::Utils#jsonapi_serialize` was renamed being now just an alias to `JSONAPI::Utils#jsonapi_format`.*
+> Because of semantic reasons `JSONAPI::Utils#jsonapi_serialize` was renamed to `JSONAPI::Utils#jsonapi_format`.
 
 ```ruby
 # app/controllers/users_controller.rb
@@ -172,7 +178,7 @@ Arguments:
 
 ### Request
 
-Before your controller's action gets executed JU will validate request against JSON API specifications and eventual query string params against the resource's definitions. If something goes wrong with the request JU will render an error response like this:
+Before a controller's action gets executed, `JSONAPI::Utils` will validate the request against JSON API specifications as well as evaluating the eventual query string params to check if they match the resource's definition. If something goes wrong during the validation process, JU will render an error response like this examples below:
 
 ```json
 HTTP/1.1 400 Bad Request
@@ -204,7 +210,7 @@ Content-Type: application/vnd.api+json
 
 #### Params helpers
 
-JU brings helper methods as a shortcut to get values from permitted params based on the resource configuration.
+JU brings helper methods as a shortcut to get values from permitted params based on the resource's configuration.
 
 - `resource_params`:
   - Returns the permitted params present in the `attributes` JSON member;
@@ -217,14 +223,14 @@ JU brings helper methods as a shortcut to get values from permitted params based
 
 ## Full example
 
-In order to start working with JU after installing the gem you simply need to do the following:
+After installing the gem you simply need to:
 
-1. Include the gem (`include JSONAPI::Utils`) in the target controller or in a `BaseController`;
+1. Include its module (`include JSONAPI::Utils`) in controller (eg. `BaseController`);
 2. Define the resources for your models;
 3. Define routes;
-4. Use JU's render methods.
+4. Use JU's render/helper methods.
 
-Time for a full example, let's say we have a Rails application for a super simple blog:
+Ok, it's time for a more complete example. Let's say we have a Rails application for a super simple blog:
 
 ### Models
 
@@ -244,13 +250,12 @@ end
 
 ### Resources
 
-Here is where we define how the serialization will behave:
+Here is where we define how the models are exposed as resource on the API:
 
 ```ruby
 # app/resources/user_resource.rb
 class UserResource < JSONAPI::Resource
   attributes :first_name, :last_name, :full_name, :birthday
-  attribute :full_name
 
   has_many :posts
 
@@ -268,7 +273,7 @@ end
 
 ### Routes & Controllers
 
-Let's define our routes using the `jsonapi_resources` and `jsonapi_links` methods provied by the `jsonapi-resources` gem:
+Let's define the routes using the `jsonapi_resources` and `jsonapi_links` methods provided by JR:
 
 ```ruby
 Rails.application.routes.draw do
@@ -279,9 +284,9 @@ Rails.application.routes.draw do
 end
 ```
 
-In our Rails controller we just need to include the `JSONAPI::Utils` module.
+In controllers we just need to include the `JSONAPI::Utils` module.
 
-> Note: with JU default rendering can be defined, like in the below example with `jsonapi_render_not_found` for when ActiveRecord doesn't find a record.
+> Note: you may want to define some default rendering like the below example using `jsonapi_render_not_found` for when ActiveRecord doesn't find a record.
 
 ```ruby
 # app/controllers/base_controller.rb
@@ -411,7 +416,7 @@ You may want a different configuration for your API. For more information check
 
 ### Requests & Responses
 
-Here's some examples of requests – based on those sample [controllers](#routes--controllers) – and their respective JSON responses.
+Here are examples of requests – based on those sample [controllers](#routes--controllers) – and their respective JSON responses.
 
 * [Collection](#collection)
 * [Collection (options)](#collection-options)

data/lib/jsonapi/utils.rb

@@ -3,6 +3,10 @@ require 'jsonapi/utils/version'
 require 'jsonapi/utils/exceptions'
 require 'jsonapi/utils/request'
 require 'jsonapi/utils/response'
+require 'jsonapi/utils/support/filter/custom'
+require 'piped_ruby'
+
+JSONAPI::Resource.extend JSONAPI::Utils::Support::Filter::Custom
 
 module JSONAPI
   module Utils

data/lib/jsonapi/utils/response/formatters.rb

@@ -57,10 +57,11 @@ module JSONAPI
         end
 
         def build_collection(records, options = {})
-          records = apply_filter(records, options)
-          records = apply_pagination(records, options)
-          records = apply_sort(records)
-          records.respond_to?(:to_ary) ? records.map { |record| turn_into_resource(record, options) } : []
+          -> { apply_filter(records, options) }
+            .>> { |filtered| apply_pagination(filtered, options) }
+            .>> { |paginated| apply_sort(paginated) }
+            .>> { |result| result.map { |record| turn_into_resource(record, options) } }
+            .unwrap
         end
 
         def turn_into_resource(record, options = {})

data/lib/jsonapi/utils/response/support.rb

@@ -1,14 +1,14 @@
-require 'jsonapi/utils/support/filter'
+require 'jsonapi/utils/support/error'
+require 'jsonapi/utils/support/filter/default'
 require 'jsonapi/utils/support/pagination'
 require 'jsonapi/utils/support/sort'
-require 'jsonapi/utils/support/error'
 
 module JSONAPI
   module Utils
     module Response
       module Support
         include ::JSONAPI::Utils::Support::Error
-        include ::JSONAPI::Utils::Support::Filter
+        include ::JSONAPI::Utils::Support::Filter::Default
         include ::JSONAPI::Utils::Support::Pagination
         include ::JSONAPI::Utils::Support::Sort
 

data/lib/jsonapi/utils/support/filter/custom.rb

@@ -0,0 +1,22 @@
+module JSONAPI::Utils::Support::Filter
+  module Custom
+    def _custom_filters
+      @_allowed_custom_filters || []
+    end
+
+    def custom_filters(*attrs)
+      attrs.each { |attr| custom_filter(attr) }
+    end
+
+    def custom_filter(attr)
+      attr = attr.to_sym
+      @_allowed_filters[attr] = {}
+
+      if !@_allowed_custom_filters.is_a?(Array)
+        @_allowed_custom_filters = Array(attr)
+      elsif @_allowed_custom_filters.include?(attr)
+        @_allowed_custom_filters.push(attr)
+      end
+    end
+  end
+end

data/lib/jsonapi/utils/support/filter/default.rb

@@ -0,0 +1,32 @@
+module JSONAPI::Utils::Support::Filter
+  module Default
+    def apply_filter(records, options = {})
+      if apply_filter?(records, options)
+        records.where(filter_params)
+      else
+        records
+      end
+    end
+
+    def apply_filter?(records, options = {})
+      params[:filter].present? && records.respond_to?(:where) &&
+        (options[:filter].nil? || options[:filter])
+    end
+
+    def filter_params
+      @_filter_params ||=
+        case params[:filter]
+        when Hash, ActionController::Parameters
+          default_filters.each_with_object({}) do |resource, hash|
+            hash[resource] = params[:filter][resource]
+          end
+        end
+    end
+
+    private
+
+    def default_filters
+      params[:filter].keys.map(&:to_sym) - @request.resource_klass._custom_filters
+    end
+  end
+end

data/lib/jsonapi/utils/support/pagination.rb

@@ -2,64 +2,124 @@ module JSONAPI
   module Utils
     module Support
       module Pagination
+        # Apply proper pagination to the records.
+        #
+        # @param records [ActiveRecord::Relation, Array] collection of records
+        #   e.g.: User.all or [{ id: 1, name: 'Tiago' }, { id: 2, name: 'Doug' }]
+        #
+        # @param options [Hash] JU's options
+        #   e.g.: { resource: V2::UserResource, count: 100 }
+        #
+        # @return [ActiveRecord::Relation, Array]
+        #
+        # @api public
         def apply_pagination(records, options = {})
           return records unless apply_pagination?(options)
+          records.is_a?(Array) ? records[paginate_with(:range)] : paginate_with(:paginator).apply(records, nil)
+        end
 
-          pagination = set_pagination
+        # Mount pagination params for JSONAPI::ResourcesOperationResult.
+        # It can also be used anywhere else as a helper method.
+        #
+        # @param records [ActiveRecord::Relation, Array] collection of records
+        #   e.g.: User.all or [{ id: 1, name: 'Tiago' }, { id: 2, name: 'Doug' }]
+        #
+        # @param options [Hash] JU's options
+        #   e.g.: { resource: V2::UserResource, count: 100 }
+        #
+        # @return [Hash]
+        #   e.g.: {"first"=>{"number"=>1, "size"=>2}, "next"=>{"number"=>2, "size"=>2}, "last"=>{"number"=>2, "size"=>2}}
+        #
+        # @api public
+        def pagination_params(records, options)
+          return {} unless JSONAPI.configuration.top_level_links_include_pagination
+          paginator.links_page_params(record_count: count_records(records, options))
+        end
 
-          records =
-            if records.is_a?(Array)
-              records[pagination[:range]]
-            else
-              pagination[:paginator].apply(records, nil)
+        private
+
+        # Define the paginator object to be used in the response's pagination.
+        #
+        # @return [PagedPaginator, OffsetPaginator]
+        #
+        # @api private
+        def paginator
+          @paginator ||=
+            if JSONAPI.configuration.default_paginator == :paged
+              PagedPaginator.new(page_params)
+            elsif JSONAPI.configuration.default_paginator == :offset
+              OffsetPaginator.new(page_params)
             end
         end
 
+        # Check whether pagination should be applied to the response.
+        #
+        # @return [Boolean]
+        #
+        # @api private
         def apply_pagination?(options)
           JSONAPI.configuration.default_paginator != :none &&
             (options[:paginate].nil? || options[:paginate])
         end
 
-        def pagination_params(records, options)
-          @paginator ||= paginator(params)
-          if @paginator && JSONAPI.configuration.top_level_links_include_pagination
-            options = {}
-            @paginator.class.requires_record_count &&
-              options[:record_count] = count_records(records, options)
-            @paginator.links_page_params(options)
-          else
-            {}
-          end
+        # Creates an instance of ActionController::Parameters for page params.
+        #
+        # @return [ActionController::Parameters]
+        #
+        # @api private
+        def page_params
+          @page_params ||= ActionController::Parameters.new(@request.params[:page] || {})
         end
 
-        def paginator(params)
-          page_params = ActionController::Parameters.new(params[:page] || {})
-
-          @paginator ||=
-            if JSONAPI.configuration.default_paginator == :paged
-              PagedPaginator.new(page_params)
-            elsif JSONAPI.configuration.default_paginator == :offset
-              OffsetPaginator.new(page_params)
+        # Define the paginator or range according to the pagination strategy.
+        #
+        # @param kind [Symbol] pagination object's kind
+        #   e.g.: :paginator or :range
+        #
+        # @return [PagedPaginator, OffsetPaginator, Range]
+        #   e.g.: #<PagedPaginator:0x00561ed06dc5a0 @number=1, @size=2>
+        #         0..9
+        #
+        # @api private
+        def paginate_with(kind)
+          @pagination ||=
+            case kind
+            when :paginator then paginator
+            when :range     then pagination_range
             end
         end
 
-        def set_pagination
-          page_params = ActionController::Parameters.new(@request.params[:page] || {})
-          if JSONAPI.configuration.default_paginator == :paged
-            @_paginator ||= PagedPaginator.new(page_params)
+        # Define a pagination range for objects which quack like Arrays.
+        #
+        # @return [Range]
+        #   e.g.: 0..9
+        #
+        # @api private
+        def pagination_range
+          case JSONAPI.configuration.default_paginator
+          when :paged
             number = page_params['number'].to_i.nonzero? || 1
             size   = page_params['size'].to_i.nonzero?   || JSONAPI.configuration.default_page_size
-            { paginator: @_paginator, range: (number - 1) * size..number * size - 1 }
-          elsif JSONAPI.configuration.default_paginator == :offset
-            @_paginator ||= OffsetPaginator.new(page_params)
+            (number - 1) * size..number * size - 1
+          when :offset
             offset = page_params['offset'].to_i.nonzero? || 0
             limit  = page_params['limit'].to_i.nonzero?  || JSONAPI.configuration.default_page_size
-            { paginator: @_paginator, range: offset..offset + limit - 1 }
-          else
-            {}
+            offset..offset + limit - 1
           end
         end
 
+        # Count records in order to build a proper pagination and to fill up the "record_count" response's member.
+        #
+        # @param records [ActiveRecord::Relation, Array] collection of records
+        #   e.g.: User.all or [{ id: 1, name: 'Tiago' }, { id: 2, name: 'Doug' }]
+        #
+        # @param options [Hash] JU's options
+        #   e.g.: { resource: V2::UserResource, count: 100 }
+        #
+        # @return [Integer]
+        #   e.g.: 42
+        #
+        # @api private
         def count_records(records, options)
           if options[:count].present?
             options[:count]

data/lib/jsonapi/utils/version.rb

@@ -1,5 +1,5 @@
 module JSONAPI
   module Utils
-    VERSION = '0.5.0.beta1'.freeze
+    VERSION = '0.5.0.beta2'.freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-utils
 version: !ruby/object:Gem::Version
-  version: 0.5.0.beta1
+  version: 0.5.0.beta2
 platform: ruby
 authors:
 - Tiago Guedes
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-01 00:00:00.000000000 Z
+date: 2016-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonapi-resources
@@ -17,138 +17,152 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.8.0.beta1
+        version: 0.8.0.beta2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.8.0.beta1
+        version: 0.8.0.beta2
+- !ruby/object:Gem::Dependency
+  name: piped_ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.10'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '10.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: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '4.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '4.2'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '3.1'
 - !ruby/object:Gem::Dependency
   name: factory_girl
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '4.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '4.5'
 - !ruby/object:Gem::Dependency
   name: smart_rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: 0.1.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: 0.1.4
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: 0.10.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: 0.10.3
 - !ruby/object:Gem::Dependency
   name: pry-byebug
   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 Rails way to get your API's data serialized through JSON API's specs
@@ -160,23 +174,24 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- CODE_OF_CONDUCT.md
-- LICENSE.txt
-- README.md
 - bin/console
 - bin/setup
-- lib/jsonapi/utils.rb
 - lib/jsonapi/utils/exceptions.rb
 - lib/jsonapi/utils/request.rb
-- lib/jsonapi/utils/response.rb
 - lib/jsonapi/utils/response/formatters.rb
 - lib/jsonapi/utils/response/renders.rb
 - lib/jsonapi/utils/response/support.rb
+- lib/jsonapi/utils/response.rb
 - lib/jsonapi/utils/support/error.rb
-- lib/jsonapi/utils/support/filter.rb
+- lib/jsonapi/utils/support/filter/custom.rb
+- lib/jsonapi/utils/support/filter/default.rb
 - lib/jsonapi/utils/support/pagination.rb
 - lib/jsonapi/utils/support/sort.rb
 - lib/jsonapi/utils/version.rb
+- lib/jsonapi/utils.rb
+- LICENSE.txt
+- README.md
+- CODE_OF_CONDUCT.md
 homepage: https://github.com/b2beauty/jsonapi-utils
 licenses:
 - MIT
@@ -187,20 +202,19 @@ 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.6.2
+rubygems_version: 2.0.14.1
 signing_key: 
 specification_version: 4
 summary: JSON::Utils is a simple way to get a full-featured JSON API serialization
   for your controller's responses.
 test_files: []
-has_rdoc: 

data/lib/jsonapi/utils/support/filter.rb

@@ -1,30 +0,0 @@
-module JSONAPI
-  module Utils
-    module Support
-      module Filter
-        def apply_filter(records, options = {})
-          if apply_filter?(records, options)
-            records.where(filter_params)
-          else
-            records
-          end
-        end
-
-        def apply_filter?(records, options = {})
-          params[:filter].present? && records.respond_to?(:where) &&
-            (options[:filter].nil? || options[:filter])
-        end
-
-        def filter_params
-          @_filter_params ||=
-            case params[:filter]
-            when Hash, ActionController::Parameters
-              params[:filter].keys.each_with_object({}) do |resource, hash|
-                hash[resource] = params[:filter][resource]
-              end
-            end
-        end
-      end
-    end
-  end
-end