active_model_serializers 0.10.5 → 0.10.6

data/lib/active_model/serializer/association.rb

@@ -1,34 +1,71 @@
+require 'active_model/serializer/lazy_association'
+
 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 :object, :include_data?, :virtual_value, :collection?, to: :lazy_association
+
+      def initialize(*)
+        super
+        @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 [ActiveModel::Serializer, nil]
-      def serializer
-        options[:serializer]
+      # @return [True,False]
+      def 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 belongs_to?
+        reflection.foreign_key_on == :self
       end
+
+      def polymorphic?
+        true == reflection_options[:polymorphic]
+      end
+
+      # @api private
+      def serializable_hash(adapter_options, adapter_instance)
+        association_serializer = lazy_association.serializer
+        return virtual_value if virtual_value
+        association_object = association_serializer && association_serializer.object
+        return unless association_object
+
+        serialization = association_serializer.serializable_hash(adapter_options, {}, adapter_instance)
+
+        if polymorphic? && serialization
+          polymorphic_type = association_object.class.name.underscore
+          serialization = { type: polymorphic_type, polymorphic_type.to_sym => serialization }
+        end
+
+        serialization
+      end
+
+      private
+
+      delegate :reflection_options, to: :lazy_association
     end
   end
 end

data/lib/active_model/serializer/belongs_to_reflection.rb

@@ -1,7 +1,11 @@
 module ActiveModel
   class Serializer
     # @api private
-    class BelongsToReflection < SingularReflection
+    class BelongsToReflection < Reflection
+      # @api private
+      def foreign_key_on
+        :self
+      end
     end
   end
 end

data/lib/active_model/serializer/concerns/caching.rb

@@ -40,9 +40,9 @@ module ActiveModel
 
       module ClassMethods
         def inherited(base)
-          super
           caller_line = caller[1]
           base._cache_digest_file_path = caller_line
+          super
         end
 
         def _cache_digest
@@ -68,6 +68,18 @@ module ActiveModel
           _cache_options && _cache_options[:skip_digest]
         end
 
+        # @api private
+        # maps attribute value to explicit key name
+        # @see Serializer::attribute
+        # @see Serializer::fragmented_attributes
+        def _attributes_keys
+          _attributes_data
+            .each_with_object({}) do |(key, attr), hash|
+            next if key == attr.name
+            hash[attr.name] = { key: key }
+          end
+        end
+
         def fragmented_attributes
           cached = _cache_only ? _cache_only : _attributes - _cache_except
           cached = cached.map! { |field| _attributes_keys.fetch(field, field) }
@@ -158,6 +170,7 @@ module ActiveModel
 
         # Read cache from cache_store
         # @return [Hash]
+        # Used in CollectionSerializer to set :cached_attributes
         def cache_read_multi(collection_serializer, adapter_instance, include_directive)
           return {} if ActiveModelSerializers.config.cache_store.blank?
 
@@ -180,12 +193,14 @@ module ActiveModel
             cache_keys << object_cache_key(serializer, adapter_instance)
 
             serializer.associations(include_directive).each do |association|
-              if association.serializer.respond_to?(:each)
-                association.serializer.each do |sub_serializer|
+              # TODO(BF): Process relationship without evaluating lazy_association
+              association_serializer = association.lazy_association.serializer
+              if association_serializer.respond_to?(:each)
+                association_serializer.each do |sub_serializer|
                   cache_keys << object_cache_key(sub_serializer, adapter_instance)
                 end
               else
-                cache_keys << object_cache_key(association.serializer, adapter_instance)
+                cache_keys << object_cache_key(association_serializer, adapter_instance)
               end
             end
           end
@@ -203,23 +218,18 @@ module ActiveModel
 
       ### INSTANCE METHODS
       def fetch_attributes(fields, cached_attributes, adapter_instance)
-        if serializer_class.cache_enabled?
-          key = cache_key(adapter_instance)
-          cached_attributes.fetch(key) do
-            serializer_class.cache_store.fetch(key, serializer_class._cache_options) do
-              attributes(fields, true)
-            end
+        key = cache_key(adapter_instance)
+        cached_attributes.fetch(key) do
+          fetch(adapter_instance, serializer_class._cache_options, key) do
+            attributes(fields, true)
           end
-        elsif serializer_class.fragment_cache_enabled?
-          fetch_attributes_fragment(adapter_instance, cached_attributes)
-        else
-          attributes(fields, true)
         end
       end
 
-      def fetch(adapter_instance, cache_options = serializer_class._cache_options)
+      def fetch(adapter_instance, cache_options = serializer_class._cache_options, key = nil)
         if serializer_class.cache_store
-          serializer_class.cache_store.fetch(cache_key(adapter_instance), cache_options) do
+          key ||= cache_key(adapter_instance)
+          serializer_class.cache_store.fetch(key, cache_options) do
             yield
           end
         else
@@ -230,7 +240,6 @@ module ActiveModel
       # 1. Determine cached fields from serializer class options
       # 2. Get non_cached_fields and fetch cache_fields
       # 3. Merge the two hashes using adapter_instance#fragment_cache
