jsonapi.rb 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f77c3754e421d90a87ea1b4e29d0a93684491c7b856358544e7d284e016f1e2
-  data.tar.gz: b2fc4ffb3a75a0dde01133af68e2993cc96ee4404adc5d7ffae49c97d15b0532
+  metadata.gz: 4c76a1e2a0107283282044d238d2926cf55e0722a0a4fe263035af40f30a8da8
+  data.tar.gz: c178cbd58f5d842400db948830eca9f5a784d3ade02bce30f048484e0d5d2178
 SHA512:
-  metadata.gz: 36eaed17ff71ecb1dbf2d78cdf80cde3d3f310a1540c62972c675430a5800cc555fc6b2cc00bd83044b5734782e7c8dea94cd9f8dd50efe29d1abfed5cb6f6d1
-  data.tar.gz: 3f6cd094ffad9b139329da5628ff68e53bccef6eba51b73f720fba402dccd9f84eae8fa3a9572f78b50dd33ad1cbd49a1f2d5816450fe58855fa2cf2b509078b
+  metadata.gz: 104169038398545873c56698b765ad9f7c91f4694c61568531ea82d5315c395956e3548ec769df03c7d3b01ade8a1966916a324af3b2a236d1afd237d81c1908
+  data.tar.gz: 39bbeb7ae0205139c41a6ba5010369694cbb1d0d9ca902a5830a7e911d3e0ca6945879aa370bf64d44322bfd8971d9b88328d1b97c29e9d68029eb9544aa7ef8

data/.gitignore

@@ -1 +1,2 @@
 coverage
+pkg

data/Gemfile.lock

@@ -8,7 +8,7 @@ GIT
 PATH
   remote: .
   specs:
-    jsonapi.rb (1.1.0)
+    jsonapi.rb (1.1.1)
       fast_jsonapi (~> 1.5)
       ransack (~> 2.1)
 

data/jsonapi.rb.gemspec

@@ -1,4 +1,4 @@
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require 'jsonapi/version'

data/lib/jsonapi/errors.rb

@@ -1,45 +1,47 @@
 require 'net/http/status'
 require 'active_support/concern'
 
-# Helpers to handle some error responses
-#
-# Most of the exceptions are handled in Rails by [ActionDispatch] middleware
-# See: https://api.rubyonrails.org/classes/ActionDispatch/ExceptionWrapper.html
-module JSONAPI::Errors
-  extend ActiveSupport::Concern
+module JSONAPI
+  # Helpers to handle some error responses
+  #
+  # Most of the exceptions are handled in Rails by [ActionDispatch] middleware
+  # See: https://api.rubyonrails.org/classes/ActionDispatch/ExceptionWrapper.html
+  module Errors
+    extend ActiveSupport::Concern
 
-  included do
-    rescue_from StandardError do |exception|
-      error = { status: '500', title: Net::HTTP::STATUS_CODES[500] }
-      render jsonapi_errors: [error], status: :internal_server_error
-    end
+    included do
+      rescue_from StandardError do |exception|
+        error = { status: '500', title: Net::HTTP::STATUS_CODES[500] }
+        render jsonapi_errors: [error], status: :internal_server_error
+      end
 
-    [
-      ActiveRecord::RecordNotFound
-    ].each do |exception_class|
-      rescue_from exception_class do |exception|
-        error = { status: '404', title: Net::HTTP::STATUS_CODES[404] }
-        render jsonapi_errors: [error], status: :not_found
+      [
+        ActiveRecord::RecordNotFound
+      ].each do |exception_class|
+        rescue_from exception_class do |exception|
+          error = { status: '404', title: Net::HTTP::STATUS_CODES[404] }
+          render jsonapi_errors: [error], status: :not_found
+        end
       end
-    end
 
-    [
-      ActionController::ParameterMissing
-    ].each do |exception_class|
-      rescue_from exception_class do |exception|
-        source = { pointer: '' }
+      [
+        ActionController::ParameterMissing
+      ].each do |exception_class|
+        rescue_from exception_class do |exception|
+          source = { pointer: '' }
 
