cheap_ams 0.10.0.rc2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 91327127509c7d851bb339e9ba020fbbc76264ba
+  data.tar.gz: 49a6e2089f5e063f3f67860ad948379d5225bc12
+SHA512:
+  metadata.gz: 11ed694fdb6ada6f3c09693d9fe3d3e9c7de739f8ebfcb3f8e2abaf09bd5f0f81a44808b45c29e905acd35ed36efb9244b53f914562b41fc5f762fb540042b97
+  data.tar.gz: ce444233a29dfb860c2194b34065ef9c553340ce03bb046afb5b5305d53e0aa59191d872642574e042b9f117105ad1109809dbf0ccf002b7694c7db1c844aeca

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+Vagrantfile
+.vagrant
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.swp
+.ruby-version
+.ruby-gemset

data/.travis.yml

@@ -0,0 +1,26 @@
+language: ruby
+
+sudo: false
+
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1
+  - 2.2
+  - jruby-19mode
+  - rbx-2
+  - ruby-head
+
+install:
+  - bundle install --retry=3
+
+env:
+  - "RAILS_VERSION=4.0"
+  - "RAILS_VERSION=4.1"
+  - "RAILS_VERSION=4.2"
+  - "RAILS_VERSION=master"
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - env: "RAILS_VERSION=master"

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+### 0.10.0
+
+  * adds adapters pattern
+  * adds support for `meta` and `meta_key` [@kurko]
+  * adds method to override association [@kurko]
+  * adds `has_one` attribute for backwards compatibility [@ggordon]
+  * adds JSON API support 1.0 [@benedikt]
+  * adds fragment cache support [@joaomdmoura]
+  * adds cache support to attributes and associations [@joaomdmoura]
+  * uses model name to determine the type [@lsylvester]
+  * remove root key option and split JSON adapter [@joaomdmoura]
+  * adds FlattenJSON as default adapter [@joaomdmoura]
+  * adds support for `pagination links` at top level of JsonApi adapter [@bacarini]

data/CONTRIBUTING.md