-      # rubocop:disable Metrics/AbcSize
       def fetch_attributes_fragment(adapter_instance, cached_attributes = {})
         serializer_class._cache_options ||= {}
         serializer_class._cache_options[:key] = serializer_class._cache_key if serializer_class._cache_key
@@ -239,22 +248,21 @@ 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)
         cached_hash =
           cached_attributes.fetch(key) do
-            serializer_class.cache_store.fetch(key, serializer_class._cache_options) do
+            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
         adapter_instance.fragment_cache(cached_hash, non_cached_hash)
       end
-      # rubocop:enable Metrics/AbcSize
 
       def cache_key(adapter_instance)
         return @cache_key if defined?(@cache_key)

data/lib/active_model/serializer/has_many_reflection.rb

@@ -1,7 +1,10 @@
 module ActiveModel
   class Serializer
     # @api private
-    class HasManyReflection < CollectionReflection
+    class HasManyReflection < Reflection
+      def collection?
+        true
+      end
     end
   end
 end

data/lib/active_model/serializer/has_one_reflection.rb

@@ -1,7 +1,7 @@
 module ActiveModel
   class Serializer
     # @api private
-    class HasOneReflection < SingularReflection
+    class HasOneReflection < Reflection
     end
   end
 end

data/lib/active_model/serializer/lazy_association.rb

@@ -0,0 +1,95 @@
+module ActiveModel
+  class Serializer
+    # @api private
+    LazyAssociation = Struct.new(:reflection, :association_options) do
+      REFLECTION_OPTIONS = %i(key links polymorphic meta serializer virtual_value namespace).freeze
+
+      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?
+        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
+        cached_result[:virtual_value] || reflection_options[:virtual_value]
+      end
+
+      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
+
+      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 namespace
+        reflection_options[:namespace] ||
+          association_options.fetch(:parent_serializer_options)[:namespace]
+      end
+    end
+  end
+end

data/lib/active_model/serializer/reflection.rb

@@ -1,4 +1,5 @@
 require 'active_model/serializer/field'
+require 'active_model/serializer/association'
 
 module ActiveModel
   class Serializer
@@ -8,12 +9,26 @@ module ActiveModel
     # @example
     #   class PostSerializer < ActiveModel::Serializer
     #     has_one :author, serializer: AuthorSerializer
+    #     belongs_to :boss, type: :users, foreign_key: :boss_id
     #     has_many :comments
     #     has_many :comments, key: :last_comments do
     #       object.comments.last(1)
     #     end
     #     has_many :secret_meta_data, if: :is_admin?
     #
+    #     has_one :blog do |serializer|
+    #       meta count: object.roles.count
+    #       serializer.cached_blog
+    #     end
+    #
+    #     private
+    #
+    #     def cached_blog
+    #       cache_store.fetch("cached_blog:#{object.updated_at}") do
+    #         Blog.find(object.blog_id)
+    #       end
+    #     end
+    #
     #     def is_admin?
     #       current_user.admin?
     #     end
@@ -23,52 +38,118 @@ module ActiveModel
     #  1) as 'comments' and named 'comments'.
     #  2) as 'object.comments.last(1)' and named 'last_comments'.
     #
-    #  PostSerializer._reflections #=>
-    #    # [
-    #    #   HasOneReflection.new(:author, serializer: AuthorSerializer),
-    #    #   HasManyReflection.new(:comments)
-    #    #   HasManyReflection.new(:comments, { key: :last_comments }, #<Block>)
-    #    #   HasManyReflection.new(:secret_meta_data, { if: :is_admin? })
-    #    # ]
+    #  PostSerializer._reflections # =>
+    #    # {
+    #    #   author: HasOneReflection.new(:author, serializer: AuthorSerializer),
+    #    #   comments: HasManyReflection.new(:comments)
+    #    #   last_comments: HasManyReflection.new(:comments, { key: :last_comments }, #<Block>)
+    #    #   secret_meta_data: HasManyReflection.new(:secret_meta_data, { if: :is_admin? })
+    #    # }
     #
     # So you can inspect reflections in your Adapters.
-    #
     class Reflection < Field
+      attr_reader :foreign_key, :type
+
       def initialize(*)
         super
-        @_links = {}
-        @_include_data = Serializer.config.include_data_default
-        @_meta = nil
+        options[:links] = {}
+        options[:include_data_setting] = Serializer.config.include_data_default
+        options[:meta] = nil
+        @type = options.fetch(:type) do
+          class_name = options.fetch(:class_name, name.to_s.camelize.singularize)
+          class_name.underscore.pluralize.to_sym
+        end
+        @foreign_key = options.fetch(:foreign_key) do
+          if collection?
+            "#{name.to_s.singularize}_ids".to_sym
+          else
+            "#{name}_id".to_sym
+          end
+        end
       end
 