-        if !%w{data attributes relationships}.include?(exception.param.to_s)
-          source[:pointer] = "/data/attributes/#{exception.param}"
-        end
+          if !%w{data attributes relationships}.include?(exception.param.to_s)
+            source[:pointer] = "/data/attributes/#{exception.param}"
+          end
 
-        error = {
-          status: '422',
-          title: Net::HTTP::STATUS_CODES[422],
-          source: source
-        }
+          error = {
+            status: '422',
+            title: Net::HTTP::STATUS_CODES[422],
+            source: source
+          }
 
-        render jsonapi_errors: [error], status: :unprocessable_entity
+          render jsonapi_errors: [error], status: :unprocessable_entity
+        end
       end
     end
   end

data/lib/jsonapi/fetching.rb

@@ -1,26 +1,28 @@
-# Inclusion and sparse fields support
-module JSONAPI::Fetching
-  private
+module JSONAPI
+  # Inclusion and sparse fields support
+  module Fetching
+    private
 
-  # Extracts and formats sparse fieldsets
-  #
-  # Ex.: `GET /resource?fields[relationship]=id,created_at`
-  #
-  # @return [Hash]
-  def jsonapi_fields
-    ActiveSupport::HashWithIndifferentAccess.new.tap do |h|
-      (params[:fields] || []).each do |k, v|
-        h[k] = v.split(',').map(&:strip).compact
+    # Extracts and formats sparse fieldsets
+    #
+    # Ex.: `GET /resource?fields[relationship]=id,created_at`
+    #
+    # @return [Hash]
+    def jsonapi_fields
+      ActiveSupport::HashWithIndifferentAccess.new.tap do |h|
+        (params[:fields] || []).each do |k, v|
+          h[k] = v.split(',').map(&:strip).compact
+        end
       end
     end
-  end
 
-  # Extracts and whitelists allowed includes
-  #
-  # Ex.: `GET /resource?include=relationship,relationship.subrelationship`
-  #
-  # @return [Array]
-  def jsonapi_include
-    params['include'].to_s.split(',').map(&:strip).compact
+    # Extracts and whitelists allowed includes
+    #
+    # Ex.: `GET /resource?include=relationship,relationship.subrelationship`
+    #
+    # @return [Array]
+    def jsonapi_include
+      params['include'].to_s.split(',').map(&:strip).compact
+    end
   end
 end

data/lib/jsonapi/filtering.rb

@@ -1,73 +1,75 @@
 require 'ransack/predicate'
 
 # Filtering and sorting support
-module JSONAPI::Filtering
-  private
+module JSONAPI
+  module Filtering
+    private
 
-  # Applies filtering and sorting to a set of resources if requested
-  #
-  # The fields follow [Ransack] specifications.
-  # See: https://github.com/activerecord-hackery/ransack#search-matchers
-  #
-  # Ex.: `GET /resource?filter[region_matches_any]=Lisb%&sort=-created_at,id`
-  #
-  # @param allowed_fields [Array] a list of allowed fields to be filtered
-  # @return [ActiveRecord::Base] a collection of resources
-  def jsonapi_filter(resources, allowed_fields)
-    extracted_params = jsonapi_filter_params(allowed_fields)
-    extracted_params[:sorts] = jsonapi_sort_params(allowed_fields)
-    resources = resources.ransack(extracted_params)
-    block_given? ? yield(resources) : resources
-  end
+    # Applies filtering and sorting to a set of resources if requested
+    #
+    # The fields follow [Ransack] specifications.
+    # See: https://github.com/activerecord-hackery/ransack#search-matchers
+    #
+    # Ex.: `GET /resource?filter[region_matches_any]=Lisb%&sort=-created_at,id`
+    #
+    # @param allowed_fields [Array] a list of allowed fields to be filtered
+    # @return [ActiveRecord::Base] a collection of resources
+    def jsonapi_filter(resources, allowed_fields)
+      extracted_params = jsonapi_filter_params(allowed_fields)
+      extracted_params[:sorts] = jsonapi_sort_params(allowed_fields)
+      resources = resources.ransack(extracted_params)
+      block_given? ? yield(resources) : resources
+    end
 
