active_model_serializers 0.10.7 → 0.10.10

data/test/benchmark/bm_active_record.rb

@@ -1,81 +0,0 @@
-require_relative './benchmarking_support'
-require_relative './app'
-
-time = 10
-disable_gc = true
-
-# This is to disable any key transform effects that may impact performance
-ActiveModelSerializers.config.key_transform = :unaltered
-
-###########################################
-# Setup active record models
-##########################################
-require 'active_record'
-require 'sqlite3'
-
-# For debugging SQL output
-# ActiveRecord::Base.logger = Logger.new(STDERR)
-
-# 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
-
-Benchmark.ams('AR: attributes', time: time, disable_gc: disable_gc) do
-  ActiveModelSerializers::SerializableResource.new(author, adapter: :attributes, include: 'profile,posts').serializable_hash
-end
-
-Benchmark.ams('AR: json', time: time, disable_gc: disable_gc) do
-  ActiveModelSerializers::SerializableResource.new(author, adapter: :json, include: 'profile,posts').serializable_hash
-end
-
-Benchmark.ams('AR: JSON API', time: time, disable_gc: disable_gc) do
-  ActiveModelSerializers::SerializableResource.new(author, adapter: :json_api, include: 'profile,posts').serializable_hash
-end

data/test/benchmark/bm_adapter.rb

@@ -1,38 +0,0 @@
-require_relative './benchmarking_support'
-require_relative './app'
-
-time = 10
-disable_gc = true
-ActiveModelSerializers.config.key_transform = :unaltered
-has_many_relationships = (0..60).map do |i|
-  HasManyRelationship.new(id: i, body: 'ZOMG A HAS MANY RELATIONSHIP')
-end
-has_one_relationship = HasOneRelationship.new(
-  id: 42,
-  first_name: 'Joao',
-  last_name: 'Moura'
-)
-primary_resource = PrimaryResource.new(
-  id: 1337,
-  title: 'New PrimaryResource',
-  virtual_attribute: nil,
-  body: 'Body',
-  has_many_relationships: has_many_relationships,
-  has_one_relationship: has_one_relationship
-)
-serializer = PrimaryResourceSerializer.new(primary_resource)
-
-Benchmark.ams('attributes', time: time, disable_gc: disable_gc) do
-  attributes = ActiveModelSerializers::Adapter::Attributes.new(serializer)
-  attributes.as_json
-end
-
-Benchmark.ams('json_api', time: time, disable_gc: disable_gc) do
-  json_api = ActiveModelSerializers::Adapter::JsonApi.new(serializer)
-  json_api.as_json
-end
-
-Benchmark.ams('json', time: time, disable_gc: disable_gc) do
-  json = ActiveModelSerializers::Adapter::Json.new(serializer)
-  json.as_json
-end

data/test/benchmark/bm_caching.rb

