msgpack 1.4.2 → 1.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 451ed743fe37bd3726f897f4daae9e7fd9b2cb065a34cf438ca786350060e0ec
-  data.tar.gz: 87335c4b1d35f9ac88af648963b1fe60caa72059ec7e6c1b6b507027da9118d8
+  metadata.gz: 750c05b37865e3da4e2ca909840dfb4afd732799f756a89465c26f2e6e77ef91
+  data.tar.gz: afc8dfd5103e65068fa054d7daf2811c65fbb7627e2986a1a50ad0307d643113
 SHA512:
-  metadata.gz: eb519049e9d8e4b36682e4b2c2625f10172745ce74ad1cfc8e6d93468b219071ed579bcfd36b7f0e1210eeb177197b435da2a028f46d2c71c73a3bcf2b53dcf8
-  data.tar.gz: e8c4765ac836226f5a2ce68a62194f112fc77bcdd9744d39040ff2db5a2c27d876348fb6002110c00b122bccdff2d539223d82ff73ea0bcb4cf1a3d9fb62defe
+  metadata.gz: 01af679c600ae449256f30a3beb5f9993266e1e8bcd11e5ec8e635301a713c3175131e112540660d8adc67ae06470043eee48d1a3b1ecc69b2e436eb0010579c
+  data.tar.gz: 13a82671e440447415c22d930dd795d4f1d6e07ea9328078ed25c887890bbc27080f38fb5d33da6cb15dc8dac2789e3a930548a64d298b1ca44b510bb3978d5f

data/.github/workflows/ci.yaml

@@ -0,0 +1,56 @@
+name: ci
+
+on:
+  pull_request:
+    branches: '*'
+  push:
+    branches:
+      - master
+      - main
+      - 'release-*'
+
+jobs:
+  mri:
+    strategy:
+      matrix:
+        os: [ubuntu, macos, windows]
+        ruby: ['2.4', '2.5', '2.6', '2.7', '3.0', '3.1']
+    runs-on: ${{ matrix.os }}-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - run: bundle install
+      - run: bundle exec rake
+
+  jruby:
+    strategy:
+      matrix:
+        os: [ubuntu]
+        # TODO: update to 9.3.3.0 once supported
+        # https://github.com/ruby/setup-ruby#supported-versions
+        ruby: ['jruby-9.2.19.0', 'jruby-9.3.2.0']
+    runs-on: ${{ matrix.os }}-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - run: bundle install
+      - run: bundle exec rake
+
+  head-versions:
+    continue-on-error: true
+    strategy:
+      matrix:
+        os: [ubuntu]
+        ruby: ['ruby-head', 'jruby-head', 'truffleruby']
+    runs-on: ${{ matrix.os }}-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - run: bundle install
+      - run: bundle exec rake || echo "failed, but ignore it"

data/ChangeLog

@@ -1,3 +1,11 @@
+2022-01-20 version 1.4.3:
+
+* Optimize serialization/deserialization of Symbols
+* Support registering ext types for objects of subclasses of primitive types (like Hash)
+* Add optimized_symbols_parsing option to Factory#register_type on MRI implementation
+* Optimize to deduplicate Hash keys on JRuby
+* Support JRuby 9.3 (and drop 9.1)
+
 2021-02-01 version 1.4.2:
 
 * Add the required Ruby version (>= 2.4) to avoid compilation errors on older Ruby runtimes

data/Rakefile

@@ -34,8 +34,8 @@ if RUBY_PLATFORM =~ /java/
     jars = ["#{jruby_home}/lib/jruby.jar"]
     ext.classpath = jars.map { |x| File.expand_path(x) }.join(':')
     ext.lib_dir = File.join(*['lib', 'msgpack', ENV['FAT_DIR']].compact)
-    ext.source_version = '1.6'
-    ext.target_version = '1.6'
+    ext.source_version = '1.8'
+    ext.target_version = '1.8'
   end
 else
   require 'rake/extensiontask'

data/doclib/msgpack/factory.rb

@@ -75,6 +75,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)
     #
     def register_type(type, klass, options={})
     end

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

