active_model_serializers 0.9.0 → 0.10.12

data/lib/action_controller/serialization_test_case.rb

@@ -1,79 +0,0 @@
-module ActionController
-  module SerializationAssertions
-    extend ActiveSupport::Concern
-
-    included do
-      setup :setup_subscriptions
-      teardown :teardown_subscriptions
-    end
-
-    def setup_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_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,65 +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)
-      @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
-      @key_format      = options[:key_format] || options[:each_serializer].try(:key_format)
-    end
-    attr_accessor :object, :scope, :root, :meta_key, :meta, :key_format
-
-    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) || DefaultSerializer
-      serializer_class.new(item, scope: scope, key_format: key_format, only: @only, except: @except)
-    end
-
-    def serializable_object
-      @object.map do |item|
-        serializer_for(item).serializable_object
-      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)
-            hash[type].concat(objects).uniq!
-          else
-            hash[type] = objects
-          end
-        end
-      end
-    end
-
-    private
-    def instrumentation_keys
-      [:object, :scope, :root, :meta_key, :meta, :each_serializer, :resource_name, :key_format]
-    end
-  end
-end

data/lib/active_model/default_serializer.rb

@@ -1,32 +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('!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.rb

@@ -1,40 +0,0 @@
-module ActiveModel
-  module Serializable
-    def as_json(options={})
-      instrument('!serialize') do
-        if root = options.fetch(:root, json_key)
-          hash = { root => serializable_object }
-          hash.merge!(serializable_data)
-          hash
-        else
-          serializable_object
-        end
-      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 embedded_in_root_associations
-      {}
-    end
-
-    private
-    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/associations.rb

@@ -1,102 +0,0 @@
-require 'active_model/default_serializer'
-
-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 }
-        @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
-      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
-
-      def embed=(embed)
-        @embed_ids     = embed == :id || embed == :ids
-        @embed_objects = embed == :object || embed == :objects
-      end
-
-      def serializer_from_object(object)
-        Serializer.serializer_for(object)
-      end
-
-      def default_serializer
-        DefaultSerializer
-      end
-
-      def build_serializer(object, options = {})
-        serializer_class(object).new(object, options.merge(self.options))
-      end
-
-      class HasOne < Association
-        def initialize(name, *args)
-          super
-          @root_key = @embedded_key.to_s.pluralize
-          @key ||= "#{name}_id"
-        end
-
-        def serializer_class(object)
-          serializer_from_options || serializer_from_object(object) || default_serializer
-        end
-
-        def build_serializer(object, options = {})
-          options[:_wrap_in_array] = embed_in_root?
-          super
-        end
-      end
-
-      class HasMany < Association
-        def initialize(name, *args)
-          super
-          @root_key = @embedded_key
-          @key ||= "#{name.to_s.singularize}_ids"
-        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/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/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
-      end
-    end
-  end
-end

data/lib/active_model/serializer/generators/serializer/templates/controller.rb

@@ -1,93 +0,0 @@
-<% if namespaced? -%>
-require_dependency "<%= namespaced_file_path %>/application_controller"
-
-<% end -%>
-<% module_namespacing do -%>
-class <%= controller_class_name %>Controller < ApplicationController
-  before_action :set_<%= singular_table_name %>, only: [:show, :edit, :update, :destroy]
-
-  # GET <%= route_url %>
-  # GET <%= route_url %>.json
-  def index
-    @<%= plural_table_name %> = <%= orm_class.all(class_name) %>
-
-    respond_to do |format|
-      format.html # index.html.erb
-      format.json { render json: <%= "@#{plural_table_name}" %> }
-    end
-  end
-
-  # GET <%= route_url %>/1
-  # GET <%= route_url %>/1.json
-  def show
-    respond_to do |format|
-      format.html # show.html.erb
-      format.json { render json: <%= "@#{singular_table_name}" %> }
-    end
-  end
-
-  # GET <%= route_url %>/new
-  def new
-    @<%= singular_table_name %> = <%= orm_class.build(class_name) %>
-  end
-
-  # GET <%= route_url %>/1/edit
-  def edit
-  end
-
-  # POST <%= route_url %>
-  # POST <%= route_url %>.json
-  def create
-    @<%= singular_table_name %> = <%= orm_class.build(class_name, "#{singular_table_name}_params") %>
-
-    respond_to do |format|
-      if @<%= orm_instance.save %>
-        format.html { redirect_to @<%= singular_table_name %>, notice: <%= "'#{human_name} was successfully created.'" %> }
-        format.json { render json: <%= "@#{singular_table_name}" %>, status: :created }
-      else
-        format.html { render action: 'new' }
-        format.json { render json: <%= "@#{orm_instance.errors}" %>, status: :unprocessable_entity }
-      end
-    end
-  end
-
-  # PATCH/PUT <%= route_url %>/1
-  # PATCH/PUT <%= route_url %>/1.json
-  def update
-    respond_to do |format|
-      if @<%= orm_instance.update("#{singular_table_name}_params") %>
-        format.html { redirect_to @<%= singular_table_name %>, notice: <%= "'#{human_name} was successfully updated.'" %> }
-        format.json { head :no_content }
-      else
-        format.html { render action: 'edit' }
-        format.json { render json: <%= "@#{orm_instance.errors}" %>, status: :unprocessable_entity }
-      end
-    end
-  end
-
-  # DELETE <%= route_url %>/1
-  # DELETE <%= route_url %>/1.json
-  def destroy
-    @<%= orm_instance.destroy %>
-    respond_to do |format|
-      format.html { redirect_to <%= index_helper %>_url }
-      format.json { head :no_content }
-    end
-  end
-
-  private
-    # Use callbacks to share common setup or constraints between actions.
-    def set_<%= singular_table_name %>
-      @<%= singular_table_name %> = <%= orm_class.find(class_name, "params[:id]") %>
-    end
-
-    # Never trust parameters from the scary internet, only allow the white list through.
-    def <%= "#{singular_table_name}_params" %>
-      <%- if attributes_names.empty? -%>
-      params[<%= ":#{singular_table_name}" %>]
-      <%- else -%>
-      params.require(<%= ":#{singular_table_name}" %>).permit(<%= attributes_names.map { |name| ":#{name}" }.join(', ') %>)
-      <%- end -%>
-    end
-end
-<% end -%>