Move association serialization to association

lib/active_model/serializer.rb

@@ -380,7 +380,7 @@ module ActiveModel
       adapter_options ||= {}
       options[:include_directive] ||= ActiveModel::Serializer.include_directive_from_options(adapter_options)
       resource = attributes_hash(adapter_options, options, adapter_instance)
-      relationships = resource_relationships(adapter_options, options, adapter_instance)
+      relationships = associations_hash(adapter_options, options, adapter_instance)
       resource.merge(relationships)
     end
     alias to_hash serializable_hash
@@ -423,34 +423,17 @@ module ActiveModel
     end
 
     # @api private
-    def resource_relationships(adapter_options, options, adapter_instance)
+    def associations_hash(adapter_options, options, adapter_instance)
       relationships = {}
       include_directive = options.fetch(:include_directive)
       associations(include_directive).each do |association|
         adapter_opts = adapter_options.merge(include_directive: include_directive[association.key])
-        relationships[association.key] ||= relationship_value_for(association, adapter_opts, adapter_instance)
+        relationships[association.key] ||= association.serializable_hash(adapter_opts, adapter_instance)
       end
 
       relationships
     end
 
-    # @api private
-    def relationship_value_for(association, adapter_options, adapter_instance)
-      return association.options[:virtual_value] if association.options[:virtual_value]
-      association_serializer = association.serializer
-      association_object = association_serializer && association_serializer.object
-      return unless association_object
-
-      relationship_value = association_serializer.serializable_hash(adapter_options, {}, adapter_instance)
-
-      if association.options[:polymorphic] && relationship_value
-        polymorphic_type = association_object.class.name.underscore
-        relationship_value = { type: polymorphic_type, polymorphic_type.to_sym => relationship_value }
-      end
-
-      relationship_value
-    end
-
     protected
 
     attr_accessor :instance_options

lib/active_model/serializer/association.rb

@@ -29,6 +29,22 @@ module ActiveModel
       def meta
         options[:meta]
       end
+
+      # @api private
+      def serializable_hash(adapter_options, adapter_instance)
+        return options[:virtual_value] if options[:virtual_value]
+        object = serializer && serializer.object
+        return unless object
+
+        serialization = serializer.serializable_hash(adapter_options, {}, adapter_instance)
+
+        if options[:polymorphic] && serialization
+          polymorphic_type = object.class.name.underscore
+          serialization = { type: polymorphic_type, polymorphic_type.to_sym => serialization }
+        end
+
+        serialization
+      end
     end
   end
 end

lib/active_model/serializer/concerns/caching.rb

@@ -245,7 +245,7 @@ module ActiveModel
         non_cached_fields = fields[:non_cached].dup
         non_cached_hash = attributes(non_cached_fields, true)
         include_directive = JSONAPI::IncludeDirective.new(non_cached_fields - non_cached_hash.keys)
-        non_cached_hash.merge! resource_relationships({}, { include_directive: include_directive }, adapter_instance)
+        non_cached_hash.merge! associations_hash({}, { include_directive: include_directive }, adapter_instance)
 
         cached_fields = fields[:cached].dup
         key = cache_key(adapter_instance)
@@ -254,7 +254,7 @@ module ActiveModel
             fetch(adapter_instance, serializer_class._cache_options, key) do
               hash = attributes(cached_fields, true)
               include_directive = JSONAPI::IncludeDirective.new(cached_fields - hash.keys)
-              hash.merge! resource_relationships({}, { include_directive: include_directive }, adapter_instance)
+              hash.merge! associations_hash({}, { include_directive: include_directive }, adapter_instance)
             end
           end
         # Merge both results