msgpack 1.4.5 → 1.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a51f64e1c017cafcef6fe080992135f5c610984ecd126f4a3a2127baa4e4a644
-  data.tar.gz: bf45726e8f6cb658390199ecb51345e034c908207b090d53934f037555d7c37a
+  metadata.gz: 9c3bd9f87eaddd3212797209da93c4ec3a1c2384cb4a41e0ea9feb48a75523f2
+  data.tar.gz: 16d6223c1c98f50e629c029f077383cbbd7cd194af038255fd28d37aeecbb39a
 SHA512:
-  metadata.gz: 0ee24ab0cb11c648e9a022f23053c118c020b7c79cac14e00a1bb82faf90c59302727a2dc691c63a959225b06a5c40ec5e09fd8f35154c7474b1e652e27b9bc5
-  data.tar.gz: 2fee550949875cc119f1865b9519c75794124ec17065b1da1ec0fd06af29ed7fbdd37d709bf8cdb217d3cf86e3004a18fab16a6ac032eec176735725439ec268
+  metadata.gz: 6d4bd9048f852ac4c6e1365b07e6a8df9869cd0d9b2ce2c8bff7c836fe3e513451cf8895b36a719d09beaafdb85101363b705da719e5e9e9c7361ee1de96f2cf
+  data.tar.gz: a15ac8e77af9dc0ccb06ed266efe1ff93a2bae78e2ab5b980ba87af486d08e34676f9203fbc6b646b3c7f14e2fbdf7d4e9e1892fd58d0ca214a39de0dd2ee345

data/.github/workflows/ci.yaml

@@ -25,12 +25,12 @@ jobs:
           bundler-cache: true # 'bundle install' and cache
       - run: bundle exec rake
 
-  jruby:
+  other:
     strategy:
       fail-fast: false
       matrix:
         os: [ubuntu]
-        ruby: ['jruby-9.2.19.0', 'jruby-9.3.3.0']
+        ruby: ['jruby-9.2.19.0', 'jruby-9.3.3.0', 'truffleruby']
     runs-on: ${{ matrix.os }}-latest
     steps:
       - uses: actions/checkout@v2
@@ -38,7 +38,7 @@ jobs:
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true # 'bundle install' and cache
-      - run: bundle exec rake
+      - run: bundle exec rake spec
 
   head-versions:
     continue-on-error: true
@@ -46,7 +46,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu]
-        ruby: ['ruby-head', 'jruby-head', 'truffleruby']
+        ruby: ['ruby-head', 'jruby-head']
     runs-on: ${{ matrix.os }}-latest
     steps:
       - uses: actions/checkout@v2
@@ -54,4 +54,4 @@ jobs:
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true # 'bundle install' and cache
-      - run: bundle exec rake || echo "failed, but ignore it"
+      - run: bundle exec rake spec || echo "failed, but ignore it"

data/ChangeLog

@@ -1,3 +1,35 @@
+2022-08-23 1.5.6:
+
+* No actual code change, just re-release the `java` version properly.
+
+2022-08-22 1.5.5:
+
+* Fix a segfault when GC triggers inside a recursive extension.
+
+2022-07-25 1.5.4:
+
+* Fix a segfault when deserializing empty symbol (`:""`).
+* Improve compilation flags to not strip debug symbols.
+
+2022-05-30 version 1.5.3:
+
+* Fix deduplication of empty strings when using the `freeze: true` option.
+* Use `rb_hash_new_capa` when available (Ruby 3.2) for improved performance when parsing large hashes.
+
+2022-05-27 version 1.5.2:
+
+* Fix bug about unpacking ext type objects with the recursive option
+
+2022-04-07 version 1.5.1:
+
+* Fix bug about packing/unpacking ext type objects with the recursive option
+
+2022-04-06 version 1.5.0:
+
+* Add recursive option on Factory#register_type to operate Packer/Unpacker manually
+* Add oversized_integer_extension option on Factory#register_type to pack/unpack bigint using ext types
+* Add Factory#pool method and Factory::Pool class to provide pooled Packer and Unpacker instances
+
 2022-02-15 version 1.4.5:
 
 * Fix to create UTF-8 Symbol keys when symbolize_keys: true

