msgpack 0.7.4 → 1.3.3

data/ext/msgpack/buffer.h

@@ -262,6 +262,20 @@ static inline size_t msgpack_buffer_append_string(msgpack_buffer_t* b, VALUE str
     return length;
 }
 
+static inline size_t msgpack_buffer_append_string_reference(msgpack_buffer_t* b, VALUE string)
+{
+    size_t length = RSTRING_LEN(string);
+
+    if(length > MSGPACK_BUFFER_STRING_WRITE_REFERENCE_MINIMUM) {
+        _msgpack_buffer_append_long_string(b, string);
+
+    } else {
+        msgpack_buffer_append(b, RSTRING_PTR(string), length);
+    }
+
+    return length;
+}
+
 
 /*
  * IO functions

data/ext/msgpack/buffer_class.c

@@ -54,7 +54,7 @@ static void Buffer_free(void* data)
 
 static VALUE Buffer_alloc(VALUE klass)
 {
-    msgpack_buffer_t* b = ALLOC_N(msgpack_buffer_t, 1);
+    msgpack_buffer_t* b = ZALLOC_N(msgpack_buffer_t, 1);
     msgpack_buffer_init(b);
 
     return Data_Wrap_Struct(klass, msgpack_buffer_mark, Buffer_free, b);

data/ext/msgpack/compat.h

@@ -28,6 +28,16 @@
 #endif
 
 
+/*
+ * ZALLOC_N (ruby 2.2 or later)
+ */
+#ifndef RB_ZALLOC_N
+#  define RB_ZALLOC_N(type,n) ((type*)ruby_xcalloc((size_t)(n),sizeof(type)))
+#endif
+#ifndef ZALLOC_N
+#  define ZALLOC_N(type,n) RB_ZALLOC_N(type,n)
+#endif
+
 /*
  * COMPAT_HAVE_ENCODING
  */

data/ext/msgpack/factory_class.c

@@ -24,7 +24,6 @@
 #include "unpacker_class.h"
 
 VALUE cMessagePack_Factory;
-VALUE cMessagePack_DefaultFactory;
 
 struct msgpack_factory_t;
 typedef struct msgpack_factory_t msgpack_factory_t;
@@ -32,6 +31,7 @@ typedef struct msgpack_factory_t msgpack_factory_t;
 struct msgpack_factory_t {
     msgpack_packer_ext_registry_t pkrg;
     msgpack_unpacker_ext_registry_t ukrg;
+    bool has_symbol_ext_type;
 };
 
 #define FACTORY(from, name) \
