msgpack 1.4.2 → 1.4.3

data/ext/java/org/msgpack/jruby/Unpacker.java

@@ -27,6 +27,7 @@ import static org.jruby.runtime.Visibility.PRIVATE;
 
 @JRubyClass(name="MessagePack::Unpacker")
 public class Unpacker extends RubyObject {
+  private static final long serialVersionUID = 8451264671199362492L;
   private final ExtensionRegistry registry;
 
   private IRubyObject stream;
@@ -59,22 +60,23 @@ public class Unpacker extends RubyObject {
     allowUnknownExt = false;
     freeze = false;
     if (args.length > 0) {
+      Ruby runtime = ctx.runtime;
       if (args[args.length - 1] instanceof RubyHash) {
         RubyHash options = (RubyHash) args[args.length - 1];
-        IRubyObject sk = options.fastARef(ctx.getRuntime().newSymbol("symbolize_keys"));
+        IRubyObject sk = options.fastARef(runtime.newSymbol("symbolize_keys"));
         if (sk != null) {
           symbolizeKeys = sk.isTrue();
         }
-        IRubyObject f = options.fastARef(ctx.getRuntime().newSymbol("freeze"));
+        IRubyObject f = options.fastARef(runtime.newSymbol("freeze"));
         if (f != null) {
           freeze = f.isTrue();
         }
-        IRubyObject au = options.fastARef(ctx.getRuntime().newSymbol("allow_unknown_ext"));
+        IRubyObject au = options.fastARef(runtime.newSymbol("allow_unknown_ext"));
         if (au != null) {
           allowUnknownExt = au.isTrue();
         }
       }
-      if (args[0] != ctx.getRuntime().getNil() && !(args[0] instanceof RubyHash)) {
+      if (args[0] != runtime.getNil() && !(args[0] instanceof RubyHash)) {
         setStream(ctx, args[0]);
       }
     }
@@ -82,24 +84,24 @@ public class Unpacker extends RubyObject {
   }
 
   public static Unpacker newUnpacker(ThreadContext ctx, ExtensionRegistry extRegistry, IRubyObject[] args) {
-    Unpacker unpacker = new Unpacker(ctx.getRuntime(), ctx.getRuntime().getModule("MessagePack").getClass("Unpacker"), extRegistry);
+    Unpacker unpacker = new Unpacker(ctx.runtime, ctx.runtime.getModule("MessagePack").getClass("Unpacker"), extRegistry);
     unpacker.initialize(ctx, args);
     return unpacker;
   }
 
   @JRubyMethod(name = "symbolize_keys?")
   public IRubyObject isSymbolizeKeys(ThreadContext ctx) {
-    return symbolizeKeys ? ctx.getRuntime().getTrue() : ctx.getRuntime().getFalse();
+    return symbolizeKeys ? ctx.runtime.getTrue() : ctx.runtime.getFalse();
   }
 
   @JRubyMethod(name = "freeze?")
   public IRubyObject isFreeze(ThreadContext ctx) {
-    return freeze ? ctx.getRuntime().getTrue() : ctx.getRuntime().getFalse();
+    return freeze ? ctx.runtime.getTrue() : ctx.runtime.getFalse();
   }
 
   @JRubyMethod(name = "allow_unknown_ext?")
   public IRubyObject isAllowUnknownExt(ThreadContext ctx) {
-    return allowUnknownExt ? ctx.getRuntime().getTrue() : ctx.getRuntime().getFalse();
+    return allowUnknownExt ? ctx.runtime.getTrue() : ctx.runtime.getFalse();
   }
 
   @JRubyMethod(name = "registered_types_internal", visibility = PRIVATE)
@@ -109,7 +111,7 @@ public class Unpacker extends RubyObject {
 
   @JRubyMethod(name = "register_type", required = 1, optional = 2)
   public IRubyObject registerType(ThreadContext ctx, IRubyObject[] args, final Block block) {
-    Ruby runtime = ctx.getRuntime();
+    Ruby runtime = ctx.runtime;
     IRubyObject type = args[0];
 
     RubyModule extModule;
@@ -155,7 +157,7 @@ public class Unpacker extends RubyObject {
     if (limit == -1) {
       limit = byteList.length() - offset;
     }
-    Decoder decoder = new Decoder(ctx.getRuntime(), registry, byteList.unsafeBytes(), byteList.begin() + offset, limit, symbolizeKeys, freeze, allowUnknownExt);
+    Decoder decoder = new Decoder(ctx.runtime, registry, byteList.unsafeBytes(), byteList.begin() + offset, limit, symbolizeKeys, freeze, allowUnknownExt);
     try {
       data = null;
       data = decoder.next();
@@ -164,13 +166,13 @@ public class Unpacker extends RubyObject {
         throw re;
       }
     }
-    return ctx.getRuntime().newFixnum(decoder.offset());
+    return ctx.runtime.newFixnum(decoder.offset());
   }
 
   @JRubyMethod(name = "data")
   public IRubyObject getData(ThreadContext ctx) {
     if (data == null) {
-      return ctx.getRuntime().getNil();
+      return ctx.runtime.getNil();
     } else {
       return data;
     }
@@ -178,14 +180,14 @@ public class Unpacker extends RubyObject {
 
   @JRubyMethod(name = "finished?")
   public IRubyObject finished_p(ThreadContext ctx) {
-    return data == null ? ctx.getRuntime().getFalse() : ctx.getRuntime().getTrue();
+    return data == null ? ctx.runtime.getFalse() : ctx.runtime.getTrue();
   }
 
   @JRubyMethod(required = 1, name = "feed", alias = { "feed_reference" })
   public IRubyObject feed(ThreadContext ctx, IRubyObject data) {
     ByteList byteList = data.asString().getByteList();
     if (decoder == null) {
-      decoder = new Decoder(ctx.getRuntime(), registry, byteList.unsafeBytes(), byteList.begin(), byteList.length(), symbolizeKeys, freeze, allowUnknownExt);
+      decoder = new Decoder(ctx.runtime, registry, byteList.unsafeBytes(), byteList.begin(), byteList.length(), symbolizeKeys, freeze, allowUnknownExt);
     } else {
       decoder.feed(byteList.unsafeBytes(), byteList.begin(), byteList.length());
     }
@@ -202,7 +204,7 @@ public class Unpacker extends RubyObject {
     feed(ctx, data);
     if (block.isGiven()) {
       each(ctx, block);
-      return ctx.getRuntime().getNil();
+      return ctx.runtime.getNil();
     } else {
       return callMethod(ctx, "to_enum");
     }
@@ -230,7 +232,7 @@ public class Unpacker extends RubyObject {
 
   @JRubyMethod
   public IRubyObject fill(ThreadContext ctx) {
-    return ctx.getRuntime().getNil();
+    return ctx.runtime.getNil();
   }
 
   @JRubyMethod
@@ -238,13 +240,13 @@ public class Unpacker extends RubyObject {
     if (decoder != null) {
       decoder.reset();
     }
-    return ctx.getRuntime().getNil();
+    return ctx.runtime.getNil();
   }
 
   @JRubyMethod(name = "read", alias = { "unpack" })
   public IRubyObject read(ThreadContext ctx) {
     if (decoder == null) {
-      throw ctx.getRuntime().newEOFError();
+      throw ctx.runtime.newEOFError();
     }
     try {
       return decoder.next();
@@ -252,19 +254,19 @@ public class Unpacker extends RubyObject {
       if (re.getException().getType() != underflowErrorClass) {
         throw re;
       } else {
-        throw ctx.getRuntime().newEOFError();
+        throw ctx.runtime.newEOFError();
       }
     }
   }
 
   @JRubyMethod(name = "skip")
   public IRubyObject skip(ThreadContext ctx) {
-    throw ctx.getRuntime().newNotImplementedError("Not supported yet in JRuby implementation");
+    throw ctx.runtime.newNotImplementedError("Not supported yet in JRuby implementation");
   }
 
   @JRubyMethod(name = "skip_nil")
   public IRubyObject skipNil(ThreadContext ctx) {
-    throw ctx.getRuntime().newNotImplementedError("Not supported yet in JRuby implementation");
+    throw ctx.runtime.newNotImplementedError("Not supported yet in JRuby implementation");
   }
 
   @JRubyMethod
@@ -276,11 +278,11 @@ public class Unpacker extends RubyObject {
         if (re.getException().getType() != underflowErrorClass) {
           throw re;
         } else {
-          throw ctx.getRuntime().newEOFError();
+          throw ctx.runtime.newEOFError();
         }
       }
     }
-    return ctx.getRuntime().getNil();
+    return ctx.runtime.getNil();
   }
 
   @JRubyMethod
@@ -292,17 +294,17 @@ public class Unpacker extends RubyObject {
         if (re.getException().getType() != underflowErrorClass) {
           throw re;
         } else {
-          throw ctx.getRuntime().newEOFError();
+          throw ctx.runtime.newEOFError();
         }
       }
     }
-    return ctx.getRuntime().getNil();
+    return ctx.runtime.getNil();
   }
 
   @JRubyMethod(name = "stream")
   public IRubyObject getStream(ThreadContext ctx) {
     if (stream == null) {
-      return ctx.getRuntime().getNil();
+      return ctx.runtime.getNil();
     } else {
       return stream;
     }
@@ -318,12 +320,12 @@ public class Unpacker extends RubyObject {
     } else if (stream.respondsTo("read")) {
       str = stream.callMethod(ctx, "read").asString();
     } else {
-      throw ctx.getRuntime().newTypeError(stream, "IO");
+      throw ctx.runtime.newTypeError(stream, "IO");
     }
     ByteList byteList = str.getByteList();
     this.stream = stream;
     this.decoder = null;
-    this.decoder = new Decoder(ctx.getRuntime(), registry, byteList.unsafeBytes(), byteList.begin(), byteList.length(), symbolizeKeys, freeze, allowUnknownExt);
+    this.decoder = new Decoder(ctx.runtime, registry, byteList.unsafeBytes(), byteList.begin(), byteList.length(), symbolizeKeys, freeze, allowUnknownExt);
     return getStream(ctx);
   }
 }

data/ext/msgpack/buffer.c

@@ -164,12 +164,7 @@ size_t msgpack_buffer_read_to_string_nonblock(msgpack_buffer_t* b, VALUE string,
             b->head->mapped_string != NO_MAPPED_STRING &&
             length >= b->read_reference_threshold) {
         VALUE s = _msgpack_buffer_refer_head_mapped_string(b, length);
-#ifndef HAVE_RB_STR_REPLACE
-        /* TODO MRI 1.8 */
-        rb_funcall(string, s_replace, 1, s);
-#else
         rb_str_replace(string, s);
-#endif
         /* here doesn't have to call ENCODING_SET because
          * encoding of s is always ASCII-8BIT */
         _msgpack_buffer_consumed(b, length);

data/ext/msgpack/buffer.h

@@ -494,4 +494,9 @@ static inline VALUE msgpack_buffer_read_top_as_string(msgpack_buffer_t* b, size_
 #endif // HAVE_RB_ENC_INTERNED_STR
 }
 
+static inline VALUE msgpack_buffer_read_top_as_symbol(msgpack_buffer_t* b, size_t length)
+{
+    return rb_str_intern(msgpack_buffer_read_top_as_string(b, length, true, false));
+}
+
 #endif

data/ext/msgpack/extconf.rb

@@ -2,14 +2,7 @@ require 'mkmf'
 
 have_header("ruby/st.h")
 have_header("st.h")
-have_func("rb_str_replace", ["ruby.h"])
-have_func("rb_intern_str", ["ruby.h"])
 have_func("rb_enc_interned_str", "ruby.h")
-have_func("rb_sym2str", ["ruby.h"])
-have_func("rb_str_intern", ["ruby.h"])
-have_func("rb_block_lambda", ["ruby.h"])
-have_func("rb_hash_dup", ["ruby.h"])
-have_func("rb_hash_clear", ["ruby.h"])
 
 unless RUBY_PLATFORM.include? 'mswin'
   $CFLAGS << %[ -I.. -Wall -O3 -g -std=gnu99]

data/ext/msgpack/factory_class.c

@@ -32,6 +32,8 @@ struct msgpack_factory_t {
     msgpack_packer_ext_registry_t pkrg;
     msgpack_unpacker_ext_registry_t ukrg;
     bool has_symbol_ext_type;
+    bool optimized_symbol_ext_type;
+    int symbol_ext_type;
 };
 
 #define FACTORY(from, name) \
@@ -114,6 +116,8 @@ VALUE MessagePack_Factory_unpacker(int argc, VALUE* argv, VALUE self)
 
     msgpack_unpacker_ext_registry_destroy(&uk->ext_registry);
     msgpack_unpacker_ext_registry_dup(&fc->ukrg, &uk->ext_registry);
+    uk->optimized_symbol_ext_type = fc->optimized_symbol_ext_type;
+    uk->symbol_ext_type = fc->symbol_ext_type;
 
     return unpacker;
 }
@@ -128,11 +132,7 @@ static VALUE Factory_registered_types_internal(VALUE self)
             rb_hash_aset(uk_mapping, INT2FIX(i - 128), fc->ukrg.array[i]);
         }
     }
-#ifdef HAVE_RB_HASH_DUP
     return rb_ary_new3(2, rb_hash_dup(fc->pkrg.hash), uk_mapping);
-#else
-    return rb_ary_new3(2, rb_funcall(fc->pkrg.hash, rb_intern("dup"), 0), uk_mapping);
-#endif
 }
 
 static VALUE Factory_register_type(int argc, VALUE* argv, VALUE self)
@@ -141,7 +141,7 @@ static VALUE Factory_register_type(int argc, VALUE* argv, VALUE self)
 
     int ext_type;
     VALUE ext_module;
-    VALUE options;
+    VALUE options = Qnil;
     VALUE packer_arg, unpacker_arg;
     VALUE packer_proc, unpacker_proc;
 
@@ -188,6 +188,8 @@ 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_module, unpacker_arg);
+        } else if (rb_respond_to(unpacker_arg, rb_intern("call"))) {
+            unpacker_proc = unpacker_arg;
         } else {
             unpacker_proc = rb_funcall(unpacker_arg, rb_intern("method"), 1, ID2SYM(rb_intern("call")));
         }
@@ -197,6 +199,9 @@ static VALUE Factory_register_type(int argc, VALUE* argv, VALUE self)
 
     if (ext_module == rb_cSymbol) {
         fc->has_symbol_ext_type = true;
+        if(RB_TEST(options) && RB_TEST(rb_hash_aref(options, ID2SYM(rb_intern("optimized_symbols_parsing"))))) {
+            fc->optimized_symbol_ext_type = true;
+        }
     }
 
     msgpack_unpacker_ext_registry_put(&fc->ukrg, ext_module, ext_type, unpacker_proc, unpacker_arg);

data/ext/msgpack/packer.c

@@ -121,7 +121,7 @@ void msgpack_packer_write_hash_value(msgpack_packer_t* pk, VALUE v)
 #endif
 }
 
-void msgpack_packer_write_other_value(msgpack_packer_t* pk, VALUE v)
+bool msgpack_packer_try_write_with_ext_type_lookup(msgpack_packer_t* pk, VALUE v)
 {
     int ext_type;
 
@@ -131,7 +131,14 @@ void msgpack_packer_write_other_value(msgpack_packer_t* pk, VALUE v)
         VALUE payload = rb_funcall(proc, s_call, 1, v);
         StringValue(payload);
         msgpack_packer_write_ext(pk, ext_type, payload);
-    } else {
+        return true;
+    }
+    return false;
+}
+
+void msgpack_packer_write_other_value(msgpack_packer_t* pk, VALUE v)
+{
+    if(!(msgpack_packer_try_write_with_ext_type_lookup(pk, v))) {
         rb_funcall(v, pk->to_msgpack_method, 1, pk->to_msgpack_arg);
     }
 }
@@ -155,13 +162,19 @@ void msgpack_packer_write_value(msgpack_packer_t* pk, VALUE v)
         msgpack_packer_write_symbol_value(pk, v);
         break;
     case T_STRING:
-        msgpack_packer_write_string_value(pk, v);
+        if(rb_class_of(v) == rb_cString || !msgpack_packer_try_write_with_ext_type_lookup(pk, v)) {
+            msgpack_packer_write_string_value(pk, v);
+        }
         break;
     case T_ARRAY:
