msgpack 0.5.12-x86-mingw32 → 0.6.0pre1-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d89cc8aeefbce6468c2ddbd690bb2ccb4e5213b
-  data.tar.gz: 44a0cfdf2427fc3c6d52f30cc740cb8d80e9f8e9
+  metadata.gz: 5b8cb2059cf2c97ba89464da38b62e22bcdcf68e
+  data.tar.gz: c12418e80eac7d2a7a6a501abe1cb7cc4a168fa5
 SHA512:
-  metadata.gz: cf586cd027ce0da5948cac89665853ff8a408c14dd225d1399f5dbbc53343241eb8bee54971c3486374da73e9a1a7861cf9b08a3572431ddd7ded41a2060ce93
-  data.tar.gz: 5e7679948efc387bd4511c80b490e6a743ae5e87701aec36d9ff2f9307ea34a09ca41651a60dc7f762b5ad9914ccd9ea3d93251708723e6113aa88d698dde0ea
+  metadata.gz: 2899ded84deadd0e46365efaa7464cd6a5ee7fd8a92362eeaa60db9f360ccdaba58d59d6f1682d1e050dc010b7380e33ac470943a3c4c276437e48440e4079d7
+  data.tar.gz: 3c46b4d61e045a6a2ccd52415152b32d8f29460f90d279f5edb5a6c86f7a1f9c890c19ab71a1f20642aa8743d0278d63e79f119e4f7f1ab2f80d2922cb308bbe

data/.gitignore

@@ -4,6 +4,8 @@
 *.gem
 *.class
 *.jar
+doc
+.yardoc
 .bundle
 Gemfile*
 pkg

data/.travis.yml

@@ -1,10 +1,9 @@
 language: ruby
 
 rvm:
-  # - 1.8.7
-  - 1.9.3
   - 2.0.0
-  - 2.1
+  - 2.1.6
+  - 2.2.2
   - ruby-head
   - rbx-2
   - jruby-19mode

data/Dockerfile

@@ -0,0 +1,30 @@
+FROM ubuntu:14.04
+MAINTAINER TAGOMORI Satoshi <tagomoris@gmail.com>
+LABEL Description="Host image to cross-compile msgpack.gem for mingw32" Vendor="MessagePack Organization" Version="1.0"
+
+USER ubuntu
+
+RUN apt-get install autoconf bison build-essential libssl-dev libyaml-dev libreadline6-dev zlib1g-dev libncurses5-dev libffi-dev libgdbm3 libgdbm-dev
+RUN apt-get install gcc-mingw32 mingw-w64
+# RUN git?
+RUN git clone https://github.com/tagomoris/xbuild.git /home/ubuntu/.xbuild
+RUN /home/ubuntu/.xbuild/ruby-install 2.2.2 /home/ubuntu/local/ruby-2.2
+RUN PATH=/home/ubuntu/local/ruby-2.2/bin:$PATH /home/ubuntu/local/ruby-2.2/bin/gem install rake-compiler
+RUN PATH=/home/ubuntu/local/ruby-2.2/bin:$PATH rake-compiler cross-ruby VERSION=2.2.2 EXTS=--without-extensions
+RUN /home/ubuntu/.xbuild/ruby-install 2.1.5 /home/ubuntu/local/ruby-2.1
+RUN PATH=/home/ubuntu/local/ruby-2.1/bin:$PATH /home/ubuntu/local/ruby-2.1/bin/gem install rake-compiler
+RUN PATH=/home/ubuntu/local/ruby-2.1/bin:$PATH rake-compiler cross-ruby VERSION=2.1.5 EXTS=--without-extensions
+RUN /home/ubuntu/.xbuild/ruby-install 2.0.0-p643 /home/ubuntu/local/ruby-2.0
+RUN PATH=/home/ubuntu/local/ruby-2.0/bin:$PATH /home/ubuntu/local/ruby-2.0/bin/gem install rake-compiler
+RUN PATH=/home/ubuntu/local/ruby-2.0/bin:$PATH rake-compiler cross-ruby VERSION=2.0.0-p643 EXTS=--without-extensions
+
+RUN git clone https://github.com/msgpack/msgpack-ruby.git /home/ubuntu/msgpack-ruby
+
+WORKDIR /home/ubuntu/msgpack-ruby
+
+ENV MSGPACK_REPO https://github.com/msgpack/msgpack-ruby.git
+ENV BUILD_BRANCH master
+ENV BUILD_POSITION HEAD
+
+ENTRYPOINT ["/home/ubuntu/msgpack-ruby/cross-build.sh", "/home/ubuntu/local/ruby-2.2", "2.0.0-p643:2.1.5:2.2.2"]
+