@@ -1,119 +0,0 @@
-require_relative './benchmarking_support'
-require_relative './app'
-
-# https://github.com/ruby-bench/ruby-bench-suite/blob/8ad567f7e43a044ae48c36833218423bb1e2bd9d/rails/benchmarks/actionpack_router.rb
-class ApiAssertion
-  include Benchmark::ActiveModelSerializers::TestMethods
-  class BadRevisionError < StandardError; end
-
-  def valid?
-    caching = get_caching
-    caching[:body].delete('meta')
-    non_caching = get_non_caching
-    non_caching[:body].delete('meta')
-    assert_responses(caching, non_caching)
-  rescue BadRevisionError => e
-    msg = { error: e.message }
-    STDERR.puts msg
-    STDOUT.puts msg
-    exit 1
-  end
-
-  def get_status(on_off = 'on'.freeze)
-    get("/status/#{on_off}")
-  end
-
-  def clear
-    get('/clear')
-  end
-
-  def get_caching(on_off = 'on'.freeze)
-    get("/caching/#{on_off}")
-  end
-
-  def get_fragment_caching(on_off = 'on'.freeze)
-    get("/fragment_caching/#{on_off}")
-  end
-
-  def get_non_caching(on_off = 'on'.freeze)
-    get("/non_caching/#{on_off}")
-  end
-
-  def debug(msg = '')
-    if block_given? && ENV['DEBUG'] =~ /\Atrue|on|0\z/i
-      STDERR.puts yield
-    else
-      STDERR.puts msg
-    end
-  end
-
-  private
-
-  def assert_responses(caching, non_caching)
-    assert_equal(caching[:code], 200, "Caching response failed: #{caching}")
-    assert_equal(caching[:body], expected, "Caching response format failed: \n+ #{caching[:body]}\n- #{expected}")
-    assert_equal(caching[:content_type], 'application/json; charset=utf-8', "Caching response content type  failed: \n+ #{caching[:content_type]}\n- application/json")
-    assert_equal(non_caching[:code], 200, "Non caching response failed: #{non_caching}")
-    assert_equal(non_caching[:body], expected, "Non Caching response format failed: \n+ #{non_caching[:body]}\n- #{expected}")
-    assert_equal(non_caching[:content_type], 'application/json; charset=utf-8', "Non caching response content type  failed: \n+ #{non_caching[:content_type]}\n- application/json")
-  end
-
-  def get(url)
-    response = request(:get, url)
-    { code: response.status, body: JSON.load(response.body), content_type: response.content_type }
-  end
-
-  def expected
-    @expected ||=
-      {
-        'primary_resource' => {
-          'id' => 1337,
-          'title' => 'New PrimaryResource',
-          'body' =>  'Body',
-          'virtual_attribute' => {
-            'id' => 999,
-            'name' => 'Free-Range Virtual Attribute'
-          },
-          'has_one_relationship' => {
-            'id' => 42,
-            'first_name' => 'Joao',
-            'last_name' => 'Moura'
-          },
-          'has_many_relationships' => [
-            {
-              'id' => 1,
-              'body' => 'ZOMG A HAS MANY RELATIONSHIP'
-            }
-          ]
-        }
-      }
-  end
-
-  def assert_equal(expected, actual, message)
-    return true if expected == actual
-    if ENV['FAIL_ASSERTION'] =~ /\Atrue|on|0\z/i # rubocop:disable Style/GuardClause
-      fail BadRevisionError, message
-    else
-      STDERR.puts message unless ENV['SUMMARIZE']
-    end
-  end
-end
-assertion = ApiAssertion.new
-assertion.valid?
-assertion.debug { assertion.get_status }
-
-time = 10
-{
-  'caching on: caching serializers: gc off' => { disable_gc: true, send: [:get_caching, 'on'] },
-  'caching on: fragment caching serializers: gc off' => { disable_gc: true, send: [:get_fragment_caching, 'on'] },
-  'caching on: non-caching serializers: gc off' => { disable_gc: true, send: [:get_non_caching, 'on'] },
-  'caching off: caching serializers: gc off' => { disable_gc: true, send: [:get_caching, 'off'] },
-  'caching off: fragment caching serializers: gc off' => { disable_gc: true, send: [:get_fragment_caching, 'off'] },
-  'caching off: non-caching serializers: gc off' => { disable_gc: true, send: [:get_non_caching, 'off'] }
-}.each do |label, options|
-  assertion.clear
-  Benchmark.ams(label, time: time, disable_gc: options[:disable_gc]) do
-    assertion.send(*options[:send])
-  end
-  assertion.debug { assertion.get_status(options[:send][-1]) }
-end

data/test/benchmark/bm_lookup_chain.rb

