active_model_serializers 0.10.6 → 0.10.13

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