data/Rakefile

@@ -52,6 +52,7 @@ else
     ext.ext_dir = 'ext/msgpack'
     ext.cross_compile = true
     ext.lib_dir = File.join(*['lib', 'msgpack', ENV['FAT_DIR']].compact)
+    ext.config_options << '--with-out-ext=fiddle'
     #ext.cross_platform = 'i386-mswin32'
   end
 

data/cross-build.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+cd /home/ubuntu/msgpack-ruby
+git remote add onetime $MSGPACK_REPO
+git checkout master
+git pull onetime $BUILD_BRANCH
+git reset --hard $BUILD_POSITION
+bundle install
+bundle rake cross native gem

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

@@ -199,11 +199,10 @@ public class Encoder {
     if (length < 32 && !binary) {
       ensureRemainingCapacity(1 + length);
       buffer.put((byte) (length | FIXSTR));
-    //TODO: msgpack-ruby original does encode this value as RAW16 (currently should be BIN8/STR8)
-    // } else if (length <= 0xff) {
-    //   ensureRemainingCapacity(2 + length);
-    //   buffer.put(binary ? BIN8 : STR8);
-    //   buffer.put((byte) length);
+    } else if (length <= 0xff) {
+      ensureRemainingCapacity(2 + length);
+      buffer.put(binary ? BIN8 : STR8);
+      buffer.put((byte) length);
     } else if (length <= 0xffff) {
       ensureRemainingCapacity(3 + length);
       buffer.put(binary ? BIN16 : STR16);

data/ext/msgpack/buffer.c

@@ -19,30 +19,35 @@
 #include "buffer.h"
 #include "rmem.h"
 
-#ifdef COMPAT_HAVE_ENCODING  /* see compat.h*/
-int s_enc_ascii8bit;
-#endif
-
 #ifndef HAVE_RB_STR_REPLACE
 static ID s_replace;
 #endif
 
+#ifdef COMPAT_HAVE_ENCODING  /* see compat.h*/
+int msgpack_rb_encindex_utf8;
+int msgpack_rb_encindex_usascii;
+int msgpack_rb_encindex_ascii8bit;
+#endif
+
 #ifndef DISABLE_RMEM
 static msgpack_rmem_t s_rmem;
 #endif
 
 void msgpack_buffer_static_init()
 {
+#ifdef COMPAT_HAVE_ENCODING
+    msgpack_rb_encindex_utf8 = rb_utf8_encindex();
+    msgpack_rb_encindex_usascii = rb_usascii_encindex();
+    msgpack_rb_encindex_ascii8bit = rb_ascii8bit_encindex();
+#endif
+
 #ifndef DISABLE_RMEM
     msgpack_rmem_init(&s_rmem);
 #endif
+
 #ifndef HAVE_RB_STR_REPLACE
     s_replace = rb_intern("replace");
 #endif
-
-#ifdef COMPAT_HAVE_ENCODING
-    s_enc_ascii8bit = rb_ascii8bit_encindex();
-#endif
 }
 
 void msgpack_buffer_static_destroy()
@@ -304,7 +309,7 @@ static inline void _msgpack_buffer_append_reference(msgpack_buffer_t* b, VALUE s
 {
     VALUE mapped_string = rb_str_dup(string);
 #ifdef COMPAT_HAVE_ENCODING
-    ENCODING_SET(mapped_string, s_enc_ascii8bit);
+    ENCODING_SET(mapped_string, msgpack_rb_encindex_ascii8bit);
 #endif
 
     _msgpack_buffer_add_new_chunk(b);
@@ -333,11 +338,11 @@ void _msgpack_buffer_append_long_string(msgpack_buffer_t* b, VALUE string)
     if(b->io != Qnil) {
         msgpack_buffer_flush(b);
 #ifdef COMPAT_HAVE_ENCODING
-        if (ENCODING_GET(string) == s_enc_ascii8bit) {
+        if (ENCODING_GET(string) == msgpack_rb_encindex_ascii8bit) {
             rb_funcall(b->io, b->io_write_all_method, 1, string);
         } else if(!STR_DUP_LIKELY_DOES_COPY(string)) {
             VALUE s = rb_str_dup(string);
-            ENCODING_SET(s, s_enc_ascii8bit);
+            ENCODING_SET(s, msgpack_rb_encindex_ascii8bit);
             rb_funcall(b->io, b->io_write_all_method, 1, s);
         } else {
             msgpack_buffer_append(b, RSTRING_PTR(string), length);

data/ext/msgpack/buffer.h

@@ -49,6 +49,12 @@
 
 #define NO_MAPPED_STRING ((VALUE)0)
 
+#ifdef COMPAT_HAVE_ENCODING  /* see compat.h*/
+extern int msgpack_rb_encindex_utf8;
+extern int msgpack_rb_encindex_usascii;
+extern int msgpack_rb_encindex_ascii8bit;
+#endif
+
 struct msgpack_buffer_chunk_t;
 typedef struct msgpack_buffer_chunk_t msgpack_buffer_chunk_t;
 

data/ext/msgpack/packer.h

@@ -66,7 +66,6 @@ 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_write_nil(msgpack_packer_t* pk)
 {
     msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 1);
@@ -271,6 +270,10 @@ 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) {
+        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);
     } else if(n < 65536) {
         msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 3);
         uint16_t be = _msgpack_be16(n);
@@ -282,6 +285,23 @@ static inline void msgpack_packer_write_raw_header(msgpack_packer_t* pk, unsigne
     }
 }
 
+static inline void msgpack_packer_write_bin_header(msgpack_packer_t* pk, unsigned int n)
+{
+    if(n < 256) {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 1);
+        unsigned char be = (uint8_t) n;
+        msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xc4, (const void*)&be, 1);
+    } else if(n < 65536) {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 3);
+        uint16_t be = _msgpack_be16(n);
+        msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xc5, (const void*)&be, 2);
+    } else {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 5);
+        uint32_t be = _msgpack_be32(n);
+        msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xc6, (const void*)&be, 4);
+    }
+}
+
 static inline void msgpack_packer_write_array_header(msgpack_packer_t* pk, unsigned int n)
 {
     if(n < 16) {
@@ -316,8 +336,25 @@ static inline void msgpack_packer_write_map_header(msgpack_packer_t* pk, unsigne
     }
 }
 
+#ifdef COMPAT_HAVE_ENCODING
+static inline bool msgpack_packer_is_binary(VALUE v, int encindex)
+{
+    return encindex == msgpack_rb_encindex_ascii8bit;
+}
 
-void _msgpack_packer_write_string_to_io(msgpack_packer_t* pk, VALUE string);
+static inline bool msgpack_packer_is_utf8_compat_string(VALUE v, int encindex)
+{
+    return encindex == msgpack_rb_encindex_utf8
+        || encindex == msgpack_rb_encindex_usascii
+#ifdef ENC_CODERANGE_ASCIIONLY
+        /* Because ENC_CODERANGE_ASCIIONLY does not scan string, it may return ENC_CODERANGE_UNKNOWN unlike */
+        /* rb_enc_str_asciionly_p. It is always faster than rb_str_encode if it is available. */
+        /* Very old Rubinius (< v1.3.1) doesn't have ENC_CODERANGE_ASCIIONLY. */
+        || (rb_enc_asciicompat(rb_enc_from_index(encindex)) && ENC_CODERANGE_ASCIIONLY(v))
+#endif
+        ;
+}
+#endif
 
 static inline void msgpack_packer_write_string_value(msgpack_packer_t* pk, VALUE v)
 {
@@ -328,8 +365,28 @@ static inline void msgpack_packer_write_string_value(msgpack_packer_t* pk, VALUE
         // TODO rb_eArgError?
         rb_raise(rb_eArgError, "size of string is too long to pack: %lu bytes should be <= %lu", len, 0xffffffffUL);
     }
+
+#ifdef COMPAT_HAVE_ENCODING
+    int encindex = ENCODING_GET(v);
+    if(msgpack_packer_is_binary(v, encindex)) {
+        /* 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)) {
+            /* 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);
+            len = RSTRING_LEN(v);
+        }
+        msgpack_packer_write_raw_header(pk, (unsigned int)len);
+        msgpack_buffer_append_string(PACKER_BUFFER_(pk), v);
+    }
+#else
     msgpack_packer_write_raw_header(pk, (unsigned int)len);
     msgpack_buffer_append_string(PACKER_BUFFER_(pk), v);
+#endif
 }
 
 static inline void msgpack_packer_write_symbol_value(msgpack_packer_t* pk, VALUE v)

data/ext/msgpack/unpacker.c

@@ -28,19 +28,11 @@
 static msgpack_rmem_t s_stack_rmem;
 #endif
 
-#ifdef COMPAT_HAVE_ENCODING  /* see compat.h*/
-static int s_enc_utf8;
-#endif
-
 void msgpack_unpacker_static_init()
 {
 #ifdef UNPACKER_STACK_RMEM
     msgpack_rmem_init(&s_stack_rmem);
 #endif
-
-#ifdef COMPAT_HAVE_ENCODING
-    s_enc_utf8 = rb_utf8_encindex();
-#endif
 }
 
 void msgpack_unpacker_static_destroy()
@@ -149,9 +141,17 @@ static inline int object_complete(msgpack_unpacker_t* uk, VALUE object)
 
 static inline int object_complete_string(msgpack_unpacker_t* uk, VALUE str)
 {
+#ifdef COMPAT_HAVE_ENCODING
+    ENCODING_SET(str, msgpack_rb_encindex_utf8);
+#endif
+    return object_complete(uk, str);
+}
+
+static inline int object_complete_binary(msgpack_unpacker_t* uk, VALUE str)
+{
 #ifdef COMPAT_HAVE_ENCODING
     // TODO ruby 2.0 has String#b method
-    ENCODING_SET(str, s_enc_utf8);
+    ENCODING_SET(str, msgpack_rb_encindex_ascii8bit);
 #endif
     return object_complete(uk, str);
 }
@@ -258,7 +258,11 @@ static inline int read_raw_body_begin(msgpack_unpacker_t* uk, bool str)
          * because rb_hash_aset freezes keys and it causes copying */
         bool will_freeze = is_reading_map_key(uk);
         VALUE string = msgpack_buffer_read_top_as_string(UNPACKER_BUFFER_(uk), length, will_freeze);
-        object_complete_string(uk, string);
+        if(str == true) {
+            object_complete_string(uk, string);
+        } else {
+            object_complete_binary(uk, string);
+        }
         if(will_freeze) {
             rb_obj_freeze(string);
         }
@@ -427,7 +431,7 @@ static int read_primitive(msgpack_unpacker_t* uk)
                 return read_raw_body_begin(uk, true);
             }
 
-        case 0xdb:  // raw 32 / str 16
+        case 0xdb:  // raw 32 / str 32
             {
                 READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 4);
                 uint32_t count = _msgpack_be32(cb->u32);
@@ -444,7 +448,7 @@ static int read_primitive(msgpack_unpacker_t* uk)
                 READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 1);
                 uint8_t count = cb->u8;
                 if(count == 0) {
-                    return object_complete_string(uk, rb_str_buf_new(0));
+                    return object_complete_binary(uk, rb_str_buf_new(0));
                 }
                 /* read_raw_body_begin sets uk->reading_raw */
                 uk->reading_raw_remaining = count;
@@ -456,7 +460,7 @@ static int read_primitive(msgpack_unpacker_t* uk)
                 READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 2);
                 uint16_t count = _msgpack_be16(cb->u16);
                 if(count == 0) {
-                    return object_complete_string(uk, rb_str_buf_new(0));
+                    return object_complete_binary(uk, rb_str_buf_new(0));
                 }
                 /* read_raw_body_begin sets uk->reading_raw */
                 uk->reading_raw_remaining = count;
