Merge remote-tracking branch 'upstream/master'

Author: CorainChicago

.travis.yml

@@ -33,8 +33,8 @@ matrix:
   include:
   - rvm: 2.2
     env: CAPTURE_STDERR=true
-  - rvm: jruby-9000
-    env: JRUBY_OPTS='--server -Xcompile.invokedynamic=false -Xcli.debug=true --debug'
+  - rvm: jruby-9.0.4.0
+    env: JRUBY_OPTS='-Xcompat.version=2.0 --server -Xcompile.invokedynamic=false -Xcli.debug=true --debug'
   allow_failures:
     - rvm: ruby-head
     - rvm: rbx-2

CHANGELOG.md

@@ -16,7 +16,22 @@ Breaking changes:
 
 Features:
 
-- [#1336](https://github.com/rails-api/active_model_serializers/pull/1336) Added support for Grape >= 0.13, < 1.0
+- [#1378](https://github.com/rails-api/active_model_serializers/pull/1378) Change association blocks
+  to be evaluated in *serializer* scope, rather than *association* scope. (@bf4)
+    * Syntax changes from e.g.
+      `has_many :titles do customers.pluck(:title) end` (in #1356) to
+      `has_many :titles do object.customers.pluck(:title) end`
+- [#1356](https://github.com/rails-api/active_model_serializers/pull/1356) Add inline syntax for
+  attributes and associations (@bf4 @beauby @noahsilas)
+  * Allows defining attributes so that they don't conflict with existing methods. e.g. `attribute
+      :title do 'Mr. Topum Hat' end`
+  * Allows defining associations so that they don't conflict with existing methods. e.g. `has_many
+      :titles do customers.pluck(:title) end`
+    * Allows dynamic associations, as compared to compare to using
+        [`virtual_value`](https://github.com/rails-api/active_model_serializers/pull/1356#discussion_r47146466).
+        e.g. `has_many :reviews, virtual_value: [{ id: 1 }, { id: 2 }]`
+  * Removes dynamically defined methods on the serializer
+- [#1336](https://github.com/rails-api/active_model_serializers/pull/1336) Added support for Grape >= 0.13, < 1.0 (@johnhamelink)
 - [#1291](https://github.com/rails-api/active_model_serializers/pull/1291) Add logging (@maurogeorge)
 - [#1225](https://github.com/rails-api/active_model_serializers/pull/1225) Better serializer lookup, use nested serializer when it exists (@beauby)
 - [#1172](https://github.com/rails-api/active_model_serializers/pull/1172) Better serializer registration, get more than just the first module (@bf4)
@@ -35,6 +50,7 @@ Fixes:
 - [#1358](https://github.com/rails-api/active_model_serializers/pull/1358) Handle serializer file paths with spaces (@rwstauner, @bf4)
 
 Misc:
+- [#1370](https://github.com/rails-api/active_model_serializers/pull/1370) Simplify attributes handling via a mixin (@beauby)
 - [#1233](https://github.com/rails-api/active_model_serializers/pull/1233) Top-level meta and meta_key options no longer handled at serializer level (@beauby)
 - [#1232](https://github.com/rails-api/active_model_serializers/pull/1232) fields option no longer handled at serializer level (@beauby)
 - [#1178](https://github.com/rails-api/active_model_serializers/pull/1178) env CAPTURE_STDERR=false lets devs see hard failures (@bf4)
@@ -183,6 +199,13 @@ Misc:
   * adds method to override association
 - [#794](https://github.com/rails-api/active_model_serializers/pull/794) add to_param for correct URL generation (@carlesjove)
 
+### v0.10.0-pre
+
+- [Introduce Adapter](https://github.com/rails-api/active_model_serializers/commit/f00fe5595ddf741dc26127ed8fe81adad833ead5)
+- Prefer `ActiveModel::Serializer` to `ActiveModelSerializers`:
+  - [Namespace](https://github.com/rails-api/active_model_serializers/commit/729a823868e8c7ac86c653fcc7100ee511e08cb6#diff-fe7aa2941c19a41ccea6e52940d84016).
+  - [README](https://github.com/rails-api/active_model_serializers/commit/4a2d9853ba7486acc1747752982aa5650e7fd6e9).
+
 ## 0.09.x
 
 ### v0.9.3 (2015/01/21 20:29 +00:00)
@@ -226,6 +249,36 @@ Features:
 - [#653](https://github.com/rails-api/active_model_serializers/pull/653) Add "_test" suffix to JsonApi::HasManyTest filename. (@alexgenco)
 - [#631](https://github.com/rails-api/active_model_serializers/pull/631) Update build badge URL (@craiglittle)
 
+### 0.9.0.alpha1 - January 7, 2014
+
+### 0.9.0.pre
+
+* The following methods were removed
+  - Model#active\_model\_serializer
+  - Serializer#include!
+  - Serializer#include?
+  - Serializer#attr\_disabled=
+  - Serializer#cache
+  - Serializer#perform\_caching
+  - Serializer#schema (needs more discussion)
+  - Serializer#attribute
+  - Serializer#include\_#{name}? (filter method added)
+  - Serializer#attributes (took a hash)
+
+* The following things were added
+  - Serializer#filter method
+  - CONFIG object
+
+* Remove support for ruby 1.8 versions.
+
+* Require rails >= 3.2.
+
+* Serializers for associations are being looked up in a parent serializer's namespace first. Same with controllers' namespaces.
+
+* Added a "prefix" option in case you want to use a different version of serializer.
+
+* Serializers default namespace can be set in `default_serializer_options` and inherited by associations.
+
 ## 0.08.x
 
 ### v0.8.3 (2014/12/10 14:45 +00:00)
@@ -241,3 +294,94 @@ Features:
 - [#610](https://github.com/rails-api/active_model_serializers/pull/610) ArraySerializer (@bolshakov)
 - [#607](https://github.com/rails-api/active_model_serializers/pull/607) ruby syntax highlights (@zigomir)
 - [#602](https://github.com/rails-api/active_model_serializers/pull/602) Add DSL for associations (@JordanFaust)
+
+### 0.8.1 (May 6, 2013)
+
+* Fix bug whereby a serializer using 'options' would blow up.
+
+### 0.8.0 (May 5, 2013)
+
+* Attributes can now have optional types.
+
+* A new DefaultSerializer ensures that POROs behave the same way as ActiveModels.
+
+* If you wish to override ActiveRecord::Base#to_Json, you can now require
+  'active_record/serializer_override'. We don't recommend you do this, but
+  many users do, so we've left it optional.
+
+* Fixed a bug where ActionController wouldn't always have MimeResponds.
+
+* An optinal caching feature allows you to cache JSON & hashes that AMS uses.
+  Adding 'cached true' to your Serializers will turn on this cache.
+
+* URL helpers used inside of Engines now work properly.
+
+* Serializers now can filter attributes with `only` and `except`:
+
+  ```
+  UserSerializer.new(user, only: [:first_name, :last_name])
+  UserSerializer.new(user, except: :first_name)
+  ```
+
+* Basic Mongoid support. We now include our mixins in the right place.
+
+* On Ruby 1.8, we now generate an `id` method that properly serializes `id`
+  columns. See issue #127 for more.
+
+* Add an alias for `scope` method to be the name of the context. By default
+  this is `current_user`. The name is automatically set when using
+  `serialization_scope` in the controller.
+
+* Pass through serialization options (such as `:include`) when a model
+  has no serializer defined.
+
+## [0.7.0 (March 6, 2013)](https://github.com/rails-api/active_model_serializers/commit/fabdc621ff97fbeca317f6301973dd4564b9e695)
+
+* ```embed_key``` option to allow embedding by attributes other than IDs
+* Fix rendering nil with custom serializer
+* Fix global ```self.root = false```
+* Add support for specifying the serializer for an association as a String
+* Able to specify keys on the attributes method
+* Serializer Reloading via ActiveSupport::DescendantsTracker
+* Reduce double map to once; Fixes datamapper eager loading.
+
+## 0.6.0 (October 22, 2012)
+
+* Serialize sets properly
+* Add root option to ArraySerializer
+* Support polymorphic associations
+* Support :each_serializer in ArraySerializer
+* Add `scope` method to easily access the scope in the serializer
+* Fix regression with Rails 3.2.6; add Rails 4 support
+* Allow serialization_scope to be disabled with serialization_scope nil
+* Array serializer should support pure ruby objects besides serializers
+
+## 0.05.x
+
+### [0.5.2 (June 5, 2012)](https://github.com/rails-api/active_model_serializers/commit/615afd125c260432d456dc8be845867cf87ea118#diff-0c5c12f311d3b54734fff06069efd2ac)
+
+### [0.5.1 (May 23, 2012)](https://github.com/rails-api/active_model_serializers/commit/00194ec0e41831802fcbf893a34c0bb0853ebe14#diff-0c5c12f311d3b54734fff06069efd2ac)
+
+### [0.5.0 (May 16, 2012)](https://github.com/rails-api/active_model_serializers/commit/33d4842dcd35c7167b0b33fc0abcf00fb2c92286)
+
+* First tagged version
+* Changes generators to always generate an ApplicationSerializer
+
+## [0.1.0 (December 21, 2011)](https://github.com/rails-api/active_model_serializers/commit/1e0c9ef93b96c640381575dcd30be07ac946818b)
+
+## First Commit as [Rails Serializers 0.0.1](https://github.com/rails-api/active_model_serializers/commit/d72b66d4c5355b0ff0a75a04895fcc4ea5b0c65e)
+  (December 1, 2011).
+
+## Prehistory
+
+- [Changing Serialization/Serializers namespace to `Serializable` (November 30, 2011)](https://github.com/rails/rails/commit/8896b4fdc8a543157cdf4dfc378607ebf6c10ab0)
+  - [Merge branch 'serializers'. This implements the ActiveModel::Serializer object. Includes code, tests, generators and guides. From José and Yehuda with love.](https://github.com/rails/rails/commit/fcacc6986ab60f1fb2e423a73bf47c7abd7b191d)
+  - But [was reverted](https://github.com/rails/rails/commit/5b2eb64ceb08cd005dc06b721935de5853971473).
+    '[Revert the serializers API as other alternatives are now also under discussion](https://github.com/rails/rails/commit/0a4035b12a6c59253cb60f9e3456513c6a6a9d33)'.
+- [Proposed Implementation to Rails 3.2 by @wycats and @josevalim (November 25, 2011)](https://github.com/rails/rails/pull/3753)
+  - [Docs and CHANGELOG](https://github.com/rails/rails/commit/696d01f7f4a8ed787924a41cce6df836cd73c46f)
+  - [Deprecation of ActiveModel::Serialization to ActiveModel::Serializable](https://github.com/rails/rails/blob/696d01f7f4a8ed787924a41cce6df836cd73c46f/activemodel/lib/active_model/serialization.rb)
+- [Creation of `ActiveModel::Serialization` from `ActiveModel::Serializer` in Rails (2009)](https://github.com/rails/rails/commit/c6bc8e662614be711f45a8d4b231d5f993b024a7#diff-d029b9768d8df0407a35804a468e3ae5)
+- [Integration of `ActiveModel::Serializer` into `ActiveRecord::Serialization`](https://github.com/rails/rails/commit/783db25e0c640c1588732967a87d65c10fddc08e)
+- [Creation of `ActiveModel::Serializer` in Rails (2009)](https://github.com/rails/rails/commit/d2b78b3594b9cc9870e6a6ebfeb2e56d00e6ddb8#diff-80d5beeced9bdc24ca2b04a201543bdd)
+- [Creation of `ActiveModel::Serializers::JSON` in Rails (2009)](https://github.com/rails/rails/commit/fbdf706fffbfb17731a1f459203d242414ef5086)

CONTRIBUTING.md

@@ -1,3 +1,5 @@
+First of all, **thank you**!
+
 ![Commit Strip
 http://www.commitstrip.com/en/2014/05/07/the-truth-behind-open-source-apps/](docs/how-open-source-maintained.jpg)
 
@@ -214,3 +216,5 @@ To run a single test suite
 Which can be further narrowed down to one test:
 
 `$ rake test TEST=path/to/test.rb TESTOPTS="--name=test_something"`
+
+:heart: :sparkling_heart: :heart:

docs/ARCHITECTURE.md

@@ -15,7 +15,7 @@ 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](jsonapi.org/) document.
+API](http://jsonapi.org/) document.
 
 The **`ActiveModel::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

docs/DESIGN.textile

@@ -0,0 +1,13 @@
+module ActiveModel
+  class Serializer
+    Attribute = Struct.new(:name, :block) do
+      def value(serializer)
+        if block
+          serializer.instance_eval(&block)
+        else
+          serializer.read_attribute_for_serialization(name)
+        end
+      end
+    end
+  end
+end

lib/active_model/serializer/attribute.rb

@@ -1,63 +1,32 @@
 module ActiveModel
   class Serializer
     module Attributes
-      # @api private
-      class Attribute
-        delegate :call, to: :reader
-
-        attr_reader :name, :reader
-
-        def initialize(name)
-          @name = name
-          @reader = :no_reader
-        end
-
-        def self.build(name, block)
-          if block
-            AttributeBlock.new(name, block)
-          else
-            AttributeReader.new(name)
-          end
-        end
-      end
-      # @api private
-      class AttributeReader < Attribute
-        def initialize(name)
-          super(name)
-          @reader = ->(instance) { instance.read_attribute_for_serialization(name) }
-        end
-      end
-      # @api private
-      class AttributeBlock < Attribute
-        def initialize(name, block)
-          super(name)
-          @reader = ->(instance) { instance.instance_eval(&block) }
-        end
-      end
-
       extend ActiveSupport::Concern
 
       included do
         with_options instance_writer: false, instance_reader: false do |serializer|
-          serializer.class_attribute :_attribute_mappings # @api private : maps attribute key names to names to names of implementing methods, @see #attribute
-          self._attribute_mappings ||= {}
+          serializer.class_attribute :_attributes_data # @api private
+          self._attributes_data ||= {}
         end
 
+        extend ActiveSupport::Autoload
+        autoload :Attribute
+
         # Return the +attributes+ of +object+ as presented
         # by the serializer.
         def attributes(requested_attrs = nil, reload = false)
           @attributes = nil if reload
-          @attributes ||= self.class._attribute_mappings.each_with_object({}) do |(key, attribute_mapping), hash|
+          @attributes ||= self.class._attributes_data.each_with_object({}) do |(key, attr), hash|
             next unless requested_attrs.nil? || requested_attrs.include?(key)
-            hash[key] = attribute_mapping.call(self)
+            hash[key] = attr.value(self)
           end
         end
       end
 
       module ClassMethods
         def inherited(base)
           super
-          base._attribute_mappings = _attribute_mappings.dup
+          base._attributes_data = _attributes_data.dup
         end
 
         # @example
@@ -85,25 +54,25 @@ def attributes(*attrs)
         #     end
         def attribute(attr, options = {}, &block)
           key = options.fetch(:key, attr)
-          _attribute_mappings[key] = Attribute.build(attr, block)
+          _attributes_data[key] = Attribute.new(attr, block)
         end
 
         # @api private
-        # names of attribute methods
+        # keys of attributes
         # @see Serializer::attribute
         def _attributes
-          _attribute_mappings.keys
+          _attributes_data.keys
         end
 
         # @api private
         # maps attribute value to explict key name
         # @see Serializer::attribute
         # @see Adapter::FragmentCache#fragment_serializer
         def _attributes_keys
-          _attribute_mappings
-            .each_with_object({}) do |(key, attribute_mapping), hash|
-              next if key == attribute_mapping.name
-              hash[attribute_mapping.name] = { key: key }
+          _attributes_data
+            .each_with_object({}) do |(key, attr), hash|
+              next if key == attr.name
+              hash[attr.name] = { key: key }
             end
         end
       end

lib/active_model/serializer/attributes.rb

@@ -8,14 +8,14 @@ class Serializer
     #     has_one :author, serializer: AuthorSerializer
     #     has_many :comments
     #     has_many :comments, key: :last_comments do
-    #       last(1)
+    #       object.comments.last(1)
     #     end
     #  end
     #
-    #  Notice that the association block is evaluated in the context of the association.
+    #  Notice that the association block is evaluated in the context of the serializer.
     #  Specifically, the association 'comments' is evaluated two different ways:
     #  1) as 'comments' and named 'comments'.
-    #  2) as 'comments.last(1)' and named 'last_comments'.
+    #  2) as 'object.comments.last(1)' and named 'last_comments'.
     #
     #  PostSerializer._reflections #=>
     #    # [
@@ -29,7 +29,7 @@ class Serializer
       # @api private
       def value(instance)
         if block
-          instance.read_attribute_for_serialization(name).instance_eval(&block)
+          instance.instance_eval(&block)
         else
           instance.read_attribute_for_serialization(name)
         end

lib/active_model/serializer/reflection.rb

@@ -2,7 +2,7 @@
 
 module ActiveModel
   class Serializer
-    class LoggingTest < Minitest::Test
+    class LoggingTest < ActiveSupport::TestCase
       class TestLogger < ActiveSupport::Logger
         def initialize
           @file = StringIO.new

test/active_model_serializers/logging_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ActiveModelSerializers::ModelTest < Minitest::Test
+class ActiveModelSerializers::ModelTest < ActiveSupport::TestCase
   include ActiveModel::Serializer::Lint::Tests
 
   def setup