active_model_serializers 0.10.0 → 0.10.3

data/lib/active_model/serializer/lint.rb

@@ -1,146 +1,150 @@
-module ActiveModel::Serializer::Lint
-  # == Active \Model \Serializer \Lint \Tests
-  #
-  # You can test whether an object is compliant with the Active \Model \Serializers
-  # API by including <tt>ActiveModel::Serializer::Lint::Tests</tt> in your TestCase.
-  # It will include tests that tell you whether your object is fully compliant,
-  # or if not, which aspects of the API are not implemented.
-  #
-  # Note an object is not required to implement all APIs in order to work
-  # with Active \Model \Serializers. This module only intends to provide guidance in case
-  # you want all features out of the box.
-  #
-  # These tests do not attempt to determine the semantic correctness of the
-  # returned values. For instance, you could implement <tt>serializable_hash</tt> to
-  # always return +{}+, and the tests would pass. It is up to you to ensure
-  # that the values are semantically meaningful.
-  module Tests
-    # Passes if the object responds to <tt>serializable_hash</tt> and if it takes
-    # zero or one arguments.
-    # Fails otherwise.
-    #
-    # <tt>serializable_hash</tt> returns a hash representation of a object's attributes.
-    # Typically, it is implemented by including ActiveModel::Serialization.
-    def test_serializable_hash
-      assert_respond_to resource, :serializable_hash, 'The resource should respond to serializable_hash'
-      resource.serializable_hash
-      resource.serializable_hash(nil)
-    end
+module ActiveModel
+  class Serializer
+    module Lint
+      # == Active \Model \Serializer \Lint \Tests
+      #
+      # You can test whether an object is compliant with the Active \Model \Serializers
+      # API by including <tt>ActiveModel::Serializer::Lint::Tests</tt> in your TestCase.
+      # It will include tests that tell you whether your object is fully compliant,
+      # or if not, which aspects of the API are not implemented.
+      #
+      # Note an object is not required to implement all APIs in order to work
+      # with Active \Model \Serializers. This module only intends to provide guidance in case
+      # you want all features out of the box.
+      #
+      # These tests do not attempt to determine the semantic correctness of the
+      # returned values. For instance, you could implement <tt>serializable_hash</tt> to
+      # always return +{}+, and the tests would pass. It is up to you to ensure
+      # that the values are semantically meaningful.
+      module Tests
+        # Passes if the object responds to <tt>serializable_hash</tt> and if it takes
+        # zero or one arguments.
+        # Fails otherwise.
+        #
+        # <tt>serializable_hash</tt> returns a hash representation of a object's attributes.
+        # Typically, it is implemented by including ActiveModel::Serialization.
+        def test_serializable_hash
+          assert_respond_to resource, :serializable_hash, 'The resource should respond to serializable_hash'
+          resource.serializable_hash
+          resource.serializable_hash(nil)
+        end
 
-    # Passes if the object responds to <tt>read_attribute_for_serialization</tt>
-    # and if it requires one argument (the attribute to be read).
-    # Fails otherwise.
-    #
-    # <tt>read_attribute_for_serialization</tt> gets the attribute value for serialization
-    # Typically, it is implemented by including ActiveModel::Serialization.
-    def test_read_attribute_for_serialization
-      assert_respond_to resource, :read_attribute_for_serialization, 'The resource should respond to read_attribute_for_serialization'
-      actual_arity = resource.method(:read_attribute_for_serialization).arity
-      # using absolute value since arity is:
-      #  1 for def read_attribute_for_serialization(name); end
-      # -1 for alias :read_attribute_for_serialization :send
-      assert_equal 1, actual_arity.abs, "expected #{actual_arity.inspect}.abs to be 1 or -1"
-    end
+        # Passes if the object responds to <tt>read_attribute_for_serialization</tt>
+        # and if it requires one argument (the attribute to be read).
+        # Fails otherwise.
+        #
+        # <tt>read_attribute_for_serialization</tt> gets the attribute value for serialization
+        # Typically, it is implemented by including ActiveModel::Serialization.
+        def test_read_attribute_for_serialization
+          assert_respond_to resource, :read_attribute_for_serialization, 'The resource should respond to read_attribute_for_serialization'
+          actual_arity = resource.method(:read_attribute_for_serialization).arity
+          # using absolute value since arity is:
+          #  1 for def read_attribute_for_serialization(name); end
+          # -1 for alias :read_attribute_for_serialization :send
+          assert_equal 1, actual_arity.abs, "expected #{actual_arity.inspect}.abs to be 1 or -1"
+        end
 