@@ -468,7 +472,7 @@ static int read_primitive(msgpack_unpacker_t* uk)
                 READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 4);
                 uint32_t count = _msgpack_be32(cb->u32);
                 if(count == 0) {
-                    return object_complete_string(uk, rb_str_buf_new(0));
+                    return object_complete_binary(uk, rb_str_buf_new(0));
                 }
                 /* read_raw_body_begin sets uk->reading_raw */
                 uk->reading_raw_remaining = count;

data/lib/msgpack/version.rb

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

data/spec/cruby/unpacker_spec.rb

@@ -262,36 +262,42 @@ describe Unpacker do
 
   it "msgpack str 8 type" do
     MessagePack.unpack([0xd9, 0x00].pack('C*')).should == ""
+    MessagePack.unpack([0xd9, 0x00].pack('C*')).encoding.should == Encoding::UTF_8
     MessagePack.unpack([0xd9, 0x01].pack('C*') + 'a').should == "a"
     MessagePack.unpack([0xd9, 0x02].pack('C*') + 'aa').should == "aa"
   end
 
   it "msgpack str 16 type" do
     MessagePack.unpack([0xda, 0x00, 0x00].pack('C*')).should == ""
+    MessagePack.unpack([0xda, 0x00, 0x00].pack('C*')).encoding.should == Encoding::UTF_8
     MessagePack.unpack([0xda, 0x00, 0x01].pack('C*') + 'a').should == "a"
     MessagePack.unpack([0xda, 0x00, 0x02].pack('C*') + 'aa').should == "aa"
   end
 
   it "msgpack str 32 type" do
     MessagePack.unpack([0xdb, 0x00, 0x00, 0x00, 0x00].pack('C*')).should == ""
