msgpack 0.7.4 → 1.3.3

data/ext/msgpack/packer_class.h

@@ -28,7 +28,5 @@ VALUE MessagePack_Packer_alloc(VALUE klass);
 
 VALUE MessagePack_Packer_initialize(int argc, VALUE* argv, VALUE self);
 
-VALUE MessagePack_pack(int argc, VALUE* argv);
-
 #endif
 

data/ext/msgpack/packer_ext_registry.c

@@ -64,7 +64,7 @@ __rb_hash_clear_clear_i(key, value, dummy)
 #endif
 
 VALUE msgpack_packer_ext_registry_put(msgpack_packer_ext_registry_t* pkrg,
-        VALUE ext_class, int ext_type, VALUE proc, VALUE arg)
+        VALUE ext_module, int ext_type, VALUE proc, VALUE arg)
 {
     VALUE e = rb_ary_new3(3, INT2FIX(ext_type), proc, arg);
     /* clear lookup cache not to miss added type */
@@ -75,5 +75,5 @@ VALUE msgpack_packer_ext_registry_put(msgpack_packer_ext_registry_t* pkrg,
         rb_hash_foreach(pkrg->cache, __rb_hash_clear_clear_i, 0);
     }
 #endif
-    return rb_hash_aset(pkrg->hash, ext_class, e);
+    return rb_hash_aset(pkrg->hash, ext_module, e);
 }

data/ext/msgpack/packer_ext_registry.h

@@ -15,8 +15,8 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
-#ifndef MSGPACK_RUBY_UNPACKER_PACKER_EXT_REGISTRY_H__
-#define MSGPACK_RUBY_UNPACKER_PACKER_EXT_REGISTRY_H__
+#ifndef MSGPACK_RUBY_PACKER_EXT_REGISTRY_H__
+#define MSGPACK_RUBY_PACKER_EXT_REGISTRY_H__
 
 #include "compat.h"
 #include "ruby.h"
@@ -26,10 +26,7 @@ typedef struct msgpack_packer_ext_registry_t msgpack_packer_ext_registry_t;
 
 struct msgpack_packer_ext_registry_t {
     VALUE hash;
-    /*
-     * lookup cache for subclasses of registered classes
-     */
-    VALUE cache;
+    VALUE cache; // lookup cache for ext types inherited from a super class
 };
 
 void msgpack_packer_ext_registry_static_init();
@@ -47,9 +44,9 @@ void msgpack_packer_ext_registry_dup(msgpack_packer_ext_registry_t* src,
         msgpack_packer_ext_registry_t* dst);
 
 VALUE msgpack_packer_ext_registry_put(msgpack_packer_ext_registry_t* pkrg,
-        VALUE ext_class, int ext_type, VALUE proc, VALUE arg);
+        VALUE ext_module, int ext_type, VALUE proc, VALUE arg);
 
