active_model_serializers 0.10.0 → 0.10.9

data/lib/active_model/serializer/lint.rb

@@ -1,146 +1,152 @@
-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
+# frozen_string_literal: true
 
-    # 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
+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>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>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>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>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>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>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>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>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>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>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'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 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
 
-    def test_active_model_errors
-      assert_respond_to resource, :errors
-    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_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
+          assert_respond_to resource, :errors
+        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_human_attribute_name
+          assert_respond_to resource.class, :human_attribute_name
+          assert_equal(-2, resource.class.method(:human_attribute_name).arity)
+        end
 
-    private
+        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 resource
-      @resource or fail "'@resource' must be set as the linted object"
-    end
+        private
+
+        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/null.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveModel
   class Serializer
     class Null < Serializer

data/lib/active_model/serializer/reflection.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'active_model/serializer/field'
+require 'active_model/serializer/association'
 
 module ActiveModel
   class Serializer
@@ -8,12 +11,26 @@ module ActiveModel
     # @example
     #   class PostSerializer < ActiveModel::Serializer
     #     has_one :author, serializer: AuthorSerializer
+    #     belongs_to :boss, type: :users, foreign_key: :boss_id
     #     has_many :comments
     #     has_many :comments, key: :last_comments do
     #       object.comments.last(1)
     #     end
     #     has_many :secret_meta_data, if: :is_admin?
     #
+    #     has_one :blog do |serializer|
+    #       meta count: object.roles.count
+    #       serializer.cached_blog
+    #     end
+    #
+    #     private
+    #
+    #     def cached_blog
+    #       cache_store.fetch("cached_blog:#{object.updated_at}") do
+    #         Blog.find(object.blog_id)
+    #       end
+    #     end
+    #
     #     def is_admin?
     #       current_user.admin?
     #     end
@@ -23,72 +40,144 @@ module ActiveModel
     #  1) as 'comments' and named 'comments'.
     #  2) as 'object.comments.last(1)' and named 'last_comments'.
     #
-    #  PostSerializer._reflections #=>
-    #    # [
-    #    #   HasOneReflection.new(:author, serializer: AuthorSerializer),
-    #    #   HasManyReflection.new(:comments)
-    #    #   HasManyReflection.new(:comments, { key: :last_comments }, #<Block>)
-    #    #   HasManyReflection.new(:secret_meta_data, { if: :is_admin? })
-    #    # ]
+    #  PostSerializer._reflections # =>
+    #    # {
+    #    #   author: HasOneReflection.new(:author, serializer: AuthorSerializer),
+    #    #   comments: HasManyReflection.new(:comments)
+    #    #   last_comments: HasManyReflection.new(:comments, { key: :last_comments }, #<Block>)
+    #    #   secret_meta_data: HasManyReflection.new(:secret_meta_data, { if: :is_admin? })
+    #    # }
     #
     # So you can inspect reflections in your Adapters.
-    #
     class Reflection < Field
+      attr_reader :foreign_key, :type
+
       def initialize(*)
         super
-        @_links = {}
-        @_include_data = true
-        @_meta = nil
+        options[:links] = {}
+        options[:include_data_setting] = Serializer.config.include_data_default
+        options[:meta] = nil
+        @type = options.fetch(:type) do
+          class_name = options.fetch(:class_name, name.to_s.camelize.singularize)
+          class_name.underscore.pluralize.to_sym
+        end
+        @foreign_key = options.fetch(:foreign_key) do
+          if collection?
+            "#{name.to_s.singularize}_ids".to_sym
+          else
+            "#{name}_id".to_sym
+          end
+        end
       end
 
-      def link(name, value = nil, &block)
-        @_links[name] = block || value
+      # @api public
+      # @example
+      #   has_one :blog do
+      #     include_data false
+      #     link :self, 'a link'
+      #     link :related, 'another link'
+      #     link :self, '//example.com/link_author/relationships/bio'
+      #     id = object.profile.id
+      #     link :related do
+      #       "//example.com/profiles/#{id}" if id != 123
+      #     end
+      #     link :related do
+      #       ids = object.likes.map(&:id).join(',')
+      #       href "//example.com/likes/#{ids}"
+      #       meta ids: ids
+      #     end
+      #   end
+      def link(name, value = nil)
+        options[:links][name] = block_given? ? Proc.new : value
         :nil
       end
 
