panko_serializer 0.1.1

data/benchmarks/profile.rb

@@ -0,0 +1,88 @@
+# 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".freeze] = "application/json".freeze
+
+    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(&block)
+  mem = MemoryProfiler.report(&block)
+  mem.pretty_print
+end
+
+memory { request(:get, "/serialize_to_stream") }

data/benchmarks/sanity.rb

@@ -0,0 +1,67 @@
+# 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 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 = {})
+  data = Benchmark.data
+  posts = data[:all]
+  posts_50 = data[:small]
+
+  merged_options = options.merge(each_serializer: serializer)
+
+  Benchmark.ams("Panko_#{prefix}_Posts_#{posts.count}") do
+    Panko::ArraySerializer.new(posts, merged_options).to_json
+  end
+
+  data = Benchmark.data
+  posts = data[:all]
+  posts_50 = data[:small]
+
+  Benchmark.ams("Panko_#{prefix}_Posts_50") do
+    Panko::ArraySerializer.new(posts_50, merged_options).to_json
+  end
+end
+
+#puts "Waiting .. #{Process.pid}"
+#gets.chomp
+
+#puts "Starting!"
+
+benchmark 'SimpleWithMethodCall', PostFastWithMethodCallSerializer
+benchmark "HasOne", PostWithHasOneFastSerializer
+benchmark "Simple", PostFastSerializer
+
+# benchmark 'SimpleWithMethodCall', PostFastWithMethodCallSerializer
+# benchmark 'Except', PostWithHasOneFastSerializer, except: [:title]
+# benchmark 'Include', PostWithHasOneFastSerializer, include: [:id, :body, :author_id, :author]

data/benchmarks/setup.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+###########################################
+# 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
+    t.timestamps(null: false)
+  end
+
+  create_table :posts, force: true do |t|
+    t.text :body
+    t.string :title
+    t.references :author
+    t.timestamps(null: false)
+  end
+
+  create_table :profiles, force: true do |t|
+    t.text :project_url
+    t.text :bio
+    t.date :birthday
+    t.references :author
+    t.timestamps(null: false)
+  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
+Post.transaction do
+  ENV.fetch("ITEMS_COUNT", "2300").to_i.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.create(name: "Preston Sego")
+    )
+  end
+end

data/benchmarks/type_casts/bm_active_record.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+require_relative "./support"
+
+def ar_type_convert(type_klass, from, to)
+  converter = type_klass.new
+  assert type_klass.name, converter.type_cast_from_database(from), to
+
+  Benchmark.ams("#{type_klass.name}_TypeCast") do
+    converter.type_cast_from_database(from)
+  end
+
+  Benchmark.ams("#{type_klass.name}_NoTypeCast") do
+    converter.type_cast_from_database(to)
+  end
+end
+
+def utc_ar_time
+	date = DateTime.new(2017, 3, 4, 12, 45, 23)
+	tz = ActiveSupport::TimeZone.new("UTC")
+	from = date.in_time_zone(tz).iso8601
+
+  type = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::DateTime.new
+  converter = ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter.new(type)
+
+  Benchmark.ams("#{tz}_#{type.class.name}_TypeCast") do
+    converter.type_cast_from_database(from).iso8601
+  end
+end
+
+
+
+def db_ar_time
+  type = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::DateTime.new
+  converter = ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter.new(type)
+
+  from = "2017-07-10 09:26:40.937392"
+
+  Benchmark.ams("ActiveRecord_Time_TypeCast_WithISO8601") do
+    converter.type_cast_from_database(from).iso8601
+  end
+end
+
+ar_type_convert ActiveRecord::Type::String, 1, "1"
+ar_type_convert ActiveRecord::Type::Text, 1, "1"
+ar_type_convert ActiveRecord::Type::Integer, "1", 1
+ar_type_convert ActiveRecord::Type::Float, "1.23", 1.23
+ar_type_convert ActiveRecord::Type::Float, "Infinity", 0.0
+ar_type_convert ActiveRecord::Type::Boolean, "true", true
+ar_type_convert ActiveRecord::Type::Boolean, "t", true
+
+ar_type_convert ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Integer, "1", 1
+ar_type_convert ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Float, "1.23", 1.23
+ar_type_convert ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Float, "Infinity", ::Float::INFINITY
+ar_type_convert ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Json, '{"a":1}', {a:1}
+
+db_ar_time
+utc_ar_time