@@ -1,83 +0,0 @@
-require_relative './benchmarking_support'
-require_relative './app'
-
-time = 10
-disable_gc = true
-ActiveModelSerializers.config.key_transform = :unaltered
-
-module AmsBench
-  module Api
-    module V1
-      class PrimaryResourceSerializer < ActiveModel::Serializer
-        attributes :title, :body
-
-        has_many :has_many_relationships
-      end
-
-      class HasManyRelationshipSerializer < ActiveModel::Serializer
-        attribute :body
-      end
-    end
-  end
-  class PrimaryResourceSerializer < ActiveModel::Serializer
-    attributes :title, :body
-
-    has_many :has_many_relationships
-
-    class HasManyRelationshipSerializer < ActiveModel::Serializer
-      attribute :body
-    end
-  end
-end
-
-resource = PrimaryResource.new(
-  id: 1,
-  title: 'title',
-  body: 'body',
-  has_many_relationships: [
-    HasManyRelationship.new(id: 1, body: 'body1'),
-    HasManyRelationship.new(id: 2, body: 'body1')
-  ]
-)
-
-serialization = lambda do
-  ActiveModelSerializers::SerializableResource.new(resource, serializer: AmsBench::PrimaryResourceSerializer).as_json
-  ActiveModelSerializers::SerializableResource.new(resource, namespace: AmsBench::Api::V1).as_json
-  ActiveModelSerializers::SerializableResource.new(resource).as_json
-end
-
-def clear_cache
-  AmsBench::PrimaryResourceSerializer.serializers_cache.clear
-  AmsBench::Api::V1::PrimaryResourceSerializer.serializers_cache.clear
-  ActiveModel::Serializer.serializers_cache.clear
-end
-
-configurable = lambda do
-  clear_cache
-  Benchmark.ams('Configurable Lookup Chain', time: time, disable_gc: disable_gc, &serialization)
-end
-
-old = lambda do
-  clear_cache
-  module ActiveModel
-    class Serializer
-      def self.serializer_lookup_chain_for(klass, namespace = nil)
-        chain = []
-
-        resource_class_name = klass.name.demodulize
-        resource_namespace = klass.name.deconstantize
-        serializer_class_name = "#{resource_class_name}Serializer"
-
-        chain.push("#{namespace}::#{serializer_class_name}") if namespace
-        chain.push("#{name}::#{serializer_class_name}") if self != ActiveModel::Serializer
-        chain.push("#{resource_namespace}::#{serializer_class_name}")
-        chain
-      end
-    end
-  end
-
-  Benchmark.ams('Old Lookup Chain (v0.10)', time: time, disable_gc: disable_gc, &serialization)
-end
-
-configurable.call
-old.call

data/test/benchmark/bm_transform.rb

@@ -1,45 +0,0 @@
-require_relative './benchmarking_support'
-require_relative './app'
-
-time = 10
-disable_gc = true
-ActiveModelSerializers.config.key_transform = :unaltered
-has_many_relationships = (0..50).map do |i|
-  HasManyRelationship.new(id: i, body: 'ZOMG A HAS MANY RELATIONSHIP')
-end
-has_one_relationship = HasOneRelationship.new(
-  id: 42,
-  first_name: 'Joao',
-  last_name: 'Moura'
-)
-primary_resource = PrimaryResource.new(
-  id: 1337,
-  title: 'New PrimaryResource',
-  virtual_attribute: nil,
-  body: 'Body',
-  has_many_relationships: has_many_relationships,
-  has_one_relationship: has_one_relationship
-)
-serializer = PrimaryResourceSerializer.new(primary_resource)
-adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer)
-serialization = adapter.as_json
-
-Benchmark.ams('camel', time: time, disable_gc: disable_gc) do
-  CaseTransform.camel(serialization)
-end
-
-Benchmark.ams('camel_lower', time: time, disable_gc: disable_gc) do
-  CaseTransform.camel_lower(serialization)
-end
-
-Benchmark.ams('dash', time: time, disable_gc: disable_gc) do
-  CaseTransform.dash(serialization)
-end
-
-Benchmark.ams('unaltered', time: time, disable_gc: disable_gc) do
-  CaseTransform.unaltered(serialization)
-end
-
-Benchmark.ams('underscore', time: time, disable_gc: disable_gc) do
-  CaseTransform.underscore(serialization)
-end