+    MessagePack.unpack([0xdb, 0x00, 0x00, 0x00, 0x00].pack('C*')).encoding.should == Encoding::UTF_8
     MessagePack.unpack([0xdb, 0x00, 0x00, 0x00, 0x01].pack('C*') + 'a').should == "a"
     MessagePack.unpack([0xdb, 0x00, 0x00, 0x00, 0x02].pack('C*') + 'aa').should == "aa"
   end
 
   it "msgpack bin 8 type" do
     MessagePack.unpack([0xc4, 0x00].pack('C*')).should == ""
+    MessagePack.unpack([0xc4, 0x00].pack('C*')).encoding.should == Encoding::ASCII_8BIT
     MessagePack.unpack([0xc4, 0x01].pack('C*') + 'a').should == "a"
     MessagePack.unpack([0xc4, 0x02].pack('C*') + 'aa').should == "aa"
   end
 
   it "msgpack bin 16 type" do
     MessagePack.unpack([0xc5, 0x00, 0x00].pack('C*')).should == ""
+    MessagePack.unpack([0xc5, 0x00, 0x00].pack('C*')).encoding.should == Encoding::ASCII_8BIT
     MessagePack.unpack([0xc5, 0x00, 0x01].pack('C*') + 'a').should == "a"
     MessagePack.unpack([0xc5, 0x00, 0x02].pack('C*') + 'aa').should == "aa"
   end
 
   it "msgpack bin 32 type" do
     MessagePack.unpack([0xc6, 0x00, 0x00, 0x00, 0x00].pack('C*')).should == ""
