msgpack 0.5.9-x86-mingw32 → 0.5.10-x86-mingw32

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

@@ -0,0 +1,78 @@
+package org.msgpack.jruby;
+
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.RubyHash;
+import org.jruby.RubyIO;
+import org.jruby.RubyInteger;
+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;
+
+
+@JRubyClass(name="MessagePack::Packer")
+public class Packer extends RubyObject {
+  private Buffer buffer;
+  private Encoder encoder;
+
+  public Packer(Ruby runtime, RubyClass type) {
+    super(runtime, type);
+  }
+
+  static class PackerAllocator implements ObjectAllocator {
+    public IRubyObject allocate(Ruby runtime, RubyClass type) {
+      return new Packer(runtime, type);
+    }
+  }
+
+  @JRubyMethod(name = "initialize", optional = 2)
+  public IRubyObject initialize(ThreadContext ctx, IRubyObject[] args) {
+    this.encoder = new Encoder(ctx.getRuntime());
+    this.buffer = new Buffer(ctx.getRuntime(), ctx.getRuntime().getModule("MessagePack").getClass("Buffer"));
+    this.buffer.initialize(ctx, args);
+    return this;
+  }
+
+  @JRubyMethod(name = "write")
+  public IRubyObject write(ThreadContext ctx, IRubyObject obj) {
+    return buffer.write(ctx, encoder.encode(obj, this));
+  }
+
+  @JRubyMethod(name = "write_nil")
+  public IRubyObject writeNil(ThreadContext ctx) {
+    return write(ctx, null);
+  }
+
+  @JRubyMethod(name = "write_array_header")
+  public IRubyObject writeArrayHeader(ThreadContext ctx, IRubyObject size) {
+    int s = (int) size.convertToInteger().getLongValue();
+    return buffer.write(ctx, encoder.encodeArrayHeader(s));
+  }
+
+  @JRubyMethod(name = "write_map_header")
+  public IRubyObject writeMapHeader(ThreadContext ctx, IRubyObject size) {
+    int s = (int) size.convertToInteger().getLongValue();
+    return buffer.write(ctx, encoder.encodeMapHeader(s));
+  }
+
+  @JRubyMethod(name = "to_s")
+  public IRubyObject toS(ThreadContext ctx) {
+    return buffer.toS(ctx);
+  }
+
+  @JRubyMethod(name = "buffer")
+  public IRubyObject buffer(ThreadContext ctx) {
+    return buffer;
+  }
+
+  @JRubyMethod(name = "flush")
+  public IRubyObject flush(ThreadContext ctx) {
+    return buffer.flush(ctx);
+  }
+
+}

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

@@ -0,0 +1,37 @@
+package org.msgpack.jruby;
+
+
+public interface Types {
+  public static final byte FIXSTR   = (byte) 0xa0; // This is actually not header byte, but prefix bit mask
+  public static final byte NIL      = (byte) 0xc0;
+  public static final byte FALSE    = (byte) 0xc2;
+  public static final byte TRUE     = (byte) 0xc3;
+  public static final byte BIN8     = (byte) 0xc4;
+  public static final byte BIN16    = (byte) 0xc5;
+  public static final byte BIN32    = (byte) 0xc6;
+  public static final byte VAREXT8  = (byte) 0xc7;
+  public static final byte VAREXT16 = (byte) 0xc8;
+  public static final byte VAREXT32 = (byte) 0xc9;
+  public static final byte FLOAT32  = (byte) 0xca;
+  public static final byte FLOAT64  = (byte) 0xcb;
+  public static final byte UINT8    = (byte) 0xcc;
+  public static final byte UINT16   = (byte) 0xcd;
+  public static final byte UINT32   = (byte) 0xce;
+  public static final byte UINT64   = (byte) 0xcf;
+  public static final byte INT8     = (byte) 0xd0;
+  public static final byte INT16    = (byte) 0xd1;
+  public static final byte INT32    = (byte) 0xd2;
+  public static final byte INT64    = (byte) 0xd3;
+  public static final byte FIXEXT1  = (byte) 0xd4;
+  public static final byte FIXEXT2  = (byte) 0xd5;
+  public static final byte FIXEXT4  = (byte) 0xd6;
+  public static final byte FIXEXT8  = (byte) 0xd7;
+  public static final byte FIXEXT16 = (byte) 0xd8;
+  public static final byte STR8     = (byte) 0xd9;
+  public static final byte STR16    = (byte) 0xda;
+  public static final byte STR32    = (byte) 0xdb;
+  public static final byte ARY16    = (byte) 0xdc;
+  public static final byte ARY32    = (byte) 0xdd;
+  public static final byte MAP16    = (byte) 0xde;
+  public static final byte MAP32    = (byte) 0xdf;
+}

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

