Add support for nested serializers.

lib/active_model/serializer.rb

@@ -6,6 +6,7 @@
 require 'active_model/serializer/configuration'
 require 'active_model/serializer/fieldset'
 require 'active_model/serializer/lint'
+require 'active_model/serializer/utils'
 
 module ActiveModel
   class Serializer
@@ -79,6 +80,10 @@ def self.cache(options = {})
       self._cache_options = (options.empty?) ? nil : options
     end
 
+    def self.nested_lookup_paths
+      @_nested_lookup_paths ||= Utils.nested_lookup_paths(self)
+    end
+
     def self.serializer_for(resource, options = {})
       if resource.respond_to?(:serializer_class)
         resource.serializer_class
@@ -111,7 +116,7 @@ def self.digest_caller_file(caller_line)
     def self.get_serializer_for(klass)
       serializers_cache.fetch_or_store(klass) do
         serializer_class_name = "#{klass.name}Serializer"
-        serializer_class = serializer_class_name.safe_constantize
+        serializer_class = Utils.nested_lookup(nested_lookup_paths, serializer_class_name)
 
         if serializer_class
           serializer_class

lib/active_model/serializer/array_serializer.rb

@@ -10,10 +10,9 @@ class ArraySerializer
       def initialize(resources, options = {})
         @root = options[:root]
         @object = resources
+        @parent_serializer = options[:_parent] || ActiveModel::Serializer
         @serializers = resources.map do |resource|
-          serializer_class = options.fetch(:serializer) do
-            ActiveModel::Serializer.serializer_for(resource)
-          end
+          serializer_class = options.fetch(:serializer) { @parent_serializer.serializer_for(resource) }
 
           if serializer_class.nil?
             fail NoSerializerError, "No serializer found for resource: #{resource.inspect}"

lib/active_model/serializer/reflection.rb

@@ -42,13 +42,13 @@ class Serializer
       def build_association(subject, parent_serializer_options)
         association_value = subject.send(name)
         reflection_options = options.dup
-        serializer_class = ActiveModel::Serializer.serializer_for(association_value, reflection_options)
+        serializer_class = subject.class.serializer_for(association_value, reflection_options)
 
         if serializer_class
           begin
             serializer = serializer_class.new(
               association_value,
-              serializer_options(parent_serializer_options, reflection_options)
+              serializer_options(parent_serializer_options, reflection_options, subject)
             )
           rescue ActiveModel::Serializer::ArraySerializer::NoSerializerError
             reflection_options[:virtual_value] = association_value.try(:as_json) || association_value
@@ -62,11 +62,12 @@ def build_association(subject, parent_serializer_options)
 
       private
 
-      def serializer_options(parent_serializer_options, reflection_options)
+      def serializer_options(parent_serializer_options, reflection_options, subject)
         serializer = reflection_options.fetch(:serializer, nil)
 
         serializer_options = parent_serializer_options.except(:serializer)
         serializer_options[:serializer] = serializer if serializer
+        serializer_options[:_parent] = subject.class
         serializer_options
       end
     end

lib/active_model/serializer/utils.rb

@@ -0,0 +1,31 @@
+module ActiveModel::Serializer::Utils
+  module_function
+
+  # Gives the existing lookup paths that are suffixes of the fully qualified path of `klass`.
+  # @param [Object] klass
+  # @return [Array<Symbol>]
+  def nested_lookup_paths(klass)
+    paths = klass.to_s.split('::').reverse.reduce([]) { |a, e| a + [[e] + Array(a.last)] }.reverse
+    paths.map! { |path| "#{path.join('::')}" }
+    paths.map! do |path|
+      begin
+        path.constantize
+      rescue NameError
+        nil
+      end
+    end
+    paths.delete(nil)
+    paths.push(Object)
+
+    paths
+  end
+
+  # Gives the class named `class_name` if it exists (directly) inside one of the lookup `paths`.
+  # @param [Array<Symbol>] paths
+  # @param [Symbol, String] class_name
+  # @return [Object, nil]
+  def nested_lookup(paths, class_name)
+    class_path = paths.find { |path| path.const_defined?(class_name, false) }
+    class_path.const_get(class_name) if class_path
+  end
+end