@@ -59,10 +59,7 @@ void Factory_mark(msgpack_factory_t* fc)
 
 static VALUE Factory_alloc(VALUE klass)
 {
-    msgpack_factory_t* fc = ALLOC_N(msgpack_factory_t, 1);
-
-    msgpack_packer_ext_registry_init(&fc->pkrg);
-    msgpack_unpacker_ext_registry_init(&fc->ukrg);
+    msgpack_factory_t* fc = ZALLOC_N(msgpack_factory_t, 1);
 
     VALUE self = Data_Wrap_Struct(klass, Factory_mark, Factory_free, fc);
     return self;
@@ -72,6 +69,11 @@ static VALUE Factory_initialize(int argc, VALUE* argv, VALUE self)
 {
     FACTORY(self, fc);
 
+    msgpack_packer_ext_registry_init(&fc->pkrg);
+    msgpack_unpacker_ext_registry_init(&fc->ukrg);
+
+    fc->has_symbol_ext_type = false;
+
     switch (argc) {
     case 0:
         break;
@@ -95,6 +97,7 @@ VALUE MessagePack_Factory_packer(int argc, VALUE* argv, VALUE self)
 
     msgpack_packer_ext_registry_destroy(&pk->ext_registry);
     msgpack_packer_ext_registry_dup(&fc->pkrg, &pk->ext_registry);
+    pk->has_symbol_ext_type = fc->has_symbol_ext_type;
 
     return packer;
 }
@@ -137,11 +140,15 @@ static VALUE Factory_register_type(int argc, VALUE* argv, VALUE self)
     FACTORY(self, fc);
 
     int ext_type;
-    VALUE ext_class;
+    VALUE ext_module;
     VALUE options;
     VALUE packer_arg, unpacker_arg;
     VALUE packer_proc, unpacker_proc;
 
+    if (OBJ_FROZEN(self)) {
+        rb_raise(rb_eRuntimeError, "can't modify frozen Factory");
+    }
+
     switch (argc) {
     case 2:
         /* register_type(0x7f, Time) */
@@ -161,14 +168,14 @@ static VALUE Factory_register_type(int argc, VALUE* argv, VALUE self)
         rb_raise(rb_eArgError, "wrong number of arguments (%d for 2..3)", argc);
     }
 
-    ext_type = rb_num2int(argv[0]);
+    ext_type = NUM2INT(argv[0]);
     if(ext_type < -128 || ext_type > 127) {
         rb_raise(rb_eRangeError, "integer %d too big to convert to `signed char'", ext_type);
     }
 
-    ext_class = argv[1];
-    if(rb_type(ext_class) != T_CLASS) {
-        rb_raise(rb_eArgError, "expected Class but found %s.", rb_obj_classname(ext_class));
+    ext_module = argv[1];
+    if(rb_type(ext_module) != T_MODULE && rb_type(ext_module) != T_CLASS) {
+        rb_raise(rb_eArgError, "expected Module/Class but found %s.", rb_obj_classname(ext_module));
     }
 
     packer_proc = Qnil;
@@ -180,15 +187,19 @@ static VALUE Factory_register_type(int argc, VALUE* argv, VALUE self)
 
     if(unpacker_arg != Qnil) {
         if(rb_type(unpacker_arg) == T_SYMBOL || rb_type(unpacker_arg) == T_STRING) {
-            unpacker_proc = rb_obj_method(ext_class, unpacker_arg);
+            unpacker_proc = rb_obj_method(ext_module, unpacker_arg);
         } else {
             unpacker_proc = rb_funcall(unpacker_arg, rb_intern("method"), 1, ID2SYM(rb_intern("call")));
         }
     }
 
-    msgpack_packer_ext_registry_put(&fc->pkrg, ext_class, ext_type, packer_proc, packer_arg);
+    msgpack_packer_ext_registry_put(&fc->pkrg, ext_module, ext_type, packer_proc, packer_arg);
 
-    msgpack_unpacker_ext_registry_put(&fc->ukrg, ext_class, ext_type, unpacker_proc, unpacker_arg);
+    if (ext_module == rb_cSymbol) {
+        fc->has_symbol_ext_type = true;
+    }
+
+    msgpack_unpacker_ext_registry_put(&fc->ukrg, ext_module, ext_type, unpacker_proc, unpacker_arg);
 
     return Qnil;
 }
@@ -206,8 +217,4 @@ void MessagePack_Factory_module_init(VALUE mMessagePack)
 
     rb_define_private_method(cMessagePack_Factory, "registered_types_internal", Factory_registered_types_internal, 0);
     rb_define_method(cMessagePack_Factory, "register_type", Factory_register_type, -1);
-
-    cMessagePack_DefaultFactory = Factory_alloc(cMessagePack_Factory);
-    Factory_initialize(0, NULL, cMessagePack_DefaultFactory);
-    rb_define_const(mMessagePack, "DefaultFactory", cMessagePack_DefaultFactory);
 }

data/ext/msgpack/factory_class.h

@@ -23,8 +23,6 @@
 
 extern VALUE cMessagePack_Factory;
 
-extern VALUE cMessagePack_DefaultFactory;
-
 extern VALUE MessagePack_Factory_packer(int argc, VALUE* argv, VALUE self);
 
 extern VALUE MessagePack_Factory_unpacker(int argc, VALUE* argv, VALUE self);

data/ext/msgpack/packer.c

@@ -121,11 +121,12 @@ void msgpack_packer_write_hash_value(msgpack_packer_t* pk, VALUE v)
 #endif
 }
 
-static void _msgpack_packer_write_other_value(msgpack_packer_t* pk, VALUE v)
+void msgpack_packer_write_other_value(msgpack_packer_t* pk, VALUE v)
 {
     int ext_type;
-    VALUE proc = msgpack_packer_ext_registry_lookup(&pk->ext_registry,
-            rb_obj_class(v), &ext_type);
+
+    VALUE proc = msgpack_packer_ext_registry_lookup(&pk->ext_registry, v, &ext_type);
+
     if(proc != Qnil) {
         VALUE payload = rb_funcall(proc, s_call, 1, v);
         StringValue(payload);
@@ -169,7 +170,7 @@ void msgpack_packer_write_value(msgpack_packer_t* pk, VALUE v)
         msgpack_packer_write_float_value(pk, v);
         break;
     default:
-        _msgpack_packer_write_other_value(pk, v);
+        msgpack_packer_write_other_value(pk, v);
     }
 }
 

