msgpack 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f57829db3ad4359a6065eced56e9fcd9bcbea1ce
-  data.tar.gz: 5c2674055751c11c5756ef056dfc3ff871ce6036
+  metadata.gz: 9bb14c162f5f2190f44cd5b8613e384d89a6ac62
+  data.tar.gz: d37af929b9bb3cff9bef8ce2f75b36124824993a
 SHA512:
-  metadata.gz: a9128c789359ddaa85199b3308e9b9d2e71889fd93b64813c247fad4a6cbc08059566006722c2349f1a3122dcf88eb0ff73fda1b2cea9c1b7e33eb79a7d0b5ed
-  data.tar.gz: 6be7ba85981626bf0bb2c938e66449cadcc03cfe6d62611639364f163b871aab64ab0ff2ab83eb8af10db713b528c3e5364f5f8ee179604864fb3cffdd934827
+  metadata.gz: 4389bb67dd52c5cd6a3c0112e880f3b9fb07a4b10667bcf1e4552fd8ad3e4d2b34a53d4c6836574e50933bd21a79f5d3257f74b2ca53bcf6c941ac4494b036e2
+  data.tar.gz: ea5abfcbf7cbea580de4b376270b2568f0acb28496cb2e7b413d793a0327bb6859540e336544fac47b10bf80c96fb990361e1a46ea3027e3712d1428775ff0d9

data/doclib/msgpack/packer.rb

@@ -17,7 +17,11 @@ module MessagePack
     #   This packer writes serialzied objects into the IO when the internal buffer is filled.
     #   _io_ must respond to write(string) or append(string) method.
     #
-    # See also Buffer#initialize for options.
+    # Supported options:
+    #
+    # * *:compatibility_mode* serialize in older versions way, without str8 and bin types
+    #
+    # See also Buffer#initialize for other options.
     #
     def initialize(*args)
     end

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

