panko_serializer 0.2.2 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 438e40448a2abf780b5369b43e9c93546d2bfc0e
-  data.tar.gz: ffe908bf3ebad77bb9d068d5bd0fdb0f504cb343
+  metadata.gz: e9e1120b6231ae836d11ca59c17443518f5ccb80
+  data.tar.gz: 2b38dd527027204628714825d38d5f8c83b0d4a9
 SHA512:
-  metadata.gz: 73657995f001cf88eba9fdc698e233d75d34fd6b2ca26651b782f700fe1a055c5627f77b2146d115fe94d2a130cbcb363107767de69289ceb934d8b6e77f0783
-  data.tar.gz: e222d962f5003c2af279b43c3c1a5b8a8817a998a10b2b917f394b5bbe50edece41ced1f8b1dff8dc72e7ba2c96c9aaa843d7c60b8719b0091f0f6088976074e
+  metadata.gz: 9642ae4e418b15a0051d2bb08b352bb035afabfb3f0eb115ded715fb6edc5db91a3a17a4dbd76793607b3c6db020eb2ea08625bf11e5b85311835cb8eebb428d
+  data.tar.gz: 9b0225b6e43c743425b8cbb0e105541ec646aa50a7fcaf634631ddc427ecc808cf1f96ac3a3ebe96bccdff292708f9a473f16be8481e4959917b79fc9b95d985

data/README.md

@@ -32,8 +32,6 @@ Then, install it on the command line:
 > bundle install
 ```
 
-> Since the Gem name and namespace differ, you need to require "panko" explicitly. This will be fixed before official release.
-
 
 
 ## Usage
@@ -66,7 +64,7 @@ class UsersController < ApplicationController
 end
 ```
 
-And voila, we have endpoint which serializers user records using Panko!
+And voila, we have endpoint which serialize users using Panko!
 
 
 ## Features

data/_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-cayman

data/benchmarks/bm_serialization_descriptor.rb

@@ -1,16 +1,8 @@
 # frozen_string_literal: true
 require_relative "./benchmarking_support"
 require "rails"
-require "active_model"
 require "active_support"
-require "active_support/json"
-require "action_controller"
-require "action_controller/railtie"
 
-
-require "memory_profiler"
-require "ruby-prof"
-require "ruby-prof-flamegraph"
 require "panko_serializer"
 
 def generate_attributes(count)

data/benchmarks/type_casts/bm_panko.rb

@@ -44,11 +44,11 @@ def db_panko_time
 		Panko::_type_cast(converter, from)
   end
 end
-panko_type_convert ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Json, '{"a":1}', {a:1}
-db_panko_time
-utc_panko_time
 
 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/benchmarks/type_casts/support.rb

@@ -4,6 +4,7 @@ require "active_record/connection_adapters/postgresql_adapter"
 require "active_model"
 require "active_support/all"
 require "pg"
+require "oj"
 
 
 require_relative "../benchmarking_support"

data/ext/panko_serializer/association.c

@@ -0,0 +1,81 @@
+#include "association.h"
+
+VALUE cAssociation;
+
+static void association_free(void* ptr) {
+  if (!ptr) {
+    return;
+  }
+
+  Association association = (Association)ptr;
+  association->name_str = Qnil;
+  association->name_id = 0;
+  association->name_sym = Qnil;
+  association->rb_descriptor = Qnil;
+
+  if (!association->descriptor || association->descriptor != NULL) {
+    association->descriptor = NULL;
+  }
+
+  xfree(association);
+}
+
+void association_mark(Association data) {
+  rb_gc_mark(data->name_str);
+  rb_gc_mark(data->name_sym);
+  rb_gc_mark(data->rb_descriptor);
+
+  if (data->descriptor != NULL) {
+    sd_mark(data->descriptor);
+  }
+}
+
+static VALUE association_new(int argc, VALUE* argv, VALUE self) {
+  Association association = ALLOC(struct _Association);
+
+  Check_Type(argv[0], T_SYMBOL);
+  Check_Type(argv[1], T_STRING);
+
+  association->name_sym = argv[0];
+  association->name_str = argv[1];
+  association->rb_descriptor = argv[2];
+
+  association->name_id = rb_intern_str(association->name_str);
+  association->descriptor = sd_read(association->rb_descriptor);
+
+  return Data_Wrap_Struct(cAssociation, association_mark, association_free,
+                          association);
+}
+
+Association association_read(VALUE association) {
+  return (Association)DATA_PTR(association);
+}
+
+VALUE association_name_sym_ref(VALUE self) {
+  Association association = (Association)DATA_PTR(self);
+  return association->name_sym;
+}
+
+VALUE association_descriptor_ref(VALUE self) {
+  Association association = (Association)DATA_PTR(self);
+  return association->rb_descriptor;
+}
+
+VALUE association_decriptor_aset(VALUE self, VALUE descriptor) {
+  Association association = (Association)DATA_PTR(self);
+
+  association->rb_descriptor = descriptor;
+  association->descriptor = sd_read(descriptor);
+
+  return association->rb_descriptor;
+}
+
+void panko_init_association(VALUE mPanko) {
+  cAssociation = rb_define_class_under(mPanko, "Association", rb_cObject);
+
+  rb_define_module_function(cAssociation, "new", association_new, -1);
+
+  rb_define_method(cAssociation, "name_sym", association_name_sym_ref, 0);
+  rb_define_method(cAssociation, "descriptor", association_descriptor_ref, 0);
+  rb_define_method(cAssociation, "descriptor=", association_decriptor_aset, 1);
+}

