active_model_serializers 0.9.0 → 0.10.12

data/lib/action_controller/serialization.rb

@@ -1,79 +1,75 @@
+# frozen_string_literal: true
+
 require 'active_support/core_ext/class/attribute'
+require 'active_model_serializers/serialization_context'
 
 module ActionController
-  # Action Controller Serialization
-  #
-  # Overrides render :json to check if the given object implements +active_model_serializer+
-  # as a method. If so, use the returned serializer instead of calling +to_json+ on the object.
-  #
-  # This module also provides a serialization_scope method that allows you to configure the
-  # +serialization_scope+ of the serializer. Most apps will likely set the +serialization_scope+
-  # to the current user:
-  #
-  #    class ApplicationController < ActionController::Base
-  #      serialization_scope :current_user
-  #    end
-  #
-  # If you need more complex scope rules, you can simply override the serialization_scope:
-  #
-  #    class ApplicationController < ActionController::Base
-  #      private
-  #
-  #      def serialization_scope
-  #        current_user
-  #      end
-  #    end
-  #
   module Serialization
     extend ActiveSupport::Concern
 
     include ActionController::Renderers
 
-    class << self
-      attr_accessor :enabled
+    module ClassMethods
+      def serialization_scope(scope)
+        self._serialization_scope = scope
+      end
     end
-    self.enabled = true
 
     included do
       class_attribute :_serialization_scope
       self._serialization_scope = :current_user
-    end
 
-    module ClassMethods
-      def serialization_scope(scope)
-        self._serialization_scope = scope
-      end
+      attr_writer :namespace_for_serializer
     end
 
-    def _render_option_json(resource, options)
-      serializer = build_json_serializer(resource, options)
+    def namespace_for_serializer
+      @namespace_for_serializer ||= namespace_for_class(self.class) unless namespace_for_class(self.class) == Object
+    end
 
-      if serializer
-        super(serializer, options)
+    def namespace_for_class(klass)
+      if Module.method_defined?(:module_parent)
+        klass.module_parent
       else
-        super
+        klass.parent
       end
     end
 
-    private
+    def serialization_scope
+      return unless _serialization_scope && respond_to?(_serialization_scope, true)
 
-    def default_serializer_options
-      {}
+      send(_serialization_scope)
     end
 
-    def serialization_scope
-      _serialization_scope = self.class._serialization_scope
-      send(_serialization_scope) if _serialization_scope && respond_to?(_serialization_scope, true)
-    end
+    def get_serializer(resource, options = {})
+      unless use_adapter?
+        warn 'ActionController::Serialization#use_adapter? has been removed. '\
+          "Please pass 'adapter: false' or see ActiveSupport::SerializableResource.new"
+        options[:adapter] = false
+      end
+
+      options.fetch(:namespace) { options[:namespace] = namespace_for_serializer }
 
-    def build_json_serializer(resource, options = {})
-      options = default_serializer_options.merge(options)
+      serializable_resource = ActiveModelSerializers::SerializableResource.new(resource, options)
+      serializable_resource.serialization_scope ||= options.fetch(:scope) { serialization_scope }
+      serializable_resource.serialization_scope_name = options.fetch(:scope_name) { _serialization_scope }
+      # For compatibility with the JSON renderer: `json.to_json(options) if json.is_a?(String)`.
+      # Otherwise, since `serializable_resource` is not a string, the renderer would call
+      # `to_json` on a String and given odd results, such as `"".to_json #=> '""'`
+      serializable_resource.adapter.is_a?(String) ? serializable_resource.adapter : serializable_resource
+    end
 
-      if serializer = options.fetch(:serializer, ActiveModel::Serializer.serializer_for(resource))
-        options[:scope] = serialization_scope unless options.has_key?(:scope)
-        options[:resource_name] = controller_name if resource.respond_to?(:to_ary)
+    # Deprecated
+    def use_adapter?
+      true
+    end
 
-        serializer.new(resource, options)
+    [:_render_option_json, :_render_with_renderer_json].each do |renderer_method|
+      define_method renderer_method do |resource, options|
+        options.fetch(:serialization_context) do
+          options[:serialization_context] = ActiveModelSerializers::SerializationContext.new(request, options)
+        end
+        serializable_resource = get_serializer(resource, options)
+        super(serializable_resource, options)
       end
     end
   end