data/test/benchmark/config.ru

@@ -1,3 +0,0 @@
-require File.expand_path(['..', 'app'].join(File::SEPARATOR), __FILE__)
-
-run Rails.application

data/test/benchmark/controllers.rb

@@ -1,83 +0,0 @@
-class PrimaryResourceController < ActionController::Base
-  PRIMARY_RESOURCE =
-    begin
-      if ENV['BENCH_STRESS']
-        has_many_relationships = (0..50).map do |i|
-          HasManyRelationship.new(id: i, body: 'ZOMG A HAS MANY RELATIONSHIP')
-        end
-      else
-        has_many_relationships = [HasManyRelationship.new(id: 1, body: 'ZOMG A HAS MANY RELATIONSHIP')]
-      end
-      has_one_relationship = HasOneRelationship.new(id: 42, first_name: 'Joao', last_name: 'Moura')
-      PrimaryResource.new(id: 1337, title: 'New PrimaryResource', virtual_attribute: nil, body: 'Body', has_many_relationships: has_many_relationships, has_one_relationship: has_one_relationship)
-    end
-
-  def render_with_caching_serializer
-    toggle_cache_status
-    render json: PRIMARY_RESOURCE, serializer: CachingPrimaryResourceSerializer, adapter: :json, meta: { caching: perform_caching }
-  end
-
-  def render_with_fragment_caching_serializer
-    toggle_cache_status
-    render json: PRIMARY_RESOURCE, serializer: FragmentCachingPrimaryResourceSerializer, adapter: :json, meta: { caching: perform_caching }
-  end
-
-  def render_with_non_caching_serializer
-    toggle_cache_status
-    render json: PRIMARY_RESOURCE, adapter: :json, meta: { caching: perform_caching }
-  end
-
-  def render_cache_status
-    toggle_cache_status
-    # Uncomment to debug
-    # STDERR.puts cache_store.class
-    # STDERR.puts cache_dependencies
-    # ActiveSupport::Cache::Store.logger.debug [ActiveModelSerializers.config.cache_store, ActiveModelSerializers.config.perform_caching, CachingPrimaryResourceSerializer._cache, perform_caching, params].inspect
-    render json: { caching: perform_caching, meta: { cache_log: cache_messages, cache_status: cache_status } }.to_json
-  end
-
-  def clear
-    ActionController::Base.cache_store.clear
-    # Test caching is on
-    # Uncomment to turn on logger; possible performance issue
-    # logger = BenchmarkLogger.new
-    # ActiveSupport::Cache::Store.logger = logger # seems to be the best way
-    #
-    # the below is used in some rails tests but isn't available/working in all versions, so far as I can tell
-    # https://github.com/rails/rails/pull/15943
-    # ActiveSupport::Notifications.subscribe(/^cache_(.*)\.active_support$/) do |*args|
-    #   logger.debug ActiveSupport::Notifications::Event.new(*args)
-    # end
-    render json: 'ok'.to_json
-  end
-
-  private
-
-  def cache_status
-    {
-      controller: perform_caching,
-      app: Rails.configuration.action_controller.perform_caching,
-      serializers: Rails.configuration.serializers.each_with_object({}) { |serializer, data| data[serializer.name] = serializer._cache.present? }
-    }
-  end
-
-  def cache_messages
-    ActiveSupport::Cache::Store.logger.is_a?(BenchmarkLogger) && ActiveSupport::Cache::Store.logger.messages.split("\n")
-  end
-
-  def toggle_cache_status
-    case params[:on]
-    when 'on'.freeze then self.perform_caching = true
-    when 'off'.freeze then self.perform_caching = false
-    else nil # no-op
-    end
-  end
-end
-
-Rails.application.routes.draw do
-  get '/status(/:on)' => 'primary_resource#render_cache_status'
-  get '/clear' => 'primary_resource#clear'
-  get '/caching(/:on)' => 'primary_resource#render_with_caching_serializer'
-  get '/fragment_caching(/:on)' => 'primary_resource#render_with_fragment_caching_serializer'
-  get '/non_caching(/:on)' => 'primary_resource#render_with_non_caching_serializer'
-end