data/benchmarks/type_casts/bm_panko.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+require_relative "./support"
+
+def panko_type_convert(type_klass, from, to)
+  converter = type_klass.new
+  assert "#{type_klass.name}", Panko::_type_cast(converter, from), to
+
+  Benchmark.ams("#{type_klass.name}_TypeCast") do
+    Panko::_type_cast(converter, from)
+  end
+
+  Benchmark.ams("#{type_klass.name}_NoTypeCast") do
+    Panko::_type_cast(converter, to)
+  end
+end
+
+
+def utc_panko_time
+	date = DateTime.new(2017, 3, 4, 12, 45, 23)
+	tz = ActiveSupport::TimeZone.new("UTC")
+	from = date.in_time_zone(tz).iso8601
+
+  type = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::DateTime.new
+  converter = ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter.new(type)
+
+  to = Panko::_type_cast(converter, from)
+
+  Benchmark.ams("#{tz}_#{type.class.name}_TypeCast") do
+    Panko::_type_cast(converter, from)
+  end
+
+  Benchmark.ams("#{tz}_#{type.class.name}_NoTypeCast") do
+    Panko::_type_cast(converter, to)
+  end
+end
+
+def db_panko_time
+  type = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::DateTime.new
+  converter = ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter.new(type)
+
+  from = "2017-07-10 09:26:40.937392"
+
+  Benchmark.ams("Panko_Time_TypeCast") do
+		Panko::_type_cast(converter, from)
+  end
+end
+
+db_panko_time
+utc_panko_time
+
+exit
+
+panko_type_convert ActiveRecord::Type::String, 1, "1"
+panko_type_convert ActiveRecord::Type::Text, 1, "1"
+panko_type_convert ActiveRecord::Type::Integer, "1", 1
+panko_type_convert ActiveRecord::Type::Float, "1.23", 1.23
+panko_type_convert ActiveRecord::Type::Float, "Infinity", ::Float::INFINITY
+panko_type_convert ActiveRecord::Type::Boolean, "true", true
+panko_type_convert ActiveRecord::Type::Boolean, "t", true
+
+panko_type_convert ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Integer, "1", 1
+panko_type_convert ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Float, "1.23", 1.23
+panko_type_convert ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Float, "Infinity", ::Float::INFINITY
+
+panko_type_convert ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Json, '{"a":1}', {a:1}
+db_panko_time
+utc_panko_time

data/benchmarks/type_casts/bm_pg.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+require_relative "./support"
+
+def pg_type_convert(type_klass, from, to)
+  converter = type_klass.new
+  assert type_klass.name, converter.decode(from), to
+
+  Benchmark.ams("#{type_klass.name}_TypeCast") do
+    converter.decode(from)
+  end
+end
+
+def pg_time
+  decoder = PG::TextDecoder::TimestampWithoutTimeZone.new
+
+  from = "2017-07-10 09:26:40.937392"
+
+  Benchmark.ams("#{decoder.class.name}_TypeCast") do
+    decoder.decode(from)
+  end
+
+  Benchmark.ams("#{decoder.class.name}_TypeCast_InTimeZone") do
+    decoder.decode(from).in_time_zone
+  end
+end
+
+
+
+
+pg_type_convert PG::TextDecoder::Integer, "1", 1
+pg_type_convert PG::TextDecoder::Float, "1.23", 1.23
+pg_type_convert PG::TextDecoder::Float, "Infinity", ::Float::INFINITY
+pg_type_convert PG::TextDecoder::Float, "-Infinity", ::Float::INFINITY
+pg_type_convert PG::TextDecoder::Float, "NaN", ::Float::NaN
+pg_time

data/benchmarks/type_casts/support.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+require "active_record"
+require "active_record/connection_adapters/postgresql_adapter"
+require "active_model"
+require "active_support/all"
+require "pg"
+
+
+require_relative "../benchmarking_support"
+require_relative "../../lib/panko/panko"
+
+def assert(type_name, from, to)
+  raise "#{type_name} - #{from.class} is not equals to #{to.class}" unless from.to_json == to.to_json
+end
+
+Time.zone = "UTC"

data/ext/panko_serializer/attributes_iterator.c