data/lib/active_model/serializable_resource.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module ActiveModel
+  class SerializableResource
+    class << self
+      extend ActiveModelSerializers::Deprecate
+
+      delegate_and_deprecate :new, ActiveModelSerializers::SerializableResource
+    end
+  end
+end

data/lib/active_model/serializer.rb

@@ -1,268 +1,425 @@
-require 'active_model/array_serializer'
-require 'active_model/serializable'
-require 'active_model/serializer/associations'
-require 'active_model/serializer/config'
-
-require 'thread'
-
+# frozen_string_literal: true
+
+require 'jsonapi/include_directive'
+require 'active_model/serializer/collection_serializer'
+require 'active_model/serializer/array_serializer'
+require 'active_model/serializer/error_serializer'
+require 'active_model/serializer/errors_serializer'
+require 'active_model/serializer/concerns/caching'
+require 'active_model/serializer/fieldset'
+require 'active_model/serializer/lint'
+
+# ActiveModel::Serializer is an abstract class that is
+# reified when subclassed to decorate a resource.
 module ActiveModel
   class Serializer
-    include Serializable
-
-    @mutex = Mutex.new
+    undef_method :select, :display # These IO methods, which are mixed into Kernel,
+    # sometimes conflict with attribute names. We don't need these IO methods.
+
+    # @see #serializable_hash for more details on these valid keys.
+    SERIALIZABLE_HASH_VALID_KEYS = [:only, :except, :methods, :include, :root].freeze
+    extend ActiveSupport::Autoload
+    eager_autoload do
+      autoload :Adapter
+      autoload :Null
+      autoload :Attribute
+      autoload :Link
+      autoload :Association
+      autoload :Reflection
+      autoload :BelongsToReflection
+      autoload :HasOneReflection
+      autoload :HasManyReflection
+    end
+    include ActiveSupport::Configurable
+    include Caching
+
+    # @param resource [ActiveRecord::Base, ActiveModelSerializers::Model]
+    # @return [ActiveModel::Serializer]
+    #   Preferentially returns
+    #   1. resource.serializer_class
+    #   2. ArraySerializer when resource is a collection
+    #   3. options[:serializer]
+    #   4. lookup serializer when resource is a Class
+    def self.serializer_for(resource_or_class, options = {})
+      if resource_or_class.respond_to?(:serializer_class)
+        resource_or_class.serializer_class
+      elsif resource_or_class.respond_to?(:to_ary)
+        config.collection_serializer
+      else
+        resource_class = resource_or_class.class == Class ? resource_or_class : resource_or_class.class
+        options.fetch(:serializer) { get_serializer_for(resource_class, options[:namespace]) }
+      end
+    end
 
+    # @see ActiveModelSerializers::Adapter.lookup
+    # Deprecated
+    def self.adapter
+      ActiveModelSerializers::Adapter.lookup(config.adapter)
+    end
     class << self
-      def inherited(base)
-        base._root = _root
-        base._attributes = (_attributes || []).dup
-        base._associations = (_associations || {}).dup
-      end
+      extend ActiveModelSerializers::Deprecate
+      deprecate :adapter, 'ActiveModelSerializers::Adapter.configured_adapter'
+    end
 
-      def setup
-        @mutex.synchronize do
-          yield CONFIG
-        end
-      end
+    # @api private
+    def self.serializer_lookup_chain_for(klass, namespace = nil)
+      lookups = ActiveModelSerializers.config.serializer_lookup_chain
+      Array[*lookups].flat_map do |lookup|
+        lookup.call(klass, self, namespace)
+      end.compact
+    end
 
-      EMBED_IN_ROOT_OPTIONS = [
-        :include,
-        :embed_in_root,
-        :embed_in_root_key,
-        :embed_namespace
-      ].freeze
-
-      def embed(type, options={})
-        CONFIG.embed = type
-        if EMBED_IN_ROOT_OPTIONS.any? { |opt| options[opt].present? }
-          CONFIG.embed_in_root = true
-        end
-        if options[:embed_in_root_key].present?
-          CONFIG.embed_in_root_key = options[:embed_in_root_key]
+    # Used to cache serializer name => serializer class
+    # when looked up by Serializer.get_serializer_for.
+    def self.serializers_cache
+      @serializers_cache ||= Concurrent::Map.new
+    end
+
+    # @api private
+    # Find a serializer from a class and caches the lookup.
+    # Preferentially returns:
+    #   1. class name appended with "Serializer"
+    #   2. try again with superclass, if present
+    #   3. nil
+    def self.get_serializer_for(klass, namespace = nil)
+      return nil unless config.serializer_lookup_enabled
+
+      cache_key = ActiveSupport::Cache.expand_cache_key(klass, namespace)
+      serializers_cache.fetch_or_store(cache_key) do
+        # NOTE(beauby): When we drop 1.9.3 support we can lazify the map for perfs.
+        lookup_chain = serializer_lookup_chain_for(klass, namespace)
+        serializer_class = lookup_chain.map(&:safe_constantize).find { |x| x && x < ActiveModel::Serializer }
+
+        if serializer_class
+          serializer_class
+        elsif klass.superclass
+          get_serializer_for(klass.superclass, namespace)
+        else
+          nil # No serializer found
         end
