panko_serializer 0.8.4 → 1.0.0

data/benchmarks/allocs.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "benchmarking_support"
-require_relative "app"
-require_relative "setup"
-
-require "memory_profiler"
-
-class PostFastSerializer < Panko::Serializer
-  attributes :id, :body, :title, :author_id
-end
-
-def count_allocs(&)
-  memory_report = MemoryProfiler.report(&)
-  puts memory_report.pretty_print
-end
-
-posts = Post.all.to_a
-merged_options = {}.merge(each_serializer: PostFastSerializer)
-posts_array_serializer = Panko::ArraySerializer.new([], merged_options)
-
-# prints out 18402
-count_allocs { posts_array_serializer.serialize_to_json posts }

data/benchmarks/app.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/setup"
-
-require "active_model"
-require "active_record"
-require "active_support"
-require "active_support/json"
-
-require "active_model_serializers"
-require "panko_serializer"

data/benchmarks/benchmarking_support.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require "benchmark/ips"
-require "json"
-require "memory_profiler"
-
-module Benchmark
-  module Runner
-    def data
-      posts = Post.all.includes(:author).to_a
-      posts_50 = posts.first(50).to_a
-      posts_single = posts.first(1).to_a
-      {all: posts, small: posts_50, single: posts_single}
-    end
-
-    def run(label = nil, time: 10, disable_gc: true, warmup: 3, &block)
-      fail ArgumentError.new, "block should be passed" unless block
-
-      GC.start
-
-      if disable_gc
-        GC.disable
-      else
-        GC.enable
-      end
-
-      memory_report = MemoryProfiler.report(&block)
-
-      report = Benchmark.ips(time, warmup, true) do |x|
-        x.report(label) { yield }
-      end
-
-      results = {
-        label: label,
-        ips: ActiveSupport::NumberHelper.number_to_delimited(report.entries.first.ips.round(2)),
-        allocs: "#{memory_report.total_allocated}/#{memory_report.total_retained}"
-      }.to_json
-
-      puts results
-    end
-  end
-
-  extend Benchmark::Runner
-end

data/benchmarks/bm_ams_0_10.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "benchmarking_support"
-require_relative "app"
-require_relative "setup"
-
-# disable logging for benchmarks
-ActiveModelSerializers.logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(File::NULL))
-
-class AmsAuthorFastSerializer < ActiveModel::Serializer
-  attributes :id, :name
-end
-
-class AmsPostFastSerializer < ActiveModel::Serializer
-  attributes :id, :body, :title, :author_id, :created_at
-end
-
-class AmsPostWithHasOneFastSerializer < ActiveModel::Serializer
-  attributes :id, :body, :title, :author_id
-
-  has_one :author, serializer: AmsAuthorFastSerializer
-end
-
-def benchmark_ams(prefix, serializer, options = {})
-  merged_options = options.merge(each_serializer: serializer)
-
-  posts = Benchmark.data[:all]
-
-  Benchmark.run("AMS_#{prefix}_Posts_#{posts.count}") do
-    ActiveModelSerializers::SerializableResource.new(posts, merged_options).to_json
-  end
-
-  posts_50 = Benchmark.data[:small]
-
-  Benchmark.run("AMS_#{prefix}_Posts_50") do
-    ActiveModelSerializers::SerializableResource.new(posts_50, merged_options).to_json
-  end
-end
-
-benchmark_ams "Attributes_Simple", AmsPostFastSerializer
-benchmark_ams "Attributes_HasOne", AmsPostWithHasOneFastSerializer
-benchmark_ams "Attributes_Except", AmsPostWithHasOneFastSerializer, except: [:title]
-benchmark_ams "Attributes_Only", AmsPostWithHasOneFastSerializer, only: [:id, :body, :author_id, :author]

data/benchmarks/bm_object_writer.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "benchmarking_support"
-require_relative "app"
-
-Benchmark.run("ObjectWriter_OneProperty_PushValue") do
-  writer = Panko::ObjectWriter.new
-
-  writer.push_object
-  writer.push_value "value1", "key1"
-  writer.pop
-
-  writer.output
-end
-
-Benchmark.run("ObjectWriter_TwoProperty_PushValue") do
-  writer = Panko::ObjectWriter.new
-
-  writer.push_object
-  writer.push_value "value1", "key1"
-  writer.push_value "value2", "key2"
-  writer.pop
-
-  writer.output
-end
-
-Benchmark.run("ObjectWriter_OneProperty_PushValuePushKey") do
-  writer = Panko::ObjectWriter.new
-
-  writer.push_object
-  writer.push_key "key1"
-  writer.push_value "value1"
-  writer.pop
-
-  writer.output
-end
-
-Benchmark.run("ObjectWriter_TwoProperty_PushValuePushKey") do
-  writer = Panko::ObjectWriter.new
-
-  writer.push_object
-  writer.push_key "key1"
-  writer.push_value "value1"
-
-  writer.push_key "key2"
-  writer.push_value "value2"
-  writer.pop
-
-  writer.output
-end
-
-Benchmark.run("ObjectWriter_NestedObject") do
-  writer = Panko::ObjectWriter.new
-
-  writer.push_object
-  writer.push_value "value1", "key1"
-
-  writer.push_object "key2"
-  writer.push_value "value2", "key2"
-  writer.pop
-
-  writer.pop
-
-  writer.output
-end

