active_model_serializers 0.9.8 → 0.10.13

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/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/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/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/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

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 -%>

data/lib/active_model/serializer/railtie.rb

@@ -1,22 +0,0 @@
-module ActiveModel
-  class Railtie < Rails::Railtie
-    initializer 'generators' do |app|
-      app.load_generators
-      require 'active_model/serializer/generators/serializer/serializer_generator'
-      require 'active_model/serializer/generators/serializer/scaffold_controller_generator'
-      require 'active_model/serializer/generators/resource_override'
-    end
-
-    initializer 'include_routes.active_model_serializer' do |app|
-      ActiveSupport.on_load(:active_model_serializers) do
-        include app.routes.url_helpers
-      end
-    end
-
-    config.to_prepare do
-      ActiveModel::Serializer.serializers_cache.clear
-    end
-  end
-end
-
-ActiveSupport.run_load_hooks(:active_model_serializers, ActiveModel::Serializer)

data/lib/active_model/serializer_support.rb

@@ -1,5 +0,0 @@
-module ActiveModel
-  module SerializerSupport
-    alias read_attribute_for_serialization send
-  end
-end

data/test/benchmark/app.rb

@@ -1,60 +0,0 @@
-# https://github.com/rails-api/active_model_serializers/pull/872
-# approx ref 792fb8a9053f8db3c562dae4f40907a582dd1720 to test against
-require 'bundler/setup'
-
-require 'rails'
-require 'active_model'
-require 'active_support'
-require 'active_support/json'
-require 'action_controller'
-require 'action_controller/test_case'
-require 'action_controller/railtie'
-abort "Rails application already defined: #{Rails.application.class}" if Rails.application
-
-class NullLogger < Logger
-  def initialize(*_args)
-  end
-
-  def add(*_args, &_block)
-  end
-end
-class BenchmarkLogger < ActiveSupport::Logger
-  def initialize
-    @file = StringIO.new
-    super(@file)
-  end
-
-  def messages
-    @file.rewind
-    @file.read
-  end
-end
-# ref: https://gist.github.com/bf4/8744473
-class BenchmarkApp < Rails::Application
-  # Set up production configuration
-  config.eager_load = true
-  config.cache_classes = true
-  # CONFIG: CACHE_ON={on,off}
-  config.action_controller.perform_caching = ENV['CACHE_ON'] != 'off'
-  config.action_controller.cache_store = ActiveSupport::Cache.lookup_store(:memory_store)
-
-  config.active_support.test_order = :random
-  config.secret_token = 'S' * 30
-  config.secret_key_base = 'abc123'
-  config.consider_all_requests_local = false
-
-  # otherwise deadlock occurred
-  config.middleware.delete 'Rack::Lock'
-
-  # to disable log files
-  config.logger = NullLogger.new
-  config.active_support.deprecation = :log
-  config.log_level = :info
-end
-
-require 'active_model_serializers'
-
-# Initialize app before any serializers are defined, for running across revisions.
-# ref: https://github.com/rails-api/active_model_serializers/pull/1478
-Rails.application.initialize!
-

data/test/benchmark/benchmarking_support.rb

@@ -1,67 +0,0 @@
-require 'benchmark/ips'
-require 'json'
-
-# Add benchmarking runner from ruby-bench-suite
-# https://github.com/ruby-bench/ruby-bench-suite/blob/master/rails/benchmarks/support/benchmark_rails.rb
-module Benchmark
-  module ActiveModelSerializers
-    module TestMethods
-      def request(method, path)
-        response = Rack::MockRequest.new(BenchmarkApp).send(method, path)
-        if response.status.in?([404, 500])
-          fail "omg, #{method}, #{path}, '#{response.status}', '#{response.body}'"
-        end
-        response
-      end
-    end
-
-    # extend Benchmark with an `ams` method
-    def ams(label = nil, time:, disable_gc: true, warmup: 3, &block)
-      fail ArgumentError.new, 'block should be passed' unless block_given?
-
-      if disable_gc
-        GC.disable
-      else
-        GC.enable
-      end
-
-      report = Benchmark.ips(time, warmup, true) do |x|
-        x.report(label) { yield }
-      end
-
-      entry = report.entries.first
-
-      output = {
-        label: label,
-        version: ::ActiveModel::Serializer::VERSION.to_s,
-        rails_version: ::Rails.version.to_s,
-        iterations_per_second: entry.ips,
-        iterations_per_second_standard_deviation: entry.error_percentage,
-        total_allocated_objects_per_iteration: count_total_allocated_objects(&block)
-      }.to_json
-
-      puts output
-      output
-    end
-
-    def count_total_allocated_objects
-      if block_given?
-        key =
-          if RUBY_VERSION < '2.2'
-            :total_allocated_object
-          else
-            :total_allocated_objects
-          end
-
-        before = GC.stat[key]
-        yield
-        after = GC.stat[key]
-        after - before
-      else
-        -1
-      end
-    end
-  end
-
-  extend Benchmark::ActiveModelSerializers
-end