@@ -0,0 +1,170 @@
+package org.msgpack.jruby;
+
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyString;
+import org.jruby.RubyObject;
+import org.jruby.RubyHash;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyIO;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.util.ByteList;
+import org.jruby.ext.stringio.StringIO;
+
+import static org.jruby.runtime.Visibility.PRIVATE;
+
+
+@JRubyClass(name="MessagePack::Unpacker")
+public class Unpacker extends RubyObject {
+  private IRubyObject stream;
+  private IRubyObject data;
+  private Decoder decoder;
+  private final RubyClass underflowErrorClass;
+
+  public Unpacker(Ruby runtime, RubyClass type) {
+    super(runtime, type);
+    this.underflowErrorClass = runtime.getModule("MessagePack").getClass("UnderflowError");
+  }
+
+  static class UnpackerAllocator implements ObjectAllocator {
+    public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+      return new Unpacker(runtime, klass);
+    }
+  }
+
+  @JRubyMethod(name = "initialize", optional = 1, visibility = PRIVATE)
+  public IRubyObject initialize(ThreadContext ctx, IRubyObject[] args) {
+    if (args.length > 0) {
+      if (args[args.length - 1] instanceof RubyHash) {
+        //TODO: symbolize_keys
+      } else if (!(args[0] instanceof RubyHash)) {
+        setStream(ctx, args[0]);
+      }
+    }
+    return this;
+  }
+
+  @JRubyMethod(required = 2)
+  public IRubyObject execute(ThreadContext ctx, IRubyObject data, IRubyObject offset) {
+    return executeLimit(ctx, data, offset, null);
+  }
+
+  @JRubyMethod(name = "execute_limit", required = 3)
+  public IRubyObject executeLimit(ThreadContext ctx, IRubyObject str, IRubyObject off, IRubyObject lim) {
+    RubyString input = str.asString();
+    int offset = RubyNumeric.fix2int(off);
+    int limit = lim == null || lim.isNil() ? -1 : RubyNumeric.fix2int(lim);
+    ByteList byteList = input.getByteList();
+    if (limit == -1) {
+      limit = byteList.length() - offset;
+    }
+    Decoder decoder = new Decoder(ctx.getRuntime(), byteList.unsafeBytes(), byteList.begin() + offset, limit);
+    try {
+      this.data = null;
+      this.data = decoder.next();
+    } catch (RaiseException re) {
+      if (re.getException().getType() != underflowErrorClass) {
+        throw re;
+      }
+    }
+    return ctx.getRuntime().newFixnum(decoder.offset());
+  }
+
+  @JRubyMethod(name = "data")
+  public IRubyObject getData(ThreadContext ctx) {
+    if (data == null) {
+      return ctx.getRuntime().getNil();
+    } else {
+      return data;
+    }
+  }
+
+  @JRubyMethod(name = "finished?")
+  public IRubyObject finished_p(ThreadContext ctx) {
+    return data == null ? ctx.getRuntime().getFalse() : ctx.getRuntime().getTrue();
+  }
+
+  @JRubyMethod(required = 1)
+  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());
+    } else {
+      decoder.feed(byteList.unsafeBytes(), byteList.begin(), byteList.length());
+    }
+    return ctx.getRuntime().getNil();
+  }
+
+  @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();
+  }
+
+  @JRubyMethod
+  public IRubyObject each(ThreadContext ctx, Block block) {
+    if (block.isGiven()) {
+      if (decoder != null) {
+        try {
+          while (decoder.hasNext()) {
+            block.yield(ctx, decoder.next());
+          }
+        } catch (RaiseException re) {
+          if (re.getException().getType() != underflowErrorClass) {
+            throw re;
+          }
+        }
+      }
+      return this;
+    } else {
+      return callMethod(ctx, "to_enum");
+    }
+  }
+
+  @JRubyMethod
+  public IRubyObject fill(ThreadContext ctx) {
+    return ctx.getRuntime().getNil();
+  }
+
+  @JRubyMethod
+  public IRubyObject reset(ThreadContext ctx) {
+    if (decoder != null) {
+      decoder.reset();
+    }
+    return ctx.getRuntime().getNil();
+  }
+
+  @JRubyMethod(name = "stream")
+  public IRubyObject getStream(ThreadContext ctx) {
+    if (stream == null) {
+      return ctx.getRuntime().getNil();
+    } else {
+      return stream;
+    }
+  }
+
+  @JRubyMethod(name = "stream=", required = 1)
+  public IRubyObject setStream(ThreadContext ctx, IRubyObject stream) {
+    RubyString str;
+    if (stream instanceof StringIO) {
+      str = stream.callMethod(ctx, "string").asString();
+    } else if (stream instanceof RubyIO) {
+      str = stream.callMethod(ctx, "read").asString();
+    } else {
+      throw ctx.getRuntime().newTypeError(stream, "IO");
+    }
+    ByteList byteList = str.getByteList();
+    this.stream = stream;
+    this.decoder = null;
+    this.decoder = new Decoder(ctx.getRuntime(), byteList.unsafeBytes(), byteList.begin(), byteList.length());
+    return getStream(ctx);
+  }
+}

