active_model_serializers 0.8.3 → 0.9.4

data/lib/action_controller/serialization.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/class/attribute'
+
 module ActionController
   # Action Controller Serialization
   #
@@ -27,34 +29,70 @@ module ActionController
 
     include ActionController::Renderers
 
+    class << self
+      attr_accessor :enabled
+    end
+    self.enabled = true
+
     included do
       class_attribute :_serialization_scope
       self._serialization_scope = :current_user
     end
 
-    def serialization_scope
-      send(_serialization_scope) if _serialization_scope &&
-        respond_to?(_serialization_scope, true)
-    end
-
-    def default_serializer_options
+    module ClassMethods
+      def serialization_scope(scope)
+        self._serialization_scope = scope
+      end
     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)
+        serializer = build_json_serializer(resource, options)
 
-        if json
-          super(json, options)
+        if serializer
+          super(serializer, options)
         else
           super(resource, options)
         end
       end
     end
 
-    module ClassMethods
-      def serialization_scope(scope)
-        self._serialization_scope = scope
+    private
+
+    def namespace_for_serializer
+      @namespace_for_serializer ||= self.class.parent unless self.class.parent == Object
+    end
+
+    def default_serializer(resource)
+      options = {}.tap do |o|
+        o[:namespace] = namespace_for_serializer if namespace_for_serializer
+      end
+
+      ActiveModel::Serializer.serializer_for(resource, options)
+    end
+
+    def default_serializer_options
+      {}
+    end
+
+    def serialization_scope
+      _serialization_scope = self.class._serialization_scope
+      send(_serialization_scope) if _serialization_scope && respond_to?(_serialization_scope, true)
+    end
+
+    def build_json_serializer(resource, options = {})
+      options = default_serializer_options.merge(options)
+      @namespace_for_serializer = options.fetch(:namespace, nil)
+
+      if serializer = options.fetch(:serializer, default_serializer(resource))
+        options[:scope] = serialization_scope unless options.has_key?(:scope)
+
+        if resource.respond_to?(:to_ary)
+          options[:resource_name] = controller_name 
+          options[:namespace] = namespace_for_serializer if namespace_for_serializer
+        end
+
+        serializer.new(resource, options)
       end
     end
   end

data/lib/action_controller/serialization_test_case.rb

@@ -0,0 +1,79 @@
+module ActionController
+  module SerializationAssertions
+    extend ActiveSupport::Concern
+
+    included do
+      setup :setup_serialization_subscriptions
+      teardown :teardown_serialization_subscriptions
+    end
+
+    def setup_serialization_subscriptions
+      @serializers = Hash.new(0)
+
+      ActiveSupport::Notifications.subscribe("!serialize.active_model_serializers") do |name, start, finish, id, payload|
+        serializer = payload[:serializer]
+        @serializers[serializer] += 1
+      end
+    end
+
+    def teardown_serialization_subscriptions
+      ActiveSupport::Notifications.unsubscribe("!serialize.active_model_serializers")
+    end
+
+    def process(*args)
+      @serializers = Hash.new(0)
+      super
+    end
+
+    # Asserts that the request was rendered with the appropriate serializers.
+    #
+    #  # assert that the "PostSerializer" serializer was rendered
+    #  assert_serializer "PostSerializer"
+    #
+    #  # assert that the instance of PostSerializer was rendered
+    #  assert_serializer PostSerializer
+    #
+    #  # assert that the "PostSerializer" serializer was rendered
+    #  assert_serializer :post_serializer
+    #
+    #  # assert that the rendered serializer starts with "Post"
+    #  assert_serializer %r{\APost.+\Z}
+    #
+    #  # assert that no serializer was rendered
+    #  assert_serializer nil
+    #
+    #
+    def assert_serializer(options = {}, message = nil)
+      # Force body to be read in case the template is being streamed.
+      response.body
+
+      rendered = @serializers
+      msg = message || "expecting <#{options.inspect}> but rendering with <#{rendered.keys}>"
+
+      matches_serializer = case options
+                           when lambda { |options| options.kind_of?(Class) && options < ActiveModel::Serializer }
+                             rendered.any? do |serializer, count|
+                               options.name == serializer
+                             end
+                           when Symbol
+                             options = options.to_s.camelize
+                             rendered.any? do |serializer, count|
+                               serializer == options
+                             end
+                           when String
+                             !options.empty? && rendered.any? do |serializer, count|
+                               serializer == options
+                             end
+                           when Regexp
+                             rendered.any? do |serializer, count|
+                               serializer.match(options)
+                             end
+                           when NilClass
+                             rendered.blank?
+                           else
+                             raise ArgumentError, "assert_serializer only accepts a String, Symbol, Regexp, ActiveModel::Serializer, or nil"
+                           end
+      assert matches_serializer, msg
+    end
+  end
+end

