panko_serializer 0.1.1

data/ext/panko_serializer/serialization_descriptor.c

@@ -0,0 +1,166 @@
+#include "serialization_descriptor.h"
+
+VALUE cSerializationDescriptor;
+
+static ID context_id = 0;
+static ID object_id = 0;
+
+static void serialization_descriptor_free(void* ptr) {
+  if (ptr == 0) {
+    return;
+  }
+
+  SerializationDescriptor sd = (SerializationDescriptor)ptr;
+  sd->serializer_type = Qnil;
+  sd->serializer = Qnil;
+  sd->fields = Qnil;
+  sd->method_fields = Qnil;
+  sd->has_one_associations = Qnil;
+  sd->has_many_associations = Qnil;
+}
+
+void serialization_descriptor_mark(SerializationDescriptor data) {
+  rb_gc_mark(data->serializer_type);
+  rb_gc_mark(data->serializer);
+  rb_gc_mark(data->fields);
+  rb_gc_mark(data->method_fields);
+  rb_gc_mark(data->has_one_associations);
+  rb_gc_mark(data->has_many_associations);
+}
+
+static VALUE serialization_descriptor_new(int argc, VALUE* argv, VALUE self) {
+  SerializationDescriptor sd = ALLOC(struct _SerializationDescriptor);
+
+  sd->serializer = Qnil;
+  sd->serializer_type = Qnil;
+  sd->fields = Qnil;
+  sd->method_fields = Qnil;
+  sd->has_one_associations = Qnil;
+  sd->has_many_associations = Qnil;
+
+  return Data_Wrap_Struct(cSerializationDescriptor,
+                          serialization_descriptor_mark,
+                          serialization_descriptor_free, sd);
+}
+
+SerializationDescriptor sd_read(VALUE descriptor) {
+  return (SerializationDescriptor)DATA_PTR(descriptor);
+}
+
+VALUE sd_build_serializer(SerializationDescriptor sd) {
+  // We build the serializer and cache it on demand,
+  // because of our cache - we lock and create descriptor, while inside
+  // a descriptor we can't create another descriptor - deadlock.
+  if (sd->serializer == Qnil) {
+    VALUE args[0];
+    sd->serializer = rb_class_new_instance(0, args, sd->serializer_type);
+  }
+
+  return sd->serializer;
+}
+
+void sd_apply_serializer_config(VALUE serializer, VALUE object, VALUE context) {
+  rb_ivar_set(serializer, object_id, object);
+  rb_ivar_set(serializer, context_id, context);
+}
+
+
+VALUE serialization_descriptor_fields_set(VALUE self, VALUE fields) {
+  SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
+
+  sd->fields = fields;
+  return Qnil;
+}
+
+VALUE serialization_descriptor_fields_ref(VALUE self) {
+  SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
+  return sd->fields;
+}
+
+VALUE serialization_descriptor_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) {
+  SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
+  return sd->method_fields;
+}
+
+VALUE serialization_descriptor_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) {
+  SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
+  return sd->has_one_associations;
+}
+
+VALUE serialization_descriptor_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) {
+  SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
+  return sd->has_many_associations;
+}
+
+VALUE serialization_descriptor_type_set(VALUE self, VALUE type) {
+  SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
+  sd->serializer_type = type;
+  return Qnil;
+}
+
+// Exposing this for testing
+VALUE serialization_descriptor_build_serializer(VALUE self) {
+  SerializationDescriptor sd = (SerializationDescriptor)DATA_PTR(self);
+  return sd_build_serializer(sd);
+}
+
+void panko_init_serialization_descriptor(VALUE mPanko) {
+  CONST_ID(object_id, "@object");
+  CONST_ID(context_id, "@context");
+
+  cSerializationDescriptor =
+      rb_define_class_under(mPanko, "SerializationDescriptor", rb_cObject);
+
+  rb_define_module_function(cSerializationDescriptor, "new",
+                            serialization_descriptor_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,
+                   "method_fields=", serialization_descriptor_method_fields_set,
+                   1);
+  rb_define_method(cSerializationDescriptor, "method_fields",
+                   serialization_descriptor_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",
+                   serialization_descriptor_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",
+                   serialization_descriptor_has_many_associations_ref, 0);
+
+  rb_define_method(cSerializationDescriptor,
+                   "type=", serialization_descriptor_type_set, 1);
+
+  rb_define_method(cSerializationDescriptor, "build_serializer",
+                   serialization_descriptor_build_serializer, 0);
+}

data/ext/panko_serializer/serialization_descriptor.h

