RC3 Updates for JSON API

CHANGELOG.md

@@ -2,4 +2,5 @@
 
   * adds support for `meta` and `meta_key` [@kurko]
   * adds method to override association [adcb99e, @kurko]
-  * add `has_one` attribute for backwards compatibility [@ggordon]
+  * adds `has_one` attribute for backwards compatibility [@ggordon]
+  * updates JSON API support to RC3 [@mateomurphy]

README.md

@@ -181,9 +181,9 @@ end
 
 #### JSONAPI
 
-This adapter follows the format specified in
+This adapter follows RC3 of the format specified in
 [jsonapi.org/format](http://jsonapi.org/format). It will include the associated
-resources in the `"linked"` member when the resource names are included in the
+resources in the `"included"` member when the resource names are included in the
 `include` option.
 
 ```ruby

lib/active_model/serializer.rb

@@ -164,6 +164,14 @@ def json_key
       end
     end
 
+    def id
+      object.id if object
+    end
+
+    def type
+      object.class.to_s.demodulize.underscore.pluralize
+    end
+
     def attributes(options = {})
       attributes =
         if options[:fields]
@@ -172,6 +180,8 @@ def attributes(options = {})
           self.class._attributes.dup
         end
 
+      attributes += options[:required_fields] if options[:required_fields]
+
       attributes.each_with_object({}) do |name, hash|
         hash[name] = send(name)
       end

lib/active_model/serializer/adapter/json_api.rb

@@ -16,7 +16,7 @@ def initialize(serializer, options = {})
         end
 
         def serializable_hash(options = {})
-          @root = (@options[:root] || serializer.json_key.to_s.pluralize).to_sym
+          @root = :data
 
           if serializer.respond_to?(:each)
             @hash[@root] = serializer.map do |s|
@@ -35,58 +35,40 @@ def serializable_hash(options = {})
         private
 
         def add_links(resource, name, serializers)
-          type = serialized_object_type(serializers)
           resource[:links] ||= {}
-
-          if name.to_s == type || !type
-            resource[:links][name] ||= []
-            resource[:links][name] += serializers.map{|serializer| serializer.id.to_s }
-          else
-            resource[:links][name] ||= {}
-            resource[:links][name][:type] = type
-            resource[:links][name][:ids] ||= []
-            resource[:links][name][:ids] += serializers.map{|serializer| serializer.id.to_s }
-          end
+          resource[:links][name] ||= { linkage: [] }
+          resource[:links][name][:linkage] += serializers.map { |serializer| { type: serializer.type, id: serializer.id.to_s } }
         end
 
         def add_link(resource, name, serializer)
           resource[:links] ||= {}
-          resource[:links][name] = nil
+          resource[:links][name] = { linkage: nil }
 
           if serializer && serializer.object
-            type = serialized_object_type(serializer)
-            if name.to_s == type || !type
-              resource[:links][name] = serializer.id.to_s
-            else
-              resource[:links][name] ||= {}
-              resource[:links][name][:type] = type
-              resource[:links][name][:id] = serializer.id.to_s
-            end
+            resource[:links][name][:linkage] = { type: serializer.type, id: serializer.id.to_s }
           end
         end
 
-        def add_linked(resource_name, serializers, parent = nil)
+        def add_included(resource_name, serializers, parent = nil)
           serializers = Array(serializers) unless serializers.respond_to?(:each)
 
           resource_path = [parent, resource_name].compact.join('.')
 
-          if include_assoc?(resource_path) && resource_type = serialized_object_type(serializers)
-            plural_name = resource_type.pluralize.to_sym
-            @top[:linked] ||= {}
-            @top[:linked][plural_name] ||= []
+          if include_assoc?(resource_path)
+            @top[:included] ||= []
 
             serializers.each do |serializer|
               attrs = attributes_for_serializer(serializer, @options)
 
-              add_resource_links(attrs, serializer, add_linked: false)
+              add_resource_links(attrs, serializer, add_included: false)
 
-              @top[:linked][plural_name].push(attrs) unless @top[:linked][plural_name].include?(attrs)
+              @top[:included].push(attrs) unless @top[:included].include?(attrs)
             end
           end
 
           serializers.each do |serializer|
             serializer.each_association do |name, association, opts|
-              add_linked(name, association, resource_path) if association
+              add_included(name, association, resource_path) if association
             end if include_nested_assoc? resource_path
           end
         end
@@ -97,14 +79,16 @@ def attributes_for_serializer(serializer, options)
             result = []
             serializer.each do |object|
               options[:fields] = @fieldset && @fieldset.fields_for(serializer)
+              options[:required_fields] = [:id, :type]
               attributes = object.attributes(options)
-              attributes[:id] = attributes[:id].to_s if attributes[:id]
+              attributes[:id] = attributes[:id].to_s
               result << attributes
             end
           else
             options[:fields] = @fieldset && @fieldset.fields_for(serializer)
+            options[:required_fields] = [:id, :type]
             result = serializer.attributes(options)
-            result[:id] = result[:id].to_s if result[:id]
+            result[:id] = result[:id].to_s
           end
 
           result
@@ -128,18 +112,8 @@ def check_assoc(assoc)
           end
         end
 
-        def serialized_object_type(serializer)
-          return false unless Array(serializer).first
-          type_name = Array(serializer).first.object.class.to_s.demodulize.underscore
-          if serializer.respond_to?(:first)
-            type_name.pluralize
-          else
-            type_name
-          end
-        end
-
         def add_resource_links(attrs, serializer, options = {})
-          options[:add_linked] = options.fetch(:add_linked, true)
+          options[:add_included] = options.fetch(:add_included, true)
 
           serializer.each_association do |name, association, opts|
             attrs[:links] ||= {}
@@ -150,9 +124,9 @@ def add_resource_links(attrs, serializer, options = {})
               add_link(attrs, name, association)
             end
 
-            if @options[:embed] != :ids && options[:add_linked]
+            if options[:add_included]
               Array(association).each do |association|
-                add_linked(name, association)
+                add_included(name, association)
               end
             end
           end

test/action_controller/adapter_selector_test.rb

@@ -29,7 +29,17 @@ def test_render_using_default_adapter
 
       def test_render_using_adapter_override
         get :render_using_adapter_override
-        assert_equal '{"profiles":{"name":"Name 1","description":"Description 1"}}', response.body
+
+        expected = {
+          data: {
+            name: "Name 1",
+            description: "Description 1",
+            id: assigns(:profile).id.to_s,
+            type: "profiles"
+          }
+        }
+
+        assert_equal expected.to_json, response.body
       end
 
       def test_render_skipping_adapter

test/action_controller/json_api_linked_test.rb

@@ -83,80 +83,87 @@ def render_collection_with_include
       def test_render_resource_without_include
         get :render_resource_without_include
         response = JSON.parse(@response.body)
-        refute response.key? 'linked'
+        refute response.key? 'included'
       end
 
       def test_render_resource_with_include
         get :render_resource_with_include
         response = JSON.parse(@response.body)
-        assert response.key? 'linked'
-        assert_equal 1, response['linked']['authors'].size
-        assert_equal 'Steve K.', response['linked']['authors'].first['name']
+        assert response.key? 'included'
+        assert_equal 1, response['included'].size
+        assert_equal 'Steve K.', response['included'].first['name']
       end
 
       def test_render_resource_with_nested_has_many_include
         get :render_resource_with_nested_has_many_include
         response = JSON.parse(@response.body)
-        expected_linked = {
-          "authors" => [{
+        expected_linked = [
+          {
             "id" => "1",
+            "type" => "authors",
             "name" => "Steve K.",
             "links" => {
-              "posts" => [],
-              "roles" => ["1", "2"],
-              "bio" => nil
+              "posts" => { "linkage" => [] },
+              "roles" => { "linkage" => [{ "type" =>"roles", "id" => "1" }, { "type" =>"roles", "id" => "2" }] },
+              "bio" => { "linkage" => nil }
             }
-          }],
-          "roles"=>[{
+          }, {
             "id" => "1",
+            "type" => "roles",
             "name" => "admin",
             "links" => {
-              "author" => "1"
+              "author" => { "linkage" => { "type" =>"authors", "id" => "1" } }
             }
           }, {
             "id" => "2",
+            "type" => "roles",
             "name" => "colab",
             "links" => {
-              "author" => "1"
+              "author" => { "linkage" => { "type" =>"authors", "id" => "1" } }
             }
-          }]
-        }
-        assert_equal expected_linked, response['linked']
+          }
+        ]
+        assert_equal expected_linked, response['included']
       end
 
       def test_render_resource_with_nested_include
         get :render_resource_with_nested_include
         response = JSON.parse(@response.body)
-        assert response.key? 'linked'
-        assert_equal 1, response['linked']['authors'].size
-        assert_equal 'Anonymous', response['linked']['authors'].first['name']
+        assert response.key? 'included'
+        assert_equal 1, response['included'].size
+        assert_equal 'Anonymous', response['included'].first['name']
       end
 
       def test_render_collection_without_include
         get :render_collection_without_include
         response = JSON.parse(@response.body)
-        refute response.key? 'linked'
+        refute response.key? 'included'
       end
 
       def test_render_collection_with_include
         get :render_collection_with_include
         response = JSON.parse(@response.body)
-        assert response.key? 'linked'
+        assert response.key? 'included'
       end
 
       def test_render_resource_with_nested_attributes_even_when_missing_associations
         get :render_resource_with_missing_nested_has_many_include
         response = JSON.parse(@response.body)
-        assert response.key? 'linked'
-        refute response['linked'].key? 'roles'
+        assert response.key? 'included'
+        refute has_type?(response['included'], 'roles')
       end
 
       def test_render_collection_with_missing_nested_has_many_include
         get :render_collection_with_missing_nested_has_many_include
         response = JSON.parse(@response.body)
-        assert response.key? 'linked'
-        assert response['linked'].key? 'roles'
+        assert response.key? 'included'
+        assert has_type?(response['included'], 'roles')
+      end
+
+      def has_type?(collection, value)
+        collection.detect { |i| i['type'] == value}
       end
+
     end
   end
 end

test/action_controller/serialization_scope_name_test.rb

@@ -2,7 +2,7 @@
 require 'pathname'
 
 class DefaultScopeNameTest < ActionController::TestCase
-  TestUser = Struct.new(:name, :admin)
+  TestUser = Struct.new(:id, :name, :admin)
 
   class UserSerializer < ActiveModel::Serializer
     attributes :admin?
@@ -17,24 +17,24 @@ class UserTestController < ActionController::Base
     before_filter { request.format = :json }
 
     def current_user
-      TestUser.new('Pete', false)
+      TestUser.new(1, 'Pete', false)
     end
 
     def render_new_user
-      render json: TestUser.new('pete', false), serializer: UserSerializer, adapter: :json_api
+      render json: TestUser.new(1, 'pete', false), serializer: UserSerializer, adapter: :json_api
     end
   end
 
  tests UserTestController
 
   def test_default_scope_name
     get :render_new_user
-    assert_equal '{"users":{"admin?":false}}', @response.body
+    assert_equal '{"data":{"admin?":false,"id":"1","type":"test_users"}}', @response.body
   end
 end
 
 class SerializationScopeNameTest < ActionController::TestCase
-  TestUser = Struct.new(:name, :admin)
+  TestUser = Struct.new(:id, :name, :admin)
 
   class AdminUserSerializer < ActiveModel::Serializer
     attributes :admin?
@@ -50,18 +50,18 @@ class AdminUserTestController < ActionController::Base
     before_filter { request.format = :json }
 
     def current_admin
-      TestUser.new('Bob', true)
+      TestUser.new(1, 'Bob', true)
     end
 
     def render_new_user
-      render json: TestUser.new('pete', false), serializer: AdminUserSerializer, adapter: :json_api
+      render json: TestUser.new(1, 'pete', false), serializer: AdminUserSerializer, adapter: :json_api
     end
   end
 
   tests AdminUserTestController
 
   def test_override_scope_name_with_controller
     get :render_new_user
-    assert_equal '{"admin_users":{"admin?":true}}', @response.body
+    assert_equal '{"data":{"admin?":true,"id":"1","type":"test_users"}}', @response.body
   end
 end