active_model_serializers 0.9.12 → 0.10.15

data/lib/action_controller/serialization.rb

@@ -1,75 +1,29 @@
 # frozen_string_literal: true
 
 require 'active_support/core_ext/class/attribute'
+require 'active_model_serializers/serialization_context'
 
 module ActionController
-  # Action Controller Serialization
-  #
-  # Overrides render :json to check if the given object implements +active_model_serializer+
-  # as a method. If so, use the returned serializer instead of calling +to_json+ on the object.
-  #
-  # This module also provides a serialization_scope method that allows you to configure the
-  # +serialization_scope+ of the serializer. Most apps will likely set the +serialization_scope+
-  # to the current user:
-  #
-  #    class ApplicationController < ActionController::Base
-  #      serialization_scope :current_user
-  #    end
-  #
-  # If you need more complex scope rules, you can simply override the serialization_scope:
-  #
-  #    class ApplicationController < ActionController::Base
-  #      private
-  #
-  #      def serialization_scope
-  #        current_user
-  #      end
-  #    end
-  #
   module Serialization
     extend ActiveSupport::Concern
 
     include ActionController::Renderers
 
-    class << self
-      attr_accessor :enabled
-    end
-    self.enabled = true
-
-    included do
-      class_attribute :_serialization_scope
-      self._serialization_scope = :current_user
-    end
-
     module ClassMethods
       def serialization_scope(scope)
         self._serialization_scope = scope
       end
     end
 
-    def initialize(*)
-      super
-      @namespace_for_serializer = nil
-    end
-    ruby2_keywords :initialize if respond_to?(:ruby2_keywords, true)
-
-    [:_render_option_json, :_render_with_renderer_json].each do |renderer_method|
-      define_method renderer_method do |resource, options|
-        serializer = build_json_serializer(resource, options)
+    included do
+      class_attribute :_serialization_scope
+      self._serialization_scope = :current_user
 
-        if serializer
-          super(serializer, options)
-        else
-          super(resource, options)
-        end
-      end
+      attr_writer :namespace_for_serializer
     end
 
-    private
-
     def namespace_for_serializer
-      @namespace_for_serializer ||= namespace_for_class(self.class)
-      @namespace_for_serializer unless @namespace_for_serializer == Object
+      @namespace_for_serializer ||= namespace_for_class(self.class) unless namespace_for_class(self.class) == Object
     end
 
     def namespace_for_class(klass)
@@ -80,36 +34,42 @@ module ActionController
       end
     end
 
-    def default_serializer(resource)
-      options = {}.tap do |o|
-        o[:namespace] = namespace_for_serializer if namespace_for_serializer
-      end
+    def serialization_scope
+      return unless _serialization_scope && respond_to?(_serialization_scope, true)
 
-      ActiveModel::Serializer.serializer_for(resource, options)
+      send(_serialization_scope)
     end
 
-    def default_serializer_options
-      {}
-    end
+    def get_serializer(resource, options = {})
+      unless use_adapter?
+        warn 'ActionController::Serialization#use_adapter? has been removed. '\
+          "Please pass 'adapter: false' or see ActiveSupport::SerializableResource.new"
+        options[:adapter] = false
+      end
 
-    def serialization_scope
-      _serialization_scope = self.class._serialization_scope
-      send(_serialization_scope) if _serialization_scope && respond_to?(_serialization_scope, true)
-    end
+      options.fetch(:namespace) { options[:namespace] = namespace_for_serializer }
 
-    def build_json_serializer(resource, options = {})
-      options = default_serializer_options.merge(options)
-      @namespace_for_serializer = options.fetch(:namespace, nil)
+      serializable_resource = ActiveModelSerializers::SerializableResource.new(resource, options)
+      serializable_resource.serialization_scope ||= options.fetch(:scope) { serialization_scope }
+      serializable_resource.serialization_scope_name = options.fetch(:scope_name) { _serialization_scope }
+      # For compatibility with the JSON renderer: `json.to_json(options) if json.is_a?(String)`.
+      # Otherwise, since `serializable_resource` is not a string, the renderer would call
+      # `to_json` on a String and given odd results, such as `"".to_json #=> '""'`
+      serializable_resource.adapter.is_a?(String) ? serializable_resource.adapter : serializable_resource
+    end
 
