active_model_serializers 0.10.3 → 0.10.12

data/bin/serve_benchmark

@@ -1,39 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-case "$1" in
-
-  start)
-  config="${CONFIG_RU:-test/benchmark/config.ru}"
-  bundle exec ruby -Ilib -S rackup "$config" --daemonize --pid tmp/benchmark_app.pid --warn --server webrick
-  until [ -f 'tmp/benchmark_app.pid' ]; do
-    sleep 0.1 # give it time to start.. I don't know a better way
-  done
-  cat tmp/benchmark_app.pid
-  true
-  ;;
-
-  stop)
-  if [ -f 'tmp/benchmark_app.pid' ]; then
-    kill -TERM $(cat tmp/benchmark_app.pid)
-  else
-    echo 'No pidfile'
-    false
-  fi
-  ;;
-
-  status)
-  if [ -f 'tmp/benchmark_app.pid' ]; then
-    kill -0 $(cat tmp/benchmark_app.pid)
-    [ "$?" -eq 0 ]
-  else
-    echo 'No pidfile'
-    false
-  fi
-  ;;
-
-  *)
-  echo "Usage: $0 [start|stop|status]"
-  ;;
-
-esac

data/docs/ARCHITECTURE.md

@@ -1,125 +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::CollectionSerializer`** represents 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 (CollectionSerializer) cannot
-identify a serializer for a resource in its collection, it throws [`:no_serializer`](https://github.com/rails-api/active_model_serializers/issues/1191#issuecomment-142327128).
-For example, when caught by `Reflection#build_association`, the association value is set 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::CollectionSerializer#new**
-  1. If the `serializer_instance` was a `CollectionSerializer` 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,42 +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)
-- [How to add relationship links](howto/add_relationship_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)
-- [How to upgrade from `0.8` to `0.10` safely](howto/upgrade_from_0_8_to_0_10.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,247 +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 json response is always rendered with a root key.
-
-The root key can be overridden by:
-* passing the `root` option in the render call. See details in the [Rendering Guides](rendering.md#overriding-the-root-key).
-* setting the `type` of the serializer. See details in the [Serializers Guide](serializers.md#type).
-
-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)