msgpack 0.7.6-x64-mingw32 → 1.0.0-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7944969d2f07c9241d76086d6fd6530502939e16
-  data.tar.gz: f14bfc95cf633b41d8aed27e5276cc9528af7efe
+  metadata.gz: a8fc0b1cda291d95b4bbd36e756affa017689c30
+  data.tar.gz: eed3786878debaaa858254407cc00c37206103e0
 SHA512:
-  metadata.gz: 3cf9f8ae071ad62407ab4a9272d6e6b1767e4a378797dfe716eacc43310175e7ee6434a11237cb9ca911761c0196903b9e6479fe15e9b6bf7f881441b52e721f
-  data.tar.gz: 5f100e66beb86a6ca8c33f3378e15915602b3eefd8d4060fa7ef642d735f6e3d536b4e44a6934c12c059a7b9a35b757b561a374768a9d5d0f72c7bae11b2d33d
+  metadata.gz: aae0c2ceb7304d2b5ff2023e8a9280afd52ca0b28f7c7118abc6591fe19ac91a0290d29061974315ead4b689697d8d015b9ef10f57413703fdb7ea2efe28b485
+  data.tar.gz: 43d04ccdf06088d505a638225cfb729588654eee8d6dd2f63cfde9b701c8b46ff1e9e3eda2db5c231c8652d33b3a335f2f9e2875904ce77f59ae73f6935351d6

data/ChangeLog

@@ -1,3 +1,8 @@
+2016-07-08 version 1.0.0:
+
+* Fix to be able to pack Symbol with ext types
+* Fix for MRI 2.4 (Integer unification)
+
 2016-05-10 version 0.7.6:
 
 * Fix bug to raise IndexOutOfBoundsException for Bignum value with small int in JRuby

data/README.rdoc