-    # Passes if the object responds to <tt>as_json</tt> and if it takes
-    # zero or one arguments.
-    # Fails otherwise.
-    #
-    # <tt>as_json</tt> returns a hash representation of a serialized object.
-    # It may delegate to <tt>serializable_hash</tt>
-    # Typically, it is implemented either by including ActiveModel::Serialization
-    # which includes ActiveModel::Serializers::JSON.
-    # or by the JSON gem when required.
-    def test_as_json
-      assert_respond_to resource, :as_json
-      resource.as_json
-      resource.as_json(nil)
-    end
+        # Passes if the object responds to <tt>as_json</tt> and if it takes
+        # zero or one arguments.
+        # Fails otherwise.
+        #
+        # <tt>as_json</tt> returns a hash representation of a serialized object.
+        # It may delegate to <tt>serializable_hash</tt>
+        # Typically, it is implemented either by including ActiveModel::Serialization
+        # which includes ActiveModel::Serializers::JSON.
+        # or by the JSON gem when required.
+        def test_as_json
+          assert_respond_to resource, :as_json
+          resource.as_json
+          resource.as_json(nil)
+        end
 
-    # Passes if the object responds to <tt>to_json</tt> and if it takes
-    # zero or one arguments.
-    # Fails otherwise.
-    #
-    # <tt>to_json</tt> returns a string representation (JSON) of a serialized object.
-    # It may be called on the result of <tt>as_json</tt>.
-    # Typically, it is implemented on all objects when the JSON gem is required.
-    def test_to_json
-      assert_respond_to resource, :to_json
-      resource.to_json
-      resource.to_json(nil)
-    end
+        # Passes if the object responds to <tt>to_json</tt> and if it takes
+        # zero or one arguments.
+        # Fails otherwise.
+        #
+        # <tt>to_json</tt> returns a string representation (JSON) of a serialized object.
+        # It may be called on the result of <tt>as_json</tt>.
+        # Typically, it is implemented on all objects when the JSON gem is required.
+        def test_to_json
+          assert_respond_to resource, :to_json
+          resource.to_json
+          resource.to_json(nil)
+        end
 
-    # Passes if the object responds to <tt>cache_key</tt>
-    # Fails otherwise.
-    #
-    # <tt>cache_key</tt> returns a (self-expiring) unique key for the object,
-    # and is part of the (self-expiring) cache_key, which is used by the
-    # adapter. It is not required unless caching is enabled.
-    def test_cache_key
-      assert_respond_to resource, :cache_key
-      actual_arity = resource.method(:cache_key).arity
-      assert_includes [-1, 0], actual_arity, "expected #{actual_arity.inspect} to be 0 or -1"
-    end
+        # Passes if the object responds to <tt>cache_key</tt>
+        # Fails otherwise.
+        #
+        # <tt>cache_key</tt> returns a (self-expiring) unique key for the object,
+        # and is part of the (self-expiring) cache_key, which is used by the
+        # adapter. It is not required unless caching is enabled.
+        def test_cache_key
+          assert_respond_to resource, :cache_key
+          actual_arity = resource.method(:cache_key).arity
+          assert_includes [-1, 0], actual_arity, "expected #{actual_arity.inspect} to be 0 or -1"
+        end
 
