active_model_serializers 0.8.3 → 0.10.0.rc5

data/lib/action_controller/serialization.rb

@@ -1,32 +1,18 @@
+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
 
+    module ClassMethods
+      def serialization_scope(scope)
+        self._serialization_scope = scope
+      end
+    end
+
     included do
       class_attribute :_serialization_scope
       self._serialization_scope = :current_user
@@ -37,24 +23,33 @@ module ActionController
         respond_to?(_serialization_scope, true)
     end
 
-    def default_serializer_options
+    def get_serializer(resource, options = {})
+      if !use_adapter?
+        warn 'ActionController::Serialization#use_adapter? has been removed. '\
+          "Please pass 'adapter: false' or see ActiveSupport::SerializableResource.new"
+        options[:adapter] = false
+      end
+      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
+
+    # Deprecated
+    def use_adapter?
+      true
     end
 
     [:_render_option_json, :_render_with_renderer_json].each do |renderer_method|
       define_method renderer_method do |resource, options|
-        json = ActiveModel::Serializer.build_json(self, resource, options)
-
-        if json
-          super(json, options)
-        else
-          super(resource, options)
+        options.fetch(:serialization_context) do
+          options[:serialization_context] = ActiveModelSerializers::SerializationContext.new(request, options)
         end
-      end
-    end
-
-    module ClassMethods
-      def serialization_scope(scope)
-        self._serialization_scope = scope
+        serializable_resource = get_serializer(resource, options)
+        super(serializable_resource, options)
       end
     end
   end

data/lib/active_model/serializable_resource.rb

@@ -0,0 +1,11 @@
+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,15 @@
+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,16 @@
+module ActiveModel
+  class Serializer
+    module Adapter
+      class Base < DelegateClass(ActiveModelSerializers::Adapter::Base)
+        class << self
+          extend ActiveModelSerializers::Deprecate
+          deprecate :inherited, 'ActiveModelSerializers::Adapter::Base.'
+        end
+
+        def initialize(serializer, options = {})
+          super(ActiveModelSerializers::Adapter::Base.new(serializer, options))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+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,15 @@
+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,15 @@
+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,24 @@
+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,9 @@
+require 'active_model/serializer/collection_serializer'
+class ActiveModel::Serializer
+  class ArraySerializer < CollectionSerializer
+    class << self
+      extend ActiveModelSerializers::Deprecate
+      deprecate :new, 'ActiveModel::Serializer::CollectionSerializer.'
+    end
+  end
+end

data/lib/active_model/serializer/association.rb

@@ -0,0 +1,19 @@
+module ActiveModel
+  class Serializer
+    # This class hold all information about serializer's association.
+    #
+    # @attr [Symbol] name
+    # @attr [ActiveModel::Serializer] serializer
+    # @attr [Hash{Symbol => Object}] options
+    #
+    # @example
+    #  Association.new(:comments, CommentSummarySerializer)
+    #
+    Association = Struct.new(:name, :serializer, :options, :links, :meta) do
+      # @return [Symbol]
+      def key
+        options.fetch(:key, name)
+      end
+    end
+  end
+end

data/lib/active_model/serializer/associations.rb

@@ -1,230 +1,97 @@
 module ActiveModel
   class Serializer