data/ext/msgpack/packer.h

@@ -32,6 +32,7 @@ struct msgpack_packer_t {
     msgpack_buffer_t buffer;
 
     bool compatibility_mode;
+    bool has_symbol_ext_type;
 
     ID to_msgpack_method;
     VALUE to_msgpack_arg;
@@ -448,7 +449,7 @@ static inline void msgpack_packer_write_string_value(msgpack_packer_t* pk, VALUE
 #endif
 }
 
-static inline void msgpack_packer_write_symbol_value(msgpack_packer_t* pk, VALUE v)
+static inline void msgpack_packer_write_symbol_string_value(msgpack_packer_t* pk, VALUE v)
 {
 #ifdef HAVE_RB_SYM2STR
     /* rb_sym2str is added since MRI 2.2.0 */
@@ -462,6 +463,17 @@ static inline void msgpack_packer_write_symbol_value(msgpack_packer_t* pk, VALUE
 #endif
 }
 
+void msgpack_packer_write_other_value(msgpack_packer_t* pk, VALUE v);
+
+static inline void msgpack_packer_write_symbol_value(msgpack_packer_t* pk, VALUE v)
+{
+    if (pk->has_symbol_ext_type) {
+        msgpack_packer_write_other_value(pk, v);
+    } else {
+        msgpack_packer_write_symbol_string_value(pk, v);
+    }
+}
+
 static inline void msgpack_packer_write_fixnum_value(msgpack_packer_t* pk, VALUE v)
 {
 #ifdef JRUBY

data/ext/msgpack/packer_class.c

@@ -56,14 +56,12 @@ static void Packer_mark(msgpack_packer_t* pk)
 
 VALUE MessagePack_Packer_alloc(VALUE klass)
 {
-    msgpack_packer_t* pk = ALLOC_N(msgpack_packer_t, 1);
+    msgpack_packer_t* pk = ZALLOC_N(msgpack_packer_t, 1);
     msgpack_packer_init(pk);
 
     VALUE self = Data_Wrap_Struct(klass, Packer_mark, Packer_free, pk);
 
     msgpack_packer_set_to_msgpack_method(pk, s_to_msgpack, self);
-    msgpack_packer_ext_registry_init(&pk->ext_registry);
-    pk->buffer_ref = MessagePack_Buffer_wrap(PACKER_BUFFER_(pk), self);
 
     return self;
 }
@@ -97,6 +95,9 @@ VALUE MessagePack_Packer_initialize(int argc, VALUE* argv, VALUE self)
 
     PACKER(self, pk);
 
+    msgpack_packer_ext_registry_init(&pk->ext_registry);
+    pk->buffer_ref = MessagePack_Buffer_wrap(PACKER_BUFFER_(pk), self);
+
     MessagePack_Buffer_set_options(PACKER_BUFFER_(pk), io, options);
 
     if(options != Qnil) {
@@ -135,6 +136,100 @@ static VALUE Packer_write_nil(VALUE self)
     return self;
 }
 
+static VALUE Packer_write_true(VALUE self)
+{
+    PACKER(self, pk);
+    msgpack_packer_write_true(pk);
+    return self;
+}
+
+static VALUE Packer_write_false(VALUE self)
+{
+    PACKER(self, pk);
+    msgpack_packer_write_false(pk);
+    return self;
+}
+
+static VALUE Packer_write_float(VALUE self, VALUE obj)
+{
+    PACKER(self, pk);
+    msgpack_packer_write_float_value(pk, obj);
+    return self;
+}
+
+static VALUE Packer_write_string(VALUE self, VALUE obj)
+{
+    PACKER(self, pk);
+    Check_Type(obj, T_STRING);
+    msgpack_packer_write_string_value(pk, obj);
+    return self;
+}
+
+static VALUE Packer_write_bin(VALUE self, VALUE obj)
+{
+    PACKER(self, pk);
+    Check_Type(obj, T_STRING);
+
+    VALUE enc = rb_enc_from_encoding(rb_ascii8bit_encoding());
+    obj = rb_str_encode(obj, enc, 0, Qnil);
+
+    msgpack_packer_write_string_value(pk, obj);
+    return self;
+}
+
+static VALUE Packer_write_array(VALUE self, VALUE obj)
+{
+    PACKER(self, pk);
+    Check_Type(obj, T_ARRAY);
+    msgpack_packer_write_array_value(pk, obj);
+    return self;
+}
+
+static VALUE Packer_write_hash(VALUE self, VALUE obj)
+{
+    PACKER(self, pk);
+    Check_Type(obj, T_HASH);
+    msgpack_packer_write_hash_value(pk, obj);
+    return self;
+}
+
+static VALUE Packer_write_symbol(VALUE self, VALUE obj)
+{
+    PACKER(self, pk);
+    Check_Type(obj, T_SYMBOL);
+    msgpack_packer_write_symbol_value(pk, obj);
+    return self;
+}
+
+static VALUE Packer_write_int(VALUE self, VALUE obj)
+{
+    PACKER(self, pk);
+
+    if (FIXNUM_P(obj)) {
+        msgpack_packer_write_fixnum_value(pk, obj);
+    } else {
+        Check_Type(obj, T_BIGNUM);
+        msgpack_packer_write_bignum_value(pk, obj);
+    }
+    return self;
+}
+
+static VALUE Packer_write_extension(VALUE self, VALUE obj)
+{
+    PACKER(self, pk);
+    Check_Type(obj, T_STRUCT);
+
+    int ext_type = FIX2INT(RSTRUCT_GET(obj, 0));
+    if(ext_type < -128 || ext_type > 127) {
+        rb_raise(rb_eRangeError, "integer %d too big to convert to `signed char'", ext_type);
+    }
+    VALUE payload = RSTRUCT_GET(obj, 1);
+    StringValue(payload);
+    msgpack_packer_write_ext(pk, ext_type, payload);
+
+    return self;
+}
+
 static VALUE Packer_write_array_header(VALUE self, VALUE n)
 {
     PACKER(self, pk);
@@ -149,6 +244,13 @@ static VALUE Packer_write_map_header(VALUE self, VALUE n)
     return self;
 }
 
+static VALUE Packer_write_bin_header(VALUE self, VALUE n)
+{
+    PACKER(self, pk);
+    msgpack_packer_write_bin_header(pk, NUM2UINT(n));
+    return self;
+}
+
 static VALUE Packer_write_float32(VALUE self, VALUE numeric)
 {
     if(!rb_obj_is_kind_of(numeric, rb_cNumeric)) {
@@ -163,7 +265,7 @@ static VALUE Packer_write_float32(VALUE self, VALUE numeric)
 static VALUE Packer_write_ext(VALUE self, VALUE type, VALUE data)
 {
     PACKER(self, pk);
-    int ext_type = rb_num2int(type);
+    int ext_type = NUM2INT(type);
     if(ext_type < -128 || ext_type > 127) {
         rb_raise(rb_eRangeError, "integer %d too big to convert to `signed char'", ext_type);
     }
@@ -249,7 +351,7 @@ static VALUE Packer_register_type(int argc, VALUE* argv, VALUE self)
     PACKER(self, pk);
 
     int ext_type;
-    VALUE ext_class;
+    VALUE ext_module;
     VALUE proc;
     VALUE arg;
 
@@ -274,36 +376,31 @@ static VALUE Packer_register_type(int argc, VALUE* argv, VALUE self)
         rb_raise(rb_eArgError, "wrong number of arguments (%d for 2..3)", argc);
     }
 
-    ext_type = rb_num2int(argv[0]);
+    ext_type = NUM2INT(argv[0]);
     if(ext_type < -128 || ext_type > 127) {
         rb_raise(rb_eRangeError, "integer %d too big to convert to `signed char'", ext_type);
     }
 
-    ext_class = argv[1];
-    if(rb_type(ext_class) != T_CLASS) {
-        rb_raise(rb_eArgError, "expected Class but found %s.", rb_obj_classname(ext_class));
+    ext_module = argv[1];
+    if(rb_type(ext_module) != T_MODULE && rb_type(ext_module) != T_CLASS) {
+        rb_raise(rb_eArgError, "expected Module/Class but found %s.", rb_obj_classname(ext_module));
     }
 
-    msgpack_packer_ext_registry_put(&pk->ext_registry, ext_class, ext_type, proc, arg);
+    msgpack_packer_ext_registry_put(&pk->ext_registry, ext_module, ext_type, proc, arg);
+
+    if (ext_module == rb_cSymbol) {
+        pk->has_symbol_ext_type = true;
+    }
 
     return Qnil;
 }
 
-VALUE MessagePack_pack(int argc, VALUE* argv)
+VALUE Packer_full_pack(VALUE self)
 {
-    VALUE v;
-
-    if (argc < 0 || argc > 3) {
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..3)", argc);
-    }
-    v = argv[0];
+    VALUE retval;
 
-    VALUE self = MessagePack_Factory_packer(argc - 1, argv + 1, cMessagePack_DefaultFactory);
     PACKER(self, pk);
 
-    msgpack_packer_write_value(pk, v);
-
-    VALUE retval;
     if(msgpack_buffer_has_io(PACKER_BUFFER_(pk))) {
         msgpack_buffer_flush(PACKER_BUFFER_(pk));
         retval = Qnil;
@@ -313,27 +410,9 @@ VALUE MessagePack_pack(int argc, VALUE* argv)
 
     msgpack_buffer_clear(PACKER_BUFFER_(pk)); /* to free rmem before GC */
 
-#ifdef RB_GC_GUARD
-    /* This prevents compilers from optimizing out the `self` variable
-     * from stack. Otherwise GC free()s it. */
-    RB_GC_GUARD(self);
-#endif
-
     return retval;
 }
 
-static VALUE MessagePack_dump_module_method(int argc, VALUE* argv, VALUE mod)
-{
-    UNUSED(mod);
-    return MessagePack_pack(argc, argv);
-}
-
-static VALUE MessagePack_pack_module_method(int argc, VALUE* argv, VALUE mod)
-{
-    UNUSED(mod);
-    return MessagePack_pack(argc, argv);
-}
-
 void MessagePack_Packer_module_init(VALUE mMessagePack)
 {
     s_to_msgpack = rb_intern("to_msgpack");
@@ -352,8 +431,19 @@ void MessagePack_Packer_module_init(VALUE mMessagePack)
     rb_define_method(cMessagePack_Packer, "write", Packer_write, 1);
     rb_define_alias(cMessagePack_Packer, "pack", "write");
     rb_define_method(cMessagePack_Packer, "write_nil", Packer_write_nil, 0);
+    rb_define_method(cMessagePack_Packer, "write_true", Packer_write_true, 0);
+    rb_define_method(cMessagePack_Packer, "write_false", Packer_write_false, 0);
+    rb_define_method(cMessagePack_Packer, "write_float", Packer_write_float, 1);
+    rb_define_method(cMessagePack_Packer, "write_string", Packer_write_string, 1);
+    rb_define_method(cMessagePack_Packer, "write_bin", Packer_write_bin, 1);
+    rb_define_method(cMessagePack_Packer, "write_array", Packer_write_array, 1);
+    rb_define_method(cMessagePack_Packer, "write_hash", Packer_write_hash, 1);
+    rb_define_method(cMessagePack_Packer, "write_symbol", Packer_write_symbol, 1);
+    rb_define_method(cMessagePack_Packer, "write_int", Packer_write_int, 1);
+    rb_define_method(cMessagePack_Packer, "write_extension", Packer_write_extension, 1);
     rb_define_method(cMessagePack_Packer, "write_array_header", Packer_write_array_header, 1);
     rb_define_method(cMessagePack_Packer, "write_map_header", Packer_write_map_header, 1);
+    rb_define_method(cMessagePack_Packer, "write_bin_header", Packer_write_bin_header, 1);
     rb_define_method(cMessagePack_Packer, "write_ext", Packer_write_ext, 2);
     rb_define_method(cMessagePack_Packer, "write_float32", Packer_write_float32, 1);
     rb_define_method(cMessagePack_Packer, "flush", Packer_flush, 0);
@@ -376,8 +466,5 @@ void MessagePack_Packer_module_init(VALUE mMessagePack)
     //rb_gc_register_address(&s_packer_value);
     //Data_Get_Struct(s_packer_value, msgpack_packer_t, s_packer);
 
-    /* MessagePack.pack(x) */
-    rb_define_module_function(mMessagePack, "pack", MessagePack_pack_module_method, -1);
-    rb_define_module_function(mMessagePack, "dump", MessagePack_dump_module_method, -1);
+    rb_define_method(cMessagePack_Packer, "full_pack", Packer_full_pack, 0);
 }
-