active_model_serializers 0.10.6 → 0.10.7

data/lib/active_model_serializers/adapter/json_api/relationship.rb

@@ -43,10 +43,16 @@ module ActiveModelSerializers
         end
 
         def data_for_one(association)
-          if association.belongs_to? &&
-              parent_serializer.object.respond_to?(association.reflection.foreign_key)
-            id = parent_serializer.object.send(association.reflection.foreign_key)
-            type = association.reflection.type.to_s
+          if belongs_to_id_on_self?(association)
+            id = parent_serializer.read_attribute_for_serialization(association.reflection.foreign_key)
+            type =
+              if association.polymorphic?
+                # We can't infer resource type for polymorphic relationships from the serializer.
+                # We can ONLY know a polymorphic resource type by inspecting each resource.
+                association.lazy_association.serializer.json_key
+              else
+                association.reflection.type.to_s
+              end
             ResourceIdentifier.for_type_with_id(type, id, serializable_resource_options)
           else
             # TODO(BF): Process relationship without evaluating lazy_association
@@ -86,6 +92,12 @@ module ActiveModelSerializers
           meta = association.meta
           meta.respond_to?(:call) ? parent_serializer.instance_eval(&meta) : meta
         end
+
+        def belongs_to_id_on_self?(association)
+          parent_serializer.config.jsonapi_use_foreign_key_on_belongs_to_relationship &&
+            association.belongs_to? &&
+            parent_serializer.object.respond_to?(association.reflection.foreign_key)
+        end
       end
     end
   end

data/lib/active_model_serializers/adapter/json_api/resource_identifier.rb

@@ -2,32 +2,34 @@ module ActiveModelSerializers
   module Adapter
     class JsonApi
       class ResourceIdentifier
-        def self.type_for(class_name, serializer_type = nil, transform_options = {})
-          if serializer_type
-            raw_type = serializer_type
-          else
-            inflection =
-              if ActiveModelSerializers.config.jsonapi_resource_type == :singular
-                :singularize
-              else
-                :pluralize
-              end
-
-            raw_type = class_name.underscore
-            raw_type = ActiveSupport::Inflector.public_send(inflection, raw_type)
-            raw_type
-              .gsub!('/'.freeze, ActiveModelSerializers.config.jsonapi_namespace_separator)
-            raw_type
-          end
+        def self.type_for(serializer, serializer_type = nil, transform_options = {})
+          raw_type = serializer_type ? serializer_type : raw_type_from_serializer_object(serializer.object)
           JsonApi.send(:transform_key_casing!, raw_type, transform_options)
         end
 
         def self.for_type_with_id(type, id, options)
-          return nil if id.blank?
-          {
-            id: id.to_s,
-            type: type_for(:no_class_needed, type, options)
-          }
+          type = inflect_type(type)
+          type = type_for(:no_class_needed, type, options)
+          if id.blank?
+            { type: type }
+          else
+            { id: id.to_s, type: type }
+          end
+        end
+
+        def self.raw_type_from_serializer_object(object)
+          class_name = object.class.name # should use model_name
+          raw_type = class_name.underscore
+          raw_type = inflect_type(raw_type)
+          raw_type
+            .gsub!('/'.freeze, ActiveModelSerializers.config.jsonapi_namespace_separator)
+          raw_type
+        end
+
+        def self.inflect_type(type)
+          singularize = ActiveModelSerializers.config.jsonapi_resource_type == :singular
+          inflection = singularize ? :singularize : :pluralize
+          ActiveSupport::Inflector.public_send(inflection, type)
         end
 
         # {http://jsonapi.org/format/#document-resource-identifier-objects Resource Identifier Objects}
@@ -37,8 +39,11 @@ module ActiveModelSerializers
         end
 
         def as_json
-          return nil if id.blank?
-          { id: id, type: type }
+          if id.blank?
+            { type: type }
+          else
+            { id: id.to_s, type: type }
+          end
         end
 
         protected
@@ -48,7 +53,8 @@ module ActiveModelSerializers
         private
 
         def type_for(serializer, transform_options)
-          self.class.type_for(serializer.object.class.name, serializer._type, transform_options)
+          serializer_type = serializer._type
+          self.class.type_for(serializer, serializer_type, transform_options)
         end
 
         def id_for(serializer)

data/test/action_controller/json_api/deserialization_test.rb

