Namespaced serializers

Adds support for finding serializers based on the "current" serializers
namespace to support things like serializer versioning. Without this you
have to be explicit in naming which serializer to use in all of your
serializer associations. That's OK usually (albeit annoying) but it
breaks polymorphism since you can't really specify the right serializer
ahead of time.

I came across a bunch of PRs such as #1225 that talk about different
versions of namespacing based on modules or controllers or whatever and
some of them even talk about supporting serializer namespaces but I have
been unable to find one that actually does this part of it. If there is
already work being done for this, feel free to ignore this PR but we
needed this for our current work.

This PR builds on top of the work done by @beauby in #1225 to add
support for namespaced serializer lookups. @beauby's work only allowed
for actual nesting of serializers withing a namespaced serializer (e.g.
for overrides) but did not actually walk up the tree to siblings or
serializers farther up the inheritance/namespace tree.

It simply modifies `Serializer#serializer_lookup_chain_for` to add all
of the possible levels of namespaces based on the current serializer.
With this patch for example if we have:
```ruby
class Public::V1::PostSerializer
  belongs_to :author
end

class Public::V1::AuthorSerializer
end
```
we will wind up with the following items in the lookup chain for an
author when serializing a Post with Public::V1::PostSerializer:
```ruby
['Public::V1::PostSerializer::AuthorSerializer',
'Public::V1::AuthorSerializer', 'Public::AuthorSerializer',
'::AuthorSerializer']
```

Author: bdmac

lib/active_model/serializer.rb

@@ -195,7 +195,10 @@ def self.serializer_lookup_chain_for(klass)
       resource_namespace = klass.name.deconstantize
       serializer_class_name = "#{resource_class_name}Serializer"
 
-      chain.push("#{name}::#{serializer_class_name}") if self != ActiveModel::Serializer
+      if self != ActiveModel::Serializer
+        chain.push("#{name}::#{serializer_class_name}")
+        chain.push(*name.deconstantize.split('::').each_with_object([]) { |element, array| array.push((array.last ? array.last + '::' : '') + element) }.reverse.map { |k| k + "::#{serializer_class_name}" })
+      end
       chain.push("#{resource_namespace}::#{serializer_class_name}")
 
       chain

test/serializers/associations_test.rb

@@ -207,6 +207,49 @@ def test_associations_namespaced_resources
           end
         end
       end
+
+      class NamespaceNestedSerializersTest < Minitest::Test
+        Post    = Class.new(::Model)
+        Comment = Class.new(::Model)
+        Author  = Class.new(::Model)
+        Description = Class.new(::Model)
+
+        module SerializerNamespace
+          class PostSerializer < ActiveModel::Serializer
+            has_many :comments
+            belongs_to :author
+            has_one :description
+          end
+          CommentSerializer     = Class.new(ActiveModel::Serializer)
+          AuthorSerializer      = Class.new(ActiveModel::Serializer)
+          DescriptionSerializer = Class.new(ActiveModel::Serializer)
+        end
+
+        def setup
+          @comment = Comment.new
+          @author = Author.new
+          @description = Description.new
+          @post = Post.new(comments: [@comment],
+                           author: @author,
+                           description: @description)
+          @post_serializer = SerializerNamespace::PostSerializer.new(@post)
+        end
+
+        def test_associations_namespaced_resources_new
+          @post_serializer.associations.each do |association|
+            case association.key
+            when :comments
+              assert_instance_of(SerializerNamespace::CommentSerializer, association.serializer.first)
+            when :author
+              assert_instance_of(SerializerNamespace::AuthorSerializer, association.serializer)
+            when :description
+              assert_instance_of(SerializerNamespace::DescriptionSerializer, association.serializer)
+            else
+              flunk "Unknown association: #{key}"
+            end
+          end
+        end
+      end
     end
   end
 end

test/serializers/serializer_for_test.rb

@@ -30,11 +30,15 @@ class SerializerTest < Minitest::Test
         module ResourceNamespace
           Post    = Class.new(::Model)
           Comment = Class.new(::Model)
+          Author  = Class.new(::Model)
 
           class PostSerializer < ActiveModel::Serializer
             class CommentSerializer < ActiveModel::Serializer
             end
           end
+
+          class AuthorSerializer < ActiveModel::Serializer
+          end
         end
 
         class MyProfile < Profile
@@ -91,6 +95,12 @@ def test_serializer_for_nested_resource
           serializer = ResourceNamespace::PostSerializer.serializer_for(comment)
           assert_equal(ResourceNamespace::PostSerializer::CommentSerializer, serializer)
         end
+
+        def test_serializer_for_namespace_nested_resource
+          author = ResourceNamespace::Author.new
+          serializer = ResourceNamespace::PostSerializer.serializer_for(author)
+          assert_equal(ResourceNamespace::AuthorSerializer, serializer)
+        end
       end
     end
   end