-    # Passes if the object responds to <tt>updated_at</tt> and if it takes no
-    # arguments.
-    # Fails otherwise.
-    #
-    # <tt>updated_at</tt> returns a Time object or iso8601 string and
-    # is part of the (self-expiring) cache_key, which is used by the adapter.
-    # It is not required unless caching is enabled.
-    def test_updated_at
-      assert_respond_to resource, :updated_at
-      actual_arity = resource.method(:updated_at).arity
-      assert_equal 0, actual_arity
-    end
+        # Passes if the object responds to <tt>updated_at</tt> and if it takes no
+        # arguments.
+        # Fails otherwise.
+        #
+        # <tt>updated_at</tt> returns a Time object or iso8601 string and
+        # is part of the (self-expiring) cache_key, which is used by the adapter.
+        # It is not required unless caching is enabled.
+        def test_updated_at
+          assert_respond_to resource, :updated_at
+          actual_arity = resource.method(:updated_at).arity
+          assert_equal 0, actual_arity
+        end
 
-    # Passes if the object responds to <tt>id</tt> and if it takes no
-    # arguments.
-    # Fails otherwise.
-    #
-    # <tt>id</tt> returns a unique identifier for the object.
-    # It is not required unless caching is enabled.
-    def test_id
-      assert_respond_to resource, :id
-      assert_equal 0, resource.method(:id).arity
-    end
+        # Passes if the object responds to <tt>id</tt> and if it takes no
+        # arguments.
+        # Fails otherwise.
+        #
+        # <tt>id</tt> returns a unique identifier for the object.
+        # It is not required unless caching is enabled.
+        def test_id
+          assert_respond_to resource, :id
+          assert_equal 0, resource.method(:id).arity
+        end
 
-    # Passes if the object's class responds to <tt>model_name</tt> and if it
-    # is in an instance of +ActiveModel::Name+.
-    # Fails otherwise.
-    #
-    # <tt>model_name</tt> returns an ActiveModel::Name instance.
-    # It is used by the serializer to identify the object's type.
-    # It is not required unless caching is enabled.
-    def test_model_name
-      resource_class = resource.class
-      assert_respond_to resource_class, :model_name
-      assert_instance_of resource_class.model_name, ActiveModel::Name
-    end
+        # Passes if the object's class responds to <tt>model_name</tt> and if it
+        # is in an instance of +ActiveModel::Name+.
+        # Fails otherwise.
+        #
+        # <tt>model_name</tt> returns an ActiveModel::Name instance.
+        # It is used by the serializer to identify the object's type.
+        # It is not required unless caching is enabled.
+        def test_model_name
+          resource_class = resource.class
+          assert_respond_to resource_class, :model_name
+          assert_instance_of resource_class.model_name, ActiveModel::Name
+        end
 
-    def test_active_model_errors
-      assert_respond_to resource, :errors
-    end
+        def test_active_model_errors
+          assert_respond_to resource, :errors
+        end
 
-    def test_active_model_errors_human_attribute_name
-      assert_respond_to resource.class, :human_attribute_name
-      assert_equal(-2, resource.class.method(:human_attribute_name).arity)
-    end
+        def test_active_model_errors_human_attribute_name
+          assert_respond_to resource.class, :human_attribute_name
+          assert_equal(-2, resource.class.method(:human_attribute_name).arity)
+        end
 
-    def test_active_model_errors_lookup_ancestors
-      assert_respond_to resource.class, :lookup_ancestors
-      assert_equal 0, resource.class.method(:lookup_ancestors).arity
-    end
+        def test_active_model_errors_lookup_ancestors
+          assert_respond_to resource.class, :lookup_ancestors
+          assert_equal 0, resource.class.method(:lookup_ancestors).arity
+        end
 
-    private
+        private
 
-    def resource
-      @resource or fail "'@resource' must be set as the linted object"
-    end
+        def resource
+          @resource or fail "'@resource' must be set as the linted object"
+        end
 
