active_model_serializers 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 65701e1dd4ae30a60340c60fa9361c540148bb64
-  data.tar.gz: f7b2b52348b116ac1eea607a51e9ddb8d9c15fce
+  metadata.gz: 71be6d0e61baa4efeb910bd0d063dca70cef1172
+  data.tar.gz: 0a462ca58f799f3a52a2bc9207a510644eb6bf9e
 SHA512:
-  metadata.gz: 658d1fadb66a26b4b93a72cdb87498bb89ee83565de5d846ca3e2cdaa913303256e9267627d8e55593aa1696963f255e2fe44918e858ce2e66251710d3694241
-  data.tar.gz: 2b100c2bcb26d9696001eefae6fd3bddc68d779578c2c313f64b06f47cf51024f6e525a7afd70d8afd28d973bb7fd2d9bb7923391d2271233317d2a6669948b0
+  metadata.gz: 13b2dfe87f088d7a3373cba201fa3b4712c26fac49e0b2274941872be29648fda607161bee2633c047d55eae18f234170b944c6948f75f306c62d400c61d660a
+  data.tar.gz: 46602b4f0d64f25b5932176251d4f473b3696ed71f11fb7e5c3d8a5874499010324d84e3a052d6f08cfa8a24b3f4c3c3ad427319b5a3fd5b020211de5859394e

data/CHANGELOG.md

@@ -20,6 +20,12 @@
 
 * 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.
+
 # VERSION 0.8.1
 
 * Fix bug whereby a serializer using 'options' would blow up.

data/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
@@ -94,6 +94,17 @@ serializer when you render the object:
 render json: @post, serializer: FancyPostSerializer
 ```
 
+### Use serialization outside of ActionController::Base
+
+When controller does not inherit from ActionController::Base,
+include Serialization module manually:
+
+```ruby
+class ApplicationController < ActionController::API
+  include ActionController::Serialization
+end
+```
+
 ## Arrays
 
 In your controllers, when you use `render :json` for an array of objects, AMS will
@@ -229,13 +240,25 @@ ActiveModel::Serializer.setup do |config|
   config.key_format = :lower_camel
 end
 
-class BlogLowerCamelSerializer < ActiveModel::Serializer 
+class BlogLowerCamelSerializer < ActiveModel::Serializer
   format_keys :lower_camel
 end
 
 BlogSerializer.new(object, key_format: :lower_camel)
 ```
 
+## Changing the default association key type
+
+You can specify that serializers use unsuffixed names as association keys by default.
+
+`````ruby
+ActiveModel::Serializer.setup do |config|
+  config.default_key_type = :name
+end
+````
+
+This will build association keys like `comments` or `author` instead of `comment_ids` or `author_id`.
+
 ## Getting the old version
 
 If you find that your project is already relying on the old rails to_json
@@ -281,7 +304,7 @@ Since this shadows any attribute named `object`, you can include them through `o
 
 ```ruby
 class VersionSerializer < ActiveModel::Serializer
-  attribute :version_object, key: :object
+  attributes :version_object
 
   def version_object
     object.object
@@ -354,7 +377,7 @@ The above usage of `:meta` will produce the following:
 If you would like to change the meta key name you can use the `:meta_key` option:
 
 ```ruby
-render json: @posts, serializer: CustomArraySerializer, meta: {total: 10}, meta_key: 'meta_object'
+render json: @posts, serializer: CustomArraySerializer, meta_object: {total: 10}, meta_key: 'meta_object'
 ```
 
 The above usage of `:meta_key` will produce the following:
@@ -467,9 +490,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
@@ -516,15 +536,15 @@ Now, any associations will be supplied as an Array of IDs:
 }
 ```
 
