msgpack 1.2.0-x64-mingw32 → 1.2.2-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e2a428806959220962e2aa9eaf49690efd8d7840
-  data.tar.gz: fa4f22246fdee17bbf61f7de26558e8b51a8adf4
+  metadata.gz: 5c538702864b2148f3bff8a85425ca6892df455f
+  data.tar.gz: 4bf3fb8cc75c99a2301b31bac20b0459ebe4a61a
 SHA512:
-  metadata.gz: 8f213af06850b4b8ee763651863ec19069d21b44e0d84b712f8efb380ec829706e9ac4ea6c975af0db5dc8bf012080e0cdba44324c316586e74d3993c0c15eb3
-  data.tar.gz: f14ce83ae916be26520adea5b3f5dc635be05d9128257de5f1bda134f81f36f03fbcdc68502fc55f6d702d12ffaaf08cefa6127c22bc0b887828a18995e79738
+  metadata.gz: '08b71774df48399761762a2a6b1ff2322523ca7052ac0628f07c2c91638211f999d6269af54f657a9c3858014c0032b325d8979086ca703d2562814930ffbd91'
+  data.tar.gz: 62349e4eda0b1774ccd6020a95222e60f9f1d837b7455ef9b52982e9775074140695de2a4ea0af3c19c54d2d12346e7cc00b49da6f16ecb713e216ffc9aafbc6

data/.travis.yml

@@ -1,20 +1,5 @@
 language: ruby
 
-rvm:
-  - 2.0.0
-  - 2.1.6
-  - 2.2.2
-  - 2.3.0
-  - 2.4.0
-  - ruby-head
-  - jruby-19mode
-  - jruby-9.1.5.0
-  - jruby-head
-
-os:
-  - linux
-  - osx
-
 sudo: false
 
 branches:
@@ -24,18 +9,30 @@ branches:
 gemfile:
   - Gemfile
 
+# http://rubies.travis-ci.org/
 matrix:
-  exclude:
-    - rvm: 2.0.0
-      os: osx
-    - rvm: jruby-19mode
+  include:
+    - rvm: 2.1.10
+      os: linux
+    - rvm: 2.2.8
+      os: linux
+    - rvm: 2.3.5
+      os: linux
+    - rvm: 2.3.5
       os: osx
-    - rvm: jruby-9.1.5.0
+    - rvm: 2.4.2
+      os: linux
+    - rvm: 2.4.2
       os: osx
+    - rvm: ruby-head
+      os: linux
+    - rvm: jruby-9.1.9.0
+      os: linux
     - rvm: jruby-head
-      os: osx
+      os: linux
+    - rvm: jruby-19mode
+      os: linux
   allow_failures:
     - rvm: ruby-head
     - rvm: jruby-head
     - rvm: jruby-19mode
-      os: osx

data/ChangeLog

@@ -1,3 +1,12 @@
+2018-01-11 version 1.2.2:
+
+* Fix bug to occur SEGV occasionally (depends on GC timing) when exttype is used
+* Fix bug to encode an ext type with wrong type id if superclass is also registered as ext type 
+
+2017-12-08 version 1.2.1:
+
+* Hotfix release only for JRuby: 1.2.0-java was built in incorrect way
+
 2017-12-07 version 1.2.0:
 
 * Add MessagePack::Factory#dump and MessagePack::Factory#load as convenient methods

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

@@ -384,7 +384,7 @@ public class Encoder {
         lookupClass = object.getSingletonClass();
       }
 
-      IRubyObject[] pair = registry.lookupPackerByModule(lookupClass);
+      IRubyObject[] pair = registry.lookupPackerForObject(object);
       if (pair != null) {
         RubyString bytes = pair[0].callMethod(runtime.getCurrentContext(), "call", object).asString();
         int type = (int) ((RubyFixnum) pair[1]).getLongValue();

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

@@ -5,6 +5,7 @@ import org.jruby.RubyHash;
 import org.jruby.RubyArray;
 import org.jruby.RubyModule;
 import org.jruby.RubyFixnum;
+import org.jruby.RubySymbol;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
@@ -74,22 +75,50 @@ public class ExtensionRegistry {
     }
   }
 
