jsonapi-utils 0.4.4 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8e4f9e4f00521de390580aa6cc15c92f785ae0a5
-  data.tar.gz: 42c4dc5facd04f531fe5e19790463785e45962d2
+  metadata.gz: ec04f95554ca59d1117ffa0452646252a5a156c5
+  data.tar.gz: 897fd3e12eceed6338421e6e5b7166afd8279947
 SHA512:
-  metadata.gz: ea64cf3d3f5900d25b194047f045ccc0450315108223250cbfab943e89f8ccd25ecff1aca8d056bb1454aa2e9e933abc08177688f110f02f4b91095f99ffdcae
-  data.tar.gz: 249e6f9b09eb464091f0c4aa38fb19920f42a3b62ad3d0d547d7274d2cdb2712230a5493711ec83e5efcea0efd5efe52bdc3b040339c5cf51d73c60bfb75381e
+  metadata.gz: 2aa0e5fc2e3c030898bd2287804bb62752523f6f9e6aad6a01c14954d9d8a09dee587117a54cd7463cb9cefedeb5ca2d91bb00548e703b5a99f57eb15e91a97b
+  data.tar.gz: 1136e92931251cce1ad8f652d56ee7555d0da2cbb93c3c4b44b7d33053b9460357b23bf84a9b178cb702e73942d92d9688e61d10ad0cd5e4e4bd80994e2d0a35

data/README.md

@@ -13,7 +13,7 @@ JSONAPI::Utils (JU) was built on top of [JSONAPI::Resources](https://github.com/
 Add these lines to your application's Gemfile:
 
 ```ruby
-gem 'jsonapi-utils', '~> 0.4.3'
+gem 'jsonapi-utils', '~> 0.4.4'
 ```
 
 And then execute:
@@ -22,11 +22,23 @@ And then execute:
 $ bundle
 ```
 
-## Macros
+## Response Macros
 
 ### jsonapi_render
 
-Validates the request and renders ActiveRecord/Hash objects into JSON API-compliant responses.
+Takes ActiveRecord/Hash objects and generates JSON API-compliant responses.
+
+```ruby
+# GET /users
+def index
+  jsonapi_render json: User.all
+end
+
+# GET /users/:id
+def show
+  jsonapi_render json: User.find(params[:id])
+end
+```
 
 Arguments:
 
@@ -37,13 +49,9 @@ Arguments:
     - `count`: explicitly points the total count of records for the request in order to build a proper pagination. By default, JU will count the total number of records.
     - `model`: sets the model reference in cases when `json` is a Hash or a collection of Hashes.
 
-```ruby
-# Single resource rendering
-jsonapi_render json: User.find(params[:id])
-
-# Collection rendering
-jsonapi_render json: User.all
+Examples:
 
+```ruby
 # Specify a particular HTTP status code
 jsonapi_render json: new_user, status: :created
 
@@ -60,17 +68,21 @@ jsonapi_render json: { data: { id: 1, first_name: 'Tiago' } }, options: { model:
 jsonapi_render json: { data: [{ id: 1, first_name: 'Tiago' }, { id: 2, first_name: 'Doug' }] }, options: { model: User }
 ```
 
-### jsonapi_serialize
+### jsonapi_format
 
-In the backstage that's the method that actually parsers ActiveRecord/Hash objects and builds a new Hash compliant with JSON API. It can be called anywhere in controllers, concerns etc.
+In the backstage this is the method that actually parses ActiveRecord/Hash objects and builds a new Hash compliant with JSON API. It can be called anywhere in your controllers being very useful whenever you need to work with a JSON API "serialized" version of your object before rendering it. 
+
+Note: because of semantic reasons `JSONAPI::Utils#jsonapi_serialize` was renamed being now just an alias to `JSONAPI::Utils#jsonapi_format`.
 
 ```ruby
-collection = jsonapi_serialize(User.all)
-render json: do_some_magic_with(collection)
+def index
+  result = do_some_magic(jsonapi_format(User.all))
+  render json: result
+end
 ```
 
 Arguments:
-  - It receives a second optional argument with the same options for `jsonapi_render`.
+  - It receives the same options as `jsonapi_render`.
 
 ## Usage
 
@@ -218,12 +230,8 @@ Content-Type: application/vnd.api+json
     {
       "title": "Record not found",
       "detail": "The record identified by 3 could not be found.",
-      "id": null,
-      "href": null,
-      "code": 404,
-      "source": null,
-      "links": null,
-      "status": "not_found"
+      "code": "404",
+      "status": "404"
     }
   ]
 }