-  # Extracts and whitelists allowed fields to be filtered
-  #
-  # The fields follow [Ransack] specifications.
-  # See: https://github.com/activerecord-hackery/ransack#search-matchers
-  #
-  # @param allowed_fields [Array] a list of allowed fields to be filtered
-  # @return [Hash] to be passed to [ActiveRecord::Base#order]
-  def jsonapi_filter_params(allowed_fields)
-    filtered = {}
-    requested = params[:filter] || {}
-    allowed_fields = allowed_fields.map(&:to_s)
+    # Extracts and whitelists allowed fields to be filtered
+    #
+    # The fields follow [Ransack] specifications.
+    # See: https://github.com/activerecord-hackery/ransack#search-matchers
+    #
+    # @param allowed_fields [Array] a list of allowed fields to be filtered
+    # @return [Hash] to be passed to [ActiveRecord::Base#order]
+    def jsonapi_filter_params(allowed_fields)
+      filtered = {}
+      requested = params[:filter] || {}
+      allowed_fields = allowed_fields.map(&:to_s)
 
-    requested.each_pair do |requested_field, to_filter|
-      field_name = requested_field.dup
-      predicate = Ransack::Predicate.detect_and_strip_from_string!(field_name)
-      predicate = Ransack::Predicate.named(predicate)
+      requested.each_pair do |requested_field, to_filter|
+        field_name = requested_field.dup
+        predicate = Ransack::Predicate.detect_and_strip_from_string!(field_name)
+        predicate = Ransack::Predicate.named(predicate)
 
-      field_names = field_name.split(/_and_|_or_/)
+        field_names = field_name.split(/_and_|_or_/)
 
-      if to_filter.is_a?(String) && to_filter.include?(',')
-        to_filter = to_filter.split(',')
-      end
+        if to_filter.is_a?(String) && to_filter.include?(',')
+          to_filter = to_filter.split(',')
+        end
 
-      if predicate && (field_names - allowed_fields).empty?
-        filtered[requested_field] = to_filter
+        if predicate && (field_names - allowed_fields).empty?
+          filtered[requested_field] = to_filter
+        end
       end
-    end
 
-    filtered
-  end
-
-  # Extracts and whitelists allowed fields to be sorted
-  #
-  # @param allowed_fields [Array] a list of allowed fields to be sorted
-  # @return [Hash] to be passed to [ActiveRecord::Base#order]
-  def jsonapi_sort_params(allowed_fields)
-    requested = params[:sort].to_s.split(',')
-    requested.map! do |requested_field|
-      desc = requested_field.to_s.start_with?('-')
-      [
-        desc ? requested_field[1..-1] : requested_field,
-        desc ? 'desc' : 'asc'
-      ]
+      filtered
     end
 
-    # Convert to strings instead of hashes to allow joined table columns.
-    requested.to_h.slice(*allowed_fields.map(&:to_s)).map do |field, dir|
-      [field, dir].join(' ')
+    # Extracts and whitelists allowed fields to be sorted
+    #
+    # @param allowed_fields [Array] a list of allowed fields to be sorted
+    # @return [Hash] to be passed to [ActiveRecord::Base#order]
+    def jsonapi_sort_params(allowed_fields)
+      requested = params[:sort].to_s.split(',')
+      requested.map! do |requested_field|
+        desc = requested_field.to_s.start_with?('-')
+        [
+          desc ? requested_field[1..-1] : requested_field,
+          desc ? 'desc' : 'asc'
+        ]
+      end
+
+      # Convert to strings instead of hashes to allow joined table columns.
+      requested.to_h.slice(*allowed_fields.map(&:to_s)).map do |field, dir|
+        [field, dir].join(' ')
+      end
     end
   end
 end

data/lib/jsonapi/pagination.rb

@@ -1,91 +1,93 @@
-# Pagination support
-module JSONAPI::Pagination
-  private
-
-  # Default number of items per page.
-  JSONAPI_PAGE_SIZE = 30
-
-  # Applies pagination to a set of resources
-  #
-  # Ex.: `GET /resource?page[number]=2&page[size]=10`
-  #
-  # @return [ActiveRecord::Base] a collection of resources
-  def jsonapi_paginate(resources)
-    offset, limit, _ = jsonapi_pagination_params
-
-    if resources.respond_to?(:offset)
-      resources = resources.offset(offset).limit(limit)
-    else
-      resources = resources[(offset)..(offset + limit)]
+module JSONAPI
+  # Pagination support
+  module Pagination
+    private
+
+    # Default number of items per page.
+    JSONAPI_PAGE_SIZE = 30
+
+    # Applies pagination to a set of resources
+    #
+    # Ex.: `GET /resource?page[number]=2&page[size]=10`
+    #
+    # @return [ActiveRecord::Base] a collection of resources
+    def jsonapi_paginate(resources)
+      offset, limit, _ = jsonapi_pagination_params
+
+      if resources.respond_to?(:offset)
+        resources = resources.offset(offset).limit(limit)
+      else
+        resources = resources[(offset)..(offset + limit)]
+      end
+
+      block_given? ? yield(resources) : resources
     end
 
-    block_given? ? yield(resources) : resources
-  end
+    # Generates the pagination links
+    #
+    # @return [Array]
+    def jsonapi_pagination(resources)
+      links = { self: request.base_url + request.original_fullpath }
+      pagination = jsonapi_pagination_meta(resources)
 
-  # Generates the pagination links
-  #
-  # @return [Array]
-  def jsonapi_pagination(resources)
-    links = { self: request.base_url + request.original_fullpath }
-    pagination = jsonapi_pagination_meta(resources)
+      return links if pagination.blank?
 
-    return links if pagination.blank?
+      original_params = params.except(
+        *request.path_parameters.keys.map(&:to_s)).to_unsafe_h
+      original_params[:page] ||= {}
+      original_url = request.base_url + request.path + '?'
 
-    original_params = params.except(
-      *request.path_parameters.keys.map(&:to_s)).to_unsafe_h
-    original_params[:page] ||= {}
-    original_url = request.base_url + request.path + '?'
+      pagination.each do |page_name, number|
+        original_params[:page][:number] = number
+        links[page_name] = original_url + CGI.unescape(original_params.to_query)
+      end
 
-    pagination.each do |page_name, number|
-      original_params[:page][:number] = number
-      links[page_name] = original_url + CGI.unescape(original_params.to_query)
+      links
     end
 
-    links
-  end
+    # Generates pagination numbers
+    #
+    # @return [Hash] with the first, previous, next, current and last page number
+    def jsonapi_pagination_meta(resources)
+      return {} unless JSONAPI::Rails.is_collection?(resources)
 
-  # Generates pagination numbers
-  #
-  # @return [Hash] with the first, previous, next, current and last page number
-  def jsonapi_pagination_meta(resources)
-    return {} unless JSONAPI::Rails.is_collection?(resources)
+      _, limit, page = jsonapi_pagination_params
 
-    _, limit, page = jsonapi_pagination_params
+      numbers = { current: page }
 
-    numbers = { current: page }
+      if resources.respond_to?(:unscope)
+        total = resources.unscope(:limit, :offset).count()
+      else
+        total = resources.size
+      end
 
-    if resources.respond_to?(:unscope)
-      total = resources.unscope(:limit, :offset).count()
-    else
-      total = resources.size
-    end
+      last_page = [1, (total.to_f / limit).ceil].max
 
-    last_page = [1, (total.to_f / limit).ceil].max
+      if page > 1
+        numbers[:first] = 1
+        numbers[:prev] = page - 1
+      end
 
-    if page > 1
-      numbers[:first] = 1
-      numbers[:prev] = page - 1
-    end
+      if page < last_page
+        numbers[:next] = page + 1
+        numbers[:last] = last_page
+      end
 
-    if page < last_page
-      numbers[:next] = page + 1
-      numbers[:last] = last_page
+      numbers
     end
 