-You may also choose to embed the IDs by the association's name underneath an
-`embed_key` for the resource. For example, say we want to change `comment_ids`
+You may also choose to embed the IDs by the association's name underneath a
+`key` for the resource. For example, say we want to change `comment_ids`
 to `comments` underneath a `links` key:
 
 ```ruby
 class PostSerializer < ActiveModel::Serializer
   attributes :id, :title, :body
 
-  has_many :comments, embed: ids, embed_namespace: :links
+  has_many :comments, embed: :ids, key: :comments, embed_namespace: :links
 end
 ```
 
@@ -615,7 +635,7 @@ the root document (say, `linked`), you can specify an `embed_in_root_key`:
 
 ```ruby
 class PostSerializer < ActiveModel::Serializer
-  embed: ids, include: true, embed_in_root_key: :linked
+  embed :ids, include: true, embed_in_root_key: :linked
 
   attributes: :id, :title, :body
   has_many :comments, :tags
@@ -646,8 +666,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
@@ -686,7 +706,7 @@ class PostSerializer < ActiveModel::Serializer
   embed :ids, include: true
 
   attributes :id, :title, :body
-  has_many :comments, embed_key: :external_id
+  has_many :comments, key: :external_id
 end
 ```
 
@@ -714,6 +734,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

data/lib/action_controller/serialization.rb

@@ -45,18 +45,32 @@ module ActionController
       end
     end
 
-    def _render_option_json(resource, options)
-      serializer = build_json_serializer(resource, options)
+    [:_render_option_json, :_render_with_renderer_json].each do |renderer_method|
+      define_method renderer_method do |resource, options|
+        serializer = build_json_serializer(resource, options)
 
-      if serializer
-        super(serializer, options)
-      else
-        super
+        if serializer
+          super(serializer, options)
+        else
+          super(resource, options)
+        end
       end
     end
 
     private
 
+    def namespace_for_serializer
+      @namespace_for_serializer ||= self.class.parent unless self.class.parent == Object
+    end
+
+    def default_serializer(resource)
+      options = {}.tap do |o|
+        o[:namespace] = namespace_for_serializer if namespace_for_serializer
+      end
+
+      ActiveModel::Serializer.serializer_for(resource, options)
+    end
+
     def default_serializer_options
       {}
     end
@@ -68,10 +82,15 @@ module ActionController
 
     def build_json_serializer(resource, options = {})
       options = default_serializer_options.merge(options)
+      @namespace_for_serializer = options.fetch(:namespace, nil)
 
-      if serializer = options.fetch(:serializer, ActiveModel::Serializer.serializer_for(resource))
+      if serializer = options.fetch(:serializer, default_serializer(resource))
         options[:scope] = serialization_scope unless options.has_key?(:scope)
-        options[:resource_name] = controller_name if resource.respond_to?(:to_ary)
+
+        if resource.respond_to?(:each)
+          options[:resource_name] = controller_name 
+          options[:namespace] = namespace_for_serializer if namespace_for_serializer
+        end
 
         serializer.new(resource, options)
       end

data/lib/action_controller/serialization_test_case.rb

@@ -3,11 +3,11 @@ module ActionController
     extend ActiveSupport::Concern
 
     included do
-      setup :setup_subscriptions
-      teardown :teardown_subscriptions
+      setup :setup_serialization_subscriptions
+      teardown :teardown_serialization_subscriptions
     end
 
-    def setup_subscriptions
+    def setup_serialization_subscriptions
       @serializers = Hash.new(0)
 
       ActiveSupport::Notifications.subscribe("!serialize.active_model_serializers") do |name, start, finish, id, payload|
@@ -16,7 +16,7 @@ module ActionController
       end
     end
 
-    def teardown_subscriptions
+    def teardown_serialization_subscriptions
       ActiveSupport::Notifications.unsubscribe("!serialize.active_model_serializers")
     end
 

data/lib/active_model/array_serializer.rb

@@ -15,12 +15,14 @@ module ActiveModel
       @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]
       @resource_name   = options[:resource_name]
       @only            = options[:only] ? Array(options[:only]) : nil
       @except          = options[:except] ? Array(options[:except]) : nil