data/test/benchmark/fixtures.rb

@@ -1,219 +0,0 @@
-Rails.configuration.serializers = []
-class HasOneRelationshipSerializer < ActiveModel::Serializer
-  attributes :id, :first_name, :last_name
-
-  has_many :primary_resources, embed: :ids
-  has_one :bio
-end
-Rails.configuration.serializers << HasOneRelationshipSerializer
-
-class VirtualAttributeSerializer < ActiveModel::Serializer
-  attributes :id, :name
-end
-Rails.configuration.serializers << VirtualAttributeSerializer
-
-class HasManyRelationshipSerializer < ActiveModel::Serializer
-  attributes :id, :body
-
-  belongs_to :primary_resource
-  belongs_to :has_one_relationship
-end
-Rails.configuration.serializers << HasManyRelationshipSerializer
-
-class PrimaryResourceSerializer < ActiveModel::Serializer
-  attributes :id, :title, :body
-
-  has_many :has_many_relationships, serializer: HasManyRelationshipSerializer
-  belongs_to :virtual_attribute, serializer: VirtualAttributeSerializer
-  belongs_to :has_one_relationship, serializer: HasOneRelationshipSerializer
-
-  link(:primary_resource_has_one_relationships) { 'https://example.com/primary_resource_has_one_relationships' }
-
-  meta do
-    {
-      rating: 5,
-      favorite_count: 10
-    }
-  end
-
-  def virtual_attribute
-    VirtualAttribute.new(id: 999, name: 'Free-Range Virtual Attribute')
-  end
-end
-Rails.configuration.serializers << PrimaryResourceSerializer
-
-class CachingHasOneRelationshipSerializer < HasOneRelationshipSerializer
-  cache key: 'writer', skip_digest: true
-end
-Rails.configuration.serializers << CachingHasOneRelationshipSerializer
-
-class CachingHasManyRelationshipSerializer < HasManyRelationshipSerializer
-  cache expires_in: 1.day, skip_digest: true
-end
-Rails.configuration.serializers << CachingHasManyRelationshipSerializer
-
-# see https://github.com/rails-api/active_model_serializers/pull/1690/commits/68715b8f99bc29677e8a47bb3f305f23c077024b#r60344532
-class CachingPrimaryResourceSerializer < ActiveModel::Serializer
-  cache key: 'primary_resource', expires_in: 0.1, skip_digest: true
-
-  attributes :id, :title, :body
-
-  belongs_to :virtual_attribute, serializer: VirtualAttributeSerializer
-  belongs_to :has_one_relationship, serializer: CachingHasOneRelationshipSerializer
-  has_many :has_many_relationships, serializer: CachingHasManyRelationshipSerializer
-
-  link(:primary_resource_has_one_relationships) { 'https://example.com/primary_resource_has_one_relationships' }
-
-  meta do
-    {
-      rating: 5,
-      favorite_count: 10
-    }
-  end
-
-  def virtual_attribute
-    VirtualAttribute.new(id: 999, name: 'Free-Range Virtual Attribute')
-  end
-end
-Rails.configuration.serializers << CachingPrimaryResourceSerializer
-
-class FragmentCachingHasOneRelationshipSerializer < HasOneRelationshipSerializer
-  cache key: 'writer', only: [:first_name, :last_name], skip_digest: true
-end
-Rails.configuration.serializers << FragmentCachingHasOneRelationshipSerializer
-
-class FragmentCachingHasManyRelationshipSerializer < HasManyRelationshipSerializer
-  cache expires_in: 1.day, except: [:body], skip_digest: true
-end
-Rails.configuration.serializers << CachingHasManyRelationshipSerializer
-
-# see https://github.com/rails-api/active_model_serializers/pull/1690/commits/68715b8f99bc29677e8a47bb3f305f23c077024b#r60344532
-class FragmentCachingPrimaryResourceSerializer < ActiveModel::Serializer
-  cache key: 'primary_resource', expires_in: 0.1, skip_digest: true
-
-  attributes :id, :title, :body
-
-  belongs_to :virtual_attribute, serializer: VirtualAttributeSerializer
-  belongs_to :has_one_relationship, serializer: FragmentCachingHasOneRelationshipSerializer
-  has_many :has_many_relationships, serializer: FragmentCachingHasManyRelationshipSerializer
-
-  link(:primary_resource_has_one_relationships) { 'https://example.com/primary_resource_has_one_relationships' }
-
-  meta do
-    {
-      rating: 5,
-      favorite_count: 10
-    }
-  end
-
-  def virtual_attribute
-    VirtualAttribute.new(id: 999, name: 'Free-Range Virtual Attribute')
-  end
-end
-Rails.configuration.serializers << FragmentCachingPrimaryResourceSerializer
-
-if ENV['ENABLE_ACTIVE_RECORD'] == 'true'
-  require 'active_record'
-
-  ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
-  ActiveRecord::Schema.define do
-    self.verbose = false
-
-    create_table :virtual_attributes, force: true do |t|
-      t.string :name
-      t.timestamps null: false
-    end
-    create_table :has_one_relationships, force: true do |t|
-      t.string :first_name
-      t.string :last_name
-      t.timestamps null: false
-    end
-    create_table :primary_resources, force: true do |t|
-      t.string :title
-      t.text :body
-      t.references :has_one_relationship
-      t.references :virtual_attribute
-      t.timestamps null: false
-    end
-    create_table :has_many_relationships, force: true do |t|
-      t.text :body
-      t.references :has_one_relationship
-      t.references :primary_resource
-      t.timestamps null: false
-    end
-  end
-
-  class HasManyRelationship < ActiveRecord::Base
-    belongs_to :has_one_relationship
-    belongs_to :primary_resource
-  end
-
-  class HasOneRelationship < ActiveRecord::Base
-    has_many :primary_resources
-    has_many :has_many_relationships
-  end
-
-  class PrimaryResource < ActiveRecord::Base
-    has_many :has_many_relationships
-    belongs_to :has_one_relationship
-    belongs_to :virtual_attribute
-  end
-
-  class VirtualAttribute < ActiveRecord::Base
-    has_many :primary_resources
-  end
-else
-  # ActiveModelSerializers::Model is a convenient
-  # serializable class to inherit from when making
-  # serializable non-activerecord objects.
-  class BenchmarkModel
-    include ActiveModel::Model
-    include ActiveModel::Serializers::JSON
-
-    attr_reader :attributes
-
-    def initialize(attributes = {})
-      @attributes = attributes
-      super
-    end
-
-    # Defaults to the downcased model name.
-    def id
-      attributes.fetch(:id) { self.class.name.downcase }
-    end
-
-    # Defaults to the downcased model name and updated_at
-    def cache_key
-      attributes.fetch(:cache_key) { "#{self.class.name.downcase}/#{id}" }
-    end
-
-    # Defaults to the time the serializer file was modified.
-    def updated_at
-      @updated_at ||= attributes.fetch(:updated_at) { File.mtime(__FILE__) }
-    end
-
-    def read_attribute_for_serialization(key)
-      if key == :id || key == 'id'
-        attributes.fetch(key) { id }
-      else
-        attributes[key]
-      end
-    end
-  end
-
-  class HasManyRelationship < BenchmarkModel
-    attr_accessor :id, :body
-  end
-
-  class HasOneRelationship < BenchmarkModel
-    attr_accessor :id, :first_name, :last_name, :primary_resources
-  end
-
-  class PrimaryResource < BenchmarkModel
-    attr_accessor :id, :title, :body, :has_many_relationships, :virtual_attribute, :has_one_relationship
-  end
-
-  class VirtualAttribute < BenchmarkModel
-    attr_accessor :id, :name
-  end
-end