active_model_serializers 0.10.5 → 0.10.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e38c0b5ccb4d32da05808ebff7112d20d7d8d451
-  data.tar.gz: 7e50bf4858b40a9f988d112a95f6afc34c38156b
+  metadata.gz: fbc0f811b036c328dccf411b6f8080b6605d8740
+  data.tar.gz: d4a0f6f7799b074aff45bc103c9c19b9ea873ab1
 SHA512:
-  metadata.gz: 25710e210284167d23ebf77b024d31b06326d71a68c8bcbc1f4f4439baf0b50018a02060da44ebefcb077c9abc2a74bd632cb54662942cb3d17c464d2b420b79
-  data.tar.gz: 712546ebd0b8fd5d1243b32c76349fc92ab0610e2562848c42c7faff4e1fc5820282ea1492c5526d721137fda7eb6dc1dacc422720f493d36e75c9185c3bff79
+  metadata.gz: 121ed054788e585e48e76af3e98490930fd26f18ebdd28d80d07cba78fe9b7c3aed8ea1e1f15ace59debb73562383657f89e4d52fa2c54391424ea53c3701a38
+  data.tar.gz: 88ab9022b49348ec463547196300480bcf02139d67cc11adfcbf8c5e4e38c3e44b27cdde7687baab54f8f8ce4bbe4fa606079dffae51ad7be42427dc15955d6e

data/.rubocop.yml

@@ -1,10 +1,13 @@
 AllCops:
   TargetRubyVersion: 2.1
   Exclude:
-    - config/initializers/forbidden_yaml.rb
     - !ruby/regexp /(vendor|bundle|bin|db|tmp)\/.*/
   DisplayCopNames: true
   DisplayStyleGuide: true
+  # https://github.com/bbatsov/rubocop/blob/master/manual/caching.md
+  # https://github.com/bbatsov/rubocop/blob/e8680418b351491e111a18cf5b453fc07a3c5239/config/default.yml#L60-L77
+  UseCache: true
+  CacheRootDirectory: tmp
 
 Rails:
   Enabled: true

data/CHANGELOG.md

@@ -1,6 +1,6 @@
 ## 0.10.x
 
-### [master (unreleased)](https://github.com/rails-api/active_model_serializers/compare/v0.10.5...master)
+### [master (unreleased)](https://github.com/rails-api/active_model_serializers/compare/v0.10.6...master)
 
 Breaking changes:
 
@@ -10,6 +10,20 @@ Fixes:
 
 Misc:
 