-      if serializer = options.fetch(:serializer, default_serializer(resource))
-        options[:scope] = serialization_scope unless options.has_key?(:scope)
+    # Deprecated
+    def use_adapter?
+      true
+    end
 
-        if resource.respond_to?(:to_ary)
-          options[:resource_name] = controller_name 
-          options[:namespace] = namespace_for_serializer if namespace_for_serializer
+    [:_render_option_json, :_render_with_renderer_json].each do |renderer_method|
+      define_method renderer_method do |resource, options|
+        options.fetch(:serialization_context) do
+          options[:serialization_context] = ActiveModelSerializers::SerializationContext.new(request, options)
         end
-
-        serializer.new(resource, options)
+        serializable_resource = get_serializer(resource, options)
+        super(serializable_resource, options)
       end
     end
   end

data/lib/active_model/serializable_resource.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module ActiveModel
+  class SerializableResource
+    class << self
+      extend ActiveModelSerializers::Deprecate
+
+      delegate_and_deprecate :new, ActiveModelSerializers::SerializableResource
+    end
+  end
+end

data/lib/active_model/serializer/adapter/attributes.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  class Serializer
+    module Adapter
+      class Attributes < DelegateClass(ActiveModelSerializers::Adapter::Attributes)
+        def initialize(serializer, options = {})
+          super(ActiveModelSerializers::Adapter::Attributes.new(serializer, options))
+        end
+        class << self
+          extend ActiveModelSerializers::Deprecate
+          deprecate :new, 'ActiveModelSerializers::Adapter::Json.'
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/adapter/base.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  class Serializer
+    module Adapter
+      class Base < DelegateClass(ActiveModelSerializers::Adapter::Base)
+        class << self
+          extend ActiveModelSerializers::Deprecate
+          deprecate :inherited, 'ActiveModelSerializers::Adapter::Base.'
+        end
+
+        # :nocov:
+        def initialize(serializer, options = {})
+          super(ActiveModelSerializers::Adapter::Base.new(serializer, options))
+        end
+        # :nocov:
+      end
+    end
+  end
+end

data/lib/active_model/serializer/adapter/json.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  class Serializer
+    module Adapter
+      class Json < DelegateClass(ActiveModelSerializers::Adapter::Json)
+        def initialize(serializer, options = {})
+          super(ActiveModelSerializers::Adapter::Json.new(serializer, options))
+        end
+        class << self
+          extend ActiveModelSerializers::Deprecate
+          deprecate :new, 'ActiveModelSerializers::Adapter::Json.new'
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/adapter/json_api.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  class Serializer
+    module Adapter
+      class JsonApi < DelegateClass(ActiveModelSerializers::Adapter::JsonApi)
+        def initialize(serializer, options = {})
+          super(ActiveModelSerializers::Adapter::JsonApi.new(serializer, options))
+        end
+        class << self
+          extend ActiveModelSerializers::Deprecate
+          deprecate :new, 'ActiveModelSerializers::Adapter::JsonApi.new'
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/adapter/null.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  class Serializer
+    module Adapter
+      class Null < DelegateClass(ActiveModelSerializers::Adapter::Null)
+        def initialize(serializer, options = {})
+          super(ActiveModelSerializers::Adapter::Null.new(serializer, options))
+        end
+        class << self
+          extend ActiveModelSerializers::Deprecate
+          deprecate :new, 'ActiveModelSerializers::Adapter::Null.new'
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/adapter.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'active_model_serializers/adapter'
+require 'active_model_serializers/deprecate'
+
+module ActiveModel
+  class Serializer
+    # @deprecated Use ActiveModelSerializers::Adapter instead
+    module Adapter
+      class << self
+        extend ActiveModelSerializers::Deprecate
+
+        DEPRECATED_METHODS = [:create, :adapter_class, :adapter_map, :adapters, :register, :lookup].freeze
+        DEPRECATED_METHODS.each do |method|
+          delegate_and_deprecate method, ActiveModelSerializers::Adapter
+        end
+      end
+    end
+  end
+end
+
+require 'active_model/serializer/adapter/base'
+require 'active_model/serializer/adapter/null'
+require 'active_model/serializer/adapter/attributes'
+require 'active_model/serializer/adapter/json'
+require 'active_model/serializer/adapter/json_api'

