panko_serializer 0.3.4 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2b1c0dbc2c75d9b48d7b2057ef66f2150702e86db83110e552ba8b99dfb7662
-  data.tar.gz: b980005c2670d69ba9093fd9aa4bee57f2f106eeedbccbd8739b64004591f62b
+  metadata.gz: 4504cdc0e66927014ebd2843a52e8cef9aa5d4443b2a2cc6c31342468ebdeb08
+  data.tar.gz: 83a6d226222bd9910addcaaf61f2c77ea131da5d0b33bcdf0ecda150d82df878
 SHA512:
-  metadata.gz: d27d528c54db62acffb611c5eba616f6346e410a78c9fe52835ccb5a60c4253e890f58dbc4aa6316f496db45fd1da7b4b79b4751fbd3898588b91efe715fb83e
-  data.tar.gz: ddf22bfc9d998fea61482a9e6ec71c460848401b7c922352f1c37395e717944c7cad77537133f90751a6cc9581e507cbb06d927af484f03bded9966a74e549e3
+  metadata.gz: 8bd4eab5358c889a895dc4ab48623eb5659572312879c5c64fccc5785e62f1cf2a9d576430cae4109937b8e61574a26273d3e9e3399dd92a03e7d60673593fce
+  data.tar.gz: f3c1994beb8627937db1827f5d5f07ba17d99809f40e752c8a3157bd38c66aa040d2db94722a14cd0643241405512be87ed6696ef5c3037283b3c930215e7709

data/.clang-format

@@ -29,10 +29,13 @@ BraceWrapping:
   AfterObjCDeclaration: false
   AfterStruct:     false
   AfterUnion:      false
+  AfterExternBlock: false
   BeforeCatch:     false
   BeforeElse:      false
   IndentBraces:    false
-  SplitEmptyFunctionBody: true
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
 BreakBeforeBinaryOperators: None
 BreakBeforeBraces: Attach
 BreakBeforeInheritanceComma: false
@@ -52,8 +55,13 @@ DerivePointerAlignment: false
 DisableFormat:   false
 ExperimentalAutoDetectBinPacking: false
 FixNamespaceComments: true
-ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
+ForEachMacros:   
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
 IncludeCategories: 
+  - Regex:           '^<ext/.*\.h>'
+    Priority:        2
   - Regex:           '^<.*\.h>'
     Priority:        1
   - Regex:           '^<.*'
@@ -62,6 +70,7 @@ IncludeCategories:
     Priority:        3
 IncludeIsMainRegex: '([-_](test|unittest))?$'
 IndentCaseLabels: true
+IndentPPDirectives: None
 IndentWidth:     2
 IndentWrappedFunctionNames: false
 JavaScriptQuotes: Leave
@@ -82,8 +91,13 @@ PenaltyBreakString: 1000
 PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 200
 PointerAlignment: Left
+RawStringFormats: 
+  - Delimiter:       pb
+    Language:        TextProto
+    BasedOnStyle:    google
 ReflowComments:  true
 SortIncludes:    true
+SortUsingDeclarations: true
 SpaceAfterCStyleCast: false
 SpaceAfterTemplateKeyword: true
 SpaceBeforeAssignmentOperators: true

data/.travis.yml

@@ -2,7 +2,7 @@ sudo: false
 cache: bundler
 language: ruby
 rvm:
-  - 2.4.2
+  - 2.5.0
 
 env:
   global:
@@ -23,5 +23,4 @@ after_success:
 env:
   matrix:
   - "RAILS_VERSION=4.2"
-  - "RAILS_VERSION=5.0"
   - "RAILS_VERSION=5.1"

data/Gemfile

@@ -3,7 +3,8 @@ source "https://rubygems.org"
 
 gemspec
 
-rails_version = "~> #{ENV.fetch("RAILS_VERSION", "4.2")}"
+raw_rails_version = ENV.fetch("RAILS_VERSION", "4.2")
+rails_version = "~> #{raw_rails_version}"
 
 gem "rails", rails_version
 gem "railties", rails_version
@@ -14,14 +15,15 @@ gem "activerecord", rails_version, group: :test
 
 group :benchmarks do
   gem "sqlite3"