+### [v0.10.6 (2017-05-01)](https://github.com/rails-api/active_model_serializers/compare/v0.10.5...v0.10.6)
+
+Fixes:
+
+- [#1857](https://github.com/rails-api/active_model_serializers/pull/1857) JSON:API does not load belongs_to relation to get identifier id. (@bf4)
+- [#2119](https://github.com/rails-api/active_model_serializers/pull/2119) JSON:API returns null resource object identifier when 'id' is null. (@bf4)
+- [#2093](https://github.com/rails-api/active_model_serializers/pull/2093) undef problematic Serializer methods: display, select. (@bf4)
+
+Misc:
+
+- [#2104](https://github.com/rails-api/active_model_serializers/pull/2104) Documentation for serializers and rendering. (@cassidycodes)
+- [#2081](https://github.com/rails-api/active_model_serializers/pull/2081) Documentation for `include` option in adapters. (@charlie-wasp)
+- [#2120](https://github.com/rails-api/active_model_serializers/pull/2120) Documentation for association options: foreign_key, type, class_name, namespace. (@bf4)
+
 ### [v0.10.5 (2017-03-07)](https://github.com/rails-api/active_model_serializers/compare/v0.10.4...v0.10.5)
 
 Breaking changes:
@@ -77,7 +91,7 @@ Misc:
 
 - [#1878](https://github.com/rails-api/active_model_serializers/pull/1878) Cache key generation for serializers now uses `ActiveSupport::Cache.expand_cache_key` instead of `Array#join` by default and is also overridable. This change should be backward-compatible. (@markiz)
 
-- [#1799](https://github.com/rails-api/active_model_serializers/pull/1799) Add documentation for setting the adapter. (@ScottKbka)
+- [#1799](https://github.com/rails-api/active_model_serializers/pull/1799) Add documentation for setting the adapter. (@cassidycodes)
 - [#1909](https://github.com/rails-api/active_model_serializers/pull/1909) Add documentation for relationship links. (@vasilakisfil, @NullVoxPopuli)
 - [#1959](https://github.com/rails-api/active_model_serializers/pull/1959) Add documentation for root. (@shunsuke227ono)
 - [#1967](https://github.com/rails-api/active_model_serializers/pull/1967) Improve type method documentation. (@yukideluxe)

data/README.md

@@ -90,8 +90,8 @@ reading documentation for our `master`, which may include features that have not
 been released yet. Please see below for the documentation relevant to you.
 
 - [0.10 (master) Documentation](https://github.com/rails-api/active_model_serializers/tree/master)
-- [0.10.4 (latest release) Documentation](https://github.com/rails-api/active_model_serializers/tree/v0.10.4)
-  - [![API Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://www.rubydoc.info/gems/active_model_serializers/0.10.4)
+- [0.10.6 (latest release) Documentation](https://github.com/rails-api/active_model_serializers/tree/v0.10.6)
+  - [![API Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://www.rubydoc.info/gems/active_model_serializers/0.10.6)
   - [Guides](docs)
 - [0.9 (0-9-stable) Documentation](https://github.com/rails-api/active_model_serializers/tree/0-9-stable)
   - [![API Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://www.rubydoc.info/github/rails-api/active_model_serializers/0-9-stable)

data/Rakefile

@@ -7,6 +7,7 @@ begin
   require 'simplecov'
 rescue LoadError # rubocop:disable Lint/HandleExceptions
 end
+import('lib/tasks/rubocop.rake')
 
 Bundler::GemHelper.install_tasks
 
@@ -30,36 +31,6 @@ namespace :yard do
   end
 end
 
-begin
-  require 'rubocop'
-  require 'rubocop/rake_task'
-rescue LoadError # rubocop:disable Lint/HandleExceptions
-else
-  Rake::Task[:rubocop].clear if Rake::Task.task_defined?(:rubocop)
-  require 'rbconfig'
-  # https://github.com/bundler/bundler/blob/1b3eb2465a/lib/bundler/constants.rb#L2
-  windows_platforms = /(msdos|mswin|djgpp|mingw)/
-  if RbConfig::CONFIG['host_os'] =~ windows_platforms
-    desc 'No-op rubocop on Windows-- unsupported platform'
-    task :rubocop do
-      puts 'Skipping rubocop on Windows'
-    end
-  elsif defined?(::Rubinius)
-    desc 'No-op rubocop to avoid rbx segfault'
-    task :rubocop do
-      puts 'Skipping rubocop on rbx due to segfault'
-      puts 'https://github.com/rubinius/rubinius/issues/3499'
-    end
-  else
-    Rake::Task[:rubocop].clear if Rake::Task.task_defined?(:rubocop)
-    desc 'Execute rubocop'
-    RuboCop::RakeTask.new(:rubocop) do |task|
-      task.options = ['--rails', '--display-cop-names', '--display-style-guide']
-      task.fail_on_error = true
-    end
-  end
-end
-
 require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |t|

data/active_model_serializers.gemspec

@@ -57,7 +57,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'simplecov', '~> 0.11'
   spec.add_development_dependency 'timecop', '~> 0.7'
-  spec.add_development_dependency 'grape', ['>= 0.13', '< 1.0']
+  spec.add_development_dependency 'grape', ['>= 0.13', '< 0.19.1']
   spec.add_development_dependency 'json_schema'
   spec.add_development_dependency 'rake', ['>= 10.0', '< 12.0']
 end

data/bin/rubocop

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+#
+# Usage:
+#   bin/rubocop [-A|-t|-h]
+#   bin/rubocop [file or path] [cli options]
+#
+# Options:
+#  Autocorrect    -A
+#  AutoGenConfig  -t
+#  Usage          -h,--help,help
+
+set -e
+
+case $1 in
+  -A)
+     echo "Rubocop autocorrect is ON" >&2
+     bundle exec rake -f lib/tasks/rubocop.rake rubocop:auto_correct
+     ;;
+
+  -t)
+     echo "Rubocop is generating a new TODO" >&2
+     bundle exec rake -f lib/tasks/rubocop.rake rubocop:auto_gen_config
+     ;;
+
+  -h|--help|help)
+     sed -ne '/^#/!q;s/.\{1,2\}//;1d;p' < "$0"
+     ;;
+
+  *)
+     # with no args, run vanilla rubocop
+     # else assume we're passing in arbitrary arguments
+     if [ -z "$1" ]; then
+       bundle exec rake -f lib/tasks/rubocop.rake rubocop
+     else
+       bundle exec rubocop "$@"
+     fi
+     ;;
+esac

data/docs/general/adapters.md

@@ -141,18 +141,25 @@ This adapter follows **version 1.0** of the [format specified](../jsonapi/schema
 }
 ```
 
-#### Included
+### Include option
 
-It will include the associated resources in the `"included"` member
-when the resource names are included in the `include` option.
-Including nested associated resources is also supported.
+Which [serializer associations](https://github.com/rails-api/active_model_serializers/blob/master/docs/general/serializers.md#associations) are rendered can be specified using the `include` option. The option usage is consistent with [the include option in the JSON API spec](http://jsonapi.org/format/#fetching-includes), and is available in all adapters.
 
+Example of the usage:
 ```ruby
   render json: @posts, include: ['author', 'comments', 'comments.author']
   # or
   render json: @posts, include: 'author,comments,comments.author'
 ```
 
+The format of the `include` option can be either:
+
+- a String composed of a comma-separated list of [relationship paths](http://jsonapi.org/format/#fetching-includes).
+- an Array of Symbols and Hashes.
+- a mix of both.
+
+An empty string or an empty array will prevent rendering of any associations.
+
 In addition, two types of wildcards may be used:
 
 - `*` includes one level of associations.
@@ -164,11 +171,6 @@ These can be combined with other paths.
   render json: @posts, include: '**' # or '*' for a single layer
 ```
 
-The format of the `include` option can be either:
-
-- a String composed of a comma-separated list of [relationship paths](http://jsonapi.org/format/#fetching-includes).
-- an Array of Symbols and Hashes.
-- a mix of both.
 
 The following would render posts and include:
 
@@ -182,6 +184,20 @@ It could be combined, like above, with other paths in any combination desired.
   render json: @posts, include: 'author.comments.**'
 ```
 
+**Note:** Wildcards are ActiveModelSerializers-specific, they are not part of the JSON API spec.
+
+The default include for the JSON API adapter is no associations. The default for the JSON and Attributes adapters is all associations.
+
+For the JSON API adapter associated resources will be gathered in the `"included"` member. For the JSON and Attributes
+adapters associated resources will be rendered among the other attributes.
+
+Only for the JSON API adapter you can specify, which attributes of associated resources will be rendered. This feature
+is called [sparse fieldset](http://jsonapi.org/format/#fetching-sparse-fieldsets):
+
+```ruby
+  render json: @posts, include: 'comments', fields: { comments: ['content', 'created_at'] }
+```
+
 ##### Security Considerations
 
 Since the included options may come from the query params (i.e. user-controller):

data/docs/general/getting_started.md

@@ -37,7 +37,7 @@ and
 class CommentSerializer < ActiveModel::Serializer
   attributes :name, :body
 
-  belongs_to :post_id
+  belongs_to :post
 end
 ```
 

data/docs/general/rendering.md

@@ -203,7 +203,7 @@ link(:link_name) { url_for(controller: 'controller_name', action: 'index', only_
 
 #### include
 
-PR please :)
+See [Adapters: Include Option](/docs/general/adapters.md#include-option).
 
 #### Overriding the root key
 
@@ -260,15 +260,29 @@ Note that by using a string and symbol, Ruby will assume the namespace is define
 
 #### serializer
 
-PR please :)
+Specify which serializer to use if you want to use a serializer other than the default.
+
+For a single resource:
+
+```ruby
+@post = Post.first
+render json: @post, serializer: SpecialPostSerializer
+```
+
+To specify which serializer to use on individual items in a collection (i.e., an `index` action), use `each_serializer`:
+
+```ruby
+@posts = Post.all
+render json: @posts, each_serializer: SpecialPostSerializer
+```
 
 #### scope
 
-PR please :)
+See [Serializers: Scope](/docs/general/serializers.md#scope).
 
 #### scope_name
 
-PR please :)
+See [Serializers: Scope](/docs/general/serializers.md#scope).
 
 ## Using a serializer without `render`
 

data/docs/general/serializers.md

@@ -64,6 +64,10 @@ Where:
   - `unless:`
   - `virtual_value:`
   - `polymorphic:` defines if polymorphic relation type should be nested in serialized association.
+  - `type:` the resource type as used by JSON:API, especially on a `belongs_to` relationship.
+  - `class_name:` used to determine `type` when `type` not given
+  - `foreign_key:` used by JSON:API on a `belongs_to` relationship to avoid unnecessarily loading the association object.
+  - `namespace:` used when looking up the serializer and `serializer` is not given.  Falls back to the parent serializer's `:namespace` instance options, which, when present, comes from the render options. See [Rendering#namespace](rendering.md#namespace] for more details.
 - optional: `&block` is a context that returns the association's attributes.
   - prevents `association_name` method from being called.
   - return value of block is used as the association value.
@@ -382,11 +386,26 @@ The serialized value for a given key. e.g. `read_attribute_for_serialization(:ti
 
 #### #links
 
-PR please :)
+Allows you to modify the `links` node. By default, this node will be populated with the attributes set using the [::link](#link) method. Using `links: nil` will remove the `links` node.
+
+```ruby
+ActiveModelSerializers::SerializableResource.new(
+  @post,
+  adapter: :json_api,
+  links: {
+    self: {
+      href: 'http://example.com/posts',
+      meta: {
+        stuff: 'value'
+      }
+    }
+  }
+)
+```
 
 #### #json_key
 
-PR please :)
+Returns the key used by the adapter as the resource root. See [root](#root) for more information.
 
 ## Examples
 

data/docs/howto/add_pagination_links.md

@@ -72,7 +72,7 @@ ActiveModelSerializers pagination relies on a paginated collection with the meth
 
 ### JSON adapter
 
-If you are using `JSON` adapter, pagination links will not be included automatically, but it is possible to do so using `meta` key.
+If you are not using `JSON` adapter, pagination links will not be included automatically, but it is possible to do so using `meta` key.
 
 Add this method to your base API controller.
 

data/docs/integrations/ember-and-json-api.md

@@ -74,6 +74,9 @@ Then, in your controller you can tell rails you're accepting and rendering the j
 end
 ```
 
+#### Note: 
+In Rails 5, the "unsafe" method ( `jsonapi_parse!` vs the safe `jsonapi_parse`) throws an `InvalidDocument` exception when the payload does not meet basic criteria for JSON API deserialization.
+
 
 ### Adapter Changes
 

data/lib/active_model/serializer.rb

@@ -4,13 +4,7 @@ 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/associations'
-require 'active_model/serializer/concerns/attributes'
 require 'active_model/serializer/concerns/caching'
-require 'active_model/serializer/concerns/configuration'
-require 'active_model/serializer/concerns/links'
-require 'active_model/serializer/concerns/meta'
-require 'active_model/serializer/concerns/type'
 require 'active_model/serializer/fieldset'
 require 'active_model/serializer/lint'
 
@@ -18,33 +12,40 @@ require 'active_model/serializer/lint'
 # reified when subclassed to decorate a resource.
 module ActiveModel
   class Serializer
+    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
     autoload :Adapter
     autoload :Null
-    include Configuration
-    include Associations
-    include Attributes
+    autoload :Attribute
+    autoload :Association
+    autoload :Reflection
+    autoload :SingularReflection
+    autoload :CollectionReflection
+    autoload :BelongsToReflection
+    autoload :HasOneReflection
+    autoload :HasManyReflection
+    include ActiveSupport::Configurable
     include Caching
-    include Links
-    include Meta
-    include Type
 
     # @param resource [ActiveRecord::Base, ActiveModelSerializers::Model]
     # @return [ActiveModel::Serializer]
     #   Preferentially returns
-    #   1. resource.serializer
+    #   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, options = {})
-      if resource.respond_to?(:serializer_class)
-        resource.serializer_class
-      elsif resource.respond_to?(:to_ary)
+    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
-        options.fetch(:serializer) { get_serializer_for(resource.class, options[:namespace]) }
+        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
 
@@ -91,6 +92,8 @@ module ActiveModel
           serializer_class
         elsif klass.superclass
           get_serializer_for(klass.superclass)
+        else
+          nil # No serializer found
         end
       end
     end
@@ -111,6 +114,193 @@ module ActiveModel
       @serialization_adapter_instance ||= ActiveModelSerializers::Adapter::Attributes
     end
 
+    # Preferred interface is ActiveModelSerializers.config
+    # BEGIN DEFAULT CONFIGURATION
+    config.collection_serializer = ActiveModel::Serializer::CollectionSerializer
+    config.serializer_lookup_enabled = true
+
+    # @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
+
+    # @deprecated Use {#config.collection_serializer} instead of this. Is
+    #   compatibility layer for ArraySerializer.
+    def config.array_serializer
+      collection_serializer
+    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.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 self.inherited(base)
+      super
+      base._attributes_data = _attributes_data.dup
+      base._reflections = _reflections.dup
+      base._links = _links.dup
+    end
+
+    # @return [Array<Symbol>] Key names of declared attributes
+    # @see Serializer::attribute
+    def self._attributes
+      _attributes_data.keys
+    end
+
+    # BEGIN SERIALIZER MACROS
+
+    # @example
+    #   class AdminAuthorSerializer < ActiveModel::Serializer
+    #     attributes :id, :name, :recent_edits
+    def self.attributes(*attrs)
+      attrs = attrs.first if attrs.first.class == Array
+
+      attrs.each do |attr|
+        attribute(attr)
+      end
+    end
+
+    # @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
+
+    # @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
+
+    # @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
+
+    # @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
+
+    # 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"
+    #
+    def self.link(name, value = nil, &block)
+      _links[name] = block || value
+    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
+
+    # 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
+
+    # END SERIALIZER MACROS
+
     attr_accessor :object, :root, :scope
 
     # `scope_name` is set as :current_user by default in the controller.
@@ -131,53 +321,49 @@ module ActiveModel
       true
     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
+
+    # @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.class._reflections.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
+
     # @return [Hash] containing the attributes and first level
     # associations, similar to how ActiveModel::Serializers::JSON is used
     # in ActiveRecord::Base.
-    #
-    # TODO: Include <tt>ActiveModel::Serializers::JSON</tt>.
-    # So that the below is true:
-    #   @param options [nil, Hash] The same valid options passed to `serializable_hash`
-    #      (:only, :except, :methods, and :include).
-    #
-    #     See
-    #     https://github.com/rails/rails/blob/v5.0.0.beta2/activemodel/lib/active_model/serializers/json.rb#L17-L101
-    #     https://github.com/rails/rails/blob/v5.0.0.beta2/activemodel/lib/active_model/serialization.rb#L85-L123
-    #     https://github.com/rails/rails/blob/v5.0.0.beta2/activerecord/lib/active_record/serialization.rb#L11-L17
-    #     https://github.com/rails/rails/blob/v5.0.0.beta2/activesupport/lib/active_support/core_ext/object/json.rb#L147-L162
-    #
-    #   @example
-    #     # The :only and :except options can be used to limit the attributes included, and work
-    #     # similar to the attributes method.
-    #     serializer.as_json(only: [:id, :name])
-    #     serializer.as_json(except: [:id, :created_at, :age])
-    #
-    #     # To include the result of some method calls on the model use :methods:
-    #     serializer.as_json(methods: :permalink)
-    #
-    #     # To include associations use :include:
-    #     serializer.as_json(include: :posts)
-    #     # Second level and higher order associations work as well:
-    #     serializer.as_json(include: { posts: { include: { comments: { only: :body } }, only: :title } })
     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)
-      cached_attributes = adapter_options[:cached_attributes] ||= {}
-      resource = fetch_attributes(options[:fields], cached_attributes, adapter_instance)
-      relationships = resource_relationships(adapter_options, options, adapter_instance)
+      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
 
     # @see #serializable_hash
-    # TODO: When moving attributes adapter logic here, @see #serializable_hash
-    # So that the below is true:
-    #   @param options [nil, Hash] The same valid options passed to `as_json`
-    #      (:root, :only, :except, :methods, and :include).
-    #   The default for `root` is nil.
-    #   The default value for include_root is false. You can change it to true if the given
-    #   JSON string includes a single root node.
     def as_json(adapter_opts = nil)
       serializable_hash(adapter_opts)
     end
@@ -196,32 +382,24 @@ module ActiveModel
     end
 
     # @api private
-    def resource_relationships(adapter_options, options, adapter_instance)
-      relationships = {}
-      include_directive = options.fetch(:include_directive)
-      associations(include_directive).each do |association|
-        adapter_opts = adapter_options.merge(include_directive: include_directive[association.key])
-        relationships[association.key] ||= relationship_value_for(association, adapter_opts, adapter_instance)
+    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
-
-      relationships
     end
 
     # @api private
-    def relationship_value_for(association, adapter_options, adapter_instance)
-      return association.options[:virtual_value] if association.options[:virtual_value]
-      association_serializer = association.serializer
-      association_object = association_serializer && association_serializer.object
-      return unless association_object
-
-      relationship_value = association_serializer.serializable_hash(adapter_options, {}, adapter_instance)
-
-      if association.options[:polymorphic] && relationship_value
-        polymorphic_type = association_object.class.name.underscore
-        relationship_value = { type: polymorphic_type, polymorphic_type.to_sym => relationship_value }
+    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
-
-      relationship_value
     end
 
     protected