data/README.md

@@ -40,7 +40,7 @@ or build msgpack-ruby and install:
 MessagePack for Ruby should run on x86, ARM, PowerPC, SPARC and other CPU architectures.
 
 And it works with MRI (CRuby) and Rubinius.
-Patches to improve portability is highly welcomed.
+Patches to improve portability are highly welcomed.
 
 
 ## Serializing objects
@@ -51,6 +51,7 @@ Use `MessagePack.pack` or `to_msgpack`:
 require 'msgpack'
 msg = MessagePack.pack(obj)  # or
 msg = obj.to_msgpack
+File.binwrite('mydata.msgpack', msg)
 ```
 
 ### Streaming serialization
@@ -71,6 +72,7 @@ Use `MessagePack.unpack`:
 
 ```ruby
 require 'msgpack'
+msg = File.binread('mydata.msgpack')
 obj = MessagePack.unpack(msg)
 ```
 
@@ -187,6 +189,28 @@ MessagePack::DefaultFactory.register_type(0x03, MyClass3)
 MessagePack.unpack(data_with_ext_typeid_03) #=> MyClass3 instance
 ```
 
+Alternatively, extension types can call the packer or unpacker recursively to generate the extension data:
+
+```ruby
+Point = Struct.new(:x, :y)
+factory = MessagePack::Factory.new
+factory.register_type(
+  0x01,
+  Point,
+  packer: ->(point, packer) {
+    packer.write(point.x)
+    packer.write(point.y)
+  },
+  unpacker: ->(unpacker) {
+    x = unpacker.read
+    y = unpacker.read
+    Point.new(x, y)
+  },
+  recursive: true,
+)
+factory.load(factory.dump(Point.new(12, 34))) # => #<struct Point x=12, y=34>
+```
+
 ## Buffer API
 
 MessagePack for Ruby provides a buffer API so that you can read or write data by hand, not via Packer or Unpacker API.

data/bench/bench.rb

@@ -0,0 +1,78 @@
+# % bundle install
+# % bundle exec ruby bench/bench.rb
+
+require 'msgpack'
+
+require 'benchmark/ips'
+
+object_plain = {
+  'message' => '127.0.0.1 - - [10/Oct/2000:13:55:36 -0700] "GET /apache_pb.gif HTTP/1.0" 200 2326 "http://www.example.com/start.html" "Mozilla/4.08 [en] (Win98; I ;Nav)"'
+}
+
+data_plain = MessagePack.pack(object_plain)
+
+object_structured = {
+  'remote_host' => '127.0.0.1',
+  'remote_user' => '-',
+  'date' => '10/Oct/2000:13:55:36 -0700',
+  'request' => 'GET /apache_pb.gif HTTP/1.0',
+  'method' => 'GET',
+  'path' => '/apache_pb.gif',
+  'protocol' => 'HTTP/1.0',
+  'status' => 200,
+  'bytes' => 2326,
+  'referer' => 'http://www.example.com/start.html',
+  'agent' => 'Mozilla/4.08 [en] (Win98; I ;Nav)',
+}
+
+data_structured = MessagePack.pack(object_structured)
+
+class Extended
+  def to_msgpack_ext
+    MessagePack.pack({})
+  end
+
+  def self.from_msgpack_ext(data)
+    MessagePack.unpack(data)
+    Extended.new
+  end
+end
+
+object_extended = {
+  'extended' => Extended.new
+}
+
+extended_packer = MessagePack::Packer.new
+extended_packer.register_type(0x00, Extended, :to_msgpack_ext)
+data_extended = extended_packer.pack(object_extended).to_s
+
+Benchmark.ips do |x|
+  x.report('pack-plain') do
+    MessagePack.pack(object_plain)
+  end
+
+  x.report('pack-structured') do
+    MessagePack.pack(object_structured)
+  end
+
+  x.report('pack-extended') do
+    packer = MessagePack::Packer.new
+    packer.register_type(0x00, Extended, :to_msgpack_ext)
+    packer.pack(object_extended).to_s
+  end
+
+  x.report('unpack-plain') do
+    MessagePack.unpack(data_plain)
+  end
+
+  x.report('unpack-structured') do
+    MessagePack.unpack(data_structured)
+  end
+
+  x.report('unpack-extended') do
+    unpacker = MessagePack::Unpacker.new
+    unpacker.register_type(0x00, Extended, :from_msgpack_ext)
+    unpacker.feed data_extended
+    unpacker.read
+  end
+end