@@ -21,6 +21,7 @@ import org.jcodings.Encoding;
 
 @JRubyClass(name="MessagePack::Buffer")
 public class Buffer extends RubyObject {
+  private static final long serialVersionUID = 8441244627425629412L;
   private IRubyObject io;
   private ByteBuffer buffer;
   private boolean writeMode;
@@ -49,7 +50,7 @@ public class Buffer extends RubyObject {
     }
     this.buffer = ByteBuffer.allocate(CACHE_LINE_SIZE - ARRAY_HEADER_SIZE);
     this.writeMode = true;
-    this.binaryEncoding = ctx.getRuntime().getEncodingService().getAscii8bitEncoding();
+    this.binaryEncoding = ctx.runtime.getEncodingService().getAscii8bitEncoding();
     return this;
   }
 
@@ -87,17 +88,17 @@ public class Buffer extends RubyObject {
       writeMode = true;
     }
     buffer.clear();
-    return ctx.getRuntime().getNil();
+    return ctx.runtime.getNil();
   }
 
   @JRubyMethod(name = "size")
   public IRubyObject size(ThreadContext ctx) {
-    return ctx.getRuntime().newFixnum(rawSize());
+    return ctx.runtime.newFixnum(rawSize());
   }
 
   @JRubyMethod(name = "empty?")
   public IRubyObject isEmpty(ThreadContext ctx) {
-    return rawSize() == 0 ? ctx.getRuntime().getTrue() : ctx.getRuntime().getFalse();
+    return rawSize() == 0 ? ctx.runtime.getTrue() : ctx.runtime.getFalse();
   }
 
   private IRubyObject bufferWrite(ThreadContext ctx, IRubyObject str) {
@@ -105,7 +106,7 @@ public class Buffer extends RubyObject {
     int length = bytes.length();
     ensureRemainingCapacity(length);
     buffer.put(bytes.unsafeBytes(), bytes.begin(), length);
-    return ctx.getRuntime().newFixnum(length);
+    return ctx.runtime.newFixnum(length);
 
   }
 
@@ -131,19 +132,19 @@ public class Buffer extends RubyObject {
       length = (int) args[0].convertToInteger().getLongValue();
     }
     if (raiseOnUnderflow && rawSize() < length) {
-      throw ctx.getRuntime().newEOFError();
+      throw ctx.runtime.newEOFError();
     }
     int readLength = Math.min(length, rawSize());
     if (readLength == 0 && length > 0) {
-      return ctx.getRuntime().getNil();
+      return ctx.runtime.getNil();
     } else if (readLength == 0) {
-      return ctx.getRuntime().newString();
+      return ctx.runtime.newString();
     } else {
       ensureReadMode();
       byte[] bytes = new byte[readLength];
       buffer.get(bytes);
       ByteList byteList = new ByteList(bytes, binaryEncoding);
-      return ctx.getRuntime().newString(byteList);
+      return ctx.runtime.newString(byteList);
     }
   }
 
@@ -161,12 +162,12 @@ public class Buffer extends RubyObject {
     feed(ctx);
     int length = (int) _length.convertToInteger().getLongValue();
     if (raiseOnUnderflow && rawSize() < length) {
-      throw ctx.getRuntime().newEOFError();
+      throw ctx.runtime.newEOFError();
     }
     ensureReadMode();
     int skipLength = Math.min(length, rawSize());
     buffer.position(buffer.position() + skipLength);
-    return ctx.getRuntime().newFixnum(skipLength);
+    return ctx.runtime.newFixnum(skipLength);
   }
 
   @JRubyMethod(name = "skip")