+    MessagePack.unpack([0xc6, 0x0, 0x00, 0x00, 0x000].pack('C*')).encoding.should == Encoding::ASCII_8BIT
     MessagePack.unpack([0xc6, 0x00, 0x00, 0x00, 0x01].pack('C*') + 'a').should == "a"
     MessagePack.unpack([0xc6, 0x00, 0x00, 0x00, 0x02].pack('C*') + 'aa').should == "aa"
   end

data/spec/format_spec.rb

@@ -83,8 +83,13 @@ describe MessagePack do
     check_raw 1, (1 << 5)-1
   end
 
+  it "raw 8" do
+    check_raw 2, (1 << 5)
+    check_raw 2, (1 << 8)-1
+  end
+
   it "raw 16" do
-    check_raw 3, (1 << 5)
+    check_raw 3, (1 << 8)
     check_raw 3, (1 << 16)-1
   end
 
@@ -93,6 +98,50 @@ describe MessagePack do
     #check_raw 5, (1 << 32)-1  # memory error
   end
 
+  it "str encoding is UTF_8" do
+    v = pack_unpack('string'.force_encoding(Encoding::UTF_8))
+    v.encoding.should == Encoding::UTF_8
+  end
+
+  it "str transcode US-ASCII" do
+    v = pack_unpack('string'.force_encoding(Encoding::US_ASCII))
+    v.encoding.should == Encoding::UTF_8
+  end
+
+  it "str transcode UTF-16" do
+    v = pack_unpack('string'.encode(Encoding::UTF_16))
+    v.encoding.should == Encoding::UTF_8
+    v.should == 'string'
+  end
+
+  it "str transcode EUC-JP 7bit safe" do
+    v = pack_unpack('string'.force_encoding(Encoding::EUC_JP))
+    v.encoding.should == Encoding::UTF_8
+    v.should == 'string'
+  end
+
+  it "str transcode EUC-JP 7bit unsafe" do
+    v = pack_unpack([0xa4, 0xa2].pack('C*').force_encoding(Encoding::EUC_JP))
+    v.encoding.should == Encoding::UTF_8
+    v.should == "\xE3\x81\x82".force_encoding('UTF-8')
+  end
+
+  it "bin 8" do
+    check_bin 2, (1<<8)-1
+  end
+
+  it "bin 16" do
+    check_bin 3, (1<<16)-1
+  end
+
+  it "bin 32" do
+    check_bin 5, (1<<16)
+  end
+
+  it "bin encoding is ASCII_8BIT" do
+    pack_unpack('string'.force_encoding(Encoding::ASCII_8BIT)).encoding.should == Encoding::ASCII_8BIT
+  end
+
   it "fixarray" do
     check_array 1, 0
     check_array 1, (1 << 4)-1