-    def assert_instance_of(result, name)
-      assert result.instance_of?(name), "#{result} should be an instance of #{name}"
+        def assert_instance_of(result, name)
+          assert result.instance_of?(name), "#{result} should be an instance of #{name}"
+        end
+      end
     end
   end
 end

data/lib/active_model/serializer/reflection.rb

@@ -37,7 +37,7 @@ module ActiveModel
       def initialize(*)
         super
         @_links = {}
-        @_include_data = true
+        @_include_data = Serializer.config.include_data_default
         @_meta = nil
       end
 
@@ -69,17 +69,15 @@ module ActiveModel
       #       Blog.find(object.blog_id)
       #     end
       #   end
-      def value(serializer)
+      def value(serializer, include_slice)
         @object = serializer.object
         @scope = serializer.scope
 
-        if block
-          block_value = instance_exec(serializer, &block)
-          if block_value == :nil
-            serializer.read_attribute_for_serialization(name)
-          else
-            block_value
-          end
+        block_value = instance_exec(serializer, &block) if block
+        return unless include_data?(include_slice)
+
+        if block && block_value != :nil
+          block_value
         else
           serializer.read_attribute_for_serialization(name)
         end
@@ -88,7 +86,7 @@ module ActiveModel
       # Build association. This method is used internally to
       # build serializer's association by its reflection.
       #
-      # @param [Serializer] subject is a parent serializer for given association
+      # @param [Serializer] parent_serializer for given association
       # @param [Hash{Symbol => Object}] parent_serializer_options
       #
       # @example
@@ -106,26 +104,36 @@ module ActiveModel
       #
       # @api private
       #
-      def build_association(subject, parent_serializer_options)
-        association_value = value(subject)
+      def build_association(parent_serializer, parent_serializer_options, include_slice = {})
         reflection_options = options.dup
-        serializer_class = subject.class.serializer_for(association_value, reflection_options)
-        reflection_options[:include_data] = @_include_data
+
+        # Pass the parent's namespace onto the child serializer
+        reflection_options[:namespace] ||= parent_serializer_options[:namespace]
+
+        association_value = value(parent_serializer, include_slice)
+        serializer_class = parent_serializer.class.serializer_for(association_value, reflection_options)
+        reflection_options[:include_data] = include_data?(include_slice)
+        reflection_options[:links] = @_links
+        reflection_options[:meta] = @_meta
 
         if serializer_class