-        msgpack_packer_write_array_value(pk, v);
+        if(rb_class_of(v) == rb_cArray || !msgpack_packer_try_write_with_ext_type_lookup(pk, v)) {
+            msgpack_packer_write_array_value(pk, v);
+        }
         break;
     case T_HASH:
-        msgpack_packer_write_hash_value(pk, v);
+        if(rb_class_of(v) == rb_cHash || !msgpack_packer_try_write_with_ext_type_lookup(pk, v)) {
+            msgpack_packer_write_hash_value(pk, v);
+        }
         break;
     case T_BIGNUM:
         msgpack_packer_write_bignum_value(pk, v);

data/ext/msgpack/packer.h

@@ -444,16 +444,7 @@ static inline void msgpack_packer_write_string_value(msgpack_packer_t* pk, VALUE
 
 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 */
     msgpack_packer_write_string_value(pk, rb_sym2str(v));
-#else
-    VALUE str = rb_id2str(SYM2ID(v));
-    if (!str) {
-       rb_raise(rb_eRuntimeError, "could not convert a symbol to string");
-    }
-    msgpack_packer_write_string_value(pk, str);
-#endif
 }
 
 void msgpack_packer_write_other_value(msgpack_packer_t* pk, VALUE v);

data/ext/msgpack/packer_class.c