@@ -0,0 +1,62 @@
+#include "attributes_iterator.h"
+
+static ID attributes_id = 0;
+static ID types_id = 0;
+static ID values_id = 0;
+
+VALUE read_attributes(VALUE obj) {
+  return rb_ivar_get(obj, attributes_id);
+}
+
+VALUE panko_read_lazy_attributes_hash(VALUE object) {
+  VALUE attributes_set = read_attributes(object);
+  if (attributes_set == Qnil) {
+    return Qnil;
+  }
+
+  VALUE attributes_hash = read_attributes(attributes_set);
+  if (attributes_hash == Qnil) {
+    return Qnil;
+  }
+
+  return attributes_hash;
+}
+
+void panko_read_types_and_value(VALUE attributes_hash,
+                                VALUE* types,
+                                VALUE* values) {
+  *types = rb_ivar_get(attributes_hash, types_id);
+  *values = rb_ivar_get(attributes_hash, values_id);
+}
+
+VALUE panko_each_attribute(VALUE obj,
+                           SerializationDescriptor descriptor,
+                           VALUE attributes,
+                           EachAttributeFunc func,
+                           VALUE context) {
+  VALUE attributes_hash = panko_read_lazy_attributes_hash(obj);
+  if(attributes_hash == Qnil) {
+    return Qnil;
+  }
+
+  VALUE types, values;
+  panko_read_types_and_value(attributes_hash, &types, &values);
+
+  int i;
+  for (i = 0; i < RARRAY_LEN(attributes); i++) {
+    VALUE member = rb_sym2str(RARRAY_AREF(attributes, i));
+
+    VALUE value = rb_hash_aref(values, member);
+    VALUE type_metadata = rb_hash_aref(types, member);
+
+    func(obj, member, value, type_metadata, context);
+  }
+
+  return Qnil;
+}
+
+void panko_init_attributes_iterator(VALUE mPanko) {
+  attributes_id = rb_intern("@attributes");
+  values_id = rb_intern("@values");
+  types_id = rb_intern("@types");
+}

data/ext/panko_serializer/attributes_iterator.h

@@ -0,0 +1,17 @@
+#include <ruby.h>
+
+#include "serialization_descriptor.h"
+
+typedef void (*EachAttributeFunc)(VALUE object,
+                                  VALUE name,
+                                  VALUE value,
+                                  VALUE type_metadata,
+                                  VALUE context);
+
+extern VALUE panko_each_attribute(VALUE object,
+                                  SerializationDescriptor descriptor,
+                                  VALUE attributes,
+                                  EachAttributeFunc func,
+                                  VALUE context);
+
+void panko_init_attributes_iterator(VALUE mPanko);

data/ext/panko_serializer/extconf.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+require "mkmf"
+
+$CPPFLAGS += " -Wall"
+
+extension_name = "panko_serializer"
+dir_config(extension_name)
+create_makefile("panko_serializer/panko_serializer")

data/ext/panko_serializer/panko_serializer.c