-        ActiveSupport::Deprecation.warn <<-WARN
-** Notice: embed is deprecated. **
-The use of .embed method on a Serializer will be soon removed, as this should have a global scope and not a class scope.
-Please use the global .setup method instead:
-ActiveModel::Serializer.setup do |config|
-  config.embed = :#{type}
-  config.embed_in_root = #{CONFIG.embed_in_root || false}
-end
-        WARN
       end
+    end
 
-      def format_keys(format)
-        @key_format = format
-      end
-      attr_reader :key_format
-
-      if RUBY_VERSION >= '2.0'
-        def serializer_for(resource)
-          if resource.respond_to?(:to_ary)
-            if Object.constants.include?(:ArraySerializer)
-              ::ArraySerializer
-            else
-              ArraySerializer
-            end
-          else
-            begin
-              Object.const_get "#{resource.class.name}Serializer"
-            rescue NameError
-              nil
-            end
-          end
-        end
+    # @api private
+    def self.include_directive_from_options(options)
+      if options[:include_directive]
+        options[:include_directive]
+      elsif options[:include]
+        JSONAPI::IncludeDirective.new(options[:include], allow_wildcard: true)
       else
-        def serializer_for(resource)
-          if resource.respond_to?(:to_ary)
-            if Object.constants.include?(:ArraySerializer)
-              ::ArraySerializer
-            else
-              ArraySerializer
-            end
-          else
-            "#{resource.class.name}Serializer".safe_constantize
-          end
-        end
+        ActiveModelSerializers.default_include_directive
       end
+    end
 
-      attr_accessor :_root, :_attributes, :_associations
-      alias root  _root=
-      alias root= _root=
+    # @api private
+    def self.serialization_adapter_instance
+      @serialization_adapter_instance ||= ActiveModelSerializers::Adapter::Attributes
+    end
 
-      def root_name
-        name.demodulize.underscore.sub(/_serializer$/, '') if name
-      end
+    # Preferred interface is ActiveModelSerializers.config
+    # BEGIN DEFAULT CONFIGURATION
+    config.collection_serializer = ActiveModel::Serializer::CollectionSerializer
+    config.serializer_lookup_enabled = true
 
-      def attributes(*attrs)
-        @_attributes.concat attrs
+    # @deprecated Use {#config.collection_serializer=} instead of this. Is
+    #   compatibility layer for ArraySerializer.
+    def config.array_serializer=(collection_serializer)
+      self.collection_serializer = collection_serializer
+    end
 
-        attrs.each do |attr|
-          define_method attr do
-            object.read_attribute_for_serialization attr
-          end unless method_defined?(attr)
-        end
-      end
+    # @deprecated Use {#config.collection_serializer} instead of this. Is
+    #   compatibility layer for ArraySerializer.
+    def config.array_serializer
+      collection_serializer
+    end
 
