merge upstream update fieldset

Author: arenoir

.travis.yml

@@ -1,18 +1,24 @@
 language: ruby
+
+sudo: false
+
 rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.1
   - jruby-19mode
   - rbx-2
   - ruby-head
+
 install:
   - bundle install --retry=3
+
 env:
   - "RAILS_VERSION=3.2"
   - "RAILS_VERSION=4.0"
   - "RAILS_VERSION=4.1"
   - "RAILS_VERSION=master"
+
 matrix:
   allow_failures:
     - rvm: ruby-head

README.md

@@ -69,6 +69,18 @@ ActiveModel::Serializer.config.adapter = :hal
 You won't need to implement an adapter unless you wish to use a new format or
 media type with AMS.
 
+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.
 
@@ -94,6 +106,27 @@ member when the resource names are included in the `include` option.
   render @posts, include: 'authors,comments'
 ```
 
+### 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: PaginatedSerializer, each_serializer: PostPreviewSerializer
+```
+
 ## Installation
 
 Add this line to your application's Gemfile:

lib/action_controller/serialization.rb

@@ -6,18 +6,32 @@ module Serialization
 
     include ActionController::Renderers
 
-    ADAPTER_OPTION_KEYS = [:include, :fields, :root]
+    ADAPTER_OPTION_KEYS = [:include, :fields, :root, :adapter]
+
+    def get_serializer(resource)
+      @_serializer ||= @_serializer_opts.delete(:serializer)
+      @_serializer ||= ActiveModel::Serializer.serializer_for(resource)
+
+      if @_serializer_opts.key?(:each_serializer)
+        @_serializer_opts[:serializer] = @_serializer_opts.delete(:each_serializer)
+      end
+
+      @_serializer
+    end
+
+    def use_adapter?
+      !(@_adapter_opts.key?(:adapter) && !@_adapter_opts[:adapter])
+    end
 
     [:_render_option_json, :_render_with_renderer_json].each do |renderer_method|
       define_method renderer_method do |resource, options|
-        serializer = ActiveModel::Serializer.serializer_for(resource)
+        @_adapter_opts, @_serializer_opts =
+          options.partition { |k, _| ADAPTER_OPTION_KEYS.include? k }.map { |h| Hash[h] }
 
-        if serializer
-          adapter_opts, serializer_opts =
-            options.partition { |k, _| ADAPTER_OPTION_KEYS.include? k }
+        if use_adapter? && (serializer = get_serializer(resource))
           # omg hax
-          object = serializer.new(resource, Hash[serializer_opts])
-          adapter = ActiveModel::Serializer.adapter.new(object, Hash[adapter_opts])
+          object = serializer.new(resource, @_serializer_opts)
+          adapter = ActiveModel::Serializer::Adapter.create(object, @_adapter_opts)
           super(adapter, options)
         else
           super(resource, options)

lib/active_model/serializer.rb

@@ -21,14 +21,21 @@ def self.inherited(base)
     def self.attributes(*attrs)
       @_attributes.concat attrs
 
-
       attrs.each do |attr|
         define_method attr do
           object.read_attribute_for_serialization(attr)
         end unless method_defined?(attr)
       end
     end
 
+    def self.attribute(attr, options = {})
+      key = options.fetch(:key, attr)
+      @_attributes.concat [key]
+      define_method key do
+        object.read_attribute_for_serialization(attr)
+      end unless method_defined?(key)
+    end
+
     # Defines an association in the object should be rendered.
     #
     # The serializer object should implement the association name
@@ -83,8 +90,7 @@ def self.serializer_for(resource)
     def self.adapter
       adapter_class = case config.adapter
       when Symbol
-        class_name = "ActiveModel::Serializer::Adapter::#{config.adapter.to_s.classify}"
-        class_name.safe_constantize
+        ActiveModel::Serializer::Adapter.adapter_class(config.adapter)
       when Class
         config.adapter
       end

lib/active_model/serializer/adapter.rb

@@ -20,6 +20,16 @@ def serializable_hash(options = {})
       def as_json(options = {})
         serializable_hash(options)
       end