-static int msgpack_packer_ext_find_inherited(VALUE key, VALUE value, VALUE arg)
+static int msgpack_packer_ext_find_superclass(VALUE key, VALUE value, VALUE arg)
 {
     VALUE *args = (VALUE *) arg;
     if(key == Qundef) {
@@ -62,34 +59,76 @@ static int msgpack_packer_ext_find_inherited(VALUE key, VALUE value, VALUE arg)
     return ST_CONTINUE;
 }
 
+static inline VALUE msgpack_packer_ext_registry_fetch(msgpack_packer_ext_registry_t* pkrg,
+        VALUE lookup_class, int* ext_type_result)
+{
+    // fetch lookup_class from hash, which is a hash to register classes
+    VALUE type = rb_hash_lookup(pkrg->hash, lookup_class);
+    if(type != Qnil) {
+        *ext_type_result = FIX2INT(rb_ary_entry(type, 0));
+        return rb_ary_entry(type, 1);
+    }
+
+    // fetch lookup_class from cache, which stores results of searching ancestors from pkrg->hash
+    VALUE type_inht = rb_hash_lookup(pkrg->cache, lookup_class);
+    if(type_inht != Qnil) {
+        *ext_type_result = FIX2INT(rb_ary_entry(type_inht, 0));
+        return rb_ary_entry(type_inht, 1);
+    }
+
+    return Qnil;
+}
 
 static inline VALUE msgpack_packer_ext_registry_lookup(msgpack_packer_ext_registry_t* pkrg,
-        VALUE ext_class, int* ext_type_result)
+        VALUE instance, int* ext_type_result)
 {
-    VALUE e = rb_hash_lookup(pkrg->hash, ext_class);
-    if(e != Qnil) {
-        *ext_type_result = FIX2INT(rb_ary_entry(e, 0));
-        return rb_ary_entry(e, 1);
+    VALUE lookup_class;
+    VALUE type;
+
+    /*
+     * 1. check whether singleton_class of this instance is registered (or resolved in past) or not.
+     *
+     * Objects of type Integer (Fixnum, Bignum), Float, Symbol and frozen
+     * String have no singleton class and raise a TypeError when trying to get
+     * it. See implementation of #singleton_class in ruby's source code:
+     * VALUE rb_singleton_class(VALUE obj);
+     *
+     * Since all but symbols are already filtered out when reaching this code
+     * only symbols are checked here.
+     */
+    if (!SYMBOL_P(instance)) {
+      lookup_class = rb_singleton_class(instance);
+
+      type = msgpack_packer_ext_registry_fetch(pkrg, lookup_class, ext_type_result);
+
+      if(type != Qnil) {
+          return type;
+      }
     }
 
-    VALUE c = rb_hash_lookup(pkrg->cache, ext_class);
-    if(c != Qnil) {
-        *ext_type_result = FIX2INT(rb_ary_entry(c, 0));
-        return rb_ary_entry(c, 1);
+    /*
+     * 2. check the class of instance is registered (or resolved in past) or not.
+     */
+    type = msgpack_packer_ext_registry_fetch(pkrg, rb_obj_class(instance), ext_type_result);
+
+    if(type != Qnil) {
+        return type;
     }
 
     /*
-     * check all keys whether it is super class of ext_class, or not
+     * 3. check all keys whether it is an ancestor of lookup_class, or not
      */
     VALUE args[2];
-    args[0] = ext_class;
+    args[0] = lookup_class;
     args[1] = Qnil;
-    rb_hash_foreach(pkrg->hash, msgpack_packer_ext_find_inherited, (VALUE) args);
-
-    VALUE hit = args[1];
-    if(hit != Qnil) {
-        rb_hash_aset(pkrg->cache, ext_class, hit);
-        return hit;
+    rb_hash_foreach(pkrg->hash, msgpack_packer_ext_find_superclass, (VALUE) args);
+
+    VALUE superclass = args[1];
+    if(superclass != Qnil) {
+        VALUE superclass_type = rb_hash_lookup(pkrg->hash, superclass);
+        rb_hash_aset(pkrg->cache, lookup_class, superclass_type);
+        *ext_type_result = FIX2INT(rb_ary_entry(superclass_type, 0));
+        return rb_ary_entry(superclass_type, 1);
     }
 
     return Qnil;

data/ext/msgpack/rbinit.c

@@ -21,7 +21,6 @@
 #include "unpacker_class.h"
 #include "factory_class.h"
 #include "extension_value_class.h"
-#include "core_ext.h"
 
 void Init_msgpack(void)
 {
@@ -32,6 +31,5 @@ void Init_msgpack(void)
     MessagePack_Unpacker_module_init(mMessagePack);
     MessagePack_Factory_module_init(mMessagePack);
     MessagePack_ExtensionValue_module_init(mMessagePack);
-    MessagePack_core_ext_module_init();
 }
 

data/ext/msgpack/unpacker.c

@@ -369,7 +369,7 @@ static int read_primitive(msgpack_unpacker_t* uk)
             {
                 READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 2);
                 uint8_t length = cb->u8;
-                int ext_type = cb->buffer[1];
+                int ext_type = (signed char) cb->buffer[1];
                 if(length == 0) {
                     return object_complete_ext(uk, ext_type, rb_str_buf_new(0));
                 }
@@ -381,7 +381,7 @@ static int read_primitive(msgpack_unpacker_t* uk)
             {
                 READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 3);
                 uint16_t length = _msgpack_be16(cb->u16);
-                int ext_type = cb->buffer[2];
+                int ext_type = (signed char) cb->buffer[2];
                 if(length == 0) {
                     return object_complete_ext(uk, ext_type, rb_str_buf_new(0));
                 }
@@ -393,7 +393,7 @@ static int read_primitive(msgpack_unpacker_t* uk)
             {
                 READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 5);
                 uint32_t length = _msgpack_be32(cb->u32);
-                int ext_type = cb->buffer[4];
+                int ext_type = (signed char) cb->buffer[4];
                 if(length == 0) {
                     return object_complete_ext(uk, ext_type, rb_str_buf_new(0));
                 }

data/ext/msgpack/unpacker_class.c

@@ -58,14 +58,10 @@ static void Unpacker_mark(msgpack_unpacker_t* uk)
 
 VALUE MessagePack_Unpacker_alloc(VALUE klass)
 {
-    msgpack_unpacker_t* uk = ALLOC_N(msgpack_unpacker_t, 1);
+    msgpack_unpacker_t* uk = ZALLOC_N(msgpack_unpacker_t, 1);
     _msgpack_unpacker_init(uk);
 
     VALUE self = Data_Wrap_Struct(klass, Unpacker_mark, Unpacker_free, uk);
-
-    msgpack_unpacker_ext_registry_init(&uk->ext_registry);
-    uk->buffer_ref = MessagePack_Buffer_wrap(UNPACKER_BUFFER_(uk), self);
-
     return self;
 }
 
@@ -81,9 +77,6 @@ VALUE MessagePack_Unpacker_initialize(int argc, VALUE* argv, VALUE self)
         VALUE v = argv[0];
         if(rb_type(v) == T_HASH) {
             options = v;
-            if(rb_type(options) != T_HASH) {
-                rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
-            }
         } else {
             io = v;
         }
@@ -101,6 +94,9 @@ VALUE MessagePack_Unpacker_initialize(int argc, VALUE* argv, VALUE self)
 
     UNPACKER(self, uk);
 
+    msgpack_unpacker_ext_registry_init(&uk->ext_registry);
+    uk->buffer_ref = MessagePack_Buffer_wrap(UNPACKER_BUFFER_(uk), self);
+
     MessagePack_Buffer_set_options(UNPACKER_BUFFER_(uk), io, options);
 
     if(options != Qnil) {
@@ -257,6 +253,17 @@ static VALUE Unpacker_feed(VALUE self, VALUE data)
     return self;
 }
 
+static VALUE Unpacker_feed_reference(VALUE self, VALUE data)
+{
+    UNPACKER(self, uk);
+
+    StringValue(data);
+
+    msgpack_buffer_append_string_reference(UNPACKER_BUFFER_(uk), data);
+
+    return self;
+}
+
 static VALUE Unpacker_each_impl(VALUE self)
 {
     UNPACKER(self, uk);
@@ -313,8 +320,7 @@ static VALUE Unpacker_feed_each(VALUE self, VALUE data)
     }
 #endif
 
-    // TODO optimize
-    Unpacker_feed(self, data);
+    Unpacker_feed_reference(self, data);
     return Unpacker_each(self);
 }
 
@@ -348,7 +354,7 @@ static VALUE Unpacker_register_type(int argc, VALUE* argv, VALUE self)
     int ext_type;
     VALUE proc;
     VALUE arg;
-    VALUE ext_class;
+    VALUE ext_module;
 
     switch (argc) {
     case 1:
@@ -361,50 +367,32 @@ static VALUE Unpacker_register_type(int argc, VALUE* argv, VALUE self)
         proc = rb_block_proc();
 #endif
         arg = proc;
-        ext_class = Qnil;
+        ext_module = Qnil;
         break;
     case 3:
         /* register_type(0x7f, Time, :from_msgpack_ext) */
-        ext_class = argv[1];
+        ext_module = argv[1];
         arg = argv[2];
-        proc = rb_obj_method(ext_class, arg);
+        proc = rb_obj_method(ext_module, arg);
         break;
     default:
         rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 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);
     }
 
-    msgpack_unpacker_ext_registry_put(&uk->ext_registry, ext_class, ext_type, proc, arg);
+    msgpack_unpacker_ext_registry_put(&uk->ext_registry, ext_module, ext_type, proc, arg);
 
     return Qnil;
 }
 
-VALUE MessagePack_unpack(int argc, VALUE* argv)
+static VALUE Unpacker_full_unpack(VALUE self)
 {
-    VALUE src;
-    VALUE self;
-
-    if (argc < 0 || argc > 2) {
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..2)", argc);
-    }
-    src = argv[0];
-
-    if(rb_type(src) == T_STRING) {
-        self = MessagePack_Factory_unpacker(argc - 1, argv + 1, cMessagePack_DefaultFactory);
-        UNPACKER(self, uk);
-        msgpack_buffer_append_string(UNPACKER_BUFFER_(uk), src);
-    } else {
-        self = MessagePack_Factory_unpacker(argc, argv, cMessagePack_DefaultFactory);
-    }
     UNPACKER(self, uk);
 
-    /* prefer reference than copying; see MessagePack_Unpacker_module_init */
-    msgpack_buffer_set_write_reference_threshold(UNPACKER_BUFFER_(uk), 0);
-
     int r = msgpack_unpacker_read(uk, 0);
     if(r < 0) {
         raise_unpacker_error(r);
@@ -416,27 +404,9 @@ VALUE MessagePack_unpack(int argc, VALUE* argv)
         rb_raise(eMalformedFormatError, "%zd extra bytes after the deserialized object", extra);
     }
 
-#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 msgpack_unpacker_get_last_object(uk);
 }
 