@@ -45,7 +45,7 @@ module ActionController
           response = JSON.parse(@response.body)
           expected = {
             'restriction_for_id' => '67',
-            'restriction_for_type' => 'discounts',
+            'restriction_for_type' => 'Discount',
             'restricted_to_id' => nil,
             'restricted_to_type' => nil
           }

data/test/action_controller/json_api/pagination_test.rb

@@ -58,8 +58,10 @@ module ActionController
           assert_equal expected_links, response['links']
         end
 
-        def test_render_only_last_and_next_pagination_links
+        def test_render_only_first_last_and_next_pagination_links
           expected_links = { 'self' => "#{WILL_PAGINATE_URI}?page%5Bnumber%5D=1&page%5Bsize%5D=2",
+                             'first' => "#{WILL_PAGINATE_URI}?page%5Bnumber%5D=1&page%5Bsize%5D=2",
+                             'prev' => nil,
                              'next' => "#{WILL_PAGINATE_URI}?page%5Bnumber%5D=2&page%5Bsize%5D=2",
                              'last' => "#{WILL_PAGINATE_URI}?page%5Bnumber%5D=2&page%5Bsize%5D=2" }
           get :render_pagination_using_will_paginate, params: { page: { number: 1, size: 2 } }
@@ -78,17 +80,21 @@ module ActionController
           assert_equal expected_links, response['links']
         end
 
-        def test_render_only_prev_and_first_pagination_links
+        def test_render_only_prev_first_and_last_pagination_links
           expected_links = { 'self' => "#{KAMINARI_URI}?page%5Bnumber%5D=3&page%5Bsize%5D=1",
                              'first' => "#{KAMINARI_URI}?page%5Bnumber%5D=1&page%5Bsize%5D=1",
-                             'prev' => "#{KAMINARI_URI}?page%5Bnumber%5D=2&page%5Bsize%5D=1" }
+                             'prev' => "#{KAMINARI_URI}?page%5Bnumber%5D=2&page%5Bsize%5D=1",
+                             'next' => nil,
+                             'last' => "#{KAMINARI_URI}?page%5Bnumber%5D=3&page%5Bsize%5D=1" }
           get :render_pagination_using_kaminari, params: { page: { number: 3, size: 1 } }
           response = JSON.parse(@response.body)
           assert_equal expected_links, response['links']
         end
 
-        def test_render_only_last_and_next_pagination_links_with_additional_params
+        def test_render_only_first_last_and_next_pagination_links_with_additional_params
           expected_links = { 'self' => "#{WILL_PAGINATE_URI}?page%5Bnumber%5D=1&page%5Bsize%5D=2&teste=additional",
+                             'first' => "#{WILL_PAGINATE_URI}?page%5Bnumber%5D=1&page%5Bsize%5D=2&teste=additional",
+                             'prev' => nil,
                              'next' => "#{WILL_PAGINATE_URI}?page%5Bnumber%5D=2&page%5Bsize%5D=2&teste=additional",
                              'last' => "#{WILL_PAGINATE_URI}?page%5Bnumber%5D=2&page%5Bsize%5D=2&teste=additional" }
           get :render_pagination_using_will_paginate, params: { page: { number: 1, size: 2 }, teste: 'additional' }
@@ -96,10 +102,12 @@ module ActionController
           assert_equal expected_links, response['links']
         end
 
-        def test_render_only_prev_and_first_pagination_links_with_additional_params
+        def test_render_only_prev_first_and_last_pagination_links_with_additional_params
           expected_links = { 'self' => "#{KAMINARI_URI}?page%5Bnumber%5D=3&page%5Bsize%5D=1&teste=additional",
                              'first' => "#{KAMINARI_URI}?page%5Bnumber%5D=1&page%5Bsize%5D=1&teste=additional",
-                             'prev' => "#{KAMINARI_URI}?page%5Bnumber%5D=2&page%5Bsize%5D=1&teste=additional" }
+                             'prev' => "#{KAMINARI_URI}?page%5Bnumber%5D=2&page%5Bsize%5D=1&teste=additional",
+                             'next' => nil,
+                             'last' => "#{KAMINARI_URI}?page%5Bnumber%5D=3&page%5Bsize%5D=1&teste=additional" }
           get :render_pagination_using_kaminari, params: { page: { number: 3, size: 1 }, teste: 'additional' }
           response = JSON.parse(@response.body)
           assert_equal expected_links, response['links']