@@ -188,23 +189,23 @@ public class Buffer extends RubyObject {
     ensureReadMode();
     int length = buffer.limit() - buffer.position();
     ByteList str = new ByteList(buffer.array(), buffer.position(), length, binaryEncoding, true);
-    return ctx.getRuntime().newString(str);
+    return ctx.runtime.newString(str);
   }
 
   @JRubyMethod(name = "to_a")
   public IRubyObject toA(ThreadContext ctx) {
-    return ctx.getRuntime().newArray(toS(ctx));
+    return ctx.runtime.newArray(toS(ctx));
   }
 
   @JRubyMethod(name = "io")
   public IRubyObject getIo(ThreadContext ctx) {
-    return io == null ? ctx.getRuntime().getNil() : io;
+    return io == null ? ctx.runtime.getNil() : io;
   }
 
   @JRubyMethod(name = "flush")
   public IRubyObject flush(ThreadContext ctx) {
     if (io == null) {
-      return ctx.getRuntime().getNil();
+      return ctx.runtime.getNil();
     } else {
       return io.callMethod(ctx, "flush");
     }
@@ -213,7 +214,7 @@ public class Buffer extends RubyObject {
   @JRubyMethod(name = "close")
   public IRubyObject close(ThreadContext ctx) {
     if (io == null) {
-      return ctx.getRuntime().getNil();
+      return ctx.runtime.getNil();
     } else {
       return io.callMethod(ctx, "close");
     }

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

@@ -122,7 +122,6 @@ public class Decoder implements Iterator<IRubyObject> {
     ByteList byteList = new ByteList(bytes, encoding);
     RubyString string = runtime.newString(byteList);
     if (this.freeze) {
-      string.setFrozen(true);
       string = runtime.freezeAndDedupString(string);
     }
     return string;
@@ -140,9 +139,14 @@ public class Decoder implements Iterator<IRubyObject> {
     RubyHash hash = RubyHash.newHash(runtime);
     for (int i = 0; i < size; i++) {
       IRubyObject key = next();
-      if (this.symbolizeKeys && key instanceof RubyString) {
+      if (key instanceof RubyString) {
+        if (this.symbolizeKeys) {
           key = ((RubyString) key).intern();
+        } else {
+          key = runtime.freezeAndDedupString((RubyString) key);
+        }
       }
+
       hash.fastASet(key, next());
     }
     return hash;

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

@@ -119,7 +119,9 @@ public class Encoder {
     } else if (object instanceof RubyFloat) {
       appendFloat((RubyFloat) object);
     } else if (object instanceof RubyString) {
-      appendString((RubyString) object);
+      if (object.getType() == runtime.getString() || !tryAppendWithExtTypeLookup(object)) {
+        appendString((RubyString) object);
+      }
     } else if (object instanceof RubySymbol) {
       if (hasSymbolExtType) {
         appendOther(object, destination);
@@ -127,9 +129,13 @@ public class Encoder {
         appendString(((RubySymbol) object).asString());
       }
     } else if (object instanceof RubyArray) {
-      appendArray((RubyArray) object);
+      if (object.getType() == runtime.getArray() || !tryAppendWithExtTypeLookup(object)) {
+        appendArray((RubyArray) object);
+      }
     } else if (object instanceof RubyHash) {
-      appendHash((RubyHash) object);
+      if (object.getType() == runtime.getHash() || !tryAppendWithExtTypeLookup(object)) {
+        appendHash((RubyHash) object);
+      }
     } else if (object instanceof ExtensionValue) {
       appendExtensionValue((ExtensionValue) object);
     } else {
@@ -153,7 +159,7 @@ public class Encoder {
   }
 
   private void appendInteger(RubyInteger object) {
-    long value = ((RubyInteger) object).getLongValue();
+    long value = object.getLongValue();
     if (value < 0) {
       if (value < Short.MIN_VALUE) {
         if (value < Integer.MIN_VALUE) {
@@ -241,7 +247,7 @@ public class Encoder {
     } else {
       ensureRemainingCapacity(5 + length);
       buffer.put(binary ? BIN32 : STR32);
-      buffer.putInt((int) length);
+      buffer.putInt(length);
     }
   }
 
@@ -249,7 +255,7 @@ public class Encoder {
     Encoding encoding = object.getEncoding();
     boolean binary = !compatibilityMode && encoding == binaryEncoding;
     if (encoding != utf8Encoding && encoding != binaryEncoding) {
-      object = (RubyString) ((RubyString) object).encode(runtime.getCurrentContext(), runtime.getEncodingService().getEncoding(utf8Encoding));
+      object = (RubyString)(object).encode(runtime.getCurrentContext(), runtime.getEncodingService().getEncoding(utf8Encoding));
     }
     ByteList bytes = object.getByteList();
     int length = bytes.length();
@@ -257,12 +263,12 @@ public class Encoder {
     buffer.put(bytes.unsafeBytes(), bytes.begin(), length);
   }
 
-  private void appendArray(RubyArray object) {
+  private void appendArray(RubyArray<?> object) {
     appendArrayHeader(object);
     appendArrayElements(object);
   }
 
-  private void appendArrayHeader(RubyArray object) {
+  private void appendArrayHeader(RubyArray<?> object) {
     appendArrayHeader(object.size());
   }
 
@@ -281,7 +287,7 @@ public class Encoder {
     }
   }
 
-  private void appendArrayElements(RubyArray object) {
+  private void appendArrayElements(RubyArray<?> object) {
     int size = object.size();
     for (int i = 0; i < size; i++) {
       appendObject(object.eltOk(i));
@@ -383,7 +389,7 @@ public class Encoder {
     appendExt((int) type, payloadBytes);
   }
 
-  private void appendOther(IRubyObject object, IRubyObject destination) {
+  private boolean tryAppendWithExtTypeLookup(IRubyObject object) {
     if (registry != null) {
       RubyModule lookupClass;
 
@@ -398,10 +404,14 @@ public class Encoder {
         RubyString bytes = pair[0].callMethod(runtime.getCurrentContext(), "call", object).asString();
         int type = (int) ((RubyFixnum) pair[1]).getLongValue();
         appendExt(type, bytes.getByteList());
-        return;
+        return true;
       }
     }
-    appendCustom(object, destination);
+    return false;
+  }
+
+  private void appendOther(IRubyObject object, IRubyObject destination) {
+    if (!tryAppendWithExtTypeLookup(object)) { appendCustom(object, destination); }
   }
 
   private void appendCustom(IRubyObject object, IRubyObject destination) {

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

@@ -37,7 +37,7 @@ public class ExtensionRegistry {
   }
 
   public IRubyObject toInternalPackerRegistry(ThreadContext ctx) {
-    RubyHash hash = RubyHash.newHash(ctx.getRuntime());
+    RubyHash hash = RubyHash.newHash(ctx.runtime);
     for (RubyModule extensionModule : extensionsByModule.keySet()) {
       ExtensionEntry entry = extensionsByModule.get(extensionModule);
       if (entry.hasPacker()) {
@@ -48,11 +48,11 @@ public class ExtensionRegistry {
   }
 
   public IRubyObject toInternalUnpackerRegistry(ThreadContext ctx) {
-    RubyHash hash = RubyHash.newHash(ctx.getRuntime());
+    RubyHash hash = RubyHash.newHash(ctx.runtime);
     for (int typeIdIndex = 0 ; typeIdIndex < 256 ; typeIdIndex++) {
       ExtensionEntry entry = extensionsByTypeId[typeIdIndex];
       if (entry != null && entry.hasUnpacker()) {
-        IRubyObject typeId = RubyFixnum.newFixnum(ctx.getRuntime(), typeIdIndex - 128);
+        IRubyObject typeId = RubyFixnum.newFixnum(ctx.runtime, typeIdIndex - 128);
         hash.put(typeId, entry.toUnpackerTuple(ctx));
       }
     }
@@ -124,7 +124,7 @@ public class ExtensionRegistry {
   private ExtensionEntry findEntryByModuleOrAncestor(final RubyModule mod) {
     ThreadContext ctx = mod.getRuntime().getCurrentContext();
     for (RubyModule extensionModule : extensionsByModule.keySet()) {
-      RubyArray ancestors = (RubyArray) mod.callMethod(ctx, "ancestors");
+      RubyArray<?> ancestors = (RubyArray)mod.callMethod(ctx, "ancestors");
       if (ancestors.callMethod(ctx, "include?", extensionModule).isTrue()) {
         return extensionsByModule.get(extensionModule);
       }
@@ -173,16 +173,16 @@ public class ExtensionRegistry {
       return unpackerProc;
     }
 
-    public RubyArray toPackerTuple(ThreadContext ctx) {
-      return RubyArray.newArray(ctx.getRuntime(), new IRubyObject[] {RubyFixnum.newFixnum(ctx.getRuntime(), typeId), packerProc, packerArg});
+    public RubyArray<?> toPackerTuple(ThreadContext ctx) {
+      return ctx.runtime.newArray(new IRubyObject[] {ctx.runtime.newFixnum(typeId), packerProc, packerArg});
     }
 
-    public RubyArray toUnpackerTuple(ThreadContext ctx) {
-      return RubyArray.newArray(ctx.getRuntime(), new IRubyObject[] {mod, unpackerProc, unpackerArg});
+    public RubyArray<?> toUnpackerTuple(ThreadContext ctx) {
+      return ctx.runtime.newArray(new IRubyObject[] {mod, unpackerProc, unpackerArg});
     }
 
     public IRubyObject[] toPackerProcTypeIdPair(ThreadContext ctx) {
-      return new IRubyObject[] {packerProc, RubyFixnum.newFixnum(ctx.getRuntime(), typeId)};
+      return new IRubyObject[] {packerProc, ctx.runtime.newFixnum(typeId)};
     }
   }
 }

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

@@ -25,6 +25,7 @@ import static org.msgpack.jruby.Types.*;
 
 @JRubyClass(name="MessagePack::ExtensionValue")
 public class ExtensionValue extends RubyObject {
+  private static final long serialVersionUID = 8451274621449322492L;
   private final Encoding binaryEncoding;
 
   private RubyFixnum type;
@@ -77,12 +78,10 @@ public class ExtensionValue extends RubyObject {
     }
     if (o instanceof ExtensionValue) {
       ExtensionValue other = (ExtensionValue) o;
-      if (!this.type.eql_p(other.type).isTrue())
+      if (!this.type.eql_p(other.type).isTrue()) {
         return runtime.getFalse();
-      if (runtime.is1_8()) {
-        return this.payload.str_eql_p(ctx, other.payload);
       } else {
-        return this.payload.str_eql_p19(ctx, other.payload);
+        return this.payload.str_eql_p(ctx, other.payload);
       }
     }
     return runtime.getFalse();
@@ -96,12 +95,10 @@ public class ExtensionValue extends RubyObject {
     }
     if (o instanceof ExtensionValue) {
       ExtensionValue other = (ExtensionValue) o;
-      if (!this.type.op_equal(ctx, other.type).isTrue())
+      if (!this.type.op_equal(ctx, other.type).isTrue()) {
         return runtime.getFalse();
-      if (runtime.is1_8()) {
-        return this.payload.op_equal(ctx, other.payload);
       } else {
-        return this.payload.op_equal19(ctx, other.payload);
+        return this.payload.op_equal(ctx, other.payload);
       }
     }
     return runtime.getFalse();

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

@@ -23,6 +23,7 @@ import static org.jruby.runtime.Visibility.PRIVATE;
 
 @JRubyClass(name="MessagePack::Factory")
 public class Factory extends RubyObject {
+  private static final long serialVersionUID = 8441284623445322492L;
   private final Ruby runtime;
   private final ExtensionRegistry extensionRegistry;
   private boolean hasSymbolExtType;
@@ -61,7 +62,7 @@ public class Factory extends RubyObject {
 
   @JRubyMethod(name = "registered_types_internal", visibility = PRIVATE)
   public IRubyObject registeredTypesInternal(ThreadContext ctx) {
-    return RubyArray.newArray(ctx.getRuntime(), new IRubyObject[] {
+    return RubyArray.newArray(ctx.runtime, new IRubyObject[] {
       extensionRegistry.toInternalPackerRegistry(ctx),
       extensionRegistry.toInternalUnpackerRegistry(ctx)
     });
@@ -69,7 +70,7 @@ public class Factory extends RubyObject {
 
   @JRubyMethod(name = "register_type", required = 2, optional = 1)
   public IRubyObject registerType(ThreadContext ctx, IRubyObject[] args) {
-    Ruby runtime = ctx.getRuntime();
+    Ruby runtime = ctx.runtime;
     IRubyObject type = args[0];
     IRubyObject mod = args[1];
 
@@ -88,6 +89,10 @@ public class Factory extends RubyObject {
         RubyHash options = (RubyHash) args[args.length - 1];
         packerArg = options.fastARef(runtime.newSymbol("packer"));
         unpackerArg = options.fastARef(runtime.newSymbol("unpacker"));
+        IRubyObject optimizedSymbolsParsingArg = options.fastARef(runtime.newSymbol("optimized_symbols_parsing"));
+        if (optimizedSymbolsParsingArg != null && optimizedSymbolsParsingArg.isTrue()) {
+          throw runtime.newArgumentError("JRuby implementation does not support the optimized_symbols_parsing option");
+        }
       } else {
         throw runtime.newArgumentError(String.format("expected Hash but found %s.", args[args.length - 1].getType().getName()));
       }

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

@@ -27,6 +27,7 @@ import static org.jruby.runtime.Visibility.PRIVATE;
 
 @JRubyClass(name="MessagePack::Packer")
 public class Packer extends RubyObject {
+  private static final long serialVersionUID = 8451274621499362492L;
   public ExtensionRegistry registry;
   private Buffer buffer;
   private Encoder encoder;
@@ -48,9 +49,10 @@ public class Packer extends RubyObject {
   @JRubyMethod(name = "initialize", optional = 2)
   public IRubyObject initialize(ThreadContext ctx, IRubyObject[] args) {
     boolean compatibilityMode = false;
+    Ruby runtime = ctx.runtime;
     if (args.length > 0 && args[args.length - 1] instanceof RubyHash) {
       RubyHash options = (RubyHash) args[args.length - 1];
-      IRubyObject mode = options.fastARef(ctx.getRuntime().newSymbol("compatibility_mode"));
+      IRubyObject mode = options.fastARef(runtime.newSymbol("compatibility_mode"));
       compatibilityMode = (mode != null) && mode.isTrue();
     }
     if (registry == null) {
@@ -58,22 +60,22 @@ public class Packer extends RubyObject {
         // 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.encoder = new Encoder(runtime, compatibilityMode, registry, hasSymbolExtType);
+    this.buffer = new Buffer(runtime, runtime.getModule("MessagePack").getClass("Buffer"));
     this.buffer.initialize(ctx, args);
-    this.binaryEncoding = ctx.getRuntime().getEncodingService().getAscii8bitEncoding();
+    this.binaryEncoding = runtime.getEncodingService().getAscii8bitEncoding();
     return this;
   }
 
   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 packer = new Packer(ctx.runtime, ctx.runtime.getModule("MessagePack").getClass("Packer"), extRegistry, hasSymbolExtType);
     packer.initialize(ctx, args);
     return packer;
   }
 
   @JRubyMethod(name = "compatibility_mode?")
   public IRubyObject isCompatibilityMode(ThreadContext ctx) {
-    return encoder.isCompatibilityMode() ? ctx.getRuntime().getTrue() : ctx.getRuntime().getFalse();
+    return encoder.isCompatibilityMode() ? ctx.runtime.getTrue() : ctx.runtime.getFalse();
   }
 
   @JRubyMethod(name = "registered_types_internal", visibility = PRIVATE)
@@ -83,7 +85,7 @@ public class Packer extends RubyObject {
 
   @JRubyMethod(name = "register_type", required = 2, optional = 1)
   public IRubyObject registerType(ThreadContext ctx, IRubyObject[] args, final Block block) {
-    Ruby runtime = ctx.getRuntime();
+    Ruby runtime = ctx.runtime;
     IRubyObject type = args[0];
     IRubyObject mod = args[1];
 
@@ -182,12 +184,12 @@ public class Packer extends RubyObject {
 
   @JRubyMethod(name = "write_true")
   public IRubyObject writeTrue(ThreadContext ctx) {
-    return write(ctx, ctx.getRuntime().getTrue());
+    return write(ctx, ctx.runtime.getTrue());
   }
 
   @JRubyMethod(name = "write_false")
   public IRubyObject writeFalse(ThreadContext ctx) {
-    return write(ctx, ctx.getRuntime().getFalse());
+    return write(ctx, ctx.runtime.getFalse());
   }
 
   @JRubyMethod(name = "write_nil")