data/ext/panko_serializer/association.h

@@ -0,0 +1,20 @@
+#include <ruby.h>
+
+#ifndef __ASSOCIATION_H__
+#define __ASSOCIATION_H__
+
+#include "serialization_descriptor.h"
+
+typedef struct _Association {
+  ID name_id;
+  VALUE name_sym;
+  VALUE name_str;
+
+  VALUE rb_descriptor;
+  SerializationDescriptor descriptor;
+} * Association;
+
+Association association_read(VALUE association);
+void panko_init_association(VALUE mPanko);
+
+#endif

data/ext/panko_serializer/attribute.c

@@ -0,0 +1,73 @@
+#include "attribute.h"
+
+VALUE cAttribute;
+
+static void attribute_free(void* ptr) {
+  if (!ptr) {
+    return;
+  }
+
+  Attribute attribute = (Attribute)ptr;
+  attribute->name_str = Qnil;
+  attribute->name_id = 0;
+  attribute->alias_name = Qnil;
+  attribute->type = Qnil;
+  attribute->record_class = Qnil;
+
+  xfree(attribute);
+}
+
+void attribute_mark(Attribute data) {
+  rb_gc_mark(data->name_str);
+  rb_gc_mark(data->alias_name);
+  rb_gc_mark(data->type);
+  rb_gc_mark(data->record_class);
+}
+
+static VALUE attribute_new(int argc, VALUE* argv, VALUE self) {
+  Attribute attribute = ALLOC(struct _Attribute);
+
+  Check_Type(argv[0], T_STRING);
+  if (argv[1] != Qnil) {
+    Check_Type(argv[1], T_STRING);
+  }
+
+  attribute->name_str = argv[0];
+  attribute->name_id = rb_intern_str(attribute->name_str);
+  attribute->alias_name = argv[1];
+  attribute->type = Qnil;
+  attribute->record_class = Qnil;
+
+  return Data_Wrap_Struct(cAttribute, attribute_mark, attribute_free,
+                          attribute);
+}
+
+Attribute attribute_read(VALUE attribute) {
+  return (Attribute)DATA_PTR(attribute);
+}
+
+void attribute_try_invalidate(Attribute attribute, VALUE new_record_class) {
+  if (rb_equal(attribute->record_class, new_record_class) == Qfalse) {
+    attribute->type = Qnil;
+    attribute->record_class = new_record_class;
+  }
+}
+
+VALUE attribute_name_ref(VALUE self) {
+  Attribute attribute = (Attribute)DATA_PTR(self);
+  return attribute->name_str;
+}
+
+VALUE attribute_alias_name_ref(VALUE self) {
+  Attribute attribute = (Attribute)DATA_PTR(self);
+  return attribute->alias_name;
+}
+
+void panko_init_attribute(VALUE mPanko) {
+  cAttribute = rb_define_class_under(mPanko, "Attribute", rb_cObject);
+
+  rb_define_module_function(cAttribute, "new", attribute_new, -1);
+
+  rb_define_method(cAttribute, "name", attribute_name_ref, 0);
+  rb_define_method(cAttribute, "alias_name", attribute_alias_name_ref, 0);
+}

data/ext/panko_serializer/attribute.h

@@ -0,0 +1,23 @@
+#include <ruby.h>
+
+#ifndef __ATTRIBUTE_H__
+#define __ATTRIBUTE_H__
+
+typedef struct _Attribute {
+  VALUE name_str;
+  ID name_id;
+  VALUE alias_name;
+
+  /*
+   * We will cache the activerecord type
+   * by the record_class
+   */
+  VALUE type;
+  VALUE record_class;
+} * Attribute;
+
+Attribute attribute_read(VALUE attribute);
+void attribute_try_invalidate(Attribute attribute, VALUE record);
+void panko_init_attribute(VALUE mPanko);
+
+#endif

data/ext/panko_serializer/attributes_iterator.c

@@ -49,79 +49,116 @@ void read_attribute_from_hash(VALUE attributes_hash,
   volatile VALUE attribute_metadata = rb_hash_aref(attributes_hash, member);
   if (attribute_metadata != Qnil) {
     *value = rb_ivar_get(attribute_metadata, value_before_type_cast_id);
-    *type = rb_ivar_get(attribute_metadata, type_id);
+
+    if (*type == Qnil) {
+      *type = rb_ivar_get(attribute_metadata, type_id);
+    }
   }
 }
 