@@ -21,7 +21,6 @@ import org.jcodings.Encoding;
 
 @JRubyClass(name="MessagePack::Buffer")
 public class Buffer extends RubyObject {
-  private RubyHash options;
   private IRubyObject io;
   private ByteBuffer buffer;
   private boolean writeMode;
@@ -46,9 +45,6 @@ public class Buffer extends RubyObject {
       if (args[0].respondsTo("read") && args[0].respondsTo("write")) {
         this.io = args[0];
       }
-      if (args[args.length - 1] instanceof RubyHash) {
-        this.options = (RubyHash) args[args.length - 1];
-      }
     }
     this.buffer = ByteBuffer.allocate(CACHE_LINE_SIZE - ARRAY_HEADER_SIZE);
     this.writeMode = true;

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

@@ -34,14 +34,16 @@ public class Encoder {
   private final Ruby runtime;
   private final Encoding binaryEncoding;
   private final Encoding utf8Encoding;
+  private final boolean compatibilityMode;
 
   private ByteBuffer buffer;
 
-  public Encoder(Ruby runtime) {
+  public Encoder(Ruby runtime, boolean compatibilityMode) {
     this.runtime = runtime;
     this.buffer = ByteBuffer.allocate(CACHE_LINE_SIZE - ARRAY_HEADER_SIZE);
     this.binaryEncoding = runtime.getEncodingService().getAscii8bitEncoding();
     this.utf8Encoding = UTF8Encoding.INSTANCE;
+    this.compatibilityMode = compatibilityMode;
   }
 
   private void ensureRemainingCapacity(int c) {
@@ -190,7 +192,7 @@ public class Encoder {
 
   private void appendString(RubyString object) {
     Encoding encoding = object.getEncoding();
-    boolean binary = encoding == binaryEncoding;
+    boolean binary = !compatibilityMode && encoding == binaryEncoding;
     if (encoding != utf8Encoding && encoding != binaryEncoding) {
       object = (RubyString) ((RubyString) object).encode(runtime.getCurrentContext(), runtime.getEncodingService().getEncoding(utf8Encoding));
     }
@@ -199,7 +201,7 @@ public class Encoder {
     if (length < 32 && !binary) {
       ensureRemainingCapacity(1 + length);
       buffer.put((byte) (length | FIXSTR));
-    } else if (length <= 0xff) {
+    } else if (length <= 0xff && !compatibilityMode) {
       ensureRemainingCapacity(2 + length);
       buffer.put(binary ? BIN8 : STR8);
       buffer.put((byte) length);

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

@@ -32,7 +32,12 @@ public class Packer extends RubyObject {
 
   @JRubyMethod(name = "initialize", optional = 2)
   public IRubyObject initialize(ThreadContext ctx, IRubyObject[] args) {
-    this.encoder = new Encoder(ctx.getRuntime());
+    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();
+    }
+    this.encoder = new Encoder(ctx.getRuntime(), compatibilityMode);
     this.buffer = new Buffer(ctx.getRuntime(), ctx.getRuntime().getModule("MessagePack").getClass("Buffer"));
     this.buffer.initialize(ctx, args);
     return this;

data/ext/msgpack/packer.h

@@ -32,11 +32,15 @@ struct msgpack_packer_t {
 
     VALUE io;
     ID io_write_all_method;
+    bool compatibility_mode;
 
     ID to_msgpack_method;
     VALUE to_msgpack_arg;
 
     VALUE buffer_ref;
+
+    /* options */
+    bool comaptibility_mode;
 };
 
 #define PACKER_BUFFER_(pk) (&(pk)->buffer)
@@ -66,6 +70,11 @@ static inline void msgpack_packer_set_io(msgpack_packer_t* pk, VALUE io, ID io_w
 
 void msgpack_packer_reset(msgpack_packer_t* pk);
 
+static inline void msgpack_packer_set_compat(msgpack_packer_t* pk, bool enable)
+{
+    pk->compatibility_mode = enable;
+}
+
 static inline void msgpack_packer_write_nil(msgpack_packer_t* pk)
 {
     msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 1);
@@ -270,7 +279,7 @@ static inline void msgpack_packer_write_raw_header(msgpack_packer_t* pk, unsigne
         msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 1);
         unsigned char h = 0xa0 | (uint8_t) n;
         msgpack_buffer_write_1(PACKER_BUFFER_(pk), h);
-    } else if(n < 256) {
+    } else if(n < 256 && !pk->compatibility_mode) {
         msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 2);
         unsigned char be = (uint8_t) n;
         msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xd9, (const void*)&be, 1);
@@ -358,7 +367,6 @@ static inline bool msgpack_packer_is_utf8_compat_string(VALUE v, int encindex)
 
 static inline void msgpack_packer_write_string_value(msgpack_packer_t* pk, VALUE v)
 {
-    /* TODO encoding conversion? */
     /* actual return type of RSTRING_LEN is long */
     unsigned long len = RSTRING_LEN(v);
     if(len > 0xffffffffUL) {
@@ -368,13 +376,14 @@ static inline void msgpack_packer_write_string_value(msgpack_packer_t* pk, VALUE
 
 #ifdef COMPAT_HAVE_ENCODING
     int encindex = ENCODING_GET(v);
-    if(msgpack_packer_is_binary(v, encindex)) {
+    if(msgpack_packer_is_binary(v, encindex) && !pk->compatibility_mode) {
         /* write ASCII-8BIT string using Binary type */
         msgpack_packer_write_bin_header(pk, (unsigned int)len);
         msgpack_buffer_append_string(PACKER_BUFFER_(pk), v);
     } else {
         /* write UTF-8, US-ASCII, or 7bit-safe ascii-compatible string using String type directly */
-        if(!msgpack_packer_is_utf8_compat_string(v, encindex)) {
+        /* in compatibility mode, packer packs String values as is */
+        if(!pk->compatibility_mode && !msgpack_packer_is_utf8_compat_string(v, encindex)) {
             /* transcode other strings to UTF-8 and write using String type */
             VALUE enc = rb_enc_from_encoding(rb_utf8_encoding()); /* rb_enc_from_encoding_index is not extern */
             v = rb_str_encode(v, enc, 0, Qnil);

data/ext/msgpack/packer_class.c

@@ -87,13 +87,24 @@ static VALUE Packer_initialize(int argc, VALUE* argv, VALUE self)
     }
 
     PACKER(self, pk);
-    MessagePack_Buffer_initialize(PACKER_BUFFER_(pk), io, options);
 
-    // TODO MessagePack_Unpacker_initialize and options
+    MessagePack_Packer_initialize(pk, io, options);
 
     return self;
 }
 
+void MessagePack_Packer_initialize(msgpack_packer_t* pk, VALUE io, VALUE options)
+{
+    MessagePack_Buffer_initialize(PACKER_BUFFER_(pk), io, options);
+
+    if(options != Qnil) {
+        VALUE v;
+
+        v = rb_hash_aref(options, ID2SYM(rb_intern("compatibility_mode")));
+        msgpack_packer_set_compat(pk, RTEST(v));
+    }
+}
+
 static VALUE Packer_buffer(VALUE self)
 {
     PACKER(self, pk);
@@ -221,11 +232,15 @@ VALUE MessagePack_pack(int argc, VALUE* argv)
 
     VALUE self = Packer_alloc(cMessagePack_Packer);
     PACKER(self, pk);
+
+    if (options != Qnil) {
+      pk->compatibility_mode = RTEST(rb_hash_aref(options, ID2SYM(rb_intern("compatibility_mode"))));
+    }
+
     //msgpack_packer_reset(s_packer);
     //msgpack_buffer_reset_io(PACKER_BUFFER_(s_packer));
 
-    MessagePack_Buffer_initialize(PACKER_BUFFER_(pk), io, options);
-    // TODO MessagePack_Unpacker_initialize and options
+    MessagePack_Packer_initialize(pk, io, options);
 
     msgpack_packer_write_value(pk, v);
 

data/ext/msgpack/packer_class.h

@@ -26,5 +26,7 @@ void MessagePack_Packer_module_init(VALUE mMessagePack);
 
 VALUE MessagePack_pack(int argc, VALUE* argv);
 
+void MessagePack_Packer_initialize(msgpack_packer_t* pk, VALUE io, VALUE options);
+
 #endif
 

data/lib/msgpack/version.rb

@@ -1,3 +1,3 @@
 module MessagePack
-	VERSION = "0.6.0"
+	VERSION = "0.6.1"
 end

data/spec/cruby/packer_spec.rb

@@ -116,5 +116,23 @@ describe Packer do
     CustomPack02.new.to_msgpack(s04)
     s04.string.should == [1,2].to_msgpack
   end
+
+  context 'in compatibility mode' do
+    it 'does not use the bin types' do
+      packed = MessagePack.pack('hello'.force_encoding(Encoding::BINARY), compatibility_mode: true)
+      packed.should eq("\xA5hello")
+      packed = MessagePack.pack(('hello' * 100).force_encoding(Encoding::BINARY), compatibility_mode: true)
+      packed.should start_with("\xDA\x01\xF4")
+
+      packer = MessagePack::Packer.new(compatibility_mode: 1)
+      packed = packer.pack(('hello' * 100).force_encoding(Encoding::BINARY))
+      packed.to_str.should start_with("\xDA\x01\xF4")
+    end
+
+    it 'does not use the str8 type' do
+      packed = MessagePack.pack('x' * 32, compatibility_mode: true)
+      packed.should start_with("\xDA\x00\x20")
+    end
+  end
 end
 

data/spec/jruby/msgpack_spec.rb

@@ -36,9 +36,15 @@ describe MessagePack do
       ['negative floats', -2.1, "\xCB\xC0\x00\xCC\xCC\xCC\xCC\xCC\xCD"]
     ],
     'strings' => [
-      ['strings', utf8enc('hello world'), "\xABhello world"],
+      ['tiny strings', utf8enc('hello world'), "\xABhello world"],
+      ['short strings', utf8enc('hello' * 5), "\xB9hellohellohellohellohello"],
       ['empty strings', utf8enc(''), "\xA0"]
     ],
+    'binary strings' => [
+      ['tiny strings', asciienc('hello world'), "\xC4\vhello world"],
+      ['short strings', asciienc('hello' * 5), "\xC4\x19hellohellohellohellohello"],
+      ['empty strings', asciienc(''), "\xC4\x00"]
+    ],
     'arrays' => [
       ['empty arrays', [], "\x90"],
       ['arrays with strings', [utf8enc("hello"), utf8enc("world")], "\x92\xA5hello\xA5world"],
@@ -139,4 +145,18 @@ describe MessagePack do
       packed.index("w\xC3\xA5rld").should_not be_nil
     end
   end
+
+  context 'in compatibility mode' do
+    it 'does not use the bin types' do
+      packed = MessagePack.pack('hello'.force_encoding(Encoding::BINARY), compatibility_mode: true)
+      packed.should eq("\xA5hello")
+      packed = MessagePack.pack(('hello' * 100).force_encoding(Encoding::BINARY), compatibility_mode: true)
+      packed.should start_with("\xDA\x01\xF4")
+    end
+
+    it 'does not use the str8 type' do
+      packed = MessagePack.pack('x' * 32, compatibility_mode: true)
+      packed.should start_with("\xDA\x00\x20")
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: msgpack
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Sadayuki Furuhashi
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-26 00:00:00.000000000 Z
+date: 2015-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler