Merge remote-tracking branch 'upstream/master'

* upstream/master:
  Conditionally include controller mixin (jsonapi-rb#40)
  Add initializer generator. (jsonapi-rb#39)
  Add ActiveSupport::Notifications instrumentation. (jsonapi-rb#41)
  Add library configuration object (jsonapi-rb#17)
  Rename JSONAPI::Rails::ActionController to JSONAPI::Rails::Controller. (jsonapi-rb#38)
  Add hook for default jsonapi object. (jsonapi-rb#37)
  Add hook for default exposures. (jsonapi-rb#36)
  Add hook for automatic pagination links. (jsonapi-rb#35)
  Upgrade to new jsonapi-deserializable version. (jsonapi-rb#34)
  Prepare for v0.2.1 release

Author: Michael Deutsch

VERSION

@@ -1 +1 @@
-0.1.2
+0.2.1

jsonapi-rails.gemspec

@@ -14,7 +14,8 @@ Gem::Specification.new do |spec|
   spec.files         = Dir['README.md', 'lib/**/*']
   spec.require_path  = 'lib'
 
-  spec.add_dependency 'jsonapi-rb', '~> 0.2.1'
+  spec.add_dependency 'jsonapi-rb', '~> 0.3.0'
+  spec.add_dependency 'jsonapi-parser', '~> 0.1.0'
 
   spec.add_development_dependency 'rails', '~> 5.0'
   spec.add_development_dependency 'sqlite3'

lib/generators/jsonapi/initializer/USAGE

@@ -0,0 +1,5 @@
+Description:
+    Generates an initializer for jsonapi-rails.
+
+Example:
+    `rails generate jsonapi:initializer`

lib/generators/jsonapi/initializer/initializer_generator.rb

@@ -0,0 +1,7 @@
+class InitializerGenerator < Rails::Generators::Base
+  source_root File.expand_path('../templates', __FILE__)
+
+  def copy_initializer_file
+    copy_file 'initializer.rb', 'config/initializers/jsonapi.rb'
+  end
+end

lib/generators/jsonapi/initializer/templates/initializer.rb

@@ -0,0 +1,6 @@
+JSONAPI::Rails.configure do |config|
+  # config.register_mime_type = true
+  # config.register_param_parser = true
+  # config.register_renderers = true
+  # config.extend_action_controller = true
+end

lib/jsonapi/rails/action_controller.rb

@@ -5,10 +5,11 @@ class Configuration < ActiveSupport::InheritableOptions; end
     DEFAULT_CONFIG = {
       register_parameter_parser: true,
       register_mime_type: true,
-      register_renderers: true
+      register_renderers: true,
+      extend_action_controller: true
     }.freeze
 
-    def self.configure(&block)
+    def self.configure
       yield config
     end
 

lib/jsonapi/rails/configuration.rb

@@ -0,0 +1,68 @@
+require 'jsonapi/deserializable'
+require 'jsonapi/parser'
+
+module JSONAPI
+  module Rails
+    module Deserializable
+      class Resource < JSONAPI::Deserializable::Resource
+        id
+        type
+        attributes
+        has_one do |_rel, id, type, key|
+          type = type.to_s.singularize.camelize
+          { "#{key}_id".to_sym => id, "#{key}_type".to_sym => type }
+        end
+        has_many do |_rel, ids, types, key|
+          key   = key.to_s.singularize
+          types = types.map { |t| t.to_s.singularize.camelize }
+          { "#{key}_ids".to_sym => ids, "#{key}_types".to_sym => types }
+        end
+      end
+    end
+
+    module Controller
+      extend ActiveSupport::Concern
+
+      JSONAPI_POINTERS_KEY = 'jsonapi_deserializable.jsonapi_pointers'.freeze
+
+      class_methods do
+        def deserializable_resource(key, options = {}, &block)
+          options = options.dup
+          klass = options.delete(:class) ||
+                  Class.new(JSONAPI::Rails::Deserializable::Resource, &block)
+
+          before_action(options) do |controller|
+            hash = controller.params[:_jsonapi].to_unsafe_hash
+            ActiveSupport::Notifications.instrument('parse.jsonapi',
+                                                    payload: hash,
+                                                    class: klass) do
+              JSONAPI::Parser::Resource.parse!(hash)
+              resource = klass.new(hash[:data])
+              controller.request.env[JSONAPI_POINTERS_KEY] =
+                resource.reverse_mapping
+              controller.params[key.to_sym] = resource.to_hash
+            end
+          end
+        end
+      end
+
+      def jsonapi_object
+        nil
+      end
+
+      def jsonapi_expose
+        {
+          url_helpers: ::Rails.application.routes.url_helpers
+        }
+      end
+
+      def jsonapi_pagination(_collection)
+        nil
+      end
+
+      def jsonapi_pointers
+        request.env[JSONAPI_POINTERS_KEY]
+      end
+    end
+  end
+end

lib/jsonapi/rails/controller.rb

@@ -4,6 +4,7 @@
 require 'active_model'
 
 require 'jsonapi/rails/configuration'
+require 'jsonapi/rails/controller'
 require 'jsonapi/rails/parser'
 require 'jsonapi/rails/renderer'
 
@@ -16,51 +17,38 @@ class Railtie < ::Rails::Railtie
         jsonapi_error: ErrorsRenderer.new
       }.freeze
 
-      initializer 'jsonapi-rails.action_controller' do
-        ActiveSupport.on_load(:action_controller) do
-          require 'jsonapi/rails/action_controller'
-          include ::JSONAPI::Rails::ActionController
-
-          if JSONAPI::Rails.config.register_mime_type
-            Mime::Type.register MEDIA_TYPE, :jsonapi
-          end
+      initializer 'jsonapi.init', after: :load_config_initializers do
+        if JSONAPI::Rails.config.register_mime_type
+          Mime::Type.register MEDIA_TYPE, :jsonapi
+        end
 
-          if JSONAPI::Rails.config.register_parameter_parser
-            if ::Rails::VERSION::MAJOR >= 5
-              ::ActionDispatch::Request.parameter_parsers[:jsonapi] = PARSER
-            else
-              ::ActionDispatch::ParamsParser::DEFAULT_PARSERS[Mime[:jsonapi]] = PARSER
-            end
+        if JSONAPI::Rails.config.register_parameter_parser
+          if ::Rails::VERSION::MAJOR >= 5
+            ::ActionDispatch::Request.parameter_parsers[:jsonapi] = PARSER
+          else
+            ::ActionDispatch::ParamsParser::DEFAULT_PARSERS[Mime[:jsonapi]] = PARSER
           end
+        end
 
-          if JSONAPI::Rails.config.register_renderers
-            ::ActionController::Renderers.add(:jsonapi) do |resources, options|
-              self.content_type ||= Mime[:jsonapi]
-
-              RENDERERS[:jsonapi].render(resources, options).to_json
-            end
-
-            ::ActionController::Renderers.add(:jsonapi_error) do |errors, options|
-              # Renderer proc is evaluated in the controller context, so it
-              # has access to the jsonapi_pointers method.
-              options = options.merge(_jsonapi_pointers: jsonapi_pointers)
-              self.content_type ||= Mime[:jsonapi]
-
-              RENDERERS[:jsonapi_error].render(errors, options).to_json
-            end
+        if JSONAPI::Rails.config.extend_action_controller
+          ActiveSupport.on_load(:action_controller) do
+            include ::JSONAPI::Rails::Controller
           end
+        end
 
-          JSONAPI::Deserializable::Resource.configure do |config|
-            config.default_has_one do |key, _rel, id, type|
-              key  = key.to_s.singularize
-              type = type.to_s.singularize.camelize
-              { "#{key}_id".to_sym => id, "#{key}_type".to_sym => type }
-            end
-
-            config.default_has_many do |key, _rel, ids, types|
-              key   = key.to_s.singularize
-              types = types.map { |t| t.to_s.singularize.camelize }
-              { "#{key}_ids".to_sym => ids, "#{key}_types".to_sym => types }
+        if JSONAPI::Rails.config.register_renderers
+          ActiveSupport.on_load(:action_controller) do
+            RENDERERS.each do |name, renderer|
+              ::ActionController::Renderers.add(name) do |resources, options|
+                # Renderer proc is evaluated in the controller context.
+                self.content_type ||= Mime[:jsonapi]
+
+                ActiveSupport::Notifications.instrument('render.jsonapi',
+                                                        resources: resources,
+                                                        options: options) do
+                  renderer.render(resources, options, self).to_json
+                end
+              end
             end
           end
         end

lib/jsonapi/rails/railtie.rb

@@ -10,16 +10,18 @@ def initialize(renderer = JSONAPI::Serializable::SuccessRenderer.new)
         freeze
       end
 
-      def render(resources, options)
-        opts = options.dup
-        # TODO(beauby): Move this to a global configuration.
-        default_exposures = {
-          url_helpers: ::Rails.application.routes.url_helpers
-        }
-        opts[:expose] = default_exposures.merge!(opts[:expose] || {})
-        opts[:jsonapi] = opts.delete(:jsonapi_object)
-
-        @renderer.render(resources, opts)
+      def render(resources, options, controller)
+        options = options.dup
+
+        if (pagination_links = controller.jsonapi_pagination(resources))
+          (options[:links] ||= {}).merge!(pagination_links)
+        end
+        options[:expose]  =
+          controller.jsonapi_expose.merge!(options[:expose] || {})
+        options[:jsonapi] =
+          options[:jsonapi_object] || controller.jsonapi_object
+
+        @renderer.render(resources, options)
       end
     end
 
@@ -30,21 +32,10 @@ def initialize(renderer = JSONAPI::Serializable::ErrorsRenderer.new)
         freeze
       end
 
-      def render(errors, options)
-        errors = [errors] unless errors.is_a?(Array)
-        errors = errors.flat_map do |error|
-          if error.respond_to?(:as_jsonapi)
-            error
-          elsif error.is_a?(ActiveModel::Errors)
-            ActiveModelError.from_errors(error, options[:_jsonapi_pointers]).to_a
-          elsif error.is_a?(Hash)
-            JSONAPI::Serializable::Error.create(error)
-          else
-            raise # TODO(lucas): Raise meaningful exception.
-          end
-        end
-
+      def render(errors, options, controller)
+        options = options.merge(_jsonapi_pointers: controller.jsonapi_pointers)
         # TODO(beauby): SerializableError inference on AR validation errors.
+
         @renderer.render(errors, options)
       end
     end