active_model_serializers 0.9.8 → 0.10.0.rc1

data/lib/action_controller/serialization_test_case.rb

@@ -1,79 +0,0 @@
-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,68 +0,0 @@
-require 'active_model/default_serializer'
-require 'active_model/serializable'
-
-module ActiveModel
-  class ArraySerializer
-    include Serializable
-
-    class << self
-      attr_accessor :_root
-      alias root  _root=
-      alias root= _root=
-    end
-
-    def initialize(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 json_key
-      key = root.nil? ? @resource_name : root
-
-      key_format == :lower_camel && key.present? ? key.camelize(:lower) : key
-    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 serializable_object(options={})
-      @object.map do |item|
-        serializer_for(item).serializable_object_with_notification(options)
-      end
-    end
-    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
-      end
-    end
-
-  end
-end

data/lib/active_model/default_serializer.rb

@@ -1,28 +0,0 @@
-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 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
-  end
-end

data/lib/active_model/serializable.rb

@@ -1,59 +0,0 @@
-require 'active_model/serializable/utils'
-
-module ActiveModel
-  module Serializable
-    INSTRUMENTATION_KEY = '!serialize.active_model_serializers'.freeze
-
-    def self.included(base)
-      base.extend Utils
-    end
-
-    def as_json(options={})
-      instrument 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 { serializable_object(options) }
-    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
-      if module_name = get_namespace
-        Serializer.serializers_cache.fetch_or_store(module_name) do
-          Utils._const_get(module_name)
-        end
-      end
-    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(&block)
-      payload = { serializer: self.class.name }
-      ActiveSupport::Notifications.instrument(INSTRUMENTATION_KEY, payload, &block)
-    end
-  end
-end

data/lib/active_model/serializable/utils.rb

@@ -1,16 +0,0 @@
-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/serializer/association.rb

@@ -1,58 +0,0 @@
-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/association/has_many.rb

@@ -1,39 +0,0 @@
-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

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

@@ -1,31 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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/USAGE

@@ -1,9 +0,0 @@
-Description:
-    Generates a serializer for the given resource with tests.
-
-Example:
-    `rails generate serializer Account name created_at`
-
-    For TestUnit it creates:
-        Serializer:  app/serializers/account_serializer.rb
-        TestUnit:    test/unit/account_serializer_test.rb

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

@@ -1,14 +0,0 @@
-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, type: :boolean
-      end
-    end
-  end
-end