-      def has_one(*attrs)
-        associate(Association::HasOne, *attrs)
-      end
+    config.default_includes = '*'
+    config.adapter = :attributes
+    config.key_transform = nil
+    config.jsonapi_pagination_links_enabled = true
+    config.jsonapi_resource_type = :plural
+    config.jsonapi_namespace_separator = '-'.freeze
+    config.jsonapi_version = '1.0'
+    config.jsonapi_toplevel_meta = {}
+    # Make JSON API top-level jsonapi member opt-in
+    # ref: http://jsonapi.org/format/#document-top-level
+    config.jsonapi_include_toplevel_object = false
+    config.jsonapi_use_foreign_key_on_belongs_to_relationship = false
+    config.include_data_default = true
+
+    # For configuring how serializers are found.
+    # This should be an array of procs.
+    #
+    # The priority of the output is that the first item
+    # in the evaluated result array will take precedence
+    # over other possible serializer paths.
+    #
+    # i.e.: First match wins.
+    #
+    # @example output
+    # => [
+    #   "CustomNamespace::ResourceSerializer",
+    #   "ParentSerializer::ResourceSerializer",
+    #   "ResourceNamespace::ResourceSerializer" ,
+    #   "ResourceSerializer"]
+    #
+    # If CustomNamespace::ResourceSerializer exists, it will be used
+    # for serialization
+    config.serializer_lookup_chain = ActiveModelSerializers::LookupChain::DEFAULT.dup
+
+    config.schema_path = 'test/support/schemas'
+    # END DEFAULT CONFIGURATION
+
+    with_options instance_writer: false, instance_reader: false do |serializer|
+      serializer.class_attribute :_attributes_data # @api private
+      self._attributes_data ||= {}
+    end
+    with_options instance_writer: false, instance_reader: true do |serializer|
+      serializer.class_attribute :_reflections
+      self._reflections ||= {}
+      serializer.class_attribute :_links # @api private
+      self._links ||= {}
+      serializer.class_attribute :_meta # @api private
+      serializer.class_attribute :_type # @api private
+    end
 
-      def has_many(*attrs)
-        associate(Association::HasMany, *attrs)
-      end
+    def self.inherited(base)
+      super
+      base._attributes_data = _attributes_data.dup
+      base._reflections = _reflections.dup
+      base._links = _links.dup
+    end
 
-      private
+    # @return [Array<Symbol>] Key names of declared attributes
+    # @see Serializer::attribute
+    def self._attributes
+      _attributes_data.keys
+    end
 
-      def associate(klass, *attrs)
-        options = attrs.extract_options!
+    # BEGIN SERIALIZER MACROS
 
-        attrs.each do |attr|
-          define_method attr do
-            object.send attr
-          end unless method_defined?(attr)
+    # @example
+    #   class AdminAuthorSerializer < ActiveModel::Serializer
+    #     attributes :id, :name, :recent_edits
+    def self.attributes(*attrs)
+      attrs = attrs.first if attrs.first.class == Array
 
-          @_associations[attr] = klass.new(attr, options)
-        end
+      attrs.each do |attr|
+        attribute(attr)
       end
     end
 
-    def initialize(object, options={})
-      @object        = object
-      @scope         = options[:scope]
-      @root          = options.fetch(:root, self.class._root)
-      @meta_key      = options[:meta_key] || :meta
-      @meta          = options[@meta_key]
-      @wrap_in_array = options[:_wrap_in_array]
-      @only          = options[:only] ? Array(options[:only]) : nil
-      @except        = options[:except] ? Array(options[:except]) : nil
-      @key_format    = options[:key_format]
-      @context       = options[:context]
+    # @example
+    #   class AdminAuthorSerializer < ActiveModel::Serializer
+    #     attributes :id, :recent_edits
+    #     attribute :name, key: :title
+    #
+    #     attribute :full_name do
+    #       "#{object.first_name} #{object.last_name}"
+    #     end
+    #
+    #     def recent_edits
+    #       object.edits.last(5)
+    #     end
+    def self.attribute(attr, options = {}, &block)
+      key = options.fetch(:key, attr)
+      _attributes_data[key] = Attribute.new(attr, options, block)
     end
-    attr_accessor :object, :scope, :root, :meta_key, :meta, :key_format, :context
 
-    def json_key
-      key = if root == true || root.nil?
-        self.class.root_name
-      else
-        root
-      end
+    # @param [Symbol] name of the association
+    # @param [Hash<Symbol => any>] options for the reflection
+    # @return [void]
+    #
+    # @example
+    #  has_many :comments, serializer: CommentSummarySerializer
+    #
+    def self.has_many(name, options = {}, &block) # rubocop:disable Style/PredicateName
+      associate(HasManyReflection.new(name, options, block))
+    end
 
-      key_format == :lower_camel && key.present? ? key.camelize(:lower) : key
+    # @param [Symbol] name of the association
+    # @param [Hash<Symbol => any>] options for the reflection
+    # @return [void]
+    #
+    # @example
+    #  belongs_to :author, serializer: AuthorSerializer
+    #
+    def self.belongs_to(name, options = {}, &block)
+      associate(BelongsToReflection.new(name, options, block))
     end
 
