msgpack 1.3.3 → 1.6.0

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);
   }

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;
@@ -34,6 +35,7 @@ public class Unpacker extends RubyObject {
   private Decoder decoder;
   private final RubyClass underflowErrorClass;
   private boolean symbolizeKeys;
+  private boolean freeze;
   private boolean allowUnknownExt;
 
   public Unpacker(Ruby runtime, RubyClass type) {
@@ -54,41 +56,70 @@ public class Unpacker extends RubyObject {
 
   @JRubyMethod(name = "initialize", optional = 2, visibility = PRIVATE)
   public IRubyObject initialize(ThreadContext ctx, IRubyObject[] args) {
+    Ruby runtime = ctx.runtime;
+
     symbolizeKeys = false;
     allowUnknownExt = false;
-    if (args.length > 0) {
-      if (args[args.length - 1] instanceof RubyHash) {
-        RubyHash options = (RubyHash) args[args.length - 1];
-        IRubyObject sk = options.fastARef(ctx.getRuntime().newSymbol("symbolize_keys"));
-        if (sk != null) {
-          symbolizeKeys = sk.isTrue();
-        }
-        IRubyObject au = options.fastARef(ctx.getRuntime().newSymbol("allow_unknown_ext"));
-        if (au != null) {
-          allowUnknownExt = au.isTrue();
-        }
+    freeze = false;
+
+    IRubyObject io = null;
+    RubyHash options = null;
+
+    if (args.length >= 1) {
+      io = args[0];
+    }
+
+    if (args.length >= 2 && args[1] != runtime.getNil()) {
+      options = (RubyHash)args[1];
+    }
+
+    if (options == null && io != null && io instanceof RubyHash) {
+      options = (RubyHash)io;
+      io = null;
+    }
+
+    if (options != null) {
+      IRubyObject sk = options.fastARef(runtime.newSymbol("symbolize_keys"));
+      if (sk != null) {
+        symbolizeKeys = sk.isTrue();
+      }
+      IRubyObject f = options.fastARef(runtime.newSymbol("freeze"));
+      if (f != null) {
+        freeze = f.isTrue();
       }
-      if (args[0] != ctx.getRuntime().getNil() && !(args[0] instanceof RubyHash)) {
-        setStream(ctx, args[0]);
+      IRubyObject au = options.fastARef(runtime.newSymbol("allow_unknown_ext"));
+      if (au != null) {
+        allowUnknownExt = au.isTrue();
       }
+
+    }
+
+    if (io != null && io != runtime.getNil()) {
+      setStream(ctx, io);
     }
+
     return this;
   }
 
   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.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)
@@ -98,7 +129,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;
@@ -126,7 +157,7 @@ public class Unpacker extends RubyObject {
       throw runtime.newRangeError(String.format("integer %d too big to convert to `signed char'", typeId));
     }
 
-    registry.put(extModule, (int) typeId, null, null, proc, arg);
+    registry.put(extModule, (int) typeId, false, null, null, proc, arg);
     return runtime.getNil();
   }
 
@@ -144,7 +175,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, allowUnknownExt);
+    Decoder decoder = new Decoder(ctx.runtime, this, byteList.unsafeBytes(), byteList.begin() + offset, limit, symbolizeKeys, freeze, allowUnknownExt);
     try {
       data = null;
       data = decoder.next();
@@ -153,13 +184,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;
     }
@@ -167,14 +198,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, allowUnknownExt);
+      decoder = new Decoder(ctx.runtime, this, byteList.unsafeBytes(), byteList.begin(), byteList.length(), symbolizeKeys, freeze, allowUnknownExt);
     } else {
       decoder.feed(byteList.unsafeBytes(), byteList.begin(), byteList.length());
     }
@@ -191,7 +222,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");
     }
@@ -219,7 +250,7 @@ public class Unpacker extends RubyObject {
 
   @JRubyMethod
   public IRubyObject fill(ThreadContext ctx) {
-    return ctx.getRuntime().getNil();
+    return ctx.runtime.getNil();
   }
 
   @JRubyMethod
@@ -227,13 +258,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();
@@ -241,19 +272,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
@@ -265,11 +296,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
@@ -281,17 +312,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;
     }
@@ -307,12 +338,16 @@ 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, allowUnknownExt);
+    this.decoder = new Decoder(ctx.runtime, this, byteList.unsafeBytes(), byteList.begin(), byteList.length(), symbolizeKeys, freeze, allowUnknownExt);
     return getStream(ctx);
   }
+
+  public ExtensionRegistry.ExtensionEntry lookupExtensionByTypeId(int typeId) {
+    return registry.lookupExtensionByTypeId(typeId);
+  }
 }