Namespaced serializer lookup for associations

CHANGELOG.md

@@ -16,7 +16,9 @@ Features:
 - [#1172](https://github.com/rails-api/active_model_serializers/pull/1172) Better serializer registration, get more than just the first module (@bf4)
 - [#1158](https://github.com/rails-api/active_model_serializers/pull/1158) Add support for wildcards in `include` option (@beauby)
 - [#1127](https://github.com/rails-api/active_model_serializers/pull/1127) Add support for nested
-    associations for JSON and Attributes adapters via the `include` option (@NullVoxPopuli, @beauby).
+    associations for JSON and Attributes adapters via the `include` option (@NullVoxPopuli, @beauby)
+- [#1193](https://github.com/rails-api/active_model_serializers/pull/1193) Add support for inline nested serializers (@beauby)
+- [#1196](https://github.com/rails-api/active_model_serializers/pull/1196) Add support for namespaced serializers (@beauby)
 
 Fixes:
 

lib/action_controller/serialization.rb

@@ -25,7 +25,8 @@ def get_serializer(resource, options = {})
           "Please pass 'adapter: false' or see ActiveSupport::SerializableResource.new"
         options[:adapter] = false
       end
-      serializable_resource = ActiveModel::SerializableResource.new(resource, options)
+      serializable_options = options.merge(controller: self)
+      serializable_resource = ActiveModel::SerializableResource.new(resource, serializable_options)
       if serializable_resource.serializer?
         serializable_resource.serialization_scope ||= serialization_scope
         serializable_resource.serialization_scope_name = _serialization_scope

lib/active_model/serializer.rb

@@ -84,8 +84,10 @@ def self.serializer_for(resource, options = {})
         resource.serializer_class
       elsif resource.respond_to?(:to_ary)
         config.array_serializer
+      elsif options.key?(:serializer)
+        options[:serializer]
       else
-        options.fetch(:serializer) { get_serializer_for(resource.class) }
+        get_serializer_for(resource.class, options[:parent_serializer], options[:controller])
       end
     end
 
@@ -108,20 +110,50 @@ def self.digest_caller_file(caller_line)
       Digest::MD5.hexdigest(serializer_file_contents)
     end
 
-    def self.get_serializer_for(klass)
+    # Compute the lookup chain for a given serializer class, parent serializer and controller
+    # @param [String] serializer_class_name The class name to lookup
+    # @param [ActiveModel::Serializer] parent_serializer The instance of the parent serializer, if any
+    # @param [ActionController] controller The instance of the calling controller, if any
+    #
+    # @return [Array<String>] The lookup chain
+    #
+    def self.serializer_lookup_chain_for(serializer_class_name, parent_serializer, controller)
+      chain = []
+
+      # Look for a serializer nested inside the current serializer first, if inside a user-defined serializer
+      chain.push("#{self}::#{serializer_class_name}") if self.class != ActiveModel::Serializer
+
+      # Look for a serializer inside the controller namespace
+      chain.push("#{controller.class.name.deconstantize}::#{serializer_class_name}") if controller
+
+      # Look for a serializer inside the root namespace (i.e. that of the first serializer of the chain)
+      if parent_serializer
+        chain.push("#{parent_serializer.root_serializer.class.name.deconstantize}::#{serializer_class_name}")
+      elsif self.class != ActiveModel::Serializer # The first serializer of the chain does not have a parent
+        chain.push("#{name.deconstantize}::#{serializer_class_name}")
+      end
+
+      # Finally, look for the serializer in the global namespace
+      chain.push(serializer_class_name)
+
+      chain
+    end
+
+    def self.get_serializer_for(klass, parent_serializer, controller)
       serializers_cache.fetch_or_store(klass) do
         serializer_class_name = "#{klass.name}Serializer"
-        serializer_class = serializer_class_name.safe_constantize
+        serializer_class = serializer_lookup_chain_for(serializer_class_name, parent_serializer, controller).lazy
+                           .map(&:safe_constantize).find { |x| x }
 
         if serializer_class
           serializer_class
         elsif klass.superclass
-          get_serializer_for(klass.superclass)
+          get_serializer_for(klass.superclass, parent_serializer, controller)
         end
       end
     end
 
-    attr_accessor :object, :root, :meta, :meta_key, :scope
+    attr_accessor :object, :root, :meta, :meta_key, :scope, :parent_serializer, :root_serializer
 
     def initialize(object, options = {})
       self.object = object
@@ -130,12 +162,13 @@ def initialize(object, options = {})
       self.meta = instance_options[:meta]
       self.meta_key = instance_options[:meta_key]
       self.scope = instance_options[:scope]
+      self.parent_serializer = instance_options[:parent_serializer]
+      self.root_serializer = (parent_serializer && parent_serializer.root_serializer) || self
 
       scope_name = instance_options[:scope_name]
-      if scope_name && !respond_to?(scope_name)
-        self.class.class_eval do
-          define_method scope_name, lambda { scope }
-        end
+      return unless scope_name && !respond_to?(scope_name)
+      self.class.class_eval do
+        define_method scope_name, -> { scope }
       end
     end
 
@@ -152,10 +185,10 @@ def attributes(options = {})
         end
 
       attributes.each_with_object({}) do |name, hash|
-        unless self.class._fragmented
-          hash[name] = send(name)
-        else
+        if self.class._fragmented
           hash[name] = self.class._fragmented.public_send(name)
+        else
+          hash[name] = send(name)
         end
       end
     end

lib/active_model/serializer/array_serializer.rb

@@ -5,20 +5,23 @@ class ArraySerializer
       include Enumerable
       delegate :each, to: :@serializers
 
-      attr_reader :object, :root, :meta, :meta_key
+      attr_reader :object, :root, :meta, :meta_key, :parent_serializer, :root_serializer
 
       def initialize(resources, options = {})
         @root = options[:root]
         @object = resources
+        @parent_serializer = options[:parent_serializer]
+        @root_serializer = @parent_serializer.try(:root_serializer)
+        lookup_serializer = (@parent_serializer && @parent_serializer.class) || ActiveModel::Serializer
         @serializers = resources.map do |resource|
-          serializer_class = options.fetch(:serializer) do
-            ActiveModel::Serializer.serializer_for(resource)
-          end
+          serializer_class = options.fetch(:serializer) { lookup_serializer.serializer_for(resource) }
 
           if serializer_class.nil?
             fail NoSerializerError, "No serializer found for resource: #{resource.inspect}"
           else
-            serializer_class.new(resource, options.except(:serializer))
+            serializer_options = options.except(:serializer)
+            serializer_options.merge!(parent_serializer: @parent_serializer) if @parent_serializer
+            serializer_class.new(resource, serializer_options)
           end
         end
         @meta     = options[:meta]

lib/active_model/serializer/associations.rb

@@ -1,3 +1,4 @@
+# 2420012eliyel - popincool - 22 cite popincourt - 4e premiere droite
 module ActiveModel
   class Serializer
     # Defines an association in the object should be rendered.
@@ -29,7 +30,7 @@ class << base
 
       module ClassMethods
         def inherited(base)
-          base._reflections = self._reflections.try(:dup) || []
+          base._reflections = _reflections.try(:dup) || []
         end
 
         # @param [Symbol] name of the association
@@ -39,8 +40,8 @@ def inherited(base)
         # @example
         #  has_many :comments, serializer: CommentSummarySerializer
         #
-        def has_many(name, options = {})
-          associate HasManyReflection.new(name, options)
+        def has_many(name, options = {}, &block)
+          associate(HasManyReflection.new(name, options), &block)
         end
 
         # @param [Symbol] name of the association
@@ -50,8 +51,8 @@ def has_many(name, options = {})
         # @example
         #  belongs_to :author, serializer: AuthorSerializer
         #
-        def belongs_to(name, options = {})
-          associate BelongsToReflection.new(name, options)
+        def belongs_to(name, options = {}, &block)
+          associate(BelongsToReflection.new(name, options), &block)
         end
 
         # @param [Symbol] name of the association
@@ -61,26 +62,41 @@ def belongs_to(name, options = {})
         # @example
         #  has_one :author, serializer: AuthorSerializer
         #
-        def has_one(name, options = {})
-          associate HasOneReflection.new(name, options)
+        def has_one(name, options = {}, &block)
+          associate(HasOneReflection.new(name, options), &block)
         end
 
         private
 
-        # Add reflection and define {name} accessor.
+        # Add reflection and define {name} accessor and nested serializer.
         # @param [ActiveModel::Serializer::Reflection] reflection
         # @return [void]
         #
         # @api private
         #
-        def associate(reflection)
+        def associate(reflection, &block)
           self._reflections = _reflections.dup
 
           define_method reflection.name do
             object.send reflection.name
           end unless method_defined?(reflection.name)
 
-          self._reflections << reflection
+          _reflections << reflection
+
+          define_nested_serializer(reflection.name.to_s.singularize, &block) if block_given?
+        end
+
+        # Define a nested serializer
+        # @param [String] resource_name The name of the association
+        # @return [void]
+        #
+        # @api private
+        #
+        def define_nested_serializer(resource_name, &block)
+          serializer_name = "#{resource_name.camelize}Serializer"
+          serializer = Class.new(ActiveModel::Serializer)
+          serializer.class_eval(&block)
+          const_set(serializer_name, serializer)
         end
       end
 

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.merge(parent_serializer: subject))
 
         if serializer_class
           begin
             serializer = serializer_class.new(
               association_value,
-              serializer_options(parent_serializer_options, reflection_options)
+              serializer_options(subject, parent_serializer_options, reflection_options)
             )
           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(subject, parent_serializer_options, reflection_options)
         serializer = reflection_options.fetch(:serializer, nil)
 
         serializer_options = parent_serializer_options.except(:serializer)
         serializer_options[:serializer] = serializer if serializer
+        serializer_options[:parent_serializer] = subject
         serializer_options
       end
     end

test/adapter/json/nested_serializers_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    module Adapter
+      class Json
+        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).serializable_hash
+            expected = { tweet: { id: 1, body: 'Tweet 1', date: 'Jan 15', author: { id: 1 }, shares: [{ id: 1, platform: 'facebook' }] } }
+            assert_equal(expected, actual)
+          end
+        end
+      end
+    end
+  end
+end

test/fixtures/poro.rb

@@ -85,6 +85,8 @@ def cache_key
     "#{self.class.name.downcase}/#{self.id}"
   end
 end
+Tweet = Class.new(Model)
+Share = Class.new(Model)
 
 module Spam; end
 Spam::UnrelatedLink = Class.new(Model)
@@ -258,4 +260,30 @@ def maker
   cache only: [:id]
   attributes :id
 end
+
+class TweetSerializer < ActiveModel::Serializer
+  attributes :id, :body, :date
+
+  belongs_to :author do
+    attributes :id
+  end
+
+  has_many :shares do
+    attributes :id, :platform
+
+    belongs_to :author do
+      attributes :id, :name
+    end
+  end
+end
+
+class ShareSerializer < ActiveModel::Serializer
+  attributes :id, :platform, :date
+
+  belongs_to :author do
+    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,11 @@ def test_serializer_custom_serializer
           serializer = ActiveModel::Serializer.serializer_for(@custom_profile)
           assert_equal ProfileSerializer, serializer
         end
+
+        def test_serializer_for_nested_resource
+          serializer = TweetSerializer.serializer_for(@share1)
+          assert_equal(TweetSerializer::ShareSerializer, serializer)
+        end
       end
     end
   end