data/benchmarks/bm_panko_json.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "benchmarking_support"
-require_relative "app"
-require_relative "setup"
-
-class AuthorFastSerializer < Panko::Serializer
-  attributes :id, :name
-end
-
-class PostFastSerializer < Panko::Serializer
-  attributes :id, :body, :title, :author_id, :created_at
-end
-
-class PostFastWithJsonSerializer < Panko::Serializer
-  attributes :id, :body, :title, :author_id, :created_at, :data
-end
-
-class PostFastWithMethodCallSerializer < Panko::Serializer
-  attributes :id, :body, :title, :author_id, :method_call
-
-  def method_call
-    object.id * 2
-  end
-end
-
-class PostWithHasOneFastSerializer < Panko::Serializer
-  attributes :id, :body, :title, :author_id
-
-  has_one :author, serializer: AuthorFastSerializer
-end
-
-class AuthorWithHasManyFastSerializer < Panko::Serializer
-  attributes :id, :name
-
-  has_many :posts, serializer: PostFastSerializer
-end
-
-def benchmark(prefix, serializer, options = {})
-  posts = Benchmark.data[:all]
-
-  merged_options = options.merge(each_serializer: serializer)
-
-  Benchmark.run("Panko_ActiveRecord_#{prefix}_Posts_#{posts.count}") do
-    Panko::ArraySerializer.new(posts, merged_options).to_json
-  end
-
-  posts_50 = Benchmark.data[:small]
-
-  Benchmark.run("Panko_ActiveRecord_#{prefix}_Posts_50") do
-    Panko::ArraySerializer.new(posts_50, merged_options).to_json
-  end
-end
-
-benchmark "Simple", PostFastSerializer
-benchmark "SimpleWithJson", PostFastWithJsonSerializer
-benchmark "HasOne", PostWithHasOneFastSerializer
-benchmark "SimpleWithMethodCall", PostFastWithMethodCallSerializer
-benchmark "Except", PostWithHasOneFastSerializer, except: [:title]
-benchmark "Only", PostWithHasOneFastSerializer, only: [:id, :body, :author_id, :author]

data/benchmarks/bm_panko_object.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "benchmarking_support"
-require_relative "app"
-require_relative "setup"
-
-class AuthorFastSerializer < Panko::Serializer
-  attributes :id, :name
-end
-
-class PostFastSerializer < Panko::Serializer
-  attributes :id, :body, :title, :author_id
-end
-
-class PostWithHasOneFastSerializer < Panko::Serializer
-  attributes :id, :body, :title, :author_id
-
-  has_one :author, serializer: AuthorFastSerializer
-end
-
-class AuthorWithHasManyFastSerializer < Panko::Serializer
-  attributes :id, :name
-
-  has_many :posts, serializer: PostFastSerializer
-end
-
-def benchmark(prefix, serializer, options = {})
-  posts = Benchmark.data[:all]
-
-  merged_options = options.merge(each_serializer: serializer)
-
-  Benchmark.run("Panko_ActiveRecord_#{prefix}_Posts_#{posts.count}") do
-    Panko::ArraySerializer.new(posts, merged_options).to_a
-  end
-
-  posts_50 = Benchmark.data[:small]
-
-  Benchmark.run("Panko_ActiveRecord_#{prefix}_Posts_50") do
-    Panko::ArraySerializer.new(posts_50, merged_options).to_a
-  end
-end
-
-benchmark "Simple", PostFastSerializer
-benchmark "HasOne", PostWithHasOneFastSerializer
-benchmark "Except", PostWithHasOneFastSerializer, except: [:title]
-benchmark "Only", PostWithHasOneFastSerializer, only: [:id, :body, :author_id, :author]