@@ -210,9 +259,11 @@ describe MessagePack do
   end
 
   def check_raw(overhead, num)
-    rawstr = " "*num
-    rawstr.force_encoding("UTF-8")
-    check num+overhead, rawstr
+    check num+overhead, (" "*num).force_encoding(Encoding::UTF_8)
+  end
+
+  def check_bin(overhead, num)
+    check num+overhead, (" "*num).force_encoding(Encoding::ASCII_8BIT)
   end
 
   def check_array(overhead, num)
@@ -223,5 +274,9 @@ describe MessagePack do
     raw = obj.to_msgpack.to_s
     raw.should == buf
   end
+
+  def pack_unpack(obj)
+    MessagePack.unpack(obj.to_msgpack)
+  end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: msgpack
 version: !ruby/object:Gem::Version
-  version: 0.5.12
+  version: 0.6.0pre1
 platform: x86-mingw32
 authors:
 - Sadayuki Furuhashi
@@ -108,6 +108,7 @@ files:
 - ".gitignore"
 - ".travis.yml"
 - ChangeLog
+- Dockerfile
 - Gemfile
 - LICENSE
 - README.rdoc
@@ -120,6 +121,7 @@ files:
 - bench/unpack.rb
 - bench/unpack_log.rb
 - bench/unpack_log_long.rb
+- cross-build.sh
 - doclib/msgpack.rb
 - doclib/msgpack/buffer.rb
 - doclib/msgpack/core_ext.rb
@@ -195,9 +197,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: msgpack
 rubygems_version: 2.4.5