+
+      def self.create(resource, options = {})
+        override = options.delete(:adapter)
+        klass = override ? adapter_class(override) : ActiveModel::Serializer.adapter
+        klass.new(resource, options)
+      end
+
+      def self.adapter_class(adapter)
+        "ActiveModel::Serializer::Adapter::#{adapter.to_s.classify}".safe_constantize
+      end
     end
   end
 end

lib/active_model/serializer/adapter/json_api.rb

@@ -25,91 +25,129 @@ def serializable_hash(options = {})
           else
             @hash[@root] = attributes_for_serializer(serializer, @options)
 
-            serializer.each_association do |name, association, opts|
-              @hash[@root][:links] ||= {}
-
-              if association.respond_to?(:each)
-                add_links(name, association, opts)
-              else
-                add_link(name, association, opts)
-              end
-            end
+            add_resource_links(@hash[@root], serializer)
           end
 
           @hash
         end
 
-        def add_links(name, serializers, options)
-          if serializers.first
-            type = serializers.first.object.class.to_s.underscore.pluralize
-          end
+        private
+
+        def add_links(resource, name, serializers)
+          type = serialized_object_type(serializers)
+          resource[:links] ||= {}
+
           if name.to_s == type || !type
-            @hash[@root][:links][name] ||= []
-            @hash[@root][:links][name] += serializers.map{|serializer| serializer.id.to_s }
+            resource[:links][name] ||= []
+            resource[:links][name] += serializers.map{|serializer| serializer.id.to_s }
           else
-            @hash[@root][:links][name] ||= {}
-            @hash[@root][:links][name][:type] = type
-            @hash[@root][:links][name][:ids] ||= []
-            @hash[@root][:links][name][:ids] += serializers.map{|serializer| serializer.id.to_s }
-          end
-
-          unless serializers.none? || @options[:embed] == :ids
-            serializers.each do |serializer|
-              add_linked(name, serializer)
-            end
+            resource[:links][name] ||= {}
+            resource[:links][name][:type] = type
+            resource[:links][name][:ids] ||= []
+            resource[:links][name][:ids] += serializers.map{|serializer| serializer.id.to_s }
           end
         end
 
-        def add_link(name, serializer, options)
+        def add_link(resource, name, serializer)
+          resource[:links] ||= {}
+          resource[:links][name] = nil
+
           if serializer
-            type = serializer.object.class.to_s.underscore
+            type = serialized_object_type(serializer)
             if name.to_s == type || !type
-              @hash[@root][:links][name] = serializer.id.to_s
+              resource[:links][name] = serializer.id.to_s
             else
-              @hash[@root][:links][name] ||= {}
-              @hash[@root][:links][name][:type] = type
-              @hash[@root][:links][name][:id] = serializer.id.to_s
+              resource[:links][name] ||= {}
+              resource[:links][name][:type] = type
+              resource[:links][name][:id] = serializer.id.to_s
             end
-
-            unless @options[:embed] == :ids
-              add_linked(name, serializer)
-            end
-          else
-            @hash[@root][:links][name] = nil
           end
         end
 
-        def add_linked(resource, serializer, parent = nil)
-          resource_path = [parent, resource].compact.join('.')
-          if include_assoc? resource_path
-            plural_name = resource.to_s.pluralize.to_sym
-            attrs = attributes_for_serializer(serializer, @options)
+        def add_linked(resource_name, serializer, parent = nil)
+          resource_path = [parent, resource_name].compact.join('.')
+
+          if include_assoc?(resource_path)
+            plural_name = serialized_object_type(serializer).pluralize.to_sym
+            attrs = [attributes_for_serializer(serializer, @options)].flatten
             @top[:linked] ||= {}
             @top[:linked][plural_name] ||= []
-            @top[:linked][plural_name].push attrs unless @top[:linked][plural_name].include? attrs
-          end
 
-          unless serializer.respond_to?(:each)
-            serializer.each_association do |name, association, opts|
-              add_linked(name, association, resource) if association
+            attrs.each do |attrs|
+              add_resource_links(attrs, serializer, add_linked: false)
+
+              @top[:linked][plural_name].push(attrs) unless @top[:linked][plural_name].include?(attrs)
             end
           end
+
+          serializer.each_association do |name, association, opts|
+            add_linked(name, association, resource_path) if association
+          end if include_nested_assoc? resource_path
         end
 
-        private
 
         def attributes_for_serializer(serializer, options)
-          if fields = @fieldset && @fieldset.fields_for(serializer)
-            options[:fields] = fields
+          if serializer.respond_to?(:each)
+            result = []
+            serializer.each do |object|
+              options[:fields] = @fieldset && @fieldset.fields_for(serializer)
+              attributes = object.attributes(options)
+              attributes[:id] = attributes[:id].to_s if attributes[:id]
+              result << attributes
+            end
+          else
+            options[:fields] = @fieldset && @fieldset.fields_for(serializer)
+            result = serializer.attributes(options)
+            result[:id] = result[:id].to_s if result[:id]
+          end
+
+          result
+        end
+
+        def include_assoc?(assoc)
+          return false unless @options[:include]
+          check_assoc("#{assoc}$")
+        end
+
+        def include_nested_assoc?(assoc)
+          return false unless @options[:include]
+          check_assoc("#{assoc}.")
+        end
+
+        def check_assoc(assoc)
+          @options[:include].split(',').any? do |s|
+            s.match(/^#{assoc.gsub('.', '\.')}/)
           end
+        end
 
-          attributes = serializer.attributes(options)
-          attributes[:id] = attributes[:id].to_s if attributes[:id]
-          attributes
+        def serialized_object_type(serializer)
+          return false unless Array(serializer).first
+          type_name = Array(serializer).first.object.class.to_s.underscore
+          if serializer.respond_to?(:first)
+            type_name.pluralize
+          else
+            type_name
+          end
         end
 
-        def include_assoc? assoc
-          @options[:include] && @options[:include].split(',').include?(assoc.to_s)
+        def add_resource_links(attrs, serializer, options = {})
+          options[:add_linked] = options.fetch(:add_linked, true)
+
+          Array(serializer).first.each_association do |name, association, opts|
+            attrs[:links] ||= {}
+
+            if association.respond_to?(:each)
+              add_links(attrs, name, association)
+            else
+              add_link(attrs, name, association)
+            end
+
+            if @options[:embed] != :ids && options[:add_linked]
+              Array(association).each do |association|
+                add_linked(name, association)
+              end
+            end
+          end
         end
       end
     end

lib/active_model/serializer/array_serializer.rb

@@ -6,7 +6,10 @@ class ArraySerializer
 
       def initialize(objects, options = {})
         @objects = objects.map do |object|
-          serializer_class = ActiveModel::Serializer.serializer_for(object)
+          serializer_class = options.fetch(
+            :serializer,
+            ActiveModel::Serializer.serializer_for(object)
+          )
           serializer_class.new(object)
         end
       end

lib/active_model/serializer/fieldset.rb

@@ -2,11 +2,13 @@ module ActiveModel
   class Serializer
     class Fieldset
 
-      attr_reader :fields, :root
-
       def initialize(fields, root = nil)
-        @root   = root
-        @fields = parse(fields)
+        @root       = root
+        @raw_fields = fields
+      end
+
+      def fields
+        @fields ||= parsed_fields
       end
 
       def fields_for(serializer)
@@ -16,15 +18,17 @@ def fields_for(serializer)
 
     private
 
-      def parse(fields)
-        if fields.is_a?(Hash)
-          fields.inject({}) { |h,(k,v)| h[k.to_sym] = v.map(&:to_sym); h}
-        elsif fields.is_a?(Array)
+      attr_reader :raw_fields, :root
+
+      def parsed_fields
+        if raw_fields.is_a?(Hash)
+          raw_fields.inject({}) { |h,(k,v)| h[k.to_sym] = v.map(&:to_sym); h}
+        elsif raw_fields.is_a?(Array)
           if root.nil?
             raise ArgumentError, 'The root argument must be specified if the fileds argument is an array.'
           end
           hash = {}
-          hash[root.to_sym] = fields.map(&:to_sym)
+          hash[root.to_sym] = raw_fields.map(&:to_sym)
           hash
         else
           {}