RocketAMF-ouvrages 1.0.0

data/ext/rocketamf_ext/deserializer.h

@@ -0,0 +1,27 @@
+#include <ruby.h>
+#ifdef HAVE_RB_STR_ENCODE
+#include <ruby/encoding.h>
+#endif
+
+typedef struct {
+    int version;
+    VALUE class_mapper;
+    VALUE src;
+    char* stream;
+    unsigned long pos;
+    unsigned long size;
+    VALUE obj_cache;
+    VALUE str_cache;
+    VALUE trait_cache;
+} AMF_DESERIALIZER;
+
+char des_read_byte(AMF_DESERIALIZER *des);
+int des_read_uint16(AMF_DESERIALIZER *des);
+unsigned int des_read_uint32(AMF_DESERIALIZER *des);
+double des_read_double(AMF_DESERIALIZER *des);
+int des_read_int(AMF_DESERIALIZER *des);
+VALUE des_read_string(AMF_DESERIALIZER *des, unsigned int len);
+VALUE des_read_sym(AMF_DESERIALIZER *des, unsigned int len);
+void des_set_src(AMF_DESERIALIZER *des, VALUE src);
+
+VALUE des_deserialize(VALUE self, VALUE ver, VALUE src);

data/ext/rocketamf_ext/extconf.rb

@@ -0,0 +1,18 @@
+require 'mkmf'
+
+# Disable the native extension by creating an empty Makefile on JRuby
+if defined? JRUBY_VERSION
+  message "Generating phony Makefile for JRuby so the gem installs"
+  mfile = File.join(File.dirname(__FILE__), 'Makefile')
+  File.open(mfile, 'w') {|f| f.write dummy_makefile(File.dirname(__FILE__)) }
+  exit 0
+end
+
+if enable_config("sort-props", false)
+  $defs.push("-DSORT_PROPS") unless $defs.include? "-DSORT_PROPS"
+end
+have_func('rb_str_encode')
+
+$CFLAGS += " -Wall"
+
+create_makefile('rocketamf_ext')

data/ext/rocketamf_ext/remoting.c

