msgpack-jruby 1.1.3-java → 1.2.0-java

data/Rakefile

@@ -31,16 +31,17 @@ end
 namespace :benchmark do
   BENCHMARK_RUBIES = ['1.9.2-p0', 'jruby-1.6.5', 'jruby-head']
   BENCHMARK_GEMSET = 'msgpack-jruby-benchmarking'
+  BENCHMARK_FILE = 'spec/benchmarks/shootout_bm.rb'
 
   task :run do
     rubies = BENCHMARK_RUBIES.map { |rb| "#{rb}@#{BENCHMARK_GEMSET}" }
-    cmd = %(rvm #{rubies.join(',')} exec viiite run spec/benchmark.rb | tee benchmark | viiite report --hierarchy --regroup=bench,lib,ruby)
+    cmd = %(rvm #{rubies.join(',')} exec viiite run #{BENCHMARK_FILE} | tee benchmark | viiite report --hierarchy --regroup=bench,lib,ruby)
     puts cmd
     system cmd
   end
 
   task :quick do
-    cmd = %(IMPLEMENTATIONS=msgpack viiite run spec/benchmark.rb | viiite report --hierarchy --regroup=bench)
+    cmd = %(IMPLEMENTATIONS=msgpack viiite run #{BENCHMARK_FILE} | viiite report --hierarchy --regroup=bench)
     puts cmd
     system cmd
   end

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

@@ -10,6 +10,7 @@ import org.jruby.RubyModule;
 import org.jruby.RubyClass;
 import org.jruby.RubyString;
 import org.jruby.RubyObject;
+import org.jruby.RubyHash;
 import org.jruby.RubyIO;
 import org.jruby.RubyStringIO;
 import org.jruby.RubyNumeric;
@@ -54,18 +55,19 @@ public class MessagePackLibrary implements Library {
   @JRubyModule(name = "MessagePack")
   public static class MessagePackModule {
     private static MessagePack msgPack = new MessagePack();
+    private static RubyObjectPacker packer = new RubyObjectPacker(msgPack);
     private static RubyObjectUnpacker unpacker = new RubyObjectUnpacker(msgPack);
     
     @JRubyMethod(module = true, required = 1)
     public static IRubyObject pack(ThreadContext ctx, IRubyObject recv, IRubyObject obj) throws IOException {
-      BufferPacker bufferedPacker = msgPack.createBufferPacker();
-      Packer packer = new RubyObjectPacker(msgPack, bufferedPacker).write(obj);
-      return RubyString.newString(ctx.getRuntime(), bufferedPacker.toByteArray());
+      return packer.pack(obj);
     }
     
-    @JRubyMethod(module = true, required = 1)
-    public static IRubyObject unpack(ThreadContext ctx, IRubyObject recv, IRubyObject obj) throws IOException {
-      return unpacker.unpack(obj.asString());
+    @JRubyMethod(module = true, required = 1, optional = 1)
+    public static IRubyObject unpack(ThreadContext ctx, IRubyObject recv, IRubyObject[] args) throws IOException {
+      RubyHash options = (args.length == 2) ? (RubyHash) args[1] : null;
+      RubyString str = args[0].asString();
+      return unpacker.unpack(str, options);
     }
   }
 
@@ -89,6 +91,7 @@ public class MessagePackLibrary implements Library {
     private MessagePackUnpacker streamUnpacker;
     private IRubyObject stream;
     private IRubyObject data;
+    private RubyHash options;
     
     public Unpacker(Ruby runtime, RubyClass type, MessagePack msgPack) {
       super(runtime, type);
@@ -100,10 +103,17 @@ public class MessagePackLibrary implements Library {
       this.data = null;
     }
 
-    @JRubyMethod(name = "initialize", optional = 1, visibility = PRIVATE)
+    @JRubyMethod(name = "initialize", optional = 2, visibility = PRIVATE)
     public IRubyObject initialize(ThreadContext ctx, IRubyObject[] args) {
-      if (args.length > 0) {
+      if (args.length == 0) {
+        options = null;
+      } else if (args.length == 1 && args[0] instanceof RubyHash) {
+        options = (RubyHash) args[0];
+      } else if (args.length > 0) {
         setStream(ctx, args[0]);
+        if (args.length > 2) {
+          options = (RubyHash) args[1];
+        }
       }
       return this;
     }
@@ -125,7 +135,7 @@ public class MessagePackLibrary implements Library {
         byte[] bytes = data.asString().getBytes();
         MessagePackBufferUnpacker localBufferUnpacker = new MessagePackBufferUnpacker(msgPack, bytes.length);
         localBufferUnpacker.wrap(bytes, jOffset, jLimit == -1 ? bytes.length - jOffset : jLimit);
-        this.data = rubyObjectUnpacker.valueToRubyObject(ctx.getRuntime(), localBufferUnpacker.readValue());
+        this.data = rubyObjectUnpacker.valueToRubyObject(ctx.getRuntime(), localBufferUnpacker.readValue(), options);
         return ctx.getRuntime().newFixnum(jOffset + localBufferUnpacker.getReadByteCount());
       } catch (IOException ioe) {
         // TODO: how to throw Ruby exceptions?
@@ -177,12 +187,12 @@ public class MessagePackLibrary implements Library {
       }
       if (block.isGiven()) {
         for (Value value : localUnpacker) {
-          IRubyObject rubyObject = rubyObjectUnpacker.valueToRubyObject(ctx.getRuntime(), value);
+          IRubyObject rubyObject = rubyObjectUnpacker.valueToRubyObject(ctx.getRuntime(), value, options);
           block.yield(ctx, rubyObject);
         }
         return ctx.getRuntime().getNil();
       } else {
-        return RubyEnumerator.RubyEnumeratorKernel.obj_to_enum(ctx, this, Block.NULL_BLOCK);
+        return RubyEnumerator.RubyEnumeratorKernel.obj_to_enum(ctx, this);
       }
     }
 

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

@@ -4,8 +4,7 @@ package org.msgpack.jruby;
 import java.io.IOException;
 
 import org.msgpack.MessagePack;
-import org.msgpack.packer.Packer;
-import org.msgpack.packer.MessagePackBufferPacker;
+import org.msgpack.packer.BufferPacker;
 
 import org.jruby.RubyObject;
 import org.jruby.RubyNil;
@@ -21,91 +20,91 @@ import org.jruby.RubyHash;
 import org.jruby.runtime.builtin.IRubyObject;
 
 
-public class RubyObjectPacker extends MessagePackBufferPacker {
-  private final Packer packer;
+public class RubyObjectPacker {
+  private final MessagePack msgPack;
 
-  public RubyObjectPacker(MessagePack msgPack, Packer packer) {
-    super(msgPack);
-    this.packer = packer;
+  public RubyObjectPacker(MessagePack msgPack) {
+    this.msgPack = msgPack;
   }
 
-  public Packer write(IRubyObject o) throws IOException {
+  public RubyString pack(IRubyObject o) throws IOException {
+    return RubyString.newString(o.getRuntime(), packRaw(o));
+  }
+
+  public byte[] packRaw(IRubyObject o) throws IOException {
+    BufferPacker packer = msgPack.createBufferPacker();
+    write(packer, o);
+    return packer.toByteArray();
+  }
+
+  private void write(BufferPacker packer, IRubyObject o) throws IOException {
     if (o == null || o instanceof RubyNil) {
       packer.writeNil();
-      return this;
     } else if (o instanceof RubyBoolean) {
       packer.write(((RubyBoolean) o).isTrue());
-      return this;
     } else if (o instanceof RubyBignum) {
-      return write((RubyBignum) o);
+      write(packer, (RubyBignum) o);
     } else if (o instanceof RubyInteger) {
-      return write((RubyInteger) o);
+      write(packer, (RubyInteger) o);
     } else if (o instanceof RubyFixnum) {
-      return write((RubyFixnum) o);
+      write(packer, (RubyFixnum) o);
     } else if (o instanceof RubyFloat) {
-      return write((RubyFloat) o);
+      write(packer, (RubyFloat) o);
     } else if (o instanceof RubyString) {
-      return write((RubyString) o);
+      write(packer, (RubyString) o);
     } else if (o instanceof RubySymbol) {
-      return write((RubySymbol) o);
+      write(packer, (RubySymbol) o);
     } else if (o instanceof RubyArray) {
-      return write((RubyArray) o);
+      write(packer, (RubyArray) o);
     } else if (o instanceof RubyHash) {
-      return write((RubyHash) o);
+      write(packer, (RubyHash) o);
     } else {
       throw o.getRuntime().newArgumentError(String.format("Cannot pack type: %s", o.getClass().getName()));
     }
   }
 
-  public final Packer write(RubyBignum bignum) throws IOException {
+  private void write(BufferPacker packer, RubyBignum bignum) throws IOException {
     packer.write(bignum.getBigIntegerValue());
-    return this;
   }
 
-  public final Packer write(RubyInteger integer) throws IOException {
+  private void write(BufferPacker packer, RubyInteger integer) throws IOException {
     packer.write(integer.getLongValue());
-    return this;
   }
 
-  public final Packer write(RubyFixnum fixnum) throws IOException {
+  private void write(BufferPacker packer, RubyFixnum fixnum) throws IOException {
     packer.write(fixnum.getLongValue());
-    return this;
   }
 
-  public final Packer write(RubyFloat flt) throws IOException {
+  private void write(BufferPacker packer, RubyFloat flt) throws IOException {
     packer.write(flt.getDoubleValue());
-    return this;
   }
 
-  public final Packer write(RubyString str) throws IOException {
+  private void write(BufferPacker packer, RubyString str) throws IOException {
     packer.write(str.getBytes());
-    return this;
   }
 
-  public final Packer write(RubySymbol sym) throws IOException {
-    return write((RubyString) sym.to_s());
+  private void write(BufferPacker packer, RubySymbol sym) throws IOException {
+    write(packer, (RubyString) sym.to_s());
   }
 
-  public final Packer write(RubyArray array) throws IOException {
+  private void write(BufferPacker packer, RubyArray array) throws IOException {
     int count = array.size();
     packer.writeArrayBegin(count);
     for (int i = 0; i < count; i++) {
-      write((RubyObject) array.entry(i));
+      write(packer, (RubyObject) array.entry(i));
     }
     packer.writeArrayEnd();
-    return this;
   }
 
-  public final Packer write(RubyHash hash) throws IOException {
+  private void write(BufferPacker packer, RubyHash hash) throws IOException {
     int count = hash.size();
     packer.writeMapBegin(count);
     RubyArray keys = hash.keys();
     RubyArray values = hash.rb_values();
     for (int i = 0; i < count; i++) {
-      write((RubyObject) keys.entry(i));
-      write((RubyObject) values.entry(i));
+      write(packer, (RubyObject) keys.entry(i));
+      write(packer, (RubyObject) values.entry(i));
     }
     packer.writeMapEnd();
-    return this;
   }
 }

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

@@ -28,6 +28,7 @@ import org.jruby.RubySymbol;
 import org.jruby.RubyArray;
 import org.jruby.RubyHash;
 import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.ThreadContext;
 
 
 public class RubyObjectUnpacker {
@@ -37,17 +38,17 @@ public class RubyObjectUnpacker {
     this.msgPack = msgPack;
   }
 
-  public IRubyObject unpack(RubyString str) throws IOException {
-    return unpack(str.getRuntime(), str.getBytes());
+  public IRubyObject unpack(RubyString str, RubyHash options) throws IOException {
+    return unpack(str.getRuntime(), str.getBytes(), options);
   }
 
-  public IRubyObject unpack(Ruby runtime, byte[] data) throws IOException {
+  public IRubyObject unpack(Ruby runtime, byte[] data, RubyHash options) throws IOException {
     MessagePackBufferUnpacker unpacker = new MessagePackBufferUnpacker(msgPack);
     unpacker.wrap(data);
-    return valueToRubyObject(runtime, unpacker.readValue()); 
+    return valueToRubyObject(runtime, unpacker.readValue(), options);
   }
 
-  IRubyObject valueToRubyObject(Ruby runtime, Value value) {
+  IRubyObject valueToRubyObject(Ruby runtime, Value value, RubyHash options) {
     switch (value.getType()) {
     case NIL:
       return runtime.getNil();
@@ -58,9 +59,9 @@ public class RubyObjectUnpacker {
     case FLOAT:
       return convert(runtime, value.asFloatValue());
     case ARRAY:
-      return convert(runtime, value.asArrayValue());
+      return convert(runtime, value.asArrayValue(), options);
     case MAP:
-      return convert(runtime, value.asMapValue());
+      return convert(runtime, value.asMapValue(), options);
     case RAW:
       return convert(runtime, value.asRawValue());
     default:
@@ -86,24 +87,29 @@ public class RubyObjectUnpacker {
     return RubyFloat.newFloat(runtime, value.asFloatValue().getDouble());
   }
 
-  private IRubyObject convert(Ruby runtime, ArrayValue value) {
+  private IRubyObject convert(Ruby runtime, ArrayValue value, RubyHash options) {
     Value[] elements = value.asArrayValue().getElementArray();
     int elementCount = elements.length;
     IRubyObject[] rubyObjects = new IRubyObject[elementCount];
     for (int i = 0; i < elementCount; i++) {
-      rubyObjects[i] = valueToRubyObject(runtime, elements[i]);
+      rubyObjects[i] = valueToRubyObject(runtime, elements[i], options);
     }
     return RubyArray.newArray(runtime, rubyObjects);
   }
 
-  private IRubyObject convert(Ruby runtime, MapValue value) {
+  private IRubyObject convert(Ruby runtime, MapValue value, RubyHash options) {
     Value[] keysAndValues = value.asMapValue().getKeyValueArray();
     int kvCount = keysAndValues.length;
     RubyHash hash = RubyHash.newHash(runtime);
     for (int i = 0; i < kvCount; i += 2) {
       Value k = keysAndValues[i];
       Value v = keysAndValues[i + 1];
-      hash.put(valueToRubyObject(runtime, k), valueToRubyObject(runtime, v));
+      IRubyObject kk = valueToRubyObject(runtime, k, options);
+      IRubyObject vv = valueToRubyObject(runtime, v, options);
+      if (symbolizeKeysEnabled(options)) {
+        kk = runtime.newSymbol(kk.asString().getByteList());
+      }
+      hash.put(kk, vv);
     }
     return hash;
   }
@@ -111,4 +117,20 @@ public class RubyObjectUnpacker {
   private IRubyObject convert(Ruby runtime, RawValue value) {
     return RubyString.newString(runtime, value.asRawValue().getByteArray());
   }
+
+  private boolean symbolizeKeysEnabled(RubyHash options) {
+    if (options == null) {
+      return false;
+    } else {
+      Ruby runtime = options.getRuntime();
+      ThreadContext ctx = runtime.getCurrentContext();
+      RubySymbol key = runtime.newSymbol("symbolize_keys");
+      IRubyObject value = options.fastARef(key);
+      if (value == null) {
+        return false;
+      } else {
+        return value.isTrue();
+      }
+    }
+  }
 }

data/lib/msgpack/version.rb

@@ -1,3 +1,3 @@
 module MessagePack
-  VERSION = '1.1.3'
+  VERSION = '1.2.0'
 end

data/spec/{benchmark.rb → benchmarks/shootout_bm.rb}

@@ -2,7 +2,7 @@
 
 if RUBY_PLATFORM.include?('java')
   # JRuby should use this library, MRI should use the standard gem
-  $: << File.expand_path('../../lib', __FILE__)
+  $: << File.expand_path('../../../lib', __FILE__)
 end
 
 require 'viiite'

data/spec/benchmarks/symbolize_keys_bm.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+$: << File.expand_path('../../../lib', __FILE__)
+
+require 'viiite'
+require 'msgpack'
+
+
+iterations = 10_000
+data = MessagePack.pack(:hello => 'world', :nested => ['structure', {:value => 42}])
+
+Viiite.bm do |b|
+  b.report(:strings) do
+    iterations.times do
+      MessagePack.unpack(data)
+    end
+  end
+
+  b.report(:symbols) do
+    options = {:symbolize_keys => true}
+    iterations.times do
+      MessagePack.unpack(data, options)
+    end
+  end
+end

data/spec/msgpack/unpacker_spec.rb

@@ -156,4 +156,38 @@ describe ::MessagePack::Unpacker do
       MessagePack.unpack(MessagePack.pack(array)).should have(10_000).items
     end
   end
+
+  context 'extensions' do
+    context 'symbolized keys' do
+      let :buffer do
+        MessagePack.pack({'hello' => 'world', 'nested' => ['object', {'structure' => true}]})
+      end
+
+      let :unpacker do
+        described_class.new(:symbolize_keys => true)
+      end
+
+      it 'can symbolize keys when using #execute' do
+        unpacker.execute(buffer, 0)
+        unpacker.data.should == {:hello => 'world', :nested => ['object', {:structure => true}]}
+      end
+
+      it 'can symbolize keys when using #each' do
+        objs = []
+        unpacker.feed(buffer)
+        unpacker.each do |obj|
+          objs << obj
+        end
+        objs.should == [{:hello => 'world', :nested => ['object', {:structure => true}]}]
+      end
+
+      it 'can symbolize keys when using #feed_each' do
+        objs = []
+        unpacker.feed_each(buffer) do |obj|
+          objs << obj
+        end
+        objs.should == [{:hello => 'world', :nested => ['object', {:structure => true}]}]
+      end
+    end
+  end
 end

data/spec/msgpack_spec.rb

@@ -78,4 +78,12 @@ describe MessagePack do
       expect { MessagePack.unpack('asdka;sd') }.to raise_error(MessagePack::UnpackError)
     end
   end
+
+  context 'extensions' do
+    it 'can unpack hashes with symbolized keys' do
+      packed = MessagePack.pack({'hello' => 'world', 'nested' => ['object', {'structure' => true}]})
+      unpacked = MessagePack.unpack(packed, :symbolize_keys => true)
+      unpacked.should == {:hello => 'world', :nested => ['object', {:structure => true}]}
+    end
+  end
 end

metadata

@@ -2,14 +2,14 @@
 name: msgpack-jruby
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 1.1.3
+  version: 1.2.0
 platform: java
 authors:
 - Theo Hultberg
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-06-14 00:00:00.000000000Z
+date: 2012-07-29 00:00:00.000000000Z
 dependencies: []
 description: JRuby compatible MessagePack implementation that does not use FFI
 email:
@@ -35,7 +35,8 @@ files:
 - lib/msgpack.rb
 - lib/msgpack/version.rb
 - msgpack-jruby.gemspec
-- spec/benchmark.rb
+- spec/benchmarks/shootout_bm.rb
+- spec/benchmarks/symbolize_keys_bm.rb
 - spec/msgpack/unpacker_spec.rb
 - spec/msgpack_spec.rb
 - spec/spec_helper.rb