data/test/adapter/json_api/include_data_if_sideloaded_test.rb

@@ -6,7 +6,7 @@ module ActiveModel
       class JsonApi
         class IncludeParamTest < ActiveSupport::TestCase
           IncludeParamAuthor = Class.new(::Model) do
-            associations :tags, :posts
+            associations :tags, :posts, :roles
           end
 
           class CustomCommentLoader
@@ -51,14 +51,19 @@ module ActiveModel
               include_data :if_sideloaded
               IncludeParamAuthorSerializer.comment_loader.all
             end
+            has_many :roles, key: :granted_roles do
+              include_data :if_sideloaded
+            end
           end
 
           def setup
             IncludeParamAuthorSerializer.comment_loader = Class.new(CustomCommentLoader).new
             @tag = Tag.new(id: 1337, name: 'mytag')
+            @role = Role.new(id: 1337, name: 'myrole')
             @author = IncludeParamAuthor.new(
               id: 1337,
-              tags: [@tag]
+              tags: [@tag],
+              roles: [@role]
             )
           end
 
@@ -105,6 +110,31 @@ module ActiveModel
             assert_equal(expected, hash[:included])
           end
 
+          def test_sideloads_included_when_using_key
+            expected = [
+              {
+                id: '1337',
+                type: 'roles',
+                attributes: {
+                  name: 'myrole',
+                  description: nil,
+                  slug: 'myrole-1337'
+                },
+                relationships: {
+                  author: { data: nil }
+                }
+              }
+            ]
+
+            hash = result(include: :granted_roles)
+            assert_equal(expected, hash[:included])
+          end
+
+          def test_sideloads_not_included_when_using_name_when_key_defined
+            hash = result(include: :roles)
+            assert_nil(hash[:included])
+          end
+
           def test_nested_relationship
             expected = {
               data: [

data/test/adapter/json_api/pagination_links_test.rb

@@ -54,6 +54,16 @@ module ActiveModelSerializers
           }
         end
 
+        def empty_collection_links
+          {
+            self: "#{URI}?page%5Bnumber%5D=1&page%5Bsize%5D=2",
+            first: "#{URI}?page%5Bnumber%5D=1&page%5Bsize%5D=2",
+            prev: nil,
+            next: nil,
+            last: "#{URI}?page%5Bnumber%5D=1&page%5Bsize%5D=2"
+          }
+        end
+
         def links
           {
             links: {
@@ -71,7 +81,9 @@ module ActiveModelSerializers
             links: {
               self: "#{URI}?page%5Bnumber%5D=3&page%5Bsize%5D=2",
               first: "#{URI}?page%5Bnumber%5D=1&page%5Bsize%5D=2",
-              prev: "#{URI}?page%5Bnumber%5D=2&page%5Bsize%5D=2"
+              prev: "#{URI}?page%5Bnumber%5D=2&page%5Bsize%5D=2",
+              next: nil,
+              last: "#{URI}?page%5Bnumber%5D=3&page%5Bsize%5D=2"
             }
           }
         end
@@ -108,10 +120,10 @@ module ActiveModelSerializers
           end
         end
 
-        def expected_response_with_no_data_pagination_links
+        def expected_response_with_empty_collection_pagination_links
           {}.tap do |hash|
             hash[:data] = []
-            hash[:links] = {}
+            hash.merge! links: empty_collection_links
           end
         end
 
@@ -139,7 +151,7 @@ module ActiveModelSerializers
 
           adapter = load_adapter(using_kaminari(1), mock_request)
 
-          assert_equal expected_response_with_no_data_pagination_links, adapter.serializable_hash
+          assert_equal expected_response_with_empty_collection_pagination_links, adapter.serializable_hash
         end
 
         def test_pagination_links_when_zero_results_will_paginate
@@ -147,7 +159,7 @@ module ActiveModelSerializers
 
           adapter = load_adapter(using_will_paginate(1), mock_request)
 
-          assert_equal expected_response_with_no_data_pagination_links, adapter.serializable_hash
+          assert_equal expected_response_with_empty_collection_pagination_links, adapter.serializable_hash
         end
 
         def test_last_page_pagination_links_using_kaminari
@@ -171,10 +183,11 @@ module ActiveModelSerializers
         def test_raises_descriptive_error_when_serialization_context_unset
           render_options = { adapter: :json_api }
           adapter = serializable(using_kaminari, render_options)
-          exception = assert_raises do
+          exception_class = ActiveModelSerializers::Adapter::JsonApi::PaginationLinks::MissingSerializationContextError
+
+          exception = assert_raises(exception_class) do
             adapter.as_json
           end
-          exception_class = ActiveModelSerializers::Adapter::JsonApi::PaginationLinks::MissingSerializationContextError
           assert_equal exception_class, exception.class
           assert_match(/CollectionSerializer#paginated\?/, exception.message)
         end

data/test/adapter/json_api/parse_test.rb

@@ -125,7 +125,7 @@ module ActiveModelSerializers
               src: 'http://example.com/images/productivity.png',
               author_id: nil,
               photographer_id: '9',
-              photographer_type: 'people',
+              photographer_type: 'Person',
               comment_ids: %w(1 2)
             }
             assert_equal(expected, parsed_hash)

data/test/adapter/json_api/type_test.rb

@@ -1,60 +1,192 @@
 require 'test_helper'
 
-module ActiveModel
-  class Serializer
-    module Adapter
-      class JsonApi
-        class TypeTest < ActiveSupport::TestCase
-          class StringTypeSerializer < ActiveModel::Serializer
-            attribute :name
-            type 'profile'
+module ActiveModelSerializers
+  module Adapter
+    class JsonApi
+      class TypeTest < ActiveSupport::TestCase
+        class StringTypeSerializer < ActiveModel::Serializer
+          attribute :name
+          type 'profile'
+        end
+
+        class SymbolTypeSerializer < ActiveModel::Serializer
+          attribute :name
+          type :profile
+        end
+
+        setup do
+          @author = Author.new(id: 1, name: 'Steve K.')
+        end
+
+        def test_config_plural
+          with_jsonapi_inflection :plural do
+            assert_type(@author, 'authors')
           end
+        end
 
-          class SymbolTypeSerializer < ActiveModel::Serializer
-            attribute :name
-            type :profile
+        def test_config_singular
+          with_jsonapi_inflection :singular do
+            assert_type(@author, 'author')
           end
+        end
+
+        def test_explicit_string_type_value
+          assert_type(@author, 'profile', serializer: StringTypeSerializer)
+        end
+
+        def test_explicit_symbol_type_value
+          assert_type(@author, 'profile', serializer: SymbolTypeSerializer)
+        end
+
+        private
 
-          setup do
-            @author = Author.new(id: 1, name: 'Steve K.')
+        def assert_type(resource, expected_type, opts = {})
+          opts = opts.reverse_merge(adapter: :json_api)
+          hash = serializable(resource, opts).serializable_hash
+          assert_equal(expected_type, hash.fetch(:data).fetch(:type))
+        end
+      end
+      class ResourceIdentifierTest < ActiveSupport::TestCase
+        class WithDefinedTypeSerializer < ActiveModel::Serializer
+          type 'with_defined_types'
+        end
+
+        class WithDefinedIdSerializer < ActiveModel::Serializer
+          def id
+            'special_id'
           end
+        end
+
+        class FragmentedSerializer < ActiveModel::Serializer
+          cache only: :id
 
-          def test_config_plural
-            with_jsonapi_resource_type :plural do
-              assert_type(@author, 'authors')
-            end
+          def id
+            'special_id'
           end
+        end
+
+        setup do
+          @model = Author.new(id: 1, name: 'Steve K.')
+          ActionController::Base.cache_store.clear
+        end
 
-          def test_config_singular
-            with_jsonapi_resource_type :singular do
-              assert_type(@author, 'author')
-            end
+        def test_defined_type
+          actual = with_jsonapi_inflection :plural do
+            actual_resource_identifier_object(WithDefinedTypeSerializer, @model)
           end
+          expected = { id: expected_model_id(@model), type: 'with-defined-types' }
+          assert_equal actual, expected
+        end
 
-          def test_explicit_string_type_value
-            assert_type(@author, 'profile', serializer: StringTypeSerializer)
+        def test_defined_type_not_inflected
+          actual = with_jsonapi_inflection :singular do
+            actual_resource_identifier_object(WithDefinedTypeSerializer, @model)
           end
+          expected = { id: expected_model_id(@model), type: 'with-defined-types' }
+          assert_equal actual, expected
+        end
 
-          def test_explicit_symbol_type_value
-            assert_type(@author, 'profile', serializer: SymbolTypeSerializer)
+        def test_singular_type
+          actual = with_jsonapi_inflection :singular do
+            actual_resource_identifier_object(AuthorSerializer, @model)
           end
+          expected = { id: expected_model_id(@model), type: 'author' }
+          assert_equal actual, expected
+        end
 
-          private
+        def test_plural_type
+          actual = with_jsonapi_inflection :plural do
+            actual_resource_identifier_object(AuthorSerializer, @model)
+          end
+          expected = { id: expected_model_id(@model), type: 'authors' }
+          assert_equal actual, expected
+        end
+
+        def test_type_with_namespace
+          Object.const_set(:Admin, Module.new)
+          model = Class.new(::Model)
+          Admin.const_set(:PowerUser, model)
+          serializer = Class.new(ActiveModel::Serializer)
+          Admin.const_set(:PowerUserSerializer, serializer)
+          with_namespace_separator '--' do
+            admin_user = Admin::PowerUser.new
+            serializer = Admin::PowerUserSerializer.new(admin_user)
+            expected = {
+              id: admin_user.id,
+              type: 'admin--power-users'
+            }
+
+            identifier = ResourceIdentifier.new(serializer, {})
+            actual = identifier.as_json
+            assert_equal(expected, actual)
+          end
+        end
+
+        def test_id_defined_on_object
+          actual = actual_resource_identifier_object(AuthorSerializer, @model)
+          expected = { id: @model.id.to_s, type: expected_model_type(@model) }
+          assert_equal actual, expected
+        end
+
+        def test_blank_id
+          model = Author.new(id: nil, name: 'Steve K.')
+          actual = actual_resource_identifier_object(AuthorSerializer, model)
+          expected = { type: expected_model_type(model) }
+          assert_equal actual, expected
+        end
+
+        def test_for_type_with_id
+          id = 1
+          actual = ResourceIdentifier.for_type_with_id('admin_user', id, {})
+          expected = { id: '1', type: 'admin-users' }
+          assert_equal actual, expected
+        end
 
-          def assert_type(resource, expected_type, opts = {})
-            opts = opts.reverse_merge(adapter: :json_api)
-            hash = serializable(resource, opts).serializable_hash
-            assert_equal(expected_type, hash.fetch(:data).fetch(:type))
+        def test_for_type_with_id_given_blank_id
+          id = ''
+          actual = ResourceIdentifier.for_type_with_id('admin_user', id, {})
+          expected = { type: 'admin-users' }
+          assert_equal actual, expected
+        end
+
+        def test_for_type_with_id_inflected
+          id = 2
+          actual = with_jsonapi_inflection :singular do
+            ResourceIdentifier.for_type_with_id('admin_users', id, {})
           end
+          expected = { id: '2', type: 'admin-user' }
+          assert_equal actual, expected
+        end
+
+        def test_id_defined_on_serializer
+          actual = actual_resource_identifier_object(WithDefinedIdSerializer, @model)
+          expected = { id: 'special_id', type: expected_model_type(@model) }
+          assert_equal actual, expected
+        end
+
+        def test_id_defined_on_fragmented
+          actual = actual_resource_identifier_object(FragmentedSerializer, @model)
+          expected = { id: 'special_id', type: expected_model_type(@model) }
+          assert_equal actual, expected
+        end
+
+        private
+
+        def actual_resource_identifier_object(serializer_class, model)
+          serializer = serializer_class.new(model)
+          resource_identifier = ResourceIdentifier.new(serializer, nil)
+          resource_identifier.as_json
+        end
 
-          def with_jsonapi_resource_type(inflection)
-            old_inflection = ActiveModelSerializers.config.jsonapi_resource_type
-            ActiveModelSerializers.config.jsonapi_resource_type = inflection
-            yield
-          ensure
-            ActiveModelSerializers.config.jsonapi_resource_type = old_inflection
+        def expected_model_type(model, inflection = ActiveModelSerializers.config.jsonapi_resource_type)
+          with_jsonapi_inflection inflection do
+            model.class.model_name.send(inflection)
           end
         end
+
+        def expected_model_id(model)
+          model.id.to_s
+        end
       end
     end
   end