-static VALUE MessagePack_load_module_method(int argc, VALUE* argv, VALUE mod)
-{
-    UNUSED(mod);
-    return MessagePack_unpack(argc, argv);
-}
-
-static VALUE MessagePack_unpack_module_method(int argc, VALUE* argv, VALUE mod)
-{
-    UNUSED(mod);
-    return MessagePack_unpack(argc, argv);
-}
-
 VALUE MessagePack_Unpacker_new(int argc, VALUE* argv)
 {
     VALUE self = MessagePack_Unpacker_alloc(cMessagePack_Unpacker);
@@ -478,6 +448,7 @@ void MessagePack_Unpacker_module_init(VALUE mMessagePack)
     rb_define_method(cMessagePack_Unpacker, "read_map_header", Unpacker_read_map_header, 0);
     //rb_define_method(cMessagePack_Unpacker, "peek_next_type", Unpacker_peek_next_type, 0);  // TODO
     rb_define_method(cMessagePack_Unpacker, "feed", Unpacker_feed, 1);
+    rb_define_method(cMessagePack_Unpacker, "feed_reference", Unpacker_feed_reference, 1);
     rb_define_method(cMessagePack_Unpacker, "each", Unpacker_each, 0);
     rb_define_method(cMessagePack_Unpacker, "feed_each", Unpacker_feed_each, 1);
     rb_define_method(cMessagePack_Unpacker, "reset", Unpacker_reset, 0);
@@ -491,8 +462,6 @@ void MessagePack_Unpacker_module_init(VALUE mMessagePack)
     /* prefer reference than copying */
     //msgpack_buffer_set_write_reference_threshold(UNPACKER_BUFFER_(s_unpacker), 0);
 
-    /* MessagePack.unpack(x) */
-    rb_define_module_function(mMessagePack, "load", MessagePack_load_module_method, -1);
-    rb_define_module_function(mMessagePack, "unpack", MessagePack_unpack_module_method, -1);
+    rb_define_method(cMessagePack_Unpacker, "full_unpack", Unpacker_full_unpack, 0);
 }
 