data/test/benchmark/bm_active_record.rb

@@ -1,41 +0,0 @@
-require_relative './benchmarking_support'
-require_relative './app'
-require_relative './setup'
-
-time = 10
-disable_gc = true
-
-
-
-authors_query = Author.preload(:posts).preload(:profile)
-author = authors_query.first
-authors = authors_query.to_a
-
-
-Benchmark.ams('Single: DefaultSerializer', time: time, disable_gc: disable_gc) do
- ActiveModel::DefaultSerializer.new(author).to_json
-end
-
-Benchmark.ams('ArraySerializer', time: time, disable_gc: disable_gc) do
- ActiveModel::ArraySerializer.new(authors).to_json
-end
-
-Benchmark.ams('ArraySerializer: each_serializer: DefaultSerializer', time: time, disable_gc: disable_gc) do
- ActiveModel::ArraySerializer.new(authors, each_serializer:ActiveModel::DefaultSerializer).to_json
-end
-
-Benchmark.ams('FlatAuthorSerializer', time: time, disable_gc: disable_gc) do
- FlatAuthorSerializer.new(author).to_json
-end
-
-Benchmark.ams('ArraySerializer: each_serializer: FlatAuthorSerializer', time: time, disable_gc: disable_gc) do
- ActiveModel::ArraySerializer.new(authors, each_serializer: FlatAuthorSerializer).to_json
-end
-
-Benchmark.ams('AuthorWithDefaultRelationshipsSerializer', time: time, disable_gc: disable_gc) do
- AuthorWithDefaultRelationshipsSerializer.new(author).to_json
-end
-
-Benchmark.ams('ArraySerializer: each_serializer: AuthorWithDefaultRelationshipsSerializer', time: time, disable_gc: disable_gc) do
- ActiveModel::ArraySerializer.new(authors, each_serializer: AuthorWithDefaultRelationshipsSerializer).to_json
-end

data/test/benchmark/setup.rb

@@ -1,75 +0,0 @@
-###########################################
-# Setup active record models
-##########################################
-require 'active_record'
-require 'sqlite3'
-
-
-# Change the following to reflect your database settings
-ActiveRecord::Base.establish_connection(
-  adapter: 'sqlite3',
-  database: ':memory:'
-)
-
-# Don't show migration output when constructing fake db
-ActiveRecord::Migration.verbose = false
-
-ActiveRecord::Schema.define do
-  create_table :authors, force: true do |t|
-    t.string :name
-  end
-
-  create_table :posts, force: true do |t|
-    t.text :body
-    t.string :title
-    t.references :author
-  end
-
-  create_table :profiles, force: true do |t|
-    t.text :project_url
-    t.text :bio
-    t.date :birthday
-    t.references :author
-  end
-end
-
-class Author < ActiveRecord::Base
-  has_one :profile
-  has_many :posts
-end
-
-class Post < ActiveRecord::Base
-  belongs_to :author
-end
-
-class Profile < ActiveRecord::Base
-  belongs_to :author
-end
-
-# Build out the data to serialize
-author = Author.create(name: 'Preston Sego')
-Profile.create(project_url: 'https://github.com/NullVoxPopuli', author: author)
-50.times do
-  Post.create(
-    body: 'something about how password restrictions are evil, and less secure, and with the math to prove it.',
-    title: 'Your bank is does not know how to do security',
-    author: author
-  )
-end
-
-ActiveModel::Serializer.root = false
-ActiveModel::ArraySerializer.root = false
-
-class FlatAuthorSerializer < ActiveModel::Serializer
-  attributes :id, :name
-end
-
-class AuthorWithDefaultRelationshipsSerializer < ActiveModel::Serializer
-  attributes :id, :name
-
-  has_one :profile
-  has_many :posts
-end
-
-# For debugging SQL output
-#ActiveRecord::Base.logger = Logger.new(STDERR)