msgpack-jruby 1.2.0-java → 1.3.0-java

data/.rvmrc

@@ -1 +1 @@
-rvm --create use jruby-1.6.7@msgpack-jruby
+rvm --create use jruby-1.7.1@msgpack-jruby

data/Rakefile

@@ -20,7 +20,7 @@ task :package => :compile do
   exit($?.exitstatus) unless $?.success?
 end
 
-task :release do
+task :release => :package do
   version_string = "v#{MessagePack::VERSION}"
   unless %x(git tag -l).include?(version_string)
     system %(git tag -a #{version_string} -m #{version_string})

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

@@ -91,7 +91,7 @@ public class MessagePackLibrary implements Library {
     private MessagePackUnpacker streamUnpacker;
     private IRubyObject stream;
     private IRubyObject data;
-    private RubyHash options;
+    private RubyObjectUnpacker.CompiledOptions options;
     
     public Unpacker(Ruby runtime, RubyClass type, MessagePack msgPack) {
       super(runtime, type);
@@ -106,13 +106,15 @@ public class MessagePackLibrary implements Library {
     @JRubyMethod(name = "initialize", optional = 2, visibility = PRIVATE)
     public IRubyObject initialize(ThreadContext ctx, IRubyObject[] args) {
       if (args.length == 0) {
-        options = null;
+        options = new RubyObjectUnpacker.CompiledOptions();
       } else if (args.length == 1 && args[0] instanceof RubyHash) {
-        options = (RubyHash) args[0];
+        options = new RubyObjectUnpacker.CompiledOptions((RubyHash) args[0]);
       } else if (args.length > 0) {
         setStream(ctx, args[0]);
         if (args.length > 2) {
-          options = (RubyHash) args[1];
+          options = new RubyObjectUnpacker.CompiledOptions((RubyHash) args[1]);
+        } else {
+          options = new RubyObjectUnpacker.CompiledOptions();
         }
       }
       return this;

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

@@ -30,6 +30,8 @@ import org.jruby.RubyHash;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.runtime.ThreadContext;
 
+import org.jcodings.Encoding;
+
 
 public class RubyObjectUnpacker {
   private final MessagePack msgPack;
@@ -38,17 +40,49 @@ public class RubyObjectUnpacker {
     this.msgPack = msgPack;
   }
 
+  public static class CompiledOptions {
+    public final boolean symbolizeKeys;
+    public final Encoding encoding;
+
+    public CompiledOptions() {
+      this(null);
+    }
+
+    public CompiledOptions(RubyHash options) {
+      if (options == null) {
+        symbolizeKeys = false;
+        encoding = null;
+      } else {
+        Ruby runtime = options.getRuntime();
+        ThreadContext ctx = runtime.getCurrentContext();
+        RubySymbol key = runtime.newSymbol("symbolize_keys");
+        IRubyObject value = options.fastARef(key);
+        symbolizeKeys = value != null && value.isTrue();
+        IRubyObject rubyEncoding = options.fastARef(runtime.newSymbol("encoding"));
+        encoding = runtime.getEncodingService().getEncodingFromObject(rubyEncoding);
+      }
+    }
+  }
+
   public IRubyObject unpack(RubyString str, RubyHash options) throws IOException {
-    return unpack(str.getRuntime(), str.getBytes(), options);
+    return unpack(str.getRuntime(), str.getBytes(), new CompiledOptions(options));
   }
 
   public IRubyObject unpack(Ruby runtime, byte[] data, RubyHash options) throws IOException {
+    return unpack(runtime, data, new CompiledOptions(options));
+  }
+
+  public IRubyObject unpack(Ruby runtime, byte[] data, CompiledOptions options) throws IOException {
     MessagePackBufferUnpacker unpacker = new MessagePackBufferUnpacker(msgPack);
     unpacker.wrap(data);
     return valueToRubyObject(runtime, unpacker.readValue(), options);
   }
 
-  IRubyObject valueToRubyObject(Ruby runtime, Value value, RubyHash options) {
+  IRubyObject valueToRubyObject(Ruby runtime, Value value, RubyHash options) throws IOException {
+    return valueToRubyObject(runtime, value, new CompiledOptions(options));
+  }
+
+  IRubyObject valueToRubyObject(Ruby runtime, Value value, CompiledOptions options) {
     switch (value.getType()) {
     case NIL:
       return runtime.getNil();
@@ -63,7 +97,7 @@ public class RubyObjectUnpacker {
     case MAP:
       return convert(runtime, value.asMapValue(), options);
     case RAW:
-      return convert(runtime, value.asRawValue());
+      return convert(runtime, value.asRawValue(), options);
     default:
       throw runtime.newArgumentError(String.format("Unexpected value: %s", value.toString()));
     }
@@ -87,7 +121,7 @@ public class RubyObjectUnpacker {
     return RubyFloat.newFloat(runtime, value.asFloatValue().getDouble());
   }
 
-  private IRubyObject convert(Ruby runtime, ArrayValue value, RubyHash options) {
+  private IRubyObject convert(Ruby runtime, ArrayValue value, CompiledOptions options) {
     Value[] elements = value.asArrayValue().getElementArray();
     int elementCount = elements.length;
     IRubyObject[] rubyObjects = new IRubyObject[elementCount];
@@ -97,7 +131,7 @@ public class RubyObjectUnpacker {
     return RubyArray.newArray(runtime, rubyObjects);
   }
 
-  private IRubyObject convert(Ruby runtime, MapValue value, RubyHash options) {
+  private IRubyObject convert(Ruby runtime, MapValue value, CompiledOptions options) {
     Value[] keysAndValues = value.asMapValue().getKeyValueArray();
     int kvCount = keysAndValues.length;
     RubyHash hash = RubyHash.newHash(runtime);
@@ -106,7 +140,7 @@ public class RubyObjectUnpacker {
       Value v = keysAndValues[i + 1];
       IRubyObject kk = valueToRubyObject(runtime, k, options);
       IRubyObject vv = valueToRubyObject(runtime, v, options);
-      if (symbolizeKeysEnabled(options)) {
+      if (options.symbolizeKeys) {
         kk = runtime.newSymbol(kk.asString().getByteList());
       }
       hash.put(kk, vv);
@@ -114,23 +148,11 @@ public class RubyObjectUnpacker {
     return hash;
   }
 
-  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();
-      }
+  private IRubyObject convert(Ruby runtime, RawValue value, CompiledOptions options) {
+    RubyString string = RubyString.newString(runtime, value.asRawValue().getByteArray());
+    if (options.encoding != null) {
+      string.setEncoding(options.encoding);
     }
+    return string;
   }
 }

data/lib/msgpack/version.rb

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

data/spec/msgpack/unpacker_spec.rb

@@ -189,5 +189,57 @@ describe ::MessagePack::Unpacker do
         objs.should == [{:hello => 'world', :nested => ['object', {:structure => true}]}]
       end
     end
+
+    context 'encoding' do
+
+      def flatten(struct, results = [])
+        case struct
+        when Array
+          struct.each { |v| flatten(v, results) }
+        when Hash
+          struct.each { |k, v| flatten(v, flatten(k, results)) }
+        else
+          results << struct
+        end
+        results
+      end
+
+      let :buffer do
+        MessagePack.pack({'hello' => 'world', 'nested' => ['object', {'structure' => true}]})
+      end
+
+      let :unpacker do
+        described_class.new(:encoding => 'UTF-8')
+      end
+
+      it 'can symbolize keys when using #execute' do
+        unpacker.execute(buffer, 0)
+        strings = flatten(unpacker.data).grep(String)
+        strings.should == %w[hello world nested object structure]
+        strings.map(&:encoding).uniq.should == [Encoding::UTF_8]
+      end
+
+      it 'can symbolize keys when using #each' do
+        objs = []
+        unpacker.feed(buffer)
+        unpacker.each do |obj|
+          objs << obj
+        end
+        strings = flatten(objs).grep(String)
+        strings.should == %w[hello world nested object structure]
+        strings.map(&:encoding).uniq.should == [Encoding::UTF_8]
+      end
+
+      it 'can symbolize keys when using #feed_each' do
+        objs = []
+        unpacker.feed_each(buffer) do |obj|
+          objs << obj
+        end
+        strings = flatten(objs).grep(String)
+        strings.should == %w[hello world nested object structure]
+        strings.map(&:encoding).uniq.should == [Encoding::UTF_8]
+      end
+    end
+
   end
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: msgpack-jruby
 version: !ruby/object:Gem::Version
+  version: 1.3.0
   prerelease:
-  version: 1.2.0
 platform: java
 authors:
 - Theo Hultberg
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-07-29 00:00:00.000000000Z
+date: 2012-12-05 00:00:00.000000000 Z
 dependencies: []
 description: JRuby compatible MessagePack implementation that does not use FFI
 email:
@@ -52,20 +52,21 @@ required_ruby_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       segments:
       - 0
+      version: !binary |-
+        MA==
       hash: 2
-      version: '0'
   none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: !binary |-
+        MA==
   none: false
 requirements: []
 rubyforge_project: msgpack-jruby
-rubygems_version: 1.8.15
+rubygems_version: 1.8.24
 signing_key:
 specification_version: 3
 summary: MessagePack implementation for JRuby
 test_files: []
-...