Make Association totally lazy

Author: bf4

lib/active_model/serializer/association.rb

@@ -4,44 +4,42 @@ module ActiveModel
   class Serializer
     # This class holds all information about serializer's association.
     #
-    # @attr [Symbol] name
-    # @attr [Hash{Symbol => Object}] options
-    # @attr [block]
-    #
-    # @example
-    #  Association.new(:comments, { serializer: CommentSummarySerializer })
-    #
-    class Association < Field
+    # @api private
+    Association = Struct.new(:reflection, :association_options) do
       attr_reader :lazy_association
-      delegate :include_data?, :virtual_value, to: :lazy_association
+      delegate :object, :include_data?, :virtual_value, :collection?, to: :lazy_association
 
       def initialize(*)
         super
-        @lazy_association = LazyAssociation.new(name, options, block)
+        @lazy_association = LazyAssociation.new(reflection, association_options)
       end
 
+      # @return [Symbol]
+      delegate :name, to: :reflection
+
       # @return [Symbol]
       def key
-        options.fetch(:key, name)
+        reflection_options.fetch(:key, name)
       end
 
       # @return [True,False]
       def key?
-        options.key?(:key)
+        reflection_options.key?(:key)
       end
 
       # @return [Hash]
       def links
-        options.fetch(:links) || {}
+        reflection_options.fetch(:links) || {}
       end
 
       # @return [Hash, nil]
+      # This gets mutated, so cannot use the cached reflection_options
       def meta
-        options[:meta]
+        reflection.options[:meta]
       end
 
       def polymorphic?
-        true == options[:polymorphic]
+        true == reflection_options[:polymorphic]
       end
 
       # @api private
@@ -63,7 +61,7 @@ def serializable_hash(adapter_options, adapter_instance)
 
       private
 
-      delegate :reflection, to: :lazy_association
+      delegate :reflection_options, to: :lazy_association
     end
   end
 end

lib/active_model/serializer/lazy_association.rb

@@ -1,21 +1,107 @@
 module ActiveModel
   class Serializer
-    class LazyAssociation < Field
+    # @api private
+    LazyAssociation = Struct.new(:reflection, :association_options) do
+      REFLECTION_OPTIONS = %i(key links polymorphic meta serializer virtual_value namespace).freeze
 
-      def serializer
-        options[:serializer]
+      delegate :collection?, to: :reflection
+
+      def reflection_options
+        @reflection_options ||= reflection.options.dup.reject { |k, _| !REFLECTION_OPTIONS.include?(k) }
       end
 
+      def object
+        @object ||= reflection.value(
+          association_options.fetch(:parent_serializer),
+          association_options.fetch(:include_slice)
+        )
+      end
+      alias_method :eval_reflection_block, :object
+
       def include_data?
-        options[:include_data]
+        eval_reflection_block if reflection.block
+        reflection.include_data?(
+          association_options.fetch(:include_slice)
+        )
+      end
+
+      # @return [ActiveModel::Serializer, nil]
+      def serializer
+        return @serializer if defined?(@serializer)
+        if serializer_class
+          serialize_object!(object)
+        elsif !object.nil? && !object.instance_of?(Object)
+          cached_result[:virtual_value] = object
+        end
+        @serializer = cached_result[:serializer]
       end
 
       def virtual_value
-        options[:virtual_value]
+        cached_result[:virtual_value] || reflection_options[:virtual_value]
+      end
+
+      # NOTE(BF): Kurko writes:
+      # 1. This class is doing a lot more than it should. It has business logic (key/meta/links) and
+      #   it also looks like a factory (serializer/serialize_object/instantiate_serializer/serializer_class).
+      #   It's hard to maintain classes that you can understand what it's really meant to be doing,
+      #   so it ends up having all sorts of methods.
+      #   Perhaps we could replace all these methods with a class called... Serializer.
+      #   See how association is doing the job a serializer again?
+      # 2. I've seen code like this in many other places.
+      #   Perhaps we should just have it all in one place: Serializer.
+      #   We already have a class called Serializer, I know,
+      #   and that is doing things that are not responsibility of a serializer.
+      def serializer_class
+        return @serializer_class if defined?(@serializer_class)
+        serializer_for_options = { namespace: namespace }
+        serializer_for_options[:serializer] = reflection_options[:serializer] if reflection_options.key?(:serializer)
+        @serializer_class = association_options.fetch(:parent_serializer).class.serializer_for(object, serializer_for_options)
+      end
+
+      private
+
+      def cached_result
+        @cached_result ||= {}
+      end
+
+      def serialize_object!(object)
+        if collection?
+          if (serializer = instantiate_collection_serializer(object)).nil?
+            # BUG: per #2027, JSON API resource relationships are only id and type, and hence either
+            # *require* a serializer or we need to be a little clever about figuring out the id/type.
+            # In either case, returning the raw virtual value will almost always be incorrect.
+            #
+            # Should be reflection_options[:virtual_value] or adapter needs to figure out what to do
+            # with an object that is non-nil and has no defined serializer.
+            cached_result[:virtual_value] = object.try(:as_json) || object
+          else
+            cached_result[:serializer] = serializer
+          end
+        else
+          cached_result[:serializer] = instantiate_serializer(object)
+        end
+      end
+
+      # NOTE(BF): This serializer throw/catch should only happen when the serializer is a collection
+      # serializer.  This is a good reason for the reflection to have a to_many? type method.
+      def instantiate_serializer(object)
+        serializer_options = association_options.fetch(:parent_serializer_options).except(:serializer)
+        serializer_options[:serializer_context_class] = association_options.fetch(:parent_serializer).class
+        serializer = reflection_options.fetch(:serializer, nil)
+        serializer_options[:serializer] = serializer if serializer
+        serializer_class.new(object, serializer_options)
+      end
+
+      def instantiate_collection_serializer(object)
+        serializer = catch(:no_serializer) do
+          instantiate_serializer(object)
+        end
+        serializer
       end
 
