active_model_serializers 0.10.0 → 0.10.11

data/docs/ARCHITECTURE.md

@@ -1,126 +0,0 @@
-[Back to Guides](README.md)
-
-This document focuses on architecture the 0.10.x version of ActiveModelSerializers. If you are interested in the architecture of the 0.8 or 0.9 versions,
-please refer to the [0.8 README](https://github.com/rails-api/active_model_serializers/blob/0-8-stable/README.md) or
-[0.9 README](https://github.com/rails-api/active_model_serializers/blob/0-9-stable/README.md).
-
-The original design is also available [here](https://github.com/rails-api/active_model_serializers/blob/d72b66d4c5355b0ff0a75a04895fcc4ea5b0c65e/README.textile).
-
-# ARCHITECTURE
-
-An **`ActiveModel::Serializer`** wraps a [serializable resource](https://github.com/rails/rails/blob/4-2-stable/activemodel/lib/active_model/serialization.rb)
-and exposes an `attributes` method, among a few others.
-It allows you to specify which attributes and associations should be represented in the serializatation of the resource.
-It requires an adapter to transform its attributes into a JSON document; it cannot be serialized itself.
-It may be useful to think of it as a
-[presenter](http://blog.steveklabnik.com/posts/2011-09-09-better-ruby-presenters).
-
-The **`ActiveModel::ArraySerializer`** represent a collection of resources as serializers
-and, if there is no serializer, primitives.
-
-The **`ActiveModel::Adapter`** describes the structure of the JSON document generated from a
-serializer. For example, the `Attributes` example represents each serializer as its
-unmodified attributes.  The `JsonApi` adapter represents the serializer as a [JSON
-API](http://jsonapi.org/) document.
-
-The **`ActiveModelSerializers::SerializableResource`** acts to coordinate the serializer(s) and adapter
-to an object that responds to `to_json`, and `as_json`.  It is used in the controller to
-encapsulate the serialization resource when rendered. However, it can also be used on its own
-to serialize a resource outside of a controller, as well.
-
-## Primitive handling
-
-Definitions: A primitive is usually a String or Array. There is no serializer
-defined for them; they will be serialized when the resource is converted to JSON (`as_json` or
-`to_json`).  (The below also applies for any object with no serializer.)
-
-ActiveModelSerializers doesn't handle primitives passed to `render json:` at all.
-
-However, when a primitive value is an attribute or in a collection,
-it is not modified.
-
-Internally, if no serializer can be found in the controller, the resource is not decorated by
-ActiveModelSerializers.
-
-If the collection serializer (ArraySerializer) cannot
-identify a serializer for a resource in its collection, it raises [`NoSerializerError`](https://github.com/rails-api/active_model_serializers/issues/1191#issuecomment-142327128)
-which is rescued in `ActiveModel::Serializer::Reflection#build_association` which sets
-the association value directly:
-
-```ruby
-reflection_options[:virtual_value] = association_value.try(:as_json) || association_value
-```
-
-(which is called by the adapter as `serializer.associations(*)`.)
-
-## How options are parsed
-
-High-level overview:
-
-- For a collection
-  - `:serializer` specifies the collection serializer and
-  - `:each_serializer` specifies the serializer for each resource in the collection.
-- For a single resource, the `:serializer` option is the resource serializer.
-- Options are partitioned in serializer options and adapter options.  Keys for adapter options are specified by
-    [`ADAPTER_OPTION_KEYS`](https://github.com/rails-api/active_model_serializers/blob/master/lib/active_model_serializers/serializable_resource.rb#L5).
-    The remaining options are serializer options.
-
-Details:
-
-1. **ActionController::Serialization**
-  1. `serializable_resource = ActiveModelSerializers::SerializableResource.new(resource, options)`
-    1. `options` are partitioned into `adapter_opts` and everything else (`serializer_opts`).
-      The `adapter_opts`  keys are defined in `ActiveModelSerializers::SerializableResource::ADAPTER_OPTION_KEYS`.
-1. **ActiveModelSerializers::SerializableResource**
-  1. `if serializable_resource.serializer?` (there is a serializer for the resource, and an adapter is used.)
-    - Where `serializer?` is `use_adapter? && !!(serializer)`
-      - Where `use_adapter?`: 'True when no explicit adapter given, or explicit value is truthy (non-nil);
-        False when explicit adapter is falsy (nil or false)'
-      - Where `serializer`:
-        1. from explicit `:serializer` option, else
-        2. implicitly from resource `ActiveModel::Serializer.serializer_for(resource)`
-  1. A side-effect of checking `serializer` is:
-     - The `:serializer` option is removed from the serializer_opts hash
-     - If the `:each_serializer` option is present, it is removed from the serializer_opts hash and set as the `:serializer` option
-  1. The serializer and adapter are created as
-    1. `serializer_instance = serializer.new(resource, serializer_opts)`
-    2. `adapter_instance = ActiveModel::Serializer::Adapter.create(serializer_instance, adapter_opts)`
-1. **ActiveModel::Serializer::ArraySerializer#new**
-  1. If the `serializer_instance` was a `ArraySerializer` and the `:serializer` serializer_opts
-    is present, then [that serializer is passed into each resource](https://github.com/rails-api/active_model_serializers/blob/a54d237e2828fe6bab1ea5dfe6360d4ecc8214cd/lib/active_model/serializer/array_serializer.rb#L14-L16).
-1. **ActiveModel::Serializer#attributes** is used by the adapter to get the attributes for
-  resource as defined by the serializer.
-
-## What does a 'serializable resource' look like?
-
-- An `ActiveRecord::Base` object.
-- Any Ruby object that passes the
-  [Lint](http://www.rubydoc.info/github/rails-api/active_model_serializers/ActiveModel/Serializer/Lint/Tests)
-  [code](https://github.com/rails-api/active_model_serializers/blob/master/lib/active_model/serializer/lint.rb).
-
-ActiveModelSerializers provides a
-[`ActiveModelSerializers::Model`](https://github.com/rails-api/active_model_serializers/blob/master/lib/active_model_serializers/model.rb),
-which is a simple serializable PORO (Plain-Old Ruby Object).
-
-ActiveModelSerializers::Model may be used either as a template, or in production code.
-
-```ruby
-class MyModel < ActiveModelSerializers::Model
-  attr_accessor :id, :name, :level
-end
-```
-
-The default serializer for `MyModel` would be `MyModelSerializer` whether MyModel is an
-ActiveRecord::Base object or not.
-
-Outside of the controller the rules are **exactly** the same as for records. For example:
-
-```ruby
-render json: MyModel.new(level: 'awesome'), adapter: :json
-```
-
-would be serialized the same as
-
-```ruby
-ActiveModelSerializers::SerializableResource.new(MyModel.new(level: 'awesome'), adapter: :json).as_json
-```

data/docs/README.md

@@ -1,40 +0,0 @@
-# Docs - ActiveModel::Serializer 0.10.x
-
-This is the documentation of ActiveModelSerializers, it's focused on the **0.10.x version.**
-
------
-
-## General
-
-- [Getting Started](general/getting_started.md)
-- [Configuration Options](general/configuration_options.md)
-- [Serializers](general/serializers.md)
-- [Adapters](general/adapters.md)
-- [Rendering](general/rendering.md)
-- [Caching](general/caching.md)
-- [Logging](general/logging.md)
-- [Deserialization](general/deserialization.md)
-- [Instrumentation](general/instrumentation.md)
-- JSON API
-  - [Schema](jsonapi/schema.md)
-  - [Errors](jsonapi/errors.md)
-- [ARCHITECTURE](ARCHITECTURE.md)
-
-## How to
-
-- [How to add root key](howto/add_root_key.md)
-- [How to add pagination links](howto/add_pagination_links.md)
-- [Using ActiveModelSerializers Outside Of Controllers](howto/outside_controller_use.md)
-- [Testing ActiveModelSerializers](howto/test.md)
-- [Passing Arbitrary Options](howto/passing_arbitrary_options.md)
-- [How to serialize a Plain-Old Ruby Object (PORO)](howto/serialize_poro.md)
-
-## Integrations
-
-| Integration | Supported ActiveModelSerializers versions |  Gem name and/or link
-|----|-----|----
-| Ember.js | 0.9.x | [active-model-adapter](https://github.com/ember-data/active-model-adapter)
-| Ember.js | 0.10.x + |  [docs/integrations/ember-and-json-api.md](integrations/ember-and-json-api.md)
-| Grape | 0.10.x + | [docs/integrations/grape.md](integrations/grape.md)  |
-| Grape | 0.9.x | https://github.com/jrhe/grape-active_model_serializers/ |
-| Sinatra | 0.9.x | https://github.com/SauloSilva/sinatra-active-model-serializers/

data/docs/STYLE.md

@@ -1,58 +0,0 @@
-# STYLE
-
-## Code and comments
-
-- We are actively working to identify tasks under the label [**Good for New
-  Contributors**](https://github.com/rails-api/active_model_serializers/labels/Good%20for%20New%20Contributors).
-  - [Changelog
-      Missing](https://github.com/rails-api/active_model_serializers/issues?q=label%3A%22Changelog+Missing%22+is%3Aclosed) is
-    an easy way to help out.
-
-- [Fix a bug](https://github.com/rails-api/active_model_serializers/labels/Ready%20for%20PR).
-  - Ready for PR - A well defined bug, needs someone to PR a fix.
-  - Bug - Anything that is broken.
-  - Regression - A bug that did not exist in previous versions and isn't a new feature (applied in tandem with Bug).
-  - Performance - A performance related issue. We could track this as a bug, but usually these would have slightly lower priority than standard bugs.
-
-- [Develop new features](https://github.com/rails-api/active_model_serializers/labels/Feature).
-
-- [Improve code quality](https://codeclimate.com/github/rails-api/active_model_serializers/code?sort=smell_count&sort_direction=desc).
-
-- [Improve amount of code exercised by tests](https://codeclimate.com/github/rails-api/active_model_serializers/coverage?sort=covered_percent&sort_direction=asc).
-
-- [Fix RuboCop (Style) TODOS](https://github.com/rails-api/active_model_serializers/blob/master/.rubocop_todo.yml).
-  - Delete and offsense, run `rake rubocop` (or possibly `rake rubocop:auto_correct`),
-    and [submit a PR](CONTRIBUTING.md#submitting-a-pull-request-pr).
-
-- We are also encouraging comments to substantial changes (larger than bugfixes and simple features) under an
-  "RFC" (Request for Comments) process before we start active development.
-   Look for the [**RFC**](https://github.com/rails-api/active_model_serializers/labels/RFC) label.
-
-
-## Pull requests
-
-- If the tests pass and the pull request looks good, a maintainer will merge it.
-- If the pull request needs to be changed,
-  - you can change it by updating the branch you generated the pull request from
-    - either by adding more commits, or
-    - by force pushing to it
-  - A maintainer can make any changes themselves and manually merge the code in.
-
-## Commit messages
-
-- [A Note About Git Commit Messages](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html)
-- [http://stopwritingramblingcommitmessages.com/](http://stopwritingramblingcommitmessages.com/)
-- [ThoughtBot style guide](https://github.com/thoughtbot/guides/tree/master/style#git)
-
-#### About Pull Requests (PR's)
-
-- [Using Pull Requests](https://help.github.com/articles/using-pull-requests)
-- [Github pull requests made easy](http://www.element84.com/github-pull-requests-made-easy.html)
-- [Exercism Git Workflow](http://help.exercism.io/git-workflow.html).
-- [Level up your Git](http://rakeroutes.com/blog/deliberate-git/)
-- [All Your Open Source Code Are Belong To Us](http://www.benjaminfleischer.com/2013/07/30/all-your-open-source-code-are-belong-to-us/)
-
-## Issue Labeling
-
-ActiveModelSerializers uses a subset of [StandardIssueLabels](https://github.com/wagenet/StandardIssueLabels) for Github Issues. You can [see our labels here](https://github.com/rails-api/active_model_serializers/labels).
-

data/docs/general/adapters.md

@@ -1,245 +0,0 @@
-[Back to Guides](../README.md)
-
-# Adapters
-
-ActiveModelSerializers offers the ability to configure which adapter
-to use both globally and/or when serializing (usually when rendering).
-
-The global adapter configuration is set on [`ActiveModelSerializers.config`](configuration_options.md).
-It should be set only once, preferably at initialization.
-
-For example:
-
-```ruby
-ActiveModelSerializers.config.adapter = ActiveModelSerializers::Adapter::JsonApi
-```
-
-or
-
-```ruby
-ActiveModelSerializers.config.adapter = :json_api
-```
-
-or
-
-```ruby
-ActiveModelSerializers.config.adapter = :json
-```
-
-The local adapter option is in the format `adapter: adapter`, where `adapter` is
-any of the same values as set globally.
-
-The configured adapter can be set as a symbol, class, or class name, as described in
-[Advanced adapter configuration](adapters.md#advanced-adapter-configuration).
-
-The `Attributes` adapter does not include a root key. It is just the serialized attributes.
-
-Use either the `JSON` or `JSON API` adapters if you want the response document to have a root key.
-
-## Built in Adapters
-
-### Attributes - Default
-
-It's the default adapter, it generates a json response without a root key.
-Doesn't follow any specific convention.
-
-##### Example output
-
-```json
-{
-  "title": "Title 1",
-  "body": "Body 1",
-  "publish_at": "2020-03-16T03:55:25.291Z",
-  "author": {
-    "first_name": "Bob",
-    "last_name": "Jones"
-  },
-  "comments": [
-    {
-      "body": "cool"
-    },
-    {
-      "body": "awesome"
-    }
-  ]
-}
-```
-
-### JSON
-
-The response document always with a root key.
-
-The root key **can't be overridden**, and will be derived from the resource being serialized.
-
-Doesn't follow any specific convention.
-
-##### Example output
-
-```json
-{
-  "post": {
-    "title": "Title 1",
-    "body": "Body 1",
-    "publish_at": "2020-03-16T03:55:25.291Z",
-    "author": {
-      "first_name": "Bob",
-      "last_name": "Jones"
-    },
-    "comments": [{
-      "body": "cool"
-    }, {
-      "body": "awesome"
-    }]
-  }
-}
-```
-
-### JSON API
-
-This adapter follows **version 1.0** of the [format specified](../jsonapi/schema.md) in
-[jsonapi.org/format](http://jsonapi.org/format).
-
-##### Example output
-
-```json
-{
-  "data": {
-    "id": "1337",
-    "type": "posts",
-    "attributes": {
-      "title": "Title 1",
-      "body": "Body 1",
-      "publish-at": "2020-03-16T03:55:25.291Z"
-    },
-    "relationships": {
-      "author": {
-        "data": {
-          "id": "1",
-          "type": "authors"
-        }
-      },
-      "comments": {
-        "data": [{
-          "id": "7",
-          "type": "comments"
-        }, {
-          "id": "12",
-          "type": "comments"
-        }]
-      }
-    },
-    "links": {
-      "post-authors": "https://example.com/post_authors"
-    },
-    "meta": {
-      "rating": 5,
-      "favorite-count": 10
-    }
-  }
-}
-```
-
-#### Included
-
-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.
-
-```ruby
-  render json: @posts, include: ['author', 'comments', 'comments.author']
-  # or
-  render json: @posts, include: 'author,comments,comments.author'
-```
-
-In addition, two types of wildcards may be used:
-
-- `*` includes one level of associations.
-- `**` includes all recursively.
-
-These can be combined with other paths.
-
-```ruby
-  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:
-
-- the author
-- the author's comments, and
-- every resource referenced by the author's comments (recursively).
-
-It could be combined, like above, with other paths in any combination desired.
-
-```ruby
-  render json: @posts, include: 'author.comments.**'
-```
-
-##### Security Considerations
-
-Since the included options may come from the query params (i.e. user-controller):
-
-```ruby
-  render json: @posts, include: params[:include]
-```
-
-The user could pass in `include=**`.
-
-We recommend filtering any user-supplied includes appropriately.
-
-## Advanced adapter configuration
-
-### Registering an adapter
-
-The default adapter can be configured, as above, to use any class given to it.
-
-An adapter may also be specified, e.g. when rendering, as a class or as a symbol.
-If a symbol, then the adapter must be, e.g. `:great_example`,
-`ActiveModelSerializers::Adapter::GreatExample`, or registered.
-
-There are two ways to register an adapter:
-
-1) The simplest, is to subclass `ActiveModelSerializers::Adapter::Base`, e.g. the below will
-register the `Example::UsefulAdapter` as `"example/useful_adapter"`.
-
-```ruby
-module Example
-  class UsefulAdapter < ActiveModelSerializers::Adapter::Base
-  end
-end
-```
-
-You'll notice that the name it registers is the underscored namespace and class.
-
-Under the covers, when the `ActiveModelSerializers::Adapter::Base` is subclassed, it registers
-the subclass as `register("example/useful_adapter", Example::UsefulAdapter)`
-
-2) Any class can be registered as an adapter by calling `register` directly on the
-`ActiveModelSerializers::Adapter` class. e.g., the below registers `MyAdapter` as
-`:special_adapter`.
-
-```ruby
-class MyAdapter; end
-ActiveModelSerializers::Adapter.register(:special_adapter, MyAdapter)
-```
-
-### Looking up an adapter
-
-| Method | Return value |
-| :------------ |:---------------|
-| `ActiveModelSerializers::Adapter.adapter_map` | A Hash of all known adapters `{ adapter_name => adapter_class }` |
-| `ActiveModelSerializers::Adapter.adapters` | A (sorted) Array of all known `adapter_names` |
-| `ActiveModelSerializers::Adapter.lookup(name_or_klass)` |  The `adapter_class`, else raises an `ActiveModelSerializers::Adapter::UnknownAdapter` error |
-| `ActiveModelSerializers::Adapter.adapter_class(adapter)` | Delegates to `ActiveModelSerializers::Adapter.lookup(adapter)` |
-| `ActiveModelSerializers::Adapter.configured_adapter` | A convenience method for `ActiveModelSerializers::Adapter.lookup(config.adapter)` |
-
-The registered adapter name is always a String, but may be looked up as a Symbol or String.
-Helpfully, the Symbol or String is underscored, so that `get(:my_adapter)` and `get("MyAdapter")`
-may both be used.
-
-For more information, see [the Adapter class on GitHub](https://github.com/rails-api/active_model_serializers/blob/master/lib/active_model_serializers/adapter.rb)

data/docs/general/caching.md

@@ -1,52 +0,0 @@
-[Back to Guides](../README.md)
-
-# Caching
-
-To cache a serializer, call ```cache``` and pass its options.
-The options are the same options of ```ActiveSupport::Cache::Store```, plus
-a ```key``` option that will be the prefix of the object cache
-on a pattern ```"#{key}/#{object.id}-#{object.updated_at}"```.
-
-The cache support is optimized to use the cached object in multiple request. An object cached on a ```show``` request will be reused at the ```index```. If there is a relationship with another cached serializer it will also be created and reused automatically.
-
-**[NOTE] Every object is individually cached.**
-
-**[NOTE] The cache is automatically expired after an object is updated, but it's not deleted.**
-
-```ruby
-cache(options = nil) # options: ```{key, expires_in, compress, force, race_condition_ttl}```
-```
-
-Take the example bellow:
-
-```ruby
-class PostSerializer < ActiveModel::Serializer
-  cache key: 'post', expires_in: 3.hours
-  attributes :title, :body
-
-  has_many :comments
-end
-```
-
-On this example every ```Post``` object will be cached with
-the key ```"post/#{post.id}-#{post.updated_at}"```. You can use this key to expire it as you want,
-but in this case it will be automatically expired after 3 hours.
-
-## Fragment Caching
-
-If there is some API endpoint that shouldn't be fully cached, you can still optimise it, using Fragment Cache on the attributes and relationships that you want to cache.
-
-You can define the attribute by using ```only``` or ```except``` option on cache method.
-
-**[NOTE] Cache serializers will be used at their relationships**
-
-Example:
-
-```ruby
-class PostSerializer < ActiveModel::Serializer
-  cache key: 'post', expires_in: 3.hours, only: [:title]
-  attributes :title, :body
-
-  has_many :comments
-end
-```

data/docs/general/configuration_options.md

@@ -1,100 +0,0 @@
-[Back to Guides](../README.md)
-
-# Configuration Options
-
-The following configuration options can be set on
-`ActiveModelSerializers.config`, preferably inside an initializer.
-
-## General
-
-##### adapter
-
-The [adapter](adapters.md) to use.
-
-Possible values:
-
-- `:attributes` (default)
-- `:json`
-- `:json_api`
-
-##### serializer_lookup_enabled
-
-Enable automatic serializer lookup.
-
-Possible values:
-
-- `true` (default)
-- `false`
-
-When `false`, serializers must be explicitly specified.
-
-##### key_transform
-
-The [key transform](key_transforms.md) to use.
-
-
-| Option | Result |
-|----|----|
-| `:camel` | ExampleKey |
-| `:camel_lower` | exampleKey |
-| `:dash` | example-key |
-| `:unaltered` | the original, unaltered key |
-| `:underscore` | example_key |
-| `nil` | use the adapter default |
-
-Each adapter has a default key transform configured:
-
-| Adapter | Default Key Transform |
-|----|----|
-| `Json` | `:unaltered` |
-| `JsonApi` | `:dash` |
-
-`config.key_transform` is a global override of the adapter default. Adapters
-still prefer the render option `:key_transform` over this setting.
-
-
-## JSON API
-
-
-##### jsonapi_resource_type
-
-Sets whether the [type](http://jsonapi.org/format/#document-resource-identifier-objects)
-of the resource should be `singularized` or `pluralized` when it is not
-[explicitly specified by the serializer](https://github.com/rails-api/active_model_serializers/blob/master/docs/general/serializers.md#type)
-
-Possible values:
-
-- `:singular`
-- `:plural` (default)
-
-##### jsonapi_include_toplevel_object
-
-Include a [top level jsonapi member](http://jsonapi.org/format/#document-jsonapi-object)
-in the response document.
-
-Possible values:
-
-- `true`
-- `false` (default)
-
-##### jsonapi_version
-
-The latest version of the spec to which the API conforms.
-
-Default: `'1.0'`.
-
-*Used when `jsonapi_include_toplevel_object` is `true`*
-
-##### jsonapi_toplevel_meta
-
-Optional top-level metadata. Not included if empty.
-
-Default: `{}`.
-
-*Used when `jsonapi_include_toplevel_object` is `true`*
-
-
-## Hooks
-
-To run a hook when ActiveModelSerializers is loaded, use
-`ActiveSupport.on_load(:action_controller) do end`