@@ -339,11 +339,7 @@ static VALUE Packer_write_to(VALUE self, VALUE io)
 static VALUE Packer_registered_types_internal(VALUE self)
 {
     PACKER(self, pk);
-#ifdef HAVE_RB_HASH_DUP
     return rb_hash_dup(pk->ext_registry.hash);
-#else
-    return rb_funcall(pk->ext_registry.hash, rb_intern("dup"), 0);
-#endif
 }
 
 static VALUE Packer_register_type(int argc, VALUE* argv, VALUE self)
@@ -359,12 +355,7 @@ static VALUE Packer_register_type(int argc, VALUE* argv, VALUE self)
     case 2:
         /* register_type(0x7f, Time) {|obj| block... } */
         rb_need_block();
-#ifdef HAVE_RB_BLOCK_LAMBDA
         proc = rb_block_lambda();
-#else
-        /* MRI 1.8 */
-        proc = rb_block_proc();
-#endif
         arg = proc;
         break;
     case 3:

data/ext/msgpack/packer_ext_registry.c

@@ -43,37 +43,15 @@ void msgpack_packer_ext_registry_mark(msgpack_packer_ext_registry_t* pkrg)
 void msgpack_packer_ext_registry_dup(msgpack_packer_ext_registry_t* src,
         msgpack_packer_ext_registry_t* dst)
 {
-#ifdef HAVE_RB_HASH_DUP
     dst->hash = rb_hash_dup(src->hash);
     dst->cache = rb_hash_dup(src->cache);
-#else
-    dst->hash = rb_funcall(src->hash, rb_intern("dup"), 0);
-    dst->cache = rb_funcall(src->cache, rb_intern("dup"), 0);
-#endif
 }
 
