panko_serializer 0.8.5 → 1.0.0

data/ext/panko_serializer/attributes_writer/type_cast/type_cast.c

@@ -1,409 +0,0 @@
-#include "type_cast.h"
-
-#include "time_conversion.h"
-
-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 oj_sc_parse_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_json_type = 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_jsonb_type = Qundef;
-static VALUE ar_pg_array_type = Qundef;
-static VALUE ar_pg_date_time_type = Qundef;
-static VALUE ar_pg_timestamp_type = Qundef;
-
-static int initiailized = 0;
-
-VALUE cache_postgres_type_lookup(VALUE ar) {
-  VALUE ar_connection_adapters, ar_postgresql, ar_oid;
-
-  if (rb_const_defined_at(ar, rb_intern("ConnectionAdapters")) != (int)Qtrue) {
-    return Qfalse;
-  }
-  ar_connection_adapters = rb_const_get_at(ar, rb_intern("ConnectionAdapters"));
-
-  if (rb_const_defined_at(ar_connection_adapters, rb_intern("PostgreSQL")) !=
-      (int)Qtrue) {
-    return Qfalse;
-  }
-  ar_postgresql =
-      rb_const_get_at(ar_connection_adapters, rb_intern("PostgreSQL"));
-
-  if (rb_const_defined_at(ar_postgresql, rb_intern("OID")) != (int)Qtrue) {
-    return Qfalse;
-  }
-  ar_oid = rb_const_get_at(ar_postgresql, rb_intern("OID"));
-
-  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("Jsonb")) == (int)Qtrue) {
-    ar_pg_jsonb_type = rb_const_get_at(ar_oid, rb_intern("Jsonb"));
-  }
-
-  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"));
-  }
-
-  if (rb_const_defined_at(ar_oid, rb_intern("Timestamp")) == (int)Qtrue) {
-    ar_pg_timestamp_type = rb_const_get_at(ar_oid, rb_intern("Timestamp"));
-  }
-
-  return Qtrue;
-}
-
-VALUE cache_time_zone_type_lookup(VALUE ar) {
-  VALUE ar_attr_methods, ar_time_zone_conversion;
-
-  // ActiveRecord::AttributeMethods
-  if (rb_const_defined_at(ar, rb_intern("AttributeMethods")) != (int)Qtrue) {
-    return Qfalse;
-  }
-  ar_attr_methods = rb_const_get_at(ar, rb_intern("AttributeMethods"));
-
-  // ActiveRecord::AttributeMethods::TimeZoneConversion
-  if (rb_const_defined_at(ar_attr_methods, rb_intern("TimeZoneConversion")) !=
-      (int)Qtrue) {
-    return Qfalse;
-  }
-  ar_time_zone_conversion =
-      rb_const_get_at(ar_attr_methods, rb_intern("TimeZoneConversion"));
-
-  if (rb_const_defined_at(ar_time_zone_conversion,
-                          rb_intern("TimeZoneConverter")) != (int)Qtrue) {
-    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, ar_type, ar_type_methods;
-
-  ar = rb_const_get_at(rb_cObject, rb_intern("ActiveRecord"));
-
-  // ActiveRecord::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"));
-  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"));
-
-  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")))) {
-    deserialize_from_db_id = rb_intern("deserialize");
-  } else {
-    deserialize_from_db_id = rb_intern("type_cast_from_database");
-  }
-
-  if (rb_const_defined_at(ar_type, rb_intern("Json")) == (int)Qtrue) {
-    ar_json_type = rb_const_get_at(ar_type, rb_intern("Json"));
-  }
-
-  int isErrored;
-  rb_protect(cache_postgres_type_lookup, ar, &isErrored);
-  if (isErrored) {
-    rb_set_errinfo(Qnil);
-  }
-
-  rb_protect(cache_time_zone_type_lookup, ar, &isErrored);
-  if (isErrored) {
-    rb_set_errinfo(Qnil);
-  }
-}
-
-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) ||
-          (ar_pg_jsonb_type != Qundef && type_klass == ar_pg_jsonb_type) ||
-          (ar_json_type != Qundef && type_klass == ar_json_type));
-}
-
-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) {
-    return Qnil;
-  }
-
-  if (RB_TYPE_P(value, T_STRING)) {
-    if (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;
-  }
-
-  if (RB_INTEGER_TYPE_P(value)) {
-    return value == INT2NUM(1) ? Qtrue : Qfalse;
-  }
-
-  return Qundef;
-}
-
-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_pg_timestamp_type != Qundef &&
-          type_klass == ar_pg_timestamp_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;
-    }
-
-    volatile VALUE iso8601_string = iso_ar_iso_datetime_string(val);
-    if (iso8601_string != Qnil) {
-      return iso8601_string;
-    }
-  }
-
-  return Qundef;
-}
-
-VALUE rescue_func(VALUE _arg, VALUE _data) { return Qfalse; }
-
-VALUE parse_json(VALUE value) {
-  return rb_funcall(oj_type, oj_sc_parse_id, 2, rb_cObject, value);
-}
-
-VALUE is_json_value(VALUE value) {
-  if (!RB_TYPE_P(value, T_STRING)) {
-    return value;
-  }
-
-  if (RSTRING_LEN(value) == 0) {
-    return Qfalse;
-  }
-
-  volatile VALUE result =
-      rb_rescue2(parse_json, value, rescue_func, Qundef, oj_parseerror_type, 0);
-
-  if (NIL_P(result)) {
-    return Qtrue;
-  }
-
-  if (result == Qfalse) {
-    return Qfalse;
-  }
-
-  // TODO: fix me!
-  return Qfalse;
-}
-
-VALUE type_cast(VALUE type_metadata, VALUE value, volatile VALUE* isJson) {
-  if (value == Qnil || value == Qundef) {
-    return value;
-  }
-
-  cache_type_lookup();
-
-  VALUE type_klass, typeCastedValue;
-
-  type_klass = CLASS_OF(type_metadata);
-  typeCastedValue = Qundef;
-
-  TypeCast typeCast;
-  for (typeCast = type_casts; typeCast->canCast != NULL; typeCast++) {
-    if (typeCast->canCast(type_klass)) {
-      typeCastedValue = typeCast->typeCast(value);
-      break;
-    }
-  }
-
-  if (is_json_type(type_klass)) {
-    if (is_json_value(value) == Qfalse) {
-      return Qnil;
-    }
-    *isJson = Qtrue;
-    return value;
-  }
-
-  if (typeCastedValue == Qundef) {
-    return rb_funcall(type_metadata, deserialize_from_db_id, 1, value);
-  }
-
-  return typeCastedValue;
-}
-
-VALUE public_type_cast(int argc, VALUE* argv, VALUE self) {
-  VALUE type_metadata, value, isJson;
-  rb_scan_args(argc, argv, "21", &type_metadata, &value, &isJson);
-
-  if (isJson == Qnil || isJson == Qundef) {
-    isJson = Qfalse;
-  }
-
-  return type_cast(type_metadata, value, &isJson);
-}
-
-void panko_init_type_cast(VALUE mPanko) {
-  to_s_id = rb_intern("to_s");
-  to_i_id = rb_intern("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"));
-  oj_sc_parse_id = rb_intern("sc_parse");
-
-  // TODO: pass 3 arguments here
-  rb_define_singleton_method(mPanko, "_type_cast", public_type_cast, -1);
-
-  panko_init_time(mPanko);
-
-  rb_global_variable(&oj_type);
-  rb_global_variable(&oj_parseerror_type);
-  rb_global_variable(&ar_string_type);
-  rb_global_variable(&ar_text_type);
-  rb_global_variable(&ar_float_type);
-  rb_global_variable(&ar_integer_type);
-  rb_global_variable(&ar_boolean_type);
-  rb_global_variable(&ar_date_time_type);
-  rb_global_variable(&ar_time_zone_converter);
-  rb_global_variable(&ar_json_type);
-  rb_global_variable(&ar_pg_integer_type);
-  rb_global_variable(&ar_pg_float_type);
-  rb_global_variable(&ar_pg_uuid_type);
-  rb_global_variable(&ar_pg_json_type);
-  rb_global_variable(&ar_pg_jsonb_type);
-  rb_global_variable(&ar_pg_array_type);
-  rb_global_variable(&ar_pg_date_time_type);
-  rb_global_variable(&ar_pg_timestamp_type);
-}