data/lib/jsonapi/utils.rb

@@ -1,260 +1,18 @@
 require 'jsonapi-resources'
 require 'jsonapi/utils/version'
 require 'jsonapi/utils/exceptions'
+require 'jsonapi/utils/request'
+require 'jsonapi/utils/response'
 
 module JSONAPI
   module Utils
+    include JSONAPI::Utils::Request
+    include JSONAPI::Utils::Response
+
     def self.included(base)
-      if base.respond_to?(:helper_method)
+      if base.respond_to?(:before_action)
         base.before_action :setup_request, :check_request
-        base.helper_method :jsonapi_render, :jsonapi_serialize
-      end
-    end
-
-    def jsonapi_render(json:, status: nil, options: {})
-      body = jsonapi_serialize(json, options)
-      render json: body, status: status || @_response_document.status
-    rescue => e
-      handle_exceptions(e)
-    ensure
-      if response.body.size > 0
-        response.headers['Content-Type'] = JSONAPI::MEDIA_TYPE
-      end
-    end
-
-    def jsonapi_render_errors(exception)
-      result = jsonapi_format_errors(exception)
-      errors = result.errors
-      render json: { errors: errors }, status: errors.first.status
-    end
-
-    def jsonapi_format_errors(exception)
-      JSONAPI::ErrorsOperationResult.new(exception.errors[0].code, exception.errors)
-    end
-
-    def jsonapi_render_internal_server_error
-      jsonapi_render_errors(::JSONAPI::Utils::Exceptions::InternalServerError.new)
-    end
-
-    def jsonapi_render_bad_request
-      jsonapi_render_errors(::JSONAPI::Utils::Exceptions::BadRequest.new)
-    end
-
-    def jsonapi_render_not_found(exception)
-      id = exception.message.match(/=([\w-]+)/).try(:[], 1) || '(no identifier)'
-      jsonapi_render_errors(JSONAPI::Exceptions::RecordNotFound.new(id))
-    end
-
-    def jsonapi_render_not_found_with_null
-      render json: { data: nil }, status: 200
-    end
-
-    def jsonapi_serialize(records, options = {})
-      if records.is_a?(Hash)
-        hash    = records.with_indifferent_access
-        records = hash_to_active_record(hash[:data], options[:model])
-      end
-
-      fix_request_options(params, records)
-      build_response_document(records, options).contents
-    end
-
-    def filter_params
-      @_filter_params ||=
-        if params[:filter].is_a?(Hash)
-          params[:filter].keys.each_with_object({}) do |resource, hash|
-            hash[resource] = params[:filter][resource]
-          end
-        end
-    end
-
-    def sort_params
-      @_sort_params ||=
-        if params[:sort].present?
-          params[:sort].split(',').each_with_object({}) do |criteria, hash|
-            order, field = criteria.match(/(\-?)(\w+)/i)[1..2]
-            hash[field]  = order == '-' ? :desc : :asc
-          end
-        end
-    end
-
-    private
-
-    def build_response_document(records, options)
-      results = JSONAPI::OperationResults.new
-
-      if records.respond_to?(:to_ary)
-        @_records = build_collection(records, options)
-        results.add_result(JSONAPI::ResourcesOperationResult.new(:ok, @_records, result_options(records, options)))
-      else
-        @_record = turn_into_resource(records, options)
-        results.add_result(JSONAPI::ResourceOperationResult.new(:ok, @_record))
-      end
-
-      @_response_document = create_response_document(results)
-    end
-
-
-    def fix_request_options(params, records)
-      return if request.method !~ /get/i ||
-                params.nil? ||
-                %w(index show create update destroy).include?(params[:action])
-      action = records.respond_to?(:to_ary) ? 'index' : 'show'
-      @request.send("setup_#{action}_action", params)
-    end
-
-    def result_options(records, options)
-      {}.tap do |data|
-        if JSONAPI.configuration.default_paginator != :none &&
-          JSONAPI.configuration.top_level_links_include_pagination
-          data[:pagination_params] = pagination_params(records, options)
-        end
-
-        if JSONAPI.configuration.top_level_meta_include_record_count
-          data[:record_count] = count_records(records, options)
-        end
-      end
-    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
-    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)
-        end
-    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) } : []
-    end
-
-    def turn_into_resource(record, options = {})
-      if options[:resource]
-        options[:resource].to_s.constantize.new(record, context)
-      else
-        @request.resource_klass.new(record, context)
-      end
-    end
-
-    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 apply_pagination(records, options = {})
-      return records unless apply_pagination?(options)
-      pagination = set_pagination(options)
-
-      records =
-        if records.is_a?(Array)
-          records[pagination[:range]]
-        else
-          pagination[:paginator].apply(records, nil)
-        end
-    end
-
-    def apply_sort(records)
-      return records unless params[:sort].present?
-
-      if records.is_a?(Array)
-        records.sort { |a, b| comp = 0; eval(sort_criteria) }
-      elsif records.respond_to?(:order)
-        records.order(sort_params)
-      end
-    end
-
-    def sort_criteria
-      sort_params.reduce('') do |sum, hash|
-        foo = ["a[:#{hash[0]}]", "b[:#{hash[0]}]"]
-        foo.reverse! if hash[1] == :desc
-        sum + "comp = comp == 0 ? #{foo.join(' <=> ')} : comp; "
-      end
-    end
-
-    def set_pagination(options)
-      page_params = ActionController::Parameters.new(@request.params[:page])
-      if JSONAPI.configuration.default_paginator == :paged
-        @_paginator ||= PagedPaginator.new(page_params)
-        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)
-        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
-        {}
-      end
-    end
-
-    def apply_pagination?(options)
-      JSONAPI.configuration.default_paginator != :none &&
-        (options[:paginate].nil? || options[:paginate])
-    end
-
-    def hash_to_active_record(data, model)
-      return data if model.nil?
-      coerced = [data].flatten.map { |hash| model.new(hash) }
-      data.is_a?(Array) ? coerced : coerced.first
-    rescue ActiveRecord::UnknownAttributeError
-      if data.is_a?(Array)
-        ids = data.map { |e| e[:id] }
-        model.where(id: ids)
-      else
-        model.find_by(id: data[:id])
-      end
-    end
-
-    def count_records(records, options)
-      if options[:count].present?
-        options[:count]
-      elsif records.is_a?(Array)
-        records.length
-      else
-        records = apply_filter(records, options) if params[:filter].present?
-        records.except(:group, :order).count("DISTINCT #{records.table.name}.id")
-      end
-    end
-
-    def setup_request
-      @request ||=
-        JSONAPI::Request.new(
-          params,
-          context: context,
-          key_formatter: key_formatter,
-          server_error_callbacks: (self.class.server_error_callbacks || [])
-        )
-    end
-
-    def check_request
-      @request.errors.blank? || render_errors(@request.errors)
-    end
   end
 end

data/lib/jsonapi/utils/exceptions.rb

@@ -1,25 +1,52 @@
 require 'jsonapi/utils/version'
 
-module JSONAPI::Utils::Exceptions
-  class BadRequest < ::JSONAPI::Exceptions::Error
-    def code; 400 end
+module JSONAPI
+  module Utils
+    module Exceptions
+      class ActiveRecord < ::JSONAPI::Exceptions::Error
+        attr_accessor :object
 
-    def errors
-      [JSONAPI::Error.new(code: 400,
-                          status: :bad_request,
-                          title: 'Bad Request',
-                          detail: 'This request is not supported.')]
-    end
-  end
+        def initialize(object)
+          @object = object
+        end
+
+        def errors
+          object.errors.keys.map do |key|
+            JSONAPI::Error.new(
+              code: JSONAPI::VALIDATION_ERROR,
+              status: :unprocessable_entity,
+              id: key,
+              title: object.errors.full_messages_for(key).first
+            )
+          end
+        end
+      end
+
+      class BadRequest < ::JSONAPI::Exceptions::Error
+        def code; '400' end
+
+        def errors
+          [JSONAPI::Error.new(
+              code: code,
+              status: :bad_request,
+              title: 'Bad Request',
+              detail: 'This request is not supported.'
+            )]
+        end
+      end
 
-  class InternalServerError < ::JSONAPI::Exceptions::Error
-    def code; 500 end
+      class InternalServerError < ::JSONAPI::Exceptions::Error
+        def code; '500' end
 