@@ -0,0 +1,189 @@
+#include <ruby.h>
+
+#include "panko_serializer.h"
+
+static ID push_value_id = 0;
+static ID push_array_id = 0;
+static ID push_object_id = 0;
+static ID pop_id = 0;
+
+static ID to_a_id = 0;
+
+void write_value(VALUE str_writer,
+                 VALUE key,
+                 VALUE value,
+                 VALUE type_metadata) {
+  if (type_metadata != Qnil) {
+    value = type_cast(type_metadata, value);
+  }
+
+  rb_funcall(str_writer, push_value_id, 2, value, key);
+}
+
+void serialize_method_fields(VALUE subject,
+                             VALUE str_writer,
+                             SerializationDescriptor descriptor,
+                             VALUE context) {
+  VALUE method_fields = descriptor->method_fields;
+  if (RARRAY_LEN(method_fields) == 0) {
+    return;
+  }
+
+  VALUE serializer = sd_build_serializer(descriptor);
+  sd_apply_serializer_config(serializer, subject, context);
+
+  long i;
+  for (i = 0; i < RARRAY_LEN(method_fields); i++) {
+    VALUE attribute_name = RARRAY_AREF(method_fields, i);
+    VALUE result = rb_funcall(serializer, rb_sym2id(attribute_name), 0);
+
+    write_value(str_writer, rb_sym2str(attribute_name), result, Qnil);
+  }
+}
+
+void panko_attributes_iter(VALUE object,
+                           VALUE name,
+                           VALUE value,
+                           VALUE type_metadata,
+                           VALUE context) {
+  write_value(context, name, value, type_metadata);
+}
+
+void serialize_fields(VALUE subject,
+                      VALUE str_writer,
+                      SerializationDescriptor descriptor,
+                      VALUE context) {
+  panko_each_attribute(subject, descriptor, descriptor->fields,
+                       panko_attributes_iter, str_writer);
+
+  serialize_method_fields(subject, str_writer, descriptor, context);
+}
+
+void serialize_has_one_associatoins(VALUE subject,
+                                    VALUE str_writer,
+                                    VALUE context,
+                                    SerializationDescriptor descriptor,
+                                    VALUE associations) {
+  long i;
+  for (i = 0; i < RARRAY_LEN(associations); i++) {
+    VALUE association = RARRAY_AREF(associations, i);
+
+    VALUE name = RARRAY_AREF(association, 0);
+    VALUE association_descriptor = RARRAY_AREF(association, 1);
+    VALUE value = rb_funcall(subject, rb_sym2id(name), 0);
+
+    if (value == Qnil) {
+      write_value(str_writer, rb_sym2str(name), value, Qnil);
+    } else {
+      serialize_subject(rb_sym2str(name), value, str_writer,
+                        sd_read(association_descriptor), context);
+    }
+  }
+}
+
+void serialize_has_many_associatoins(VALUE subject,
+                                     VALUE str_writer,
+                                     VALUE context,
+                                     SerializationDescriptor descriptor,
+                                     VALUE associations) {
+  long i;
+  for (i = 0; i < RARRAY_LEN(associations); i++) {
+    VALUE association = RARRAY_AREF(associations, i);
+
+    VALUE name = RARRAY_AREF(association, 0);
+    VALUE association_descriptor = RARRAY_AREF(association, 1);
+    VALUE value = rb_funcall(subject, rb_sym2id(name), 0);
+
+    if (value == Qnil) {
+      write_value(str_writer, rb_sym2str(name), value, Qnil);
+    } else {
+      serialize_subjects(rb_sym2str(name), value, str_writer,
+                         sd_read(association_descriptor), context);
+    }
+  }
+}
+
+VALUE serialize_subject(VALUE key,
+                        VALUE subject,
+                        VALUE str_writer,
+                        SerializationDescriptor descriptor,
+                        VALUE context) {
+  rb_funcall(str_writer, push_object_id, 1, key);
+
+  serialize_fields(subject, str_writer, descriptor, context);
+
+  if (RARRAY_LEN(descriptor->has_one_associations) >= 0) {
+    serialize_has_one_associatoins(subject, str_writer, context, descriptor,
+                                   descriptor->has_one_associations);
+  }
+
+  if (RARRAY_LEN(descriptor->has_many_associations) >= 0) {
+    serialize_has_many_associatoins(subject, str_writer, context, descriptor,
+                                    descriptor->has_many_associations);
+  }
+
+  rb_funcall(str_writer, pop_id, 0);
+
+  return Qnil;
+}
+
+VALUE serialize_subjects(VALUE key,
+                         VALUE subjects,
+                         VALUE str_writer,
+                         SerializationDescriptor descriptor,
+                         VALUE context) {
+  rb_funcall(str_writer, push_array_id, 1, key);
+
+  if (!RB_TYPE_P(subjects, T_ARRAY)) {
+    subjects = rb_funcall(subjects, to_a_id, 0);
+  }
+
+  long i;
+  for (i = 0; i < RARRAY_LEN(subjects); i++) {
+    VALUE subject = RARRAY_AREF(subjects, i);
+    serialize_subject(Qnil, subject, str_writer, descriptor, context);
+  }
+
+  rb_funcall(str_writer, pop_id, 0);
+
+  return Qnil;
+}
+
+VALUE serialize_subject_api(VALUE klass,
+                            VALUE subject,
+                            VALUE str_writer,
+                            VALUE descriptor,
+                            VALUE context) {
+  return serialize_subject(Qnil, subject, str_writer, sd_read(descriptor),
+                           context);
+}
+
+VALUE serialize_subjects_api(VALUE klass,
+                             VALUE subjects,
+                             VALUE str_writer,
+                             VALUE descriptor,
+                             VALUE context) {
+  serialize_subjects(Qnil, subjects, str_writer, sd_read(descriptor), context);
+
+  return Qnil;
+}
+
+void Init_panko_serializer() {
+  CONST_ID(push_value_id, "push_value");
+  CONST_ID(push_array_id, "push_array");
+  CONST_ID(push_object_id, "push_object");
+  CONST_ID(pop_id, "pop");
+  CONST_ID(to_a_id, "to_a");
+
+  VALUE mPanko = rb_define_module("Panko");
+
+  rb_define_singleton_method(mPanko, "serialize_subject", serialize_subject_api,
+                             4);
+
+  rb_define_singleton_method(mPanko, "serialize_subjects",
+                             serialize_subjects_api, 4);
+
+  panko_init_serialization_descriptor(mPanko);
+  panko_init_attributes_iterator(mPanko);
+  panko_init_type_cast(mPanko);
+}

data/ext/panko_serializer/panko_serializer.h

@@ -0,0 +1,17 @@
+#include <ruby.h>
+
+#include "serialization_descriptor.h"
+#include "attributes_iterator.h"
+#include "type_cast.h"
+
+VALUE serialize_subject(VALUE key,
+                        VALUE subject,
+                        VALUE str_writer,
+                        SerializationDescriptor descriptor,
+                        VALUE context);
+
+VALUE serialize_subjects(VALUE key,
+                         VALUE subjects,
+                         VALUE str_writer,
+                         SerializationDescriptor descriptor,
+                         VALUE context);