-    numbers
-  end
-
-  # Extracts the pagination params
-  #
-  # @return [Array] with the offset, limit and the current page number
-  def jsonapi_pagination_params
-    def_per_page = self.class.const_get(:JSONAPI_PAGE_SIZE).to_i
+    # Extracts the pagination params
+    #
+    # @return [Array] with the offset, limit and the current page number
+    def jsonapi_pagination_params
+      def_per_page = self.class.const_get(:JSONAPI_PAGE_SIZE).to_i
 
-    pagination = params[:page].try(:slice, :number, :size) || {}
-    per_page = (pagination[:size] || def_per_page).to_f.to_i
-    per_page = def_per_page if per_page > def_per_page
-    num = [1, pagination[:number].to_f.to_i].max
+      pagination = params[:page].try(:slice, :number, :size) || {}
+      per_page = (pagination[:size] || def_per_page).to_f.to_i
+      per_page = def_per_page if per_page > def_per_page
+      num = [1, pagination[:number].to_f.to_i].max
 
-    [(num - 1) * per_page, per_page, num]
+      [(num - 1) * per_page, per_page, num]
+    end
   end
 end

data/lib/jsonapi/rails.rb

@@ -2,97 +2,99 @@ require 'jsonapi/error_serializer'
 require 'jsonapi/active_model_error_serializer'
 
 # Rails integration
-module JSONAPI::Rails
-  # Updates the mime types and registers the renderers
-  #
-  # @return [NilClass]
-  def self.install!
-    return unless defined?(::Rails)
-
-    Mime::Type.register JSONAPI::MEDIA_TYPE, :jsonapi
-
-    # Map the JSON parser to the JSONAPI mime type requests.
-    if Rails::VERSION::MAJOR >= 5
-      parser = ActionDispatch::Request.parameter_parsers[:json]
-      ActionDispatch::Request.parameter_parsers[:jsonapi] = parser
-    else
-      parser = ActionDispatch::ParamsParser::DEFAULT_PARSERS[Mime[:json]]
-      ActionDispatch::ParamsParser::DEFAULT_PARSERS[Mime[:jsonapi]] = parser
-    end
+module JSONAPI
+  module Rails
+    # Updates the mime types and registers the renderers
+    #
+    # @return [NilClass]
+    def self.install!
+      return unless defined?(::Rails)
+
+      Mime::Type.register JSONAPI::MEDIA_TYPE, :jsonapi
+
+      # Map the JSON parser to the JSONAPI mime type requests.
+      if Rails::VERSION::MAJOR >= 5
+        parser = ActionDispatch::Request.parameter_parsers[:json]
+        ActionDispatch::Request.parameter_parsers[:jsonapi] = parser
+      else
+        parser = ActionDispatch::ParamsParser::DEFAULT_PARSERS[Mime[:json]]
+        ActionDispatch::ParamsParser::DEFAULT_PARSERS[Mime[:jsonapi]] = parser
+      end
 
-    self.add_renderer!
-    self.add_errors_renderer!
-  end
+      self.add_renderer!
+      self.add_errors_renderer!
+    end
 
-  # Adds the error renderer
-  #
-  # @return [NilClass]
-  def self.add_errors_renderer!
-    ActionController::Renderers.add(:jsonapi_errors) do |resource, options|
-      self.content_type ||= Mime[:jsonapi]
+    # Adds the error renderer
+    #
+    # @return [NilClass]
+    def self.add_errors_renderer!
+      ActionController::Renderers.add(:jsonapi_errors) do |resource, options|
+        self.content_type ||= Mime[:jsonapi]
 
-      resource = [resource] unless JSONAPI::Rails.is_collection?(resource)
+        resource = [resource] unless JSONAPI::Rails.is_collection?(resource)
 
-      return JSONAPI::ErrorSerializer.new(resource, options)
-        .serialized_json unless resource.is_a?(ActiveModel::Errors)
+        return JSONAPI::ErrorSerializer.new(resource, options)
+          .serialized_json unless resource.is_a?(ActiveModel::Errors)
 