-  gem "pg"
+  gem "pg", "0.21"
 
   gem "memory_profiler"
   gem "ruby-prof"
   gem "ruby-prof-flamegraph"
 
   gem "benchmark-ips"
-  gem "active_model_serializers", "0.9.7"
+  gem "active_model_serializers"
+  gem "fast_jsonapi" if raw_rails_version.start_with? "5"
 
   gem "terminal-table"
 end

data/Rakefile

@@ -4,6 +4,7 @@ require "rspec/core/rake_task"
 require "json"
 require "terminal-table"
 require "rake/extensiontask"
+require "pty"
 
 gem = Gem::Specification.load( File.dirname(__FILE__) + "/panko_serializer.gemspec" )
 
@@ -21,15 +22,40 @@ Rake::Task[:spec].prerequisites << :compile
 
 task default: :spec
 
+def print_and_flush(str)
+  print str
+  $stdout.flush
+end
+
+def run_process(cmd)
+  puts "> Running #{cmd}"
+  lines = []
+  PTY.spawn(cmd) do |stdout, stdin, pid|
+    begin
+      stdout.each do |line|
+        print_and_flush '.'
+        lines << line
+      end
+    rescue Errno::EIO
+      puts "Errno:EIO error, but this probably just means " +
+            "that the process has finished giving output - #{cmd}"
+    end
+  end
+
+  lines
+rescue PTY::ChildExited
+  puts "The child process exited! - #{cmd}"
+  []
+end
 
-def run_benchmarks(files, items_count: 14_000)
+def run_benchmarks(files, items_count: 7_000)
   headings = ["Benchmark", "ip/s", "allocs/retained"]
   files.each do |benchmark_file|
-    output = `ITEMS_COUNT=#{items_count} RAILS_ENV=production ruby #{benchmark_file}`
 
-    rows = output.each_line.map do |line|
-      result = JSON.parse(line)
-      result.values
+    lines = run_process "ITEMS_COUNT=#{items_count} RAILS_ENV=production ruby #{benchmark_file}"
+    rows = lines.map do |line|
+      row = JSON.parse(line)
+      row.values
     end
 
     puts "\n\n"

data/benchmarks/bm_ams_0_10.rb

@@ -0,0 +1,56 @@
+# 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('/dev/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)
+
+  data = Benchmark.data
+  posts = data[:all]
+  posts_50 = data[:small]
+
+
+  Benchmark.run("AMS_#{prefix}_Posts_#{posts.count}") do
+    ActiveModelSerializers::SerializableResource.new(posts, merged_options).to_json
+  end
+
+  data = Benchmark.data
+  posts = data[:all]
+  posts_50 = 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]
+
+ActiveModel::Serializer.config.adapter = :json_api
+
+benchmark_ams "JsonAPI_Simple", AmsPostFastSerializer
+benchmark_ams "JsonAPI_HasOne", AmsPostWithHasOneFastSerializer
+benchmark_ams "JsonAPI_Except", AmsPostWithHasOneFastSerializer, except: [:title]
+benchmark_ams "JsonAPI_Only", AmsPostWithHasOneFastSerializer, only: [:id, :body, :author_id, :author]

data/benchmarks/bm_fastjsonapi.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+exit unless ENV.fetch("RAILS_VERSION", "4.2").start_with? "5"
+
+require_relative "./benchmarking_support"
+require_relative "./app"
+require_relative "./setup"
+require 'fast_jsonapi'
+
+class AuthorSerializer
+  include FastJsonapi::ObjectSerializer
+  attributes :id, :name
+end
+
+
+class PostFastSerializer
+  include FastJsonapi::ObjectSerializer
+  attributes :id, :body, :title, :author_id, :created_at
+end
+
+class PostWithHasOneFastSerializer
+  include FastJsonapi::ObjectSerializer
+  attributes :id, :body, :title, :author_id
+
+  has_one :author
+end
+
+class AuthorWithHasManyFastSerializer
+  include FastJsonapi::ObjectSerializer
+  attributes :id, :name
+
+  has_many :posts, serializer: :post_fast
+end
+
+
+def benchmark(prefix, serializer, options = {})
+  data = Benchmark.data
+  posts = data[:all]
+  posts_50 = data[:small]
+
+  merged_options = options.merge(each_serializer: serializer)
+
+  Benchmark.run("FastJSONAPI_#{prefix}_Posts_#{posts.count}") do
+    serializer.new(posts, merged_options).serialized_json
+  end
+
+  data = Benchmark.data
+  posts = data[:all]
+  posts_50 = data[:small]
+
+  Benchmark.run("FastJSONAPI_#{prefix}_Posts_50") do
+    serializer.new(posts_50, merged_options).serialized_json
+  end
+end
+
+benchmark "Simple", PostFastSerializer
+benchmark "HasOne", PostWithHasOneFastSerializer, include: [:author]