data/doclib/msgpack/factory.rb

@@ -31,7 +31,7 @@ module MessagePack
     #
     # See Packer#initialize for supported options.
     #
-    def dump(obj, options={})
+    def dump(obj, options=nil)
     end
     alias pack dump
 
@@ -57,7 +57,7 @@ module MessagePack
     #
     # See Unpacker#initialize for supported options.
     #
-    def load(data, options={})
+    def load(data, options=nil)
     end
     alias unpack load
 
@@ -76,6 +76,7 @@ module MessagePack
     # * *:packer* specify symbol or proc object for packer
     # * *:unpacker* specify symbol or proc object for unpacker
     # * *:optimized_symbols_parsing* specify true to use the optimized symbols parsing (not supported on JRuby now)
+    # * *recursive* specify true to receive the packer or unpacker as argument to generate the extension body manually.
     #
     def register_type(type, klass, options={})
     end
@@ -98,5 +99,47 @@ module MessagePack
     #
     def type_registered?(klass_or_type, selector=:both)
     end
+
+    #
+    # Creates a MessagePack::PooledFactory instance of the given size.
+    #
+    # PooledFactory keeps Packer and Unpacker instance in a pool for improved performance.
+    # Note that the size defines how many instances are kept in cache, not the maximum of instances
+    # that can be created. If the pool limit is reached, a new instance is created anyway.
+    #
+    # @param size [Fixnum] specify how many Packer and Unpacker to keep in cache (default 1)
+    # @param options [Hash] Combined options for Packer and Unpacker. See Packer#initialize and Unpacker#initialize
+    #                       for supported options.
+    def pool(size=1, **options)
+    end
+
+    class Pool
+      #
+      # Deserializes an object from the string or io and returns it.
+      #
+      # If there're not enough data to deserialize one object, this method raises EOFError.
+      # If data format is invalid, this method raises MessagePack::MalformedFormatError.
+      # If the object nests too deeply, this method raises MessagePack::StackError.
+      #
+      # @param data [String]
+      # @return [Object] deserialized object
+      #
+      # See Unpacker#initialize for supported options.
+      #
+      def load(data)
+      end
+
+      #
+      # Serialize the passed value
+      #
+      # If it could not serialize the object, it raises
+      # NoMethodError: undefined method `to_msgpack' for #<the_object>.
+      #
+      # @param obj [Object] object to serialize
+      # @return [String] serialized object
+      #
+      def dump(object)
+      end
+    end
   end
 end

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

@@ -224,4 +224,10 @@ public class Buffer extends RubyObject {
   public IRubyObject writeTo(ThreadContext ctx, IRubyObject io) {
     return io.callMethod(ctx, "write", readCommon(ctx, null, false));
   }
+
+  public ByteList getBytes() {
+    byte[] bytes = new byte[rawSize()];
+    buffer.get(bytes);
+    return new ByteList(bytes, binaryEncoding);
+  }
 }

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

@@ -14,6 +14,7 @@ import org.jruby.RubyBignum;
 import org.jruby.RubyString;
 import org.jruby.RubyArray;
 import org.jruby.RubyHash;
