active_model_serializers 0.8.3 → 0.10.8

data/lib/active_model/serializer.rb

@@ -1,515 +1,416 @@
-require "active_support/core_ext/class/attribute"
-require "active_support/core_ext/module/anonymous"
-require 'active_support/dependencies'
-require 'active_support/descendants_tracker'
-
+require 'thread_safe'
+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
-  # Active Model Serializer
-  #
-  # Provides a basic serializer implementation that allows you to easily
-  # control how a given object is going to be serialized. On initialization,
-  # it expects two objects as arguments, a resource and options. For example,
-  # one may do in a controller:
-  #
-  #     PostSerializer.new(@post, :scope => current_user).to_json
-  #
-  # The object to be serialized is the +@post+ and the current user is passed
-  # in for authorization purposes.
-  #
-  # We use the scope to check if a given attribute should be serialized or not.
-  # For example, some attributes may only be returned if +current_user+ is the
-  # author of the post:
-  #
-  #     class PostSerializer < ActiveModel::Serializer
-  #       attributes :title, :body
-  #       has_many :comments
-  #
-  #       private
-  #
-  #       def attributes
-  #         hash = super
-  #         hash.merge!(:email => post.email) if author?
-  #         hash
-  #       end
-  #
-  #       def author?
-  #         post.author == scope
-  #       end
-  #     end
-  #
   class Serializer
-    extend ActiveSupport::DescendantsTracker
-
-    INCLUDE_METHODS = {}
-    INSTRUMENT = { :serialize => :"serialize.serializer", :associations => :"associations.serializer" }
-
-    class IncludeError < StandardError
-      attr_reader :source, :association
-
-      def initialize(source, association)
-        @source, @association = source, association
-      end
-
-      def to_s
-        "Cannot serialize #{association} when #{source} does not have a root!"
+    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
 
-    class_attribute :_attributes
-    self._attributes = {}
-
-    class_attribute :_associations
-    self._associations = {}
-
-    class_attribute :_root
-    class_attribute :_embed
-    self._embed = :objects
-    class_attribute :_root_embed
-
-    class_attribute :cache
-    class_attribute :perform_caching
-
+    # @see ActiveModelSerializers::Adapter.lookup
+    # Deprecated
+    def self.adapter
+      ActiveModelSerializers::Adapter.lookup(config.adapter)
+    end
     class << self
-      # set perform caching like root
-      def cached(value = true)
-        self.perform_caching = value
-      end
-
-      # Define attributes to be used in the serialization.
-      def attributes(*attrs)
-
-        self._attributes = _attributes.dup
-
-        attrs.each do |attr|
-          if Hash === attr
-            attr.each {|attr_real, key| attribute attr_real, :key => key }
-          else
-            attribute attr
-          end
-        end
-      end
-
-      def attribute(attr, options={})
-        self._attributes = _attributes.merge(attr.is_a?(Hash) ? attr : {attr => options[:key] || attr.to_s.gsub(/\?$/, '').to_sym})
-
-        attr = attr.keys[0] if attr.is_a? Hash
-
-        unless method_defined?(attr)
-          define_method attr do
-            object.read_attribute_for_serialization(attr.to_sym)
-          end
-        end
-
-        define_include_method attr
-
-        # protect inheritance chains and open classes
-        # if a serializer inherits from another OR
-        #  attributes are added later in a classes lifecycle
-        # poison the cache
-        define_method :_fast_attributes do
-          raise NameError
-        end
-
-      end
-
-      def associate(klass, attrs) #:nodoc:
-        options = attrs.extract_options!
-        self._associations = _associations.dup
-
-        attrs.each do |attr|
-          unless method_defined?(attr)
-            define_method attr do
-              object.send attr
-            end
-          end
-
-          define_include_method attr
-
-          self._associations[attr] = klass.refine(attr, options)
-        end
-      end
+      extend ActiveModelSerializers::Deprecate
+      deprecate :adapter, 'ActiveModelSerializers::Adapter.configured_adapter'
+    end
 
-      def define_include_method(name)
-        method = "include_#{name}?".to_sym
+    # @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
 
-        INCLUDE_METHODS[name] = method
+    # Used to cache serializer name => serializer class
+    # when looked up by Serializer.get_serializer_for.
+    def self.serializers_cache
+      @serializers_cache ||= ThreadSafe::Cache.new
+    end
 