-      def link(name, value = nil, &block)
-        @_links[name] = block || value
+      # @api public
+      # @example
+      #   has_one :blog do
+      #     include_data false
+      #     link :self, 'a link'
+      #     link :related, 'another link'
+      #     link :self, '//example.com/link_author/relationships/bio'
+      #     id = object.profile.id
+      #     link :related do
+      #       "//example.com/profiles/#{id}" if id != 123
+      #     end
+      #     link :related do
+      #       ids = object.likes.map(&:id).join(',')
+      #       href "//example.com/likes/#{ids}"
+      #       meta ids: ids
+      #     end
+      #   end
+      def link(name, value = nil)
+        options[:links][name] = block_given? ? Proc.new : value
         :nil
       end
 
-      def meta(value = nil, &block)
-        @_meta = block || value
+      # @api public
+      # @example
+      #   has_one :blog do
+      #     include_data false
+      #     meta(id: object.blog.id)
+      #     meta liked: object.likes.any?
+      #     link :self do
+      #       href object.blog.id.to_s
+      #       meta(id: object.blog.id)
+      #     end
+      def meta(value = nil)
+        options[:meta] = block_given? ? Proc.new : value
         :nil
       end
 
+      # @api public
+      # @example
+      #   has_one :blog do
+      #     include_data false
+      #     link :self, 'a link'
+      #     link :related, 'another link'
+      #   end
+      #
+      #   has_one :blog do
+      #     include_data false
+      #     link :self, 'a link'
+      #     link :related, 'another link'
+      #   end
+      #
+      #    belongs_to :reviewer do
+      #      meta name: 'Dan Brown'
+      #      include_data true
+      #    end
+      #
+      #    has_many :tags, serializer: TagSerializer do
+      #      link :self, '//example.com/link_author/relationships/tags'
+      #      include_data :if_sideloaded
+      #    end
       def include_data(value = true)
-        @_include_data = value
+        options[:include_data_setting] = value
         :nil
       end
 
+      def collection?
+        false
+      end
+
+      def include_data?(include_slice)
+        include_data_setting = options[:include_data_setting]
+        case include_data_setting
+        when :if_sideloaded then include_slice.key?(name)
+        when true           then true
+        when false          then false
+        else fail ArgumentError, "Unknown include_data_setting '#{include_data_setting.inspect}'"
+        end
+      end
+
       # @param serializer [ActiveModel::Serializer]
       # @yield [ActiveModel::Serializer]
       # @return [:nil, associated resource or resource collection]
-      # @example
-      #   has_one :blog do |serializer|
-      #     serializer.cached_blog
-      #   end
-      #
-      #   def cached_blog
-      #     cache_store.fetch("cached_blog:#{object.updated_at}") do
-      #       Blog.find(object.blog_id)
-      #     end
-      #   end
       def value(serializer, include_slice)
         @object = serializer.object
         @scope = serializer.scope
@@ -83,6 +164,11 @@ module ActiveModel
         end
       end
 
+      # @api private
+      def foreign_key_on
+        :related
+      end
+
       # Build association. This method is used internally to
       # build serializer's association by its reflection.
       #
@@ -103,61 +189,19 @@ module ActiveModel
       #    comments_reflection.build_association(post_serializer, foo: 'bar')
       #
       # @api private
-      #
       def build_association(parent_serializer, parent_serializer_options, include_slice = {})
-        reflection_options = options.dup
-
-        # Pass the parent's namespace onto the child serializer
-        reflection_options[:namespace] ||= parent_serializer_options[:namespace]
-
-        association_value = value(parent_serializer, include_slice)
-        serializer_class = parent_serializer.class.serializer_for(association_value, reflection_options)
-        reflection_options[:include_data] = include_data?(include_slice)
-        reflection_options[:links] = @_links
-        reflection_options[:meta] = @_meta
-
-        if serializer_class
-          serializer = catch(:no_serializer) do
-            serializer_class.new(
-              association_value,
-              serializer_options(parent_serializer, parent_serializer_options, reflection_options)
-            )
-          end
-          if serializer.nil?
-            reflection_options[:virtual_value] = association_value.try(:as_json) || association_value
-          else
-            reflection_options[:serializer] = serializer
-          end
-        elsif !association_value.nil? && !association_value.instance_of?(Object)
-          reflection_options[:virtual_value] = association_value
-        end
-
-        block = nil
-        Association.new(name, reflection_options, block)
+        association_options = {
+          parent_serializer: parent_serializer,
+          parent_serializer_options: parent_serializer_options,
+          include_slice: include_slice
+        }
+        Association.new(self, association_options)
       end
 
       protected
 
+      # used in instance exec
       attr_accessor :object, :scope
-
-      private
-
-      def include_data?(include_slice)
-        if @_include_data == :if_sideloaded
-          include_slice.key?(name)
-        else
-          @_include_data
-        end
-      end
-
-      def serializer_options(parent_serializer, parent_serializer_options, reflection_options)
-        serializer = reflection_options.fetch(:serializer, nil)
-
-        serializer_options = parent_serializer_options.except(:serializer)
-        serializer_options[:serializer] = serializer if serializer
-        serializer_options[:serializer_context_class] = parent_serializer.class
-        serializer_options
-      end
     end
   end
 end