active_model_serializers 0.9.8 → 0.10.0.rc1

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/lib/active_model_serializers/model/caching.rb

@@ -1,25 +0,0 @@
-module ActiveModelSerializers
-  class Model
-    module Caching
-      extend ActiveSupport::Concern
-
-      included do
-        attr_writer :updated_at
-        attributes :id
-      end
-
-      # Defaults to the downcased model name and updated_at
-      def cache_key
-        ActiveSupport::Cache.expand_cache_key([
-          self.class.model_name.name.downcase,
-          "#{id}-#{updated_at.strftime('%Y%m%d%H%M%S%9N')}"
-        ].compact)
-      end
-
-      # Defaults to the time the serializer file was modified.
-      def updated_at
-        defined?(@updated_at) ? @updated_at : File.mtime(__FILE__)
-      end
-    end
-  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)

data/test/fixtures/active_record.rb

@@ -1,96 +0,0 @@
-require 'active_record'
-
-ActiveRecord::Base.establish_connection(
-  :adapter  => 'sqlite3',
-  :database => ':memory:'
-)
-
-ActiveRecord::Schema.define do
-  create_table :ar_posts, force: true do |t|
-    t.string     :title
-    t.text       :body
-    t.belongs_to :ar_section, index: true
-    t.timestamps
-  end
-
-  create_table :ar_comments, force: true do |t|
-    t.text       :body
-    t.belongs_to :ar_post, index: true
-    t.timestamps
-  end
-
-  create_table :ar_tags, force: true do |t|
-    t.string :name
-  end
-
-  create_table :ar_sections, force: true do |t|
-    t.string :name
-  end
-
-  create_table :ar_posts_tags, force: true do |t|
-    t.references :ar_post, :ar_tag, index: true
-  end
-
-  create_table :ar_comments_tags, force: true do |t|
-    t.references :ar_comment, :ar_tag, index: true
-  end
-end
-
-class ARPost < ActiveRecord::Base
-  has_many :ar_comments, class_name: 'ARComment'
-  has_and_belongs_to_many :ar_tags, class_name: 'ARTag', join_table: :ar_posts_tags
-  belongs_to :ar_section, class_name: 'ARSection'
-end
-
-class ARComment < ActiveRecord::Base
-  belongs_to :ar_post, class_name: 'ARPost'
-  has_and_belongs_to_many :ar_tags, class_name: 'ARTag', join_table: :ar_comments_tags
-end
-
-class ARTag < ActiveRecord::Base
-end
-
-class ARSection < ActiveRecord::Base
-end
-
-class ARPostSerializer < ActiveModel::Serializer
-  attributes :title, :body
-
-  has_many :ar_comments, :ar_tags
-  has_one  :ar_section
-end
-
-class ARCommentSerializer < ActiveModel::Serializer
-  attributes :body
-
-  has_many :ar_tags
-end
-
-class ARTagSerializer < ActiveModel::Serializer
-  attributes :name
-end
-
-class ARSectionSerializer < ActiveModel::Serializer
-  attributes 'name'
-end
-
-class AREmbeddedSerializer < ActiveModel::Serializer
-  has_many :ar_tags, :ar_comments
-end
-
-ARPost.create(title: 'New post',
-              body:  'A body!!!',
-              ar_section: ARSection.create(name: 'ruby')).tap do |post|
-
-  short_tag = post.ar_tags.create(name: 'short')
-  whiny_tag = post.ar_tags.create(name: 'whiny')
-  happy_tag = ARTag.create(name: 'happy')
-
-  post.ar_comments.create(body: 'what a dumb post').tap do |comment|
-    comment.ar_tags.concat happy_tag, whiny_tag
-  end
-
-  post.ar_comments.create(body: 'i liked it').tap do |comment|
-    comment.ar_tags.concat happy_tag, short_tag
-  end
-end