msgpack 1.4.2 → 1.6.0

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

@@ -38,12 +38,16 @@ public class Encoder {
   private final Encoding utf8Encoding;
   private final boolean compatibilityMode;
   private final ExtensionRegistry registry;
+  private final Packer packer;
 
   public boolean hasSymbolExtType;
+  private boolean hasBigintExtType;
+  private boolean recursiveExtension;
 
   private ByteBuffer buffer;
 
-  public Encoder(Ruby runtime, boolean compatibilityMode, ExtensionRegistry registry, boolean hasSymbolExtType) {
+  public Encoder(Ruby runtime, Packer packer, boolean compatibilityMode, ExtensionRegistry registry, boolean hasSymbolExtType, boolean hasBigintExtType) {
+    this.packer = packer;
     this.runtime = runtime;
     this.buffer = ByteBuffer.allocate(CACHE_LINE_SIZE - ARRAY_HEADER_SIZE);
     this.binaryEncoding = runtime.getEncodingService().getAscii8bitEncoding();
@@ -51,6 +55,7 @@ public class Encoder {
     this.compatibilityMode = compatibilityMode;
     this.registry = registry;
     this.hasSymbolExtType = hasSymbolExtType;
+    this.hasBigintExtType = hasBigintExtType;
   }
 
   public boolean isCompatibilityMode() {
@@ -66,9 +71,17 @@ public class Encoder {
   }
 
   private IRubyObject readRubyString() {
-    IRubyObject str = runtime.newString(new ByteList(buffer.array(), 0, buffer.position(), binaryEncoding, false));
-    buffer.clear();
-    return str;
+    if (recursiveExtension) {
+      // If recursiveExtension is true, it means we re-entered encode, so we MUST NOT flush the buffer.
+	  // Instead we return an empty string to act as a null object for the caller. The buffer will actually
+	  // be flushed once we're done serializing the recursive extension.
+	  // All other method that consume the buffer should do so through readRubyString or implement the same logic.
+      return runtime.newString();
+    } else {
+      IRubyObject str = runtime.newString(new ByteList(buffer.array(), 0, buffer.position(), binaryEncoding, false));
+      buffer.clear();
+      return str;
+    }
   }
 
   public IRubyObject encode(IRubyObject object) {
@@ -119,7 +132,9 @@ public class Encoder {
     } else if (object instanceof RubyFloat) {
       appendFloat((RubyFloat) object);
     } else if (object instanceof RubyString) {
-      appendString((RubyString) object);
+      if (object.getType() == runtime.getString() || !tryAppendWithExtTypeLookup(object)) {
+        appendString((RubyString) object);
+      }
     } else if (object instanceof RubySymbol) {
       if (hasSymbolExtType) {
         appendOther(object, destination);
@@ -127,9 +142,13 @@ public class Encoder {
         appendString(((RubySymbol) object).asString());
       }
     } else if (object instanceof RubyArray) {
-      appendArray((RubyArray) object);
+      if (object.getType() == runtime.getArray() || !tryAppendWithExtTypeLookup(object)) {
+        appendArray((RubyArray) object);
+      }
     } else if (object instanceof RubyHash) {
-      appendHash((RubyHash) object);
+      if (object.getType() == runtime.getHash() || !tryAppendWithExtTypeLookup(object)) {
+        appendHash((RubyHash) object);
+      }
     } else if (object instanceof ExtensionValue) {
       appendExtensionValue((ExtensionValue) object);
     } else {
@@ -141,7 +160,10 @@ public class Encoder {
     BigInteger value = object.getBigIntegerValue();
     if (value.compareTo(RubyBignum.LONG_MIN) < 0 || value.compareTo(RubyBignum.LONG_MAX) > 0) {
       if (value.bitLength() > 64 || (value.bitLength() > 63 && value.signum() < 0)) {
-        throw runtime.newArgumentError(String.format("Cannot pack big integer: %s", value));
+        if (hasBigintExtType && tryAppendWithExtTypeLookup(object)) {
+          return;
+        }
+        throw runtime.newRangeError(String.format("Cannot pack big integer: %s", value));
       }
       ensureRemainingCapacity(9);
       buffer.put(value.signum() < 0 ? INT64 : UINT64);
@@ -153,7 +175,7 @@ public class Encoder {
   }
 
   private void appendInteger(RubyInteger object) {
-    long value = ((RubyInteger) object).getLongValue();
+    long value = object.getLongValue();
     if (value < 0) {
       if (value < Short.MIN_VALUE) {
         if (value < Integer.MIN_VALUE) {
@@ -241,7 +263,7 @@ public class Encoder {
     } else {
       ensureRemainingCapacity(5 + length);
       buffer.put(binary ? BIN32 : STR32);
-      buffer.putInt((int) length);
+      buffer.putInt(length);
     }
   }
 
@@ -249,7 +271,7 @@ public class Encoder {
     Encoding encoding = object.getEncoding();
     boolean binary = !compatibilityMode && encoding == binaryEncoding;
     if (encoding != utf8Encoding && encoding != binaryEncoding) {
-      object = (RubyString) ((RubyString) object).encode(runtime.getCurrentContext(), runtime.getEncodingService().getEncoding(utf8Encoding));
+      object = (RubyString)(object).encode(runtime.getCurrentContext(), runtime.getEncodingService().getEncoding(utf8Encoding));
     }
     ByteList bytes = object.getByteList();
     int length = bytes.length();
@@ -257,12 +279,12 @@ public class Encoder {
     buffer.put(bytes.unsafeBytes(), bytes.begin(), length);
   }
 
-  private void appendArray(RubyArray object) {
+  private void appendArray(RubyArray<?> object) {
     appendArrayHeader(object);
     appendArrayElements(object);
   }
 
-  private void appendArrayHeader(RubyArray object) {
+  private void appendArrayHeader(RubyArray<?> object) {
     appendArrayHeader(object.size());
   }
 
@@ -281,7 +303,7 @@ public class Encoder {
     }
   }
 
-  private void appendArrayElements(RubyArray object) {
+  private void appendArrayElements(RubyArray<?> object) {
     int size = object.size();
     for (int i = 0; i < size; i++) {
       appendObject(object.eltOk(i));
@@ -383,25 +405,41 @@ public class Encoder {
     appendExt((int) type, payloadBytes);
   }
 
-  private void appendOther(IRubyObject object, IRubyObject destination) {
+  private boolean tryAppendWithExtTypeLookup(IRubyObject object) {
     if (registry != null) {
-      RubyModule lookupClass;
-
-      if (object.getType() == runtime.getSymbol()) {
-        lookupClass = object.getType();
-      } else {
-        lookupClass = object.getSingletonClass();
-      }
-
-      IRubyObject[] pair = registry.lookupPackerForObject(object);
-      if (pair != null) {
-        RubyString bytes = pair[0].callMethod(runtime.getCurrentContext(), "call", object).asString();
-        int type = (int) ((RubyFixnum) pair[1]).getLongValue();
-        appendExt(type, bytes.getByteList());
-        return;
+      ExtensionRegistry.ExtensionEntry entry = registry.lookupExtensionForObject(object);
+      if (entry != null) {
+        IRubyObject proc = entry.getPackerProc();
+        int type = entry.getTypeId();
+
+        if (entry.isRecursive()) {
+          ByteBuffer oldBuffer = buffer;
+          buffer = ByteBuffer.allocate(CACHE_LINE_SIZE - ARRAY_HEADER_SIZE);
+          boolean previousRecursiveExtension = recursiveExtension;
+          recursiveExtension = true;
+
+          ByteList payload;
+          try {
+            IRubyObject args[] = { object, packer };
+            proc.callMethod(runtime.getCurrentContext(), "call", args);
+            payload = new ByteList(buffer.array(), 0, buffer.position(), binaryEncoding, false);
+          } finally {
+            recursiveExtension = previousRecursiveExtension;
+            buffer = oldBuffer;
+          }
+          appendExt(type, payload);
+        } else {
+          RubyString bytes = proc.callMethod(runtime.getCurrentContext(), "call", object).asString();
+          appendExt(type, bytes.getByteList());
+        }
+        return true;
       }
     }
-    appendCustom(object, destination);
+    return false;
+  }
+
+  private void appendOther(IRubyObject object, IRubyObject destination) {
+    if (!tryAppendWithExtTypeLookup(object)) { appendCustom(object, destination); }
   }
 
   private void appendCustom(IRubyObject object, IRubyObject destination) {

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

@@ -37,7 +37,7 @@ public class ExtensionRegistry {
   }
 
   public IRubyObject toInternalPackerRegistry(ThreadContext ctx) {
-    RubyHash hash = RubyHash.newHash(ctx.getRuntime());
+    RubyHash hash = RubyHash.newHash(ctx.runtime);
     for (RubyModule extensionModule : extensionsByModule.keySet()) {
       ExtensionEntry entry = extensionsByModule.get(extensionModule);
       if (entry.hasPacker()) {
@@ -48,75 +48,57 @@ public class ExtensionRegistry {
   }
 
   public IRubyObject toInternalUnpackerRegistry(ThreadContext ctx) {
-    RubyHash hash = RubyHash.newHash(ctx.getRuntime());
+    RubyHash hash = RubyHash.newHash(ctx.runtime);
     for (int typeIdIndex = 0 ; typeIdIndex < 256 ; typeIdIndex++) {
       ExtensionEntry entry = extensionsByTypeId[typeIdIndex];
       if (entry != null && entry.hasUnpacker()) {
-        IRubyObject typeId = RubyFixnum.newFixnum(ctx.getRuntime(), typeIdIndex - 128);
+        IRubyObject typeId = RubyFixnum.newFixnum(ctx.runtime, typeIdIndex - 128);
         hash.put(typeId, entry.toUnpackerTuple(ctx));
       }
     }
     return hash;
   }
 
-  public void put(RubyModule mod, int typeId, IRubyObject packerProc, IRubyObject packerArg, IRubyObject unpackerProc, IRubyObject unpackerArg) {
-    ExtensionEntry entry = new ExtensionEntry(mod, typeId, packerProc, packerArg, unpackerProc, unpackerArg);
+  public void put(RubyModule mod, int typeId, boolean recursive, IRubyObject packerProc, IRubyObject packerArg, IRubyObject unpackerProc, IRubyObject unpackerArg) {
+    ExtensionEntry entry = new ExtensionEntry(mod, typeId, recursive, packerProc, packerArg, unpackerProc, unpackerArg);
     extensionsByModule.put(mod, entry);
     extensionsByTypeId[typeId + 128] = entry;
     extensionsByAncestor.clear();
   }
 
-  public IRubyObject lookupUnpackerByTypeId(int typeId) {
+  public ExtensionEntry lookupExtensionByTypeId(int typeId) {
     ExtensionEntry e = extensionsByTypeId[typeId + 128];
     if (e != null && e.hasUnpacker()) {
-      return e.getUnpackerProc();
-    } else {
-      return null;
+      return e;
     }
+    return null;
   }
 
-  public IRubyObject[] lookupPackerForObject(IRubyObject object) {
+  public ExtensionEntry lookupExtensionForObject(IRubyObject object) {
     RubyModule lookupClass = null;
-    IRubyObject[] pair;
+    ExtensionEntry entry = null;
     /*
      * Objects of type Integer (Fixnum, Bignum), Float, Symbol and frozen
      * String have no singleton class and raise a TypeError when trying to get
      * it.
-     *
-     * Since all but symbols are already filtered out when reaching this code
-     * only symbols are checked here.
      */
-    if (!(object instanceof RubySymbol)) {
-      lookupClass = object.getSingletonClass();
-      pair = fetchEntryByModule(lookupClass);
-      if (pair != null) {
-          return pair;
-      }
+    lookupClass = object.getMetaClass();
+    entry = extensionsByModule.get(lookupClass);
+    if (entry != null && entry.hasPacker()) {
+      return entry;
     }
 
-    pair = fetchEntryByModule(object.getType());
-    if (pair != null) {
-      return pair;
+    RubyModule realClass = object.getType();
+    if (realClass != lookupClass) {
+      entry = extensionsByModule.get(realClass);
+      if (entry != null && entry.hasPacker()) {
+        return entry;
+      }
     }
 
-    if (lookupClass == null) {
-      lookupClass = object.getType(); // only for Symbol
-    }
-    ExtensionEntry e = findEntryByModuleOrAncestor(lookupClass);
-    if (e != null && e.hasPacker()) {
-      extensionsByAncestor.put(e.getExtensionModule(), e);
-      return e.toPackerProcTypeIdPair(lookupClass.getRuntime().getCurrentContext());
-    }
-    return null;
-  }
-
-  private IRubyObject[] fetchEntryByModule(final RubyModule mod) {
-    ExtensionEntry e = extensionsByModule.get(mod);
-    if (e == null) {
-      e = extensionsByAncestor.get(mod);
-    }
-    if (e != null && e.hasPacker()) {
-      return e.toPackerProcTypeIdPair(mod.getRuntime().getCurrentContext());
+    entry = findEntryByModuleOrAncestor(lookupClass);
+    if (entry != null && entry.hasPacker()) {
+      return entry;
     }
     return null;
   }
@@ -124,7 +106,7 @@ public class ExtensionRegistry {
   private ExtensionEntry findEntryByModuleOrAncestor(final RubyModule mod) {
     ThreadContext ctx = mod.getRuntime().getCurrentContext();
     for (RubyModule extensionModule : extensionsByModule.keySet()) {
-      RubyArray ancestors = (RubyArray) mod.callMethod(ctx, "ancestors");
+      RubyArray<?> ancestors = (RubyArray)mod.callMethod(ctx, "ancestors");
       if (ancestors.callMethod(ctx, "include?", extensionModule).isTrue()) {
         return extensionsByModule.get(extensionModule);
       }
@@ -132,17 +114,19 @@ public class ExtensionRegistry {
     return null;
   }
 
-  private static class ExtensionEntry {
+  public static class ExtensionEntry {
     private final RubyModule mod;
     private final int typeId;
+    private final boolean recursive;
     private final IRubyObject packerProc;
     private final IRubyObject packerArg;
     private final IRubyObject unpackerProc;
     private final IRubyObject unpackerArg;
 
-    public ExtensionEntry(RubyModule mod, int typeId, IRubyObject packerProc, IRubyObject packerArg, IRubyObject unpackerProc, IRubyObject unpackerArg) {
+    public ExtensionEntry(RubyModule mod, int typeId, boolean recursive, IRubyObject packerProc, IRubyObject packerArg, IRubyObject unpackerProc, IRubyObject unpackerArg) {
       this.mod = mod;
       this.typeId = typeId;
+      this.recursive = recursive;
       this.packerProc = packerProc;
       this.packerArg = packerArg;
       this.unpackerProc = unpackerProc;
@@ -157,6 +141,10 @@ public class ExtensionRegistry {
       return typeId;
     }
 
+    public boolean isRecursive() {
+      return recursive;
+    }
+
     public boolean hasPacker() {
       return packerProc != null;
     }
@@ -173,16 +161,16 @@ public class ExtensionRegistry {
       return unpackerProc;
     }
 
-    public RubyArray toPackerTuple(ThreadContext ctx) {
-      return RubyArray.newArray(ctx.getRuntime(), new IRubyObject[] {RubyFixnum.newFixnum(ctx.getRuntime(), typeId), packerProc, packerArg});
+    public RubyArray<?> toPackerTuple(ThreadContext ctx) {
+      return ctx.runtime.newArray(new IRubyObject[] {ctx.runtime.newFixnum(typeId), packerProc, packerArg});
     }
 
-    public RubyArray toUnpackerTuple(ThreadContext ctx) {
-      return RubyArray.newArray(ctx.getRuntime(), new IRubyObject[] {mod, unpackerProc, unpackerArg});
+    public RubyArray<?> toUnpackerTuple(ThreadContext ctx) {
+      return ctx.runtime.newArray(new IRubyObject[] {mod, unpackerProc, unpackerArg});
     }
 
     public IRubyObject[] toPackerProcTypeIdPair(ThreadContext ctx) {
-      return new IRubyObject[] {packerProc, RubyFixnum.newFixnum(ctx.getRuntime(), typeId)};
+      return new IRubyObject[] {packerProc, ctx.runtime.newFixnum(typeId)};
     }
   }
 }

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

@@ -25,6 +25,7 @@ import static org.msgpack.jruby.Types.*;
 
 @JRubyClass(name="MessagePack::ExtensionValue")
 public class ExtensionValue extends RubyObject {
+  private static final long serialVersionUID = 8451274621449322492L;
   private final Encoding binaryEncoding;
 
   private RubyFixnum type;
@@ -77,12 +78,10 @@ public class ExtensionValue extends RubyObject {
     }
     if (o instanceof ExtensionValue) {
       ExtensionValue other = (ExtensionValue) o;
-      if (!this.type.eql_p(other.type).isTrue())
+      if (!this.type.eql_p(other.type).isTrue()) {
         return runtime.getFalse();
-      if (runtime.is1_8()) {
-        return this.payload.str_eql_p(ctx, other.payload);
       } else {
-        return this.payload.str_eql_p19(ctx, other.payload);
+        return this.payload.str_eql_p(ctx, other.payload);
       }
     }
     return runtime.getFalse();
@@ -96,12 +95,10 @@ public class ExtensionValue extends RubyObject {
     }
     if (o instanceof ExtensionValue) {
       ExtensionValue other = (ExtensionValue) o;
-      if (!this.type.op_equal(ctx, other.type).isTrue())
+      if (!this.type.op_equal(ctx, other.type).isTrue()) {
         return runtime.getFalse();
-      if (runtime.is1_8()) {
-        return this.payload.op_equal(ctx, other.payload);
       } else {
-        return this.payload.op_equal19(ctx, other.payload);
+        return this.payload.op_equal(ctx, other.payload);
       }
     }
     return runtime.getFalse();

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

@@ -12,6 +12,8 @@ import org.jruby.RubyInteger;
 import org.jruby.RubyFixnum;
 import org.jruby.RubyString;
 import org.jruby.RubySymbol;
+import org.jruby.RubyProc;
+import org.jruby.RubyMethod;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.anno.JRubyClass;
 import org.jruby.anno.JRubyMethod;
@@ -23,15 +25,18 @@ import static org.jruby.runtime.Visibility.PRIVATE;
 
 @JRubyClass(name="MessagePack::Factory")
 public class Factory extends RubyObject {
+  private static final long serialVersionUID = 8441284623445322492L;
   private final Ruby runtime;
-  private final ExtensionRegistry extensionRegistry;
+  private ExtensionRegistry extensionRegistry;
   private boolean hasSymbolExtType;
+  private boolean hasBigIntExtType;
 
   public Factory(Ruby runtime, RubyClass type) {
     super(runtime, type);
     this.runtime = runtime;
     this.extensionRegistry = new ExtensionRegistry();
     this.hasSymbolExtType = false;
+    this.hasBigIntExtType = false;
   }
 
   static class FactoryAllocator implements ObjectAllocator {
@@ -49,9 +54,17 @@ public class Factory extends RubyObject {
     return this;
   }
 
-  @JRubyMethod(name = "packer", optional = 1)
+  @JRubyMethod(name = "dup")
+  public IRubyObject dup() {
+    Factory clone = (Factory)super.dup();
+    clone.extensionRegistry = extensionRegistry();
+    clone.hasSymbolExtType = hasSymbolExtType;
+    return clone;
+  }
+
+  @JRubyMethod(name = "packer", optional = 2)
   public Packer packer(ThreadContext ctx, IRubyObject[] args) {
-    return Packer.newPacker(ctx, extensionRegistry(), hasSymbolExtType, args);
+    return Packer.newPacker(ctx, extensionRegistry(), hasSymbolExtType, hasBigIntExtType, args);
   }
 
   @JRubyMethod(name = "unpacker", optional = 2)
@@ -61,7 +74,7 @@ public class Factory extends RubyObject {
 
   @JRubyMethod(name = "registered_types_internal", visibility = PRIVATE)
   public IRubyObject registeredTypesInternal(ThreadContext ctx) {
-    return RubyArray.newArray(ctx.getRuntime(), new IRubyObject[] {
+    return RubyArray.newArray(ctx.runtime, new IRubyObject[] {
       extensionRegistry.toInternalPackerRegistry(ctx),
       extensionRegistry.toInternalUnpackerRegistry(ctx)
     });
@@ -69,13 +82,15 @@ public class Factory extends RubyObject {
 
   @JRubyMethod(name = "register_type", required = 2, optional = 1)
   public IRubyObject registerType(ThreadContext ctx, IRubyObject[] args) {
-    Ruby runtime = ctx.getRuntime();
+    Ruby runtime = ctx.runtime;
     IRubyObject type = args[0];
     IRubyObject mod = args[1];
 
     IRubyObject packerArg;
     IRubyObject unpackerArg;
 
+    RubyHash options = null;
+
     if (isFrozen()) {
         throw runtime.newRuntimeError("can't modify frozen Factory");
     }
@@ -85,9 +100,13 @@ public class Factory extends RubyObject {
       unpackerArg = runtime.newSymbol("from_msgpack_ext");
     } else if (args.length == 3) {
       if (args[args.length - 1] instanceof RubyHash) {
-        RubyHash options = (RubyHash) args[args.length - 1];
+        options = (RubyHash) args[args.length - 1];
         packerArg = options.fastARef(runtime.newSymbol("packer"));
         unpackerArg = options.fastARef(runtime.newSymbol("unpacker"));
+        IRubyObject optimizedSymbolsParsingArg = options.fastARef(runtime.newSymbol("optimized_symbols_parsing"));
+        if (optimizedSymbolsParsingArg != null && optimizedSymbolsParsingArg.isTrue()) {
+          throw runtime.newArgumentError("JRuby implementation does not support the optimized_symbols_parsing option");
+        }
       } else {
         throw runtime.newArgumentError(String.format("expected Hash but found %s.", args[args.length - 1].getType().getName()));
       }
@@ -113,17 +132,38 @@ public class Factory extends RubyObject {
     if (unpackerArg != null) {
       if (unpackerArg instanceof RubyString || unpackerArg instanceof RubySymbol) {
         unpackerProc = extModule.method(unpackerArg.callMethod(ctx, "to_sym"));
+      } else if (unpackerArg instanceof RubyProc || unpackerArg instanceof RubyMethod) {
+        unpackerProc = unpackerArg;
       } else {
         unpackerProc = unpackerArg.callMethod(ctx, "method", runtime.newSymbol("call"));
       }
     }
 
-    extensionRegistry.put(extModule, (int) typeId, packerProc, packerArg, unpackerProc, unpackerArg);
+    boolean recursive = false;
+    if (options != null) {
+      IRubyObject recursiveExtensionArg = options.fastARef(runtime.newSymbol("recursive"));
+      if (recursiveExtensionArg != null && recursiveExtensionArg.isTrue()) {
+        recursive = true;
+      }
+    }
+
+    extensionRegistry.put(extModule, (int) typeId, recursive, packerProc, packerArg, unpackerProc, unpackerArg);
 
     if (extModule == runtime.getSymbol()) {
       hasSymbolExtType = true;
     }
 
+    if (options != null) {
+      IRubyObject oversizedIntegerExtensionArg = options.fastARef(runtime.newSymbol("oversized_integer_extension"));
+      if (oversizedIntegerExtensionArg != null && oversizedIntegerExtensionArg.isTrue()) {
+        if (extModule == runtime.getModule("Integer")) {
+          hasBigIntExtType = true;
+        } else {
+          throw runtime.newArgumentError("oversized_integer_extension: true is only for Integer class");
+        }
+      }
+    }
+
     return runtime.getNil();
   }
 }

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

@@ -27,53 +27,65 @@ import static org.jruby.runtime.Visibility.PRIVATE;
 
 @JRubyClass(name="MessagePack::Packer")
 public class Packer extends RubyObject {
+  private static final long serialVersionUID = 8451274621499362492L;
   public ExtensionRegistry registry;
   private Buffer buffer;
   private Encoder encoder;
   private boolean hasSymbolExtType;
+  private boolean hasBigintExtType;
   private Encoding binaryEncoding;
 
-  public Packer(Ruby runtime, RubyClass type, ExtensionRegistry registry, boolean hasSymbolExtType) {
+  public Packer(Ruby runtime, RubyClass type, ExtensionRegistry registry, boolean hasSymbolExtType, boolean hasBigintExtType) {
     super(runtime, type);
     this.registry = registry;
     this.hasSymbolExtType = hasSymbolExtType;
+    this.hasBigintExtType = hasBigintExtType;
   }
 
   static class PackerAllocator implements ObjectAllocator {
     public IRubyObject allocate(Ruby runtime, RubyClass type) {
-      return new Packer(runtime, type, null, false);
+      return new Packer(runtime, type, null, false, false);
     }
   }
 
   @JRubyMethod(name = "initialize", optional = 2)
   public IRubyObject initialize(ThreadContext ctx, IRubyObject[] args) {
     boolean compatibilityMode = false;
-    if (args.length > 0 && args[args.length - 1] instanceof RubyHash) {
-      RubyHash options = (RubyHash) args[args.length - 1];
-      IRubyObject mode = options.fastARef(ctx.getRuntime().newSymbol("compatibility_mode"));
-      compatibilityMode = (mode != null) && mode.isTrue();
+    Ruby runtime = ctx.runtime;
+    if (args.length > 0) {
+      RubyHash options = null;
+      if (args[args.length - 1] instanceof RubyHash) {
+        options = (RubyHash) args[args.length - 1];
+      } else if (args.length > 1 && args[args.length - 2] instanceof RubyHash) {
+        options = (RubyHash) args[args.length - 2];
+      }
+
+      if (options != null) {
+        IRubyObject mode = options.fastARef(runtime.newSymbol("compatibility_mode"));
+        compatibilityMode = (mode != null) && mode.isTrue();
+      }
     }
     if (registry == null) {
         // registry is null when allocate -> initialize
         // registry is already initialized (and somthing might be registered) when newPacker from Factory
         this.registry = new ExtensionRegistry();
     }
-    this.encoder = new Encoder(ctx.getRuntime(), compatibilityMode, registry, hasSymbolExtType);
-    this.buffer = new Buffer(ctx.getRuntime(), ctx.getRuntime().getModule("MessagePack").getClass("Buffer"));
+    this.encoder = new Encoder(runtime, this, compatibilityMode, registry, hasSymbolExtType, hasBigintExtType);
+    this.buffer = new Buffer(runtime, runtime.getModule("MessagePack").getClass("Buffer"));
     this.buffer.initialize(ctx, args);
-    this.binaryEncoding = ctx.getRuntime().getEncodingService().getAscii8bitEncoding();
+    this.binaryEncoding = runtime.getEncodingService().getAscii8bitEncoding();
     return this;
   }
 
-  public static Packer newPacker(ThreadContext ctx, ExtensionRegistry extRegistry, boolean hasSymbolExtType, IRubyObject[] args) {
-    Packer packer = new Packer(ctx.getRuntime(), ctx.getRuntime().getModule("MessagePack").getClass("Packer"), extRegistry, hasSymbolExtType);
+  public static Packer newPacker(ThreadContext ctx, ExtensionRegistry extRegistry, boolean hasSymbolExtType, boolean hasBigintExtType, IRubyObject[] args) {
+    Packer packer = new Packer(ctx.runtime, ctx.runtime.getModule("MessagePack").getClass("Packer"), extRegistry, hasSymbolExtType, hasBigintExtType);
     packer.initialize(ctx, args);
     return packer;
   }
 
   @JRubyMethod(name = "compatibility_mode?")
   public IRubyObject isCompatibilityMode(ThreadContext ctx) {
-    return encoder.isCompatibilityMode() ? ctx.getRuntime().getTrue() : ctx.getRuntime().getFalse();
+    return encoder.isCompatibilityMode() ? ctx.runtime.getTrue() : ctx.runtime.getFalse();
   }
 
   @JRubyMethod(name = "registered_types_internal", visibility = PRIVATE)
@@ -83,7 +95,7 @@ public class Packer extends RubyObject {
 
   @JRubyMethod(name = "register_type", required = 2, optional = 1)
   public IRubyObject registerType(ThreadContext ctx, IRubyObject[] args, final Block block) {
-    Ruby runtime = ctx.getRuntime();
+    Ruby runtime = ctx.runtime;
     IRubyObject type = args[0];
     IRubyObject mod = args[1];
 
@@ -112,7 +124,7 @@ public class Packer extends RubyObject {
     }
     RubyModule extModule = (RubyModule) mod;
 
-    registry.put(extModule, (int) typeId, proc, arg, null, null);
+    registry.put(extModule, (int) typeId, false, proc, arg, null, null);
 
     if (extModule == runtime.getSymbol()) {
       encoder.hasSymbolExtType = true;
@@ -182,12 +194,12 @@ public class Packer extends RubyObject {
 
   @JRubyMethod(name = "write_true")
   public IRubyObject writeTrue(ThreadContext ctx) {
-    return write(ctx, ctx.getRuntime().getTrue());
+    return write(ctx, ctx.runtime.getTrue());
   }
 
   @JRubyMethod(name = "write_false")
   public IRubyObject writeFalse(ThreadContext ctx) {
-    return write(ctx, ctx.getRuntime().getFalse());
+    return write(ctx, ctx.runtime.getFalse());
   }
 
   @JRubyMethod(name = "write_nil")
@@ -255,7 +267,7 @@ public class Packer extends RubyObject {
     return buffer.size(ctx);
   }
 
-  @JRubyMethod(name = "clear")
+  @JRubyMethod(name = "clear", alias = { "reset" })
   public IRubyObject clear(ThreadContext ctx) {
     return buffer.clear(ctx);
   }