test/adapter/json_api/nested_serializers_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    module Adapter
+      class JsonApi
+        class NestedSerializersTest < Minitest::Test
+          def setup
+            @tweet = Tweet.new(id: 1, body: 'Tweet 1', date: 'Jan 15')
+            @share1 = Share.new(id: 1, platform: 'facebook', date: 'Jan 16')
+            @author = Author.new(id: 1, name: 'Lucas H.')
+            @tweet.author = @author
+            @tweet.shares = [@share1]
+            @share1.author = @author
+            @author.posts = []
+            @author.roles = []
+            @author.bio = nil
+          end
+
+          def test_nested_serializers
+            actual = ActiveModel::SerializableResource.new(@tweet, adapter: :json_api).serializable_hash
+            expected = {
+              data: {
+                id: '1', type: 'tweets', attributes: { body: 'Tweet 1', date: 'Jan 15' },
+                relationships: { author: { data: { id: '1', type: 'authors' } },
+                                 shares: { data: [{ id: '1', type: 'shares' }] } }
+              }
+            }
+            assert_equal(expected, actual)
+          end
+        end
+      end
+    end
+  end
+end

test/fixtures/poro.rb

@@ -79,6 +79,8 @@ class ProfilePreviewSerializer < ActiveModel::Serializer
 Place    = Class.new(Model)
 Tag      = Class.new(Model)
 VirtualValue = Class.new(Model)
+Tweet    = Class.new(Model)
+Share    = Class.new(Model)
 Comment = Class.new(Model) do
   # Uses a custom non-time-based cache key
   def cache_key
@@ -258,4 +260,34 @@ def maker
   cache only: [:id]
   attributes :id
 end
+
+class TweetSerializer < ActiveModel::Serializer
+  attributes :id, :body, :date
+
+  belongs_to :author
+  class AuthorSerializer < ActiveModel::Serializer
+    attributes :id
+  end
+
+  has_many :shares
+  class ShareSerializer < ActiveModel::Serializer
+    attributes :id, :platform
+
+    belongs_to :author
+    class AuthorSerializer < ActiveModel::Serializer
+      attributes :id, :name
+    end
+  end
+end
+
+class ShareSerializer < ActiveModel::Serializer
+  attributes :id, :platform, :date
+
+  belongs_to :author
+  class AuthorSerializer < ActiveModel::Serializer
+    attributes :id, :name, :email
+  end
+  belongs_to :post
+end
+
 $VERBOSE = verbose

test/serializers/serializer_for_test.rb

@@ -38,6 +38,8 @@ def setup
           @my_profile = MyProfile.new
           @custom_profile = CustomProfile.new
           @model = ::Model.new
+          @tweet = Tweet.new
+          @share1 = Share.new
         end
 
         def test_serializer_for_existing_serializer
@@ -59,6 +61,16 @@ def test_serializer_custom_serializer
           serializer = ActiveModel::Serializer.serializer_for(@custom_profile)
           assert_equal ProfileSerializer, serializer
         end
+
+        def test_serializer_nested_serializer
+          serializer = TweetSerializer.serializer_for(@share1)
+          assert_equal(TweetSerializer::ShareSerializer, serializer)
+        end
+
+        def test_serializer_non_nested_serializer
+          serializer = ActiveModel::Serializer.serializer_for(@share1)
+          assert_equal(ShareSerializer, serializer)
+        end
       end
     end
   end

test/utils/nested_lookup_paths_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    module Utils
+      class NestedLookupPathsTest < Minitest::Test
+        def test_activemodel_serializer
+          expected = [::ActiveModel::Serializer, ::Object]
+          actual = Utils.nested_lookup_paths(ActiveModel::Serializer)
+          assert_equal(expected, actual)
+        end
+
+        def test_nested_classes
+          expected = [::TweetSerializer::ShareSerializer::AuthorSerializer,
+                      ::ShareSerializer::AuthorSerializer,
+                      ::AuthorSerializer,
+                      ::Object]
+          actual = Utils.nested_lookup_paths(TweetSerializer::ShareSerializer::AuthorSerializer)
+          assert_equal(expected, actual)
+        end
+      end
+    end
+  end
+end

test/utils/nested_lookup_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    module Utils
+      class NestedLookupTest < Minitest::Test
+        def test_existing
+          paths = [::TweetSerializer, ::Object]
+          expected = ::TweetSerializer::ShareSerializer
+          actual = Utils.nested_lookup(paths, 'ShareSerializer')
+          assert_equal(expected, actual)
+        end
+
+        def test_non_existing
+          paths = [::Object]
+          actual = Utils.nested_lookup(paths, 'NonExistingSerializer')
+          assert_nil(actual)
+        end
+      end
+    end
+  end
+end