-      def reflection
-        options[:reflection]
+      def namespace
+        reflection_options[:namespace] ||
+          association_options.fetch(:parent_serializer_options)[:namespace]
       end
     end
   end

lib/active_model/serializer/reflection.rb

@@ -47,8 +47,6 @@ class Serializer
     #
     # So you can inspect reflections in your Adapters.
     class Reflection < Field
-      REFLECTION_OPTIONS = %i(key links polymorphic meta serializer virtual_value namespace).freeze
-
       def initialize(*)
         super
         options[:links] = {}
@@ -125,92 +123,6 @@ def collection?
         false
       end
 
-      # Build association. This method is used internally to
-      # build serializer's association by its reflection.
-      #
-      # @param [Serializer] parent_serializer for given association
-      # @param [Hash{Symbol => Object}] parent_serializer_options
-      #
-      # @example
-      #    # Given the following serializer defined:
-      #    class PostSerializer < ActiveModel::Serializer
-      #      has_many :comments, serializer: CommentSummarySerializer
-      #    end
-      #
-      #    # Then you instantiate your serializer
-      #    post_serializer = PostSerializer.new(post, foo: 'bar') #
-      #    # to build association for comments you need to get reflection
-      #    comments_reflection = PostSerializer._reflections.detect { |r| r.name == :comments }
-      #    # and #build_association
-      #    comments_reflection.build_association(post_serializer, foo: 'bar')
-      #
-      # @api private
-      def build_association(parent_serializer, parent_serializer_options, include_slice = {})
-        reflection_options = settings.merge(include_data: include_data?(include_slice)) unless block?
-
-        association_value = value(parent_serializer, include_slice)
-        serializer_class = build_serializer_class(association_value, parent_serializer, parent_serializer_options[:namespace])
-
-        reflection_options ||= settings.merge(include_data: include_data?(include_slice)) # Needs to be after association_value is evaluated unless reflection.block.nil?
-
-        if serializer_class
-          if (serializer = build_serializer!(association_value, serializer_class, parent_serializer, parent_serializer_options))
-            reflection_options[:serializer] = serializer
-          else
-            # BUG: per #2027, JSON API resource relationships are only id and type, and hence either
-            # *require* a serializer or we need to be a little clever about figuring out the id/type.
-            # In either case, returning the raw virtual value will almost always be incorrect.
-            #
-            # Should be reflection_options[:virtual_value] or adapter needs to figure out what to do
-            # with an object that is non-nil and has no defined serializer.
-            reflection_options[:virtual_value] = association_value.try(:as_json) || association_value
-          end
-        elsif !association_value.nil? && !association_value.instance_of?(Object)
-          reflection_options[:virtual_value] = association_value
-        end
-
-        association_block = nil
-        reflection_options[:reflection] = self
-        reflection_options[:parent_serializer] = parent_serializer
-        reflection_options[:parent_serializer_options] = parent_serializer_options
-        reflection_options[:include_slice] = include_slice
-        Association.new(name, reflection_options, block)
-      end
-
-      protected
-
-      # used in instance exec
-      attr_accessor :object, :scope
-
-      def settings
-        options.dup.reject { |k, _| !REFLECTION_OPTIONS.include?(k) }
-      end
-
-      # Evaluation of the reflection.block will mutate options.
-      # So, the settings cannot be used until the block is evaluated.
-      # This means that each time the block is evaluated, it may set a new
-      # value in the reflection instance. This is not thread-safe.
-      # @example
-      #   has_many :likes do
-      #     meta liked: object.likes.any?
-      #     include_data: object.loaded?
-      #   end
-      def block?
-        !block.nil?
-      end
-
-      def serializer?
-        options.key?(:serializer)
-      end
-
-      def serializer
-        options[:serializer]
-      end
-
-      def namespace
-        options[:namespace]
-      end
-
       def include_data?(include_slice)
         include_data_setting = options[:include_data_setting]
         case include_data_setting