+      @namespace       = options[:namespace]
       @key_format      = options[:key_format] || options[:each_serializer].try(:key_format)
     end
     attr_accessor :object, :scope, :root, :meta_key, :meta, :key_format
@@ -32,13 +34,13 @@ module ActiveModel
     end
 
     def serializer_for(item)
-      serializer_class = @each_serializer || Serializer.serializer_for(item) || DefaultSerializer
-      serializer_class.new(item, scope: scope, key_format: key_format, only: @only, except: @except)
+      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, polymorphic: @polymorphic, namespace: @namespace)
     end
 
-    def serializable_object
+    def serializable_object(options={})
       @object.map do |item|
-        serializer_for(item).serializable_object
+        serializer_for(item).serializable_object_with_notification(options)
       end
     end
     alias_method :serializable_array, :serializable_object
@@ -49,7 +51,11 @@ module ActiveModel
           next if !objects || objects.flatten.empty?
 
           if hash.has_key?(type)
-            hash[type].concat(objects).uniq!
+            case hash[type] when Hash
+              hash[type].deep_merge!(objects){ |key, old, new| (Array(old) + Array(new)).uniq }
+            else
+              hash[type].concat(objects).uniq!
+            end
           else
             hash[type] = objects
           end
@@ -58,6 +64,7 @@ module ActiveModel
     end
 
     private
+
     def instrumentation_keys
       [:object, :scope, :root, :meta_key, :meta, :each_serializer, :resource_name, :key_format]
     end

data/lib/active_model/serializable.rb

@@ -1,17 +1,29 @@
+require 'active_model/serializable/utils'
+
 module ActiveModel
   module Serializable
+    def self.included(base)
+      base.extend Utils
+    end
+
     def as_json(options={})
       instrument('!serialize') do
         if root = options.fetch(:root, json_key)
-          hash = { root => serializable_object }
+          hash = { root => serializable_object(options) }
           hash.merge!(serializable_data)
           hash
         else
-          serializable_object
+          serializable_object(options)
         end
       end
     end
 
+    def serializable_object_with_notification(options={})
+      instrument('!serialize') do
+        serializable_object(options)
+      end
+    end
+
     def serializable_data
       embedded_in_root_associations.tap do |hash|
         if respond_to?(:meta) && meta
@@ -20,11 +32,21 @@ module ActiveModel
       end
     end
 
+    def namespace
+      get_namespace && Utils._const_get(get_namespace)
+    end
+
     def embedded_in_root_associations
       {}
     end
 
     private
+
+    def get_namespace
+      modules = self.class.name.split('::')
+      modules[0..-2].join('::') if modules.size > 1
+    end
+
     def instrument(action, &block)
       payload = instrumentation_keys.inject({ serializer: self.class.name }) do |payload, key|
         payload[:payload] = self.instance_variable_get(:"@#{key}")

data/lib/active_model/serializable/utils.rb

@@ -0,0 +1,16 @@
+module ActiveModel
+  module Serializable
+    module Utils
+      extend self
+
+      def _const_get(const)
+        begin
+          method = RUBY_VERSION >= '2.0' ? :const_get : :qualified_const_get
+          Object.send method, const
+        rescue NameError
+          const.safe_constantize
+        end
+      end
+    end
+  end
+end

data/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'
@@ -55,33 +55,15 @@ end
       end
       attr_reader :key_format
 
-      if RUBY_VERSION >= '2.0'
-        def serializer_for(resource)
-          if resource.respond_to?(:to_ary)
-            if Object.constants.include?(:ArraySerializer)
-              ::ArraySerializer
-            else
-              ArraySerializer
-            end
-          else
-            begin
-              Object.const_get "#{resource.class.name}Serializer"
-            rescue NameError
-              nil
-            end
-          end
-        end
-      else
-        def serializer_for(resource)
-          if resource.respond_to?(:to_ary)
-            if Object.constants.include?(:ArraySerializer)
-              ::ArraySerializer
-            else
-              ArraySerializer
-            end
+      def serializer_for(resource, options = {})
+        if resource.respond_to?(:each)
+          if Object.constants.include?(:ArraySerializer)
+            ::ArraySerializer
           else