data/benchmarks/bm_plain_object.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "benchmarking_support"
-require_relative "app"
-
-class AuthorFastSerializer < Panko::Serializer
-  attributes :id, :name
-end
-
-class PostFastSerializer < Panko::Serializer
-  attributes :id, :body, :title, :author_id, :created_at
-end
-
-class PostFastWithMethodCallSerializer < Panko::Serializer
-  attributes :id, :body, :title, :author_id, :method_call
-
-  def method_call
-    object.id * 2
-  end
-end
-
-class PostWithHasOneFastSerializer < Panko::Serializer
-  attributes :id, :body, :title, :author_id
-
-  has_one :author, serializer: AuthorFastSerializer
-end
-
-class AuthorWithHasManyFastSerializer < Panko::Serializer
-  attributes :id, :name
-
-  has_many :posts, serializer: PostFastSerializer
-end
-
-class Post
-  attr_accessor :id, :body, :title, :created_at, :author_id
-  attr_reader :author
-
-  def self.create(attrs)
-    p = Post.new
-    attrs.each do |k, v|
-      p.send :"#{k}=", v
-    end
-    p
-  end
-
-  def author=(author)
-    @author = author
-    @author_id = author.id
-  end
-end
-
-class Author
-  attr_accessor :id, :name
-
-  def self.create(attrs)
-    a = Author.new
-    attrs.each do |k, v|
-      a.send :"#{k}=", v
-    end
-    a
-  end
-end
-
-def benchmark_data
-  posts = []
-  ENV.fetch("ITEMS_COUNT", "2300").to_i.times do |i|
-    posts << Post.create(
-      id: i,
-      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.create(id: i, name: "Preston Sego")
-    )
-  end
-
-  {all: posts, small: posts.first(50)}
-end
-
-def benchmark(prefix, serializer, options = {})
-  data = benchmark_data
-  posts = data[:all]
-
-  merged_options = options.merge(each_serializer: serializer)
-
-  Benchmark.run("Panko_Plain_#{prefix}_Posts_#{posts.count}") do
-    Panko::ArraySerializer.new(posts, merged_options).to_json
-  end
-
-  posts_50 = benchmark_data[:small]
-
-  Benchmark.run("Panko_Plain_#{prefix}_Posts_50") do
-    Panko::ArraySerializer.new(posts_50, merged_options).to_json
-  end
-end
-
-benchmark "Simple", PostFastSerializer
-benchmark "HasOne", PostWithHasOneFastSerializer
-benchmark "SimpleWithMethodCall", PostFastWithMethodCallSerializer
-benchmark "Except", PostWithHasOneFastSerializer, except: [:title]
-benchmark "Only", PostWithHasOneFastSerializer, only: [:id, :body, :author_id, :author]

data/benchmarks/bm_serialization_descriptor.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "benchmarking_support"
-require "active_support"
-
-require "panko_serializer"
-
-def generate_attributes(count)
-  (1..count).map { |i| :"attr_#{i}" }
-end
-
-class LeafASerializer < Panko::Serializer
-  attributes(*generate_attributes(5))
-end
-
-class LeafBSerializer < Panko::Serializer
-  attributes(*generate_attributes(6))
-end
-
-class ChildrenSerializer < Panko::Serializer
-  attributes(*generate_attributes(28))
-
-  has_one :leaf_a, serializer: LeafASerializer
-  has_one :leaf_b, serializer: LeafBSerializer
-
-  def attr_1
-  end
-
-  def attr_2
-  end
-
-  def attr_3
-  end
-
-  def attr_4
-  end
-
-  def attr_5
-  end
-end
-
-class ParentSerializer < Panko::Serializer
-  attributes(*generate_attributes(46))
-
-  has_many :children, serializer: ChildrenSerializer
-
-  def attr_1
-  end
-
-  def attr_2
-  end
-
-  def attr_3
-  end
-
-  def attr_4
-  end
-end
-
-attrs = generate_attributes(21)
-attrs << :children
-filters = {
-  instance: attrs,
-  children: generate_attributes(11)
-}
-Benchmark.run("NoFilters") do
-  Panko::SerializationDescriptor.build(ParentSerializer)
-end
-
-Benchmark.run("Attribute") do
-  Panko::SerializationDescriptor.build(ParentSerializer, only: [:children])
-end
-
-Benchmark.run("AssociationFilters") do
-  Panko::SerializationDescriptor.build(ParentSerializer, only: filters)
-end

data/benchmarks/bm_serializer_resolver.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "benchmarking_support"
-require_relative "app"
-
-class NotSerializer
-end
-
-class RealSerializer < Panko::Serializer
-end
-
-Benchmark.run("CantFindConst") do
-  Panko::SerializerResolver.resolve("cant_find_const", Object)
-end
-
-Benchmark.run("NotSerializer") do
-  Panko::SerializerResolver.resolve("not", Object)
-end
-
-Benchmark.run("RealSerializer") do
-  Panko::SerializerResolver.resolve("real", Object)
-end