@@ -238,42 +150,39 @@ def value(serializer, include_slice)
         end
       end
 
-      def build_serializer!(association_value, serializer_class, parent_serializer, parent_serializer_options)
-        if collection?
-          build_association_collection_serializer(parent_serializer, parent_serializer_options, association_value, serializer_class)
-        else
-          build_association_serializer(parent_serializer, parent_serializer_options, association_value, serializer_class)
-        end
-      end
-
-      def build_serializer_class(association_value, parent_serializer, parent_serializer_namespace_option)
-        serializer_for_options = {
-          # Pass the parent's namespace onto the child serializer
-          namespace: namespace || parent_serializer_namespace_option
+      # Build association. This method is used internally to
+      # build serializer's association by its reflection.
+      #
+      # @param [Serializer] parent_serializer for given association
+      # @param [Hash{Symbol => Object}] parent_serializer_options
+      #
+      # @example
+      #    # Given the following serializer defined:
+      #    class PostSerializer < ActiveModel::Serializer
+      #      has_many :comments, serializer: CommentSummarySerializer
+      #    end
+      #
+      #    # Then you instantiate your serializer
+      #    post_serializer = PostSerializer.new(post, foo: 'bar') #
+      #    # to build association for comments you need to get reflection
+      #    comments_reflection = PostSerializer._reflections.detect { |r| r.name == :comments }
+      #    # and #build_association
+      #    comments_reflection.build_association(post_serializer, foo: 'bar')
+      #
+      # @api private
+      def build_association(parent_serializer, parent_serializer_options, include_slice = {})
+        association_options = {
+          parent_serializer: parent_serializer,
+          parent_serializer_options: parent_serializer_options,
+          include_slice: include_slice
         }
-        serializer_for_options[:serializer] = serializer if serializer?
-        parent_serializer.class.serializer_for(association_value, serializer_for_options)
+        Association.new(self, association_options)
       end
 
-      # NOTE(BF): This serializer throw/catch should only happen when the serializer is a collection
-      # serializer.
-      #
-      # @return [ActiveModel::Serializer, nil]
-      def build_association_collection_serializer(parent_serializer, parent_serializer_options, association_value, serializer_class)
-        catch(:no_serializer) do
-          build_association_serializer(parent_serializer, parent_serializer_options, association_value, serializer_class)
-        end
-      end
+      protected
 
-      # @return [ActiveModel::Serializer, nil]
-      def build_association_serializer(parent_serializer, parent_serializer_options, association_value, serializer_class)
-        # Make all the parent serializer instance options available to associations
-        # except ActiveModelSerializers-specific ones we don't want.
-        serializer_options = parent_serializer_options.except(:serializer)
-        serializer_options[:serializer_context_class] = parent_serializer.class
-        serializer_options[:serializer] = serializer if serializer
-        serializer_class.new(association_value, serializer_options)
-      end
+      # used in instance exec
+      attr_accessor :object, :scope
     end
   end
 end

lib/active_model_serializers/adapter/json_api/relationship.rb

@@ -34,13 +34,34 @@ def as_json
         private
 
         def data_for(association)
+          if association.collection?
+            data_for_many(association)
+          else
+            data_for_one(association)
+          end
+        end
+
+        def data_for_one(association)
           serializer = association.lazy_association.serializer
-          if serializer.respond_to?(:each)
-            serializer.map { |s| ResourceIdentifier.new(s, serializable_resource_options).as_json }
-          elsif (virtual_value = association.virtual_value)
+          if (virtual_value = association.virtual_value)
             virtual_value
-          elsif serializer && serializer.object
+          elsif serializer && association.object
             ResourceIdentifier.new(serializer, serializable_resource_options).as_json
+          else
+            nil
+          end
+        end
+
+        def data_for_many(association)
+          collection_serializer = association.lazy_association.serializer
+          if collection_serializer.respond_to?(:each)
+            collection_serializer.map do |serializer|
+              ResourceIdentifier.new(serializer, serializable_resource_options).as_json
+            end
+          elsif (virtual_value = association.virtual_value)
+            virtual_value
+          else
+            []
           end
         end