Merge remote-tracking branch 'upstream/master'

* upstream/master:
  Improve specs (jsonapi-rb#33)
  Expose deserialization reverse mapping in controllers (jsonapi-rb#29)
  Update jsonapi-rb to v0.2.1. (jsonapi-rb#32)
  Add dummy app temp files to .gitignore (jsonapi-rb#30)
  Deal with jsonapi-serializable no longer calling to_json (jsonapi-rb#26)

Author: Michael Deutsch

jsonapi-rails.gemspec

@@ -14,11 +14,10 @@ Gem::Specification.new do |spec|
   spec.files         = Dir['README.md', 'lib/**/*']
   spec.require_path  = 'lib'
 
-  spec.add_dependency 'jsonapi-rb', '~> 0.1'
+  spec.add_dependency 'jsonapi-rb', '~> 0.2.1'
 
   spec.add_development_dependency 'rails', '~> 5.0'
   spec.add_development_dependency 'sqlite3'
   spec.add_development_dependency 'rake',        '~> 11.3'
   spec.add_development_dependency 'rspec-rails', '~> 3.5'
-  spec.add_development_dependency 'dry-validation', '~> 0.10'
 end

lib/jsonapi/rails/action_controller.rb

@@ -6,9 +6,9 @@ module Rails
     module ActionController
       extend ActiveSupport::Concern
 
-      REVERSE_MAPPING_KEY = 'jsonapi_deserializable.reverse_mapping'.freeze
+      JSONAPI_POINTERS_KEY = 'jsonapi_deserializable.jsonapi_pointers'.freeze
 
-      module ClassMethods
+      class_methods do
         def deserializable_resource(key, options = {}, &block)
           _deserializable(key, options,
                           JSONAPI::Deserializable::Resource, &block)
@@ -26,17 +26,14 @@ def _deserializable(key, options, fallback, &block)
 
           before_action(options) do |controller|
             resource = klass.new(controller.params[:_jsonapi].to_unsafe_hash)
-            controller.request.env[REVERSE_MAPPING_KEY] =
+            controller.request.env[JSONAPI_POINTERS_KEY] =
               resource.reverse_mapping
             controller.params[key.to_sym] = resource.to_hash
           end
         end
       end
-
-      private
-
       def jsonapi_pointers
-        request.env[REVERSE_MAPPING_KEY]
+        request.env[JSONAPI_POINTERS_KEY]
       end
     end
   end

lib/jsonapi/rails/railtie.rb

@@ -12,8 +12,8 @@ module Rails
     class Railtie < ::Rails::Railtie
       MEDIA_TYPE = 'application/vnd.api+json'.freeze
       RENDERERS = {
-        jsonapi:        JSONAPI::Rails.rails_renderer(SuccessRenderer),
-        jsonapi_errors: JSONAPI::Rails.rails_renderer(ErrorsRenderer)
+        jsonapi:       SuccessRenderer.new,
+        jsonapi_error: ErrorsRenderer.new
       }.freeze
 
       initializer 'jsonapi-rails.action_controller' do
@@ -34,8 +34,19 @@ class Railtie < ::Rails::Railtie
           end
 
           if JSONAPI::Rails.config.register_renderers
-            RENDERERS.each do |key, renderer|
-              ::ActionController::Renderers.add(key, &renderer)
+            ::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
           end
 

lib/jsonapi/rails/renderer.rb

@@ -4,7 +4,13 @@
 module JSONAPI
   module Rails
     class SuccessRenderer
-      def self.render(resources, options)
+      def initialize(renderer = JSONAPI::Serializable::SuccessRenderer.new)
+        @renderer = renderer
+
+        freeze
+      end
+
+      def render(resources, options)
         opts = options.dup
         # TODO(beauby): Move this to a global configuration.
         default_exposures = {
@@ -13,12 +19,18 @@ def self.render(resources, options)
         opts[:expose] = default_exposures.merge!(opts[:expose] || {})
         opts[:jsonapi] = opts.delete(:jsonapi_object)
 
-        JSONAPI::Serializable::Renderer.render(resources, opts)
+        @renderer.render(resources, opts)
       end
     end
 
     class ErrorsRenderer
-      def self.render(errors, options)
+      def initialize(renderer = JSONAPI::Serializable::ErrorsRenderer.new)
+        @renderer = renderer
+
+        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)
@@ -32,20 +44,8 @@ def self.render(errors, options)
           end
         end
 
-        JSONAPI::Serializable::ErrorRenderer.render(errors, options)
-      end
-    end
-
-    module_function
-
-    # @api private
-    def rails_renderer(renderer)
-      proc do |json, options|
-        # Renderer proc is evaluated in the controller context.
-        options = options.merge(_jsonapi_pointers: jsonapi_pointers)
-        json = renderer.render(json, options) unless json.is_a?(String)
-        self.content_type ||= Mime[:jsonapi]
-        self.response_body = json
+        # TODO(beauby): SerializableError inference on AR validation errors.
+        @renderer.render(errors, options)
       end
     end
   end

spec/action_controller_spec.rb

@@ -1,19 +1,72 @@
 require 'rails_helper'
 
-RSpec.describe JSONAPI::Rails::ActionController do
-  class TestController < ActionController::Base
-    deserializable_resource "things"
+describe ActionController::Base, type: :controller do
+  describe '.deserializable_resource' do
+    controller do
+      deserializable_resource :user
+
+      def create
+        render plain: 'ok'
+      end
+    end
+
+    let(:payload) do
+      {
+        _jsonapi: {
+          'data' => {
+            'type' => 'users',
+            'attributes' => { 'foo' => 'bar', 'bar' => 'baz' }
+          }
+        }
+      }
+    end
+
+    it 'makes the deserialized resource available in params' do
+      post :create, params: payload
+
+      expected = { 'type' => 'users', 'foo' => 'bar', 'bar' => 'baz' }
+      expect(controller.params[:user]).to eq(expected)
+    end
+
+    it 'makes the deserialization mapping available via #jsonapi_pointers' do
+      post :create, params: payload
+
+      expected = { foo: '/data/attributes/foo',
+                   bar: '/data/attributes/bar',
+                   type: '/data/type' }
+      expect(controller.jsonapi_pointers).to eq(expected)
+    end
   end
 
-  let(:controller) { TestController.new }
+  describe '#render jsonapi:' do
+    controller do
+      def index
+        serializer = Class.new(JSONAPI::Serializable::Resource) do
+          type :users
+          attribute :name
+        end
+        user = OpenStruct.new(id: 1, name: 'Lucas')
 
-  context 'source pointers' do
-    it 'should fetch the mapping created during deserialization' do
-      reverse_mapping = {id: "/data/id", type: "/data/type"}
-      allow(controller).to receive(:request) do
-        OpenStruct.new(env: {'jsonapi_deserializable.reverse_mapping' => reverse_mapping})
+        render jsonapi: user, class: serializer
       end
-      expect(controller.send(:jsonapi_pointers)).to equal reverse_mapping
+    end
+
+    subject { JSON.parse(response.body) }
+    let(:serialized_user) do
+      {
+        'data' => {
+          'id' => '1',
+          'type' => 'users',
+          'attributes' => { 'name' => 'Lucas' }
+        }
+      }
+    end
+
+    it 'renders a JSON API document' do
+      get :index
+
+      expect(response.content_type).to eq('application/vnd.api+json')
+      is_expected.to eq(serialized_user)
     end
   end
 end

spec/dummy/app/controllers/tweets_controller.rb

@@ -6,7 +6,6 @@
 require 'spec_helper'
 require 'rspec/rails'
 # Add additional requires below this line. Rails is not loaded until this point!
-require 'dry-validation'
 
 # Requires supporting ruby files with custom matchers and macros, etc, in
 # spec/support/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
@@ -56,40 +55,3 @@
   # arbitrary gems may also be filtered via:
   # config.filter_gems_from_backtrace("gem name")
 end
-
-# Custom RSpec matchers
-module JSONAPI
-  module RSpec
-    class BeValidJsonapiMatcher
-      def matches?(body)
-        JSONAPI.parse_response!(JSON.parse(body))
-        true
-      end
-    end
-
-    def be_valid_jsonapi
-      BeValidJsonapiMatcher.new
-    end
-
-    class MatchSchemaMatcher
-      def matches?(body, &block)
-        schema = Dry::Validation.Schema(&block)
-        @body = JSON.parse(body) unless body.is_a?(Hash)
-        @result = schema.call(@body.with_indifferent_access)
-        @result.success?
-      end
-
-      def failure_message
-        "#{@body} #{@result.errors}"
-      end
-    end
-
-    def match_schema(&block)
-      MatchSchemaMatcher.new(&block)
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.include JSONAPI::RSpec
-end

spec/dummy/app/deserializable/deserializable_tweet.rb

@@ -0,0 +1,11 @@
+require 'rails_helper'
+
+describe JSONAPI::Rails::Railtie do
+  it 'registers the JSON API MIME type' do
+    expect(Mime[:jsonapi]).to eq('application/vnd.api+json')
+  end
+
+  it 'registers the params parser for the JSON API MIME type' do
+    expect(::ActionDispatch::Request.parameter_parsers[:jsonapi]).not_to be_nil
+  end
+end