data/benchmarks/bm_to_object.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "benchmarking_support"
-require_relative "app"
-require_relative "setup"
-
-class PostWithAliasModel < ActiveRecord::Base
-  self.table_name = "posts"
-
-  alias_attribute :new_id, :id
-  alias_attribute :new_body, :body
-  alias_attribute :new_title, :title
-  alias_attribute :new_author_id, :author_id
-  alias_attribute :new_created_at, :created_at
-end
-
-class PostWithAliasFastSerializer < Panko::Serializer
-  attributes :new_id, :new_body, :new_title, :new_author_id, :new_created_at
-end
-
-def benchmark_aliased(prefix, serializer, options = {})
-  posts = PostWithAliasModel.all.to_a
-  posts_50 = posts.first(50).to_a
-
-  merged_options = options.merge(each_serializer: serializer)
-
-  Benchmark.run("Panko_#{prefix}_PostWithAliasModels_#{posts.count}") do
-    Panko::ArraySerializer.new(posts, merged_options).to_json
-  end
-
-  Benchmark.run("Panko_#{prefix}_Posts_50") do
-    Panko::ArraySerializer.new(posts_50, merged_options).to_json
-  end
-end
-
-class AuthorFastSerializer < Panko::Serializer
-  attributes :id, :name
-end
-
-class PostFastSerializer < Panko::Serializer
-  attributes :id, :body, :title, :author_id, :created_at
-end
-
-class PostFastWithMethodCallSerializer < Panko::Serializer
-  attributes :id, :body, :title, :author_id, :created_at, :method_call
-
-  def method_call
-    object.id
-  end
-end
-
-class PostWithHasOneFastSerializer < Panko::Serializer
-  attributes :id, :body, :title, :author_id, :created_at
-
-  has_one :author, serializer: AuthorFastSerializer
-end
-
-class AuthorWithHasManyFastSerializer < Panko::Serializer
-  attributes :id, :name
-
-  has_many :posts, serializer: PostFastSerializer
-end
-
-def benchmark(prefix, serializer, options = {})
-  posts = Benchmark.data[:all]
-
-  merged_options = options.merge(each_serializer: serializer)
-
-  Benchmark.run("Panko_#{prefix}_Posts_#{posts.count}") do
-    Panko::ArraySerializer.new(posts, merged_options).to_a
-  end
-
-  posts_50 = Benchmark.data[:small]
-
-  Benchmark.run("Panko_#{prefix}_Posts_50") do
-    Panko::ArraySerializer.new(posts_50, merged_options).to_a
-  end
-end
-
-benchmark "Simple", PostFastSerializer
-benchmark "HasOne", PostWithHasOneFastSerializer

data/benchmarks/profile.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "benchmarking_support"
-require_relative "app"
-require_relative "setup"
-
-require "memory_profiler"
-
-class NullLogger < Logger
-  def initialize(*args)
-  end
-
-  def add(*args, &block)
-  end
-end
-
-class BenchmarkApp < Rails::Application
-  routes.append do
-    get "/simple" => "main#simple"
-    get "/text" => "main#text"
-
-    get "/serialize_to_string" => "main#serialize_to_string"
-    get "/serialize_to_stream" => "streaming#serialize_to_stream"
-  end
-
-  config.secret_token = "s" * 30
-  config.secret_key_base = "foo"
-  config.consider_all_requests_local = false
-
-  # simulate production
-  config.cache_classes = true
-  config.eager_load = true
-  config.action_controller.perform_caching = true
-
-  # otherwise deadlock occured
-  config.middleware.delete "Rack::Lock"
-
-  # to disable log files
-  config.logger = NullLogger.new
-  config.active_support.deprecation = :log
-end
-
-BenchmarkApp.initialize!
-
-class AuthorFastSerializer < Panko::Serializer
-  attributes :id, :name
-end
-
-class PostWithHasOneFastSerializer < Panko::Serializer
-  attributes :id, :body, :title, :author_id
-
-  has_one :author, serializer: AuthorFastSerializer
-end
-
-class StreamingController < ActionController::Base
-  include ActionController::Live
-
-  def serialize_to_stream
-    headers["Content-Type"] = "application/json"
-
-    data = Benchmark.data[:all]
-    serializer = Panko::ArraySerializer.new([], each_serializer: PostWithHasOneFastSerializer)
-    writer = Oj::StreamWriter.new(response.stream, mode: :rails)
-
-    serializer.serialize_to_writer(data, writer)
-
-    response.stream.close
-  end
-end
-
-class RouteNotFoundError < StandardError; end
-
-def request(method, path)
-  response = Rack::MockRequest.new(BenchmarkApp).send(method, path)
-  if response.status.in?([404, 500])
-    raise RouteNotFoundError.new, "not found #{method.to_s.upcase} #{path}"
-  end
-  response
-end
-
-def memory(&)
-  mem = MemoryProfiler.report(&)
-  mem.pretty_print
-end
-
-memory { request(:get, "/serialize_to_stream") }