data/ext/msgpack/unpacker_class.h

@@ -28,7 +28,5 @@ VALUE MessagePack_Unpacker_alloc(VALUE klass);
 
 VALUE MessagePack_Unpacker_initialize(int argc, VALUE* argv, VALUE self);
 
-VALUE MessagePack_unpack(int argc, VALUE* argv);
-
 #endif
 

data/ext/msgpack/unpacker_ext_registry.c

@@ -53,9 +53,9 @@ void msgpack_unpacker_ext_registry_dup(msgpack_unpacker_ext_registry_t* src,
 }
 
 VALUE msgpack_unpacker_ext_registry_put(msgpack_unpacker_ext_registry_t* ukrg,
-        VALUE ext_class, int ext_type, VALUE proc, VALUE arg)
+        VALUE ext_module, int ext_type, VALUE proc, VALUE arg)
 {
-    VALUE e = rb_ary_new3(3, ext_class, proc, arg);
+    VALUE e = rb_ary_new3(3, ext_module, proc, arg);
     VALUE before = ukrg->array[ext_type + 128];
     ukrg->array[ext_type + 128] = e;
     return before;

data/ext/msgpack/unpacker_ext_registry.h

@@ -15,8 +15,8 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
-#ifndef MSGPACK_RUBY_PACKER_PACKER_EXT_REGISTRY_H__
-#define MSGPACK_RUBY_PACKER_PACKER_EXT_REGISTRY_H__
+#ifndef MSGPACK_RUBY_UNPACKER_EXT_REGISTRY_H__
+#define MSGPACK_RUBY_UNPACKER_EXT_REGISTRY_H__
 
 #include "compat.h"
 #include "ruby.h"
@@ -44,7 +44,7 @@ void msgpack_unpacker_ext_registry_dup(msgpack_unpacker_ext_registry_t* src,
         msgpack_unpacker_ext_registry_t* dst);
 
 VALUE msgpack_unpacker_ext_registry_put(msgpack_unpacker_ext_registry_t* ukrg,
-        VALUE ext_class, int ext_type, VALUE proc, VALUE arg);
+        VALUE ext_module, int ext_type, VALUE proc, VALUE arg);
 
 static inline VALUE msgpack_unpacker_ext_registry_lookup(msgpack_unpacker_ext_registry_t* ukrg,
         int ext_type)

data/lib/msgpack.rb

@@ -15,3 +15,39 @@ end
 require "msgpack/packer"
 require "msgpack/unpacker"
 require "msgpack/factory"
+require "msgpack/symbol"
+require "msgpack/core_ext"
+require "msgpack/timestamp"
+require "msgpack/time"
+
+module MessagePack
+  DefaultFactory = MessagePack::Factory.new
+  DEFAULT_EMPTY_PARAMS = {}.freeze
+
+  def load(src, param = nil)
+    unpacker = nil
+
+    if src.is_a? String
+      unpacker = DefaultFactory.unpacker param || DEFAULT_EMPTY_PARAMS
+      unpacker.feed_reference src
+    else
+      unpacker = DefaultFactory.unpacker src, param || DEFAULT_EMPTY_PARAMS
+    end
+
+    unpacker.full_unpack
+  end
+  alias :unpack :load
+
+  module_function :load
+  module_function :unpack
+
+  def pack(v, *rest)
+    packer = DefaultFactory.packer(*rest)
+    packer.write v
+    packer.full_pack
+  end
+  alias :dump :pack
+
+  module_function :pack
+  module_function :dump
+end