data/benchmarks/bm_panko_json.rb

@@ -40,7 +40,7 @@ def benchmark(prefix, serializer, options = {})
 
   merged_options = options.merge(each_serializer: serializer)
 
-  Benchmark.run("Panko_#{prefix}_Posts_#{posts.count}") do
+  Benchmark.run("Panko_ActiveRecord_#{prefix}_Posts_#{posts.count}") do
     Panko::ArraySerializer.new(posts, merged_options).to_json
   end
 
@@ -48,13 +48,13 @@ def benchmark(prefix, serializer, options = {})
   posts = data[:all]
   posts_50 = data[:small]
 
-  Benchmark.run("Panko_#{prefix}_Posts_50") do
+  Benchmark.run("Panko_ActiveRecord_#{prefix}_Posts_50") do
     Panko::ArraySerializer.new(posts_50, merged_options).to_json
   end
 end
 
-benchmark "HasOne", PostWithHasOneFastSerializer
 benchmark "Simple", PostFastSerializer
+benchmark "HasOne", PostWithHasOneFastSerializer
 benchmark "SimpleWithMethodCall", PostFastWithMethodCallSerializer
 benchmark "Except", PostWithHasOneFastSerializer, except: [:title]
-benchmark "Include", PostWithHasOneFastSerializer, include: [:id, :body, :author_id, :author]
+benchmark "Only", PostWithHasOneFastSerializer, only: [:id, :body, :author_id, :author]

data/benchmarks/bm_panko_object.rb

@@ -32,7 +32,7 @@ def benchmark(prefix, serializer, options = {})
 
   merged_options = options.merge(each_serializer: serializer)
 
-  Benchmark.run("Panko_#{prefix}_Posts_#{posts.count}") do
+  Benchmark.run("Panko_ActiveRecord_#{prefix}_Posts_#{posts.count}") do
     Panko::ArraySerializer.new(posts, merged_options).to_a
   end
 
@@ -40,30 +40,12 @@ def benchmark(prefix, serializer, options = {})
   posts = data[:all]
   posts_50 = data[:small]
 
-  Benchmark.run("Panko_#{prefix}_Posts_50") do
+  Benchmark.run("Panko_ActiveRecord_#{prefix}_Posts_50") do
     Panko::ArraySerializer.new(posts_50, merged_options).to_a
   end
-
-  posts_array_serializer = Panko::ArraySerializer.new([], merged_options)
-
-  data = Benchmark.data
-  posts = data[:all]
-  posts_50 = data[:small]
-
-  Benchmark.run("Panko_Reused_#{prefix}_Posts_#{posts.count}") do
-    posts_array_serializer.serialize posts
-  end
-
-  data = Benchmark.data
-  posts = data[:all]
-  posts_50 = data[:small]
-
-  Benchmark.run("Panko_Reused_#{prefix}_Posts_50") do
-    posts_array_serializer.serialize posts_50
-  end
 end
 
-benchmark "HasOne", PostWithHasOneFastSerializer
 benchmark "Simple", PostFastSerializer
+benchmark "HasOne", PostWithHasOneFastSerializer
 benchmark "Except", PostWithHasOneFastSerializer, except: [:title]
-benchmark "Include", PostWithHasOneFastSerializer, include: [:id, :body, :author_id, :author]
+benchmark "Only", PostWithHasOneFastSerializer, only: [:id, :body, :author_id, :author]

data/benchmarks/bm_plain_object.rb