-    def attributes
-      filter(self.class._attributes.dup).each_with_object({}) do |name, hash|
-        hash[name] = send(name)
-      end
+    # @param [Symbol] name of the association
+    # @param [Hash<Symbol => any>] options for the reflection
+    # @return [void]
+    #
+    # @example
+    #  has_one :author, serializer: AuthorSerializer
+    #
+    def self.has_one(name, options = {}, &block) # rubocop:disable Style/PredicateName
+      associate(HasOneReflection.new(name, options, block))
     end
 
-    def associations
-      associations = self.class._associations
-      included_associations = filter(associations.keys)
-      associations.each_with_object({}) do |(name, association), hash|
-        if included_associations.include? name
-          if association.embed_ids?
-            ids = serialize_ids association
-            if association.embed_namespace?
-              hash = hash[association.embed_namespace] ||= {}
-              hash[association.key] = ids
-            else
-              hash[association.key] = ids
-            end
-          elsif association.embed_objects?
-            if association.embed_namespace?
-              hash = hash[association.embed_namespace] ||= {}
-            end
-            hash[association.embedded_key] = serialize association
-          end
-        end
-      end
+    # Add reflection and define {name} accessor.
+    # @param [ActiveModel::Serializer::Reflection] reflection
+    # @return [void]
+    #
+    # @api private
+    def self.associate(reflection)
+      key = reflection.options[:key] || reflection.name
+      self._reflections[key] = reflection
+    end
+    private_class_method :associate
+
+    # Define a link on a serializer.
+    # @example
+    #   link(:self) { resource_url(object) }
+    # @example
+    #   link(:self) { "http://example.com/resource/#{object.id}" }
+    # @example
+    #   link :resource, "http://example.com/resource"
+    # @example
+    #   link(:callback, if: :internal?), { "http://example.com/callback" }
+    #
+    def self.link(name, *args, &block)
+      options = args.extract_options!
+      # For compatibility with the use case of passing link directly as string argument
+      # without block, we are creating a wrapping block
+      _links[name] = Link.new(name, options, block || ->(_serializer) { args.first })
     end
 
-    def filter(keys)
-      if @only
-        keys & @only
-      elsif @except
-        keys - @except
-      else
-        keys
-      end
+    # Set the JSON API meta attribute of a serializer.
+    # @example
+    #   class AdminAuthorSerializer < ActiveModel::Serializer
+    #     meta { stuff: 'value' }
+    # @example
+    #     meta do
+    #       { comment_count: object.comments.count }
+    #     end
+    def self.meta(value = nil, &block)
+      self._meta = block || value
     end
 
-    def embedded_in_root_associations
-      associations = self.class._associations
-      included_associations = filter(associations.keys)
-      associations.each_with_object({}) do |(name, association), hash|
-        if included_associations.include? name
-          if association.embed_in_root?
-            if association.embed_in_root_key?
-              hash = hash[association.embed_in_root_key] ||= {}
-            end
-            association_serializer = build_serializer(association)
-            hash.merge!(association_serializer.embedded_in_root_associations) {|key, oldval, newval| [newval, oldval].flatten }
-
-            serialized_data = association_serializer.serializable_object
-            key = association.root_key
-            if hash.has_key?(key)
-              hash[key].concat(serialized_data).uniq!
-            else
-              hash[key] = serialized_data
-            end
-          end
-        end
-      end
+    # Set the JSON API type of a serializer.
+    # @example
+    #   class AdminAuthorSerializer < ActiveModel::Serializer
+    #     type 'authors'
+    def self.type(type)
+      self._type = type && type.to_s
     end
 
-    def build_serializer(association)
-      object = send(association.name)
-      association.build_serializer(object, scope: scope)
+    # END SERIALIZER MACROS
+
+    attr_accessor :object, :root, :scope
+
+    # `scope_name` is set as :current_user by default in the controller.
+    # If the instance does not have a method named `scope_name`, it
+    # defines the method so that it calls the +scope+.
+    def initialize(object, options = {})
+      self.object = object
+      self.instance_options = options
+      self.root = instance_options[:root]
+      self.scope = instance_options[:scope]
+
+      return if !(scope_name = instance_options[:scope_name]) || respond_to?(scope_name)
+
+      define_singleton_method scope_name, -> { scope }
     end
 
-    def serialize(association)
-      build_serializer(association).serializable_object
+    def success?
+      true
     end
 
