Refactor JsonApi adapter in order to avoid recomputation of hashes for included resources.

Author: beauby

lib/active_model/serializer/adapter/json_api.rb

@@ -56,15 +56,29 @@ def initialize(serializer, options = {})
         def serializable_hash(options = nil)
           options ||= {}
 
-          hash =
-            if serializer.respond_to?(:each)
-              serializable_hash_for_collection(options)
+          is_collection = serializer.respond_to?(:each)
+          resources = {}
+          process_resource(serializer, @include_tree, true, resources)
+          primary_data, included = resources.each_with_object([[], []]) do |(_, resource), (primary, included)|
+            if resource[:is_primary]
+              primary.push(resource.except(:is_primary))
             else
-              serializable_hash_for_single_resource
+              included.push(resource.except(:is_primary))
             end
+          end
+
+          hash = {}
+          hash[:data] = is_collection ? primary_data : primary_data.first
+
+          hash[:included] = included if included.any?
 
           ApiObjects::JsonApi.add!(hash)
 
+          if is_collection && serializer.paginated?
+            hash[:links] ||= {}
+            hash[:links].update(links_for(serializer, options))
+          end
+
           if instance_options[:links]
             hash[:links] ||= {}
             hash[:links].update(instance_options[:links])
@@ -84,38 +98,32 @@ def fragment_cache(cached_hash, non_cached_hash)
 
         private
 
-        def serializable_hash_for_collection(options)
-          hash = { data: [] }
-          included = []
-          serializer.each do |s|
-            result = self.class.new(s, instance_options.merge(fieldset: fieldset)).serializable_hash(options)
-            hash[:data] << result[:data]
-            next unless result[:included]
-
-            included |= result[:included]
+        def process_resource(serializer, include_tree, is_primary, hashes)
+          if serializer.respond_to?(:each)
+            serializer.each { |s| process_resource(s, include_tree, is_primary, hashes) }
+            return
           end
-
-          included.delete_if { |resource| hash[:data].include?(resource) }
-          hash[:included] = included if included.any?
-
-          if serializer.paginated?
-            hash[:links] ||= {}
-            hash[:links].update(links_for(serializer, options))
+          return unless serializer && serializer.object
+          resource_identifier = resource_identifier_for(serializer)
+          key = [resource_identifier_type_for(serializer), resource_identifier_id_for(serializer)]
+          if hashes[key]
+            hashes[key][:is_primary] ||= is_primary
+            return
           end
 
-          hash
-        end
+          hash = resource_identifier.merge(is_primary: is_primary)
+
+          attributes = attributes_for(serializer)
+          hash[:attributes] = attributes if attributes.any?
 
-        def serializable_hash_for_single_resource
-          primary_data = primary_data_for(serializer)
           relationships = relationships_for(serializer)
-          primary_data[:relationships] = relationships if relationships.any?
-          hash = { data: primary_data }
+          hash[:relationships] = relationships if relationships.any?
 
-          included = included_resources(@include_tree, [primary_data])
-          hash[:included] = included if included.any?
+          hashes[key] = hash
 
-          hash
+          serializer.associations(include_tree).each do |association|
+            process_resource(association.serializer, include_tree[association.key], false, hashes)
+          end
         end
 
         def resource_identifier_type_for(serializer)
@@ -142,26 +150,15 @@ def resource_identifier_for(serializer)
           { id: id.to_s, type: type }
         end
 
-        def resource_object_for(serializer)
-          cache_check(serializer) do
-            resource_object = resource_identifier_for(serializer)
-            requested_fields = fieldset && fieldset.fields_for(resource_object[:type])
-            attributes = serializer.attributes.except(:id)
-            attributes.slice!(*requested_fields) if requested_fields
-            resource_object[:attributes] = attributes if attributes.any?
-            resource_object
-          end
-        end
+        def attributes_for(serializer)
+          attributes = serializer.attributes.except(:id)
+          requested_fields = fieldset && fieldset.fields_for(resource_identifier_type_for(serializer))
+          attributes.slice!(*requested_fields) if requested_fields
 
-        def primary_data_for(serializer)
-          if serializer.respond_to?(:each)
-            serializer.map { |s| resource_object_for(s) }
-          else
-            resource_object_for(serializer)
-          end
+          attributes
         end
 
-        def relationship_value_for(serializer, options = {})
+        def linkage_for(serializer, options = {})
           if serializer.respond_to?(:each)
             serializer.map { |s| resource_identifier_for(s) }
           else
@@ -175,36 +172,7 @@ def relationship_value_for(serializer, options = {})
 
         def relationships_for(serializer)
           serializer.associations.each_with_object({}) do |association, hash|
-            hash[association.key] = { data: relationship_value_for(association.serializer, association.options) }
-          end
-        end
-
-        def included_resources(include_tree, primary_data)
-          included = []
-
-          serializer.associations(include_tree).each do |association|
-            add_included_resources_for(association.serializer, include_tree[association.key], primary_data, included)
-          end
-
-          included
-        end
-
-        def add_included_resources_for(serializer, include_tree, primary_data, included)
-          if serializer.respond_to?(:each)
-            serializer.each { |s| add_included_resources_for(s, include_tree, primary_data, included) }
-          else
-            return unless serializer && serializer.object
-
-            resource_object = primary_data_for(serializer)
-            relationships = relationships_for(serializer)
-            resource_object[:relationships] = relationships if relationships.any?
-
-            return if included.include?(resource_object) || primary_data.include?(resource_object)
-            included.push(resource_object)
-
-            serializer.associations(include_tree).each do |association|
-              add_included_resources_for(association.serializer, include_tree[association.key], primary_data, included)
-            end
+            hash[association.key] = { data: linkage_for(association.serializer, association.options) }
           end
         end