-          begin
-            serializer = serializer_class.new(
+          serializer = catch(:no_serializer) do
+            serializer_class.new(
               association_value,
-              serializer_options(subject, parent_serializer_options, reflection_options)
+              serializer_options(parent_serializer, parent_serializer_options, reflection_options)
             )
-          rescue ActiveModel::Serializer::CollectionSerializer::NoSerializerError
+          end
+          if serializer.nil?
             reflection_options[:virtual_value] = association_value.try(:as_json) || association_value
+          else
+            reflection_options[:serializer] = serializer
           end
         elsif !association_value.nil? && !association_value.instance_of?(Object)
           reflection_options[:virtual_value] = association_value
         end
 
-        Association.new(name, serializer, reflection_options, @_links, @_meta)
+        block = nil
+        Association.new(name, reflection_options, block)
       end
 
       protected
@@ -134,12 +142,20 @@ module ActiveModel
 
       private
 
-      def serializer_options(subject, parent_serializer_options, reflection_options)
+      def include_data?(include_slice)
+        if @_include_data == :if_sideloaded
+          include_slice.key?(name)
+        else
+          @_include_data
+        end
+      end
+
+      def serializer_options(parent_serializer, 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[:serializer_context_class] = subject.class
+        serializer_options[:serializer_context_class] = parent_serializer.class
         serializer_options
       end
     end

data/lib/active_model/serializer/version.rb

@@ -1,5 +1,5 @@
 module ActiveModel
   class Serializer
-    VERSION = '0.10.0'.freeze
+    VERSION = '0.10.3'.freeze
   end
 end

data/lib/active_model/serializer.rb

@@ -1,18 +1,18 @@
 require 'thread_safe'
+require 'jsonapi/include_directive'
 require 'active_model/serializer/collection_serializer'
 require 'active_model/serializer/array_serializer'
 require 'active_model/serializer/error_serializer'
 require 'active_model/serializer/errors_serializer'
-require 'active_model/serializer/include_tree'
-require 'active_model/serializer/associations'
-require 'active_model/serializer/attributes'
-require 'active_model/serializer/caching'
-require 'active_model/serializer/configuration'
+require 'active_model/serializer/concerns/associations'
+require 'active_model/serializer/concerns/attributes'
+require 'active_model/serializer/concerns/caching'
+require 'active_model/serializer/concerns/configuration'
+require 'active_model/serializer/concerns/links'
+require 'active_model/serializer/concerns/meta'
+require 'active_model/serializer/concerns/type'
 require 'active_model/serializer/fieldset'
 require 'active_model/serializer/lint'
-require 'active_model/serializer/links'
-require 'active_model/serializer/meta'
-require 'active_model/serializer/type'
 
 # ActiveModel::Serializer is an abstract class that is
 # reified when subclassed to decorate a resource.
@@ -44,7 +44,7 @@ module ActiveModel
       elsif resource.respond_to?(:to_ary)
         config.collection_serializer
       else
-        options.fetch(:serializer) { get_serializer_for(resource.class) }
+        options.fetch(:serializer) { get_serializer_for(resource.class, options[:namespace]) }
       end
     end
 
@@ -59,17 +59,11 @@ module ActiveModel
     end
 
     # @api private
-    def self.serializer_lookup_chain_for(klass)
-      chain = []
-
-      resource_class_name = klass.name.demodulize
-      resource_namespace = klass.name.deconstantize
-      serializer_class_name = "#{resource_class_name}Serializer"
-
-      chain.push("#{name}::#{serializer_class_name}") if self != ActiveModel::Serializer
-      chain.push("#{resource_namespace}::#{serializer_class_name}")
-
-      chain
+    def self.serializer_lookup_chain_for(klass, namespace = nil)
+      lookups = ActiveModelSerializers.config.serializer_lookup_chain
+      Array[*lookups].flat_map do |lookup|
+        lookup.call(klass, self, namespace)
+      end.compact
     end
 
     # Used to cache serializer name => serializer class
@@ -84,11 +78,14 @@ module ActiveModel
     #   1. class name appended with "Serializer"
     #   2. try again with superclass, if present
     #   3. nil
-    def self.get_serializer_for(klass)
+    def self.get_serializer_for(klass, namespace = nil)
       return nil unless config.serializer_lookup_enabled
-      serializers_cache.fetch_or_store(klass) do
+
+      cache_key = ActiveSupport::Cache.expand_cache_key(klass, namespace)
+      serializers_cache.fetch_or_store(cache_key) do
         # NOTE(beauby): When we drop 1.9.3 support we can lazify the map for perfs.
-        serializer_class = serializer_lookup_chain_for(klass).map(&:safe_constantize).find { |x| x && x < ActiveModel::Serializer }
+        lookup_chain = serializer_lookup_chain_for(klass, namespace)
+        serializer_class = lookup_chain.map(&:safe_constantize).find { |x| x && x < ActiveModel::Serializer }
 
         if serializer_class
           serializer_class
@@ -98,6 +95,22 @@ module ActiveModel
       end
     end
 
+    # @api private
+    def self.include_directive_from_options(options)
+      if options[:include_directive]
+        options[:include_directive]
+      elsif options[:include]
+        JSONAPI::IncludeDirective.new(options[:include], allow_wildcard: true)
+      else
+        ActiveModelSerializers.default_include_directive
+      end
+    end
+
+    # @api private
+    def self.serialization_adapter_instance
+      @serialization_adapter_instance ||= ActiveModelSerializers::Adapter::Attributes
+    end
+
     attr_accessor :object, :root, :scope
 
     # `scope_name` is set as :current_user by default in the controller.
@@ -109,10 +122,9 @@ module ActiveModel
       self.root = instance_options[:root]
       self.scope = instance_options[:scope]
 
-      scope_name = instance_options[:scope_name]
-      if scope_name && !respond_to?(scope_name)
-        define_singleton_method scope_name, lambda { scope }
-      end
+      return if !(scope_name = instance_options[:scope_name]) || respond_to?(scope_name)
+
+      define_singleton_method scope_name, -> { scope }
     end
 
     def success?
@@ -123,9 +135,7 @@ module ActiveModel
     # associations, similar to how ActiveModel::Serializers::JSON is used
     # in ActiveRecord::Base.
     #
-    # TODO: Move to here the Attributes adapter logic for
-    # +serializable_hash_for_single_resource(options)+
-    # and include <tt>ActiveModel::Serializers::JSON</tt>.
+    # TODO: Include <tt>ActiveModel::Serializers::JSON</tt>.
     # So that the below is true:
     #   @param options [nil, Hash] The same valid options passed to `serializable_hash`
     #      (:only, :except, :methods, and :include).
@@ -149,11 +159,13 @@ module ActiveModel
     #     serializer.as_json(include: :posts)
     #     # Second level and higher order associations work as well:
     #     serializer.as_json(include: { posts: { include: { comments: { only: :body } }, only: :title } })
-    def serializable_hash(adapter_opts = nil)
-      adapter_opts ||= {}
-      adapter_opts = { include: '*', adapter: :attributes }.merge!(adapter_opts)
-      adapter = ActiveModelSerializers::Adapter.create(self, adapter_opts)
-      adapter.serializable_hash(adapter_opts)
+    def serializable_hash(adapter_options = nil, options = {}, adapter_instance = self.class.serialization_adapter_instance)
+      adapter_options ||= {}
+      options[:include_directive] ||= ActiveModel::Serializer.include_directive_from_options(adapter_options)
+      cached_attributes = adapter_options[:cached_attributes] ||= {}
+      resource = fetch_attributes(options[:fields], cached_attributes, adapter_instance)
+      relationships = resource_relationships(adapter_options, options, adapter_instance)
+      resource.merge(relationships)
     end
     alias to_hash serializable_hash
     alias to_h serializable_hash
@@ -178,13 +190,40 @@ module ActiveModel
     def read_attribute_for_serialization(attr)
       if respond_to?(attr)
         send(attr)
-      elsif self.class._fragmented
-        self.class._fragmented.read_attribute_for_serialization(attr)
       else
         object.read_attribute_for_serialization(attr)
       end
     end
 
+    # @api private
+    def resource_relationships(adapter_options, options, adapter_instance)
+      relationships = {}
+      include_directive = options.fetch(:include_directive)
+      associations(include_directive).each do |association|
+        adapter_opts = adapter_options.merge(include_directive: include_directive[association.key])
+        relationships[association.key] ||= relationship_value_for(association, adapter_opts, adapter_instance)
+      end
+
+      relationships
+    end
+
+    # @api private
+    def relationship_value_for(association, adapter_options, adapter_instance)
+      return association.options[:virtual_value] if association.options[:virtual_value]
+      association_serializer = association.serializer
+      association_object = association_serializer && association_serializer.object
+      return unless association_object
+
+      relationship_value = association_serializer.serializable_hash(adapter_options, {}, adapter_instance)
+
+      if association.options[:polymorphic] && relationship_value
+        polymorphic_type = association_object.class.name.underscore
+        relationship_value = { type: polymorphic_type, polymorphic_type.to_sym => relationship_value }
+      end
+
+      relationship_value
+    end
+
     protected
 
     attr_accessor :instance_options