-      errors = []
-      model = resource.marshal_dump.first
-      model_serializer = JSONAPI::Rails.serializer_class(model)
+        errors = []
+        model = resource.marshal_dump.first
+        model_serializer = JSONAPI::Rails.serializer_class(model)
 
-      resource.details.each do |error_key, error_hashes|
-        error_hashes.each do |error_hash|
-          errors << [ error_key, error_hash ]
+        resource.details.each do |error_key, error_hashes|
+          error_hashes.each do |error_hash|
+            errors << [ error_key, error_hash ]
+          end
         end
-      end
 
-      JSONAPI::ActiveModelErrorSerializer.new(
-        errors, params: { model: model, model_serializer: model_serializer }
-      ).serialized_json
+        JSONAPI::ActiveModelErrorSerializer.new(
+          errors, params: { model: model, model_serializer: model_serializer }
+        ).serialized_json
+      end
     end
-  end
 
-  # Adds the default renderer
-  #
-  # @return [NilClass]
-  def self.add_renderer!
-    ActionController::Renderers.add(:jsonapi) do |resource, options|
-      self.content_type ||= Mime[:jsonapi]
-
-      options[:meta] ||= (
-        jsonapi_meta(resource) if respond_to?(:jsonapi_meta, true))
-      options[:links] ||= (
-        jsonapi_pagination(resource) if respond_to?(:jsonapi_pagination, true))
-
-      # If it's an empty collection, return it directly.
-      if JSONAPI::Rails.is_collection?(resource) && !resource.any?
-        return options.slice(:meta, :links).merge(data: []).to_json
-      end
+    # Adds the default renderer
+    #
+    # @return [NilClass]
+    def self.add_renderer!
+      ActionController::Renderers.add(:jsonapi) do |resource, options|
+        self.content_type ||= Mime[:jsonapi]
+
+        options[:meta] ||= (
+          jsonapi_meta(resource) if respond_to?(:jsonapi_meta, true))
+        options[:links] ||= (
+          jsonapi_pagination(resource) if respond_to?(:jsonapi_pagination, true))
+
+        # If it's an empty collection, return it directly.
+        if JSONAPI::Rails.is_collection?(resource) && !resource.any?
+          return options.slice(:meta, :links).merge(data: []).to_json
+        end
 
-      options[:fields] ||= jsonapi_fields if respond_to?(:jsonapi_fields, true)
-      options[:include] ||= (
-        jsonapi_include if respond_to?(:jsonapi_include, true))
+        options[:fields] ||= jsonapi_fields if respond_to?(:jsonapi_fields, true)
+        options[:include] ||= (
+          jsonapi_include if respond_to?(:jsonapi_include, true))
 
-      serializer_class = JSONAPI::Rails.serializer_class(resource)
-      serializer_class.new(resource, options).serialized_json
+        serializer_class = JSONAPI::Rails.serializer_class(resource)
+        serializer_class.new(resource, options).serialized_json
+      end
     end
-  end
 
-  # Checks if an object is a collection
-  #
-  # @param object [Object] to check
-  # @return [TrueClass] upon success
-  def self.is_collection?(object)
-    object.is_a?(Enumerable) && !object.respond_to?(:each_pair)
-  end
+    # Checks if an object is a collection
+    #
+    # @param object [Object] to check
+    # @return [TrueClass] upon success
+    def self.is_collection?(object)
+      object.is_a?(Enumerable) && !object.respond_to?(:each_pair)
+    end
 
-  # Resolves resource serializer class
-  #
-  # @return [Class]
-  def self.serializer_class(resource)
-    klass = resource.class
-    klass = resource.first.class if self.is_collection?(resource)
+    # Resolves resource serializer class
+    #
+    # @return [Class]
+    def self.serializer_class(resource)
+      klass = resource.class
+      klass = resource.first.class if self.is_collection?(resource)
 
-    "#{klass.name}Serializer".constantize
+      "#{klass.name}Serializer".constantize
+    end
   end
 end

data/lib/jsonapi/version.rb

@@ -1,3 +1,3 @@
 module JSONAPI
-  VERSION = '1.1.0'
+  VERSION = '1.1.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi.rb
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Stas Suscov