data/lib/active_model/array_serializer.rb

@@ -1,104 +1,73 @@
-require "active_support/core_ext/class/attribute"
-require 'active_support/dependencies'
-require 'active_support/descendants_tracker'
+require 'active_model/default_serializer'
+require 'active_model/serializable'
 
 module ActiveModel
-  # Active Model Array Serializer
-  #
-  # Serializes an Array, checking if each element implements
-  # the +active_model_serializer+ method.
-  #
-  # To disable serialization of root elements:
-  #
-  #     ActiveModel::ArraySerializer.root = false
-  #
   class ArraySerializer
-    extend ActiveSupport::DescendantsTracker
-
-    attr_reader :object, :options
-
-    class_attribute :root
-
-    class_attribute :cache
-    class_attribute :perform_caching
+    include Serializable
 
     class << self
-      # set perform caching like root
-      def cached(value = true)
-        self.perform_caching = value
-      end
+      attr_accessor :_root
+      alias root  _root=
+      alias root= _root=
     end
 
     def initialize(object, options={})
-      @object, @options = object, options
+      @object          = object
+      @scope           = options[:scope]
+      @root            = options.fetch(:root, self.class._root)
+      @polymorphic     = options.fetch(:polymorphic, false)
+      @meta_key        = options[:meta_key] || :meta
+      @meta            = options[@meta_key]
+      @each_serializer = options[:each_serializer]
+      @resource_name   = options[:resource_name]
+      @only            = options[:only] ? Array(options[:only]) : nil
+      @except          = options[:except] ? Array(options[:except]) : nil
+      @context         = options[:context]
+      @namespace       = options[:namespace]
+      @key_format      = options[:key_format] || options[:each_serializer].try(:key_format)
     end
+    attr_accessor :object, :scope, :root, :meta_key, :meta, :key_format, :context
 
-    def meta_key
-      @options[:meta_key].try(:to_sym) || :meta
-    end
+    def json_key
+      key = root.nil? ? @resource_name : root
 
-    def include_meta(hash)
-      hash[meta_key] = @options[:meta] if @options.has_key?(:meta)
+      key_format == :lower_camel && key.present? ? key.camelize(:lower) : key
     end
 
-    def as_json(*args)
-      @options[:hash] = hash = {}
-      @options[:unique_values] = {}
-
-      if root = @options[:root]
-        hash.merge!(root => serializable_array)
-        include_meta hash
-        hash
-      else
-        serializable_array
-      end
+    def serializer_for(item)
+      serializer_class = @each_serializer || Serializer.serializer_for(item, namespace: @namespace) || DefaultSerializer
+      serializer_class.new(item, scope: scope, key_format: key_format, context: @context, only: @only, except: @except, polymorphic: @polymorphic, namespace: @namespace)
     end
 
-    def to_json(*args)
-      if perform_caching?
-        cache.fetch expand_cache_key([self.class.to_s.underscore, cache_key, 'to-json']) do
-          super
-        end
-      else
-        super
+    def serializable_object(options={})
+      @object.map do |item|
+        serializer_for(item).serializable_object_with_notification(options)
       end
     end
-
-    def serializable_array
-      if perform_caching?
-        cache.fetch expand_cache_key([self.class.to_s.underscore, cache_key, 'serializable-array']) do
-          _serializable_array
+    alias_method :serializable_array, :serializable_object
+
+    def embedded_in_root_associations
+      @object.each_with_object({}) do |item, hash|
+        serializer_for(item).embedded_in_root_associations.each_pair do |type, objects|
+          next if !objects || objects.flatten.empty?
+
+          if hash.has_key?(type)
+            case hash[type] when Hash
+              hash[type].deep_merge!(objects){ |key, old, new| (Array(old) + Array(new)).uniq }
+            else
+              hash[type].concat(objects).uniq!
+            end
+          else
+            hash[type] = objects
+          end
         end
-      else
-        _serializable_array
       end
     end
 
     private