-VALUE panko_each_attribute(VALUE obj,
-                           VALUE attributes,
-                           VALUE aliases,
-                           EachAttributeFunc func,
-                           VALUE context) {
-  volatile VALUE lazy_attribute_hash, delegate_hash;
-  VALUE values = Qundef;
-  VALUE types = Qundef;
-  VALUE additional_types = Qundef;
-  int i;
-
-  lazy_attribute_hash = panko_read_lazy_attributes_hash(obj);
+struct attributes {
+  VALUE attributes_hash;
+
+  VALUE types;
+  VALUE additional_types;
+  VALUE values;
+
+  // heuristicts
+  bool shouldReadFromHash;
+  bool tryToReadFromAdditionalTypes;
+};
+
+struct attributes init_context(VALUE obj) {
+  struct attributes attributes_ctx;
+  attributes_ctx.attributes_hash = Qnil;
+  attributes_ctx.values = Qnil;
+  attributes_ctx.types = Qnil;
+  attributes_ctx.additional_types = Qnil;
+
+  attributes_ctx.shouldReadFromHash = false;
+  attributes_ctx.tryToReadFromAdditionalTypes = false;
+
+  volatile VALUE lazy_attribute_hash = panko_read_lazy_attributes_hash(obj);
+
   if (lazy_attribute_hash == Qnil) {
-    return Qnil;
+    // TODO: handle
   }
 
-  bool tryToReadFromDelegateHash = false;
-  bool tryToReadFromAdditionalTypes = false;
-
-  // If lazy_attribute_hash is not ActiveRecord::LazyAttributeHash
-  // and it's actually hash, read from it
   if (RB_TYPE_P(lazy_attribute_hash, T_HASH)) {
-    delegate_hash = lazy_attribute_hash;
-    tryToReadFromDelegateHash = true;
+    attributes_ctx.attributes_hash = lazy_attribute_hash;
+    attributes_ctx.shouldReadFromHash = true;
   } else {
-    delegate_hash = rb_ivar_get(lazy_attribute_hash, delegate_hash_id);
-    tryToReadFromDelegateHash = !panko_is_empty_hash(delegate_hash);
+    volatile VALUE delegate_hash =
+        rb_ivar_get(lazy_attribute_hash, delegate_hash_id);
+    if (!panko_is_empty_hash(delegate_hash)) {
+      attributes_ctx.attributes_hash = delegate_hash;
+      attributes_ctx.shouldReadFromHash = true;
+    }
 
-    panko_read_types_and_value(lazy_attribute_hash, &types, &additional_types,
-                               &values);
+    panko_read_types_and_value(lazy_attribute_hash, &attributes_ctx.types,
+                               &attributes_ctx.additional_types,
+                               &attributes_ctx.values);
 
-    tryToReadFromAdditionalTypes = !panko_is_empty_hash(additional_types);
+    attributes_ctx.tryToReadFromAdditionalTypes =
+        !panko_is_empty_hash(attributes_ctx.additional_types);
   }
 
-  bool tryToReadFromAliases = !panko_is_empty_hash(aliases);
-
-  for (i = 0; i < RARRAY_LEN(attributes); i++) {
-    volatile VALUE member_raw = RARRAY_AREF(attributes, i);
-    volatile VALUE member = rb_sym2str(member_raw);
+  return attributes_ctx;
+}
 
-    volatile VALUE value = Qundef;
-    volatile VALUE type_metadata = Qnil;
+VALUE read_attribute(struct attributes attributes_ctx, Attribute attribute) {
+  VALUE member = attribute->name_str;
+  volatile VALUE value = Qundef;
 
-    // First try to read from delegate hash,
-    // If the object was create in memory `User.new(name: "Yosi")`
-    // it won't exist in types/values
-    if (tryToReadFromDelegateHash) {
-      read_attribute_from_hash(delegate_hash, member, &value, &type_metadata);
+  if (attributes_ctx.values != Qnil && value == Qundef) {
+    value = rb_hash_aref(attributes_ctx.values, member);
+    if (value == Qnil) {
+      value = Qundef;
     }
+  }
+
+  if (value == Qundef && attributes_ctx.shouldReadFromHash) {
+    read_attribute_from_hash(attributes_ctx.attributes_hash, member, &value,
+                             &attribute->type);
+  }
 
-    if (values != Qundef && value == Qundef) {
-      value = rb_hash_aref(values, member);
+  if (attribute->type == Qnil) {
+    if (attributes_ctx.tryToReadFromAdditionalTypes) {
+      attribute->type = rb_hash_aref(attributes_ctx.additional_types, member);
+    }
 
-      if (tryToReadFromAdditionalTypes) {
-        type_metadata = rb_hash_aref(additional_types, member);
-      }
-      if (type_metadata == Qnil) {
-        type_metadata = rb_hash_aref(types, member);
-      }
+    if (attributes_ctx.types != Qnil && attribute->type == Qnil) {
+      attribute->type = rb_hash_aref(attributes_ctx.types, member);
     }
+  }
+
+  if (attribute->type != Qnil && value != Qnil) {
+    return type_cast(attribute->type, value);
+  }
+
+  return value;
+}
+
+VALUE panko_each_attribute(VALUE obj,
+                           VALUE attributes,
+                           EachAttributeFunc func,
+                           VALUE writer) {
+  long i;
+  struct attributes attributes_ctx = init_context(obj);
+  volatile VALUE record_class = CLASS_OF(obj);
+
+  for (i = 0; i < RARRAY_LEN(attributes); i++) {
+    volatile VALUE raw_attribute = RARRAY_AREF(attributes, i);
+    Attribute attribute = attribute_read(raw_attribute);
+    attribute_try_invalidate(attribute, record_class);
 
-    if (tryToReadFromAliases) {
-      volatile VALUE alias_name = rb_hash_aref(aliases, member_raw);
-      if (alias_name != Qnil) {
-        member = rb_sym2str(alias_name);
-      }
+    volatile VALUE name_str = attribute->name_str;
+    if (attribute->alias_name != Qnil) {
+      name_str = attribute->alias_name;
     }
 
-    func(obj, member, value, type_metadata, context);
+    volatile VALUE value = read_attribute(attributes_ctx, attribute);
+    func(writer, name_str, value);
   }
 
   return Qnil;

data/ext/panko_serializer/attributes_iterator.h

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

data/ext/panko_serializer/panko_serializer.c

@@ -9,14 +9,7 @@ static ID pop_id;
 
 static ID to_a_id;
 
-void write_value(VALUE str_writer,
-                 VALUE key,
-                 VALUE value,
-                 VALUE type_metadata) {
-  if (type_metadata != Qnil && value != Qnil) {
-    value = type_cast(type_metadata, value);
-  }
-
+void write_value(VALUE str_writer, VALUE key, VALUE value) {
   rb_funcall(str_writer, push_value_id, 2, value, key);
 }
 
@@ -36,28 +29,20 @@ void serialize_method_fields(VALUE subject,
   sd_apply_serializer_config(serializer, subject, context);
 
   for (i = 0; i < RARRAY_LEN(method_fields); i++) {
-    VALUE attribute_name = RARRAY_AREF(method_fields, i);
+    volatile VALUE attribute_name = RARRAY_AREF(method_fields, i);
     volatile VALUE result =
         rb_funcall(serializer, rb_sym2id(attribute_name), 0);
 
-    write_value(str_writer, rb_sym2str(attribute_name), result, Qnil);
+    write_value(str_writer, rb_sym2str(attribute_name), result);
   }
 }
 
-void panko_attributes_iter(VALUE object,
-                           VALUE name,
-                           VALUE value,
-                           VALUE type_metadata,
-                           VALUE str_writer) {
-  write_value(str_writer, name, value, type_metadata);
-}
-
 void serialize_fields(VALUE subject,
                       VALUE str_writer,
                       SerializationDescriptor descriptor,
                       VALUE context) {
-  panko_each_attribute(subject, descriptor->fields, descriptor->aliases,
-                       panko_attributes_iter, str_writer);
+  panko_each_attribute(subject, descriptor->attributes, write_value,
+                       str_writer);
 
   serialize_method_fields(subject, str_writer, descriptor, context);
 }
@@ -69,17 +54,16 @@ void serialize_has_one_associations(VALUE subject,
                                     VALUE associations) {
   long i;
   for (i = 0; i < RARRAY_LEN(associations); i++) {
-    volatile VALUE association = RARRAY_AREF(associations, i);
+    volatile VALUE association_el = RARRAY_AREF(associations, i);
+    Association association = association_read(association_el);
 
-    volatile VALUE name = RARRAY_AREF(association, 0);
-    volatile VALUE association_descriptor = RARRAY_AREF(association, 1);
-    volatile VALUE value = rb_funcall(subject, rb_sym2id(name), 0);
+    volatile VALUE value = rb_funcall(subject, association->name_id, 0);
 
     if (value == Qnil) {
-      write_value(str_writer, rb_sym2str(name), value, Qnil);
+      write_value(str_writer, association->name_str, value);
     } else {
-      serialize_subject(rb_sym2str(name), value, str_writer,
-                        sd_read(association_descriptor), context);
+      serialize_subject(association->name_str, value, str_writer,
+                        association->descriptor, context);
     }
   }
 }
@@ -91,17 +75,16 @@ void serialize_has_many_associations(VALUE subject,
                                      VALUE associations) {
   long i;
   for (i = 0; i < RARRAY_LEN(associations); i++) {
-    volatile VALUE association = RARRAY_AREF(associations, i);
+    volatile VALUE association_el = RARRAY_AREF(associations, i);
+    Association association = association_read(association_el);
 
-    volatile VALUE name = RARRAY_AREF(association, 0);
-    volatile VALUE association_descriptor = RARRAY_AREF(association, 1);
-    volatile VALUE value = rb_funcall(subject, rb_sym2id(name), 0);
+    volatile VALUE value = rb_funcall(subject, association->name_id, 0);
 
     if (value == Qnil) {
-      write_value(str_writer, rb_sym2str(name), value, Qnil);
+      write_value(str_writer, association->name_str, value);
     } else {
-      serialize_subjects(rb_sym2str(name), value, str_writer,
-                         sd_read(association_descriptor), context);
+      serialize_subjects(association->name_str, value, str_writer,
+                         association->descriptor, context);
     }
   }
 }
@@ -190,4 +173,6 @@ void Init_panko_serializer() {
   panko_init_serialization_descriptor(mPanko);
   panko_init_attributes_iterator(mPanko);
   panko_init_type_cast(mPanko);
+  panko_init_attribute(mPanko);
+  panko_init_association(mPanko);
 }

data/ext/panko_serializer/panko_serializer.h

@@ -1,7 +1,9 @@
 #include <ruby.h>
 
-#include "serialization_descriptor.h"
+#include "association.h"
+#include "attribute.h"
 #include "attributes_iterator.h"
+#include "serialization_descriptor.h"
 #include "type_cast.h"
 
 VALUE serialize_subject(VALUE key,

data/ext/panko_serializer/serialization_descriptor.c

@@ -5,46 +5,44 @@ VALUE cSerializationDescriptor;
 static ID context_id;
 static ID object_id;
 
-static void serialization_descriptor_free(void* ptr) {
-  SerializationDescriptor sd;
-  if (ptr == 0) {
+static void sd_free(SerializationDescriptor sd) {
+  if (!sd) {
     return;
   }
 
-  sd = (SerializationDescriptor)ptr;
   sd->serializer_type = Qnil;
   sd->serializer = Qnil;
-  sd->fields = Qnil;
+  sd->attributes = Qnil;
   sd->method_fields = Qnil;
   sd->has_one_associations = Qnil;
   sd->has_many_associations = Qnil;
   sd->aliases = Qnil;
+
+  xfree(sd);
 }
 
-void serialization_descriptor_mark(SerializationDescriptor data) {
+void sd_mark(SerializationDescriptor data) {
   rb_gc_mark(data->serializer_type);
   rb_gc_mark(data->serializer);
-  rb_gc_mark(data->fields);
+  rb_gc_mark(data->attributes);
   rb_gc_mark(data->method_fields);
   rb_gc_mark(data->has_one_associations);
   rb_gc_mark(data->has_many_associations);
   rb_gc_mark(data->aliases);
 }
 
-static VALUE serialization_descriptor_new(int argc, VALUE* argv, VALUE self) {
+static VALUE sd_new(int argc, VALUE* argv, VALUE self) {
   SerializationDescriptor sd = ALLOC(struct _SerializationDescriptor);
 
   sd->serializer = Qnil;
   sd->serializer_type = Qnil;
-  sd->fields = Qnil;
+  sd->attributes = Qnil;
   sd->method_fields = Qnil;
   sd->has_one_associations = Qnil;
   sd->has_many_associations = Qnil;
   sd->aliases = Qnil;
 
-  return Data_Wrap_Struct(cSerializationDescriptor,
-                          serialization_descriptor_mark,
-                          serialization_descriptor_free, sd);
+  return Data_Wrap_Struct(cSerializationDescriptor, sd_mark, sd_free, sd);
 }
 
 SerializationDescriptor sd_read(VALUE descriptor) {
@@ -60,87 +58,94 @@ VALUE sd_build_serializer(SerializationDescriptor sd) {
   return sd->serializer;
 }
 
+VALUE sd_serializer_set(VALUE self, VALUE serializer) {
+  SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
+
+  sd->serializer = serializer;
+  return Qnil;
+}
+
+VALUE sd_serializer_ref(VALUE self) {
+  SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
+
+  return sd->serializer;
+}
+
 void sd_apply_serializer_config(VALUE serializer, VALUE object, VALUE context) {
   rb_ivar_set(serializer, object_id, object);
-  if(context != Qnil && context != Qundef) {
+  if (context != Qnil && context != Qundef) {
     rb_ivar_set(serializer, context_id, context);
   }
 }
-
-VALUE serialization_descriptor_fields_set(VALUE self, VALUE fields) {
+VALUE sd_attributes_set(VALUE self, VALUE attributes) {
   SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
 
-  sd->fields = fields;
+  sd->attributes = attributes;
   return Qnil;
 }
 
-VALUE serialization_descriptor_fields_ref(VALUE self) {
+VALUE sd_attributes_ref(VALUE self) {
   SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
-  return sd->fields;
+  return sd->attributes;
 }
 
-VALUE serialization_descriptor_method_fields_set(VALUE self,
-                                                 VALUE method_fields) {
+VALUE sd_method_fields_set(VALUE self, VALUE method_fields) {
   SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
   sd->method_fields = method_fields;
   return Qnil;
 }
 
-VALUE serialization_descriptor_method_fields_ref(VALUE self) {
+VALUE sd_method_fields_ref(VALUE self) {
   SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
   return sd->method_fields;
 }
 
-VALUE serialization_descriptor_has_one_associations_set(
-    VALUE self,
-    VALUE has_one_associations) {
+VALUE sd_has_one_associations_set(VALUE self, VALUE has_one_associations) {
   SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
   sd->has_one_associations = has_one_associations;
   return Qnil;
 }
 
-VALUE serialization_descriptor_has_one_associations_ref(VALUE self) {
+VALUE sd_has_one_associations_ref(VALUE self) {
   SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
   return sd->has_one_associations;
 }
 
-VALUE serialization_descriptor_has_many_associations_set(
-    VALUE self,
-    VALUE has_many_associations) {
+VALUE sd_has_many_associations_set(VALUE self, VALUE has_many_associations) {
   SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
   sd->has_many_associations = has_many_associations;
   return Qnil;
 }
 
-VALUE serialization_descriptor_has_many_associations_ref(VALUE self) {
+VALUE sd_has_many_associations_ref(VALUE self) {
   SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
   return sd->has_many_associations;
 }
 
-VALUE serialization_descriptor_type_set(VALUE self, VALUE type) {
+VALUE sd_type_set(VALUE self, VALUE type) {
   SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
   sd->serializer_type = type;
   return Qnil;
 }
 
-VALUE serialization_descriptor_type_aref(VALUE self, VALUE type) {
+VALUE sd_type_aref(VALUE self, VALUE type) {
   SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
   return sd->serializer_type;
 }
 
-VALUE serialization_descriptor_aliases_set(VALUE self, VALUE aliases) {
+VALUE sd_aliases_set(VALUE self, VALUE aliases) {
   SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
   sd->aliases = aliases;
   return Qnil;
 }
 
-VALUE serialization_descriptor_aliases_aref(VALUE self, VALUE aliases) {
+VALUE sd_aliases_aref(VALUE self, VALUE aliases) {
   SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
   return sd->aliases;
 }
 
 // Exposing this for testing
-VALUE serialization_descriptor_build_serializer(VALUE self) {
+VALUE public_sd_build_serializer(VALUE self) {
   SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
   return sd_build_serializer(sd);
 }
@@ -152,40 +157,39 @@ void panko_init_serialization_descriptor(VALUE mPanko) {
   cSerializationDescriptor =
       rb_define_class_under(mPanko, "SerializationDescriptor", rb_cObject);
 
-  rb_define_module_function(cSerializationDescriptor, "new",
-                            serialization_descriptor_new, -1);
+  rb_define_module_function(cSerializationDescriptor, "new", sd_new, -1);
 
-  rb_define_method(cSerializationDescriptor,
-                   "fields=", serialization_descriptor_fields_set, 1);
-  rb_define_method(cSerializationDescriptor, "fields",
-                   serialization_descriptor_fields_ref, 0);
+  rb_define_method(cSerializationDescriptor, "serializer=", sd_serializer_set,
+                   1);
+  rb_define_method(cSerializationDescriptor, "serializer", sd_serializer_ref,
+                   0);
 
-  rb_define_method(cSerializationDescriptor,
-                   "method_fields=", serialization_descriptor_method_fields_set,
+  rb_define_method(cSerializationDescriptor, "attributes=", sd_attributes_set,
                    1);
+  rb_define_method(cSerializationDescriptor, "attributes", sd_attributes_ref,
+                   0);
+
+  rb_define_method(cSerializationDescriptor,
+                   "method_fields=", sd_method_fields_set, 1);
   rb_define_method(cSerializationDescriptor, "method_fields",
-                   serialization_descriptor_method_fields_ref, 0);
+                   sd_method_fields_ref, 0);
 
-  rb_define_method(cSerializationDescriptor, "has_one_associations=",
-                   serialization_descriptor_has_one_associations_set, 1);
+  rb_define_method(cSerializationDescriptor,
+                   "has_one_associations=", sd_has_one_associations_set, 1);
   rb_define_method(cSerializationDescriptor, "has_one_associations",
-                   serialization_descriptor_has_one_associations_ref, 0);
+                   sd_has_one_associations_ref, 0);
 
-  rb_define_method(cSerializationDescriptor, "has_many_associations=",
-                   serialization_descriptor_has_many_associations_set, 1);
+  rb_define_method(cSerializationDescriptor,
+                   "has_many_associations=", sd_has_many_associations_set, 1);
   rb_define_method(cSerializationDescriptor, "has_many_associations",
-                   serialization_descriptor_has_many_associations_ref, 0);
+                   sd_has_many_associations_ref, 0);
 
-  rb_define_method(cSerializationDescriptor,
-                   "type=", serialization_descriptor_type_set, 1);
-  rb_define_method(cSerializationDescriptor, "type",
-                   serialization_descriptor_type_aref, 0);
+  rb_define_method(cSerializationDescriptor, "type=", sd_type_set, 1);
+  rb_define_method(cSerializationDescriptor, "type", sd_type_aref, 0);
 
-  rb_define_method(cSerializationDescriptor,
-                   "aliases=", serialization_descriptor_aliases_set, 1);
-  rb_define_method(cSerializationDescriptor, "aliases",
-                   serialization_descriptor_aliases_aref, 0);
+  rb_define_method(cSerializationDescriptor, "aliases=", sd_aliases_set, 1);
+  rb_define_method(cSerializationDescriptor, "aliases", sd_aliases_aref, 0);
 
   rb_define_method(cSerializationDescriptor, "build_serializer",
-                   serialization_descriptor_build_serializer, 0);
+                   public_sd_build_serializer, 0);
 }

data/ext/panko_serializer/serialization_descriptor.h

@@ -10,19 +10,17 @@ typedef struct _SerializationDescriptor {
   VALUE serializer;
 
   // Metadata
-  VALUE fields;
-  VALUE method_fields;
+  VALUE attributes;
   VALUE aliases;
+  VALUE method_fields;
   VALUE has_one_associations;
   VALUE has_many_associations;
 } * SerializationDescriptor;
 
-VALUE serialization_descriptor_fields_ref(VALUE descriptor);
-VALUE serialization_descriptor_method_fields_ref(VALUE descriptor);
-VALUE serialization_descriptor_has_one_associations_ref(VALUE descriptor);
-VALUE serialization_descriptor_has_many_associations_ref(VALUE descriptor);
-
 SerializationDescriptor sd_read(VALUE descriptor);
+
+void sd_mark(SerializationDescriptor data);
+
 VALUE sd_build_serializer(SerializationDescriptor descriptor);
 void sd_apply_serializer_config(VALUE serializer, VALUE object, VALUE context);
 

data/ext/panko_serializer/type_cast.c

@@ -5,6 +5,10 @@ ID deserialize_from_db_id = 0;
 ID to_s_id = 0;
 ID to_i_id = 0;
 
+static VALUE oj_type = Qundef;
+static VALUE oj_parseerror_type = Qundef;
+ID load_id = 0;
+
 // Caching ActiveRecord Types
 static VALUE ar_string_type = Qundef;
 static VALUE ar_text_type = Qundef;
@@ -41,11 +45,25 @@ VALUE cache_postgres_type_lookup(VALUE ar) {
     return Qfalse;
   }
 
-  ar_pg_integer_type = rb_const_get_at(ar_oid, rb_intern("Integer"));
-  ar_pg_float_type = rb_const_get_at(ar_oid, rb_intern("Float"));
-  ar_pg_uuid_type = rb_const_get_at(ar_oid, rb_intern("Uuid"));
-  ar_pg_json_type = rb_const_get_at(ar_oid, rb_intern("Json"));
-  ar_pg_date_time_type = rb_const_get_at(ar_oid, rb_intern("DateTime"));
+  if (rb_const_defined_at(ar_oid, rb_intern("Float")) == (int)Qtrue) {
+    ar_pg_float_type = rb_const_get_at(ar_oid, rb_intern("Float"));
+  }
+
+  if (rb_const_defined_at(ar_oid, rb_intern("Integer")) == (int)Qtrue) {
+    ar_pg_integer_type = rb_const_get_at(ar_oid, rb_intern("Integer"));
+  }
+
+  if (rb_const_defined_at(ar_oid, rb_intern("Uuid")) == (int)Qtrue) {
+    ar_pg_uuid_type = rb_const_get_at(ar_oid, rb_intern("Uuid"));
+  }
+
+  if (rb_const_defined_at(ar_oid, rb_intern("Json")) == (int)Qtrue) {
+    ar_pg_json_type = rb_const_get_at(ar_oid, rb_intern("Json"));
+  }
+
+  if (rb_const_defined_at(ar_oid, rb_intern("DateTime")) == (int)Qtrue) {
+    ar_pg_date_time_type = rb_const_get_at(ar_oid, rb_intern("DateTime"));
+  }
 
   return Qtrue;
 }
@@ -187,14 +205,22 @@ bool is_json_type(VALUE type_klass) {
   return ar_pg_json_type != Qundef && type_klass == ar_pg_json_type;
 }
 
+VALUE rescue_func() {
+  return Qnil;
+}
+
+VALUE parse_json(VALUE value) {
+  return rb_funcall(oj_type, load_id, 1, value);
+}
+
 VALUE cast_json_type(VALUE value) {
   if (!RB_TYPE_P(value, T_STRING)) {
     return value;
   }
 
-  // TODO: instead of parsing the json, let's signal to "write_value"
-  // to use "push_json" instead of "push_value"
-  return Qundef;
+  volatile VALUE result =
+      rb_rescue2(parse_json, value, rescue_func, Qundef, oj_parseerror_type, 0);
+  return result;
 }
 
 bool is_boolean_type(VALUE type_klass) {
@@ -282,6 +308,10 @@ void panko_init_type_cast(VALUE mPanko) {
   to_s_id = rb_intern_const("to_s");
   to_i_id = rb_intern_const("to_i");
 
+  oj_type = rb_const_get_at(rb_cObject, rb_intern("Oj"));
+  oj_parseerror_type = rb_const_get_at(oj_type, rb_intern("ParseError"));
+  load_id = rb_intern_const("load");
+
   rb_define_singleton_method(mPanko, "_type_cast", public_type_cast, 2);
 
   panko_init_time(mPanko);

data/ext/panko_serializer/type_cast.h

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

data/lib/panko/attribute.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Panko
+  class Attribute
+    def self.create(name, alias_name: nil)
+      alias_name = alias_name.to_s unless alias_name.nil?
+      Attribute.new(name.to_s, alias_name)
+    end
+
+    def ==(attr)
+      return name.to_sym == attr if attr.is_a? Symbol
+      if attr.is_a? Panko::Attribute
+        return name == attr.name && alias_name == attr.alias_name
+      end
+      super
+    end
+
+    def hash
+      name.to_sym.hash
+    end
+
+    def eql?(attr)
+      self.==(attr)
+    end
+
+    def inspect
+      "<Panko::Attribute name=#{name.inspect} alias_name=#{alias_name.inspect}>"
+    end
+  end
+end

data/lib/panko/response.rb

@@ -2,6 +2,12 @@
 require "oj"
 
 module Panko
+  JsonValue = Struct.new(:value) do
+    def self.from(value)
+      JsonValue.new(value)
+    end
+  end
+
   class Response
     def initialize(data)
       @data = data
@@ -15,6 +21,8 @@ module Panko
       @data.each do |key, value|
         if value.is_a?(Panko::ArraySerializer) || value.is_a?(Panko::Serializer)
           writer.push_json(value.to_json, key.to_s)
+        elsif value.is_a?(Panko::JsonValue)
+          writer.push_json(value.value, key.to_s)
         else
           writer.push_value(value, key.to_s)
         end

data/lib/panko/serialization_descriptor.rb

@@ -20,13 +20,31 @@ module Panko
 
       backend.type = descriptor.type
 
-      backend.fields = descriptor.fields.dup
+      backend.attributes = descriptor.attributes.map do |attr|
+        Attribute.create(attr.name, alias_name: attr.alias_name)
+      end
+
       backend.method_fields = descriptor.method_fields.dup
 
-      backend.has_many_associations = descriptor.has_many_associations.dup
-      backend.has_one_associations = descriptor.has_one_associations.dup
+      unless descriptor.serializer.nil?
+        backend.serializer = descriptor.serializer.reset
+      end
+
+      backend.has_many_associations = descriptor.has_many_associations.map do |assoc|
+        Panko::Association.new(
+          assoc.name_sym,
+          assoc.name_sym.to_s,
+          Panko::SerializationDescriptor.duplicate(assoc.descriptor)
+        )
+      end
 
-      backend.aliases = descriptor.aliases.dup
+      backend.has_one_associations = descriptor.has_one_associations.map do |assoc|
+        Panko::Association.new(
+          assoc.name_sym,
+          assoc.name_sym.to_s,
+          Panko::SerializationDescriptor.duplicate(assoc.descriptor)
+        )
+      end
 
       backend
     end
@@ -40,14 +58,7 @@ module Panko
       attributes_only_filters, associations_only_filters = resolve_filters(options, :only)
       attributes_except_filters, associations_except_filters = resolve_filters(options, :except)
 
-      apply_aliases_filters(
-        self.aliases,
-        attributes_only_filters,
-        attributes_except_filters
-      )
-
-      self.fields = apply_fields_filters(
-        self.fields,
+      apply_attribute_filters!(
         attributes_only_filters,
         attributes_except_filters
       )
@@ -79,17 +90,19 @@ module Panko
       attributes_only_filters = only_filters[:attributes] || []
       unless attributes_only_filters.empty?
         associations.select! do |association|
-          attributes_only_filters.include?(association.first)
+          attributes_only_filters.include?(association.name_sym)
         end
       end
 
+
       attributes_except_filters = except_filters[:attributes] || []
       unless attributes_except_filters.empty?
         associations.reject! do |association|
-          attributes_except_filters.include?(association.first)
+          attributes_except_filters.include?(association.name_sym)
         end
       end
 
+
       associations_only_filters = only_filters[:associations]
       associations_except_filters = except_filters[:associations]
 
@@ -98,8 +111,8 @@ module Panko
       end
 
       associations.map do |association|
-        name = association.first
-        descriptor = association.last
+        name = association.name_sym
+        descriptor = association.descriptor
 
         only_filter = associations_only_filters[name]
         except_filter = associations_except_filters[name]
@@ -107,7 +120,6 @@ module Panko
         filters = {}
         filters[:only] = only_filter unless only_filter.nil?
         filters[:except] = except_filter unless except_filter.nil?
-
         descriptor.apply_filters(filters) unless filters.empty?
 
         association
@@ -140,24 +152,22 @@ module Panko
       fields
     end
 
-    def apply_aliases_filters(aliases, only, except)
-      return if self.aliases.nil? || self.aliases.empty?
-
+    def apply_attribute_filters!(only, except)
       unless only.empty?
-        only.map! do |field_name|
-          alias_name = self.aliases.key(field_name)
-          next field_name if alias_name.nil?
+        self.attributes.select! do |attribute|
+          name_to_check = attribute.name
+          name_to_check = attribute.alias_name unless attribute.alias_name.nil?
 
-          alias_name
+          only.include?(name_to_check.to_sym)
         end
       end
 
       unless except.empty?
-        except.map! do |field_name|
-          alias_name = self.aliases.key(field_name)
-          next field_name if alias_name.nil?
+        self.attributes.reject! do |attribute|
+          name_to_check = attribute.name
+          name_to_check = attribute.alias_name unless attribute.alias_name.nil?
 
-          alias_name
+          except.include?(name_to_check.to_sym)
         end
       end
     end

data/lib/panko/serializer.rb

@@ -9,9 +9,11 @@ module Panko
         base._descriptor = Panko::SerializationDescriptor.new
         base._descriptor.type = base
 
+        base._descriptor.attributes = []
         base._descriptor.aliases = {}
-        base._descriptor.fields = []
+
         base._descriptor.method_fields = []
+
         base._descriptor.has_many_associations = []
         base._descriptor.has_one_associations = []
       end
@@ -19,36 +21,39 @@ module Panko
       attr_accessor :_descriptor
 
       def attributes(*attrs)
-        @_descriptor.fields.push(*attrs).uniq!
+        @_descriptor.attributes.push(*attrs.map { |attr| Attribute.create(attr) }).uniq!
       end
 
       def aliases(aliases = {})
-        @_descriptor.aliases = aliases
-        attributes(*aliases.keys)
+        aliases.each do |attr, alias_name|
+          @_descriptor.attributes << Attribute.create(attr, alias_name: alias_name)
+        end
       end
 
       def method_added(method)
         return if @_descriptor.nil?
-        @_descriptor.fields.delete(method)
+        @_descriptor.attributes.delete(method)
         @_descriptor.method_fields << method
       end
 
       def has_one(name, options)
         serializer_const = options[:serializer]
 
-        @_descriptor.has_one_associations << [
+        @_descriptor.has_one_associations << Panko::Association.new(
           name,
+          name.to_s,
           Panko::SerializationDescriptor.build(serializer_const, options)
-        ]
+        )
       end
 
       def has_many(name, options)
         serializer_const = options[:serializer] || options[:each_serializer]
 
-        @_descriptor.has_many_associations << [
+        @_descriptor.has_many_associations << Panko::Association.new(
           name,
+          name.to_s.freeze,
           Panko::SerializationDescriptor.build(serializer_const, options)
-        ]
+        )
       end
     end
 
@@ -68,5 +73,12 @@ module Panko
       Panko::serialize_subject(object, writer, @descriptor, @context)
       writer.to_s
     end
+
+    def reset
+      @object = nil
+      @context = nil
+
+      self
+    end
   end
 end

data/lib/panko/version.rb

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

data/lib/panko_serializer.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 require "panko/version"
+require "panko/attribute"
 require "panko/serializer"
 require "panko/array_serializer"
 require "panko/response"
 
 
 # C Extension
+require "oj"
 require "panko/panko_serializer"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: panko_serializer
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.2
 platform: ruby
 authors:
 - Yosi Attias
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-26 00:00:00.000000000 Z
+date: 2017-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -97,6 +97,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- _config.yml
 - benchmarks/BENCHMARKS.md
 - benchmarks/allocs.rb
 - benchmarks/app.rb
@@ -112,6 +113,10 @@ files:
 - benchmarks/type_casts/bm_active_record.rb
 - benchmarks/type_casts/bm_panko.rb
 - benchmarks/type_casts/support.rb
+- 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/extconf.rb
@@ -124,6 +129,7 @@ files:
 - ext/panko_serializer/type_cast.c
 - ext/panko_serializer/type_cast.h
 - lib/panko/array_serializer.rb
+- lib/panko/attribute.rb
 - lib/panko/response.rb
 - lib/panko/serialization_descriptor.rb
 - lib/panko/serializer.rb
@@ -150,7 +156,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: Fast serialization for ActiveModel