data/lib/msgpack.rb

@@ -1,6 +1,13 @@
 require "msgpack/version"
-begin
-  require "msgpack/#{RUBY_VERSION[/\d+.\d+/]}/msgpack"
-rescue LoadError
-  require "msgpack/msgpack"
+
+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)
+else
+  begin
+    require "msgpack/#{RUBY_VERSION[/\d+.\d+/]}/msgpack"
+  rescue LoadError
+    require "msgpack/msgpack"
+  end
 end

data/lib/msgpack/version.rb

@@ -1,3 +1,3 @@
 module MessagePack
-	VERSION = "0.5.9"
+	VERSION = "0.5.10"
 end

data/msgpack.gemspec

@@ -1,4 +1,4 @@
-$:.push File.expand_path("../lib", __FILE__)
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
 require 'msgpack/version'
 
 Gem::Specification.new do |s|
@@ -6,16 +6,21 @@ Gem::Specification.new do |s|
   s.version = MessagePack::VERSION
   s.summary = "MessagePack, a binary-based efficient data interchange format."
   s.description = %q{MessagePack is a binary-based efficient object serialization library. It enables to exchange structured objects between many languages like JSON. But unlike JSON, it is very fast and small.}
-  s.author = "Sadayuki Furuhashi"
-  s.email = "frsyuki@gmail.com"
+  s.authors = ["Sadayuki Furuhashi", "Theo Hultberg"]
+  s.email = ["frsyuki@gmail.com", "theo@iconara.net"]
   s.license = "Apache 2.0"
   s.homepage = "http://msgpack.org/"
   s.rubyforge_project = "msgpack"
   s.has_rdoc = false
-  s.files = `git ls-files`.split("\n")
-  s.test_files = `git ls-files -- {test,spec}/*`.split("\n")
   s.require_paths = ["lib"]
-  s.extensions = ["ext/msgpack/extconf.rb"]
+  if /java/ =~ RUBY_PLATFORM
+    s.files = Dir['lib/**/*.rb', 'lib/**/*.jar']
+    s.platform = Gem::Platform.new('java')
+  else
+    s.files = `git ls-files`.split("\n")
+    s.extensions = ["ext/msgpack/extconf.rb"]
+  end
+  s.test_files = `git ls-files -- {test,spec}/*`.split("\n")
 
   s.add_development_dependency 'bundler', ['~> 1.0']
   s.add_development_dependency 'rake', ['~> 0.9.2']

data/spec/format_spec.rb

@@ -20,55 +20,55 @@ describe MessagePack do
 
   it "positive fixnum" do
     check 1, 1
-    check 1, (1<<6)
-    check 1, (1<<7)-1
+    check 1, (1 << 6)
+    check 1, (1 << 7)-1
   end
 
   it "positive int 8" do
     check 1, -1
-    check 2, (1<<7)
-    check 2, (1<<8)-1
+    check 2, (1 << 7)
+    check 2, (1 << 8) - 1
   end
 
   it "positive int 16" do
-    check 3, (1<<8)
-    check 3, (1<<16)-1
+    check 3, (1 << 8)
+    check 3, (1 << 16) - 1
   end
 
   it "positive int 32" do
-    check 5, (1<<16)
-    check 5, (1<<32)-1
+    check 5, (1 << 16)
+    check 5, (1 << 32) - 1
   end
 
   it "positive int 64" do
-    check 9, (1<<32)
+    check 9, (1 << 32)
     #check 9, (1<<64)-1
   end
 
   it "negative fixnum" do
     check 1, -1
-    check 1, -((1<<5)-1)
-    check 1, -(1<<5)
+    check 1, -((1 << 5)-1)
+    check 1, -(1 << 5)
   end
 
   it "negative int 8" do
-    check 2, -((1<<5)+1)
-    check 2, -(1<<7)
+    check 2, -((1 << 5)+1)
+    check 2, -(1 << 7)
   end
 
   it "negative int 16" do
-    check 3, -((1<<7)+1)
-    check 3, -(1<<15)
+    check 3, -((1 << 7)+1)
+    check 3, -(1 << 15)
   end
 
   it "negative int 32" do
-    check 5, -((1<<15)+1)
-    check 5, -(1<<31)
+    check 5, -((1 << 15)+1)
+    check 5, -(1 << 31)
   end
 
   it "negative int 64" do
-    check 9, -((1<<31)+1)
-    check 9, -(1<<63)
+    check 9, -((1 << 31)+1)
+    check 9, -(1 << 63)
   end
 
   it "double" do
@@ -80,32 +80,32 @@ describe MessagePack do
 
   it "fixraw" do
     check_raw 1, 0
-    check_raw 1, (1<<5)-1
+    check_raw 1, (1 << 5)-1
   end
 
   it "raw 16" do
-    check_raw 3, (1<<5)
-    check_raw 3, (1<<16)-1
+    check_raw 3, (1 << 5)
+    check_raw 3, (1 << 16)-1
   end
 
   it "raw 32" do
-    check_raw 5, (1<<16)
-    #check_raw 5, (1<<32)-1  # memory error
+    check_raw 5, (1 << 16)
+    #check_raw 5, (1 << 32)-1  # memory error
   end
 
   it "fixarray" do
     check_array 1, 0
-    check_array 1, (1<<4)-1
+    check_array 1, (1 << 4)-1
   end
 
   it "array 16" do
-    check_array 3, (1<<4)
-    #check_array 3, (1<<16)-1
+    check_array 3, (1 << 4)
+    #check_array 3, (1 << 16)-1
   end
 
   it "array 32" do
-    #check_array 5, (1<<16)
-    #check_array 5, (1<<32)-1  # memory error
+    #check_array 5, (1 << 16)
+    #check_array 5, (1 << 32)-1  # memory error
   end
 
   it "nil" do
@@ -210,7 +210,9 @@ describe MessagePack do
   end
 
   def check_raw(overhead, num)
-    check num+overhead, " "*num
+    rawstr = " "*num
+    rawstr.force_encoding("UTF-8")
+    check num+overhead, rawstr
   end
 
   def check_array(overhead, num)