@@ -0,0 +1,102 @@
+# 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, :author_id
+
+  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]
+  posts_50 = data[:small]
+
+  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
+
+  data = benchmark_data
+  posts = data[:all]
+  posts_50 = 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/type_casts/bm_panko.rb

@@ -46,9 +46,6 @@ def db_panko_time
 end
 
 panko_type_convert ActiveRecord::Type::String, 1, "1"
-panko_type_convert ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Json, '{"a":1}', {a:1}
-exit
-
 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

data/docs/README.md

@@ -1,5 +1,5 @@
 * [Panko](../README.md)
-* [Getting Stated](getting-started.md)
+* [Getting Started](getting-started.md)
 * Reference
   * [Attributes](attributes.md)
   * [Associations](associations.md)

data/ext/panko_serializer/{attributes_iterator.c → attributes_writer/active_record.c}

@@ -1,4 +1,4 @@
-#include "attributes_iterator.h"
+#include "active_record.h"
 
 static ID attributes_id;
 static ID types_id;
@@ -139,10 +139,10 @@ VALUE read_attribute(struct attributes attributes_ctx, Attribute attribute) {
   return value;
 }
 
-VALUE panko_each_attribute(VALUE obj,
-                           VALUE attributes,
-                           EachAttributeFunc func,
-                           VALUE writer) {
+VALUE active_record_attributes_writer(VALUE obj,
+                                      VALUE attributes,
+                                      EachAttributeFunc func,
+                                      VALUE writer) {
   long i;
   struct attributes attributes_ctx = init_context(obj);
   volatile VALUE record_class = CLASS_OF(obj);
@@ -152,19 +152,15 @@ VALUE panko_each_attribute(VALUE obj,
     Attribute attribute = attribute_read(raw_attribute);
     attribute_try_invalidate(attribute, record_class);
 
-    volatile VALUE name_str = attribute->name_str;
-    if (attribute->alias_name != Qnil) {
-      name_str = attribute->alias_name;
-    }
-
     volatile VALUE value = read_attribute(attributes_ctx, attribute);
-    func(writer, name_str, value);
+
+    func(writer, attr_name_for_serialization(attribute), value);
   }
 
   return Qnil;
 }
 
-void panko_init_attributes_iterator(VALUE mPanko) {
+void init_active_record_attributes_writer(VALUE mPanko) {
   attributes_id = rb_intern("@attributes");
   delegate_hash_id = rb_intern("@delegate_hash");
   values_id = rb_intern("@values");

data/ext/panko_serializer/attributes_writer/active_record.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <ruby.h>
+#include <stdbool.h>
+
+#include "serialization_descriptor/attribute.h"
+#include "type_cast/type_cast.h"
+#include "common.h"
+
+extern VALUE active_record_attributes_writer(VALUE object,
+                                             VALUE attributes,
+                                             EachAttributeFunc func,
+                                             VALUE context);
+
+void init_active_record_attributes_writer(VALUE mPanko);

data/ext/panko_serializer/attributes_writer/common.c

@@ -0,0 +1,10 @@
+#include "common.h"
+
+VALUE attr_name_for_serialization(Attribute attribute) {
+  volatile VALUE name_str = attribute->name_str;
+  if (attribute->alias_name != Qnil) {
+    name_str = attribute->alias_name;
+  }
+
+  return name_str;
+}

data/ext/panko_serializer/attributes_writer/common.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include "../serialization_descriptor/attribute.h"
+#include "ruby.h"
+
+typedef void (*EachAttributeFunc)(VALUE writer, VALUE name, VALUE value);
+
+VALUE attr_name_for_serialization(Attribute attribute);

data/ext/panko_serializer/attributes_writer/plain.c

@@ -0,0 +1,17 @@
+#include "plain.h"
+
+VALUE plain_attributes_writer(VALUE obj,
+                              VALUE attributes,
+                              EachAttributeFunc func,
+                              VALUE writer) {
+  long i;
+  for (i = 0; i < RARRAY_LEN(attributes); i++) {
+    volatile VALUE raw_attribute = RARRAY_AREF(attributes, i);
+    Attribute attribute = attribute_read(raw_attribute);
+    volatile VALUE value = rb_funcall(obj, attribute->name_id, 0);
+
+    func(writer, attr_name_for_serialization(attribute), value);
+  }
+
+  return Qnil;
+}

data/ext/panko_serializer/attributes_writer/plain.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "common.h"
+#include "ruby.h"
+
+VALUE plain_attributes_writer(VALUE obj,
+                              VALUE attributes,
+                              EachAttributeFunc func,
+                              VALUE writer);

data/ext/panko_serializer/{time_conversion.h → attributes_writer/type_cast/time_conversion.h}

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <ruby.h>
 #include <ruby/oniguruma.h>
 

data/ext/panko_serializer/{type_cast.c → attributes_writer/type_cast/type_cast.c}

@@ -112,7 +112,8 @@ void cache_type_lookup() {
   ar_date_time_type = rb_const_get_at(ar_type, rb_intern("DateTime"));
 
   ar_type_methods = rb_class_instance_methods(0, NULL, ar_string_type);
-  if(rb_ary_includes(ar_type_methods, rb_to_symbol(rb_str_new_cstr("deserialize")))) {
+  if (rb_ary_includes(ar_type_methods,
+                      rb_to_symbol(rb_str_new_cstr("deserialize")))) {
     deserialize_from_db_id = rb_intern("deserialize");
   } else {
     deserialize_from_db_id = rb_intern("type_cast_from_database");

data/ext/panko_serializer/{type_cast.h → attributes_writer/type_cast/type_cast.h}

@@ -1,9 +1,8 @@
+#pragma once
+
 #include <ruby.h>
 #include <stdbool.h>
 
-#ifndef __PANKO_TYPE_CAST_H__
-#define __PANKO_TYPE_CAST_H__
-
 /*
  * Type Casting
  *
@@ -75,5 +74,3 @@ static struct _TypeCast type_casts[] = {
 
 extern VALUE type_cast(VALUE type_metadata, VALUE value);
 void panko_init_type_cast(VALUE mPanko);
-
-#endif

data/ext/panko_serializer/attributes_writer/writer.c

@@ -0,0 +1,50 @@
+#include "writer.h"
+
+static bool types_initialized = false;
+static VALUE ar_base_type = Qundef;
+
+void init_types(VALUE v) {
+  if (types_initialized == true) {
+    return;
+  }
+
+  types_initialized = true;
+
+  volatile VALUE ar_type =
+      rb_const_get_at(rb_cObject, rb_intern("ActiveRecord"));
+  ar_base_type = rb_const_get_at(ar_type, rb_intern("Base"));
+}
+
+AttributesWriter create_attributes_writer(VALUE subject) {
+  // If ActiveRecord::Base can't be found it will throw error
+  int isErrored;
+  rb_protect(init_types, Qnil, &isErrored);
+
+  if (ar_base_type != Qundef &&
+      rb_obj_is_kind_of(subject, ar_base_type) == Qtrue) {
+    return (AttributesWriter){
+        .object_type = ActiveRecord,
+        .write_attributes = active_record_attributes_writer};
+  } else {
+    return (AttributesWriter){.object_type = Plain,
+                              .write_attributes = plain_attributes_writer};
+  }
+
+  return create_empty_attributes_writer();
+}
+
+VALUE empty_write_attributes(VALUE obj,
+                             VALUE attributes,
+                             EachAttributeFunc func,
+                             VALUE writer) {
+  return Qnil;
+}
+
+AttributesWriter create_empty_attributes_writer() {
+  return (AttributesWriter){.object_type = Unknown,
+                            .write_attributes = empty_write_attributes};
+}
+
+void init_attributes_writer(VALUE mPanko) {
+  init_active_record_attributes_writer(mPanko);
+}

data/ext/panko_serializer/attributes_writer/writer.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <ruby.h>
+
+#include "common.h"
+#include "active_record.h"
+#include "plain.h"
+
+enum ObjectType { Unknown = 0, ActiveRecord = 1, Plain = 2 };
+
+typedef struct _AttributesWriter {
+  enum ObjectType object_type;
+
+  int (*write_attributes)(VALUE object,
+                          VALUE attributes,
+                          EachAttributeFunc func,
+                          VALUE context);
+} AttributesWriter;
+
+/**
+ * Infers the attributes writer from the subject type
+ */
+AttributesWriter create_attributes_writer(VALUE subject);
+
+/**
+ * Creates empty writer
+ * Useful when the writer is not known, and you need init something
+ */
+AttributesWriter create_empty_attributes_writer();
+
+void init_attributes_writer(VALUE mPanko);

data/ext/panko_serializer/extconf.rb

@@ -1,8 +1,28 @@
 # frozen_string_literal: true
 require "mkmf"
+require "pathname"
 
 $CPPFLAGS += " -Wall"
 
 extension_name = "panko_serializer"
 dir_config(extension_name)
+
+RbConfig.expand(srcdir = "$(srcdir)".dup)
+
+# enum all source files
+$srcs = Dir[File.join(srcdir, "**/*.c")]
+
+
+# Get all source directories recursivley
+directories = Dir[File.join(srcdir, "**/*")].select { |f| File.directory?(f) }
+directories = directories.map { |d| Pathname.new(d).relative_path_from(Pathname.new(srcdir)) }
+directories.each do |dir|
+	# add include path to the internal folder
+	# $(srcdir) is a root folder, where "extconf.rb" is stored
+	$INCFLAGS << " -I$(srcdir)/#{dir}"
+
+	# add folder, where compiler can search source files
+	$VPATH << "$(srcdir)/#{dir}"
+end
+
 create_makefile("panko/panko_serializer")

data/ext/panko_serializer/panko_serializer.c

@@ -41,8 +41,8 @@ void serialize_fields(VALUE subject,
                       VALUE str_writer,
                       SerializationDescriptor descriptor,
                       VALUE context) {
-  panko_each_attribute(subject, descriptor->attributes, write_value,
-                       str_writer);
+  descriptor->attributes_writer.write_attributes(
+      subject, descriptor->attributes, write_value, str_writer);
 
   serialize_method_fields(subject, str_writer, descriptor, context);
 }
@@ -94,6 +94,8 @@ VALUE serialize_subject(VALUE key,
                         VALUE str_writer,
                         SerializationDescriptor descriptor,
                         VALUE context) {
+  sd_set_writer(descriptor, subject);
+
   rb_funcall(str_writer, push_object_id, 1, key);
 
   serialize_fields(subject, str_writer, descriptor, context);
@@ -141,8 +143,8 @@ VALUE serialize_subject_api(VALUE klass,
                             VALUE str_writer,
                             VALUE descriptor,
                             VALUE context) {
-  return serialize_subject(Qnil, subject, str_writer, sd_read(descriptor),
-                           context);
+  SerializationDescriptor sd = sd_read(descriptor);
+  return serialize_subject(Qnil, subject, str_writer, sd, context);
 }
 
 VALUE serialize_subjects_api(VALUE klass,
@@ -171,7 +173,7 @@ void Init_panko_serializer() {
                              serialize_subjects_api, 4);
 
   panko_init_serialization_descriptor(mPanko);
-  panko_init_attributes_iterator(mPanko);
+  init_attributes_writer(mPanko);
   panko_init_type_cast(mPanko);
   panko_init_attribute(mPanko);
   panko_init_association(mPanko);

data/ext/panko_serializer/panko_serializer.h

@@ -1,10 +1,9 @@
 #include <ruby.h>
 
-#include "association.h"
-#include "attribute.h"
-#include "attributes_iterator.h"
-#include "serialization_descriptor.h"
-#include "type_cast.h"
+#include "attributes_writer/writer.h"
+#include "serialization_descriptor/serialization_descriptor.h"
+#include "serialization_descriptor/association.h"
+#include "serialization_descriptor/attribute.h"
 
 VALUE serialize_subject(VALUE key,
                         VALUE subject,

data/ext/panko_serializer/{serialization_descriptor.c → serialization_descriptor/serialization_descriptor.c}

@@ -5,6 +5,7 @@ VALUE cSerializationDescriptor;
 static ID context_id;
 static ID object_id;
 
+
 static void sd_free(SerializationDescriptor sd) {
   if (!sd) {
     return;
@@ -42,6 +43,8 @@ static VALUE sd_new(int argc, VALUE* argv, VALUE self) {
   sd->has_many_associations = Qnil;
   sd->aliases = Qnil;
 
+  sd->attributes_writer = create_empty_attributes_writer();
+
   return Data_Wrap_Struct(cSerializationDescriptor, sd_mark, sd_free, sd);
 }
 
@@ -49,6 +52,15 @@ SerializationDescriptor sd_read(VALUE descriptor) {
   return (SerializationDescriptor)DATA_PTR(descriptor);
 }
 
+
+void sd_set_writer(SerializationDescriptor sd, VALUE subject) {
+  if (sd->attributes_writer.object_type != Unknown) {
+    return;
+  }
+
+  sd->attributes_writer = create_attributes_writer(subject);
+}
+
 VALUE sd_build_serializer(SerializationDescriptor sd) {
   if (sd->serializer == Qnil) {
     VALUE args[0];

data/ext/panko_serializer/{serialization_descriptor.h → serialization_descriptor/serialization_descriptor.h}

@@ -1,7 +1,9 @@
+#pragma once
+
 #include <ruby.h>
+#include <stdbool.h>
 
-#ifndef __SD_H__
-#define __SD_H__
+#include "attributes_writer/writer.h"
 
 typedef struct _SerializationDescriptor {
   // type of the serializer, so we can create it later
@@ -15,6 +17,8 @@ typedef struct _SerializationDescriptor {
   VALUE method_fields;
   VALUE has_one_associations;
   VALUE has_many_associations;
+
+  AttributesWriter attributes_writer;
 } * SerializationDescriptor;
 
 SerializationDescriptor sd_read(VALUE descriptor);
@@ -23,7 +27,6 @@ void sd_mark(SerializationDescriptor data);
 
 VALUE sd_build_serializer(SerializationDescriptor descriptor);
 void sd_apply_serializer_config(VALUE serializer, VALUE object, VALUE context);
+void sd_set_writer(SerializationDescriptor sd, VALUE subject);
 
 void panko_init_serialization_descriptor(VALUE mPanko);
-
-#endif

data/lib/panko/serialization_descriptor.rb

@@ -7,6 +7,10 @@ module Panko
     #
     def self.build(serializer, options={})
       backend = Panko::SerializationDescriptor.duplicate(serializer._descriptor)
+
+      if serializer.respond_to? :filters_for
+        options.merge! serializer.filters_for(options[:context])
+      end
       backend.apply_filters(options)
       backend
     end

data/lib/panko/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Panko
-  VERSION = "0.3.4"
+  VERSION = "0.3.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: panko_serializer
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.5
 platform: ruby
 authors:
 - Yosi Attias
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-06 00:00:00.000000000 Z
+date: 2018-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -101,10 +101,11 @@ files:
 - benchmarks/allocs.rb
 - benchmarks/app.rb
 - benchmarks/benchmarking_support.rb
-- benchmarks/bm_active_model_serializers.rb
-- benchmarks/bm_controller.rb
+- benchmarks/bm_ams_0_10.rb
+- benchmarks/bm_fastjsonapi.rb
 - benchmarks/bm_panko_json.rb
 - benchmarks/bm_panko_object.rb
+- benchmarks/bm_plain_object.rb
 - benchmarks/bm_serialization_descriptor.rb
 - benchmarks/bm_serializer_resolver.rb
 - benchmarks/profile.rb
@@ -121,21 +122,27 @@ files:
 - docs/getting-started.md
 - docs/performance.md
 - docs/response-bag.md
-- ext/panko_serializer/association.c
-- ext/panko_serializer/association.h
-- ext/panko_serializer/attribute.c
-- ext/panko_serializer/attribute.h
-- ext/panko_serializer/attributes_iterator.c
-- ext/panko_serializer/attributes_iterator.h
+- ext/panko_serializer/attributes_writer/active_record.c
+- ext/panko_serializer/attributes_writer/active_record.h
+- ext/panko_serializer/attributes_writer/common.c
+- ext/panko_serializer/attributes_writer/common.h
+- ext/panko_serializer/attributes_writer/plain.c
+- ext/panko_serializer/attributes_writer/plain.h
+- ext/panko_serializer/attributes_writer/type_cast/time_conversion.c
+- ext/panko_serializer/attributes_writer/type_cast/time_conversion.h
+- ext/panko_serializer/attributes_writer/type_cast/type_cast.c
+- ext/panko_serializer/attributes_writer/type_cast/type_cast.h
+- ext/panko_serializer/attributes_writer/writer.c
+- ext/panko_serializer/attributes_writer/writer.h
 - ext/panko_serializer/extconf.rb
 - ext/panko_serializer/panko_serializer.c
 - ext/panko_serializer/panko_serializer.h
-- ext/panko_serializer/serialization_descriptor.c
-- ext/panko_serializer/serialization_descriptor.h
-- ext/panko_serializer/time_conversion.c
-- ext/panko_serializer/time_conversion.h
-- ext/panko_serializer/type_cast.c
-- ext/panko_serializer/type_cast.h
+- ext/panko_serializer/serialization_descriptor/association.c
+- ext/panko_serializer/serialization_descriptor/association.h
+- ext/panko_serializer/serialization_descriptor/attribute.c
+- ext/panko_serializer/serialization_descriptor/attribute.h
+- ext/panko_serializer/serialization_descriptor/serialization_descriptor.c
+- ext/panko_serializer/serialization_descriptor/serialization_descriptor.h
 - lib/panko/array_serializer.rb
 - lib/panko/attribute.rb
 - lib/panko/response.rb
@@ -165,7 +172,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.4
+rubygems_version: 2.7.5
 signing_key: 
 specification_version: 4
 summary: Fast serialization for ActiveModel

data/benchmarks/bm_active_model_serializers.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-require_relative "./benchmarking_support"
-require_relative "./app"
-require_relative "./setup"
-
-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)
-
-  data = Benchmark.data
-  posts = data[:all]
-  posts_50 = data[:small]
-
-
-  Benchmark.run("AMS_#{prefix}_Posts_#{posts.count}") do
-    ActiveModel::ArraySerializer.new(posts, merged_options).serializable_object
-  end
-
-  data = Benchmark.data
-  posts = data[:all]
-  posts_50 = data[:small]
-
-  Benchmark.run("AMS_#{prefix}_Posts_50") do
-    ActiveModel::ArraySerializer.new(posts_50, merged_options).serializable_object
-  end
-end
-
-
-benchmark_ams "Simple", AmsPostFastSerializer
-benchmark_ams "HasOne", AmsPostWithHasOneFastSerializer
-benchmark_ams "Except", AmsPostWithHasOneFastSerializer, except: [:title]
-benchmark_ams "Include", AmsPostWithHasOneFastSerializer, include: [:id, :body, :author_id, :author]

data/benchmarks/bm_controller.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-require_relative "./benchmarking_support"
-require_relative "./app"
-require_relative "./setup"
-
-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"
-  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 MainController < ActionController::Base
-  def text
-    render text: '{"ok":true}'.freeze, content_type: "application/json".freeze
-  end
-
-  def simple
-    render json: { ok: true }
-  end
-
-  def serialize_to_string
-    data = Benchmark.data[:all]
-    render text: Panko::ArraySerializer.new(data, each_serializer: PostWithHasOneFastSerializer).to_json, content_type: "application/json".freeze
-  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
-
-
-Benchmark.run("text") { request(:get, "/text") }
-Benchmark.run("simple") { request(:get, "/simple") }
-
-Benchmark.run("serialize_to_string") { request(:get, "/serialize_to_string") }

data/ext/panko_serializer/attributes_iterator.h

@@ -1,15 +0,0 @@
-#include <ruby.h>
-#include <stdbool.h>
-
-#include "attribute.h"
-#include "serialization_descriptor.h"
-#include "type_cast.h"
-
-typedef void (*EachAttributeFunc)(VALUE writer, VALUE name, VALUE value);
-
-extern VALUE panko_each_attribute(VALUE object,
-                                  VALUE attributes,
-                                  EachAttributeFunc func,
-                                  VALUE context);
-
-void panko_init_attributes_iterator(VALUE mPanko);