panko_serializer 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b721121db1bee35804d8beda87689c2a76ef7c52
-  data.tar.gz: 7b6610f84d75aa9f5c929833598a3467499f22d7
+  metadata.gz: 73b05629bbbeb18415188b8c70e316f678f604ba
+  data.tar.gz: 95922dc138d747c5fa0ca282ff6b9eda4e004d55
 SHA512:
-  metadata.gz: 9ea137eb8d6229fee333c1dca93b0646bf072116f2541ec2a4a9dba80e25f55fa226dda3a95fd70780ba78dd1eae5e28438dadb109062c38656f38512ec67813
-  data.tar.gz: e01f5ac93e458bfad776aa0e64d7cf168095688e6f9d8d2eeb19d2329e3eab4861aa2ff6d09736d673aa225872996df65471451685957168b31089d1eb856cf7
+  metadata.gz: 1b6489dc3d9532d01766a38cbb6d0652275883d8ea8ad7b8dc6b82494f1d5035f5c95a925b2b0908bdcaf3a6807ec7afaca3c5982a1a894e102ac9aa7ae35243
+  data.tar.gz: 83c2b331d7acb26d4bbf6e851b5f30250b7074195c2f8a722bea053db867aa34af23a05dc015a0ceec098cfbc747b9f892516f9a8d534c50f5189180bcd5cf82

data/README.md

