msgpack 0.7.4 → 1.3.3

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

@@ -2,6 +2,7 @@ package org.msgpack.jruby;
 
 
 import org.jruby.Ruby;
+import org.jruby.RubyModule;
 import org.jruby.RubyClass;
 import org.jruby.RubyObject;
 import org.jruby.RubyArray;
@@ -24,11 +25,13 @@ import static org.jruby.runtime.Visibility.PRIVATE;
 public class Factory extends RubyObject {
   private final Ruby runtime;
   private final ExtensionRegistry extensionRegistry;
+  private boolean hasSymbolExtType;
 
   public Factory(Ruby runtime, RubyClass type) {
     super(runtime, type);
     this.runtime = runtime;
     this.extensionRegistry = new ExtensionRegistry();
+    this.hasSymbolExtType = false;
   }
 
   static class FactoryAllocator implements ObjectAllocator {
@@ -48,10 +51,10 @@ public class Factory extends RubyObject {
 
   @JRubyMethod(name = "packer", optional = 1)
   public Packer packer(ThreadContext ctx, IRubyObject[] args) {
-    return Packer.newPacker(ctx, extensionRegistry(), args);
+    return Packer.newPacker(ctx, extensionRegistry(), hasSymbolExtType, args);
   }
 
-  @JRubyMethod(name = "unpacker", optional = 1)
+  @JRubyMethod(name = "unpacker", optional = 2)
   public Unpacker unpacker(ThreadContext ctx, IRubyObject[] args) {
     return Unpacker.newUnpacker(ctx, extensionRegistry(), args);
   }
@@ -68,10 +71,15 @@ public class Factory extends RubyObject {
   public IRubyObject registerType(ThreadContext ctx, IRubyObject[] args) {
     Ruby runtime = ctx.getRuntime();
     IRubyObject type = args[0];
-    IRubyObject klass = args[1];
+    IRubyObject mod = args[1];
 
     IRubyObject packerArg;
     IRubyObject unpackerArg;
+
+    if (isFrozen()) {
+        throw runtime.newRuntimeError("can't modify frozen Factory");
+    }
+
     if (args.length == 2) {
       packerArg = runtime.newSymbol("to_msgpack_ext");
       unpackerArg = runtime.newSymbol("from_msgpack_ext");
@@ -92,10 +100,10 @@ public class Factory extends RubyObject {
       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()));
+    if (!(mod instanceof RubyModule)) {
+      throw runtime.newArgumentError(String.format("expected Module/Class but found %s.", mod.getType().getName()));
     }
-    RubyClass extClass = (RubyClass) klass;
+    RubyModule extModule = (RubyModule) mod;
 
     IRubyObject packerProc = runtime.getNil();
     IRubyObject unpackerProc = runtime.getNil();
@@ -104,13 +112,17 @@ public class Factory extends RubyObject {
     }
     if (unpackerArg != null) {
       if (unpackerArg instanceof RubyString || unpackerArg instanceof RubySymbol) {
-        unpackerProc = extClass.method(unpackerArg.callMethod(ctx, "to_sym"));
+        unpackerProc = extModule.method(unpackerArg.callMethod(ctx, "to_sym"));
       } else {
         unpackerProc = unpackerArg.callMethod(ctx, "method", runtime.newSymbol("call"));
       }
     }
 
-    extensionRegistry.put(extClass, (int) typeId, packerProc, packerArg, unpackerProc, unpackerArg);
+    extensionRegistry.put(extModule, (int) typeId, packerProc, packerArg, unpackerProc, unpackerArg);
+
+    if (extModule == runtime.getSymbol()) {
+      hasSymbolExtType = true;
+    }
 
     return runtime.getNil();
   }

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

@@ -20,11 +20,8 @@ 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());
@@ -44,94 +41,5 @@ public class MessagePackLibrary implements Library {
     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);
-  }
-
-  private void installCoreExtensions(Ruby runtime) {
-    RubyClass extensionValueClass = runtime.getModule("MessagePack").getClass("ExtensionValue");
-    installCoreExtensions(
-      runtime,
-      runtime.getNilClass(),
-      runtime.getTrueClass(),
-      runtime.getFalseClass(),
-      runtime.getFixnum(),
-      runtime.getBignum(),
-      runtime.getFloat(),
-      runtime.getString(),
-      runtime.getArray(),
-      runtime.getHash(),
-      runtime.getSymbol(),
-      extensionValueClass
-    );
-  }
-
-  private void installCoreExtensions(Ruby runtime, RubyClass... classes) {
-    for (RubyClass cls : classes) {
-      cls.addMethod("to_msgpack", createToMsgpackMethod(runtime, cls));
-    }
-  }
-
-  private DynamicMethod createToMsgpackMethod(final Ruby runtime, RubyClass cls) {
-    return new DynamicMethod(cls, Visibility.PUBLIC, CallConfiguration.FrameNoneScopeNone) {
-      @Override
-      public IRubyObject call(ThreadContext context, IRubyObject recv, RubyModule clazz, String name, IRubyObject[] args, Block block) {
-        if (args.length == 0) {
-          IRubyObject[] allArgs = { recv };
-          return MessagePackModule.pack(runtime.getCurrentContext(), null, allArgs);
-        } else if (args.length == 1 && args[0] instanceof Packer) {
-          Packer packer = (Packer)args[0];
-          return packer.write(runtime.getCurrentContext(), recv);
-        } else if (args.length == 1) {
-          IRubyObject[] allArgs = { recv, args[0] };
-          return MessagePackModule.pack(runtime.getCurrentContext(), null, allArgs);
-        } else {
-          throw runtime.newArgumentError(String.format("wrong number of arguments (%d for 0..1)", args.length));
-        }
-      }
-
-      @Override
-      public DynamicMethod dup() {
-        return this;
-      }
-    };
-  }
-
-  @JRubyModule(name = "MessagePack")
-  public static class MessagePackModule {
-    @JRubyMethod(module = true, required = 1, optional = 1, alias = {"dump"})
-    public static IRubyObject pack(ThreadContext ctx, IRubyObject recv, IRubyObject[] args) {
-      IRubyObject[] extraArgs = null;
-      if (args.length == 0) {
-        extraArgs = new IRubyObject[] {};
-      } else {
-        extraArgs = new IRubyObject[args.length - 1];
-        System.arraycopy(args, 1, extraArgs, 0, args.length - 1);
-      }
-      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) {
-      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 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

@@ -2,6 +2,7 @@ package org.msgpack.jruby;
 
 
 import org.jruby.Ruby;
+import org.jruby.RubyModule;
 import org.jruby.RubyClass;
 import org.jruby.RubyObject;
 import org.jruby.RubyArray;
@@ -17,6 +18,10 @@ import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.util.ByteList;
+import org.jruby.util.TypeConverter;
+import org.msgpack.jruby.ExtensionValue;
+
+import org.jcodings.Encoding;
 
 import static org.jruby.runtime.Visibility.PRIVATE;
 
@@ -25,15 +30,18 @@ public class Packer extends RubyObject {
   public ExtensionRegistry registry;
   private Buffer buffer;
   private Encoder encoder;
+  private boolean hasSymbolExtType;
+  private Encoding binaryEncoding;
 
-  public Packer(Ruby runtime, RubyClass type, ExtensionRegistry registry) {
+  public Packer(Ruby runtime, RubyClass type, ExtensionRegistry registry, boolean hasSymbolExtType) {
     super(runtime, type);
     this.registry = registry;
+    this.hasSymbolExtType = hasSymbolExtType;
   }
 
   static class PackerAllocator implements ObjectAllocator {
     public IRubyObject allocate(Ruby runtime, RubyClass type) {
-      return new Packer(runtime, type, null);
+      return new Packer(runtime, type, null, false);
     }
   }
 
@@ -45,15 +53,20 @@ public class Packer extends RubyObject {
       IRubyObject mode = options.fastARef(ctx.getRuntime().newSymbol("compatibility_mode"));
       compatibilityMode = (mode != null) && mode.isTrue();
     }
-    this.encoder = new Encoder(ctx.getRuntime(), compatibilityMode, registry);
+    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.buffer.initialize(ctx, args);
-    this.registry = new ExtensionRegistry();
+    this.binaryEncoding = ctx.getRuntime().getEncodingService().getAscii8bitEncoding();
     return this;
   }
 
-  public static Packer newPacker(ThreadContext ctx, ExtensionRegistry extRegistry, IRubyObject[] args) {
-    Packer packer = new Packer(ctx.getRuntime(), ctx.getRuntime().getModule("MessagePack").getClass("Packer"), extRegistry);
+  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);
     packer.initialize(ctx, args);
     return packer;
   }
@@ -72,7 +85,7 @@ public class Packer extends RubyObject {
   public IRubyObject registerType(ThreadContext ctx, IRubyObject[] args, final Block block) {
     Ruby runtime = ctx.getRuntime();
     IRubyObject type = args[0];
-    IRubyObject klass = args[1];
+    IRubyObject mod = args[1];
 
     IRubyObject arg;
     IRubyObject proc;
@@ -94,12 +107,17 @@ public class Packer extends RubyObject {
       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()));
+    if (!(mod instanceof RubyModule)) {
+      throw runtime.newArgumentError(String.format("expected Module/Class but found %s.", mod.getType().getName()));
+    }
+    RubyModule extModule = (RubyModule) mod;
+
+    registry.put(extModule, (int) typeId, proc, arg, null, null);
+
+    if (extModule == runtime.getSymbol()) {
+      encoder.hasSymbolExtType = true;
     }
-    RubyClass extClass = (RubyClass) klass;
 
-    registry.put(extClass, (int) typeId, proc, arg, null, null);
     return runtime.getNil();
   }
 
@@ -109,6 +127,69 @@ public class Packer extends RubyObject {
     return this;
   }
 
+  @JRubyMethod(name = "write_float")
+  public IRubyObject writeFloat(ThreadContext ctx, IRubyObject obj) {
+    checkType(ctx, obj, org.jruby.RubyFloat.class);
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_array")
+  public IRubyObject writeArray(ThreadContext ctx, IRubyObject obj) {
+    checkType(ctx, obj, org.jruby.RubyArray.class);
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_string")
+  public IRubyObject writeString(ThreadContext ctx, IRubyObject obj) {
+    checkType(ctx, obj, org.jruby.RubyString.class);
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_bin")
+  public IRubyObject writeBin(ThreadContext ctx, IRubyObject obj) {
+    checkType(ctx, obj, org.jruby.RubyString.class);
+    obj = ((org.jruby.RubyString) obj).encode(ctx, ctx.runtime.getEncodingService().getEncoding(binaryEncoding));
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_hash")
+  public IRubyObject writeHash(ThreadContext ctx, IRubyObject obj) {
+    checkType(ctx, obj, org.jruby.RubyHash.class);
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_symbol")
+  public IRubyObject writeSymbol(ThreadContext ctx, IRubyObject obj) {
+    checkType(ctx, obj, org.jruby.RubySymbol.class);
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_int")
+  public IRubyObject writeInt(ThreadContext ctx, IRubyObject obj) {
+    if (!(obj instanceof RubyFixnum)) {
+      checkType(ctx, obj, org.jruby.RubyBignum.class);
+    }
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_extension")
+  public IRubyObject writeExtension(ThreadContext ctx, IRubyObject obj) {
+    if (!(obj instanceof ExtensionValue)) {
+      throw ctx.runtime.newTypeError("Expected extension");
+    }
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_true")
+  public IRubyObject writeTrue(ThreadContext ctx) {
+    return write(ctx, ctx.getRuntime().getTrue());
+  }
+
+  @JRubyMethod(name = "write_false")
+  public IRubyObject writeFalse(ThreadContext ctx) {
+    return write(ctx, ctx.getRuntime().getFalse());
+  }
+
   @JRubyMethod(name = "write_nil")
   public IRubyObject writeNil(ThreadContext ctx) {
     write(ctx, null);
@@ -139,6 +220,21 @@ public class Packer extends RubyObject {
     return this;
   }
 
+  @JRubyMethod(name = "write_bin_header")
+  public IRubyObject writeBinHeader(ThreadContext ctx, IRubyObject size) {
+    int s = (int) size.convertToInteger().getLongValue();
+    buffer.write(ctx, encoder.encodeBinHeader(s));
+    return this;
+  }
+
+  @JRubyMethod(name = "full_pack")
+  public IRubyObject fullPack(ThreadContext ctx) {
+    if (buffer.hasIo()) {
+      return null;
+    }
+    return toS(ctx);
+  }
+
   @JRubyMethod(name = "to_s", alias = { "to_str" })
   public IRubyObject toS(ThreadContext ctx) {
     return buffer.toS(ctx);
@@ -163,4 +259,11 @@ public class Packer extends RubyObject {
   public IRubyObject clear(ThreadContext ctx) {
     return buffer.clear(ctx);
   }
+
+  private void checkType(ThreadContext ctx, IRubyObject obj, Class<? extends IRubyObject> expectedType) {
+    if (!expectedType.isInstance(obj)) {
+      String expectedName = expectedType.getName().substring("org.jruby.Ruby".length());
+      throw ctx.runtime.newTypeError(String.format("wrong argument type %s (expected %s)", obj.getMetaClass().toString(), expectedName));
+    }
+  }
 }

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

@@ -3,6 +3,7 @@ package org.msgpack.jruby;
 import java.util.Arrays;
 
 import org.jruby.Ruby;
+import org.jruby.RubyModule;
 import org.jruby.RubyClass;
 import org.jruby.RubyString;
 import org.jruby.RubyObject;
@@ -51,7 +52,7 @@ public class Unpacker extends RubyObject {
     }
   }
 
-  @JRubyMethod(name = "initialize", optional = 1, visibility = PRIVATE)
+  @JRubyMethod(name = "initialize", optional = 2, visibility = PRIVATE)
   public IRubyObject initialize(ThreadContext ctx, IRubyObject[] args) {
     symbolizeKeys = false;
     allowUnknownExt = false;
@@ -66,7 +67,8 @@ public class Unpacker extends RubyObject {
         if (au != null) {
           allowUnknownExt = au.isTrue();
         }
-      } else if (!(args[0] instanceof RubyHash)) {
+      }
+      if (args[0] != ctx.getRuntime().getNil() && !(args[0] instanceof RubyHash)) {
         setStream(ctx, args[0]);
       }
     }
@@ -99,7 +101,7 @@ public class Unpacker extends RubyObject {
     Ruby runtime = ctx.getRuntime();
     IRubyObject type = args[0];
 
-    RubyClass extClass;
+    RubyModule extModule;
     IRubyObject arg;
     IRubyObject proc;
     if (args.length == 1) {
@@ -110,11 +112,11 @@ public class Unpacker extends RubyObject {
       if (proc == null)
         System.err.println("proc from Block is null");
       arg = proc;
-      extClass = null;
+      extModule = null;
     } else if (args.length == 3) {
-      extClass = (RubyClass) args[1];
+      extModule = (RubyModule) args[1];
       arg = args[2];
-      proc = extClass.method(arg);
+      proc = extModule.method(arg);
     } else {
       throw runtime.newArgumentError(String.format("wrong number of arguments (%d for 1 or 3)", 2 + args.length));
     }
@@ -124,7 +126,7 @@ public class Unpacker extends RubyObject {
       throw runtime.newRangeError(String.format("integer %d too big to convert to `signed char'", typeId));
     }
 
-    registry.put(extClass, (int) typeId, null, null, proc, arg);
+    registry.put(extModule, (int) typeId, null, null, proc, arg);
     return runtime.getNil();
   }
 
@@ -168,7 +170,7 @@ public class Unpacker extends RubyObject {
     return data == null ? ctx.getRuntime().getFalse() : ctx.getRuntime().getTrue();
   }
 
-  @JRubyMethod(required = 1)
+  @JRubyMethod(required = 1, name = "feed", alias = { "feed_reference" })
   public IRubyObject feed(ThreadContext ctx, IRubyObject data) {
     ByteList byteList = data.asString().getByteList();
     if (decoder == null) {
@@ -179,6 +181,11 @@ public class Unpacker extends RubyObject {
     return this;
   }
 
+  @JRubyMethod(name = "full_unpack")
+  public IRubyObject fullUnpack(ThreadContext ctx) {
+    return decoder.next();
+  }
+
   @JRubyMethod(name = "feed_each", required = 1)
   public IRubyObject feedEach(ThreadContext ctx, IRubyObject data, Block block) {
     feed(ctx, data);