-    def serialize_ids(association)
-      associated_data = send(association.name)
-      if associated_data.respond_to?(:to_ary)
-        associated_data.map { |elem| elem.read_attribute_for_serialization(association.embed_key) }
-      else
-        associated_data.read_attribute_for_serialization(association.embed_key) if associated_data
+    # Return the +attributes+ of +object+ as presented
+    # by the serializer.
+    def attributes(requested_attrs = nil, reload = false)
+      @attributes = nil if reload
+      @attributes ||= self.class._attributes_data.each_with_object({}) do |(key, attr), hash|
+        next if attr.excluded?(self)
+        next unless requested_attrs.nil? || requested_attrs.include?(key)
+        hash[key] = attr.value(self)
       end
     end
 
-    def key_format
-      @key_format || self.class.key_format || CONFIG.key_format
+    # @param [JSONAPI::IncludeDirective] include_directive (defaults to the
+    #   +default_include_directive+ config value when not provided)
+    # @return [Enumerator<Association>]
+    def associations(include_directive = ActiveModelSerializers.default_include_directive, include_slice = nil)
+      include_slice ||= include_directive
+      return Enumerator.new {} unless object
+
+      Enumerator.new do |y|
+        (self.instance_reflections ||= self.class._reflections.deep_dup).each do |key, reflection|
+          next if reflection.excluded?(self)
+          next unless include_directive.key?(key)
+
+          association = reflection.build_association(self, instance_options, include_slice)
+          y.yield association
+        end
+      end
     end
 
-    def format_key(key)
-      if key_format == :lower_camel
-        key.to_s.camelize(:lower)
-      else
-        key
+    # @return [Hash] containing the attributes and first level
+    # associations, similar to how ActiveModel::Serializers::JSON is used
+    # in ActiveRecord::Base.
+    def serializable_hash(adapter_options = nil, options = {}, adapter_instance = self.class.serialization_adapter_instance)
+      adapter_options ||= {}
+      options[:include_directive] ||= ActiveModel::Serializer.include_directive_from_options(adapter_options)
+      if (fieldset = adapter_options[:fieldset])
+        options[:fields] = fieldset.fields_for(json_key)
       end
+      resource = attributes_hash(adapter_options, options, adapter_instance)
+      relationships = associations_hash(adapter_options, options, adapter_instance)
+      resource.merge(relationships)
     end
+    alias to_hash serializable_hash
+    alias to_h serializable_hash
 
-    def convert_keys(hash)
-      Hash[hash.map do |k,v|
-        key = if k.is_a?(Symbol)
-          format_key(k).to_sym
-        else
-          format_key(k)
+    # @see #serializable_hash
+    def as_json(adapter_opts = nil)
+      serializable_hash(adapter_opts)
+    end
+
+    # Used by adapter as resource root.
+    def json_key
+      root || _type ||
+        begin
+          object.class.model_name.to_s.underscore
+        rescue ArgumentError
+          'anonymous_object'
         end
+    end
+
+    def read_attribute_for_serialization(attr)
+      if respond_to?(attr)
+        send(attr)
+      else
+        object.read_attribute_for_serialization(attr)
+      end
+    end
 
-        [key ,v]
-      end]
+    # @api private
+    def attributes_hash(_adapter_options, options, adapter_instance)
+      if self.class.cache_enabled?
+        fetch_attributes(options[:fields], options[:cached_attributes] || {}, adapter_instance)
+      elsif self.class.fragment_cache_enabled?
+        fetch_attributes_fragment(adapter_instance, options[:cached_attributes] || {})
+      else
+        attributes(options[:fields], true)
+      end
     end
 
-    def serializable_object(options={})
-      return @wrap_in_array ? [] : nil if @object.nil?
-      hash = attributes
-      hash.merge! associations
-      hash = convert_keys(hash) if key_format.present?
-      @wrap_in_array ? [hash] : hash
+    # @api private
+    def associations_hash(adapter_options, options, adapter_instance)
+      include_directive = options.fetch(:include_directive)
+      include_slice = options[:include_slice]
+      associations(include_directive, include_slice).each_with_object({}) do |association, relationships|
+        adapter_opts = adapter_options.merge(include_directive: include_directive[association.key], adapter_instance: adapter_instance)
+        relationships[association.key] = association.serializable_hash(adapter_opts, adapter_instance)
+      end
     end
-    alias_method :serializable_hash, :serializable_object
-  end
 
+    protected
+
+    attr_accessor :instance_options, :instance_reflections
+  end
 end