+import org.jruby.RubyInteger;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.ByteList;
@@ -35,7 +36,7 @@ public class Decoder implements Iterator<IRubyObject> {
   private final RubyClass unexpectedTypeErrorClass;
   private final RubyClass unknownExtTypeErrorClass;
 
-  private ExtensionRegistry registry;
+  private Unpacker unpacker;
   private ByteBuffer buffer;
   private boolean symbolizeKeys;
   private boolean freeze;
@@ -45,29 +46,29 @@ public class Decoder implements Iterator<IRubyObject> {
     this(runtime, null, new byte[] {}, 0, 0, false, false, false);
   }
 
-  public Decoder(Ruby runtime, ExtensionRegistry registry) {
-    this(runtime, registry, new byte[] {}, 0, 0, false, false, false);
+  public Decoder(Ruby runtime, Unpacker unpacker) {
+    this(runtime, unpacker, new byte[] {}, 0, 0, false, false, false);
   }
 
   public Decoder(Ruby runtime, byte[] bytes) {
     this(runtime, null, bytes, 0, bytes.length, false, false, false);
   }
 
-  public Decoder(Ruby runtime, ExtensionRegistry registry, byte[] bytes) {
-    this(runtime, registry, bytes, 0, bytes.length, false, false, false);
+  public Decoder(Ruby runtime, Unpacker unpacker, byte[] bytes) {
+    this(runtime, unpacker, bytes, 0, bytes.length, false, false, false);
   }
 
-  public Decoder(Ruby runtime, ExtensionRegistry registry, byte[] bytes, boolean symbolizeKeys, boolean freeze, boolean allowUnknownExt) {
-    this(runtime, registry, bytes, 0, bytes.length, symbolizeKeys, freeze, allowUnknownExt);
+  public Decoder(Ruby runtime, Unpacker unpacker, byte[] bytes, boolean symbolizeKeys, boolean freeze, boolean allowUnknownExt) {
+    this(runtime, unpacker, bytes, 0, bytes.length, symbolizeKeys, freeze, allowUnknownExt);
   }
 
-  public Decoder(Ruby runtime, ExtensionRegistry registry, byte[] bytes, int offset, int length) {
-    this(runtime, registry, bytes, offset, length, false, false, false);
+  public Decoder(Ruby runtime, Unpacker unpacker, byte[] bytes, int offset, int length) {
+    this(runtime, unpacker, bytes, offset, length, false, false, false);
   }
 
-  public Decoder(Ruby runtime, ExtensionRegistry registry, byte[] bytes, int offset, int length, boolean symbolizeKeys, boolean freeze, boolean allowUnknownExt) {
+  public Decoder(Ruby runtime, Unpacker unpacker, byte[] bytes, int offset, int length, boolean symbolizeKeys, boolean freeze, boolean allowUnknownExt) {
     this.runtime = runtime;
-    this.registry = registry;
+    this.unpacker = unpacker;
     this.symbolizeKeys = symbolizeKeys;
     this.freeze = freeze;
     this.allowUnknownExt = allowUnknownExt;
@@ -154,18 +155,21 @@ public class Decoder implements Iterator<IRubyObject> {
 
   private IRubyObject consumeExtension(int size) {
     int type = buffer.get();
-    byte[] payload = readBytes(size);
-
-    if (registry != null) {
-      IRubyObject proc = registry.lookupUnpackerByTypeId(type);
-      if (proc != null) {
-        ByteList byteList = new ByteList(payload, runtime.getEncodingService().getAscii8bitEncoding());
-        return proc.callMethod(runtime.getCurrentContext(), "call", runtime.newString(byteList));
+    if (unpacker != null) {
+      ExtensionRegistry.ExtensionEntry entry = unpacker.lookupExtensionByTypeId(type);
+      if (entry != null) {
+        IRubyObject proc = entry.getUnpackerProc();
+        if (entry.isRecursive()) {
+          return proc.callMethod(runtime.getCurrentContext(), "call", unpacker);
+        } else {
+          ByteList byteList = new ByteList(readBytes(size), runtime.getEncodingService().getAscii8bitEncoding());
+          return proc.callMethod(runtime.getCurrentContext(), "call", runtime.newString(byteList));
+        }
       }
     }
 
     if (this.allowUnknownExt) {
-      return ExtensionValue.newExtensionValue(runtime, type, payload);
+      return ExtensionValue.newExtensionValue(runtime, type, readBytes(size));
     }
 
     throw runtime.newRaiseException(unknownExtTypeErrorClass, "unexpected extension type");

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

@@ -38,12 +38,16 @@ public class Encoder {
   private final Encoding utf8Encoding;
   private final boolean compatibilityMode;
   private final ExtensionRegistry registry;
+  private final Packer packer;
 
   public boolean hasSymbolExtType;
+  private boolean hasBigintExtType;
+  private boolean recursiveExtension;
 
   private ByteBuffer buffer;
 
-  public Encoder(Ruby runtime, boolean compatibilityMode, ExtensionRegistry registry, boolean hasSymbolExtType) {
+  public Encoder(Ruby runtime, Packer packer, boolean compatibilityMode, ExtensionRegistry registry, boolean hasSymbolExtType, boolean hasBigintExtType) {
+    this.packer = packer;
     this.runtime = runtime;
     this.buffer = ByteBuffer.allocate(CACHE_LINE_SIZE - ARRAY_HEADER_SIZE);
     this.binaryEncoding = runtime.getEncodingService().getAscii8bitEncoding();
@@ -51,6 +55,7 @@ public class Encoder {
     this.compatibilityMode = compatibilityMode;
     this.registry = registry;
     this.hasSymbolExtType = hasSymbolExtType;
+    this.hasBigintExtType = hasBigintExtType;
   }
 
   public boolean isCompatibilityMode() {
@@ -66,9 +71,17 @@ public class Encoder {
   }
 
   private IRubyObject readRubyString() {
-    IRubyObject str = runtime.newString(new ByteList(buffer.array(), 0, buffer.position(), binaryEncoding, false));
-    buffer.clear();
-    return str;
+    if (recursiveExtension) {
+      // If recursiveExtension is true, it means we re-entered encode, so we MUST NOT flush the buffer.
+	  // Instead we return an empty string to act as a null object for the caller. The buffer will actually
+	  // be flushed once we're done serializing the recursive extension.
+	  // All other method that consume the buffer should do so through readRubyString or implement the same logic.
+      return runtime.newString();
+    } else {
+      IRubyObject str = runtime.newString(new ByteList(buffer.array(), 0, buffer.position(), binaryEncoding, false));
+      buffer.clear();
+      return str;
+    }
   }
 
   public IRubyObject encode(IRubyObject object) {
@@ -147,7 +160,10 @@ public class Encoder {
     BigInteger value = object.getBigIntegerValue();
     if (value.compareTo(RubyBignum.LONG_MIN) < 0 || value.compareTo(RubyBignum.LONG_MAX) > 0) {
       if (value.bitLength() > 64 || (value.bitLength() > 63 && value.signum() < 0)) {
-        throw runtime.newArgumentError(String.format("Cannot pack big integer: %s", value));
+        if (hasBigintExtType && tryAppendWithExtTypeLookup(object)) {
+          return;
+        }
+        throw runtime.newRangeError(String.format("Cannot pack big integer: %s", value));
       }
       ensureRemainingCapacity(9);
       buffer.put(value.signum() < 0 ? INT64 : UINT64);
@@ -391,19 +407,31 @@ public class Encoder {
 
   private boolean tryAppendWithExtTypeLookup(IRubyObject object) {
     if (registry != null) {
-      RubyModule lookupClass;
-
-      if (object.getType() == runtime.getSymbol()) {
-        lookupClass = object.getType();
-      } else {
-        lookupClass = object.getSingletonClass();
-      }
-
-      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();
-        appendExt(type, bytes.getByteList());
+      ExtensionRegistry.ExtensionEntry entry = registry.lookupExtensionForObject(object);
+      if (entry != null) {
+        IRubyObject proc = entry.getPackerProc();
+        int type = entry.getTypeId();
+
+        if (entry.isRecursive()) {
+          ByteBuffer oldBuffer = buffer;
+          buffer = ByteBuffer.allocate(CACHE_LINE_SIZE - ARRAY_HEADER_SIZE);
+          boolean previousRecursiveExtension = recursiveExtension;
+          recursiveExtension = true;
+
+          ByteList payload;
+          try {
+            IRubyObject args[] = { object, packer };
+            proc.callMethod(runtime.getCurrentContext(), "call", args);
+            payload = new ByteList(buffer.array(), 0, buffer.position(), binaryEncoding, false);
+          } finally {
+            recursiveExtension = previousRecursiveExtension;
+            buffer = oldBuffer;
+          }
+          appendExt(type, payload);
+        } else {
+          RubyString bytes = proc.callMethod(runtime.getCurrentContext(), "call", object).asString();
+          appendExt(type, bytes.getByteList());
+        }
         return true;
       }
     }

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

@@ -59,59 +59,46 @@ public class ExtensionRegistry {
     return hash;
   }
 
-  public void put(RubyModule mod, int typeId, IRubyObject packerProc, IRubyObject packerArg, IRubyObject unpackerProc, IRubyObject unpackerArg) {
-    ExtensionEntry entry = new ExtensionEntry(mod, typeId, packerProc, packerArg, unpackerProc, unpackerArg);
+  public void put(RubyModule mod, int typeId, boolean recursive, IRubyObject packerProc, IRubyObject packerArg, IRubyObject unpackerProc, IRubyObject unpackerArg) {
+    ExtensionEntry entry = new ExtensionEntry(mod, typeId, recursive, packerProc, packerArg, unpackerProc, unpackerArg);
     extensionsByModule.put(mod, entry);
     extensionsByTypeId[typeId + 128] = entry;
     extensionsByAncestor.clear();
   }
 
-  public IRubyObject lookupUnpackerByTypeId(int typeId) {
+  public ExtensionEntry lookupExtensionByTypeId(int typeId) {
     ExtensionEntry e = extensionsByTypeId[typeId + 128];
     if (e != null && e.hasUnpacker()) {
-      return e.getUnpackerProc();
-    } else {
-      return null;
+      return e;
     }
+    return null;
   }
 
-  public IRubyObject[] lookupPackerForObject(IRubyObject object) {
+  public ExtensionEntry lookupExtensionForObject(IRubyObject object) {
     RubyModule lookupClass = null;
-    IRubyObject[] pair;
+    ExtensionEntry entry = null;
     /*
      * Objects of type Integer (Fixnum, Bignum), Float, Symbol and frozen
      * String have no singleton class and raise a TypeError when trying to get
      * it.
      */
     lookupClass = object.getMetaClass();
-    pair = fetchEntryByModule(lookupClass);
-    if (pair != null) {
-      return pair;
+    entry = extensionsByModule.get(lookupClass);
+    if (entry != null && entry.hasPacker()) {
+      return entry;
     }
 
     RubyModule realClass = object.getType();
     if (realClass != lookupClass) {
-      pair = fetchEntryByModule(realClass);
-      if (pair != null) {
-        return pair;
+      entry = extensionsByModule.get(realClass);
+      if (entry != null && entry.hasPacker()) {
+        return entry;
       }
     }
 
-    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.hasPacker()) {
-      return e.toPackerProcTypeIdPair(mod.getRuntime().getCurrentContext());
+    entry = findEntryByModuleOrAncestor(lookupClass);
+    if (entry != null && entry.hasPacker()) {
+      return entry;
     }
     return null;
   }
@@ -127,17 +114,19 @@ public class ExtensionRegistry {
     return null;
   }
 
-  private static class ExtensionEntry {
+  public static class ExtensionEntry {
     private final RubyModule mod;
     private final int typeId;
+    private final boolean recursive;
     private final IRubyObject packerProc;
     private final IRubyObject packerArg;
     private final IRubyObject unpackerProc;
     private final IRubyObject unpackerArg;
 
-    public ExtensionEntry(RubyModule mod, int typeId, IRubyObject packerProc, IRubyObject packerArg, IRubyObject unpackerProc, IRubyObject unpackerArg) {
+    public ExtensionEntry(RubyModule mod, int typeId, boolean recursive, IRubyObject packerProc, IRubyObject packerArg, IRubyObject unpackerProc, IRubyObject unpackerArg) {
       this.mod = mod;
       this.typeId = typeId;
+      this.recursive = recursive;
       this.packerProc = packerProc;
       this.packerArg = packerArg;
       this.unpackerProc = unpackerProc;
@@ -152,6 +141,10 @@ public class ExtensionRegistry {
       return typeId;
     }
 
+    public boolean isRecursive() {
+      return recursive;
+    }
+
     public boolean hasPacker() {
       return packerProc != null;
     }