-    module Associations #:nodoc:
-      class Config #:nodoc:
-        class_attribute :options
-
-        def self.refine(name, class_options)
-          current_class = self
-
-          Class.new(self) do
-            singleton_class.class_eval do
-              define_method(:to_s) do
-                "(subclass of #{current_class.name})"
-              end
-
-              alias inspect to_s
-            end
-
-            self.options = class_options
-
-            # cache the root so we can reuse it without falling back on a per-instance basis
-            begin
-              self.options[:root] ||= self.new(name, nil).root
-            rescue
-              # this could fail if it needs a valid source, for example a polymorphic association
-            end
-
-          end
-        end
-
-        self.options = {}
-
-        def initialize(name, source, options={})
-          @name = name
-          @source = source
-          @options = options
-        end
-
-        def option(key, default=nil)
-          if @options.key?(key)
-            @options[key]
-          elsif self.class.options.key?(key)
-            self.class.options[key]
-          else
-            default
-          end
-        end
-
-        def target_serializer
-          serializer = option(:serializer)
-          serializer.is_a?(String) ? serializer.constantize : serializer
-        end
-
-        def source_serializer
-          @source
-        end
-
-        def key
-          option(:key) || @name
-        end
-
-        def root
-          option(:root) || @name
-        end
-
-        def name
-          option(:name) || @name
-        end
-
-        def associated_object
-          option(:value) || source_serializer.send(name)
-        end
-
-        def embed_ids?
-          [:id, :ids].include? option(:embed, source_serializer._embed)
-        end
-
-        def embed_objects?
-          [:object, :objects].include? option(:embed, source_serializer._embed)
-        end
-
-        def embed_in_root?
-          option(:include, source_serializer._root_embed)
-        end
-
-        def embeddable?
-          !associated_object.nil?
-        end
-
-      protected
-
-        def find_serializable(object)
-          if target_serializer
-            target_serializer.new(object, source_serializer.options)
-          elsif object.respond_to?(:active_model_serializer) && (ams = object.active_model_serializer)
-            ams.new(object, source_serializer.options)
-          else
-            object
-          end
-        end
+    # Defines an association in the object should be rendered.
+    #
+    # The serializer object should implement the association name
+    # as a method which should return an array when invoked. If a method
+    # with the association name does not exist, the association name is
+    # dispatched to the serialized object.
+    #
+    module Associations
+      extend ActiveSupport::Concern
+
+      DEFAULT_INCLUDE_TREE = ActiveModel::Serializer::IncludeTree.from_string('*')
+
+      included do
+        with_options instance_writer: false, instance_reader: true do |serializer|
+          serializer.class_attribute :_reflections
+          self._reflections ||= []
+        end
+
+        extend ActiveSupport::Autoload
+        autoload :Association
+        autoload :Reflection
+        autoload :SingularReflection
+        autoload :CollectionReflection
+        autoload :BelongsToReflection
+        autoload :HasOneReflection
+        autoload :HasManyReflection
       end
 
-      class HasMany < Config #:nodoc:
-        def key
-          if key = option(:key)
-            key
-          elsif embed_ids?
-            "#{@name.to_s.singularize}_ids".to_sym
-          else
-            @name
-          end
-        end
-
-        def embed_key
-          if key = option(:embed_key)
-            key
-          else
-            :id
-          end
-        end
-
-        def serialize
-          associated_object.map do |item|
-            find_serializable(item).serializable_hash
-          end
-        end
-
-        def serializables
-          associated_object.map do |item|
-            find_serializable(item)
-          end
-        end
-
-        def serialize_ids
-          ids_key = "#{@name.to_s.singularize}_ids".to_sym
-          if !option(:embed_key) && !source_serializer.respond_to?(@name.to_s) && source_serializer.object.respond_to?(ids_key)
-            source_serializer.object.read_attribute_for_serialization(ids_key)
-          else
-            associated_object.map do |item|
-              item.read_attribute_for_serialization(embed_key)
-            end
-          end
+      module ClassMethods
+        def inherited(base)
+          super
+          base._reflections = _reflections.dup
+        end
+
+        # @param [Symbol] name of the association
+        # @param [Hash<Symbol => any>] options for the reflection
+        # @return [void]
+        #
+        # @example
+        #  has_many :comments, serializer: CommentSummarySerializer
+        #
+        def has_many(name, options = {}, &block)
+          associate(HasManyReflection.new(name, options, block))
+        end
+
+        # @param [Symbol] name of the association
+        # @param [Hash<Symbol => any>] options for the reflection
+        # @return [void]
+        #
+        # @example
+        #  belongs_to :author, serializer: AuthorSerializer
+        #
+        def belongs_to(name, options = {}, &block)
+          associate(BelongsToReflection.new(name, options, block))
+        end
+
+        # @param [Symbol] name of the association
+        # @param [Hash<Symbol => any>] options for the reflection
+        # @return [void]
+        #
+        # @example
+        #  has_one :author, serializer: AuthorSerializer
+        #
+        def has_one(name, options = {}, &block)
+          associate(HasOneReflection.new(name, options, block))
+        end
+
+        private
+
+        # Add reflection and define {name} accessor.
+        # @param [ActiveModel::Serializer::Reflection] reflection
+        # @return [void]
+        #
+        # @api private
+        #
+        def associate(reflection)
+          self._reflections << reflection
         end
       end
 
-      class HasOne < Config #:nodoc:
-        def embeddable?
-          if polymorphic? && associated_object.nil?
-            false
-          else
-            true
-          end
-        end
-
-        def polymorphic?
-          option :polymorphic
-        end
-
-        def root
-          if root = option(:root)
-            root
-          elsif polymorphic?
-            associated_object.class.to_s.pluralize.demodulize.underscore.to_sym
-          else
-            @name.to_s.pluralize.to_sym
-          end
-        end
-
-        def key
-          if key = option(:key)
-            key
-          elsif embed_ids? && !polymorphic?
-            "#{@name}_id".to_sym
-          else
-            @name
-          end
-        end
-
-        def embed_key
-          if key = option(:embed_key)
-            key
-          else
-            :id
-          end
-        end
-
-        def polymorphic_key
-          associated_object.class.to_s.demodulize.underscore.to_sym
-        end
-
-        def serialize
-          object = associated_object
-
-          if object && polymorphic?
-            {
-              :type => polymorphic_key,
-              polymorphic_key => find_serializable(object).serializable_hash
-            }
-          elsif object
-            find_serializable(object).serializable_hash
-          end
-        end
-
-        def serializables
-          object = associated_object
-          value = object && find_serializable(object)
-          value ? [value] : []
-        end
-
-        def serialize_ids
-          id_key = "#{@name}_id".to_sym
-
-          if polymorphic?
-            if associated_object
-              {
-                :type => polymorphic_key,
-                :id => associated_object.read_attribute_for_serialization(embed_key)
-              }
-            else
-              nil
-            end
-          elsif !option(:embed_key) && !source_serializer.respond_to?(@name.to_s) && source_serializer.object.respond_to?(id_key)
-            source_serializer.object.read_attribute_for_serialization(id_key)
-          elsif associated_object
-            associated_object.read_attribute_for_serialization(embed_key)
-          else
-            nil
+      # @param [IncludeTree] include_tree (defaults to all associations when not provided)
+      # @return [Enumerator<Association>]
+      #
+      def associations(include_tree = DEFAULT_INCLUDE_TREE)
+        return unless object
+
+        Enumerator.new do |y|
+          self.class._reflections.each do |reflection|
+            next if reflection.excluded?(self)
+            key = reflection.options.fetch(:key, reflection.name)
+            next unless include_tree.key?(key)
+            y.yield reflection.build_association(self, instance_options)
           end
         end
       end

data/lib/active_model/serializer/attribute.rb

@@ -0,0 +1,25 @@
+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/attributes.rb

@@ -0,0 +1,82 @@
+module ActiveModel
+  class Serializer
+    module Attributes
+      extend ActiveSupport::Concern
+
+      included do
+        with_options instance_writer: false, instance_reader: false do |serializer|
+          serializer.class_attribute :_attributes_data # @api private
+          self._attributes_data ||= {}
+        end
+
+        extend ActiveSupport::Autoload
+        autoload :Attribute
+
+        # Return the +attributes+ of +object+ as presented
+        # by the serializer.
+        def attributes(requested_attrs = nil, reload = false)
+          @attributes = nil if reload
+          @attributes ||= self.class._attributes_data.each_with_object({}) do |(key, attr), hash|
+            next if attr.excluded?(self)
+            next unless requested_attrs.nil? || requested_attrs.include?(key)
+            hash[key] = attr.value(self)
+          end
+        end
+      end
+
+      module ClassMethods
+        def inherited(base)
+          super
+          base._attributes_data = _attributes_data.dup
+        end
+
+        # @example
+        #   class AdminAuthorSerializer < ActiveModel::Serializer
+        #     attributes :id, :name, :recent_edits
+        def attributes(*attrs)
+          attrs = attrs.first if attrs.first.class == Array
+
+          attrs.each do |attr|
+            attribute(attr)
+          end
+        end
+
+        # @example
+        #   class AdminAuthorSerializer < ActiveModel::Serializer
+        #     attributes :id, :recent_edits
+        #     attribute :name, key: :title
+        #
+        #     attribute :full_name do
+        #       "#{object.first_name} #{object.last_name}"
+        #     end
+        #
+        #     def recent_edits
+        #       object.edits.last(5)
+        #     end
+        def attribute(attr, options = {}, &block)
+          key = options.fetch(:key, attr)
+          _attributes_data[key] = Attribute.new(attr, options, block)
+        end
+
+        # @api private
+        # keys of attributes
+        # @see Serializer::attribute
+        def _attributes
+          _attributes_data.keys
+        end
+
+        # @api private
+        # maps attribute value to explict key name
+        # @see Serializer::attribute
+        # @see FragmentCache#fragment_serializer
+        def _attributes_keys
+          _attributes_data
+            .each_with_object({}) do |(key, attr), hash|
+              next if key == attr.name
+              hash[attr.name] = { key: key }
+            end
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/belongs_to_reflection.rb

@@ -0,0 +1,10 @@
+module ActiveModel
+  class Serializer
+    # @api private
+    class BelongsToReflection < SingularReflection
+      def macro
+        :belongs_to
+      end
+    end
+  end
+end