-    def errors
-      [JSONAPI::Error.new(code: 500,
-                          status: :internal_server_error,
-                          title: 'Internal Server Error',
-                          detail: 'An internal error ocurred while processing the request.')]
+        def errors
+          [JSONAPI::Error.new(
+            code: code,
+            status: :internal_server_error,
+            title: 'Internal Server Error',
+            detail: 'An internal error ocurred while processing the request.'
+          )]
+        end
+      end
     end
   end
 end

data/lib/jsonapi/utils/request.rb

@@ -0,0 +1,19 @@
+module JSONAPI
+  module Utils
+    module Request
+      def setup_request
+        @request ||=
+          JSONAPI::Request.new(
+            params,
+            context: context,
+            key_formatter: key_formatter,
+            server_error_callbacks: (self.class.server_error_callbacks || [])
+          )
+      end
+
+      def check_request
+        @request.errors.blank? || jsonapi_render_errors(json: @request)
+      end
+    end
+  end
+end

data/lib/jsonapi/utils/response.rb

@@ -0,0 +1,13 @@
+require 'jsonapi/utils/response/formatters'
+require 'jsonapi/utils/response/renders'
+require 'jsonapi/utils/response/support'
+
+module JSONAPI
+  module Utils
+    module Response
+      include Renders
+      include Formatters
+      include Support
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+module JSONAPI
+  module Utils
+    module Response
+      module Formatters
+        def jsonapi_format(records, options = {})
+          if records.is_a?(Hash)
+            hash    = records.with_indifferent_access
+            records = hash_to_active_record(hash[:data], options[:model])
+          end
+          fix_request_options(params, records)
+          build_response_document(records, options).contents
+        end
+
+        alias_method :jsonapi_serialize, :jsonapi_format
+
+        def jsonapi_format_errors(data)
+          data   = JSONAPI::Utils::Exceptions::ActiveRecord.new(data) if data.is_a?(ActiveRecord::Base)
+          errors = data.respond_to?(:errors) ? data.errors : data
+          JSONAPI::Utils::Support::Error.sanitize(errors).uniq
+        end
+
+        protected
+
+        def build_response_document(records, options)
+          results = JSONAPI::OperationResults.new
+
+          if records.respond_to?(:to_ary)
+            @_records = build_collection(records, options)
+            results.add_result(JSONAPI::ResourcesOperationResult.new(:ok, @_records, result_options(records, options)))
+          else
+            @_record = turn_into_resource(records, options)
+            results.add_result(JSONAPI::ResourceOperationResult.new(:ok, @_record))
+          end
+
+          @_response_document = create_response_document(results)
+        end
+
+        def fix_request_options(params, records)
+          return if request.method !~ /get/i ||
+                    params.nil? ||
+                    %w(index show create update destroy).include?(params[:action])
+          action = records.respond_to?(:to_ary) ? 'index' : 'show'
+          @request.send("setup_#{action}_action", params)
+        end
+
+        def result_options(records, options)
+          {}.tap do |data|
+            if JSONAPI.configuration.default_paginator != :none &&
+              JSONAPI.configuration.top_level_links_include_pagination
+              data[:pagination_params] = pagination_params(records, options)
+            end
+
+            if JSONAPI.configuration.top_level_meta_include_record_count
+              data[:record_count] = count_records(records, options)
+            end
+          end
+        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) } : []
+        end
+
+        def turn_into_resource(record, options = {})
+          if options[:resource]
+            options[:resource].to_s.constantize.new(record, context)
+          else
+            @request.resource_klass.new(record, context)
+          end
+        end
+
+        def hash_to_active_record(data, model)
+          return data if model.nil?
+          coerced = [data].flatten.map { |hash| model.new(hash) }
+          data.is_a?(Array) ? coerced : coerced.first
+        rescue ActiveRecord::UnknownAttributeError
+          if data.is_a?(Array)
+            ids = data.map { |e| e[:id] }
+            model.where(id: ids)
+          else
+            model.find_by(id: data[:id])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module JSONAPI
+  module Utils
+    module Response
+      module Renders
+        def jsonapi_render(json:, status: nil, options: {})
+          body = jsonapi_format(json, options)
+          render json: body, status: status || @_response_document.status
+        rescue => e
+          handle_exceptions(e)
+        ensure
+          correct_media_type
+        end
+
+        def jsonapi_render_errors(exception = nil, json: nil, status: nil)
+          body   = jsonapi_format_errors(exception || json)
+          status = status || body.try(:first).try(:[], :status)
+          render json: { errors: body }, status: status
+        ensure
+          correct_media_type
+        end
+
+        def jsonapi_render_internal_server_error
+          jsonapi_render_errors(::JSONAPI::Utils::Exceptions::InternalServerError.new)
+        end
+
+        def jsonapi_render_bad_request
+          jsonapi_render_errors(::JSONAPI::Utils::Exceptions::BadRequest.new)
+        end
+
+        def jsonapi_render_not_found(exception)
+          id = exception.message.match(/=([\w-]+)/).try(:[], 1) || '(no identifier)'
+          jsonapi_render_errors(JSONAPI::Exceptions::RecordNotFound.new(id))
+        end
+
+        def jsonapi_render_not_found_with_null
+          render json: { data: nil }, status: 200
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'jsonapi/utils/support/filter'
+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::Pagination
+        include ::JSONAPI::Utils::Support::Sort
+
+        protected
+
+        def correct_media_type
+          if response.body.size > 0
+            response.headers['Content-Type'] = JSONAPI::MEDIA_TYPE
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module JSONAPI
+  module Utils
+    module Support
+      module Error
+        MEMBERS = %i(title detail id code source links status meta)
+
+        module_function
+
+        def sanitize(errors)
+          Array(errors).map do |error|
+            MEMBERS.reduce({}) do |sum, key|
+              value = error.try(key) || error.try(:[], key)
+              if value.nil?
+                sum
+              else
+                value = value.to_s if key == :code
+                sum.merge(key => value)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+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 ||=
+            if params[:filter].is_a?(Hash)
+              params[:filter].keys.each_with_object({}) do |resource, hash|
+                hash[resource] = params[:filter][resource]
+              end
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+module JSONAPI
+  module Utils
+    module Support
+      module Pagination
+        def apply_pagination(records, options = {})
+          return records unless apply_pagination?(options)
+          pagination = set_pagination(options)
+
+          records =
+            if records.is_a?(Array)
+              records[pagination[:range]]
+            else
+              pagination[:paginator].apply(records, nil)
+            end
+        end
+
+        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
+        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)
+            end
+        end
+
+        def set_pagination(options)
+          page_params = ActionController::Parameters.new(@request.params[:page])
+          if JSONAPI.configuration.default_paginator == :paged
+            @_paginator ||= PagedPaginator.new(page_params)
+            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)
+            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
+            {}
+          end
+        end
+
+        def count_records(records, options)
+          if options[:count].present?
+            options[:count]
+          elsif records.is_a?(Array)
+            records.length
+          else
+            records = apply_filter(records, options) if params[:filter].present?
+            records.except(:group, :order).count("DISTINCT #{records.table.name}.id")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module JSONAPI
+  module Utils
+    module Support
+      module Sort
+        def apply_sort(records)
+          return records unless params[:sort].present?
+
+          if records.is_a?(Array)
+            records.sort { |a, b| comp = 0; eval(sort_criteria) }
+          elsif records.respond_to?(:order)
+            records.order(sort_params)
+          end
+        end
+
+        def sort_criteria
+          sort_params.reduce('') do |sum, hash|
+            foo = ["a[:#{hash[0]}]", "b[:#{hash[0]}]"]
+            foo.reverse! if hash[1] == :desc
+            sum + "comp = comp == 0 ? #{foo.join(' <=> ')} : comp; "
+          end
+        end
+
+        def sort_params
+          @_sort_params ||=
+            if params[:sort].present?
+              params[:sort].split(',').each_with_object({}) do |criteria, hash|
+                order, field = criteria.match(/(\-?)(\w+)/i)[1..2]
+                hash[field]  = order == '-' ? :desc : :asc
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/utils/version.rb

@@ -1,5 +1,5 @@
 module JSONAPI
   module Utils
-    VERSION = '0.4.4'
+    VERSION = '0.4.5'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-utils
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.5
 platform: ruby
 authors:
 - Tiago Guedes
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-05-24 00:00:00.000000000 Z
+date: 2016-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonapi-resources
@@ -139,6 +139,15 @@ files:
 - 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/support/error.rb
+- lib/jsonapi/utils/support/filter.rb
+- lib/jsonapi/utils/support/pagination.rb
+- lib/jsonapi/utils/support/sort.rb
 - lib/jsonapi/utils/version.rb
 homepage: https://github.com/b2beauty/jsonapi-utils
 licenses: