msgpack 1.8.3 → 1.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed5705d96741dbe59f61d59de79d133dfead8636cbf8c9db51b684c425a52e34
-  data.tar.gz: 6fa2a89acb1a2ae0db5068fa59b483d2292e0b9ad681f9c3c058cf164dd28385
+  metadata.gz: 9a5462dff41bc8885570f42b59092d6e02729500a9a873aa15ead68ed8872ccb
+  data.tar.gz: 3fcc99b85b8ece0dd0158f2ee511784a789f41ab9d3bafd9f6fc006ccd3b9061
 SHA512:
-  metadata.gz: 8edfe983aaee5230a1c1547e45894403c9c4435a65bbe4d88b4e9a800bb31467ad867526f4d54baf2cd6b7738cd9458104fc0caa772bba0dcbcb25c427002218
-  data.tar.gz: 3d282debd040b4f9b0f2a15c2c34068b64d01c696d1756f235c63078e54d5fcc2d1896f1b32321aa2c70ec67b8205eb608e841aff60eecd78a651e614016eac3
+  metadata.gz: 3cb8969960d3d2de3beb39503cb33259ac169f27397d75f981a2563bf14700e4359ca30f2fc6357bf848b707546dc0c692385250c186496e2ef7d5546809bab3
+  data.tar.gz: 5cb7b9154e12839ee504c5630d3cee504558206ea63fb54236fc7433191a763267a7fce29a43157d59507f0cc1d4b5b88ba62607571ce98ca1175aa911c1c338

data/ChangeLog

@@ -1,3 +1,16 @@
+2026-09-11 1.8.5
+
+* Prevent stack depth underflow when skipping from recursive unpacker.
+* Fix `Unpacker#skip_nil` to properly consume the buffer.
+* Fix some small difference in Factory registration of the Java implementation.
+* Fix some Factory/ext_type optimization edge cases.
+
+2026-07-28 1.8.4
+
+* Fix `MessagePack::Buffer` to stop using already released memory page.
+  This could have caused data to leak across buffers when using the MessagePack::Buffer API
+  directly.
+
 2026-06-10 1.8.3
 
 * Fix an integer overflow when parsing maps.
@@ -6,7 +19,7 @@
 
 * Fix `Buffer#clear` to properly reset memory chunks before adding them back to the pool.
   This could have caused data to leak across buffers when using the MessagePack::Buffer API
-  directly. [CVE-PENDING].
+  directly. [CVE-2026-54522].
 
 2026-05-28 1.8.1
 

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

@@ -59,6 +59,7 @@ public class Factory extends RubyObject {
     Factory clone = (Factory)super.dup();
     clone.extensionRegistry = extensionRegistry();
     clone.hasSymbolExtType = hasSymbolExtType;
+    clone.hasBigIntExtType = hasBigIntExtType;
     return clone;
   }
 
