panko_serializer 0.8.4 → 0.8.5

data/benchmarks/BENCHMARKS.md

@@ -1,48 +0,0 @@
-## Initial state
-```
-Native_Posts_2300             57 ip/s      13802 allocs/op
-Native_Posts_50     2956 ip/s        302 allocs/op
-
-AMS_Simple_Posts_2300         21 ip/s      94309 allocs/op
-AMS_Simple_Posts_50         1008 ip/s       2059 allocs/op
-AMS_HasOne_Posts_2300          9 ip/s     147209 allocs/op
-AMS_HasOne_Posts_50          451 ip/s       3209 allocs/op
-
-Panko_HasOne_Posts_2300      164 ip/s       2372 allocs/op
-Panko_HasOne_Posts_50       6118 ip/s        122 allocs/op
-Panko_Reused_HasOne_Posts_2300       178 ip/s       2303 allocs/op
-Panko_Reused_HasOne_Posts_50        8203 ip/s         53 allocs/op
-
-Panko_Simple_Posts_2300      150 ip/s       2372 allocs/op
-Panko_Simple_Posts_50       5639 ip/s        122 allocs/op
-Panko_Reused_Simple_Posts_2300       180 ip/s       2303 allocs/op
-Panko_Reused_Simple_Posts_50        8388 ip/s         53 allocs/op
-```
-
-## Refactorings, method call support, combining
-
-### class eval
-```
-Panko_HasOne_Posts_2300       64 ip/s       9477 allocs/op
-Panko_HasOne_Posts_50       2397 ip/s        477 allocs/op
-Panko_Reused_HasOne_Posts_2300        70 ip/s       9423 allocs/op
-Panko_Reused_HasOne_Posts_50        2596 ip/s        423 allocs/op
-
-Panko_Simple_Posts_2300      191 ip/s       2472 allocs/op
-Panko_Simple_Posts_50       5128 ip/s        222 allocs/op
-Panko_Reused_Simple_Posts_2300       180 ip/s       2418 allocs/op
-Panko_Reused_Simple_Posts_50        5534 ip/s        168 allocs/op
-```
-
-### instance eval
-```
-Panko_HasOne_Posts_2300       60 ip/s       9473 allocs/op
-Panko_HasOne_Posts_50       2399 ip/s        473 allocs/op
-Panko_Reused_HasOne_Posts_2300        66 ip/s       9419 allocs/op
-Panko_Reused_HasOne_Posts_50        2582 ip/s        419 allocs/op
-
-Panko_Simple_Posts_2300      195 ip/s       2470 allocs/op
-Panko_Simple_Posts_50       4838 ip/s        220 allocs/op
-Panko_Reused_Simple_Posts_2300       196 ip/s       2416 allocs/op
-Panko_Reused_Simple_Posts_50        6241 ip/s        166 allocs/op
-```

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