-#ifndef HAVE_RB_HASH_CLEAR
-
-static int
-__rb_hash_clear_clear_i(key, value, dummy)
-    VALUE key, value, dummy;
-{
-    return ST_DELETE;
-}
-
-#endif
-
 VALUE msgpack_packer_ext_registry_put(msgpack_packer_ext_registry_t* pkrg,
         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 */
-#ifdef HAVE_RB_HASH_CLEAR
     rb_hash_clear(pkrg->cache);
-#else
-    if(FIX2INT(rb_funcall(pkrg->cache, rb_intern("size"), 0)) > 0) {
-        rb_hash_foreach(pkrg->cache, __rb_hash_clear_clear_i, 0);
-    }
-#endif
     return rb_hash_aset(pkrg->hash, ext_module, e);
 }

data/ext/msgpack/unpacker.c

@@ -151,8 +151,19 @@ static inline int object_complete(msgpack_unpacker_t* uk, VALUE object)
     return PRIMITIVE_OBJECT_COMPLETE;
 }
 
+static inline int object_complete_symbol(msgpack_unpacker_t* uk, VALUE object)
+{
+    uk->last_object = object;
+    reset_head_byte(uk);
+    return PRIMITIVE_OBJECT_COMPLETE;
+}
+
 static inline int object_complete_ext(msgpack_unpacker_t* uk, int ext_type, VALUE str)
 {
+    if (uk->optimized_symbol_ext_type && ext_type == uk->symbol_ext_type) {
+        return object_complete_symbol(uk, rb_str_intern(str));
+    }
+
     VALUE proc = msgpack_unpacker_ext_registry_lookup(&uk->ext_registry, ext_type);
     if(proc != Qnil) {
         VALUE obj = rb_funcall(proc, s_call, 1, str);
@@ -273,22 +284,27 @@ static inline int read_raw_body_begin(msgpack_unpacker_t* uk, int raw_type)
     /* try optimized read */
     size_t length = uk->reading_raw_remaining;
     if(length <= msgpack_buffer_top_readable_size(UNPACKER_BUFFER_(uk))) {
-        /* don't use zerocopy for hash keys but get a frozen string directly
-         * because rb_hash_aset freezes keys and it causes copying */
-        bool will_freeze = uk->freeze || is_reading_map_key(uk);
-        VALUE string = msgpack_buffer_read_top_as_string(UNPACKER_BUFFER_(uk), length, will_freeze, raw_type == RAW_TYPE_STRING);
         int ret;
-        if(raw_type == RAW_TYPE_STRING || raw_type == RAW_TYPE_BINARY) {
-            ret = object_complete(uk, string);
+        if ((uk->optimized_symbol_ext_type && uk->symbol_ext_type == raw_type) || (uk->symbolize_keys && is_reading_map_key(uk))) {
+            VALUE symbol = msgpack_buffer_read_top_as_symbol(UNPACKER_BUFFER_(uk), length);
+            ret = object_complete_symbol(uk, symbol);
         } else {
-            ret = object_complete_ext(uk, raw_type, string);
-        }
+            /* don't use zerocopy for hash keys but get a frozen string directly
+             * because rb_hash_aset freezes keys and it causes copying */
+            bool will_freeze = uk->freeze || is_reading_map_key(uk);
+            VALUE string = msgpack_buffer_read_top_as_string(UNPACKER_BUFFER_(uk), length, will_freeze, raw_type == RAW_TYPE_STRING);
+            if(raw_type == RAW_TYPE_STRING || raw_type == RAW_TYPE_BINARY) {
+                ret = object_complete(uk, string);
+            } else {
+                ret = object_complete_ext(uk, raw_type, string);
+            }
 
 # if !HASH_ASET_DEDUPE
-        if(will_freeze) {
-            rb_obj_freeze(string);
-        }
+            if(will_freeze) {
+                rb_obj_freeze(string);
+            }
 # endif
+        }
         uk->reading_raw_remaining = 0;
         return ret;
     }
@@ -705,18 +721,8 @@ int msgpack_unpacker_read(msgpack_unpacker_t* uk, size_t target_stack_depth)
                 break;
             case STACK_TYPE_MAP_VALUE:
                 if(uk->symbolize_keys && rb_type(top->key) == T_STRING) {
-                    /* here uses rb_intern_str instead of rb_intern so that Ruby VM can GC unused symbols */
-#ifdef HAVE_RB_STR_INTERN
-                    /* rb_str_intern is added since MRI 2.2.0 */
+                    /* here uses rb_str_intern instead of rb_intern so that Ruby VM can GC unused symbols */
                     rb_hash_aset(top->object, rb_str_intern(top->key), uk->last_object);
-#else
-#ifndef HAVE_RB_INTERN_STR
-                    /* MRI 1.8 doesn't have rb_intern_str or rb_intern2 */
-                    rb_hash_aset(top->object, ID2SYM(rb_intern(RSTRING_PTR(top->key))), uk->last_object);
-#else
-                    rb_hash_aset(top->object, ID2SYM(rb_intern_str(top->key)), uk->last_object);
-#endif
-#endif
                 } else {
                     rb_hash_aset(top->object, top->key, uk->last_object);
                 }

data/ext/msgpack/unpacker.h

@@ -66,6 +66,8 @@ struct msgpack_unpacker_t {
     bool symbolize_keys;
     bool freeze;
     bool allow_unknown_ext;
+    bool optimized_symbol_ext_type;
+    int symbol_ext_type;
 };
 
 #define UNPACKER_BUFFER_(uk) (&(uk)->buffer)

data/ext/msgpack/unpacker_class.c

@@ -369,12 +369,7 @@ static VALUE Unpacker_register_type(int argc, VALUE* argv, VALUE self)
     case 1:
         /* register_type(0x7f) {|data| block... } */
         rb_need_block();
-#ifdef HAVE_RB_BLOCK_LAMBDA
         proc = rb_block_lambda();
-#else
-        /* MRI 1.8 */
-        proc = rb_block_proc();
-#endif
         arg = proc;
         ext_module = Qnil;
         break;

data/lib/msgpack/symbol.rb

@@ -1,9 +1,19 @@
 class Symbol
-  def to_msgpack_ext
-    [to_s].pack('A*')
+  # to_msgpack_ext is supposed to return a binary string.
+  # The canonical way to do it for symbols would be:
+  #  [to_s].pack('A*')
+  # However in this instance we can take a shortcut
+  if method_defined?(:name)
+    alias_method :to_msgpack_ext, :name
+  else
+    alias_method :to_msgpack_ext, :to_s
   end
 
   def self.from_msgpack_ext(data)
-    data.unpack('A*').first.to_sym
+    # from_msgpack_ext is supposed to parse a binary string.
+    # The canonical way to do it for symbols would be:
+    #  data.unpack1('A*').to_sym
+    # However in this instance we can take a shortcut
+    data.to_sym
   end
-end
+end

data/lib/msgpack/time.rb

@@ -18,7 +18,7 @@ module MessagePack
                else
                  lambda do |payload|
                    tv = MessagePack::Timestamp.from_msgpack_ext(payload)
-                   ::Time.at(tv.sec, tv.nsec / 1000.0)
+                   ::Time.at(tv.sec, tv.nsec / 1000.0r)
                  end
                end
 

data/lib/msgpack/version.rb

@@ -1,5 +1,5 @@
 module MessagePack
-  VERSION = "1.4.2"
+  VERSION = "1.4.3"
   # Note for maintainers:
   #  Don't miss building/releasing the JRuby version (rake buld:java)
   #  See "How to build -java rubygems" in README for more details.

data/lib/msgpack.rb

@@ -1,9 +1,8 @@
 require "msgpack/version"
 
 if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby" # This is same with `/java/ =~ RUBY_VERSION`
-  require "java"
   require "msgpack/msgpack.jar"
-  org.msgpack.jruby.MessagePackLibrary.new.load(JRuby.runtime, false)
+  JRuby::Util.load_ext("org.msgpack.jruby.MessagePackLibrary")
 else
   require "msgpack/msgpack"
 end

data/spec/factory_spec.rb

@@ -280,6 +280,23 @@ describe MessagePack::Factory do
       unpacker.feed(packed_symbol).unpack
     end
 
+    context 'using the optimized symbol unpacker' do
+      before do
+        skip if IS_JRUBY # JRuby implementation doesn't support the optimized symbols unpacker for now
+        subject.register_type(
+          0x00,
+          ::Symbol,
+          packer: :to_msgpack_ext,
+          unpacker: :from_msgpack_ext,
+          optimized_symbols_parsing: true,
+        )
+      end
+
+      it 'lets symbols survive a roundtrip' do
+        expect(symbol_after_roundtrip).to be :symbol
+      end
+    end
+
     context 'if no ext type is registered for symbols' do
       it 'converts symbols to string' do
         expect(symbol_after_roundtrip).to eq 'symbol'

data/spec/msgpack_spec.rb

@@ -115,7 +115,7 @@ describe MessagePack do
       expect { MessagePack.pack(self) }.to raise_error(NoMethodError, /^undefined method `to_msgpack'/)
     end
 
-    it 'rasies an error on #unpack with garbage' do
+    it 'raises an error on #unpack with garbage' do
       skip "but nothing was raised. why?"
       expect { MessagePack.unpack('asdka;sd') }.to raise_error(MessagePack::UnpackError)
     end

data/spec/packer_spec.rb

@@ -488,6 +488,24 @@ describe MessagePack::Packer do
       it { is_expected.to eq "\xC7\x0F\x01value_msgpacked" }
     end
 
+    shared_examples_for 'extension subclasses core type' do |klass|
+      before { stub_const('Value', Class.new(klass)) }
+      let(:object) { Value.new }
+      subject { packer.pack(object).to_s }
+
+      it "defaults to #{klass.name} packer if no extension is present" do
+        expect(subject).to eq(MessagePack.dump(klass.new))
+      end
+
+      it "uses core type extension for #{klass.name}" do
+        packer.register_type(0x01, Value, ->(_) { 'value_msgpacked' })
+        expect(subject).to eq("\xC7\x0F\x01value_msgpacked")
+      end
+    end
+    it_behaves_like 'extension subclasses core type', Hash
+    it_behaves_like 'extension subclasses core type', Array
+    it_behaves_like 'extension subclasses core type', String
+
     context 'when registering a type for symbols' do
       before { packer.register_type(0x00, ::Symbol, :to_msgpack_ext) }