-  public IRubyObject[] lookupPackerByModule(RubyModule mod) {
+  public IRubyObject[] lookupPackerForObject(IRubyObject object) {
+    RubyModule lookupClass = null;
+    IRubyObject[] pair;
+    /*
+     * Objects of type Integer (Fixnum, Bignum), Float, Symbol and frozen
+     * String have no singleton class and raise a TypeError when trying to get
+     * it.
+     *
+     * Since all but symbols are already filtered out when reaching this code
+     * only symbols are checked here.
+     */
+    if (!(object instanceof RubySymbol)) {
+      lookupClass = object.getSingletonClass();
+      pair = fetchEntryByModule(lookupClass);
+      if (pair != null) {
+          return pair;
+      }
+    }
+
+    pair = fetchEntryByModule(object.getType());
+    if (pair != null) {
+      return pair;
+    }
+
+    if (lookupClass == null) {
+      lookupClass = object.getType(); // only for Symbol
+    }
+    ExtensionEntry e = findEntryByModuleOrAncestor(lookupClass);
+    if (e != null && e.hasPacker()) {
+      extensionsByAncestor.put(e.getExtensionModule(), e);
+      return e.toPackerProcTypeIdPair(lookupClass.getRuntime().getCurrentContext());
+    }
+    return null;
+  }
+
+  private IRubyObject[] fetchEntryByModule(final RubyModule mod) {
     ExtensionEntry e = extensionsByModule.get(mod);
     if (e == null) {
       e = extensionsByAncestor.get(mod);
     }
-    if (e == null) {
-      e = findEntryByModuleOrAncestor(mod);
-      if (e != null) {
-        extensionsByAncestor.put(e.getExtensionModule(), e);
-      }
-    }
     if (e != null && e.hasPacker()) {
       return e.toPackerProcTypeIdPair(mod.getRuntime().getCurrentContext());
-    } else {
-      return null;
     }
+    return null;
   }
 
   private ExtensionEntry findEntryByModuleOrAncestor(final RubyModule mod) {

data/ext/msgpack/buffer_class.c

@@ -54,7 +54,7 @@ static void Buffer_free(void* data)
 
 static VALUE Buffer_alloc(VALUE klass)
 {
-    msgpack_buffer_t* b = ALLOC_N(msgpack_buffer_t, 1);
+    msgpack_buffer_t* b = ZALLOC_N(msgpack_buffer_t, 1);
     msgpack_buffer_init(b);
 
     return Data_Wrap_Struct(klass, msgpack_buffer_mark, Buffer_free, b);

data/ext/msgpack/compat.h

@@ -28,6 +28,16 @@
 #endif
 
 
+/*
+ * ZALLOC_N (ruby 2.2 or later)
+ */
+#ifndef RB_ZALLOC_N
+#  define RB_ZALLOC_N(type,n) ((type*)ruby_xcalloc((size_t)(n),sizeof(type)))
+#endif
+#ifndef ZALLOC_N
+#  define ZALLOC_N(type,n) RB_ZALLOC_N(type,n)
+#endif
+
 /*
  * COMPAT_HAVE_ENCODING
  */

data/ext/msgpack/factory_class.c

@@ -59,10 +59,7 @@ void Factory_mark(msgpack_factory_t* fc)
 
 static VALUE Factory_alloc(VALUE klass)
 {
-    msgpack_factory_t* fc = ALLOC_N(msgpack_factory_t, 1);
-
-    msgpack_packer_ext_registry_init(&fc->pkrg);
-    msgpack_unpacker_ext_registry_init(&fc->ukrg);
+    msgpack_factory_t* fc = ZALLOC_N(msgpack_factory_t, 1);
 
     VALUE self = Data_Wrap_Struct(klass, Factory_mark, Factory_free, fc);
     return self;
@@ -72,6 +69,9 @@ static VALUE Factory_initialize(int argc, VALUE* argv, VALUE self)
 {
     FACTORY(self, fc);
 
+    msgpack_packer_ext_registry_init(&fc->pkrg);
+    msgpack_unpacker_ext_registry_init(&fc->ukrg);
+
     fc->has_symbol_ext_type = false;
 
     switch (argc) {

data/ext/msgpack/packer.c

@@ -125,25 +125,7 @@ void msgpack_packer_write_other_value(msgpack_packer_t* pk, VALUE v)
 {
     int ext_type;
 
-    VALUE lookup_class;
-
-    /*
-     * Objects of type Integer (Fixnum, Bignum), Float, Symbol and frozen
-     * String have no singleton class and raise a TypeError when trying to get
-     * it. See implementation of #singleton_class in ruby's source code:
-     * VALUE rb_singleton_class(VALUE obj);
-     *
-     * Since all but symbols are already filtered out when reaching this code
-     * only symbols are checked here.
-     */
-    if (SYMBOL_P(v)) {
-      lookup_class = rb_obj_class(v);
-    } else {
-      lookup_class = rb_singleton_class(v);
-    }
-
-    VALUE proc = msgpack_packer_ext_registry_lookup(&pk->ext_registry, lookup_class,
-      &ext_type);
+    VALUE proc = msgpack_packer_ext_registry_lookup(&pk->ext_registry, v, &ext_type);
 
     if(proc != Qnil) {
         VALUE payload = rb_funcall(proc, s_call, 1, v);

data/ext/msgpack/packer_class.c

@@ -56,14 +56,12 @@ static void Packer_mark(msgpack_packer_t* pk)
 
 VALUE MessagePack_Packer_alloc(VALUE klass)
 {
-    msgpack_packer_t* pk = ALLOC_N(msgpack_packer_t, 1);
+    msgpack_packer_t* pk = ZALLOC_N(msgpack_packer_t, 1);
     msgpack_packer_init(pk);
 
     VALUE self = Data_Wrap_Struct(klass, Packer_mark, Packer_free, pk);
 
     msgpack_packer_set_to_msgpack_method(pk, s_to_msgpack, self);
-    msgpack_packer_ext_registry_init(&pk->ext_registry);
-    pk->buffer_ref = MessagePack_Buffer_wrap(PACKER_BUFFER_(pk), self);
 
     return self;
 }
@@ -97,6 +95,9 @@ VALUE MessagePack_Packer_initialize(int argc, VALUE* argv, VALUE self)
 
     PACKER(self, pk);
 
+    msgpack_packer_ext_registry_init(&pk->ext_registry);
+    pk->buffer_ref = MessagePack_Buffer_wrap(PACKER_BUFFER_(pk), self);
+
     MessagePack_Buffer_set_options(PACKER_BUFFER_(pk), io, options);
 
     if(options != Qnil) {

data/ext/msgpack/packer_ext_registry.h

@@ -59,24 +59,64 @@ static int msgpack_packer_ext_find_superclass(VALUE key, VALUE value, VALUE arg)
     return ST_CONTINUE;
 }
 
-
-static inline VALUE msgpack_packer_ext_registry_lookup(msgpack_packer_ext_registry_t* pkrg,
+static inline VALUE msgpack_packer_ext_registry_fetch(msgpack_packer_ext_registry_t* pkrg,
         VALUE lookup_class, int* ext_type_result)
 {
+    // fetch lookup_class from hash, which is a hash to register classes
     VALUE type = rb_hash_lookup(pkrg->hash, lookup_class);
     if(type != Qnil) {
         *ext_type_result = FIX2INT(rb_ary_entry(type, 0));
         return rb_ary_entry(type, 1);
     }
 
+    // fetch lookup_class from cache, which stores results of searching ancestors from pkrg->hash
     VALUE type_inht = rb_hash_lookup(pkrg->cache, lookup_class);
     if(type_inht != Qnil) {
         *ext_type_result = FIX2INT(rb_ary_entry(type_inht, 0));
         return rb_ary_entry(type_inht, 1);
     }
 
+    return Qnil;
+}
+
+static inline VALUE msgpack_packer_ext_registry_lookup(msgpack_packer_ext_registry_t* pkrg,
+        VALUE instance, int* ext_type_result)
+{
+    VALUE lookup_class;
+    VALUE type;
+
+    /*
+     * 1. check whether singleton_class of this instance is registered (or resolved in past) or not.
+     *
+     * Objects of type Integer (Fixnum, Bignum), Float, Symbol and frozen
+     * String have no singleton class and raise a TypeError when trying to get
+     * it. See implementation of #singleton_class in ruby's source code:
+     * VALUE rb_singleton_class(VALUE obj);
+     *
+     * Since all but symbols are already filtered out when reaching this code
+     * only symbols are checked here.
+     */
+    if (!SYMBOL_P(instance)) {
+      lookup_class = rb_singleton_class(instance);
+
+      type = msgpack_packer_ext_registry_fetch(pkrg, lookup_class, ext_type_result);
+
+      if(type != Qnil) {
+          return type;
+      }
+    }
+
+    /*
+     * 2. check the class of instance is registered (or resolved in past) or not.
+     */
+    type = msgpack_packer_ext_registry_fetch(pkrg, rb_obj_class(instance), ext_type_result);
+
+    if(type != Qnil) {
+        return type;
+    }
+
     /*
-     * check all keys whether it is an ancestor of lookup_class, or not
+     * 3. check all keys whether it is an ancestor of lookup_class, or not
      */
     VALUE args[2];
     args[0] = lookup_class;

data/ext/msgpack/unpacker_class.c

@@ -58,14 +58,10 @@ static void Unpacker_mark(msgpack_unpacker_t* uk)
 
 VALUE MessagePack_Unpacker_alloc(VALUE klass)
 {
-    msgpack_unpacker_t* uk = ALLOC_N(msgpack_unpacker_t, 1);
+    msgpack_unpacker_t* uk = ZALLOC_N(msgpack_unpacker_t, 1);
     _msgpack_unpacker_init(uk);
 
     VALUE self = Data_Wrap_Struct(klass, Unpacker_mark, Unpacker_free, uk);
-
-    msgpack_unpacker_ext_registry_init(&uk->ext_registry);
-    uk->buffer_ref = MessagePack_Buffer_wrap(UNPACKER_BUFFER_(uk), self);
-
     return self;
 }
 
@@ -101,6 +97,9 @@ VALUE MessagePack_Unpacker_initialize(int argc, VALUE* argv, VALUE self)
 
     UNPACKER(self, uk);
 
+    msgpack_unpacker_ext_registry_init(&uk->ext_registry);
+    uk->buffer_ref = MessagePack_Buffer_wrap(UNPACKER_BUFFER_(uk), self);
+
     MessagePack_Buffer_set_options(UNPACKER_BUFFER_(uk), io, options);
 
     if(options != Qnil) {

data/lib/msgpack/version.rb

@@ -1,3 +1,3 @@
 module MessagePack
-  VERSION = "1.2.0"
+  VERSION = "1.2.2"
 end

data/spec/factory_spec.rb

@@ -331,6 +331,19 @@ describe MessagePack::Factory do
     end
   end
 
+  describe 'under stressful GC' do
+    it 'works well' do
+      begin
+        GC.stress = true
+
+        f = MessagePack::Factory.new
+        f.register_type(0x0a, Symbol)
+      ensure
+        GC.stress = false
+      end
+    end
+  end
+
   describe 'DefaultFactory' do
     it 'is a factory' do
       MessagePack::DefaultFactory.should be_kind_of(MessagePack::Factory)

data/spec/packer_spec.rb

@@ -372,6 +372,50 @@ describe MessagePack::Packer do
       end
     end
 
+    context 'when it and its super class has an ext type' do
+      before { stub_const('Value', Class.new) }
+      before do
+        Value.class_eval do
+          def to_msgpack_ext
+            'value_msgpacked'
+          end
+        end
+      end
+      before { packer.register_type(0x01, Value, :to_msgpack_ext) }
+
+      context "when it is a child class" do
+        before { stub_const('InheritedValue', Class.new(Value)) }
+        before do
+          InheritedValue.class_eval do
+            def to_msgpack_ext
+              'inherited_value_msgpacked'
+            end
+          end
+        end
+
+        before { packer.register_type(0x02, InheritedValue, :to_msgpack_ext) }
+        subject { packer.pack(InheritedValue.new).to_s }
+
+        it { is_expected.to eq "\xC7\x19\x02inherited_value_msgpacked" }
+      end
+
+      context "even when it is a child class" do
+        before { stub_const('InheritedValue', Class.new(Value)) }
+        before do
+          InheritedValue.class_eval do
+            def to_msgpack_ext
+              'inherited_value_msgpacked'
+            end
+          end
+        end
+
+        before { packer.register_type(0x02, InheritedValue, :to_msgpack_ext) }
+        subject { packer.pack(Value.new).to_s }
+
+        it { is_expected.to eq "\xC7\x0F\x01value_msgpacked" }
+      end
+    end
+
     context 'when it has no ext type but an included module has' do
       subject { packer.pack(Value.new).to_s }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: msgpack
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.2
 platform: x64-mingw32
 authors:
 - Sadayuki Furuhashi
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-07 00:00:00.000000000 Z
+date: 2018-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -246,7 +246,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: msgpack
-rubygems_version: 2.6.12
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: MessagePack, a binary-based efficient data interchange format.