-            "#{resource.class.name}Serializer".safe_constantize
+            ArraySerializer
           end
+        else
+          _const_get build_serializer_class(resource, options)
         end
       end
 
@@ -90,14 +72,19 @@ end
       alias root= _root=
 
       def root_name
-        name.demodulize.underscore.sub(/_serializer$/, '') if name
+        if name
+          root_name = name.demodulize.underscore.sub(/_serializer$/, '')
+          CONFIG.plural_default_root ? root_name.pluralize : root_name
+        end
       end
 
       def attributes(*attrs)
-        @_attributes.concat attrs
-
         attrs.each do |attr|
-          define_method attr do
+          striped_attr = strip_attribute attr
+
+          @_attributes << striped_attr
+
+          define_method striped_attr do
             object.read_attribute_for_serialization attr
           end unless method_defined?(attr)
         end
@@ -113,6 +100,22 @@ end
 
       private
 
+      def strip_attribute(attr)
+        symbolized = attr.is_a?(Symbol)
+
+        attr = attr.to_s.gsub(/\?\Z/, '')
+        attr = attr.to_sym if symbolized
+        attr
+      end
+
+      def build_serializer_class(resource, options)
+        "".tap do |klass_name|
+          klass_name << "#{options[:namespace]}::" if options[:namespace]
+          klass_name << options[:prefix].to_s.classify if options[:prefix]
+          klass_name << "#{resource.class.name}Serializer"
+        end
+      end
+
       def associate(klass, *attrs)
         options = attrs.extract_options!
 
@@ -130,6 +133,7 @@ end
       @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]
@@ -137,8 +141,9 @@ end
       @except        = options[:except] ? Array(options[:except]) : nil
       @key_format    = options[:key_format]
       @context       = options[:context]
+      @namespace     = options[:namespace]
     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?
@@ -194,12 +199,15 @@ end
       included_associations = filter(associations.keys)
       associations.each_with_object({}) do |(name, association), hash|
         if included_associations.include? name
+          association_serializer = build_serializer(association)
+          # we must do this always because even if the current association is not
+          # embeded in root, it might have its own associations that are embeded in root
+          hash.merge!(association_serializer.embedded_in_root_associations) {|key, oldval, newval| [newval, oldval].flatten }
+
           if association.embed_in_root?
             if association.embed_in_root_key?
               hash = hash[association.embed_in_root_key] ||= {}
             end
-            association_serializer = build_serializer(association)
-            hash.merge!(association_serializer.embedded_in_root_associations) {|key, oldval, newval| [newval, oldval].flatten }
 
             serialized_data = association_serializer.serializable_object
             key = association.root_key
@@ -215,7 +223,17 @@ end
 
     def build_serializer(association)
       object = send(association.name)
-      association.build_serializer(object, scope: scope)
+      association.build_serializer(object, association_options_for_serializer(association))
+    end
+
+    def association_options_for_serializer(association)
+      prefix    = association.options[:prefix]
+      namespace = association.options[:namespace] || @namespace || self.namespace
+
+      { scope: scope }.tap do |opts|
+        opts[:namespace] = namespace if namespace
+        opts[:prefix]    = prefix    if prefix
+      end
     end
 
     def serialize(association)
@@ -225,9 +243,9 @@ end
     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
 
@@ -255,14 +273,30 @@ end
       end]
     end
 
+    attr_writer :serialization_options
+    def serialization_options
+      @serialization_options || {}
+    end
+
     def serializable_object(options={})
+      self.serialization_options = options
       return @wrap_in_array ? [] : nil if @object.nil?
       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