-        unless method_defined?(method)
-          define_method method do
-            true
-          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)
+        else
+          nil # No serializer found
         end
       end
+    end
 
-      # Defines an association in the object should be rendered.
-      #
-      # The serializer object should implement the association name
-      # as a method which should return an array when invoked. If a method
-      # with the association name does not exist, the association name is
-      # dispatched to the serialized object.
-      def has_many(*attrs)
-        associate(Associations::HasMany, attrs)
-      end
-
-      # Defines an association in the object should be rendered.
-      #
-      # The serializer object should implement the association name
-      # as a method which should return an object when invoked. If a method
-      # with the association name does not exist, the association name is
-      # dispatched to the serialized object.
-      def has_one(*attrs)
-        associate(Associations::HasOne, attrs)
+    # @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
+        ActiveModelSerializers.default_include_directive
       end
+    end
 
-      # Return a schema hash for the current serializer. This information
-      # can be used to generate clients for the serialized output.
-      #
-      # The schema hash has two keys: +attributes+ and +associations+.
-      #
-      # The +attributes+ hash looks like this:
-      #
-      #     { :name => :string, :age => :integer }
-      #
-      # The +associations+ hash looks like this:
-      #     { :posts => { :has_many => :posts } }
-      #
-      # If :key is used:
-      #
-      #     class PostsSerializer < ActiveModel::Serializer
-      #       has_many :posts, :key => :my_posts
-      #     end
-      #
-      # the hash looks like this:
-      #
-      #     { :my_posts => { :has_many => :posts }
-      #
-      # This information is extracted from the serializer's model class,
-      # which is provided by +SerializerClass.model_class+.
-      #
-      # The schema method uses the +columns_hash+ and +reflect_on_association+
-      # methods, provided by default by ActiveRecord. You can implement these
-      # methods on your custom models if you want the serializer's schema method
-      # to work.
-      #
-      # TODO: This is currently coupled to Active Record. We need to
-      # figure out a way to decouple those two.
-      def schema
-        klass = model_class
-        columns = klass.columns_hash
-
-        attrs = {}
-        _attributes.each do |name, key|
-          if column = columns[name.to_s]
-            attrs[key] = column.type
-          else
-            # Computed attribute (method on serializer or model). We cannot
-            # infer the type, so we put nil, unless specified in the attribute declaration
-            if name != key
-              attrs[name] = key
-            else
-              attrs[key] = nil
-            end
-          end
-        end
-
-        associations = {}
-        _associations.each do |attr, association_class|
-          association = association_class.new(attr, self)
-
-          if model_association = klass.reflect_on_association(association.name)
-            # Real association.
-            associations[association.key] = { model_association.macro => model_association.name }
-          else
-            # Computed association. We could infer has_many vs. has_one from
-            # the association class, but that would make it different from
-            # real associations, which read has_one vs. belongs_to from the
-            # model.
-            associations[association.key] = nil
-          end
-        end
+    # @api private
+    def self.serialization_adapter_instance
+      @serialization_adapter_instance ||= ActiveModelSerializers::Adapter::Attributes
+    end
 
-        { :attributes => attrs, :associations => associations }
-      end
+    # Preferred interface is ActiveModelSerializers.config
+    # BEGIN DEFAULT CONFIGURATION
+    config.collection_serializer = ActiveModel::Serializer::CollectionSerializer
+    config.serializer_lookup_enabled = true
 
-      # The model class associated with this serializer.
-      def model_class
-        name.sub(/Serializer$/, '').constantize
-      end
+    # @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
 
-      # Define how associations should be embedded.
-      #
-      #   embed :objects               # Embed associations as full objects
-      #   embed :ids                   # Embed only the association ids
-      #   embed :ids, :include => true # Embed the association ids and include objects in the root
-      #
-      def embed(type, options={})
-        self._embed = type
-        self._root_embed = true if options[:include]
-      end
+    # @deprecated Use {#config.collection_serializer} instead of this. Is
+    #   compatibility layer for ArraySerializer.
+    def config.array_serializer
+      collection_serializer
+    end
 