@@ -2,6 +2,13 @@
 
 [![Build Status](https://travis-ci.org/yosiat/panko_serializer.svg?branch=master)](https://travis-ci.org/yosiat/panko_serializer)
 
+Panko is high performance library for serializing ActiveRecord objects.
+
+## Status
+
+Panko is not ready for official release (it's missing documentation, tests, configuration options to remove assumptions).
+
+
 
 ## License
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/benchmarks/type_casts/bm_panko.rb

@@ -45,11 +45,6 @@ def db_panko_time
   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

data/ext/panko_serializer/attributes_iterator.c

@@ -1,24 +1,26 @@
 #include "attributes_iterator.h"
 
-static ID attributes_id = 0;
-static ID types_id = 0;
-static ID values_id = 0;
-static ID delegate_hash_id = 0;
+static ID attributes_id;
+static ID types_id;
+static ID values_id;
+static ID delegate_hash_id;
 
-static ID value_before_type_cast_id = 0;
-static ID type_id = 0;
+static ID value_before_type_cast_id;
+static ID type_id;
 
 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);
+  volatile VALUE attributes_set, attributes_hash;
+
+  attributes_set = read_attributes(object);
   if (attributes_set == Qnil) {
     return Qnil;
   }
 
-  VALUE attributes_hash = read_attributes(attributes_set);
+  attributes_hash = read_attributes(attributes_set);
   if (attributes_hash == Qnil) {
     return Qnil;
   }
@@ -37,29 +39,31 @@ VALUE panko_each_attribute(VALUE obj,
                            VALUE attributes,
                            EachAttributeFunc func,
                            VALUE context) {
-  VALUE attributes_hash = panko_read_lazy_attributes_hash(obj);
+  volatile VALUE attributes_hash, delegate_hash;
+  int i;
+
+  attributes_hash = panko_read_lazy_attributes_hash(obj);
   if (attributes_hash == Qnil) {
     return Qnil;
   }
 
-  VALUE delegate_hash = rb_ivar_get(attributes_hash, delegate_hash_id);
+  delegate_hash = rb_ivar_get(attributes_hash, delegate_hash_id);
   bool tryToReadFromDelegateHash = RHASH_SIZE(delegate_hash) > 0;
 
   VALUE types, values;
   panko_read_types_and_value(attributes_hash, &types, &values);
 
-  int i;
   for (i = 0; i < RARRAY_LEN(attributes); i++) {
-    VALUE member = RARRAY_AREF(attributes, i);
+    volatile VALUE member = rb_sym2str(RARRAY_AREF(attributes, i));
 
-    VALUE value = Qundef;
-    VALUE type_metadata = Qnil;
+    volatile VALUE value = Qundef;
+    volatile VALUE type_metadata = Qnil;
 
     // 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) {
-      VALUE attribute_metadata = rb_hash_aref(delegate_hash, member);
+      volatile VALUE attribute_metadata = rb_hash_aref(delegate_hash, member);
       if (attribute_metadata != Qnil) {
         value = rb_ivar_get(attribute_metadata, value_before_type_cast_id);
         type_metadata = rb_ivar_get(attribute_metadata, type_id);

data/ext/panko_serializer/panko_serializer.c

@@ -2,12 +2,12 @@
 
 #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 push_value_id;
+static ID push_array_id;
+static ID push_object_id;
+static ID pop_id;
 
-static ID to_a_id = 0;
+static ID to_a_id;
 
 void write_value(VALUE str_writer,
                  VALUE key,
@@ -24,18 +24,21 @@ void serialize_method_fields(VALUE subject,
                              VALUE str_writer,
                              SerializationDescriptor descriptor,
                              VALUE context) {
-  VALUE method_fields = descriptor->method_fields;
+  VALUE method_fields, serializer;
+  long i;
+
+  method_fields = descriptor->method_fields;
   if (RARRAY_LEN(method_fields) == 0) {
     return;
   }
 
-  VALUE serializer = sd_build_serializer(descriptor);
+  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);
+    volatile VALUE result =
+        rb_funcall(serializer, rb_sym2id(attribute_name), 0);
 
     write_value(str_writer, rb_sym2str(attribute_name), result, Qnil);
   }
@@ -53,7 +56,8 @@ void serialize_fields(VALUE subject,
                       VALUE str_writer,
                       SerializationDescriptor descriptor,
                       VALUE context) {
-  panko_each_attribute(subject, descriptor->fields, panko_attributes_iter, str_writer);
+  panko_each_attribute(subject, descriptor->fields, panko_attributes_iter,
+                       str_writer);
 
   serialize_method_fields(subject, str_writer, descriptor, context);
 }
@@ -65,11 +69,11 @@ void serialize_has_one_associatoins(VALUE subject,
                                     VALUE associations) {
   long i;
   for (i = 0; i < RARRAY_LEN(associations); i++) {
-    VALUE association = RARRAY_AREF(associations, i);
+    volatile 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);
+    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);
 
     if (value == Qnil) {
       write_value(str_writer, rb_sym2str(name), value, Qnil);
@@ -87,11 +91,11 @@ void serialize_has_many_associatoins(VALUE subject,
                                      VALUE associations) {
   long i;
   for (i = 0; i < RARRAY_LEN(associations); i++) {
-    VALUE association = RARRAY_AREF(associations, i);
+    volatile 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);
+    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);
 
     if (value == Qnil) {
       write_value(str_writer, rb_sym2str(name), value, Qnil);
@@ -131,15 +135,16 @@ VALUE serialize_subjects(VALUE key,
                          VALUE str_writer,
                          SerializationDescriptor descriptor,
                          VALUE context) {
+  long i;
+
   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);
+    volatile VALUE subject = RARRAY_AREF(subjects, i);
     serialize_subject(Qnil, subject, str_writer, descriptor, context);
   }
 
@@ -168,11 +173,11 @@ VALUE serialize_subjects_api(VALUE klass,
 }
 
 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");
+  push_value_id = rb_intern("push_value");
+  push_array_id = rb_intern("push_array");
+  push_object_id = rb_intern("push_object");
+  pop_id = rb_intern("pop");
+  to_a_id = rb_intern("to_a");
 
   VALUE mPanko = rb_define_module("Panko");
 

data/ext/panko_serializer/serialization_descriptor.c

@@ -2,15 +2,16 @@
 
 VALUE cSerializationDescriptor;
 
-static ID context_id = 0;
-static ID object_id = 0;
+static ID context_id;
+static ID object_id;
 
 static void serialization_descriptor_free(void* ptr) {
+  SerializationDescriptor sd;
   if (ptr == 0) {
     return;
   }
 
-  SerializationDescriptor sd = (SerializationDescriptor)ptr;
+  sd = (SerializationDescriptor)ptr;
   sd->serializer_type = Qnil;
   sd->serializer = Qnil;
   sd->fields = Qnil;
@@ -64,7 +65,6 @@ void sd_apply_serializer_config(VALUE serializer, VALUE object, VALUE context) {
   rb_ivar_set(serializer, context_id, context);
 }
 
-
 VALUE serialization_descriptor_fields_set(VALUE self, VALUE fields) {
   SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
 
@@ -121,6 +121,11 @@ VALUE serialization_descriptor_type_set(VALUE self, VALUE type) {
   return Qnil;
 }
 
+VALUE serialization_descriptor_type_aref(VALUE self, VALUE type) {
+  SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
+  return sd->serializer_type;
+}
+
 // Exposing this for testing
 VALUE serialization_descriptor_build_serializer(VALUE self) {
   SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
@@ -128,8 +133,8 @@ VALUE serialization_descriptor_build_serializer(VALUE self) {
 }
 
 void panko_init_serialization_descriptor(VALUE mPanko) {
-  CONST_ID(object_id, "@object");
-  CONST_ID(context_id, "@context");
+  object_id = rb_intern("@object");
+  context_id = rb_intern("@context");
 
   cSerializationDescriptor =
       rb_define_class_under(mPanko, "SerializationDescriptor", rb_cObject);
@@ -160,6 +165,8 @@ void panko_init_serialization_descriptor(VALUE mPanko) {
 
   rb_define_method(cSerializationDescriptor,
                    "type=", serialization_descriptor_type_set, 1);
+  rb_define_method(cSerializationDescriptor,
+                   "type", serialization_descriptor_type_aref, 0);
 
   rb_define_method(cSerializationDescriptor, "build_serializer",
                    serialization_descriptor_build_serializer, 0);

data/ext/panko_serializer/time_conversion.c

@@ -1,65 +1,79 @@
 #include "time_conversion.h"
 
+const int YEAR_REGION = 1;
+const int MONTH_REGION = 2;
+const int DAY_REGION = 3;
+const int HOUR_REGION = 4;
+const int MINUTE_REGION = 5;
+const int SECOND_REGION = 6;
+
 static regex_t* iso8601_time_regex;
 static regex_t* ar_iso_datetime_regex;
 
 VALUE is_iso8601_time_string(const char* value) {
   const UChar *start, *range, *end;
+  OnigPosition r;
 
   const UChar* str = (const UChar*)(value);
 
   end = str + strlen(value);
   start = str;
   range = end;
-  OnigPosition r = onig_search(iso8601_time_regex, str, end, start, range, NULL,
-                               ONIG_OPTION_NONE);
+  r = onig_search(iso8601_time_regex, str, end, start, range, NULL,
+                  ONIG_OPTION_NONE);
 
   return r >= 0 ? Qtrue : Qfalse;
 }
 
-void append_region_part(char* buf,
-                        const char* value,
-                        const OnigRegion* region,
-                        int i) {
-  long substringLength = region->end[i] - region->beg[i];
-  strncat(buf, value + region->beg[i], substringLength);
+void append_region(const char* source,
+                   char** to,
+                   const OnigRegion* region,
+                   int region_number) {
+  long iter = 0;
+  long regionEnd = region->end[region_number];
+  for (iter = region->beg[region_number]; iter < regionEnd; iter++) {
+    *(*to)++ = source[iter];
+  }
 }
 
 VALUE iso_ar_iso_datetime_string(const char* value) {
   const UChar *start, *range, *end;
+  OnigPosition r;
   OnigRegion* region = onig_region_new();
+  volatile VALUE output;
 
   const UChar* str = (const UChar*)(value);
 
   end = str + strlen(value);
   start = str;
   range = end;
-  OnigPosition r = onig_search(ar_iso_datetime_regex, str, end, start, range,
-                               region, ONIG_OPTION_NONE);
+  r = onig_search(ar_iso_datetime_regex, str, end, start, range, region,
+                  ONIG_OPTION_NONE);
 
-  VALUE output = Qnil;
+  output = Qnil;
   if (r >= 0) {
     char buf[21] = "";
+    char* cur = buf;
 
-    append_region_part(buf, value, region, 1);
-    strncat(buf, "-", 1);
+    append_region(value, &cur, region, YEAR_REGION);
+    *cur++ = '-';
 
-    append_region_part(buf, value, region, 2);
-    strncat(buf, "-", 1);
+    append_region(value, &cur, region, MONTH_REGION);
+    *cur++ = '-';
 
-    append_region_part(buf, value, region, 3);
-    strncat(buf, "T", 1);
+    append_region(value, &cur, region, DAY_REGION);
+    *cur++ = 'T';
 
-    append_region_part(buf, value, region, 4);
-    strncat(buf, ":", 1);
+    append_region(value, &cur, region, HOUR_REGION);
+    *cur++ = ':';
 
-    append_region_part(buf, value, region, 5);
-    strncat(buf, ":", 1);
+    append_region(value, &cur, region, MINUTE_REGION);
+    *cur++ = ':';
 
-    append_region_part(buf, value, region, 6);
-    strncat(buf, "Z", 1);
+    append_region(value, &cur, region, SECOND_REGION);
+    *cur++ = 'Z';
 
-    output = rb_str_new(buf, strlen(buf));
+    output = rb_str_new(buf, cur - buf);
   }
 
   onig_region_free(region, 1);
@@ -81,12 +95,14 @@ void build_regex(OnigRegex* reg, const UChar* pattern) {
 }
 
 void panko_init_time(VALUE mPanko) {
-  const UChar* ISO8601_PATTERN =
+  const UChar *ISO8601_PATTERN, *AR_ISO_DATETIME_PATTERN;
+
+  ISO8601_PATTERN =
       (UChar*)"^([\\+-]?\\d{4}(?!\\d{2}\\b))((-?)((0[1-9]|1[0-2])(\\3([12]\\d|0[1-9]|3[01]))?|W([0-4]\\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\\d|[12]\\d{2}|3([0-5]\\d|6[1-6])))([T\\s]((([01]\\d|2[0-3])((:?)[0-5]\\d)?|24\\:?00)([\\.,]\\d+(?!:))?)?(\\17[0-5]\\d([\\.,]\\d+)?)?([zZ]|([\\+-])([01]\\d|2[0-3]):?([0-5]\\d)?)?)?)?$";
 
   build_regex(&iso8601_time_regex, ISO8601_PATTERN);
 
-  const UChar* AR_ISO_DATETIME_PATTERN =
+  AR_ISO_DATETIME_PATTERN =
       (UChar*)"\\A(?<year>\\d{4})-(?<month>\\d\\d)-(?<mday>\\d\\d) (?<hour>\\d\\d):(?<min>\\d\\d):(?<sec>\\d\\d)(\\.(?<microsec>\\d+))?\\z";
 
   build_regex(&ar_iso_datetime_regex, AR_ISO_DATETIME_PATTERN);

data/ext/panko_serializer/type_cast.c

@@ -1,9 +1,9 @@
 #include "type_cast.h"
 #include "time_conversion.h"
 
-static ID type_cast_from_database_id = 0;
-static ID to_s_id = 0;
-static ID to_i_id = 0;
+ID type_cast_from_database_id = 0;
+ID to_s_id = 0;
+ID to_i_id = 0;
 
 // Caching ActiveRecord Types
 static VALUE ar_string_type = Qundef;
@@ -23,19 +23,20 @@ static VALUE ar_pg_date_time_type = Qundef;
 static int initiailized = 0;
 
 VALUE cache_postgres_type_lookup(VALUE ar) {
-  VALUE ar_connection_adapters =
-      rb_const_get_at(ar, rb_intern("ConnectionAdapters"));
+  VALUE ar_connection_adapters, ar_postgresql, ar_oid;
+
+  ar_connection_adapters = rb_const_get_at(ar, rb_intern("ConnectionAdapters"));
   if (ar_connection_adapters == Qundef) {
     return Qfalse;
   }
 
-  VALUE ar_postgresql =
+  ar_postgresql =
       rb_const_get_at(ar_connection_adapters, rb_intern("PostgreSQL"));
   if (ar_postgresql == Qundef) {
     return Qfalse;
   }
 
-  VALUE ar_oid = rb_const_get_at(ar_postgresql, rb_intern("OID"));
+  ar_oid = rb_const_get_at(ar_postgresql, rb_intern("OID"));
   if (ar_oid == Qundef) {
     return Qfalse;
   }
@@ -50,14 +51,16 @@ VALUE cache_postgres_type_lookup(VALUE ar) {
 }
 
 VALUE cache_time_zone_type_lookup(VALUE ar) {
+  VALUE ar_attr_methods, ar_time_zone_conversion;
+
   // ActiveRecord::AttributeMethods
-  VALUE ar_attr_methods = rb_const_get_at(ar, rb_intern("AttributeMethods"));
+  ar_attr_methods = rb_const_get_at(ar, rb_intern("AttributeMethods"));
   if (ar_attr_methods == Qundef) {
     return Qfalse;
   }
 
   // ActiveRecord::AttributeMethods::TimeZoneConversion
-  VALUE ar_time_zone_conversion =
+  ar_time_zone_conversion =
       rb_const_get_at(ar_attr_methods, rb_intern("TimeZoneConversion"));
   if (ar_time_zone_conversion == Qundef) {
     return Qfalse;
@@ -76,10 +79,12 @@ void cache_type_lookup() {
 
   initiailized = 1;
 
-  VALUE ar = rb_const_get_at(rb_cObject, rb_intern("ActiveRecord"));
+  VALUE ar, ar_type;
+
+  ar = rb_const_get_at(rb_cObject, rb_intern("ActiveRecord"));
 
   // ActiveRecord::Type
-  VALUE ar_type = rb_const_get_at(ar, rb_intern("Type"));
+  ar_type = rb_const_get_at(ar, rb_intern("Type"));
 
   ar_string_type = rb_const_get_at(ar_type, rb_intern("String"));
   ar_text_type = rb_const_get_at(ar_type, rb_intern("Text"));
@@ -226,7 +231,7 @@ VALUE cast_date_time_type(VALUE value) {
       return value;
     }
 
-    VALUE iso8601_string = iso_ar_iso_datetime_string(val);
+    volatile VALUE iso8601_string = iso_ar_iso_datetime_string(val);
     if (iso8601_string != Qnil) {
       return iso8601_string;
     }
@@ -238,8 +243,10 @@ VALUE cast_date_time_type(VALUE value) {
 VALUE type_cast(VALUE type_metadata, VALUE value) {
   cache_type_lookup();
 
-  VALUE type_klass = CLASS_OF(type_metadata);
-  VALUE typeCastedValue = Qundef;
+  VALUE type_klass, typeCastedValue;
+
+  type_klass = CLASS_OF(type_metadata);
+  typeCastedValue = Qundef;
 
   TypeCast typeCast;
   for (typeCast = type_casts; typeCast->canCast != NULL; typeCast++) {

data/lib/panko/array_serializer.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require_relative "cache"
 
 module Panko
   class ArraySerializer
@@ -15,7 +14,7 @@ module Panko
         except: options.fetch(:except, [])
       }
 
-      @descriptor = Panko::CACHE.fetch(@each_serializer, serializer_options)
+      @descriptor = SerializationDescriptorBuilder.build(@each_serializer, serializer_options)
       @context = options.fetch(:context, nil)
     end
 

data/lib/panko/serialization_descriptor.rb

@@ -1,32 +1,25 @@
 # frozen_string_literal: true
 module Panko
   module SerializationDescriptorBuilder
-    def self.build(serializer, options={})
-      backend = Panko::SerializationDescriptor.new
-
+    def self.apply_filters(backend, options)
       serializer_only_filters, attributes_only_filters = resolve_filters(options, :only)
       serializer_except_filters, attributes_except_filters = resolve_filters(options, :except)
 
-      fields, method_fields = fields_of(serializer)
-
-      backend.type = serializer
-
       backend.fields = apply_fields_filters(
-        fields,
+        backend.fields,
         serializer_only_filters,
         serializer_except_filters
       )
-      backend.fields = backend.fields.map &:to_s
 
       backend.method_fields = apply_fields_filters(
-        method_fields,
+        backend.method_fields,
         serializer_only_filters,
         serializer_except_filters
       )
 
       backend.has_many_associations = build_associations(
         apply_association_filters(
-          serializer._has_many_associations,
+          backend.has_many_associations,
           serializer_only_filters,
           serializer_except_filters
         ),
@@ -36,44 +29,49 @@ module Panko
 
       backend.has_one_associations = build_associations(
         apply_association_filters(
-          serializer._has_one_associations,
+          backend.has_one_associations,
           serializer_only_filters,
           serializer_except_filters
         ),
         attributes_only_filters,
         attributes_except_filters
       )
+    end
+
+    def self.duplicate(descriptor)
+      backend = Panko::SerializationDescriptor.new
+
+      backend.type = descriptor.type
+
+      backend.fields = descriptor.fields
+      backend.method_fields = descriptor.method_fields
+
+      backend.has_many_associations = descriptor.has_many_associations
+      backend.has_one_associations = descriptor.has_one_associations
 
       backend
     end
 
-    def self.fields_of(serializer)
-      fields = []
-      method_fields = []
+    def self.build(serializer, options={})
+      backend = duplicate(serializer._descriptor)
 
-      serializer._attributes.each do |attribute|
-        if serializer.method_defined? attribute
-          method_fields << attribute
-        else
-          fields << attribute
-        end
-      end
+      apply_filters(backend, options)
 
-      return fields, method_fields
+      backend
     end
 
     def self.build_associations(associations, attributes_only_filters, attributes_except_filters)
-      associations.map do |association|
-        options = association[:options]
-        serializer_const = resolve_serializer(options[:serializer])
+      associations.each do |association|
+        name = association.first
+        descriptor = association.last
 
-        options[:only] = options.fetch(:only, []) + attributes_only_filters.fetch(association[:name], [])
-        options[:except] = options.fetch(:except, []) + attributes_except_filters.fetch(association[:name], [])
 
-        [
-          association[:name],
-          SerializationDescriptorBuilder.build(serializer_const, options.except(:serializer))
-        ]
+        options = {
+          only: attributes_only_filters.fetch(name, []),
+          except: attributes_except_filters.fetch(name, [])
+        }
+
+        apply_filters(descriptor, options)
       end
     end
 
@@ -88,6 +86,8 @@ module Panko
       # which mean, for the current instance use `[:a]` as filter
       # and for association named `foo` use `[:b]`
 
+      return [], {} if filters.empty?
+
       serializer_filters = filters.fetch(:instance, [])
       association_filters = filters.except(:instance)
 
@@ -95,19 +95,19 @@ module Panko
     end
 
     def self.apply_fields_filters(fields, only, except)
-      return fields & only if only.present?
-      return fields - except if except.present?
+      return fields & only unless only.empty?
+      return fields - except unless except.empty?
 
       fields
     end
 
     def self.apply_association_filters(associations, only, except)
-      if only.present?
-        return associations.select { |assoc| only.include?(assoc[:name]) }
+      unless only.empty?
+        return associations.select { |assoc| only.include?(assoc.first) }
       end
 
-      if except.present?
-        return associations.reject { |assoc| except.include?(assoc[:name]) }
+      unless except.empty?
+        return associations.reject { |assoc| except.include?(assoc.first) }
       end
 
       associations

data/lib/panko/serializer.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require_relative "cache"
 require_relative "serialization_descriptor"
 require "oj"
 
@@ -7,33 +6,48 @@ module Panko
   class Serializer
     class << self
       def inherited(base)
-        base._attributes = (_attributes || []).dup
-        base._has_one_associations = (_has_one_associations || []).dup
-        base._has_many_associations = (_has_many_associations || []).dup
+        base._descriptor = Panko::SerializationDescriptor.new
+        base._descriptor.type = base
 
-        @_attributes = []
-        @_has_one_associations = []
-        @_has_many_associations = []
+        base._descriptor.fields = []
+        base._descriptor.method_fields = []
+        base._descriptor.has_many_associations = []
+        base._descriptor.has_one_associations = []
       end
 
-      attr_accessor :_attributes, :_has_one_associations, :_has_many_associations
+      attr_accessor :_descriptor
 
       def attributes(*attrs)
-        @_attributes.push(*attrs).uniq!
+        @_descriptor.fields.push(*attrs).uniq!
+      end
+
+      def method_added(method)
+        return if @_descriptor.nil?
+        @_descriptor.fields.delete(method)
+        @_descriptor.method_fields << method
       end
 
       def has_one(name, options)
-        @_has_one_associations << { name: name, options: options }
+        serializer_const = SerializationDescriptorBuilder.resolve_serializer(options[:serializer])
+
+        @_descriptor.has_one_associations << [
+          name,
+          SerializationDescriptorBuilder.build(serializer_const, options)
+        ]
       end
 
       def has_many(name, options)
-        @_has_many_associations << { name: name, options: options }
+        serializer_const = SerializationDescriptorBuilder.resolve_serializer(options[:serializer])
+
+        @_descriptor.has_many_associations << [
+          name,
+          SerializationDescriptorBuilder.build(serializer_const, options)
+        ]
       end
     end
 
     def initialize(options = {})
-      @descriptor = Panko::CACHE.fetch(self.class, options)
-
+      @descriptor = SerializationDescriptorBuilder.build(self.class, options)
       @context = options[:context]
     end
 

data/lib/panko/version.rb

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

data/panko_serializer.gemspec

@@ -27,5 +27,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake-compiler"
 
   spec.add_dependency "oj", "~> 3.2.0"
-  spec.add_dependency "concurrent-ruby"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: panko_serializer
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Yosi Attias
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-22 00:00:00.000000000 Z
+date: 2017-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,20 +80,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 3.2.0
-- !ruby/object:Gem::Dependency
-  name: concurrent-ruby
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: 
 email:
 - yosy101@gmail.com
@@ -139,7 +125,6 @@ files:
 - ext/panko_serializer/type_cast.h
 - lib/panko.rb
 - lib/panko/array_serializer.rb
-- lib/panko/cache.rb
 - lib/panko/response.rb
 - lib/panko/serialization_descriptor.rb
 - lib/panko/serializer.rb
@@ -165,7 +150,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Fast serialization for ActiveModel

data/lib/panko/cache.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-require "concurrent"
-
-
-module Panko
-  # Serialer Descriptor Cache
-  class Cache
-    def initialize
-      @_cache = Concurrent::Map.new
-    end
-
-    def fetch(serializer_const, options)
-      serializer_key = build_key(serializer_const, options[:only], options[:except])
-      serializer = @_cache.compute_if_absent(serializer_key) {
-        SerializationDescriptorBuilder.build(serializer_const,
-                                             only: options.fetch(:only, []),
-                                             except: options.fetch(:except, [])
-                                            )
-      }
-
-      serializer
-    end
-
-    private
-
-    #
-    # Create key based on what we define unique serializer
-    #
-    def build_key(serializer_const, only, except)
-      [serializer_const, only, except].hash
-    end
-  end
-
-  CACHE = Panko::Cache.new
-end