@@ -110,8 +111,8 @@ public class Factory extends RubyObject {
 
     extensionRegistry.put(extModule, (int) typeId, recursive, packerProc, unpackerProc);
 
-    if (extModule == runtime.getSymbol() && !packerProc.isNil()) {
-      hasSymbolExtType = true;
+    if (extModule == runtime.getSymbol()) {
+      hasSymbolExtType = packerProc != null && !packerProc.isNil();
     }
 
     if (options != null) {
@@ -122,6 +123,8 @@ public class Factory extends RubyObject {
         } else {
           throw runtime.newArgumentError("oversized_integer_extension: true is only for Integer class");
         }
+      } else if (extModule == runtime.getModule("Integer")) {
+        hasBigIntExtType = false;
       }
     }
 

data/ext/msgpack/buffer.c

@@ -127,6 +127,15 @@ void msgpack_buffer_mark(void *ptr)
 
 bool _msgpack_buffer_shift_chunk(msgpack_buffer_t* b)
 {
+    if(b->rmem_owner == &b->head->mem) {
+        /* the chunk that owns the rmem page is going away and takes the page
+         * with it. don't carve the remaining space out of a page that is
+         * already back in the pool. */
+        b->rmem_end = NULL;
+        b->rmem_last = NULL;
+        b->rmem_owner = NULL;
+    }
+
     _msgpack_buffer_chunk_destroy(b->head);
 
     if(b->head == &b->tail) {
@@ -264,6 +273,18 @@ static inline msgpack_buffer_chunk_t* _msgpack_buffer_alloc_new_chunk(msgpack_bu
     return chunk;
 }
 
+/* b->tail is copied into nc and then rebuilt, so the rmem page pointer moves
+ * to nc. the owner has to follow it: if it kept pointing at b->tail.mem, the
+ * transfer in _msgpack_buffer_chunk_malloc would degenerate into a
+ * self-assignment and the page would be released by nc while the rebuilt tail
+ * is still reading from it. */
+static inline void _msgpack_buffer_transfer_rmem_owner(msgpack_buffer_t* b, msgpack_buffer_chunk_t* nc)
+{
+    if(b->rmem_owner == &b->tail.mem) {
+        b->rmem_owner = &nc->mem;
+    }
+}
+
 static inline void _msgpack_buffer_add_new_chunk(msgpack_buffer_t* b)
 {
     if(b->head == &b->tail) {
@@ -275,6 +296,7 @@ static inline void _msgpack_buffer_add_new_chunk(msgpack_buffer_t* b)
         msgpack_buffer_chunk_t* nc = _msgpack_buffer_alloc_new_chunk(b);
 
         *nc = b->tail;
+        _msgpack_buffer_transfer_rmem_owner(b, nc);
         b->head = nc;
         nc->next = &b->tail;
 
@@ -295,6 +317,7 @@ static inline void _msgpack_buffer_add_new_chunk(msgpack_buffer_t* b)
 
         /* rebuild tail */
         *nc = b->tail;
+        _msgpack_buffer_transfer_rmem_owner(b, nc);
         before_tail->next = nc;
         nc->next = &b->tail;
     }

data/ext/msgpack/factory_class.c

@@ -121,7 +121,10 @@ static VALUE Factory_dup(VALUE self)
     msgpack_factory_t *fc = Factory_get(self);
     msgpack_factory_t *cloned_fc = Factory_get(clone);
 
+    cloned_fc->has_bigint_ext_type = fc->has_bigint_ext_type;
     cloned_fc->has_symbol_ext_type = fc->has_symbol_ext_type;
+    cloned_fc->optimized_symbol_ext_type = fc->optimized_symbol_ext_type;
+    cloned_fc->symbol_ext_type = fc->symbol_ext_type;
     cloned_fc->pkrg = fc->pkrg;
     msgpack_unpacker_ext_registry_borrow(fc->ukrg, &cloned_fc->ukrg);
     msgpack_packer_ext_registry_dup(clone, &fc->pkrg, &cloned_fc->pkrg);
@@ -230,12 +233,13 @@ static VALUE Factory_register_type_internal(VALUE self, VALUE rb_ext_type, VALUE
     }
 
     if(ext_module == rb_cSymbol) {
-        if(NIL_P(options) || RTEST(rb_hash_aref(options, ID2SYM(rb_intern("packer"))))) {
-            fc->has_symbol_ext_type = true;
-        }
-        if(RTEST(options) && RTEST(rb_hash_aref(options, ID2SYM(rb_intern("optimized_symbols_parsing"))))) {
-            fc->optimized_symbol_ext_type = true;
-        }
+        fc->symbol_ext_type = ext_type;
+        fc->has_symbol_ext_type = NIL_P(options) || RTEST(packer_proc);
+        fc->optimized_symbol_ext_type = RTEST(options) && RTEST(rb_hash_aref(options, ID2SYM(rb_intern("optimized_symbols_parsing"))));
+    }
+
+    if(ext_module == rb_cInteger) {
+        fc->has_bigint_ext_type = false;
     }
 
     if(RTEST(options)) {
@@ -246,7 +250,6 @@ static VALUE Factory_register_type_internal(VALUE self, VALUE rb_ext_type, VALUE
                 rb_raise(rb_eArgError, "oversized_integer_extension: true is only for Integer class");
             }
         }
-
         if(RTEST(rb_hash_aref(options, ID2SYM(rb_intern("recursive"))))) {
             flags |= MSGPACK_EXT_RECURSIVE;
         }

data/ext/msgpack/packer.h

@@ -25,11 +25,6 @@
 #define MSGPACK_PACKER_IO_FLUSH_THRESHOLD_TO_WRITE_STRING_BODY (1024)
 #endif
 
-#ifndef UNREACHABLE_RETURN
-// Ruby 2.5
-#define UNREACHABLE_RETURN() return
-#endif
-
 struct msgpack_packer_t;
 typedef struct msgpack_packer_t msgpack_packer_t;
 
@@ -418,7 +413,6 @@ static inline void msgpack_packer_write_string_value(msgpack_packer_t* pk, VALUE
 
     if(RB_UNLIKELY(len > 0xffffffffL)) {
         rb_raise(rb_eArgError, "size of string is too long to pack: %lu bytes should be <= %ld", len, 0xffffffffL);
-        UNREACHABLE_RETURN();
     }
 
     if (RB_UNLIKELY(pk->compatibility_mode)) {

data/ext/msgpack/packer_class.c

@@ -235,7 +235,7 @@ static VALUE Packer_write_extension(VALUE self, VALUE obj)
 
     VALUE rb_ext_type = RSTRUCT_GET(obj, 0);
     if(!RB_TYPE_P(rb_ext_type, T_FIXNUM)) {
-        rb_raise(rb_eRangeError, "integer %s too big to convert to `signed char'", RSTRING_PTR(rb_String(rb_ext_type)));
+        rb_raise(rb_eRangeError, "integer %"PRIsVALUE" too big to convert to `signed char'", rb_ext_type);
     }
 
     int ext_type = FIX2INT(rb_ext_type);

data/ext/msgpack/unpacker.c

@@ -211,7 +211,7 @@ static inline int object_complete(msgpack_unpacker_t* uk, VALUE object)
     return PRIMITIVE_OBJECT_COMPLETE;
 }
 
-static inline int object_complete_symbol(msgpack_unpacker_t* uk, VALUE object)
+static inline int object_complete_frozen(msgpack_unpacker_t* uk, VALUE object)
 {
     uk->last_object = object;
     reset_head_byte(uk);
@@ -222,9 +222,9 @@ static inline int object_complete_ext(msgpack_unpacker_t* uk, int ext_type, VALU
 {
     if (uk->optimized_symbol_ext_type && ext_type == uk->symbol_ext_type) {
         if (RB_UNLIKELY(NIL_P(str))) { // empty extension is returned as Qnil
-            return object_complete_symbol(uk, ID2SYM(rb_intern3("", 0, rb_utf8_encoding())));
+            return object_complete_frozen(uk, ID2SYM(rb_intern3("", 0, rb_utf8_encoding())));
         }
-        return object_complete_symbol(uk, rb_str_intern(str));
+        return object_complete_frozen(uk, rb_str_intern(str));
     }
 
     int ext_flags;
@@ -378,10 +378,23 @@ static inline int read_raw_body_begin(msgpack_unpacker_t* uk, int raw_type)
             reset_head_byte(uk);
             uk->reading_raw_remaining = 0;
 
-            _msgpack_unpacker_stack_push(uk, STACK_TYPE_RECURSIVE, 1, Qnil);
+            if(_msgpack_unpacker_stack_push(uk, STACK_TYPE_RECURSIVE, 1, Qnil) < 0) {
+                /* Recursive extensions re-enter msgpack_unpacker_read() through the
+                 * user proc, consuming a full C stack frame per nesting level. If we
+                 * ignore a failed push (stack already at MSGPACK_UNPACKER_STACK_CAPACITY)
+                 * the recursion continues unbounded and exhausts the C stack (SIGSEGV)
+                 * instead of raising StackError like every other container type. */
+                return PRIMITIVE_STACK_TOO_DEEP;
+            }
+            size_t barrier_depth = uk->stack.depth;
             int raised;
             obj = protected_proc_call(proc, 1, &uk->self, &raised);
-            msgpack_unpacker_stack_pop(uk);
+
+            /* The user proc can drive the unpacker itself (Unpacker#read, #skip,
+             * or a rescued error) and leave stack.depth anywhere, including 0.
+             * Restore it to just below the barrier we pushed instead of an
+             * unconditional decrement, which would underflow to SIZE_MAX. */
+            uk->stack.depth = barrier_depth - 1;
 
             if (raised) {
                 uk->last_object = rb_errinfo();
@@ -398,7 +411,7 @@ static inline int read_raw_body_begin(msgpack_unpacker_t* uk, int raw_type)
         int ret;
         if ((uk->optimized_symbol_ext_type && uk->symbol_ext_type == raw_type)) {
             VALUE symbol = msgpack_buffer_read_top_as_symbol(UNPACKER_BUFFER_(uk), length, raw_type != RAW_TYPE_BINARY);
-            ret = object_complete_symbol(uk, symbol);
+            ret = object_complete_frozen(uk, symbol);
         } else if (is_reading_map_key(uk) && raw_type == RAW_TYPE_STRING) {
            /* don't use zerocopy for hash keys but get a frozen string directly
             * because rb_hash_aset freezes keys and it causes copying */
@@ -409,7 +422,7 @@ static inline int read_raw_body_begin(msgpack_unpacker_t* uk, int raw_type)
                 } else {
                     key = msgpack_buffer_read_top_as_symbol(UNPACKER_BUFFER_(uk), length, true);
                 }
-                ret = object_complete_symbol(uk, key);
+                ret = object_complete_frozen(uk, key);
             } else {
                 if (uk->use_key_cache) {
                     key = msgpack_buffer_read_top_as_interned_string(UNPACKER_BUFFER_(uk), &uk->key_cache, length);
@@ -450,10 +463,10 @@ static int read_primitive(msgpack_unpacker_t* uk)
 
     SWITCH_RANGE_BEGIN(b)
     SWITCH_RANGE(b, 0x00, 0x7f)  // Positive Fixnum
-        return object_complete(uk, INT2NUM(b));
+        return object_complete_frozen(uk, INT2NUM(b));
 
     SWITCH_RANGE(b, 0xe0, 0xff)  // Negative Fixnum
-        return object_complete(uk, INT2NUM((int8_t)b));
+        return object_complete_frozen(uk, INT2NUM((int8_t)b));
 
     SWITCH_RANGE(b, 0xa0, 0xbf)  // FixRaw / fixstr
         size_t count = b & 0x1f;
@@ -478,15 +491,15 @@ static int read_primitive(msgpack_unpacker_t* uk)
     SWITCH_RANGE(b, 0xc0, 0xdf)  // Variable
         switch(b) {
         case 0xc0:  // nil
-            return object_complete(uk, Qnil);
+            return object_complete_frozen(uk, Qnil);
 
         //case 0xc1:  // string
 
         case 0xc2:  // false
-            return object_complete(uk, Qfalse);
+            return object_complete_frozen(uk, Qfalse);
 
         case 0xc3:  // true
-            return object_complete(uk, Qtrue);
+            return object_complete_frozen(uk, Qtrue);
 
         case 0xc7: // ext 8
             {
@@ -542,14 +555,14 @@ static int read_primitive(msgpack_unpacker_t* uk)
             {
                 READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 1);
                 uint8_t u8 = cb.u8;
-                return object_complete(uk, INT2NUM((int)u8));
+                return object_complete_frozen(uk, INT2NUM((int)u8));
             }
 
         case 0xcd:  // unsigned int 16
             {
                 READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 2);
                 uint16_t u16 = _msgpack_be16(cb.u16);
-                return object_complete(uk, INT2NUM((int)u16));
+                return object_complete_frozen(uk, INT2NUM((int)u16));
             }
 
         case 0xce:  // unsigned int 32
@@ -570,14 +583,14 @@ static int read_primitive(msgpack_unpacker_t* uk)
             {
                 READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 1);
                 int8_t i8 = cb.i8;
-                return object_complete(uk, INT2NUM((int)i8));
+                return object_complete_frozen(uk, INT2NUM((int)i8));
             }
 
         case 0xd1:  // signed int 16
             {
                 READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 2);
                 int16_t i16 = _msgpack_be16(cb.i16);
-                return object_complete(uk, INT2NUM((int)i16));
+                return object_complete_frozen(uk, INT2NUM((int)i16));
             }
 
         case 0xd2:  // signed int 32
@@ -897,82 +910,6 @@ int msgpack_unpacker_skip(msgpack_unpacker_t* uk, size_t target_stack_depth)
     }
 }
 
-int msgpack_unpacker_peek_next_object_type(msgpack_unpacker_t* uk)
-{
-    int b = get_head_byte(uk);
-    if(b < 0) {
-        return b;
-    }
-
-    SWITCH_RANGE_BEGIN(b)
-    SWITCH_RANGE(b, 0x00, 0x7f)  // Positive Fixnum
-        return TYPE_INTEGER;
-
-    SWITCH_RANGE(b, 0xe0, 0xff)  // Negative Fixnum
-        return TYPE_INTEGER;
-
-    SWITCH_RANGE(b, 0xa0, 0xbf)  // FixRaw
-        return TYPE_RAW;
-
-    SWITCH_RANGE(b, 0x90, 0x9f)  // FixArray
-        return TYPE_ARRAY;
-
-    SWITCH_RANGE(b, 0x80, 0x8f)  // FixMap
-        return TYPE_MAP;
-
-    SWITCH_RANGE(b, 0xc0, 0xdf)  // Variable
-        switch(b) {
-        case 0xc0:  // nil
-            return TYPE_NIL;
-
-        case 0xc2:  // false
-        case 0xc3:  // true
-            return TYPE_BOOLEAN;
-
-        case 0xca:  // float
-        case 0xcb:  // double
-            return TYPE_FLOAT;
-
-        case 0xcc:  // unsigned int  8
-        case 0xcd:  // unsigned int 16
-        case 0xce:  // unsigned int 32
-        case 0xcf:  // unsigned int 64
-            return TYPE_INTEGER;
-
-        case 0xd0:  // signed int  8
-        case 0xd1:  // signed int 16
-        case 0xd2:  // signed int 32
-        case 0xd3:  // signed int 64
-            return TYPE_INTEGER;
-
-        case 0xd9:  // raw 8 / str 8
-        case 0xda:  // raw 16 / str 16
-        case 0xdb:  // raw 32 / str 32
-            return TYPE_RAW;
-
-        case 0xc4:  // bin 8
-        case 0xc5:  // bin 16
-        case 0xc6:  // bin 32
-            return TYPE_RAW;
-
-        case 0xdc:  // array 16
-        case 0xdd:  // array 32
-            return TYPE_ARRAY;
-
-        case 0xde:  // map 16
-        case 0xdf:  // map 32
-            return TYPE_MAP;
-
-        default:
-            return PRIMITIVE_INVALID_BYTE;
-        }
-
-    SWITCH_RANGE_DEFAULT
-        return PRIMITIVE_INVALID_BYTE;
-
-    SWITCH_RANGE_END
-}
-
 int msgpack_unpacker_skip_nil(msgpack_unpacker_t* uk)
 {
     int b = get_head_byte(uk);
@@ -980,8 +917,8 @@ int msgpack_unpacker_skip_nil(msgpack_unpacker_t* uk)
         return b;
     }
     if(b == 0xc0) {
+        reset_head_byte(uk);
         return 1;
     }
     return 0;
 }
-

data/ext/msgpack/unpacker.h

@@ -77,16 +77,6 @@ struct msgpack_unpacker_t {
 
 #define UNPACKER_BUFFER_(uk) (&(uk)->buffer)
 
-enum msgpack_unpacker_object_type {
-    TYPE_NIL = 0,
-    TYPE_BOOLEAN,
-    TYPE_INTEGER,
-    TYPE_FLOAT,
-    TYPE_RAW,
-    TYPE_ARRAY,
-    TYPE_MAP,
-};
-
 void msgpack_unpacker_static_init(void);
 
 void msgpack_unpacker_static_destroy(void);
@@ -139,9 +129,6 @@ static inline VALUE msgpack_unpacker_get_last_object(msgpack_unpacker_t* uk)
     return uk->last_object;
 }
 
-
-int msgpack_unpacker_peek_next_object_type(msgpack_unpacker_t* uk);
-
 int msgpack_unpacker_skip_nil(msgpack_unpacker_t* uk);
 
 int msgpack_unpacker_read_array_header(msgpack_unpacker_t* uk, uint32_t* result_size);

data/lib/msgpack/factory.rb

@@ -14,10 +14,12 @@ module MessagePack
           options[:packer] = packer.to_sym.to_proc
         when Method
           options[:packer] = packer.to_proc
-        when packer.respond_to?(:call)
-          options[:packer] = packer.method(:call).to_proc
         else
-          raise ::TypeError, "expected :packer argument to be a callable object, got: #{packer.inspect}"
+          if packer.respond_to?(:call)
+            options[:packer] = packer.method(:call).to_proc
+          else
+            raise ::TypeError, "expected :packer argument to be a callable object, got: #{packer.inspect}"
+          end
         end
 
         case unpacker = options[:unpacker]
@@ -27,10 +29,12 @@ module MessagePack
           options[:unpacker] = klass.method(unpacker).to_proc
         when Method
           options[:unpacker] = unpacker.to_proc
-        when packer.respond_to?(:call)
-          options[:unpacker] = unpacker.method(:call).to_proc
         else
-          raise ::TypeError, "expected :unpacker argument to be a callable object, got: #{unpacker.inspect}"
+          if unpacker.respond_to?(:call)
+            options[:unpacker] = unpacker.method(:call).to_proc
+          else
+            raise ::TypeError, "expected :unpacker argument to be a callable object, got: #{unpacker.inspect}"
+          end
         end
       end
 
@@ -51,7 +55,7 @@ module MessagePack
           type = ary[0]
           packer_proc = ary[1]
           unpacker_proc = nil
-          if unpacker.has_key?(type)
+          if unpacker.has_key?(type) && unpacker[type][0] == klass
             unpacker_proc = unpacker.delete(type)[1]
           end
           list << {type: type, class: klass, packer: packer_proc, unpacker: unpacker_proc}
@@ -85,7 +89,7 @@ module MessagePack
 
     def type_registered?(klass_or_type, selector=:both)
       case klass_or_type
-      when Class
+      when Module
         klass = klass_or_type
         registered_types(selector).any?{|entry| klass <= entry[:class] }
       when Integer

data/lib/msgpack/packer.rb

@@ -23,7 +23,7 @@ module MessagePack
 
     def type_registered?(klass_or_type)
       case klass_or_type
-      when Class
+      when Module
         klass = klass_or_type
         registered_types.any?{|entry| klass <= entry[:class] }
       when Integer

data/lib/msgpack/unpacker.rb

@@ -27,7 +27,7 @@ module MessagePack
 
     def type_registered?(klass_or_type)
       case klass_or_type
-      when Class
+      when Module
         klass = klass_or_type
         registered_types.any?{|entry| klass == entry[:class] }
       when Integer

data/lib/msgpack/version.rb

@@ -1,5 +1,5 @@
 module MessagePack
-  VERSION = "1.8.3"
+  VERSION = "1.8.5"
   # Note for maintainers:
   #  Don't miss building/releasing the JRuby version (rake buld:java)
   #  See "How to build -java rubygems" in README for more details.

data/msgpack.gemspec

@@ -29,13 +29,4 @@ Gem::Specification.new do |s|
     "documentation_uri" => "https://github.com/msgpack/msgpack/blob/master/spec.md",
     "source_code_uri" => "https://github.com/msgpack/msgpack-ruby"
   }
-
-  s.add_development_dependency 'bundler'
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'rake-compiler', ['>= 1.1.9']
-  s.add_development_dependency 'rspec', ['~> 3.3']
-  s.add_development_dependency 'ruby_memcheck'
-  s.add_development_dependency 'yard'
-  s.add_development_dependency 'json'
-  s.add_development_dependency 'benchmark-ips', ['~> 2.10.0']
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: msgpack
 version: !ruby/object:Gem::Version
-  version: 1.8.3
+  version: 1.8.5
 platform: ruby
 authors:
 - Sadayuki Furuhashi
@@ -10,119 +10,7 @@ authors:
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake-compiler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.1.9
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.1.9
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.3'
-- !ruby/object:Gem::Dependency
-  name: ruby_memcheck
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: yard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: json
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: benchmark-ips
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.10.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.10.0
+dependencies: []
 description: MessagePack is a binary-based efficient object serialization library.
   It enables to exchange structured objects between many languages like JSON. But
   unlike JSON, it is very fast and small.
@@ -210,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.12
+rubygems_version: 4.0.16
 specification_version: 4
 summary: MessagePack, a binary-based efficient data interchange format.
 test_files: []