sync with upstream

Author: kfyodor

README.md

@@ -1,12 +1,12 @@
-[![Build Status](https://api.travis-ci.org/rails-api/active_model_serializers.png?branch=0-9-stable)](https://travis-ci.org/rails-api/active_model_serializers) 
-[![Code Climate](https://codeclimate.com/github/rails-api/active_model_serializers.png)](https://codeclimate.com/github/rails-api/active_model_serializers) 
+[![Build Status](https://api.travis-ci.org/rails-api/active_model_serializers.png?branch=0-9-stable)](https://travis-ci.org/rails-api/active_model_serializers)
+[![Code Climate](https://codeclimate.com/github/rails-api/active_model_serializers.png)](https://codeclimate.com/github/rails-api/active_model_serializers)
 
 # ActiveModel::Serializers
 
 ## Purpose
 
-`ActiveModel::Serializers` encapsulates the JSON serialization of objects. 
-Objects that respond to read\_attribute\_for\_serialization 
+`ActiveModel::Serializers` encapsulates the JSON serialization of objects.
+Objects that respond to read\_attribute\_for\_serialization
 (including `ActiveModel` and `ActiveRecord` objects) are supported.
 
 Serializers know about both a model and the `current_user`, so you can
@@ -229,7 +229,7 @@ ActiveModel::Serializer.setup do |config|
   config.key_format = :lower_camel
 end
 
-class BlogLowerCamelSerializer < ActiveModel::Serializer 
+class BlogLowerCamelSerializer < ActiveModel::Serializer
   format_keys :lower_camel
 end
 
@@ -467,9 +467,6 @@ You may also use the `:serializer` option to specify a custom serializer class a
 
 Serializers are only concerned with multiplicity, and not ownership. `belongs_to` ActiveRecord associations can be included using `has_one` in your serializer.
 
-NOTE: polymorphic was removed because was only supported for has\_one
-associations and is in the TODO list of the project.
-
 ## Embedding Associations
 
 By default, associations will be embedded inside the serialized object. So if
@@ -646,8 +643,8 @@ The above would yield the following JSON document:
 }
 ```
 
-When side-loading data, your serializer cannot have the `{ root: false }` option, 
-as this would lead to invalid JSON. If you do not have a root key, the `include` 
+When side-loading data, your serializer cannot have the `{ root: false }` option,
+as this would lead to invalid JSON. If you do not have a root key, the `include`
 instruction will be ignored
 
 You can also specify a different root for the embedded objects than the key
@@ -714,6 +711,78 @@ data looking for information, is extremely useful.
 If you are mostly working with the data in simple scenarios and manually making
 Ajax requests, you probably just want to use the default embedded behavior.
 
+
+## Embedding Polymorphic Associations
+
+Because we need both the id and the type to be able to identify a polymorphic associated model, these are serialized in a slightly different format than common ones.
+
+When embedding entire objects:
+
+```ruby
+class PostSerializer < ActiveModel::Serializer
+  attributes :id, :title
+  has_many :attachments, polymorphic: true
+end
+```
+
+```json
+{
+  "post": {
+    "id": 1,
+    "title": "New post",
+    "attachments": [
+      {
+        "type": "image"
+        "image": {
+          "id": 3
+          "name": "logo"
+          "url": "http://images.com/logo.jpg"
+        }
+      },
+      {
+        "type": "video"
+        "video": {
+          "id": 12
+          "uid": "XCSSMDFWW"
+          "source": "youtube"
+        }
+      }
+    ]
+  }
+}
+```
+
+When embedding ids:
+
+```ruby
+class PostSerializer < ActiveModel::Serializer
+  embed :ids
+
+  attributes :id, :title
+  has_many :attachments, polymorphic: true
+end
+```
+
+```json
+{
+  "post": {
+    "id": 1,
+    "title": "New post",
+    "attachment_ids": [
+      {
+        "type": "image"
+        "id": 12
+      },
+      {
+        "type": "video"
+        "id": 3
+      }
+    ]
+  }
+}
+```
+
+
 ## Customizing Scope
 
 In a serializer, `current_user` is the current authorization scope which the controller

lib/active_model/array_serializer.rb

@@ -15,6 +15,7 @@ def initialize(object, options={})
       @object          = object
       @scope           = options[:scope]
       @root            = options.fetch(:root, self.class._root)
+      @polymorphic   = options.fetch(:polymorphic, false)
       @meta_key        = options[:meta_key] || :meta
       @meta            = options[@meta_key]
       @each_serializer = options[:each_serializer]
@@ -34,7 +35,7 @@ def json_key
 
     def serializer_for(item)
       serializer_class = @each_serializer || Serializer.serializer_for(item, namespace: @namespace) || DefaultSerializer
-      serializer_class.new(item, scope: scope, key_format: key_format, only: @only, except: @except)
+      serializer_class.new(item, scope: scope, key_format: key_format, only: @only, except: @except, polymorphic: @polymorphic)
     end
 
     def serializable_object

lib/active_model/serializer.rb

@@ -1,6 +1,6 @@
 require 'active_model/array_serializer'
 require 'active_model/serializable'
-require 'active_model/serializer/associations'
+require 'active_model/serializer/association'
 require 'active_model/serializer/config'
 
 require 'thread'
@@ -138,6 +138,7 @@ def initialize(object, options={})
       @object        = object
       @scope         = options[:scope]
       @root          = options.fetch(:root, self.class._root)
+      @polymorphic   = options.fetch(:polymorphic, false)
       @meta_key      = options[:meta_key] || :meta
       @meta          = options[@meta_key]
       @wrap_in_array = options[:_wrap_in_array]
@@ -146,7 +147,7 @@ def initialize(object, options={})
       @key_format    = options[:key_format]
       @context       = options[:context]
     end
-    attr_accessor :object, :scope, :root, :meta_key, :meta, :key_format, :context
+    attr_accessor :object, :scope, :root, :meta_key, :meta, :key_format, :context, :polymorphic
 
     def json_key
       key = if root == true || root.nil?
@@ -242,9 +243,9 @@ def serialize(association)
     def serialize_ids(association)
       associated_data = send(association.name)
       if associated_data.respond_to?(:to_ary)
-        associated_data.map { |elem| elem.read_attribute_for_serialization(association.embed_key) }
+        associated_data.map { |elem| serialize_id(elem, association) }
       else
-        associated_data.read_attribute_for_serialization(association.embed_key) if associated_data
+        serialize_id(associated_data, association) if associated_data
       end
     end
 
@@ -277,9 +278,19 @@ def serializable_object(options={})
       hash = attributes
       hash.merge! associations
       hash = convert_keys(hash) if key_format.present?
+      hash = { :type => type_name(@object), type_name(@object) => hash } if @polymorphic
       @wrap_in_array ? [hash] : hash
     end
     alias_method :serializable_hash, :serializable_object
+
+    def serialize_id(elem, association)
+      id = elem.read_attribute_for_serialization(association.embed_key)
+      association.polymorphic? ? { id: id, type: type_name(elem) } : id
+    end
+
+    def type_name(elem)
+      elem.class.to_s.demodulize.underscore.to_sym
+    end
   end
 
 end

lib/active_model/serializer/associations.rb renamed to lib/active_model/serializer/association.rb

@@ -1,4 +1,6 @@
 require 'active_model/default_serializer'
+require 'active_model/serializer/association/has_one'
+require 'active_model/serializer/association/has_many'
 
 module ActiveModel
   class Serializer
@@ -13,6 +15,7 @@ def initialize(name, options={})
         @name          = name.to_s
         @options       = options
         self.embed     = options.fetch(:embed) { CONFIG.embed }
+        @polymorphic   = options.fetch(:polymorphic, false)
         @embed_in_root = options.fetch(:embed_in_root) { options.fetch(:include) { CONFIG.embed_in_root } }
         @key_format    = options.fetch(:key_format) { CONFIG.key_format }
         @embed_key     = options[:embed_key] || :id
@@ -25,13 +28,14 @@ def initialize(name, options={})
         @serializer_from_options = serializer.is_a?(String) ? serializer.constantize : serializer
       end
 
-      attr_reader :name, :embed_ids, :embed_objects
+      attr_reader :name, :embed_ids, :embed_objects, :polymorphic
       attr_accessor :embed_in_root, :embed_key, :key, :embedded_key, :root_key, :serializer_from_options, :options, :key_format, :embed_in_root_key, :embed_namespace
       alias embed_ids? embed_ids
       alias embed_objects? embed_objects
       alias embed_in_root? embed_in_root
       alias embed_in_root_key? embed_in_root_key
       alias embed_namespace? embed_namespace
+      alias polymorphic? polymorphic
 
       def embed=(embed)
         @embed_ids     = embed == :id || embed == :ids
@@ -49,54 +53,6 @@ def default_serializer
       def build_serializer(object, options = {})
         serializer_class(object, options).new(object, options.merge(self.options))
       end
-
-      class HasOne < Association
-        def initialize(name, *args)
-          super
-          @root_key = @embedded_key.to_s.pluralize
-          @key ||= "#{name}_id"
-        end
-
-        def serializer_class(object, options = {})
-          serializer_from_options || serializer_from_object(object, options) || default_serializer
-        end
-
-        def build_serializer(object, options = {})
-          options[:_wrap_in_array] = embed_in_root?
-          super
-        end
-      end
-
-      class HasMany < Association
-        def initialize(name, *args)
-          super
-          @root_key = @embedded_key
-          @key ||= "#{name.to_s.singularize}_ids"
-        end
-
-        def serializer_class(object, _ = {})
-          if use_array_serializer?
-            ArraySerializer
-          else
-            serializer_from_options
-          end
-        end
-
-        def options
-          if use_array_serializer?
-            { each_serializer: serializer_from_options }.merge! super
-          else
-            super
-          end
-        end
-
-        private
-
-        def use_array_serializer?
-          !serializer_from_options ||
-            serializer_from_options && !(serializer_from_options <= ArraySerializer)
-        end
-      end
     end
   end
 end

lib/active_model/serializer/association/has_many.rb

@@ -0,0 +1,36 @@
+module ActiveModel
+  class Serializer
+    class Association
+      class HasMany < Association
+        def initialize(name, *args)
+          super
+          @root_key = @embedded_key
+          @key ||= "#{name.to_s.singularize}_ids"
+        end
+
+        def serializer_class(object, _)
+          if use_array_serializer?
+            ArraySerializer
+          else
+            serializer_from_options
+          end
+        end
+
+        def options
+          if use_array_serializer?
+            { each_serializer: serializer_from_options }.merge! super
+          else
+            super
+          end
+        end
+
+        private
+
+        def use_array_serializer?
+          !serializer_from_options ||
+            serializer_from_options && !(serializer_from_options <= ArraySerializer)
+        end
+      end
+    end
+  end
+end

lib/active_model/serializer/association/has_one.rb

@@ -0,0 +1,22 @@
+module ActiveModel
+  class Serializer
+    class Association
+      class HasOne < Association
+        def initialize(name, *args)
+          super
+          @root_key = @embedded_key.to_s.pluralize
+          @key ||= "#{name}_id"
+        end
+
+        def serializer_class(object, options = {})
+          serializer_from_options || serializer_from_object(object, options) || default_serializer
+        end
+
+        def build_serializer(object, options = {})
+          options[:_wrap_in_array] = embed_in_root?
+          super
+        end
+      end
+    end
+  end
+end

lib/active_model_serializers.rb

@@ -9,7 +9,7 @@
   require 'action_controller/serialization'
   require 'action_controller/serialization_test_case'
 
-  ActiveSupport.on_load(:after_initialize) do
+  ActiveSupport.on_load(:action_controller) do
     if ::ActionController::Serialization.enabled
       ActionController::Base.send(:include, ::ActionController::Serialization)
       ActionController::TestCase.send(:include, ::ActionController::SerializationAssertions)