@@ -0,0 +1,30 @@
+#include <ruby.h>
+
+#ifndef __SD_H__
+#define __SD_H__
+
+typedef struct _SerializationDescriptor {
+  // type of the serializer, so we can create it later
+  VALUE serializer_type;
+  // Cached value of the serializer
+  VALUE serializer;
+
+  // Metadata
+  VALUE fields;
+  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);
+VALUE sd_build_serializer(SerializationDescriptor descriptor);
+void sd_apply_serializer_config(VALUE serializer, VALUE object, VALUE context);
+
+void panko_init_serialization_descriptor(VALUE mPanko);
+
+#endif

data/ext/panko_serializer/time_conversion.c

@@ -0,0 +1,94 @@
+#include "time_conversion.h"
+
+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;
+
+  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);
+
+  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);
+}
+
+VALUE iso_ar_iso_datetime_string(const char* value) {
+  const UChar *start, *range, *end;
+  OnigRegion* region = onig_region_new();
+
+  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);
+
+  VALUE output = Qnil;
+  if (r >= 0) {
+    char buf[21];
+    sprintf(buf, "");
+
+    append_region_part(buf, value, region, 1);
+    strncat(buf, "-", 1);
+
+    append_region_part(buf, value, region, 2);
+    strncat(buf, "-", 1);
+
+    append_region_part(buf, value, region, 3);
+    strncat(buf, "T", 1);
+
+    append_region_part(buf, value, region, 4);
+    strncat(buf, ":", 1);
+
+    append_region_part(buf, value, region, 5);
+    strncat(buf, ":", 1);
+
+    append_region_part(buf, value, region, 6);
+    strncat(buf, "Z", 1);
+
+    output = rb_str_new(buf, strlen(buf));
+  }
+
+  onig_region_free(region, 1);
+  return output;
+}
+
+void build_regex(OnigRegex* reg, const UChar* pattern) {
+  OnigErrorInfo einfo;
+
+  int r = onig_new(reg, pattern, pattern + strlen((char*)pattern),
+                   ONIG_OPTION_DEFAULT, ONIG_ENCODING_ASCII,
+                   ONIG_SYNTAX_DEFAULT, &einfo);
+
+  if (r != ONIG_NORMAL) {
+    char s[ONIG_MAX_ERROR_MESSAGE_LEN];
+    onig_error_code_to_str((UChar*)s, r, &einfo);
+    printf("ERROR: %s\n", s);
+  }
+}
+
+void panko_init_time(VALUE mPanko) {
+  const UChar* 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 =
+      (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/time_conversion.h

@@ -0,0 +1,6 @@
+#include <ruby.h>
+#include <ruby/oniguruma.h>
+
+VALUE is_iso8601_time_string(const char* value);
+VALUE iso_ar_iso_datetime_string(const char* value);
+void panko_init_time(VALUE mPanko);

data/ext/panko_serializer/type_cast.c

@@ -0,0 +1,271 @@
+#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;
+
+// Caching ActiveRecord Types
+static VALUE ar_string_type = Qundef;
+static VALUE ar_text_type = Qundef;
+static VALUE ar_float_type = Qundef;
+static VALUE ar_integer_type = Qundef;
+static VALUE ar_boolean_type = Qundef;
+static VALUE ar_date_time_type = Qundef;
+static VALUE ar_time_zone_converter = Qundef;
+
+static VALUE ar_pg_integer_type = Qundef;
+static VALUE ar_pg_float_type = Qundef;
+static VALUE ar_pg_uuid_type = Qundef;
+static VALUE ar_pg_json_type = Qundef;
+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"));
+  if (ar_connection_adapters == Qundef) {
+    return Qfalse;
+  }
+
+  VALUE 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"));
+  if (ar_oid == Qundef) {
+    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"));
+
+  return Qtrue;
+}
+
+VALUE cache_time_zone_type_lookup(VALUE ar) {
+  // ActiveRecord::AttributeMethods
+  VALUE 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 =
+      rb_const_get_at(ar_attr_methods, rb_intern("TimeZoneConversion"));
+  if (ar_time_zone_conversion == Qundef) {
+    return Qfalse;
+  }
+
+  ar_time_zone_converter =
+      rb_const_get_at(ar_time_zone_conversion, rb_intern("TimeZoneConverter"));
+
+  return Qtrue;
+}
+
+void cache_type_lookup() {
+  if (initiailized == 1) {
+    return;
+  }
+
+  initiailized = 1;
+
+  VALUE ar = rb_const_get_at(rb_cObject, rb_intern("ActiveRecord"));
+
+  // ActiveRecord::Type
+  VALUE 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"));
+  ar_float_type = rb_const_get_at(ar_type, rb_intern("Float"));
+  ar_integer_type = rb_const_get_at(ar_type, rb_intern("Integer"));
+  ar_boolean_type = rb_const_get_at(ar_type, rb_intern("Boolean"));
+  ar_date_time_type = rb_const_get_at(ar_type, rb_intern("DateTime"));
+
+  // TODO: if we get error or not, add this to some debug log
+  int isErrored;
+  rb_protect(cache_postgres_type_lookup, ar, &isErrored);
+
+  rb_protect(cache_time_zone_type_lookup, ar, &isErrored);
+}
+
+bool is_string_or_text_type(VALUE type_klass) {
+  return type_klass == ar_string_type || type_klass == ar_text_type ||
+         (ar_pg_uuid_type != Qundef && type_klass == ar_pg_uuid_type);
+}
+
+VALUE cast_string_or_text_type(VALUE value) {
+  if (RB_TYPE_P(value, T_STRING)) {
+    return value;
+  }
+
+  if (value == Qtrue) {
+    return rb_str_new_cstr("t");
+  }
+
+  if (value == Qfalse) {
+    return rb_str_new_cstr("f");
+  }
+
+  return rb_funcall(value, to_s_id, 0);
+}
+
+bool is_float_type(VALUE type_klass) {
+  return type_klass == ar_float_type ||
+         (ar_pg_float_type != Qundef && type_klass == ar_pg_float_type);
+}
+
+VALUE cast_float_type(VALUE value) {
+  if (RB_TYPE_P(value, T_FLOAT)) {
+    return value;
+  }
+
+  if (RB_TYPE_P(value, T_STRING)) {
+    const char* val = StringValuePtr(value);
+    return rb_float_new(strtod(val, NULL));
+  }
+
+  return Qundef;
+}
+
+bool is_integer_type(VALUE type_klass) {
+  return type_klass == ar_integer_type ||
+         (ar_pg_integer_type != Qundef && type_klass == ar_pg_integer_type);
+}
+
+VALUE cast_integer_type(VALUE value) {
+  if (RB_INTEGER_TYPE_P(value)) {
+    return value;
+  }
+
+  if (RB_TYPE_P(value, T_STRING)) {
+    const char* val = StringValuePtr(value);
+    if (strlen(val) == 0) {
+      return Qnil;
+    }
+    return rb_cstr2inum(val, 10);
+  }
+
+  if (RB_FLOAT_TYPE_P(value)) {
+    // We are calling the `to_i` here, because ruby internal
+    // `flo_to_i` is not accessible
+    return rb_funcall(value, to_i_id, 0);
+  }
+
+  if (value == Qtrue) {
+    return INT2NUM(1);
+  }
+
+  if (value == Qfalse) {
+    return INT2NUM(0);
+  }
+
+  // At this point, we handled integer, float, string and booleans
+  // any thing other than this (array, hashes, etc) should result in nil
+  return Qnil;
+}
+
+bool is_json_type(VALUE type_klass) {
+  return ar_pg_json_type != Qundef && type_klass == ar_pg_json_type;
+}
+
+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;
+}
+
+bool is_boolean_type(VALUE type_klass) {
+  return type_klass == ar_boolean_type;
+}
+
+VALUE cast_boolean_type(VALUE value) {
+  if (value == Qtrue || value == Qfalse) {
+    return value;
+  }
+
+  if (value == Qnil || RSTRING_LEN(value) == 0) {
+    return Qnil;
+  }
+
+  const char* val = StringValuePtr(value);
+  bool isFalseValue =
+      (*val == '0' || (*val == 'f' || *val == 'F') ||
+       (strcmp(val, "false") == 0 || strcmp(val, "FALSE") == 0) ||
+       (strcmp(val, "off") == 0 || strcmp(val, "OFF") == 0));
+
+  return isFalseValue ? Qfalse : Qtrue;
+}
+
+bool is_date_time_type(VALUE type_klass) {
+  return (type_klass == ar_date_time_type) ||
+         (ar_pg_date_time_type != Qundef &&
+          type_klass == ar_pg_date_time_type) ||
+         (ar_time_zone_converter != Qundef &&
+          type_klass == ar_time_zone_converter);
+}
+
+VALUE cast_date_time_type(VALUE value) {
+  // Instead of take strings to comparing them to time zones
+  // and then comparing them back to string
+  // We will just make sure we have string on ISO8601 and it's utc
+  if (RB_TYPE_P(value, T_STRING)) {
+    const char* val = StringValuePtr(value);
+    // 'Z' in ISO8601 says it's UTC
+    if (val[strlen(val) - 1] == 'Z' && is_iso8601_time_string(val) == Qtrue) {
+      return value;
+    }
+
+    VALUE iso8601_string = iso_ar_iso_datetime_string(val);
+    if (iso8601_string != Qnil) {
+      return iso8601_string;
+    }
+  }
+
+  return Qundef;
+}
+
+VALUE type_cast(VALUE type_metadata, VALUE value) {
+  cache_type_lookup();
+
+  VALUE type_klass = CLASS_OF(type_metadata);
+  VALUE typeCastedValue = Qundef;
+
+  TypeCast typeCast;
+  for (typeCast = type_casts; typeCast->canCast != NULL; typeCast++) {
+    if (typeCast->canCast(type_klass)) {
+      typeCastedValue = typeCast->typeCast(value);
+      break;
+    }
+  }
+
+  if (typeCastedValue == Qundef) {
+    return rb_funcall(type_metadata, type_cast_from_database_id, 1, value);
+  }
+
+  return typeCastedValue;
+}
+
+VALUE public_type_cast(VALUE module, VALUE type_metadata, VALUE value) {
+  return type_cast(type_metadata, value);
+}
+
+void panko_init_type_cast(VALUE mPanko) {
+  type_cast_from_database_id = rb_intern_const("type_cast_from_database");
+  to_s_id = rb_intern_const("to_s");
+  to_i_id = rb_intern_const("to_i");
+
+  rb_define_singleton_method(mPanko, "_type_cast", public_type_cast, 2);
+
+  panko_init_time(mPanko);
+}

data/ext/panko_serializer/type_cast.h

@@ -0,0 +1,74 @@
+#include <ruby.h>
+#include <stdbool.h>
+
+/*
+ * Type Casting
+ *
+ * We do "special" type casting which is mix of two inspirations:
+ *  *) light records gem
+ *  *) pg TextDecoders
+ *
+ * The whole idea behind those type casts, are to do the minimum required
+ * type casting in the most performant manner and *allocation free*.
+ *
+ * For example, in `ActiveRecord::Type::String` the type_cast_from_database
+ * creates new string, for known reasons, but, in serialization flow we don't
+ * need to create new string becuase we afraid of mutations.
+ *
+ * Since we know before hand, that we are only reading from the database, and
+ * *not* writing and the end result if for JSON we can skip some "defenses".
+ */
+
+typedef bool (*TypeMatchFunc)(VALUE type_klass);
+
+/*
+ * TypeCastFunc
+ *
+ * @return VALUE casted value or Qundef if not casted
+ */
+typedef VALUE (*TypeCastFunc)(VALUE value);
+
+typedef struct _TypeCast {
+  TypeMatchFunc canCast;
+  TypeCastFunc typeCast;
+} * TypeCast;
+
+// ActiveRecord::Type::String
+// ActiveRecord::Type::Text
+bool is_string_or_text_type(VALUE type_klass);
+VALUE cast_string_or_text_type(VALUE value);
+
+// ActiveRecord::Type::Float
+bool is_float_type(VALUE type_klass);
+VALUE cast_float_type(VALUE value);
+
+// ActiveRecord::Type::Integer
+bool is_integer_type(VALUE type_klass);
+VALUE cast_integer_type(VALUE value);
+
+// ActiveRecord::ConnectoinAdapters::PostgreSQL::Json
+bool is_json_type(VALUE type_klass);
+VALUE cast_json_type(VALUE value);
+
+// ActiveRecord::Type::Boolean
+bool is_boolean_type(VALUE type_klass);
+VALUE cast_boolean_type(VALUE value);
+
+// ActiveRecord::Type::DateTime
+// ActiveRecord::ConnectionAdapters::PostgreSQL::OID::DateTime
+// ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter
+bool is_date_time_type(VALUE type_klass);
+VALUE cast_date_time_type(VALUE value);
+
+static struct _TypeCast type_casts[] = {
+    {is_string_or_text_type, cast_string_or_text_type},
+    {is_integer_type, cast_integer_type},
+    {is_boolean_type, cast_boolean_type},
+    {is_date_time_type, cast_date_time_type},
+    {is_float_type, cast_float_type},
+    {is_json_type, cast_json_type},
+
+    {NULL, NULL}};
+
+extern VALUE type_cast(VALUE type_metadata, VALUE value);
+void panko_init_type_cast(VALUE mPanko);

data/lib/panko/array_serializer.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require_relative "cache"
+
+module Panko
+  class ArraySerializer
+    attr_accessor :subjects
+
+    def initialize(subjects, options = {})
+      @subjects = subjects
+      @each_serializer = options[:each_serializer]
+
+
+      serializer_options = {
+        only: options.fetch(:only, []),
+        except: options.fetch(:except, [])
+      }
+
+      @descriptor = Panko::CACHE.fetch(@each_serializer, serializer_options)
+      @context = options.fetch(:context, nil)
+    end
+
+    def to_json
+      serialize_to_json @subjects
+    end
+
+    def serialize(subjects)
+      Oj.load(serialize_to_json(subjects))
+    end
+
+    def to_a
+      Oj.load(serialize_to_json(@subjects))
+    end
+
+    def serialize_to_json(subjects)
+      writer = Oj::StringWriter.new(mode: :rails)
+      Panko::serialize_subjects(subjects.to_a, writer, @descriptor, @context)
+      writer.to_s
+    end
+  end
+end