data/lib/active_model/serializer/array_serializer.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'active_model/serializer/collection_serializer'
+
+module ActiveModel
+  class Serializer
+    class ArraySerializer < CollectionSerializer
+      class << self
+        extend ActiveModelSerializers::Deprecate
+        deprecate :new, 'ActiveModel::Serializer::CollectionSerializer.'
+      end
+    end
+  end
+end

data/lib/active_model/serializer/association.rb

@@ -1,58 +1,73 @@
 # frozen_string_literal: true
 
-require 'active_model/default_serializer'
-require 'active_model/serializer/association/has_one'
-require 'active_model/serializer/association/has_many'
+require 'active_model/serializer/lazy_association'
 
 module ActiveModel
   class Serializer
-    class Association
-      def initialize(name, options={})
-        if options.has_key?(:include)
-          ActiveSupport::Deprecation.warn("** Notice: include was renamed to embed_in_root. **")
-        end
+    # This class holds all information about serializer's association.
+    #
+    # @api private
+    Association = Struct.new(:reflection, :association_options) do
+      attr_reader :lazy_association
+      delegate :object, :include_data?, :virtual_value, :collection?, to: :lazy_association
+
+      def initialize(*)
+        super
+        @lazy_association = LazyAssociation.new(reflection, association_options)
+      end
 
-        @name          = name.to_s
-        @options       = options
-        self.embed     = options.fetch(:embed) { CONFIG.embed }
-        @polymorphic   = options.fetch(:polymorphic, false)
-        @embed_in_root = options.fetch(:embed_in_root) { options.fetch(:include) { CONFIG.embed_in_root } }
-        @key_format    = options.fetch(:key_format) { CONFIG.key_format }
-        @embed_key     = options[:embed_key] || :id
-        @key           = options[:key]
-        @embedded_key  = options[:root] || name
-        @embed_in_root_key = options.fetch(:embed_in_root_key) { CONFIG.embed_in_root_key }
-        @embed_namespace = options.fetch(:embed_namespace) { CONFIG.embed_namespace }
+      # @return [Symbol]
+      delegate :name, to: :reflection
 
-        serializer = @options[:serializer]
-        @serializer_from_options = serializer.is_a?(String) ? serializer.constantize : serializer
+      # @return [Symbol]
+      def key
+        reflection_options.fetch(:key, name)
       end
 
-      attr_reader :name, :embed_ids, :embed_objects, :polymorphic
-      attr_accessor :embed_in_root, :embed_key, :key, :embedded_key, :root_key, :serializer_from_options, :options, :key_format, :embed_in_root_key, :embed_namespace
-      alias embed_ids? embed_ids
-      alias embed_objects? embed_objects
-      alias embed_in_root? embed_in_root
-      alias embed_in_root_key? embed_in_root_key
-      alias embed_namespace? embed_namespace
-      alias polymorphic? polymorphic
+      # @return [True,False]
+      def key?
+        reflection_options.key?(:key)
+      end
+
+      # @return [Hash]
+      def links
+        reflection_options.fetch(:links) || {}
+      end
 
-      def embed=(embed)
-        @embed_ids     = embed == :id || embed == :ids
-        @embed_objects = embed == :object || embed == :objects
+      # @return [Hash, nil]
+      # This gets mutated, so cannot use the cached reflection_options
+      def meta
+        reflection.options[:meta]
       end
 
-      def serializer_from_object(object, options = {})
-        Serializer.serializer_for(object, options)
+      def belongs_to?
+        reflection.foreign_key_on == :self
       end
 
-      def default_serializer
-        DefaultSerializer
+      def polymorphic?
+        true == reflection_options[:polymorphic]
       end
 
-      def build_serializer(object, options = {})
-        serializer_class(object, options).new(object, options.merge(self.options))
+      # @api private
+      def serializable_hash(adapter_options, adapter_instance)
+        association_serializer = lazy_association.serializer
+        return virtual_value if virtual_value
+        association_object = association_serializer && association_serializer.object
+        return unless association_object
+
+        serialization = association_serializer.serializable_hash(adapter_options, {}, adapter_instance)
+
+        if polymorphic? && serialization
+          polymorphic_type = association_object.class.name.underscore
+          serialization = { type: polymorphic_type, polymorphic_type.to_sym => serialization }
+        end
+
+        serialization
       end
+
+      private
+
+      delegate :reflection_options, to: :lazy_association
     end
   end
 end