@@ -0,0 +1,184 @@
+#include "deserializer.h"
+#include "serializer.h"
+#include "constants.h"
+
+extern VALUE mRocketAMF;
+extern VALUE mRocketAMFExt;
+extern VALUE cDeserializer;
+extern VALUE cSerializer;
+VALUE cRocketAMFHeader;
+VALUE cRocketAMFMessage;
+VALUE cRocketAMFAbstractMessage;
+ID id_amf_version;
+ID id_headers;
+ID id_messages;
+ID id_data;
+
+/*
+ * call-seq:
+ *   env.populate_from_stream(stream, class_mapper=nil)
+ *
+ * Included into RocketAMF::Envelope, this method handles deserializing an AMF
+ * request/response into the envelope
+ */
+static VALUE env_populate_from_stream(int argc, VALUE *argv, VALUE self) {
+    static VALUE cClassMapper = 0;
+    if(cClassMapper == 0) cClassMapper = rb_const_get(mRocketAMF, rb_intern("ClassMapper"));
+
+    // Parse args
+    VALUE src;
+    VALUE class_mapper;
+    rb_scan_args(argc, argv, "11", &src, &class_mapper);
+    if(class_mapper == Qnil) class_mapper = rb_class_new_instance(0, NULL, cClassMapper);
+
+    // Create AMF0 deserializer
+    VALUE args[3];
+    args[0] = class_mapper;
+    VALUE des_rb = rb_class_new_instance(1, args, cDeserializer);
+    AMF_DESERIALIZER *des;
+    Data_Get_Struct(des_rb, AMF_DESERIALIZER, des);
+    des_set_src(des, src);
+
+    // Read amf version
+    int amf_ver = des_read_uint16(des);
+
+    // Read headers
+    VALUE headers = rb_hash_new();
+    int header_cnt = des_read_uint16(des);
+    int i;
+    for(i = 0; i < header_cnt; i++) {
+        VALUE name = des_read_string(des, des_read_uint16(des));
+        VALUE must_understand = des_read_byte(des) != 0 ? Qtrue : Qfalse;
+        des_read_uint32(des); // Length is ignored
+        VALUE data = des_deserialize(des_rb, INT2FIX(0), Qnil);
+
+        args[0] = name;
+        args[1] = must_understand;
+        args[2] = data;
+        rb_hash_aset(headers, name, rb_class_new_instance(3, args, cRocketAMFHeader));
+    }
+
+    // Read messages
+    VALUE messages = rb_ary_new();
+    int message_cnt = des_read_uint16(des);
+    for(i = 0; i < message_cnt; i++) {
+        VALUE target_uri = des_read_string(des, des_read_uint16(des));
+        VALUE response_uri = des_read_string(des, des_read_uint16(des));
+        des_read_uint32(des); // Length is ignored
+        VALUE data = des_deserialize(des_rb, INT2FIX(0), Qnil);
+
+        // If they're using the flex remoting APIs, remove array wrapper
+        if(TYPE(data) == T_ARRAY && RARRAY_LEN(data) == 1 && rb_obj_is_kind_of(RARRAY_PTR(data)[0], cRocketAMFAbstractMessage) == Qtrue) {
+            data = RARRAY_PTR(data)[0];
+        }
+
+        args[0] = target_uri;
+        args[1] = response_uri;
+        args[2] = data;
+        rb_ary_push(messages, rb_class_new_instance(3, args, cRocketAMFMessage));
+    }
+
+    // Populate remoting object
+    rb_ivar_set(self, id_amf_version, INT2FIX(amf_ver));
+    rb_ivar_set(self, id_headers, headers);
+    rb_ivar_set(self, id_messages, messages);
+
+    return self;
+}
+
+/*
+ * call-seq:
+ *   env.serialize(class_mapper=nil)
+ *
+ * Included into RocketAMF::Envelope, this method handles serializing an AMF
+ * request/response into a string
+ */
+static VALUE env_serialize(int argc, VALUE *argv, VALUE self) {
+    static VALUE cClassMapper = 0;
+    if(cClassMapper == 0) cClassMapper = rb_const_get(mRocketAMF, rb_intern("ClassMapper"));
+
+    // Parse args
+    VALUE class_mapper;
+    rb_scan_args(argc, argv, "01", &class_mapper);
+    if(class_mapper == Qnil) class_mapper = rb_class_new_instance(0, NULL, cClassMapper);
+
+    // Get instance variables
+    long amf_ver = FIX2LONG(rb_ivar_get(self, id_amf_version));
+    VALUE headers = rb_funcall(rb_ivar_get(self, id_headers), rb_intern("values"), 0); // Get array of header values
+    VALUE messages = rb_ivar_get(self, id_messages);
+
+    // Create AMF0 serializer
+    VALUE args[1] = {class_mapper};
+    VALUE ser_rb = rb_class_new_instance(1, args, cSerializer);
+    AMF_SERIALIZER *ser;
+    Data_Get_Struct(ser_rb, AMF_SERIALIZER, ser);
+
+    // Write version
+    ser_write_uint16(ser, amf_ver);
+
+    // Write headers
+    long header_cnt = RARRAY_LEN(headers);
+    ser_write_uint16(ser, header_cnt);
+    int i;
+    char *str;
+    long str_len;
+    for(i = 0; i < header_cnt; i++) {
+        VALUE header = RARRAY_PTR(headers)[i];
+
+        // Write header name
+        ser_get_string(rb_funcall(header, rb_intern("name"), 0), Qtrue, &str, &str_len);
+        ser_write_uint16(ser, str_len);
+        rb_str_buf_cat(ser->stream, str, str_len);
+
+        // Write understand flag
+        ser_write_byte(ser, rb_funcall(header, rb_intern("must_understand"), 0) == Qtrue ? 1 : 0);
+
+        // Serialize data
+        ser_write_uint32(ser, -1); // length of data - -1 if you don't know
+        ser_serialize(ser_rb, INT2FIX(0), rb_funcall(header, id_data, 0));
+    }
+
+    // Write messages
+    long message_cnt = RARRAY_LEN(messages);
+    ser_write_uint16(ser, message_cnt);
+    for(i = 0; i < message_cnt; i++) {
+        VALUE message = RARRAY_PTR(messages)[i];
+
+        // Write target_uri
+        ser_get_string(rb_funcall(message, rb_intern("target_uri"), 0), Qtrue, &str, &str_len);
+        ser_write_uint16(ser, str_len);
+        rb_str_buf_cat(ser->stream, str, str_len);
+
+        // Write response_uri
+        ser_get_string(rb_funcall(message, rb_intern("response_uri"), 0), Qtrue, &str, &str_len);
+        ser_write_uint16(ser, str_len);
+        rb_str_buf_cat(ser->stream, str, str_len);
+
+        // Serialize data
+        ser_write_uint32(ser, -1); // length of data - -1 if you don't know
+        if(amf_ver == 3) {
+            ser_write_byte(ser, AMF0_AMF3_MARKER);
+            ser_serialize(ser_rb, INT2FIX(3), rb_funcall(message, id_data, 0));
+        } else {
+            ser_serialize(ser_rb, INT2FIX(0), rb_funcall(message, id_data, 0));
+        }
+    }
+
+    return ser->stream;
+}
+
+
+void Init_rocket_amf_remoting() {
+    VALUE mEnvelope = rb_define_module_under(mRocketAMFExt, "Envelope");
+    rb_define_method(mEnvelope, "populate_from_stream", env_populate_from_stream, -1);
+    rb_define_method(mEnvelope, "serialize", env_serialize, -1);
+
+    // Get refs to commonly used symbols and ids
+    id_amf_version = rb_intern("@amf_version");
+    id_headers = rb_intern("@headers");
+    id_messages = rb_intern("@messages");
+    id_data = rb_intern("data");
+    cRocketAMFHeader = rb_const_get(mRocketAMF, rb_intern("Header"));
+    cRocketAMFMessage = rb_const_get(mRocketAMF, rb_intern("Message"));
+    cRocketAMFAbstractMessage = rb_const_get(rb_const_get(mRocketAMF, rb_intern("Values")), rb_intern("AbstractMessage"));
+}

data/ext/rocketamf_ext/rocketamf_ext.c

@@ -0,0 +1,38 @@
+#include <ruby.h>
+
+VALUE mRocketAMF;
+VALUE mRocketAMFExt;
+VALUE cDeserializer;
+VALUE cSerializer;
+VALUE cStringIO;
+VALUE cDate;
+VALUE cDateTime;
+VALUE sym_class_name;
+VALUE sym_members;
+VALUE sym_externalizable;
+VALUE sym_dynamic;
+
+void Init_rocket_amf_deserializer();
+void Init_rocket_amf_serializer();
+void Init_rocket_amf_fast_class_mapping();
+void Init_rocket_amf_remoting();
+
+void Init_rocketamf_ext() {
+    mRocketAMF = rb_define_module("RocketAMF");
+    mRocketAMFExt = rb_define_module_under(mRocketAMF, "Ext");
+
+    // Set up classes
+    Init_rocket_amf_deserializer();
+    Init_rocket_amf_serializer();
+    Init_rocket_amf_fast_class_mapping();
+    Init_rocket_amf_remoting();
+
+    // Get refs to commonly used symbols and ids
+    cStringIO = rb_const_get(rb_cObject, rb_intern("StringIO"));
+    cDate = rb_const_get(rb_cObject, rb_intern("Date"));
+    cDateTime = rb_const_get(rb_cObject, rb_intern("DateTime"));
+    sym_class_name = ID2SYM(rb_intern("class_name"));
+    sym_members = ID2SYM(rb_intern("members"));
+    sym_externalizable = ID2SYM(rb_intern("externalizable"));
+    sym_dynamic = ID2SYM(rb_intern("dynamic"));
+}