@@ -0,0 +1,31 @@
+## How can I help?
+
+Everyone is encouraged to open issues that are affecting you: bugs, ideas, performance problems – everything helps!
+
+The first place to start is by looking at our [GitHub Issues](https://github.com/rails-api/active_model_serializers/issues).
+
+The vast majority of development is happening under the `master` branch, currently slated for release as `0.10.x`. This is where we would suggest you start.
+
+Fixing bugs is extraordinarily helpful and requires the least familiarity with AMS. Look for issues labeled [**Needs Bug Verification**](https://github.com/rails-api/active_model_serializers/labels/Needs%20Bug%20Verification) and [**Bug**](https://github.com/rails-api/active_model_serializers/labels/bug).
+
+We are also 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). Some bugs are expressly not good for new contributors, so don't expect 100% overlap between the two.
+
+If you want to work on new feature development, look for the label [**Feature**](https://github.com/rails-api/active_model_serializers/labels/Feature).
+
+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.
+
+## Issue Labeling
+
+AMS 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).
+
+## Contributing
+
+1. Fork it ( https://github.com/rails-api/active_model_serializers/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Write tests for your feature, or regression tests highlighting a bug
+4. Write the feature itself, or fix your bug
+5. Commit your changes (`git commit -am 'Add some feature'`)
+6. Push to the branch (`git push origin my-new-feature`)
+7. Create a new Pull Request
+
+Remember to squash your commits and rebase off `master`.

data/Gemfile

@@ -0,0 +1,35 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in active_model_serializers.gemspec
+gemspec
+
+version = ENV['RAILS_VERSION'] || '4.2'
+
+if version == 'master'
+  gem 'rack', github: 'rack/rack'
+  git 'https://github.com/rails/rails.git' do
+    gem 'railties'
+    gem 'activesupport'
+    gem 'activemodel'
+    gem 'actionpack'
+    # Rails 5
+    gem 'actionview'
+  end
+  # Rails 5
+  gem 'rails-controller-testing', github: 'rails/rails-controller-testing'
+else
+  gem_version = "~> #{version}.0"
+  gem 'railties', gem_version
+  gem 'activesupport', gem_version
+  gem 'activemodel', gem_version
+  gem 'actionpack', gem_version
+end
+
+group :test do
+  gem 'activerecord'
+  gem 'sqlite3', platform: :ruby
+  gem 'activerecord-jdbcsqlite3-adapter', platform: :jruby
+end
+
+# Windows does not include zoneinfo files, so bundle the tzinfo-data gem
+gem 'tzinfo-data', platforms: [:mingw, :mswin, :x64_mingw, :jruby]

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Steve Klabnik
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,348 @@
+# ActiveModel::Serializer
+
+[![Build Status](https://travis-ci.org/rails-api/active_model_serializers.svg)](https://travis-ci.org/rails-api/active_model_serializers)
+
+_Windows Build Status -_ ![Build Status](https://ci.appveyor.com/api/projects/status/1dly7uj4l69bchmu)
+
+ActiveModel::Serializer brings convention over configuration to your JSON generation.
+
+AMS does this through two components: **serializers** and **adapters**.
+Serializers describe _which_ attributes and relationships should be serialized.
+Adapters describe _how_ attributes and relationships should be serialized.
+
+By default AMS will use the **Flatten Json Adapter**. But we strongly advise you to use **JsonApi Adapter** that follows 1.0 of the format specified in [jsonapi.org/format](http://jsonapi.org/format).
+Check how to change the adapter in the sections bellow.
+
+# RELEASE CANDIDATE, PLEASE READ
+
+This is the master branch of AMS. It will become the `0.10.0` release when it's
+ready. Currently this is a release candidate. This is **not** backward
+compatible with `0.9.0` or `0.8.0`.
+
+`0.10.x` will be based on the `0.8.0` code, but with a more flexible
+architecture. We'd love your help. [Learn how you can help here.](https://github.com/rails-api/active_model_serializers/blob/master/CONTRIBUTING.md)
+
+## Example
+
+Given two models, a `Post(title: string, body: text)` and a
+`Comment(name: string, body: text, post_id: integer)`, you will have two
+serializers:
+
+```ruby
+class PostSerializer < ActiveModel::Serializer
+  cache key: 'posts', expires_in: 3.hours
+  attributes :title, :body
+
+  has_many :comments
+
+  url :post
+end
+```
+
+and
+
+```ruby
+class CommentSerializer < ActiveModel::Serializer
+  attributes :name, :body
+
+  belongs_to :post
+
+  url [:post, :comment]
+end
+```
+
+Generally speaking, you as a user of AMS will write (or generate) these
+serializer classes. If you want to use a different adapter, such as a JsonApi, you can
+change this in an initializer:
+
+```ruby
+ActiveModel::Serializer.config.adapter = ActiveModel::Serializer::Adapter::JsonApi
+```
+
+or
+
+```ruby
+ActiveModel::Serializer.config.adapter = :json_api
+```
+
+You won't need to implement an adapter unless you wish to use a new format or
+media type with AMS.
+
+If you want to have a root key on your responses you should use the Json adapter, instead of the default FlattenJson:
+
+```ruby
+ActiveModel::Serializer.config.adapter = :json
+```
+
+If you would like the key in the outputted JSON to be different from its name in ActiveRecord, you can use the :key option to customize it:
+
+```ruby
+class PostSerializer < ActiveModel::Serializer
+  attributes :id, :body
+
+  # look up :subject on the model, but use +title+ in the JSON
+  attribute :subject, :key => :title
+  has_many :comments
+end
+```
+
+In your controllers, when you use `render :json`, Rails will now first search
+for a serializer for the object and use it if available.
+
+```ruby
+class PostsController < ApplicationController
+  def show
+    @post = Post.find(params[:id])
+
+    render json: @post
+  end
+end
+```
+
+In this case, Rails will look for a serializer named `PostSerializer`, and if
+it exists, use it to serialize the `Post`.
+
+### Specify a serializer
+
+If you wish to use a serializer other than the default, you can explicitly pass it to the renderer.
+
+#### 1. For a resource:
+
+```ruby
+  render json: @post, serializer: PostPreviewSerializer
+```
+
+#### 2. For an array resource:
+
+```ruby
+# Use the default `ArraySerializer`, which will use `each_serializer` to
+# serialize each element
+render json: @posts, each_serializer: PostPreviewSerializer
+
+# Or, you can explicitly provide the collection serializer as well
+render json: @posts, serializer: CollectionSerializer, each_serializer: PostPreviewSerializer
+```
+
+### Meta
+
+If you want a `meta` attribute in your response, specify it in the `render`
+call:
+
+```ruby
+render json: @post, meta: { total: 10 }
+```
+
+The key can be customized using `meta_key` option.
+
+```ruby
+render json: @post, meta: { total: 10 }, meta_key: "custom_meta"
+```
+
+`meta` will only be included in your response if you are using an Adapter that supports `root`, as JsonAPI and Json adapters, the default adapter (FlattenJson) doesn't have `root`.
+
+### Overriding association methods
+
+If you want to override any association, you can use:
+
+```ruby
+class PostSerializer < ActiveModel::Serializer
+  attributes :id, :body
+
+  has_many :comments
+
+  def comments
+    object.comments.active
+  end
+end
+```
+
+### Overriding attribute methods
+
+If you want to override any attribute, you can use:
+
+```ruby
+class PostSerializer < ActiveModel::Serializer
+  attributes :id, :body
+
+  has_many :comments
+
+  def body
+    object.body.downcase
+  end
+end
+```
+
+### Built in Adapters
+
+#### FlattenJSON
+
+It's the default adapter, it generates a json response without a root key.
+Doesn't follow any specifc convention.
+
+#### JSON
+
+It also generates a json response but always with a root key. The root key **can't be overridden**, and will be automatically defined accordingly with the objects being serialized.
+Doesn't follow any specifc convention.
+
+#### JSONAPI
+
+This adapter follows 1.0 of the format specified in
+[jsonapi.org/format](http://jsonapi.org/format). It will include the associated
+resources in the `"included"` member when the resource names are included in the
+`include` option.
+
+```ruby
+  render @posts, include: ['authors', 'comments']
+  # or
+  render @posts, include: 'authors,comments'
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```
+gem 'active_model_serializers'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+## Creating a Serializer
+
+The easiest way to create a new serializer is to generate a new resource, which
+will generate a serializer at the same time:
+
+```
+$ rails g resource post title:string body:string
+```
+
+This will generate a serializer in `app/serializers/post_serializer.rb` for
+your new model. You can also generate a serializer for an existing model with
+the serializer generator:
+
+```
+$ rails g serializer post
+```
+
+The generated seralizer will contain basic `attributes` and
+`has_many`/`has_one`/`belongs_to` declarations, based on the model. For example:
+
+```ruby
+class PostSerializer < ActiveModel::Serializer
+  attributes :title, :body
+
+  has_many :comments
+  has_one :author
+
+  url :post
+end
+```
+
+and
+
+```ruby
+class CommentSerializer < ActiveModel::Serializer
+  attributes :name, :body
+
+  belongs_to :post_id
+
+  url [:post, :comment]
+end
+```
+
+The attribute names are a **whitelist** of attributes to be serialized.
+
+The `has_many`, `has_one`, and `belongs_to` declarations describe relationships between
+resources. By default, when you serialize a `Post`, you will get its `Comments`
+as well.
+
+You may also use the `:serializer` option to specify a custom serializer class, for example:
+
+```ruby
+  has_many :comments, serializer: CommentPreviewSerializer
+```
+
+And you can change the JSON key that the serializer should use for a particular association:
+
+```ruby
+  has_many :comments, key: :reviews
+```
+
+The `url` declaration describes which named routes to use while generating URLs
+for your JSON. Not every adapter will require URLs.
+## Pagination
+
+Pagination links will be included in your response automatically as long as the resource is paginated using [Kaminari](https://github.com/amatsuda/kaminari) or [WillPaginate](https://github.com/mislav/will_paginate) and if you are using a ```JSON-API``` adapter.
+
+Although the others adapters does not have this feature, it is possible to implement pagination links to `JSON` adapter. For more information about it, please see in our docs [How to add pagination links](https://github.com/rails-api/active_model_serializers/blob/master/docs/howto/add_pagination_links.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 update an object 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
+
+  url :post
+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.
+
+### Fragmenting 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
+
+  url :post
+end
+```
+
+## Getting Help
+
+If you find a bug, please report an [Issue](https://github.com/rails-api/active_model_serializers/issues/new).
+
+If you have a question, please [post to Stack Overflow](http://stackoverflow.com/questions/tagged/active-model-serializers).
+
+Thanks!
+
+# Contributing
+
+See [CONTRIBUTING.md](https://github.com/rails-api/active_model_serializers/blob/master/CONTRIBUTING.md)

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.ruby_opts = ['-r./test/test_helper.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/appveyor.yml

@@ -0,0 +1,25 @@
+version: '{build}'
+
+skip_tags: true
+
+environment:
+  matrix:
+    - ruby_version: "193"
+    - ruby_version: "193-x64"
+    - ruby_version: "200"
+    - ruby_version: "200-x64"
+    - ruby_version: "21"
+    - ruby_version: "21-x64"
+
+install:
+  - SET PATH=C:\Ruby%ruby_version%\bin;%PATH%
+  - ruby --version
+  - gem --version
+  - gem install bundler
+  - bundler --version
+  - bundle install --retry=3
+
+test_script:
+  - bundle exec rake
+
+build: off

data/cheap_ams.gemspec

@@ -0,0 +1,49 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_model/serializer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'cheap_ams'
+  spec.version       = ActiveModel::Serializer::VERSION
+  spec.platform      = Gem::Platform::RUBY
+  spec.authors       = ['Steve Klabnik']
+  spec.email         = ['steve@steveklabnik.com']
+  spec.summary       = %q{Conventions-based JSON generation for Rails.}
+  spec.description   = %q{ActiveModel::Serializers allows you to generate your JSON in an object-oriented and convention-driven manner.}
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 1.9.3'
+
+  rails_versions = '>= 4.0'
+  spec.add_runtime_dependency 'activemodel', rails_versions
+    # 'activesupport', rails_versions
+    # 'builder'
+
+  spec.add_runtime_dependency 'actionpack', rails_versions
+    # 'activesupport', rails_versions
+    # 'rack'
+    # 'rack-test', '~> 0.6.2'
+
+  spec.add_runtime_dependency 'railties', rails_versions
+    # 'activesupport', rails_versions
+    # 'actionpack', rails_versions
+    # 'rake', '>= 0.8.7'
+
+  # 'activesupport', rails_versions
+    # 'i18n,
+    # 'tzinfo'
+    # 'minitest'
+    # 'thread_safe'
+
+  # Soft dependency for pagination
+  spec.add_development_dependency 'kaminari'
+  spec.add_development_dependency 'will_paginate'
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'timecop', '>= 0.7'
+end

data/docs/README.md

@@ -0,0 +1,27 @@
+# Docs - ActiveModel::Serializer 0.10.x
+
+This is the documentation of AMS, it's focused on the **0.10.x version.**
+
+-----
+
+## General
+
+- [Getting Started](general/getting_started.md)
+- [Adapters](general/adapters.md)
+
+## How to
+
+- [How to add root key](howto/add_root_key.md)
+- [How to add pagination links](howto/add_pagination_links.md)
+
+## Getting Help
+
+If you find a bug, please report an [Issue](https://github.com/rails-api/active_model_serializers/issues/new).
+
+If you have a question, please [post to Stack Overflow](http://stackoverflow.com/questions/tagged/active-model-serializers).
+
+Thanks!
+
+## Contributing
+
+See [CONTRIBUTING.md](https://github.com/rails-api/active_model_serializers/blob/master/CONTRIBUTING.md)

data/docs/general/adapters.md

@@ -0,0 +1,51 @@
+# Adapters
+
+AMS does this through two components: **serializers** and **adapters**.
+Serializers describe _which_ attributes and relationships should be serialized.
+Adapters describe _how_ attributes and relationships should be serialized.
+You can use one of the built-in adapters (```FlattenJSON``` is the default one) or create one by yourself, but you won't need to implement an adapter unless you wish to use a new format or media type with AMS.
+
+## Built in Adapters
+
+### FlattenJSON - Default
+
+It's the default adapter, it generates a json response without a root key.
+Doesn't follow any specifc convention.
+
+### JSON
+
+It also generates a json response but always with a root key. The root key **can't be overridden**, and will be automatically defined accordingly to the objects being serialized.
+Doesn't follow any specifc convention.
+
+### JSONAPI
+
+This adapter follows **version 1.0** of the format specified in
+[jsonapi.org/format](http://jsonapi.org/format). It will include the associated
+resources in the `"included"` member when the resource names are included in the
+`include` option.
+
+```ruby
+  render @posts, include: ['authors', 'comments']
+  # or
+  render @posts, include: 'authors,comments'
+```
+
+## Choosing an adapter
+
+If you want to use a different adapter, such as JsonApi, you can change this in an initializer:
+
+```ruby
+ActiveModel::Serializer.config.adapter = ActiveModel::Serializer::Adapter::JsonApi
+```
+
+or
+
+```ruby
+ActiveModel::Serializer.config.adapter = :json_api
+```
+
+If you want to have a root key in your responses you should use the Json adapter, instead of the default FlattenJson:
+
+```ruby
+ActiveModel::Serializer.config.adapter = :json
+```