-      def meta(value = nil, &block)
-        @_meta = block || value
+      # @api public
+      # @example
+      #   has_one :blog do
+      #     include_data false
+      #     meta(id: object.blog.id)
+      #     meta liked: object.likes.any?
+      #     link :self do
+      #       href object.blog.id.to_s
+      #       meta(id: object.blog.id)
+      #     end
+      def meta(value = nil)
+        options[:meta] = block_given? ? Proc.new : value
         :nil
       end
 
+      # @api public
+      # @example
+      #   has_one :blog do
+      #     include_data false
+      #     link :self, 'a link'
+      #     link :related, 'another link'
+      #   end
+      #
+      #   has_one :blog do
+      #     include_data false
+      #     link :self, 'a link'
+      #     link :related, 'another link'
+      #   end
+      #
+      #    belongs_to :reviewer do
+      #      meta name: 'Dan Brown'
+      #      include_data true
+      #    end
+      #
+      #    has_many :tags, serializer: TagSerializer do
+      #      link :self, '//example.com/link_author/relationships/tags'
+      #      include_data :if_sideloaded
+      #    end
       def include_data(value = true)
-        @_include_data = value
+        options[:include_data_setting] = value
         :nil
       end
 
+      def collection?
+        false
+      end
+
+      def include_data?(include_slice)
+        include_data_setting = options[:include_data_setting]
+        case include_data_setting
+        when :if_sideloaded then include_slice.key?(options.fetch(:key, name))
+        when true           then true
+        when false          then false
+        else fail ArgumentError, "Unknown include_data_setting '#{include_data_setting.inspect}'"
+        end
+      end
+
       # @param serializer [ActiveModel::Serializer]
       # @yield [ActiveModel::Serializer]
       # @return [:nil, associated resource or resource collection]
-      # @example
-      #   has_one :blog do |serializer|
-      #     serializer.cached_blog
-      #   end
-      #
-      #   def cached_blog
-      #     cache_store.fetch("cached_blog:#{object.updated_at}") do
-      #       Blog.find(object.blog_id)
-      #     end
-      #   end
-      def value(serializer)
+      def value(serializer, include_slice)
+        # NOTE(BF): This method isn't thread-safe because the _reflections class attribute is not thread-safe
+        # Therefore, when we build associations from reflections, we dup the entire reflection instance.
+        # Better solutions much appreciated!
         @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
       end
 
+      # @api private
+      def foreign_key_on
+        :related
+      end
+
       # 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
@@ -105,43 +194,19 @@ module ActiveModel
       #    comments_reflection.build_association(post_serializer, foo: 'bar')
       #
       # @api private
-      #
-      def build_association(subject, parent_serializer_options)
-        association_value = value(subject)
-        reflection_options = options.dup
-        serializer_class = subject.class.serializer_for(association_value, reflection_options)
-        reflection_options[:include_data] = @_include_data
-
-        if serializer_class
-          begin
-            serializer = serializer_class.new(
-              association_value,
-              serializer_options(subject, parent_serializer_options, reflection_options)
-            )
-          rescue ActiveModel::Serializer::CollectionSerializer::NoSerializerError
-            reflection_options[:virtual_value] = association_value.try(:as_json) || association_value
-          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)
+      def build_association(parent_serializer, parent_serializer_options, include_slice = {})
+        association_options = {
+          parent_serializer: parent_serializer,
+          parent_serializer_options: parent_serializer_options,
+          include_slice: include_slice
+        }
+        Association.new(self, association_options)
       end
 
       protected
 
+      # used in instance exec
       attr_accessor :object, :scope
-
-      private
-
-      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[:serializer_context_class] = subject.class
-        serializer_options
-      end
     end
   end
 end

data/lib/active_model/serializer/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module ActiveModel
   class Serializer
-    VERSION = '0.10.0'.freeze
+    VERSION = '0.10.9'.freeze
   end
 end