data/ext/rocketamf_ext/serializer.c

@@ -0,0 +1,834 @@
+#include "serializer.h"
+#include "constants.h"
+#include "utility.h"
+
+extern VALUE mRocketAMF;
+extern VALUE mRocketAMFExt;
+extern VALUE cSerializer;
+extern VALUE cStringIO;
+extern VALUE cDate;
+extern VALUE cDateTime;
+extern VALUE sym_class_name;
+extern VALUE sym_members;
+extern VALUE sym_externalizable;
+extern VALUE sym_dynamic;
+VALUE cArrayCollection;
+ID id_haskey;
+ID id_encode_amf;
+ID id_is_array_collection;
+ID id_use_array_collection;
+ID id_get_as_class_name;
+ID id_props_for_serialization;
+ID id_utc;
+ID id_to_f;
+ID id_is_integer;
+
+static VALUE ser0_serialize(VALUE self, VALUE obj);
+static VALUE ser3_serialize(VALUE self, VALUE obj);
+
+void ser_write_byte(AMF_SERIALIZER *ser, char byte) {
+    char bytes[2] = {byte, '\0'};
+    rb_str_buf_cat(ser->stream, bytes, 1);
+}
+
+void ser_write_int(AMF_SERIALIZER *ser, int num) {
+    char tmp[4];
+    int tmp_len;
+
+    num &= 0x1fffffff;
+    if (num < 0x80) {
+        tmp_len = 1;
+        tmp[0] = num;
+    } else if (num < 0x4000) {
+        tmp_len = 2;
+        tmp[0] = (num >> 7 & 0x7f) | 0x80;
+        tmp[1] = num & 0x7f;
+    } else if (num < 0x200000) {
+        tmp_len = 3;
+        tmp[0] = (num >> 14 & 0x7f) | 0x80;
+        tmp[1] = (num >> 7 & 0x7f) | 0x80;
+        tmp[2] = num & 0x7f;
+    } else if (num < 0x40000000) {
+        tmp_len = 4;
+        tmp[0] = (num >> 22 & 0x7f) | 0x80;
+        tmp[1] = (num >> 15 & 0x7f) | 0x80;
+        tmp[2] = (num >> 8 & 0x7f) | 0x80;
+        tmp[3] = (num & 0xff);
+    } else {
+        rb_raise(rb_eRangeError, "int %d out of range", num);
+    }
+
+    rb_str_buf_cat(ser->stream, tmp, tmp_len);
+}
+
+void ser_write_uint16(AMF_SERIALIZER *ser, long num) {
+    if(num > 0xffff) rb_raise(rb_eRangeError, "int %ld out of range", num);
+    char tmp[2] = {(num >> 8) & 0xff, num & 0xff};
+    rb_str_buf_cat(ser->stream, tmp, 2);
+}
+
+void ser_write_uint32(AMF_SERIALIZER *ser, long num) {
+    if(num > 0xffffffff) rb_raise(rb_eRangeError, "int %ld out of range", num);
+	char tmp[4] = {(num >> 24) & 0xff, (num >> 16) & 0xff, (num >> 8) & 0xff, num & 0xff};
+	rb_str_buf_cat(ser->stream, tmp, 4);
+}
+
+void ser_write_double(AMF_SERIALIZER *ser, double num) {
+	union aligned {
+		double dval;
+		char cval[8];
+	} d;
+	const char *number = d.cval;
+	d.dval = num;
+
+#ifdef WORDS_BIGENDIAN
+    rb_str_buf_cat(ser->stream, number, 8);
+#else
+    char netnum[8] = {number[7],number[6],number[5],number[4],number[3],number[2],number[1],number[0]};
+    rb_str_buf_cat(ser->stream, netnum, 8);
+#endif
+}
+
+void ser_get_string(VALUE obj, VALUE encode, char** str, long* len) {
+    int type = TYPE(obj);
+    if(type == T_STRING) {
+#ifdef HAVE_RB_STR_ENCODE
+        if(encode == Qtrue) {
+            rb_encoding *enc = rb_enc_get(obj);
+            if (enc != rb_ascii8bit_encoding()) {
+                rb_encoding *utf8 = rb_utf8_encoding();
+                if (enc != utf8) obj = rb_str_encode(obj, rb_enc_from_encoding(utf8), 0, Qnil);
+            }
+        }
+#endif
+        *str = RSTRING_PTR(obj);
+        *len = RSTRING_LEN(obj);
+    } else if(type == T_SYMBOL) {
+        *str = (char*)rb_id2name(SYM2ID(obj));
+        *len = strlen(*str);
+    } else if(obj == Qnil) {
+        *len = 0;
+    } else {
+        rb_raise(rb_eArgError, "Invalid type in ser_get_string: %d", type);
+    }
+}
+
+/*
+ * Write the given array in AMF0 notation
+ */
+static void ser0_write_array(VALUE self, VALUE ary) {
+    AMF_SERIALIZER *ser;
+    Data_Get_Struct(self, AMF_SERIALIZER, ser);
+
+    // Cache it
+    st_add_direct(ser->obj_cache, ary, LONG2FIX(ser->obj_index));
+    ser->obj_index++;
+
+    // Write it out
+    long i, len = RARRAY_LEN(ary);
+    ser_write_byte(ser, AMF0_STRICT_ARRAY_MARKER);
+    ser_write_uint32(ser, len);
+    for(i = 0; i < len; i++) {
+        ser0_serialize(self, RARRAY_PTR(ary)[i]);
+    }
+}
+
+/*
+ * Supports writing strings and symbols. For hash keys, strings all have 16 bit
+ * lengths, so writing a type marker is unnecessary. In that case the third
+ * parameter should be set to Qfalse instead of Qtrue.
+ */
+static void ser0_write_string(AMF_SERIALIZER *ser, VALUE obj, VALUE write_marker) {
+    // Extract char array and length from object
+    char* str;
+    long len;
+    ser_get_string(obj, Qtrue, &str, &len);
+
+    // Write string
+    if(len > 0xffff) {
+        if(write_marker == Qtrue) ser_write_byte(ser, AMF0_LONG_STRING_MARKER);
+        ser_write_uint32(ser, len);
+    } else {
+        if(write_marker == Qtrue) ser_write_byte(ser, AMF0_STRING_MARKER);
+        ser_write_uint16(ser, len);
+    }
+    rb_str_buf_cat(ser->stream, str, len);
+}
+
+/*
+ * Hash iterator for object properties that writes the key and then serializes
+ * the value
+ */
+static int ser0_hash_iter(VALUE key, VALUE val, const VALUE args[1]) {
+    AMF_SERIALIZER *ser;
+    Data_Get_Struct(args[0], AMF_SERIALIZER, ser);
+
+    // Write key and value
+    ser0_write_string(ser, key, Qfalse); // Technically incorrect if key length is longer than a 16 bit string, but if you run into that you're screwed anyways
+    ser0_serialize(args[0], val);
+
+    return ST_CONTINUE;
+}
+
+/*
+ * Used for both hashes and objects. Takes the object and the props hash or Qnil,
+ * which forces a call to the class mapper for props for serialization. Prop
+ * sorting must be enabled by an explicit call to extconf.rb, so the tests will
+ * not pass typically on Ruby 1.8.
+ */
+static void ser0_write_object(VALUE self, VALUE obj, VALUE props) {
+    AMF_SERIALIZER *ser;
+    Data_Get_Struct(self, AMF_SERIALIZER, ser);
+
+    // Cache it
+    st_add_direct(ser->obj_cache, obj, LONG2FIX(ser->obj_index));
+    ser->obj_index++;
+
+    // Make a request for props hash unless we already have it
+    if(props == Qnil) {
+        props = rb_funcall(ser->class_mapper, id_props_for_serialization, 1, obj);
+    }
+
+    // Write header
+    VALUE class_name = rb_funcall(ser->class_mapper, id_get_as_class_name, 1, obj);
+    if(class_name != Qnil) {
+        ser_write_byte(ser, AMF0_TYPED_OBJECT_MARKER);
+        ser0_write_string(ser, class_name, Qfalse);
+    } else {
+        ser_write_byte(ser, AMF0_OBJECT_MARKER);
+    }
+
+    // Write out data
+    VALUE args[1] = {self};
+#ifdef SORT_PROPS
+    // Sort is required prior to Ruby 1.9 to pass all the tests, as Ruby 1.8 hashes don't store insert order
+    VALUE sorted_props = rb_funcall(props, rb_intern("sort"), 0);
+    long i, len = RARRAY_LEN(sorted_props);
+    for(i = 0; i < len; i++) {
+        VALUE pair = RARRAY_PTR(sorted_props)[i];
+        ser0_hash_iter(RARRAY_PTR(pair)[0], RARRAY_PTR(pair)[1], args);
+    }
+#else
+    rb_hash_foreach(props, ser0_hash_iter, (st_data_t)args);
+#endif
+
+    ser_write_uint16(ser, 0);
+    ser_write_byte(ser, AMF0_OBJECT_END_MARKER);
+}
+
+static void ser0_write_time(VALUE self, VALUE time) {
+    AMF_SERIALIZER *ser;
+    Data_Get_Struct(self, AMF_SERIALIZER, ser);
+
+    ser_write_byte(ser, AMF0_DATE_MARKER);
+
+    // Write time
+    time = rb_obj_dup(time);
+    rb_funcall(time, id_utc, 0);
+    double tmp_num = NUM2DBL(rb_funcall(time, id_to_f, 0)) * 1000;
+    ser_write_double(ser, tmp_num);
+    ser_write_uint16(ser, 0); // Time zone
+}
+
+static void ser0_write_date(VALUE self, VALUE date) {
+    AMF_SERIALIZER *ser;
+    Data_Get_Struct(self, AMF_SERIALIZER, ser);
+
+    ser_write_byte(ser, AMF0_DATE_MARKER);
+
+    // Write time
+    double tmp_num = rb_str_to_dbl(rb_funcall(date, rb_intern("strftime"), 1, rb_str_new2("%Q")), Qfalse);
+    ser_write_double(ser, tmp_num);
+    ser_write_uint16(ser, 0); // Time zone
+}
+
+/*
+ * Serializes the object to a string and returns that string
+ */
+static VALUE ser0_serialize(VALUE self, VALUE obj) {
+    AMF_SERIALIZER *ser;
+    Data_Get_Struct(self, AMF_SERIALIZER, ser);
+
+    int type = TYPE(obj);
+    VALUE klass = Qnil;
+    if(type == T_OBJECT || type == T_DATA) {
+        klass = CLASS_OF(obj);
+    }
+
+    VALUE obj_index;
+    if(st_lookup(ser->obj_cache, obj, &obj_index)) {
+        ser_write_byte(ser, AMF0_REFERENCE_MARKER);
+        ser_write_uint16(ser, FIX2LONG(obj_index));
+    } else if(rb_respond_to(obj, id_encode_amf)) {
+        rb_funcall(obj, id_encode_amf, 1, self);
+    } else if(type == T_STRING || type == T_SYMBOL) {
+        ser0_write_string(ser, obj, Qtrue);
+    } else if(rb_obj_is_kind_of(obj, rb_cNumeric)) {
+        ser_write_byte(ser, AMF0_NUMBER_MARKER);
+        ser_write_double(ser, RFLOAT_VALUE(rb_Float(obj)));
+    } else if(type == T_NIL) {
+        ser_write_byte(ser, AMF0_NULL_MARKER);
+    } else if(type == T_TRUE || type == T_FALSE) {
+        ser_write_byte(ser, AMF0_BOOLEAN_MARKER);
+        ser_write_byte(ser, type == T_TRUE ? 1 : 0);
+    } else if(type == T_ARRAY) {
+        ser0_write_array(self, obj);
+    } else if(klass == rb_cTime) {
+        ser0_write_time(self, obj);
+    } else if(klass == cDate || klass == cDateTime) {
+        ser0_write_date(self, obj);
+    } else if(type == T_HASH || type == T_OBJECT) {
+        ser0_write_object(self, obj, Qnil);
+    }
+
+    return ser->stream;
+}
+
+/*
+ * Writes an AMF3 style string. Accepts strings, symbols, and nil, and handles
+ * all the necessary encoding and caching.
+ */
+static void ser3_write_utf8vr(AMF_SERIALIZER *ser, VALUE obj) {
+    // Extract char array and length from object
+    char* str;
+    long len;
+    ser_get_string(obj, Qtrue, &str, &len);
+
+    // Write string
+    VALUE str_index;
+    if(len == 0) {
+        ser_write_byte(ser, AMF3_EMPTY_STRING);
+    } else if(st_lookup(ser->str_cache, (st_data_t)str, &str_index)) {
+        ser_write_int(ser, FIX2INT(str_index) << 1);
+    } else {
+        st_add_direct(ser->str_cache, (st_data_t)strdup(str), LONG2FIX(ser->str_index));
+        ser->str_index++;
+
+        ser_write_int(ser, ((int)len) << 1 | 1);
+        rb_str_buf_cat(ser->stream, str, len);
+    }
+}
+
+/*
+ * Writes Numeric conforming object using AMF3 notation
+ */
+static void ser3_write_numeric(AMF_SERIALIZER *ser, VALUE num) {
+    // Is it an integer in range?
+    if(rb_funcall(num, id_is_integer, 0) == Qtrue) {
+        // It's an integer internally, so now we need to check if it's in range
+        VALUE int_obj = rb_Integer(num);
+        if(TYPE(int_obj) == T_FIXNUM) {
+            long long_val = FIX2LONG(int_obj);
+            if(long_val < MIN_INTEGER || long_val > MAX_INTEGER) {
+                // Outside range, but we have a value already, so just cast to double
+                ser_write_byte(ser, AMF3_DOUBLE_MARKER);
+                ser_write_double(ser, (double)long_val);
+            } else {
+                // Inside valid integer range
+                ser_write_byte(ser, AMF3_INTEGER_MARKER);
+                ser_write_int(ser, (int)long_val);
+            }
+            return;
+        }
+    }
+
+    // It's either not an integer or out of range, so write as a double
+    ser_write_byte(ser, AMF3_DOUBLE_MARKER);
+    ser_write_double(ser, RFLOAT_VALUE(rb_Float(num)));
+}
+
+/*
+ * Writes the given array using AMF3 notation
+ */
+static void ser3_write_array(VALUE self, VALUE ary) {
+    AMF_SERIALIZER *ser;
+    Data_Get_Struct(self, AMF_SERIALIZER, ser);
+
+    // Is it an array collection?
+    VALUE is_ac = Qfalse;
+    if(rb_respond_to(ary, id_is_array_collection)) {
+        is_ac = rb_funcall(ary, id_is_array_collection, 0);
+    } else {
+        is_ac = rb_funcall(ser->class_mapper, id_use_array_collection, 0);
+    }
+
+    // Write type marker
+    ser_write_byte(ser, is_ac ? AMF3_OBJECT_MARKER : AMF3_ARRAY_MARKER);
+
+    // Write object ref, or cache it
+    VALUE obj_index;
+    if(st_lookup(ser->obj_cache, ary, &obj_index)) {
+        ser_write_int(ser, FIX2INT(obj_index) << 1);
+        return;
+    } else {
+        st_add_direct(ser->obj_cache, ary, LONG2FIX(ser->obj_index));
+        ser->obj_index++;
+        if(is_ac) ser->obj_index++; // The array collection source array
+    }
+
+    // Write out traits and array marker if it's an array collection
+    if(is_ac) {
+        VALUE trait_index;
+        char array_collection_name[34] = "flex.messaging.io.ArrayCollection";
+        if(st_lookup(ser->trait_cache, (st_data_t)array_collection_name, &trait_index)) {
+            ser_write_int(ser, FIX2INT(trait_index) << 2 | 0x01);
+        } else {
+            st_add_direct(ser->trait_cache, (st_data_t)strdup(array_collection_name), LONG2FIX(ser->trait_index));
+            ser->trait_index++;
+            ser_write_byte(ser, 0x07); // Trait header
+            ser3_write_utf8vr(ser, rb_str_new2(array_collection_name));
+        }
+        ser_write_byte(ser, AMF3_ARRAY_MARKER);
+    }
+
+    // Write header
+    int header = ((int)RARRAY_LEN(ary)) << 1 | 1;
+    ser_write_int(ser, header);
+    ser_write_byte(ser, AMF3_CLOSE_DYNAMIC_ARRAY);
+
+    // Write contents
+    long i, len = RARRAY_LEN(ary);
+    for(i = 0; i < len; i++) {
+        ser3_serialize(self, RARRAY_PTR(ary)[i]);
+    }
+}
+
+/*
+ * AMF3 property hash write iterator. Checks the args->extra hash, if given,
+ * and skips properties that are keys in that hash.
+ */
+static int ser3_hash_iter(VALUE key, VALUE val, const VALUE args[2]) {
+    AMF_SERIALIZER *ser;
+    Data_Get_Struct(args[0], AMF_SERIALIZER, ser);
+
+    if(args[1] == Qnil || rb_funcall(args[1], id_haskey, 1, key) == Qfalse) {
+        // Write key and value
+        ser3_write_utf8vr(ser, key);
+        ser3_serialize(args[0], val);
+    }
+    return ST_CONTINUE;
+}
+
+/*
+ * Used for both hashes and objects. Takes the object and the props hash or Qnil,
+ * which forces a call to the class mapper for props for serialization. Prop
+ * sorting must be enabled by an explicit call to extconf.rb, so the tests will
+ * not pass typically on Ruby 1.8. If you need to have specific traits, you can
+ * also pass that in, or pass Qnil to use the default traits - dynamic with no
+ * defined members.
+ */
+static void ser3_write_object(VALUE self, VALUE obj, VALUE props, VALUE traits) {
+    AMF_SERIALIZER *ser;
+    Data_Get_Struct(self, AMF_SERIALIZER, ser);
+    long i;
+
+    // Write type marker
+    ser_write_byte(ser, AMF3_OBJECT_MARKER);
+
+    // Write object ref, or cache it
+    VALUE obj_index;
+    if(st_lookup(ser->obj_cache, obj, &obj_index)) {
+        ser_write_int(ser, FIX2INT(obj_index) << 1);
+        return;
+    } else {
+        st_add_direct(ser->obj_cache, obj, LONG2FIX(ser->obj_index));
+        ser->obj_index++;
+    }
+
+    // Extract traits data, or use defaults
+    VALUE is_default = Qfalse;
+    VALUE class_name = Qnil;
+    VALUE members = Qnil;
+    long members_len = 0;
+    VALUE dynamic = Qtrue;
+    VALUE externalizable = Qfalse;
+    if(traits == Qnil) {
+        class_name = rb_funcall(ser->class_mapper, id_get_as_class_name, 1, obj);
+        if(class_name == Qnil) is_default = Qtrue;
+    } else {
+        class_name = rb_hash_aref(traits, sym_class_name);
+        members = rb_hash_aref(traits, sym_members);
+        if(members != Qnil) members_len = RARRAY_LEN(members);
+        dynamic = rb_hash_aref(traits, sym_dynamic);
+        externalizable = rb_hash_aref(traits, sym_externalizable);
+    }
+
+    // Handle trait caching
+    int did_ref = 0;
+    VALUE trait_index;
+    if(is_default == Qtrue || class_name != Qnil) {
+        const char *ref_class_name = is_default == Qtrue ? "__default__" : RSTRING_PTR(class_name);
+        if(st_lookup(ser->trait_cache, (st_data_t)ref_class_name, &trait_index)) {
+            ser_write_int(ser, FIX2INT(trait_index) << 2 | 0x01);
+            did_ref = 1;
+        } else {
+            st_add_direct(ser->trait_cache, (st_data_t)strdup(ref_class_name), LONG2FIX(ser->trait_index));
+            ser->trait_index++;
+        }
+    }
+
+    // Write traits outs if didn't write reference
+    if(!did_ref) {
+        // Write out trait header
+        int header = 0x03;
+        if(dynamic == Qtrue) header |= 0x02 << 2;
+        if(externalizable == Qtrue) header |= 0x01 << 2;
+        header |= ((int)members_len) << 4;
+        ser_write_int(ser, header);
+
+        // Write class name
+        ser3_write_utf8vr(ser, class_name);
+
+        // Write out members
+        for(i = 0; i < members_len; i++) {
+            ser3_write_utf8vr(ser, RARRAY_PTR(members)[i]);
+        }
+    }
+
+    // Raise exception if marked externalizable
+    if(externalizable == Qtrue) {
+        rb_funcall(obj, rb_intern("write_external"), 1, self);
+        return;
+    }
+
+    // Make a request for props hash unless we already have it
+    if(props == Qnil) {
+        props = rb_funcall(ser->class_mapper, id_props_for_serialization, 1, obj);
+    }
+
+    // Write sealed members
+    VALUE skipped_members = members_len ? rb_hash_new() : Qnil;
+    for(i = 0; i < members_len; i++) {
+        ser3_serialize(self, rb_hash_aref(props, RARRAY_PTR(members)[i]));
+        rb_hash_aset(skipped_members, RARRAY_PTR(members)[i], Qtrue);
+    }
+
+    // Write dynamic properties
+    if(dynamic == Qtrue) {
+        VALUE args[2] = {self, skipped_members};
+#ifdef SORT_PROPS
+        // Sort is required prior to Ruby 1.9 to pass all the tests, as Ruby 1.8 hashes don't store insert order
+        VALUE sorted_props = rb_funcall(props, rb_intern("sort"), 0);
+        for(i = 0; i < RARRAY_LEN(sorted_props); i++) {
+            VALUE pair = RARRAY_PTR(sorted_props)[i];
+            ser3_hash_iter(RARRAY_PTR(pair)[0], RARRAY_PTR(pair)[1], args);
+        }
+#else
+        rb_hash_foreach(props, ser3_hash_iter, (st_data_t)args);
+#endif
+
+        ser_write_byte(ser, AMF3_CLOSE_DYNAMIC_OBJECT);
+    }
+}
+
+static void ser3_write_time(VALUE self, VALUE time_obj) {
+    AMF_SERIALIZER *ser;
+    Data_Get_Struct(self, AMF_SERIALIZER, ser);
+
+    ser_write_byte(ser, AMF3_DATE_MARKER);
+
+    // Write object ref, or cache it
+    VALUE obj_index;
+    if(st_lookup(ser->obj_cache, time_obj, &obj_index)) {
+        ser_write_int(ser, FIX2INT(obj_index) << 1);
+        return;
+    } else {
+        st_add_direct(ser->obj_cache, time_obj, LONG2FIX(ser->obj_index));
+        ser->obj_index++;
+    }
+
+    // Write time
+    ser_write_byte(ser, AMF3_NULL_MARKER); // Ref header
+    time_obj = rb_obj_dup(time_obj);
+    rb_funcall(time_obj, id_utc, 0);
+    double tmp_num = NUM2DBL(rb_funcall(time_obj, id_to_f, 0)) * 1000;
+    ser_write_double(ser, tmp_num);
+}
+
+static void ser3_write_date(VALUE self, VALUE date) {
+    AMF_SERIALIZER *ser;
+    Data_Get_Struct(self, AMF_SERIALIZER, ser);
+
+    ser_write_byte(ser, AMF3_DATE_MARKER);
+
+    // Write object ref, or cache it
+    VALUE obj_index;
+    if(st_lookup(ser->obj_cache, date, &obj_index)) {
+        ser_write_int(ser, FIX2INT(obj_index) << 1);
+        return;
+    } else {
+        st_add_direct(ser->obj_cache, date, LONG2FIX(ser->obj_index));
+        ser->obj_index++;
+    }
+
+    // Write time
+    ser_write_byte(ser, AMF3_NULL_MARKER); // Ref header
+    double tmp_num = rb_str_to_dbl(rb_funcall(date, rb_intern("strftime"), 1, rb_str_new2("%Q")), Qfalse);
+    ser_write_double(ser, tmp_num);
+}
+
+static void ser3_write_byte_array(VALUE self, VALUE ba) {
+    AMF_SERIALIZER *ser;
+    Data_Get_Struct(self, AMF_SERIALIZER, ser);
+
+    ser_write_byte(ser, AMF3_BYTE_ARRAY_MARKER);
+
+    // Write object ref, or cache it
+    VALUE obj_index;
+    if(st_lookup(ser->obj_cache, ba, &obj_index)) {
+        ser_write_int(ser, FIX2INT(obj_index) << 1);
+        return;
+    } else {
+        st_add_direct(ser->obj_cache, ba, LONG2FIX(ser->obj_index));
+        ser->obj_index++;
+    }
+
+    // Write byte array
+    VALUE str = rb_funcall(ba, rb_intern("string"), 0);
+    int len = (int)(RSTRING_LEN(str) << 1); // Explicitly cast to int to avoid compiler warning
+    ser_write_int(ser, len | 1);
+    rb_str_buf_cat(ser->stream, RSTRING_PTR(str), RSTRING_LEN(str));
+}
+
+/*
+ * Serializes the object to a string and returns that string
+ */
+static VALUE ser3_serialize(VALUE self, VALUE obj) {
+    AMF_SERIALIZER *ser;
+    Data_Get_Struct(self, AMF_SERIALIZER, ser);
+
+    int type = TYPE(obj);
+    VALUE klass = Qnil;
+    if(type == T_OBJECT || type == T_DATA || type == T_ARRAY) {
+        klass = CLASS_OF(obj);
+    }
+
+    if(rb_respond_to(obj, id_encode_amf)) {
+        rb_funcall(obj, id_encode_amf, 1, self);
+    } else if(type == T_STRING || type == T_SYMBOL) {
+        ser_write_byte(ser, AMF3_STRING_MARKER);
+        ser3_write_utf8vr(ser, obj);
+    } else if(rb_obj_is_kind_of(obj, rb_cNumeric)) {
+        ser3_write_numeric(ser, obj);
+    } else if(type == T_NIL) {
+        ser_write_byte(ser, AMF3_NULL_MARKER);
+    } else if(type == T_TRUE) {
+        ser_write_byte(ser, AMF3_TRUE_MARKER);
+    } else if(type == T_FALSE) {
+        ser_write_byte(ser, AMF3_FALSE_MARKER);
+    } else if(type == T_ARRAY) {
+        ser3_write_array(self, obj);
+    } else if(type == T_HASH) {
+        ser3_write_object(self, obj, Qnil, Qnil);
+    } else if(klass == rb_cTime) {
+        ser3_write_time(self, obj);
+    } else if(klass == cDate || klass == cDateTime) {
+        ser3_write_date(self, obj);
+    } else if(klass == cStringIO) {
+        ser3_write_byte_array(self, obj);
+    } else if(type == T_OBJECT) {
+        ser3_write_object(self, obj, Qnil, Qnil);
+    }
+
+    return ser->stream;
+}
+
+/*
+ * Mark ruby objects for GC
+ */
+static void ser_mark(AMF_SERIALIZER *ser) {
+    if(!ser) return;
+    rb_gc_mark(ser->class_mapper);
+    rb_gc_mark(ser->stream);
+}
+
+/*
+ * Free cache tables, stream and the struct itself
+ */
+int ser_free_strtable_key(st_data_t key, st_data_t value, st_data_t ignored)
+{
+    xfree((void *)key);
+
+    return ST_DELETE;
+}
+inline void ser_free_cache(AMF_SERIALIZER *ser) {
+    if(ser->str_cache) {
+        st_foreach(ser->str_cache, ser_free_strtable_key, 0);
+        st_free_table(ser->str_cache);
+        ser->str_cache = NULL;
+    }
+    if(ser->trait_cache) {
+        st_foreach(ser->trait_cache, ser_free_strtable_key, 0);
+        st_free_table(ser->trait_cache);
+        ser->trait_cache = NULL;
+    }
+    if(ser->obj_cache) {
+        st_free_table(ser->obj_cache);
+        ser->obj_cache = NULL;
+    }
+}
+static void ser_free(AMF_SERIALIZER *ser) {
+    ser_free_cache(ser);
+    xfree(ser);
+}
+
+/*
+ * Create new struct and wrap with class
+ */
+static VALUE ser_alloc(VALUE klass) {
+    // Allocate struct
+    AMF_SERIALIZER *ser = ALLOC(AMF_SERIALIZER);
+    memset(ser, 0, sizeof(AMF_SERIALIZER));
+    return Data_Wrap_Struct(klass, ser_mark, ser_free, ser);
+}
+
+/*
+ * Initializer
+ */
+static VALUE ser_initialize(VALUE self, VALUE class_mapper) {
+    AMF_SERIALIZER *ser;
+    Data_Get_Struct(self, AMF_SERIALIZER, ser);
+
+    ser->class_mapper = class_mapper;
+    ser->depth = 0;
+    ser->stream = rb_str_buf_new(0);
+
+    return self;
+}
+
+/*
+ * call-seq:
+ *   ser.version => int
+ *
+ * Returns the serializer version number, so that a custom encode_amf method
+ * knows which version to encode for
+ */
+static VALUE ser_version(VALUE self) {
+    AMF_SERIALIZER *ser;
+    Data_Get_Struct(self, AMF_SERIALIZER, ser);
+    return INT2FIX(ser->version);
+}
+
+/*
+ * call-seq:
+ *   ser.stream => string
+ *
+ * Returns the string that the serializer is writing to
+ */
+static VALUE ser_stream(VALUE self) {
+    AMF_SERIALIZER *ser;
+    Data_Get_Struct(self, AMF_SERIALIZER, ser);
+    return ser->stream;
+}
+
+/*
+ * call-seq:
+ *   ser.serialize(amf_ver, obj) => string
+ *
+ * Serialize the given object to the current stream and returns the stream
+ */
+VALUE ser_serialize(VALUE self, VALUE ver, VALUE obj) {
+    AMF_SERIALIZER *ser;
+    Data_Get_Struct(self, AMF_SERIALIZER, ser);
+
+    // Process version
+    int int_ver = FIX2INT(ver);
+    if(int_ver != 0 && int_ver != 3) rb_raise(rb_eArgError, "unsupported version %d", int_ver);
+    ser->version = int_ver;
+
+    // Initialize caches
+    if(ser->depth == 0) {
+        ser->obj_cache = st_init_numtable();
+        ser->obj_index = 0;
+        if(ser->version == 3) {
+            ser->str_cache = st_init_strtable();
+            ser->str_index = 0;
+            ser->trait_cache = st_init_strtable();
+            ser->trait_index = 0;
+        }
+    }
+    ser->depth++;
+
+    // Perform serialization
+    if(ser->version == 0) {
+        ser0_serialize(self, obj);
+    } else {
+        ser3_serialize(self, obj);
+    }
+
+    // Clean up
+    ser->depth--;
+    if(ser->depth == 0) ser_free_cache(ser);
+
+    return ser->stream;
+}
+
+/*
+ * call-seq:
+ *   ser.write_array(ary) => ser
+ *
+ * Serializes the given array to the serializer stream
+ */
+static VALUE ser_write_array(VALUE self, VALUE ary) {
+    AMF_SERIALIZER *ser;
+    Data_Get_Struct(self, AMF_SERIALIZER, ser);
+    if(ser->version == 0) {
+        ser0_write_array(self, ary);
+    } else {
+        ser3_write_array(self, ary);
+    }
+    return self;
+}
+
+/*
+ * call-seq:
+ *   ser.write_object(obj, props=nil) => ser
+ *   ser.write_object(obj, props=nil, traits=nil) => ser
+ *
+ * Serializes the given object or hash to the serializer stream using
+ * the proper serializer version. If given a props hash, uses that
+ * instead of using the class mapper to calculate it. If given a traits
+ * hash for AMF3, uses that instead of the default dynamic traits with
+ * the mapped class name.
+ */
+static VALUE ser_write_object(int argc, VALUE *argv, VALUE self) {
+    AMF_SERIALIZER *ser;
+    Data_Get_Struct(self, AMF_SERIALIZER, ser);
+
+    // Check args and call implementation
+    VALUE obj;
+    VALUE props = Qnil;
+    VALUE traits = Qnil;
+    if(ser->version == 0) {
+        rb_scan_args(argc, argv, "11", &obj, &props);
+        ser0_write_object(self, obj, props);
+    } else {
+        rb_scan_args(argc, argv, "12", &obj, &props, &traits);
+        ser3_write_object(self, obj, props, traits);
+    }
+
+    return self;
+}
+
+void Init_rocket_amf_serializer() {
+    // Define Serializer
+    cSerializer = rb_define_class_under(mRocketAMFExt, "Serializer", rb_cObject);
+    rb_define_alloc_func(cSerializer, ser_alloc);
+    rb_define_method(cSerializer, "initialize", ser_initialize, 1);
+    rb_define_method(cSerializer, "version", ser_version, 0);
+    rb_define_method(cSerializer, "stream", ser_stream, 0);
+    rb_define_method(cSerializer, "serialize", ser_serialize, 2);
+    rb_define_method(cSerializer, "write_array", ser_write_array, 1);
+    rb_define_method(cSerializer, "write_object", ser_write_object, -1);
+
+    // Get refs to commonly used symbols and ids
+    id_haskey = rb_intern("has_key?");
+    id_encode_amf = rb_intern("encode_amf");
+    id_is_array_collection = rb_intern("is_array_collection?");
+    id_use_array_collection = rb_intern("use_array_collection");
+    id_get_as_class_name = rb_intern("get_as_class_name");
+    id_props_for_serialization = rb_intern("props_for_serialization");
+    id_utc = rb_intern("utc");
+    id_to_f = rb_intern("to_f");
+    id_is_integer = rb_intern("integer?");
+}