data/lib/active_model/serializer/attribute.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'active_model/serializer/field'
+
+module ActiveModel
+  class Serializer
+    # Holds all the meta-data about an attribute as it was specified in the
+    # ActiveModel::Serializer class.
+    #
+    # @example
+    #   class PostSerializer < ActiveModel::Serializer
+    #     attribute :content
+    #     attribute :name, key: :title
+    #     attribute :email, key: :author_email, if: :user_logged_in?
+    #     attribute :preview do
+    #       truncate(object.content)
+    #     end
+    #
+    #     def user_logged_in?
+    #       current_user.logged_in?
+    #     end
+    #   end
+    #
+    class Attribute < Field
+    end
+  end
+end

data/lib/active_model/serializer/belongs_to_reflection.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  class Serializer
+    # @api private
+    class BelongsToReflection < Reflection
+      # @api private
+      def foreign_key_on
+        :self
+      end
+    end
+  end
+end

data/lib/active_model/serializer/collection_serializer.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  class Serializer
+    class CollectionSerializer
+      include Enumerable
+      delegate :each, to: :@serializers
+
+      attr_reader :object, :root
+
+      def initialize(resources, options = {})
+        @object                  = resources
+        @options                 = options
+        @root                    = options[:root]
+        @serializers             = serializers_from_resources
+      end
+
+      def success?
+        true
+      end
+
+      # @api private
+      def serializable_hash(adapter_options, options, adapter_instance)
+        options[:include_directive] ||= ActiveModel::Serializer.include_directive_from_options(adapter_options)
+        options[:cached_attributes] ||= ActiveModel::Serializer.cache_read_multi(self, adapter_instance, options[:include_directive])
+        serializers.map do |serializer|
+          serializer.serializable_hash(adapter_options, options, adapter_instance)
+        end
+      end
+
+      # TODO: unify naming of root, json_key, and _type.  Right now, a serializer's
+      # json_key comes from the root option or the object's model name, by default.
+      # But, if a dev defines a custom `json_key` method with an explicit value,
+      # we have no simple way to know that it is safe to call that instance method.
+      # (which is really a class property at this point, anyhow).
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # Disabling cop since it's good to highlight the complexity of this method by
+      # including all the logic right here.
+      def json_key
+        return root if root
+        # 1. get from options[:serializer] for empty resource collection
+        key = object.empty? &&
+          (explicit_serializer_class = options[:serializer]) &&
+          explicit_serializer_class._type
+        # 2. get from first serializer instance in collection
+        key ||= (serializer = serializers.first) && serializer.json_key
+        # 3. get from collection name, if a named collection
+        key ||= object.respond_to?(:name) ? object.name && object.name.underscore : nil
+        # 4. key may be nil for empty collection and no serializer option
+        key &&= key.pluralize
+        if raise_cannot_infer_root_key_error?
+          # 5. fail if the key cannot be determined
+          key || fail(CannotInferRootKeyError, 'Cannot infer root key from collection type. Please specify the root or each_serializer option, or render a JSON String')
+        end
+        key
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      def paginated?
+        ActiveModelSerializers.config.jsonapi_pagination_links_enabled &&
+          object.respond_to?(:current_page) &&
+          object.respond_to?(:total_pages) &&
+          object.respond_to?(:size)
+      end
+
+      class CannotInferRootKeyError < StandardError; end
+
+      protected
+
+      attr_reader :serializers, :options
+
+      private
+
+      def raise_cannot_infer_root_key_error?
+        ActiveModelSerializers.config.raise_cannot_infer_root_key_error
+      end
+
+      def serializers_from_resources
+        serializer_context_class = options.fetch(:serializer_context_class, ActiveModel::Serializer)
+        object.map do |resource|
+          serializer_from_resource(resource, serializer_context_class, options)
+        end
+      end
+
+      def serializer_from_resource(resource, serializer_context_class, options)
+        serializer_class = options.fetch(:serializer) do
+          serializer_context_class.serializer_for(resource, namespace: options[:namespace])
+        end
+
+        if serializer_class.nil?
+          ActiveModelSerializers.logger.debug "No serializer found for resource: #{resource.inspect}"
+          throw :no_serializer
+        else
+          serializer_class.new(resource, options.except(:serializer))
+        end
+      end
+    end
+  end
+end