-    def _serializable_array
-      @object.map do |item|
-        if @options.has_key? :each_serializer
-          serializer = @options[:each_serializer]
-        elsif item.respond_to?(:active_model_serializer)
-          serializer = item.active_model_serializer
-        end
-
-        serializable = serializer ? serializer.new(item, @options) : DefaultSerializer.new(item, @options.merge(:root => false))
-
-        if serializable.respond_to?(:serializable_hash)
-          serializable.serializable_hash
-        else
-          serializable.as_json
-        end
-      end
-    end
-
-    def expand_cache_key(*args)
-      ActiveSupport::Cache.expand_cache_key(args)
-    end
 
-    def perform_caching?
-      perform_caching && cache && respond_to?(:cache_key)
+    def instrumentation_keys
+      [:object, :scope, :root, :meta_key, :meta, :each_serializer, :resource_name, :key_format, :context]
     end
   end
 end

data/lib/active_model/default_serializer.rb

@@ -0,0 +1,32 @@
+require 'active_model/serializable'
+
+module ActiveModel
+  # DefaultSerializer
+  #
+  # Provides a constant interface for all items
+  class DefaultSerializer
+    include ActiveModel::Serializable
+
+    attr_reader :object
+
+    def initialize(object, options={})
+      @object = object
+      @wrap_in_array = options[:_wrap_in_array]
+    end
+
+    def as_json(options={})
+      instrument('!serialize') do
+        return [] if @object.nil? && @wrap_in_array
+        hash = @object.as_json
+        @wrap_in_array ? [hash] : hash
+      end
+    end
+    alias serializable_hash as_json
+    alias serializable_object as_json
+
+    private
+    def instrumentation_keys
+      [:object, :wrap_in_array]
+    end
+  end
+end

data/lib/active_model/serializable/utils.rb

@@ -0,0 +1,16 @@
+module ActiveModel
+  module Serializable
+    module Utils
+      extend self
+
+      def _const_get(const)
+        begin
+          method = RUBY_VERSION >= '2.0' ? :const_get : :qualified_const_get
+          Object.send method, const
+        rescue NameError
+          const.safe_constantize
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializable.rb

@@ -0,0 +1,62 @@
+require 'active_model/serializable/utils'
+
+module ActiveModel
+  module Serializable
+    def self.included(base)
+      base.extend Utils
+    end
+
+    def as_json(options={})
+      instrument('!serialize') do
+        if root = options.fetch(:root, json_key)
+          hash = { root => serializable_object(options) }
+          hash.merge!(serializable_data)
+          hash
+        else
+          serializable_object(options)
+        end
+      end
+    end
+
+    def serializable_object_with_notification(options={})
+      instrument('!serialize') do
+        serializable_object(options)
+      end
+    end
+
+    def serializable_data
+      embedded_in_root_associations.tap do |hash|
+        if respond_to?(:meta) && meta
+          hash[meta_key] = meta
+        end
+      end
+    end
+
+    def namespace
+      get_namespace && Utils._const_get(get_namespace)
+    end
+
+    def embedded_in_root_associations
+      {}
+    end
+
+    private
+
+    def get_namespace
+      modules = self.class.name.split('::')
+      modules[0..-2].join('::') if modules.size > 1
+    end
+
+    def instrument(action, &block)
+      payload = instrumentation_keys.inject({ serializer: self.class.name }) do |payload, key|
+        payload[:payload] = self.instance_variable_get(:"@#{key}")
+        payload
+      end
+      ActiveSupport::Notifications.instrument("#{action}.active_model_serializers", payload, &block)
+    end
+
+    def instrumentation_keys
+      [:object, :scope, :root, :meta_key, :meta, :wrap_in_array, :only, :except, :key_format]
+    end
+  end
+end

data/lib/active_model/serializer/association/has_many.rb

@@ -0,0 +1,39 @@
+module ActiveModel
+  class Serializer
+    class Association
+      class HasMany < Association
+        def initialize(name, *args)
+          super
+          @root_key = @embedded_key.to_s
+          @key ||= case CONFIG.default_key_type
+            when :name then name.to_s.pluralize
+            else "#{name.to_s.singularize}_ids"
+          end
+        end
+
+        def serializer_class(object, _)
+          if use_array_serializer?
+            ArraySerializer
+          else
+            serializer_from_options
+          end
+        end
+
+        def options
+          if use_array_serializer?
+            { each_serializer: serializer_from_options }.merge! super
+          else
+            super
+          end
+        end
+
+        private
+
+        def use_array_serializer?
+          !serializer_from_options ||
+            serializer_from_options && !(serializer_from_options <= ArraySerializer)
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/association/has_one.rb