-      # Defines the root used on serialization. If false, disables the root.
-      def root(name)
-        self._root = name
-      end
-      alias_method :root=, :root
-
-      # Used internally to create a new serializer object based on controller
-      # settings and options for a given resource. These settings are typically
-      # set during the request lifecycle or by the controller class, and should
-      # not be manually defined for this method.
-      def build_json(controller, resource, options)
-        default_options = controller.send(:default_serializer_options) || {}
-        options = default_options.merge(options || {})
-
-        serializer = options.delete(:serializer) ||
-          (resource.respond_to?(:active_model_serializer) &&
-           resource.active_model_serializer)
-
-        return serializer unless serializer
-
-        if resource.respond_to?(:to_ary)
-          unless serializer <= ActiveModel::ArraySerializer
-            raise ArgumentError.new("#{serializer.name} is not an ArraySerializer. " +
-                                    "You may want to use the :each_serializer option instead.")
-          end
-
-          if options[:root] != false && serializer.root != false
-            # the serializer for an Array is ActiveModel::ArraySerializer
-            options[:root] ||= serializer.root || controller.controller_name
-          end
-        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
 
-        options[:scope] = controller.serialization_scope unless options.has_key?(:scope)
-        options[:scope_name] = controller._serialization_scope
-        options[:url_options] = controller.url_options
+    config.schema_path = 'test/support/schemas'
+    # END DEFAULT CONFIGURATION
 
-        serializer.new(resource, options)
-      end
+    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
 
-    attr_reader :object, :options
-
-    def initialize(object, options={})
-      @object, @options = object, options
+    def self.inherited(base)
+      super
+      base._attributes_data = _attributes_data.dup
+      base._reflections = _reflections.dup
+      base._links = _links.dup
+    end
 
-      scope_name = @options[:scope_name]
-      if scope_name && !respond_to?(scope_name)
-        self.class.class_eval do
-          define_method scope_name, lambda { scope }
-        end
-      end
+    # @return [Array<Symbol>] Key names of declared attributes
+    # @see Serializer::attribute
+    def self._attributes
+      _attributes_data.keys
     end
 
-    def root_name
-      return false if self._root == false
+    # BEGIN SERIALIZER MACROS
 
-      class_name = self.class.name.demodulize.underscore.sub(/_serializer$/, '').to_sym unless self.class.name.blank?
+    # @example
+    #   class AdminAuthorSerializer < ActiveModel::Serializer
+    #     attributes :id, :name, :recent_edits
+    def self.attributes(*attrs)
+      attrs = attrs.first if attrs.first.class == Array
 
-      if self._root == true
-        class_name
-      else
-        self._root || class_name
+      attrs.each do |attr|
+        attribute(attr)
       end
     end
 
-    def url_options
-      @options[:url_options] || {}
+    # @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
 
-    def meta_key
-      @options[:meta_key].try(:to_sym) || :meta
+    # @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
 
-    def include_meta(hash)
-      hash[meta_key] = @options[:meta] if @options.has_key?(:meta)
+    # @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 to_json(*args)
-      if perform_caching?
-        cache.fetch expand_cache_key([self.class.to_s.underscore, cache_key, 'to-json']) do
-          super
-        end
-      else
-        super
-      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
 
-    # Returns a json representation of the serializable
-    # object including the root.
-    def as_json(options={})
-      options ||= {}
-      if root = options.fetch(:root, @options.fetch(:root, root_name))
-        @options[:hash] = hash = {}
-        @options[:unique_values] = {}
-
-        hash.merge!(root => serializable_hash)
-        include_meta hash
-        hash
-      else
-        serializable_hash
-      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
-
-    # Returns a hash representation of the serializable
-    # object without the root.
-    def serializable_hash
-      if perform_caching?
-        cache.fetch expand_cache_key([self.class.to_s.underscore, cache_key, 'serializable-hash']) do
-          _serializable_hash
-        end
-      else
-        _serializable_hash
-      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 include_associations!
-      _associations.each_key do |name|
-        include!(name) if include?(name)
-      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 include?(name)
-      return false if @options.key?(:only) && !Array(@options[:only]).include?(name)
-      return false if @options.key?(:except) && Array(@options[:except]).include?(name)
-      send INCLUDE_METHODS[name]
-    end
-
-    def include!(name, options={})
-      # Make sure that if a special options[:hash] was passed in, we generate
-      # a new unique values hash and don't clobber the original. If the hash
-      # passed in is the same as the current options hash, use the current
-      # unique values.
-      #
-      # TODO: Should passing in a Hash even be public API here?
-      unique_values =
-        if hash = options[:hash]
-          if @options[:hash] == hash
-            @options[:unique_values] ||= {}
-          else
-            {}
-          end
-        else
-          hash = @options[:hash]
-          @options[:unique_values] ||= {}
-        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
 