@@ -91,6 +91,36 @@ or event-driven style which works well with EventMachine:
 
 See {API reference}[http://ruby.msgpack.org/MessagePack/Unpacker.html] for details.
 
+= Serializing and deserializing symbols
+
+By default, symbols are serialized as strings:
+
+    packed = :symbol.to_msgpack     # => "\xA6symbol"
+    MessagePack.unpack(packed)      # => "symbol"
+
+This can be customized by registering an extension type for them:
+
+    MessagePack::DefaultFactory.register_type(0x00, Symbol)
+
+    # symbols now survive round trips
+    packed = :symbol.to_msgpack     # => "\xc7\x06\x00symbol"
+    MessagePack.unpack(packed)      # => :symbol
+
+The extension type for symbols is configurable like any other extension type.
+For example, to customize how symbols are packed you can just redefine
+Symbol#to_msgpack_ext. Doing this gives you an option to prevent symbols from
+being serialized altogether by throwing an exception:
+
+    class Symbol
+        def to_msgpack_ext
+            raise "Serialization of symbols prohibited"
+        end
+    end
+
+    MessagePack::DefaultFactory.register_type(0x00, Symbol)
+
+    [1, :symbol, 'string'].to_msgpack  # => RuntimeError: Serialization of symbols prohibited
+
 = Extension Types
 
 Packer and Unpacker support {Extension types of MessagePack}[https://github.com/msgpack/msgpack/blob/master/spec.md#types-extension-type].

data/bench/pack_symbols.rb

@@ -0,0 +1,28 @@
+require 'viiite'
+require 'msgpack'
+
+data = :symbol
+
+Viiite.bench do |b|
+  b.variation_point :branch, `git rev-parse --abbrev-ref HEAD`
+
+  b.range_over([:symbol, :none], :reg_type) do |reg_type|
+    packer = MessagePack::Packer.new
+    packer.register_type(0x00, Symbol, :to_msgpack_ext) if reg_type == :symbol
+
+    b.range_over([100_000, 1_000_000, 10_000_000], :count) do |count|
+      packer.clear
+      b.report(:multi_run) do
+        count.times do
+          packer.pack(data)
+        end
+      end
+
+      packer.clear
+      items_data = [].fill(data, 0, count)
+      b.report(:large_run) do
+        packer.pack(items_data)
+      end
+    end
+  end
+end

data/bench/run_symbols.sh

@@ -0,0 +1,26 @@
+#!/bin/sh
+
+# so master and this branch have the benchmark file in any case
+cp bench/pack_symbols.rb bench/pack_symbols_tmp.rb
+
+benchmark=""
+current_branch=`git rev-parse --abbrev-ref HEAD`
+
+for branch in master $current_branch; do
+    echo "Testing branch $branch"
+    git checkout $branch
+
+    echo "Installing gem..."
+    rake install
+
+    echo "Running benchmark..."
+    if [ "$benchmark" ]; then
+        benchmark+=$'\n'
+    fi
+    benchmark+=$(viiite run bench/pack_symbols_tmp.rb)
+    echo
+done
+
+rm bench/pack_symbols_tmp.rb
+
+echo "$benchmark" | viiite report --regroup bench,reg_type,count,branch

data/doclib/msgpack/core_ext.rb

@@ -1,101 +1,101 @@
 
 class NilClass
   #
-  # Same as MessagePack.to_msgpack(self[, io]).
+  # Same as MessagePack.to_msgpack(self[, packer]).
   #
   # @return [String] serialized data
   #
-  def to_msgpack(io=nil)
+  def to_msgpack(packer=nil)
   end
 end
 
 class TrueClass
   #
-  # Same as MessagePack.to_msgpack(self[, io]).
+  # Same as MessagePack.to_msgpack(self[, packer]).
   #
   # @return [String] serialized data
   #
-  def to_msgpack(io=nil)
+  def to_msgpack(packer=nil)
   end
 end
 
 class FalseClass
   #
-  # Same as MessagePack.to_msgpack(self[, io]).
+  # Same as MessagePack.to_msgpack(self[, packer]).
   #
   # @return [String] serialized data
   #
-  def to_msgpack(io=nil)
+  def to_msgpack(packer=nil)
   end
 end
 
 class Fixnum < Integer
   #
-  # Same as MessagePack.to_msgpack(self[, io]).
+  # Same as MessagePack.to_msgpack(self[, packer]).
   #
   # @return [String] serialized data
   #
-  def to_msgpack(io=nil)
+  def to_msgpack(packer=nil)
   end
 end
 
 class Bignum < Integer
   #
-  # Same as MessagePack.to_msgpack(self[, io]).
+  # Same as MessagePack.to_msgpack(self[, packer]).
   #
   # @return [String] serialized data
   #
-  def to_msgpack(io=nil)
+  def to_msgpack(packer=nil)
   end
 end
 
 class Float < Numeric
   #
-  # Same as MessagePack.to_msgpack(self[, io]).
+  # Same as MessagePack.to_msgpack(self[, packer]).
   #
   # @return [String] serialized data
   #
-  def to_msgpack(io=nil)
+  def to_msgpack(packer=nil)
   end
 end
 
 class String
   #
-  # Same as MessagePack.to_msgpack(self[, io]).
+  # Same as MessagePack.to_msgpack(self[, packer]).
   #
   # @return [String] serialized data
   #
-  def to_msgpack(io=nil)
+  def to_msgpack(packer=nil)
   end
 end
 
 class Array
   #
-  # Same as MessagePack.to_msgpack(self[, io]).
+  # Same as MessagePack.to_msgpack(self[, packer]).
   #
   # @return [String] serialized data
   #
-  def to_msgpack(io=nil)
+  def to_msgpack(packer=nil)
   end
 end
 
 class Hash
   #
-  # Same as MessagePack.to_msgpack(self[, io]).
+  # Same as MessagePack.to_msgpack(self[, packer]).
   #
   # @return [String] serialized data
   #
-  def to_msgpack(io=nil)
+  def to_msgpack(packer=nil)
   end
 end
 
 class Symbol
   #
-  # Same as MessagePack.to_msgpack(self[, io]).
+  # Same as MessagePack.to_msgpack(self[, packer]).
   #
   # @return [String] serialized data
   #
-  def to_msgpack(io=nil)
+  def to_msgpack(packer=nil)
   end
 end
 

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

@@ -38,15 +38,18 @@ public class Encoder {
   private final boolean compatibilityMode;
   private final ExtensionRegistry registry;
 
+  public boolean hasSymbolExtType;
+
   private ByteBuffer buffer;
 
-  public Encoder(Ruby runtime, boolean compatibilityMode, ExtensionRegistry registry) {
+  public Encoder(Ruby runtime, boolean compatibilityMode, ExtensionRegistry registry, boolean hasSymbolExtType) {
     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;
     this.registry = registry;
+    this.hasSymbolExtType = hasSymbolExtType;
   }
 
   public boolean isCompatibilityMode() {
@@ -112,7 +115,11 @@ public class Encoder {
     } else if (object instanceof RubyString) {
       appendString((RubyString) object);
     } else if (object instanceof RubySymbol) {
-      appendString(((RubySymbol) object).asString());
+      if (hasSymbolExtType) {
+        appendOther(object, destination);
+      } else {
+        appendString(((RubySymbol) object).asString());
+      }
     } else if (object instanceof RubyArray) {
       appendArray((RubyArray) object);
     } else if (object instanceof RubyHash) {

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

@@ -24,11 +24,13 @@ import static org.jruby.runtime.Visibility.PRIVATE;
 public class Factory extends RubyObject {
   private final Ruby runtime;
   private final ExtensionRegistry extensionRegistry;
+  private boolean hasSymbolExtType;
 
   public Factory(Ruby runtime, RubyClass type) {
     super(runtime, type);
     this.runtime = runtime;
     this.extensionRegistry = new ExtensionRegistry();
+    this.hasSymbolExtType = false;
   }
 
   static class FactoryAllocator implements ObjectAllocator {
@@ -48,7 +50,7 @@ public class Factory extends RubyObject {
 
   @JRubyMethod(name = "packer", optional = 1)
   public Packer packer(ThreadContext ctx, IRubyObject[] args) {
-    return Packer.newPacker(ctx, extensionRegistry(), args);
+    return Packer.newPacker(ctx, extensionRegistry(), hasSymbolExtType, args);
   }
 
   @JRubyMethod(name = "unpacker", optional = 1)
@@ -112,6 +114,10 @@ public class Factory extends RubyObject {
 
     extensionRegistry.put(extClass, (int) typeId, packerProc, packerArg, unpackerProc, unpackerArg);
 
+    if (extClass == runtime.getSymbol()) {
+      hasSymbolExtType = true;
+    }
+
     return runtime.getNil();
   }
 }

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

@@ -25,15 +25,17 @@ public class Packer extends RubyObject {
   public ExtensionRegistry registry;
   private Buffer buffer;
   private Encoder encoder;
+  private boolean hasSymbolExtType;
 
-  public Packer(Ruby runtime, RubyClass type, ExtensionRegistry registry) {
+  public Packer(Ruby runtime, RubyClass type, ExtensionRegistry registry, boolean hasSymbolExtType) {
     super(runtime, type);
     this.registry = registry;
+    this.hasSymbolExtType = hasSymbolExtType;
   }
 
   static class PackerAllocator implements ObjectAllocator {
     public IRubyObject allocate(Ruby runtime, RubyClass type) {
-      return new Packer(runtime, type, null);
+      return new Packer(runtime, type, null, false);
     }
   }
 
@@ -45,15 +47,19 @@ public class Packer extends RubyObject {
       IRubyObject mode = options.fastARef(ctx.getRuntime().newSymbol("compatibility_mode"));
       compatibilityMode = (mode != null) && mode.isTrue();
     }
-    this.encoder = new Encoder(ctx.getRuntime(), compatibilityMode, registry);
+    if (registry == null) {
+        // registry is null when allocate -> initialize
+        // registry is already initialized (and somthing might be registered) when newPacker from Factory
+        this.registry = new ExtensionRegistry();
+    }
+    this.encoder = new Encoder(ctx.getRuntime(), compatibilityMode, registry, hasSymbolExtType);
     this.buffer = new Buffer(ctx.getRuntime(), ctx.getRuntime().getModule("MessagePack").getClass("Buffer"));
     this.buffer.initialize(ctx, args);
-    this.registry = new ExtensionRegistry();
     return this;
   }
 
-  public static Packer newPacker(ThreadContext ctx, ExtensionRegistry extRegistry, IRubyObject[] args) {
-    Packer packer = new Packer(ctx.getRuntime(), ctx.getRuntime().getModule("MessagePack").getClass("Packer"), extRegistry);
+  public static Packer newPacker(ThreadContext ctx, ExtensionRegistry extRegistry, boolean hasSymbolExtType, IRubyObject[] args) {
+    Packer packer = new Packer(ctx.getRuntime(), ctx.getRuntime().getModule("MessagePack").getClass("Packer"), extRegistry, hasSymbolExtType);
     packer.initialize(ctx, args);
     return packer;
   }
@@ -100,6 +106,11 @@ public class Packer extends RubyObject {
     RubyClass extClass = (RubyClass) klass;
 
     registry.put(extClass, (int) typeId, proc, arg, null, null);
+
+    if (extClass == runtime.getSymbol()) {
+      encoder.hasSymbolExtType = true;
+    }
+
     return runtime.getNil();
   }
 

data/ext/msgpack/core_ext.c

@@ -65,6 +65,17 @@ static VALUE FalseClass_to_msgpack(int argc, VALUE* argv, VALUE self)
     return packer;
 }
 
+static VALUE Integer_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    if (FIXNUM_P(self)) {
+        msgpack_packer_write_fixnum_value(pk, self);
+    } else {
+        msgpack_packer_write_bignum_value(pk, self);
+    }
+    return packer;
+}
+
 static VALUE Fixnum_to_msgpack(int argc, VALUE* argv, VALUE self)
 {
     ENSURE_PACKER(argc, argv, packer, pk);
@@ -132,8 +143,12 @@ void MessagePack_core_ext_module_init()
     rb_define_method(rb_cNilClass,   "to_msgpack", NilClass_to_msgpack, -1);
     rb_define_method(rb_cTrueClass,  "to_msgpack", TrueClass_to_msgpack, -1);
     rb_define_method(rb_cFalseClass, "to_msgpack", FalseClass_to_msgpack, -1);
+#ifdef RUBY_INTEGER_UNIFICATION
+    rb_define_method(rb_cInteger, "to_msgpack", Integer_to_msgpack, -1);
+#else
     rb_define_method(rb_cFixnum, "to_msgpack", Fixnum_to_msgpack, -1);
     rb_define_method(rb_cBignum, "to_msgpack", Bignum_to_msgpack, -1);
+#endif
     rb_define_method(rb_cFloat,  "to_msgpack", Float_to_msgpack, -1);
     rb_define_method(rb_cString, "to_msgpack", String_to_msgpack, -1);
     rb_define_method(rb_cArray,  "to_msgpack", Array_to_msgpack, -1);

data/ext/msgpack/factory_class.c

@@ -32,6 +32,7 @@ typedef struct msgpack_factory_t msgpack_factory_t;
 struct msgpack_factory_t {
     msgpack_packer_ext_registry_t pkrg;
     msgpack_unpacker_ext_registry_t ukrg;
+    bool has_symbol_ext_type;
 };
 
 #define FACTORY(from, name) \
@@ -72,6 +73,8 @@ static VALUE Factory_initialize(int argc, VALUE* argv, VALUE self)
 {
     FACTORY(self, fc);
 
+    fc->has_symbol_ext_type = false;
+
     switch (argc) {
     case 0:
         break;
@@ -95,6 +98,7 @@ VALUE MessagePack_Factory_packer(int argc, VALUE* argv, VALUE self)
 
     msgpack_packer_ext_registry_destroy(&pk->ext_registry);
     msgpack_packer_ext_registry_dup(&fc->pkrg, &pk->ext_registry);
+    pk->has_symbol_ext_type = fc->has_symbol_ext_type;
 
     return packer;
 }
@@ -188,6 +192,10 @@ static VALUE Factory_register_type(int argc, VALUE* argv, VALUE self)
 
     msgpack_packer_ext_registry_put(&fc->pkrg, ext_class, ext_type, packer_proc, packer_arg);
 
+    if (ext_class == rb_cSymbol) {
+        fc->has_symbol_ext_type = true;
+    }
+
     msgpack_unpacker_ext_registry_put(&fc->ukrg, ext_class, ext_type, unpacker_proc, unpacker_arg);
 
     return Qnil;

data/ext/msgpack/packer.c

@@ -121,7 +121,7 @@ void msgpack_packer_write_hash_value(msgpack_packer_t* pk, VALUE v)
 #endif
 }
 
-static void _msgpack_packer_write_other_value(msgpack_packer_t* pk, VALUE v)
+void msgpack_packer_write_other_value(msgpack_packer_t* pk, VALUE v)
 {
     int ext_type;
     VALUE proc = msgpack_packer_ext_registry_lookup(&pk->ext_registry,
@@ -169,7 +169,7 @@ void msgpack_packer_write_value(msgpack_packer_t* pk, VALUE v)
         msgpack_packer_write_float_value(pk, v);
         break;
     default:
-        _msgpack_packer_write_other_value(pk, v);
+        msgpack_packer_write_other_value(pk, v);
     }
 }
 

data/ext/msgpack/packer.h

@@ -32,6 +32,7 @@ struct msgpack_packer_t {
     msgpack_buffer_t buffer;
 
     bool compatibility_mode;
+    bool has_symbol_ext_type;
 
     ID to_msgpack_method;
     VALUE to_msgpack_arg;
@@ -448,7 +449,7 @@ static inline void msgpack_packer_write_string_value(msgpack_packer_t* pk, VALUE
 #endif
 }
 
-static inline void msgpack_packer_write_symbol_value(msgpack_packer_t* pk, VALUE v)
+static inline void msgpack_packer_write_symbol_string_value(msgpack_packer_t* pk, VALUE v)
 {
 #ifdef HAVE_RB_SYM2STR
     /* rb_sym2str is added since MRI 2.2.0 */
@@ -462,6 +463,17 @@ static inline void msgpack_packer_write_symbol_value(msgpack_packer_t* pk, VALUE
 #endif
 }
 
+void msgpack_packer_write_other_value(msgpack_packer_t* pk, VALUE v);
+
+static inline void msgpack_packer_write_symbol_value(msgpack_packer_t* pk, VALUE v)
+{
+    if (pk->has_symbol_ext_type) {
+        msgpack_packer_write_other_value(pk, v);
+    } else {
+        msgpack_packer_write_symbol_string_value(pk, v);
+    }
+}
+
 static inline void msgpack_packer_write_fixnum_value(msgpack_packer_t* pk, VALUE v)
 {
 #ifdef JRUBY

data/ext/msgpack/packer_class.c

@@ -286,6 +286,10 @@ static VALUE Packer_register_type(int argc, VALUE* argv, VALUE self)
 
     msgpack_packer_ext_registry_put(&pk->ext_registry, ext_class, ext_type, proc, arg);
 
+    if (ext_class == rb_cSymbol) {
+        pk->has_symbol_ext_type = true;
+    }
+
     return Qnil;
 }
 

data/ext/msgpack/packer_ext_registry.h

@@ -15,8 +15,8 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
-#ifndef MSGPACK_RUBY_UNPACKER_PACKER_EXT_REGISTRY_H__
-#define MSGPACK_RUBY_UNPACKER_PACKER_EXT_REGISTRY_H__
+#ifndef MSGPACK_RUBY_PACKER_EXT_REGISTRY_H__
+#define MSGPACK_RUBY_PACKER_EXT_REGISTRY_H__
 
 #include "compat.h"
 #include "ruby.h"

data/ext/msgpack/unpacker_ext_registry.h

@@ -15,8 +15,8 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
-#ifndef MSGPACK_RUBY_PACKER_PACKER_EXT_REGISTRY_H__
-#define MSGPACK_RUBY_PACKER_PACKER_EXT_REGISTRY_H__
+#ifndef MSGPACK_RUBY_UNPACKER_EXT_REGISTRY_H__
+#define MSGPACK_RUBY_UNPACKER_EXT_REGISTRY_H__
 
 #include "compat.h"
 #include "ruby.h"

data/lib/msgpack.rb

@@ -15,3 +15,4 @@ end
 require "msgpack/packer"
 require "msgpack/unpacker"
 require "msgpack/factory"
+require "msgpack/symbol"

data/lib/msgpack/symbol.rb

@@ -0,0 +1,9 @@
+class Symbol
+  def to_msgpack_ext
+    [to_s].pack('A*')
+  end
+
+  def self.from_msgpack_ext(data)
+    data.unpack('A*').first.to_sym
+  end
+end

data/lib/msgpack/version.rb

@@ -1,3 +1,3 @@
 module MessagePack
-  VERSION = "0.7.6"
+  VERSION = "1.0.0"
 end

data/spec/factory_spec.rb

@@ -210,6 +210,66 @@ describe MessagePack::Factory do
     end
   end
 
+  describe 'the special treatment of symbols with ext type' do
+    let(:packer) { subject.packer }
+    let(:unpacker) { subject.unpacker }
+
+    def symbol_after_roundtrip
+      packed_symbol = packer.pack(:symbol).to_s
+      unpacker.feed(packed_symbol).unpack
+    end
+
+    context 'if no ext type is registered for symbols' do
+      it 'converts symbols to string' do
+        expect(symbol_after_roundtrip).to eq 'symbol'
+      end
+    end
+
+    context 'if an ext type is registered for symbols' do
+      context 'if using the default serializer' do
+        before { subject.register_type(0x00, ::Symbol) }
+
+        it 'lets symbols survive a roundtrip' do
+          expect(symbol_after_roundtrip).to be :symbol
+        end
+      end
+
+      context 'if using a custom serializer' do
+        before do
+          class Symbol
+            alias_method :to_msgpack_ext_orig, :to_msgpack_ext
+            def to_msgpack_ext
+              self.to_s.codepoints.to_a.pack('n*')
+            end
+          end
+
+          class << Symbol
+            alias_method :from_msgpack_ext_orig, :from_msgpack_ext
+            def from_msgpack_ext(data)
+              data.unpack('n*').map(&:chr).join.to_sym
+            end
+          end
+        end
+
+        before { subject.register_type(0x00, ::Symbol) }
+
+        it 'lets symbols survive a roundtrip' do
+          expect(symbol_after_roundtrip).to be :symbol
+        end
+
+        after do
+          class Symbol
+            alias_method :to_msgpack_ext, :to_msgpack_ext_orig
+          end
+
+          class << Symbol
+            alias_method :from_msgpack_ext, :from_msgpack_ext_orig
+          end
+        end
+      end
+    end
+  end
+
   describe 'DefaultFactory' do
     it 'is a factory' do
       MessagePack::DefaultFactory.should be_kind_of(MessagePack::Factory)

data/spec/packer_spec.rb

@@ -323,6 +323,42 @@ describe MessagePack::Packer do
       expect(two[:class]).to eq(ValueTwo)
       expect(two[:packer]).to eq(:to_msgpack_ext)
     end
+
+    context 'when registering a type for symbols' do
+      before { packer.register_type(0x00, ::Symbol, :to_msgpack_ext) }
+
+      it 'packs symbols in an ext type' do
+        expect(packer.pack(:symbol).to_s).to eq "\xc7\x06\x00symbol"
+      end
+    end
+  end
+
+  describe "fixnum and bignum" do
+    it "fixnum.to_msgpack" do
+      23.to_msgpack.should == "\x17"
+    end
+
+    it "fixnum.to_msgpack(packer)" do
+      23.to_msgpack(packer)
+      packer.to_s.should == "\x17"
+    end
+
+    it "bignum.to_msgpack" do
+      -4294967296.to_msgpack.should == "\xD3\xFF\xFF\xFF\xFF\x00\x00\x00\x00"
+    end
+
+    it "bignum.to_msgpack(packer)" do
+      -4294967296.to_msgpack(packer)
+      packer.to_s.should == "\xD3\xFF\xFF\xFF\xFF\x00\x00\x00\x00"
+    end
+
+    it "unpack(fixnum)" do
+      MessagePack.unpack("\x17").should == 23
+    end
+
+    it "unpack(bignum)" do
+      MessagePack.unpack("\xD3\xFF\xFF\xFF\xFF\x00\x00\x00\x00").should == -4294967296
+    end
   end
 
   describe "ext formats" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: msgpack
 version: !ruby/object:Gem::Version
-  version: 0.7.6
+  version: 1.0.0
 platform: x64-mingw32
 authors:
 - Sadayuki Furuhashi
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-10 00:00:00.000000000 Z
+date: 2016-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -133,8 +133,10 @@ files:
 - bench/pack.rb
 - bench/pack_log.rb
 - bench/pack_log_long.rb
+- bench/pack_symbols.rb
 - bench/run.sh
 - bench/run_long.sh
+- bench/run_symbols.sh
 - bench/unpack.rb
 - bench/unpack_log.rb
 - bench/unpack_log_long.rb
@@ -193,6 +195,7 @@ files:
 - lib/msgpack/2.3/msgpack.so
 - lib/msgpack/factory.rb
 - lib/msgpack/packer.rb
+- lib/msgpack/symbol.rb
 - lib/msgpack/unpacker.rb
 - lib/msgpack/version.rb
 - msgpack.gemspec