@@ -0,0 +1,25 @@
+module ActiveModel
+  class Serializer
+    class Association
+      class HasOne < Association
+        def initialize(name, *args)
+          super
+          @root_key = @embedded_key.to_s.pluralize
+          @key ||= case CONFIG.default_key_type
+            when :name then name.to_s.singularize
+            else "#{name}_id"
+          end
+        end
+
+        def serializer_class(object, options = {})
+          (serializer_from_options unless object.nil?) || serializer_from_object(object, options) || default_serializer
+        end
+
+        def build_serializer(object, options = {})
+          options[:_wrap_in_array] = embed_in_root?
+          super
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/association.rb

@@ -0,0 +1,58 @@
+require 'active_model/default_serializer'
+require 'active_model/serializer/association/has_one'
+require 'active_model/serializer/association/has_many'
+
+module ActiveModel
+  class Serializer
+    class Association
+      def initialize(name, options={})
+        if options.has_key?(:include)
+          ActiveSupport::Deprecation.warn <<-WARN
+** Notice: include was renamed to embed_in_root. **
+          WARN
+        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 }
+
+        serializer = @options[:serializer]
+        @serializer_from_options = serializer.is_a?(String) ? serializer.constantize : serializer
+      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
+
+      def embed=(embed)
+        @embed_ids     = embed == :id || embed == :ids
+        @embed_objects = embed == :object || embed == :objects
+      end
+
+      def serializer_from_object(object, options = {})
+        Serializer.serializer_for(object, options)
+      end
+
+      def default_serializer
+        DefaultSerializer
+      end
+
+      def build_serializer(object, options = {})
+        serializer_class(object, options).new(object, options.merge(self.options))
+      end
+    end
+  end
+end

data/lib/active_model/serializer/config.rb

@@ -0,0 +1,31 @@
+module ActiveModel
+  class Serializer
+    class Config
+      def initialize(data = {})
+        @data = data
+      end
+
+      def each(&block)
+        @data.each(&block)
+      end
+
+      def clear
+        @data.clear
+      end
+
+      def method_missing(name, *args)
+        name = name.to_s
+        return @data[name] if @data.include?(name)
+        match = name.match(/\A(.*?)([?=]?)\Z/)
+        case match[2]
+        when "="
+          @data[match[1]] = args.first
+        when "?"
+          !!@data[match[1]]
+        end
+      end
+    end
+
+    CONFIG = Config.new('embed' => :objects) # :nodoc:
+  end
+end

data/lib/active_model/serializer/generators/resource_override.rb

@@ -0,0 +1,13 @@
+require 'rails/generators'
+require 'rails/generators/rails/resource/resource_generator'
+
+module Rails
+  module Generators
+    class ResourceGenerator
+      def add_serializer
+        invoke 'serializer'
+      end
+    end
+  end
+end
+

data/lib/active_model/serializer/generators/serializer/scaffold_controller_generator.rb

@@ -0,0 +1,14 @@
+require 'rails/generators'
+require 'rails/generators/rails/scaffold_controller/scaffold_controller_generator'
+
+module Rails
+  module Generators
+    class ScaffoldControllerGenerator
+      if Rails::VERSION::MAJOR >= 4
+        source_root File.expand_path('../templates', __FILE__)
+
+        hook_for :serializer, default: true
+      end
+    end
+  end
+end

data/lib/active_model/serializer/generators/serializer/serializer_generator.rb

@@ -0,0 +1,37 @@
+module Rails
+  module Generators
+    class SerializerGenerator < NamedBase
+      source_root File.expand_path('../templates', __FILE__)
+      check_class_collision suffix: 'Serializer'
+
+      argument :attributes, type: :array, default: [], banner: 'field:type field:type'
+
+      class_option :parent, type: :string, desc: 'The parent class for the generated serializer'
+
+      def create_serializer_file
+        template 'serializer.rb', File.join('app/serializers', class_path, "#{file_name}_serializer.rb")
+      end
+
+      private
+
+      def attributes_names
+        [:id] + attributes.select { |attr| !attr.reference? }.map { |a| a.name.to_sym }
+      end
+
+      def association_names
+        attributes.select { |attr| attr.reference? }.map { |a| a.name.to_sym }
+      end
+
+      def parent_class_name
+        if options[:parent]
+          options[:parent]
+        elsif (ns = Rails::Generators.namespace) && ns.const_defined?(:ApplicationSerializer) ||
+               (Object.const_get(:ApplicationSerializer) rescue nil)
+          'ApplicationSerializer'
+        else
+          'ActiveModel::Serializer'
+        end
+      end
+    end
+  end
+end