-      node = options[:node] ||= @node
-      value = options[:value]
+    # END SERIALIZER MACROS
 
-      if options[:include] == nil
-        if @options.key?(:include)
-          options[:include] = @options[:include].include?(name)
-        elsif @options.include?(:exclude)
-          options[:include] = !@options[:exclude].include?(name)
-        end
-      end
+    attr_accessor :object, :root, :scope
 
-      association_class =
-        if klass = _associations[name]
-          klass
-        elsif value.respond_to?(:to_ary)
-          Associations::HasMany
-        else
-          Associations::HasOne
-        end
+    # `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]
 
-      association = association_class.new(name, self, options)
+      return if !(scope_name = instance_options[:scope_name]) || respond_to?(scope_name)
 
-      if association.embed_ids?
-        node[association.key] = association.serialize_ids
+      define_singleton_method scope_name, -> { scope }
+    end
 
-        if association.embed_in_root? && hash.nil?
-          raise IncludeError.new(self.class, association.name)
-        elsif association.embed_in_root? && association.embeddable?
-          merge_association hash, association.root, association.serializables, unique_values
-        end
-      elsif association.embed_objects?
-        node[association.key] = association.serialize
-      end
+    def success?
+      true
     end
 
-    # In some cases, an Array of associations is built by merging the associated
-    # content for all of the children. For instance, if a Post has_many comments,
-    # which has_many tags, the top-level :tags key will contain the merged list
-    # of all tags for all comments of the post.
-    #
-    # In order to make this efficient, we store a :unique_values hash containing
-    # a unique list of all of the objects that are already in the Array. This
-    # avoids the need to scan through the Array looking for entries every time
-    # we want to merge a new list of values.
-    def merge_association(hash, key, serializables, unique_values)
-      already_serialized = (unique_values[key] ||= {})
-      serializable_hashes = (hash[key] ||= [])
-
-      serializables.each do |serializable|
-        unless already_serialized.include? serializable.object
-          already_serialized[serializable.object] = true
-          serializable_hashes << serializable.serializable_hash
-        end
+    # 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
 
-    # Returns a hash representation of the serializable
-    # object attributes.
-    def attributes
-      _fast_attributes
-      rescue NameError
-        method = "def _fast_attributes\n"
+    # @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
 
-        method << "  h = {}\n"
+      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)
 
-        _attributes.each do |name,key|
-          method << "  h[:\"#{key}\"] = read_attribute_for_serialization(:\"#{name}\") if include?(:\"#{name}\")\n"
+          association = reflection.build_association(self, instance_options, include_slice)
+          y.yield association
         end
-        method << "  h\nend"
-
-        self.class.class_eval method
-        _fast_attributes
+      end
     end
 
-    # Returns options[:scope]
-    def scope
-      @options[:scope]
+    # @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)
+      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
 
-    alias :read_attribute_for_serialization :send
-
-    def _serializable_hash
-      return nil if @object.nil?
-      @node = attributes
-      include_associations! if _embed
-      @node
+    # @see #serializable_hash
+    def as_json(adapter_opts = nil)
+      serializable_hash(adapter_opts)
     end
 
-    def perform_caching?
-      perform_caching && cache && respond_to?(:cache_key)
+    # Used by adapter as resource root.
+    def json_key
+      root || _type || object.class.model_name.to_s.underscore
     end
 
-    def expand_cache_key(*args)
-      ActiveSupport::Cache.expand_cache_key(args)
+    def read_attribute_for_serialization(attr)
+      if respond_to?(attr)
+        send(attr)
+      else
+        object.read_attribute_for_serialization(attr)
+      end
     end
 
-    # Use ActiveSupport::Notifications to send events to external systems.
-    # The event name is: name.class_name.serializer
-    def instrument(name, payload = {}, &block)
-      event_name = INSTRUMENT[name]
-      ActiveSupport::Notifications.instrument(event_name, payload, &block)
+    # @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
-  end
-
-  # DefaultSerializer
-  #
-  # Provides a constant interface for all items, particularly
-  # for ArraySerializer.
-  class DefaultSerializer
-    attr_reader :object, :options
 
-    def initialize(object, options={})
-      @object, @options = object, options
+    # @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
 
-    def serializable_hash
-      @object.as_json(@options)
-    end
+    protected
+
+    attr_accessor :instance_options, :instance_reflections
   end
 end