data/ext/panko_serializer/attributes_writer/type_cast/type_cast.h

@@ -1,81 +0,0 @@
-#pragma once
-
-#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},
-
-    {NULL, NULL}};
-
-extern VALUE type_cast(VALUE type_metadata, VALUE value,
-                       volatile VALUE* isJson);
-void panko_init_type_cast(VALUE mPanko);
-
-// Introduced in ruby 2.4
-#ifndef RB_INTEGER_TYPE_P
-#define RB_INTEGER_TYPE_P(obj) (RB_FIXNUM_P(obj) || RB_TYPE_P(obj, T_BIGNUM))
-#endif

data/ext/panko_serializer/common.h

@@ -1,9 +0,0 @@
-#pragma once
-
-#include <ruby.h>
-
-#define PANKO_SAFE_HASH_SIZE(hash) \
-  (hash == Qnil || hash == Qundef) ? 0 : RHASH_SIZE(hash)
-
-#define PANKO_EMPTY_HASH(hash) \
-  (hash == Qnil || hash == Qundef) ? 1 : (RHASH_SIZE(hash) == 0)

data/ext/panko_serializer/extconf.rb

@@ -1,28 +0,0 @@
-# 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

@@ -1,181 +0,0 @@
-#include "panko_serializer.h"
-
-#include <ruby.h>
-
-static ID push_value_id;
-static ID push_array_id;
-static ID push_object_id;
-static ID push_json_id;
-static ID pop_id;
-
-static ID to_a_id;
-
-static ID object_id;
-static ID serialization_context_id;
-
-static VALUE SKIP = Qundef;
-
-void write_value(VALUE str_writer, VALUE key, VALUE value, VALUE isJson) {
-  if (isJson == Qtrue) {
-    rb_funcall(str_writer, push_json_id, 2, value, key);
-  } else {
-    rb_funcall(str_writer, push_value_id, 2, value, key);
-  }
-}
-
-void serialize_method_fields(VALUE object, VALUE str_writer,
-                             SerializationDescriptor descriptor) {
-  if (RARRAY_LEN(descriptor->method_fields) == 0) {
-    return;
-  }
-
-  volatile VALUE method_fields, serializer, key;
-  long i;
-
-  method_fields = descriptor->method_fields;
-
-  serializer = descriptor->serializer;
-  rb_ivar_set(serializer, object_id, object);
-
-  for (i = 0; i < RARRAY_LEN(method_fields); i++) {
-    volatile VALUE raw_attribute = RARRAY_AREF(method_fields, i);
-    Attribute attribute = PANKO_ATTRIBUTE_READ(raw_attribute);
-
-    volatile VALUE result = rb_funcall(serializer, attribute->name_id, 0);
-    if (result != SKIP) {
-      key = attr_name_for_serialization(attribute);
-      write_value(str_writer, key, result, Qfalse);
-    }
-  }
-
-  rb_ivar_set(serializer, object_id, Qnil);
-}
-
-void serialize_fields(VALUE object, VALUE str_writer,
-                      SerializationDescriptor descriptor) {
-  descriptor->attributes_writer.write_attributes(object, descriptor->attributes,
-                                                 write_value, str_writer);
-
-  serialize_method_fields(object, str_writer, descriptor);
-}
-
-void serialize_has_one_associations(VALUE object, VALUE str_writer,
-                                    VALUE associations) {
-  long i;
-  for (i = 0; i < RARRAY_LEN(associations); i++) {
-    volatile VALUE association_el = RARRAY_AREF(associations, i);
-    Association association = association_read(association_el);
-
-    volatile VALUE value = rb_funcall(object, association->name_id, 0);
-
-    if (NIL_P(value)) {
-      write_value(str_writer, association->name_str, value, Qfalse);
-    } else {
-      serialize_object(association->name_str, value, str_writer,
-                       association->descriptor);
-    }
-  }
-}
-
-void serialize_has_many_associations(VALUE object, VALUE str_writer,
-                                     VALUE associations) {
-  long i;
-  for (i = 0; i < RARRAY_LEN(associations); i++) {
-    volatile VALUE association_el = RARRAY_AREF(associations, i);
-    Association association = association_read(association_el);
-
-    volatile VALUE value = rb_funcall(object, association->name_id, 0);
-
-    if (NIL_P(value)) {
-      write_value(str_writer, association->name_str, value, Qfalse);
-    } else {
-      serialize_objects(association->name_str, value, str_writer,
-                        association->descriptor);
-    }
-  }
-}
-
-VALUE serialize_object(VALUE key, VALUE object, VALUE str_writer,
-                       SerializationDescriptor descriptor) {
-  sd_set_writer(descriptor, object);
-
-  rb_funcall(str_writer, push_object_id, 1, key);
-
-  serialize_fields(object, str_writer, descriptor);
-
-  if (RARRAY_LEN(descriptor->has_one_associations) > 0) {
-    serialize_has_one_associations(object, str_writer,
-                                   descriptor->has_one_associations);
-  }
-
-  if (RARRAY_LEN(descriptor->has_many_associations) > 0) {
-    serialize_has_many_associations(object, str_writer,
-                                    descriptor->has_many_associations);
-  }
-
-  rb_funcall(str_writer, pop_id, 0);
-
-  return Qnil;
-}
-
-VALUE serialize_objects(VALUE key, VALUE objects, VALUE str_writer,
-                        SerializationDescriptor descriptor) {
-  long i;
-
-  rb_funcall(str_writer, push_array_id, 1, key);
-
-  if (!RB_TYPE_P(objects, T_ARRAY)) {
-    objects = rb_funcall(objects, to_a_id, 0);
-  }
-
-  for (i = 0; i < RARRAY_LEN(objects); i++) {
-    volatile VALUE object = RARRAY_AREF(objects, i);
-    serialize_object(Qnil, object, str_writer, descriptor);
-  }
-
-  rb_funcall(str_writer, pop_id, 0);
-
-  return Qnil;
-}
-
-VALUE serialize_object_api(VALUE klass, VALUE object, VALUE str_writer,
-                           VALUE descriptor) {
-  SerializationDescriptor sd = sd_read(descriptor);
-  return serialize_object(Qnil, object, str_writer, sd);
-}
-
-VALUE serialize_objects_api(VALUE klass, VALUE objects, VALUE str_writer,
-                            VALUE descriptor) {
-  serialize_objects(Qnil, objects, str_writer, sd_read(descriptor));
-
-  return Qnil;
-}
-
-void Init_panko_serializer() {
-  push_value_id = rb_intern("push_value");
-  push_array_id = rb_intern("push_array");
-  push_object_id = rb_intern("push_object");
-  push_json_id = rb_intern("push_json");
-  pop_id = rb_intern("pop");
-  to_a_id = rb_intern("to_a");
-  object_id = rb_intern("@object");
-  serialization_context_id = rb_intern("@serialization_context");
-
-  VALUE mPanko = rb_define_module("Panko");
-
-  rb_define_singleton_method(mPanko, "serialize_object", serialize_object_api,
-                             3);
-
-  rb_define_singleton_method(mPanko, "serialize_objects", serialize_objects_api,
-                             3);
-
-  VALUE mPankoSerializer = rb_const_get(mPanko, rb_intern("Serializer"));
-  SKIP = rb_const_get(mPankoSerializer, rb_intern("SKIP"));
-  rb_global_variable(&SKIP);
-
-  panko_init_serialization_descriptor(mPanko);
-  init_attributes_writer(mPanko);
-  panko_init_type_cast(mPanko);
-  panko_init_attribute(mPanko);
-  panko_init_association(mPanko);
-}