msgpack 0.7.0dev1-x64-mingw32 → 0.7.0-x64-mingw32

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

@@ -0,0 +1,117 @@
+package org.msgpack.jruby;
+
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.RubyArray;
+import org.jruby.RubyHash;
+import org.jruby.RubyIO;
+import org.jruby.RubyInteger;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyString;
+import org.jruby.RubySymbol;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.util.ByteList;
+
+import static org.jruby.runtime.Visibility.PRIVATE;
+
+@JRubyClass(name="MessagePack::Factory")
+public class Factory extends RubyObject {
+  private final Ruby runtime;
+  private final ExtensionRegistry extensionRegistry;
+
+  public Factory(Ruby runtime, RubyClass type) {
+    super(runtime, type);
+    this.runtime = runtime;
+    this.extensionRegistry = new ExtensionRegistry();
+  }
+
+  static class FactoryAllocator implements ObjectAllocator {
+    public IRubyObject allocate(Ruby runtime, RubyClass type) {
+      return new Factory(runtime, type);
+    }
+  }
+
+  public ExtensionRegistry extensionRegistry() {
+    return extensionRegistry.dup();
+  }
+
+  @JRubyMethod(name = "initialize")
+  public IRubyObject initialize(ThreadContext ctx) {
+    return this;
+  }
+
+  @JRubyMethod(name = "packer", optional = 1)
+  public Packer packer(ThreadContext ctx, IRubyObject[] args) {
+    return Packer.newPacker(ctx, extensionRegistry(), args);
+  }
+
+  @JRubyMethod(name = "unpacker", optional = 1)
+  public Unpacker unpacker(ThreadContext ctx, IRubyObject[] args) {
+    return Unpacker.newUnpacker(ctx, extensionRegistry(), args);
+  }
+
+  @JRubyMethod(name = "registered_types_internal", visibility = PRIVATE)
+  public IRubyObject registeredTypesInternal(ThreadContext ctx) {
+    return RubyArray.newArray(ctx.getRuntime(), new IRubyObject[] {
+      extensionRegistry.toInternalPackerRegistry(ctx),
+      extensionRegistry.toInternalUnpackerRegistry(ctx)
+    });
+  }
+
+  @JRubyMethod(name = "register_type", required = 2, optional = 1)
+  public IRubyObject registerType(ThreadContext ctx, IRubyObject[] args) {
+    Ruby runtime = ctx.getRuntime();
+    IRubyObject type = args[0];
+    IRubyObject klass = args[1];
+
+    IRubyObject packerArg;
+    IRubyObject unpackerArg;
+    if (args.length == 2) {
+      packerArg = runtime.newSymbol("to_msgpack_ext");
+      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];
+        packerArg = options.fastARef(runtime.newSymbol("packer"));
+        unpackerArg = options.fastARef(runtime.newSymbol("unpacker"));
+      } else {
+        throw runtime.newArgumentError(String.format("expected Hash but found %s.", args[args.length - 1].getType().getName()));
+      }
+    } else {
+      throw runtime.newArgumentError(String.format("wrong number of arguments (%d for 2..3)", 2 + args.length));
+    }
+
+    long typeId = ((RubyFixnum) type).getLongValue();
+    if (typeId < -128 || typeId > 127) {
+      throw runtime.newRangeError(String.format("integer %d too big to convert to `signed char'", typeId));
+    }
+
+    if (!(klass instanceof RubyClass)) {
+      throw runtime.newArgumentError(String.format("expected Class but found %s.", klass.getType().getName()));
+    }
+    RubyClass extClass = (RubyClass) klass;
+
+    IRubyObject packerProc = runtime.getNil();
+    IRubyObject unpackerProc = runtime.getNil();
+    if (packerArg != null) {
+      packerProc = packerArg.callMethod(ctx, "to_proc");
+    }
+    if (unpackerArg != null) {
+      if (unpackerArg instanceof RubyString || unpackerArg instanceof RubySymbol) {
+        unpackerProc = extClass.method(unpackerArg.callMethod(ctx, "to_sym"));
+      } else {
+        unpackerProc = unpackerArg.callMethod(ctx, "method", runtime.newSymbol("call"));
+      }
+    }
+
+    extensionRegistry.put(extClass, (int) typeId, packerProc, packerArg, unpackerProc, unpackerArg);
+
+    return runtime.getNil();
+  }
+}

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

@@ -20,15 +20,20 @@ import org.jruby.internal.runtime.methods.DynamicMethod;
 
 
 public class MessagePackLibrary implements Library {
+  public static Factory defaultFactory;
+
   public void load(Ruby runtime, boolean wrap) {
     RubyModule msgpackModule = runtime.defineModule("MessagePack");
     msgpackModule.defineAnnotatedMethods(MessagePackModule.class);
     RubyClass standardErrorClass = runtime.getStandardError();
     RubyClass unpackErrorClass = msgpackModule.defineClassUnder("UnpackError", standardErrorClass, standardErrorClass.getAllocator());
     RubyClass underflowErrorClass = msgpackModule.defineClassUnder("UnderflowError", unpackErrorClass, unpackErrorClass.getAllocator());
+    RubyClass malformedFormatErrorClass = msgpackModule.defineClassUnder("MalformedFormatError", unpackErrorClass, unpackErrorClass.getAllocator());
+    RubyClass stackErrorClass = msgpackModule.defineClassUnder("StackError", unpackErrorClass, unpackErrorClass.getAllocator());
     RubyModule typeErrorModule = msgpackModule.defineModuleUnder("TypeError");
-    RubyClass unexpectedTypeErrorClass = msgpackModule.defineClassUnder("UnexpetedTypeError", unpackErrorClass, standardErrorClass.getAllocator());
+    RubyClass unexpectedTypeErrorClass = msgpackModule.defineClassUnder("UnexpectedTypeError", unpackErrorClass, unpackErrorClass.getAllocator());
     unexpectedTypeErrorClass.includeModule(typeErrorModule);
+    RubyClass unknownExtTypeErrorClass = msgpackModule.defineClassUnder("UnknownExtTypeError", unpackErrorClass, unpackErrorClass.getAllocator());
     RubyClass extensionValueClass = msgpackModule.defineClassUnder("ExtensionValue", runtime.getObject(), new ExtensionValue.ExtensionValueAllocator());
     extensionValueClass.defineAnnotatedMethods(ExtensionValue.class);
     RubyClass packerClass = msgpackModule.defineClassUnder("Packer", runtime.getObject(), new Packer.PackerAllocator());
@@ -37,6 +42,11 @@ public class MessagePackLibrary implements Library {
     unpackerClass.defineAnnotatedMethods(Unpacker.class);
     RubyClass bufferClass = msgpackModule.defineClassUnder("Buffer", runtime.getObject(), new Buffer.BufferAllocator());
     bufferClass.defineAnnotatedMethods(Buffer.class);
+    RubyClass factoryClass = msgpackModule.defineClassUnder("Factory", runtime.getObject(), new Factory.FactoryAllocator());
+    factoryClass.defineAnnotatedMethods(Factory.class);
+    defaultFactory = new Factory(runtime, factoryClass);
+    defaultFactory.initialize(runtime.getCurrentContext());
+    msgpackModule.defineConstant("DefaultFactory", defaultFactory);
     installCoreExtensions(runtime);
   }
 
@@ -100,20 +110,27 @@ public class MessagePackLibrary implements Library {
         extraArgs = new IRubyObject[args.length - 1];
         System.arraycopy(args, 1, extraArgs, 0, args.length - 1);
       }
-      Packer packer = new Packer(ctx.getRuntime(), ctx.getRuntime().getModule("MessagePack").getClass("Packer"));
-      packer.initialize(ctx, extraArgs);
+      Packer packer = MessagePackLibrary.defaultFactory.packer(ctx, extraArgs);
       packer.write(ctx, args[0]);
       return packer.toS(ctx);
     }
 
     @JRubyMethod(module = true, required = 1, optional = 1, alias = {"load"})
     public static IRubyObject unpack(ThreadContext ctx, IRubyObject recv, IRubyObject[] args) {
-      Decoder decoder = new Decoder(ctx.getRuntime(), args[0].asString().getBytes());
+      ExtensionRegistry registry = MessagePackLibrary.defaultFactory.extensionRegistry();
+
+      boolean symbolizeKeys = false;
+      boolean allowUnknownExt = false;
       if (args.length > 1 && !args[args.length - 1].isNil()) {
         RubyHash hash = args[args.length - 1].convertToHash();
-        IRubyObject symbolizeKeys = hash.fastARef(ctx.getRuntime().newSymbol("symbolize_keys"));
-        decoder.symbolizeKeys(symbolizeKeys != null && symbolizeKeys.isTrue());
+        IRubyObject symbolizeKeysVal = hash.fastARef(ctx.getRuntime().newSymbol("symbolize_keys"));
+        symbolizeKeys = symbolizeKeysVal != null && symbolizeKeysVal.isTrue();
+        IRubyObject allowUnknownExtVal = hash.fastARef(ctx.getRuntime().newSymbol("allow_unknown_ext"));
+        allowUnknownExt = (allowUnknownExtVal != null && allowUnknownExtVal.isTrue());
       }
+      byte[] bytes = args[0].asString().getBytes();
+      Decoder decoder = new Decoder(ctx.getRuntime(), registry, bytes, 0, bytes.length, symbolizeKeys, allowUnknownExt);
+
       return decoder.next();
     }
   }

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

@@ -4,9 +4,12 @@ package org.msgpack.jruby;
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
 import org.jruby.RubyObject;
+import org.jruby.RubyArray;
 import org.jruby.RubyHash;
 import org.jruby.RubyIO;
 import org.jruby.RubyInteger;
+import org.jruby.RubyFixnum;
+import org.jruby.runtime.Block;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.anno.JRubyClass;
 import org.jruby.anno.JRubyMethod;
@@ -14,19 +17,22 @@ import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.util.ByteList;
 
+import static org.jruby.runtime.Visibility.PRIVATE;
 
 @JRubyClass(name="MessagePack::Packer")
 public class Packer extends RubyObject {
+  public ExtensionRegistry registry;
   private Buffer buffer;
   private Encoder encoder;
 
-  public Packer(Ruby runtime, RubyClass type) {
+  public Packer(Ruby runtime, RubyClass type, ExtensionRegistry registry) {
     super(runtime, type);
+    this.registry = registry;
   }
 
   static class PackerAllocator implements ObjectAllocator {
     public IRubyObject allocate(Ruby runtime, RubyClass type) {
-      return new Packer(runtime, type);
+      return new Packer(runtime, type, null);
     }
   }
 
@@ -35,15 +41,68 @@ public class Packer extends RubyObject {
     boolean compatibilityMode = false;
     if (args.length > 0 && args[args.length - 1] instanceof RubyHash) {
       RubyHash options = (RubyHash) args[args.length - 1];
-      compatibilityMode = options.fastARef(ctx.getRuntime().newSymbol("compatibility_mode")).isTrue();
+      IRubyObject mode = options.fastARef(ctx.getRuntime().newSymbol("compatibility_mode"));
+      compatibilityMode = (mode != null) && mode.isTrue();
     }
-    this.encoder = new Encoder(ctx.getRuntime(), compatibilityMode);
+    this.encoder = new Encoder(ctx.getRuntime(), compatibilityMode, registry);
     this.buffer = new Buffer(ctx.getRuntime(), ctx.getRuntime().getModule("MessagePack").getClass("Buffer"));
     this.buffer.initialize(ctx, args);
+    this.registry = new ExtensionRegistry();
     return this;
   }
 
-  @JRubyMethod(name = "write")
+  public static Packer newPacker(ThreadContext ctx, ExtensionRegistry extRegistry, IRubyObject[] args) {
+    Packer packer = new Packer(ctx.getRuntime(), ctx.getRuntime().getModule("MessagePack").getClass("Packer"), extRegistry);
+    packer.initialize(ctx, args);
+    return packer;
+  }
+
+  @JRubyMethod(name = "compatibility_mode?")
+  public IRubyObject isCompatibilityMode(ThreadContext ctx) {
+    return encoder.isCompatibilityMode() ? ctx.getRuntime().getTrue() : ctx.getRuntime().getFalse();
+  }
+
+  @JRubyMethod(name = "registered_types_internal", visibility = PRIVATE)
+  public IRubyObject registeredTypesInternal(ThreadContext ctx) {
+    return registry.toInternalPackerRegistry(ctx);
+  }
+
+  @JRubyMethod(name = "register_type", required = 2, optional = 1)
+  public IRubyObject registerType(ThreadContext ctx, IRubyObject[] args, final Block block) {
+    Ruby runtime = ctx.getRuntime();
+    IRubyObject type = args[0];
+    IRubyObject klass = args[1];
+
+    IRubyObject arg;
+    IRubyObject proc;
+    if (args.length == 2) {
+      if (! block.isGiven()) {
+        throw runtime.newLocalJumpErrorNoBlock();
+      }
+      proc = block.getProcObject();
+      arg = proc;
+    } else if (args.length == 3) {
+      arg = args[2];
+      proc = arg.callMethod(ctx, "to_proc");
+    } else {
+      throw runtime.newArgumentError(String.format("wrong number of arguments (%d for 2..3)", 2 + args.length));
+    }
+
+    long typeId = ((RubyFixnum) type).getLongValue();
+    if (typeId < -128 || typeId > 127) {
+      throw runtime.newRangeError(String.format("integer %d too big to convert to `signed char'", typeId));
+    }
+
+    if (!(klass instanceof RubyClass)) {
+      throw runtime.newArgumentError(String.format("expected Class but found %s.", klass.getType().getName()));
+    }
+    RubyClass extClass = (RubyClass) klass;
+
+    registry.put(extClass, (int) typeId, proc, arg, null, null);
+    return runtime.getNil();
+  }
+
+  @JRubyMethod(name = "write", alias = { "pack" })
   public IRubyObject write(ThreadContext ctx, IRubyObject obj) {
     buffer.write(ctx, encoder.encode(obj, this));
     return this;
@@ -69,7 +128,7 @@ public class Packer extends RubyObject {
     return this;
   }
 
-  @JRubyMethod(name = "to_s")
+  @JRubyMethod(name = "to_s", alias = { "to_str" })
   public IRubyObject toS(ThreadContext ctx) {
     return buffer.toS(ctx);
   }

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

@@ -1,12 +1,16 @@
 package org.msgpack.jruby;
 
+import java.util.Arrays;
 
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
 import org.jruby.RubyString;
 import org.jruby.RubyObject;
+import org.jruby.RubyArray;
 import org.jruby.RubyHash;
 import org.jruby.RubyNumeric;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyProc;
 import org.jruby.RubyIO;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.runtime.builtin.IRubyObject;
@@ -20,17 +24,24 @@ import org.jruby.ext.stringio.StringIO;
 
 import static org.jruby.runtime.Visibility.PRIVATE;
 
-
 @JRubyClass(name="MessagePack::Unpacker")
 public class Unpacker extends RubyObject {
+  private final ExtensionRegistry registry;
+
   private IRubyObject stream;
   private IRubyObject data;
   private Decoder decoder;
   private final RubyClass underflowErrorClass;
   private boolean symbolizeKeys;
+  private boolean allowUnknownExt;
 
   public Unpacker(Ruby runtime, RubyClass type) {
+    this(runtime, type, new ExtensionRegistry());
+  }
+
+  public Unpacker(Ruby runtime, RubyClass type, ExtensionRegistry registry) {
     super(runtime, type);
+    this.registry = registry;
     this.underflowErrorClass = runtime.getModule("MessagePack").getClass("UnderflowError");
   }
 
@@ -43,6 +54,7 @@ public class Unpacker extends RubyObject {
   @JRubyMethod(name = "initialize", optional = 1, visibility = PRIVATE)
   public IRubyObject initialize(ThreadContext ctx, IRubyObject[] args) {
     symbolizeKeys = false;
+    allowUnknownExt = false;
     if (args.length > 0) {
       if (args[args.length - 1] instanceof RubyHash) {
         RubyHash options = (RubyHash) args[args.length - 1];
@@ -50,6 +62,10 @@ public class Unpacker extends RubyObject {
         if (sk != null) {
           symbolizeKeys = sk.isTrue();
         }
+        IRubyObject au = options.fastARef(ctx.getRuntime().newSymbol("allow_unknown_ext"));
+        if (au != null) {
+          allowUnknownExt = au.isTrue();
+        }
       } else if (!(args[0] instanceof RubyHash)) {
         setStream(ctx, args[0]);
       }
@@ -57,6 +73,61 @@ public class Unpacker extends RubyObject {
     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.initialize(ctx, args);
+    return unpacker;
+  }
+
+  @JRubyMethod(name = "symbolize_keys?")
+  public IRubyObject isSymbolizeKeys(ThreadContext ctx) {
+    return symbolizeKeys ? ctx.getRuntime().getTrue() : ctx.getRuntime().getFalse();
+  }
+
+  @JRubyMethod(name = "allow_unknown_ext?")
+  public IRubyObject isAllowUnknownExt(ThreadContext ctx) {
+    return allowUnknownExt ? ctx.getRuntime().getTrue() : ctx.getRuntime().getFalse();
+  }
+
+  @JRubyMethod(name = "registered_types_internal", visibility = PRIVATE)
+  public IRubyObject registeredTypesInternal(ThreadContext ctx) {
+    return registry.toInternalUnpackerRegistry(ctx);
+  }
+
+  @JRubyMethod(name = "register_type", required = 1, optional = 2)
+  public IRubyObject registerType(ThreadContext ctx, IRubyObject[] args, final Block block) {
+    Ruby runtime = ctx.getRuntime();
+    IRubyObject type = args[0];
+
+    RubyClass extClass;
+    IRubyObject arg;
+    IRubyObject proc;
+    if (args.length == 1) {
+      if (! block.isGiven()) {
+        throw runtime.newLocalJumpErrorNoBlock();
+      }
+      proc = RubyProc.newProc(runtime, block, block.type);
+      if (proc == null)
+        System.err.println("proc from Block is null");
+      arg = proc;
+      extClass = null;
+    } else if (args.length == 3) {
+      extClass = (RubyClass) args[1];
+      arg = args[2];
+      proc = extClass.method(arg);
+    } else {
+      throw runtime.newArgumentError(String.format("wrong number of arguments (%d for 1 or 3)", 2 + args.length));
+    }
+
+    long typeId = ((RubyFixnum) type).getLongValue();
+    if (typeId < -128 || typeId > 127) {
+      throw runtime.newRangeError(String.format("integer %d too big to convert to `signed char'", typeId));
+    }
+
+    registry.put(extClass, (int) typeId, null, null, proc, arg);
+    return runtime.getNil();
+  }
+
   @JRubyMethod(required = 2)
   public IRubyObject execute(ThreadContext ctx, IRubyObject data, IRubyObject offset) {
     return executeLimit(ctx, data, offset, null);
@@ -71,11 +142,10 @@ public class Unpacker extends RubyObject {
     if (limit == -1) {
       limit = byteList.length() - offset;
     }
-    Decoder decoder = new Decoder(ctx.getRuntime(), byteList.unsafeBytes(), byteList.begin() + offset, limit);
-    decoder.symbolizeKeys(symbolizeKeys);
+    Decoder decoder = new Decoder(ctx.getRuntime(), registry, byteList.unsafeBytes(), byteList.begin() + offset, limit, symbolizeKeys, allowUnknownExt);
     try {
-      this.data = null;
-      this.data = decoder.next();
+      data = null;
+      data = decoder.next();
     } catch (RaiseException re) {
       if (re.getException().getType() != underflowErrorClass) {
         throw re;
@@ -102,8 +172,7 @@ public class Unpacker extends RubyObject {
   public IRubyObject feed(ThreadContext ctx, IRubyObject data) {
     ByteList byteList = data.asString().getByteList();
     if (decoder == null) {
-      decoder = new Decoder(ctx.getRuntime(), byteList.unsafeBytes(), byteList.begin(), byteList.length());
-      decoder.symbolizeKeys(symbolizeKeys);
+      decoder = new Decoder(ctx.getRuntime(), registry, byteList.unsafeBytes(), byteList.begin(), byteList.length(), symbolizeKeys, allowUnknownExt);
     } else {
       decoder.feed(byteList.unsafeBytes(), byteList.begin(), byteList.length());
     }
@@ -113,8 +182,12 @@ public class Unpacker extends RubyObject {
   @JRubyMethod(name = "feed_each", required = 1)
   public IRubyObject feedEach(ThreadContext ctx, IRubyObject data, Block block) {
     feed(ctx, data);
-    each(ctx, block);
-    return ctx.getRuntime().getNil();
+    if (block.isGiven()) {
+      each(ctx, block);
+      return ctx.getRuntime().getNil();
+    } else {
+      return callMethod(ctx, "to_enum");
+    }
   }
 
   @JRubyMethod
@@ -150,20 +223,30 @@ public class Unpacker extends RubyObject {
     return ctx.getRuntime().getNil();
   }
 
-  @JRubyMethod
+  @JRubyMethod(name = "read", alias = { "unpack" })
   public IRubyObject read(ThreadContext ctx) {
-    if (decoder != null) {
-      try {
-        return decoder.next();
-      } catch (RaiseException re) {
-        if (re.getException().getType() != underflowErrorClass) {
-          throw re;
-        } else {
-          throw ctx.getRuntime().newEOFError();
-        }
+    if (decoder == null) {
+      throw ctx.getRuntime().newEOFError();
+    }
+    try {
+      return decoder.next();
+    } catch (RaiseException re) {
+      if (re.getException().getType() != underflowErrorClass) {
+        throw re;
+      } else {
+        throw ctx.getRuntime().newEOFError();
       }
     }
-    return ctx.getRuntime().getNil();
+  }
+
+  @JRubyMethod(name = "skip")
+  public IRubyObject skip(ThreadContext ctx) {
+    throw ctx.getRuntime().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");
   }
 
   @JRubyMethod
@@ -220,8 +303,7 @@ public class Unpacker extends RubyObject {
     ByteList byteList = str.getByteList();
     this.stream = stream;
     this.decoder = null;
-    this.decoder = new Decoder(ctx.getRuntime(), byteList.unsafeBytes(), byteList.begin(), byteList.length());
-    decoder.symbolizeKeys(symbolizeKeys);
+    this.decoder = new Decoder(ctx.getRuntime(), registry, byteList.unsafeBytes(), byteList.begin(), byteList.length(), symbolizeKeys, allowUnknownExt);
     return getStream(ctx);
   }
 }