Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package rubygem-msgpack for openSUSE:Factory checked in at 2022-01-28 22:12:29 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/rubygem-msgpack (Old) and /work/SRC/openSUSE:Factory/.rubygem-msgpack.new.1898 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "rubygem-msgpack" Fri Jan 28 22:12:29 2022 rev:14 rq:949578 version:1.4.4 Changes: -------- --- /work/SRC/openSUSE:Factory/rubygem-msgpack/rubygem-msgpack.changes 2021-02-20 22:12:13.535034951 +0100 +++ /work/SRC/openSUSE:Factory/.rubygem-msgpack.new.1898/rubygem-msgpack.changes 2022-01-28 22:12:41.458826366 +0100 @@ -1,0 +2,19 @@ +Tue Jan 25 07:13:34 UTC 2022 - Stephan Kulow <co...@suse.com> + +updated to version 1.4.4 + see installed ChangeLog + + 2022-01-22 version 1.4.4: + + * Specify the build option --platform=8 for older Java platforms + + 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) + + +------------------------------------------------------------------- Old: ---- msgpack-1.4.2.gem New: ---- msgpack-1.4.4.gem ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ rubygem-msgpack.spec ++++++ --- /var/tmp/diff_new_pack.PhUmKB/_old 2022-01-28 22:12:41.962822917 +0100 +++ /var/tmp/diff_new_pack.PhUmKB/_new 2022-01-28 22:12:41.966822889 +0100 @@ -1,7 +1,7 @@ # # spec file for package rubygem-msgpack # -# Copyright (c) 2021 SUSE LLC +# Copyright (c) 2022 SUSE LLC # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -24,7 +24,7 @@ # Name: rubygem-msgpack -Version: 1.4.2 +Version: 1.4.4 Release: 0 %define mod_name msgpack %define mod_full_name %{mod_name}-%{version} ++++++ msgpack-1.4.2.gem -> msgpack-1.4.4.gem ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/.github/workflows/ci.yaml new/.github/workflows/ci.yaml --- old/.github/workflows/ci.yaml 1970-01-01 01:00:00.000000000 +0100 +++ new/.github/workflows/ci.yaml 2022-01-22 10:08:54.000000000 +0100 @@ -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 }} + bundler-cache: true # 'bundle install' and cache + - 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 }} + bundler-cache: true # 'bundle install' and cache + - 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 }} + bundler-cache: true # 'bundle install' and cache + - run: bundle exec rake || echo "failed, but ignore it" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/.travis.yml new/.travis.yml --- old/.travis.yml 2021-02-01 04:16:37.000000000 +0100 +++ new/.travis.yml 1970-01-01 01:00:00.000000000 +0100 @@ -1,39 +0,0 @@ -language: ruby - -branches: - only: - - master - -gemfile: - - Gemfile - -before_install: - # This is only for Ruby 2.5.0, Bundler 1.16.1 and rubygems 2.7.3 - # See https://github.com/travis-ci/travis-ci/issues/8969 - - "[ \"x2.7.3\" = \"x\"$(gem --version) ] && gem update --system --no-document || echo \"no need to update rubygem\"" - -# http://rubies.travis-ci.org/ -matrix: - include: - - rvm: 2.4.5 - os: linux - - rvm: 2.5.8 - os: linux - - rvm: 2.6.6 - os: linux - - rvm: 2.6.6 - os: osx - - rvm: 2.7.1 - os: linux - - rvm: ruby-head - os: linux - - rvm: jruby-head - os: linux - - rvm: jruby-19mode - os: linux - allow_failures: - - rvm: 2.6.1 - os: osx - - rvm: ruby-head - - rvm: jruby-head - - rvm: jruby-19mode diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ChangeLog new/ChangeLog --- old/ChangeLog 2021-02-01 04:16:37.000000000 +0100 +++ new/ChangeLog 2022-01-22 10:08:54.000000000 +0100 @@ -1,3 +1,15 @@ +2022-01-22 version 1.4.4: + +* Specify the build option --platform=8 for older Java platforms + +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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Rakefile new/Rakefile --- old/Rakefile 2021-02-01 04:16:37.000000000 +0100 +++ new/Rakefile 2022-01-22 10:08:54.000000000 +0100 @@ -34,8 +34,7 @@ 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.release = '8' end else require 'rake/extensiontask' Binary files old/checksums.yaml.gz and new/checksums.yaml.gz differ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/doclib/msgpack/factory.rb new/doclib/msgpack/factory.rb --- old/doclib/msgpack/factory.rb 2021-02-01 04:16:37.000000000 +0100 +++ new/doclib/msgpack/factory.rb 2022-01-22 10:08:54.000000000 +0100 @@ -75,6 +75,7 @@ # # * *: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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/java/org/msgpack/jruby/Buffer.java new/ext/java/org/msgpack/jruby/Buffer.java --- old/ext/java/org/msgpack/jruby/Buffer.java 2021-02-01 04:16:37.000000000 +0100 +++ new/ext/java/org/msgpack/jruby/Buffer.java 2022-01-22 10:08:54.000000000 +0100 @@ -21,6 +21,7 @@ @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 @@ } 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ @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"); } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/java/org/msgpack/jruby/Decoder.java new/ext/java/org/msgpack/jruby/Decoder.java --- old/ext/java/org/msgpack/jruby/Decoder.java 2021-02-01 04:16:37.000000000 +0100 +++ new/ext/java/org/msgpack/jruby/Decoder.java 2022-01-22 10:08:54.000000000 +0100 @@ -122,7 +122,6 @@ 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 @@ 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; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/java/org/msgpack/jruby/Encoder.java new/ext/java/org/msgpack/jruby/Encoder.java --- old/ext/java/org/msgpack/jruby/Encoder.java 2021-02-01 04:16:37.000000000 +0100 +++ new/ext/java/org/msgpack/jruby/Encoder.java 2022-01-22 10:08:54.000000000 +0100 @@ -119,7 +119,9 @@ } 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 @@ 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 @@ } 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 @@ } else { ensureRemainingCapacity(5 + length); buffer.put(binary ? BIN32 : STR32); - buffer.putInt((int) length); + buffer.putInt(length); } } @@ -249,7 +255,7 @@ 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 @@ 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 @@ } } - 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 @@ 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 @@ 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) { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/java/org/msgpack/jruby/ExtensionRegistry.java new/ext/java/org/msgpack/jruby/ExtensionRegistry.java --- old/ext/java/org/msgpack/jruby/ExtensionRegistry.java 2021-02-01 04:16:37.000000000 +0100 +++ new/ext/java/org/msgpack/jruby/ExtensionRegistry.java 2022-01-22 10:08:54.000000000 +0100 @@ -37,7 +37,7 @@ } 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 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 @@ 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 @@ 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)}; } } } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/java/org/msgpack/jruby/ExtensionValue.java new/ext/java/org/msgpack/jruby/ExtensionValue.java --- old/ext/java/org/msgpack/jruby/ExtensionValue.java 2021-02-01 04:16:37.000000000 +0100 +++ new/ext/java/org/msgpack/jruby/ExtensionValue.java 2022-01-22 10:08:54.000000000 +0100 @@ -25,6 +25,7 @@ @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 @@ } 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 @@ } 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(); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/java/org/msgpack/jruby/Factory.java new/ext/java/org/msgpack/jruby/Factory.java --- old/ext/java/org/msgpack/jruby/Factory.java 2021-02-01 04:16:37.000000000 +0100 +++ new/ext/java/org/msgpack/jruby/Factory.java 2022-01-22 10:08:54.000000000 +0100 @@ -23,6 +23,7 @@ @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 @@ @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 @@ @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 @@ 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())); } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/java/org/msgpack/jruby/Packer.java new/ext/java/org/msgpack/jruby/Packer.java --- old/ext/java/org/msgpack/jruby/Packer.java 2021-02-01 04:16:37.000000000 +0100 +++ new/ext/java/org/msgpack/jruby/Packer.java 2022-01-22 10:08:54.000000000 +0100 @@ -27,6 +27,7 @@ @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 @@ @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 @@ // 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 @@ @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 @@ @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") diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/java/org/msgpack/jruby/Unpacker.java new/ext/java/org/msgpack/jruby/Unpacker.java --- old/ext/java/org/msgpack/jruby/Unpacker.java 2021-02-01 04:16:37.000000000 +0100 +++ new/ext/java/org/msgpack/jruby/Unpacker.java 2022-01-22 10:08:54.000000000 +0100 @@ -27,6 +27,7 @@ @JRubyClass(name="MessagePack::Unpacker") public class Unpacker extends RubyObject { + private static final long serialVersionUID = 8451264671199362492L; private final ExtensionRegistry registry; private IRubyObject stream; @@ -59,22 +60,23 @@ allowUnknownExt = false; freeze = false; if (args.length > 0) { + Ruby runtime = ctx.runtime; if (args[args.length - 1] instanceof RubyHash) { RubyHash options = (RubyHash) args[args.length - 1]; - IRubyObject sk = options.fastARef(ctx.getRuntime().newSymbol("symbolize_keys")); + IRubyObject sk = options.fastARef(runtime.newSymbol("symbolize_keys")); if (sk != null) { symbolizeKeys = sk.isTrue(); } - IRubyObject f = options.fastARef(ctx.getRuntime().newSymbol("freeze")); + IRubyObject f = options.fastARef(runtime.newSymbol("freeze")); if (f != null) { freeze = f.isTrue(); } - IRubyObject au = options.fastARef(ctx.getRuntime().newSymbol("allow_unknown_ext")); + IRubyObject au = options.fastARef(runtime.newSymbol("allow_unknown_ext")); if (au != null) { allowUnknownExt = au.isTrue(); } } - if (args[0] != ctx.getRuntime().getNil() && !(args[0] instanceof RubyHash)) { + if (args[0] != runtime.getNil() && !(args[0] instanceof RubyHash)) { setStream(ctx, args[0]); } } @@ -82,24 +84,24 @@ } public static Unpacker newUnpacker(ThreadContext ctx, ExtensionRegistry extRegistry, IRubyObject[] args) { - Unpacker unpacker = new Unpacker(ctx.getRuntime(), ctx.getRuntime().getModule("MessagePack").getClass("Unpacker"), extRegistry); + Unpacker unpacker = new Unpacker(ctx.runtime, ctx.runtime.getModule("MessagePack").getClass("Unpacker"), extRegistry); unpacker.initialize(ctx, args); return unpacker; } @JRubyMethod(name = "symbolize_keys?") public IRubyObject isSymbolizeKeys(ThreadContext ctx) { - return symbolizeKeys ? ctx.getRuntime().getTrue() : ctx.getRuntime().getFalse(); + return symbolizeKeys ? ctx.runtime.getTrue() : ctx.runtime.getFalse(); } @JRubyMethod(name = "freeze?") public IRubyObject isFreeze(ThreadContext ctx) { - return freeze ? ctx.getRuntime().getTrue() : ctx.getRuntime().getFalse(); + return freeze ? ctx.runtime.getTrue() : ctx.runtime.getFalse(); } @JRubyMethod(name = "allow_unknown_ext?") public IRubyObject isAllowUnknownExt(ThreadContext ctx) { - return allowUnknownExt ? ctx.getRuntime().getTrue() : ctx.getRuntime().getFalse(); + return allowUnknownExt ? ctx.runtime.getTrue() : ctx.runtime.getFalse(); } @JRubyMethod(name = "registered_types_internal", visibility = PRIVATE) @@ -109,7 +111,7 @@ @JRubyMethod(name = "register_type", required = 1, optional = 2) public IRubyObject registerType(ThreadContext ctx, IRubyObject[] args, final Block block) { - Ruby runtime = ctx.getRuntime(); + Ruby runtime = ctx.runtime; IRubyObject type = args[0]; RubyModule extModule; @@ -155,7 +157,7 @@ if (limit == -1) { limit = byteList.length() - offset; } - Decoder decoder = new Decoder(ctx.getRuntime(), registry, byteList.unsafeBytes(), byteList.begin() + offset, limit, symbolizeKeys, freeze, allowUnknownExt); + Decoder decoder = new Decoder(ctx.runtime, registry, byteList.unsafeBytes(), byteList.begin() + offset, limit, symbolizeKeys, freeze, allowUnknownExt); try { data = null; data = decoder.next(); @@ -164,13 +166,13 @@ throw re; } } - return ctx.getRuntime().newFixnum(decoder.offset()); + return ctx.runtime.newFixnum(decoder.offset()); } @JRubyMethod(name = "data") public IRubyObject getData(ThreadContext ctx) { if (data == null) { - return ctx.getRuntime().getNil(); + return ctx.runtime.getNil(); } else { return data; } @@ -178,14 +180,14 @@ @JRubyMethod(name = "finished?") public IRubyObject finished_p(ThreadContext ctx) { - return data == null ? ctx.getRuntime().getFalse() : ctx.getRuntime().getTrue(); + return data == null ? ctx.runtime.getFalse() : ctx.runtime.getTrue(); } @JRubyMethod(required = 1, name = "feed", alias = { "feed_reference" }) public IRubyObject feed(ThreadContext ctx, IRubyObject data) { ByteList byteList = data.asString().getByteList(); if (decoder == null) { - decoder = new Decoder(ctx.getRuntime(), registry, byteList.unsafeBytes(), byteList.begin(), byteList.length(), symbolizeKeys, freeze, allowUnknownExt); + decoder = new Decoder(ctx.runtime, registry, byteList.unsafeBytes(), byteList.begin(), byteList.length(), symbolizeKeys, freeze, allowUnknownExt); } else { decoder.feed(byteList.unsafeBytes(), byteList.begin(), byteList.length()); } @@ -202,7 +204,7 @@ feed(ctx, data); if (block.isGiven()) { each(ctx, block); - return ctx.getRuntime().getNil(); + return ctx.runtime.getNil(); } else { return callMethod(ctx, "to_enum"); } @@ -230,7 +232,7 @@ @JRubyMethod public IRubyObject fill(ThreadContext ctx) { - return ctx.getRuntime().getNil(); + return ctx.runtime.getNil(); } @JRubyMethod @@ -238,13 +240,13 @@ if (decoder != null) { decoder.reset(); } - return ctx.getRuntime().getNil(); + return ctx.runtime.getNil(); } @JRubyMethod(name = "read", alias = { "unpack" }) public IRubyObject read(ThreadContext ctx) { if (decoder == null) { - throw ctx.getRuntime().newEOFError(); + throw ctx.runtime.newEOFError(); } try { return decoder.next(); @@ -252,19 +254,19 @@ if (re.getException().getType() != underflowErrorClass) { throw re; } else { - throw ctx.getRuntime().newEOFError(); + throw ctx.runtime.newEOFError(); } } } @JRubyMethod(name = "skip") public IRubyObject skip(ThreadContext ctx) { - throw ctx.getRuntime().newNotImplementedError("Not supported yet in JRuby implementation"); + throw ctx.runtime.newNotImplementedError("Not supported yet in JRuby implementation"); } @JRubyMethod(name = "skip_nil") public IRubyObject skipNil(ThreadContext ctx) { - throw ctx.getRuntime().newNotImplementedError("Not supported yet in JRuby implementation"); + throw ctx.runtime.newNotImplementedError("Not supported yet in JRuby implementation"); } @JRubyMethod @@ -276,11 +278,11 @@ if (re.getException().getType() != underflowErrorClass) { throw re; } else { - throw ctx.getRuntime().newEOFError(); + throw ctx.runtime.newEOFError(); } } } - return ctx.getRuntime().getNil(); + return ctx.runtime.getNil(); } @JRubyMethod @@ -292,17 +294,17 @@ if (re.getException().getType() != underflowErrorClass) { throw re; } else { - throw ctx.getRuntime().newEOFError(); + throw ctx.runtime.newEOFError(); } } } - return ctx.getRuntime().getNil(); + return ctx.runtime.getNil(); } @JRubyMethod(name = "stream") public IRubyObject getStream(ThreadContext ctx) { if (stream == null) { - return ctx.getRuntime().getNil(); + return ctx.runtime.getNil(); } else { return stream; } @@ -318,12 +320,12 @@ } else if (stream.respondsTo("read")) { str = stream.callMethod(ctx, "read").asString(); } else { - throw ctx.getRuntime().newTypeError(stream, "IO"); + throw ctx.runtime.newTypeError(stream, "IO"); } ByteList byteList = str.getByteList(); this.stream = stream; this.decoder = null; - this.decoder = new Decoder(ctx.getRuntime(), registry, byteList.unsafeBytes(), byteList.begin(), byteList.length(), symbolizeKeys, freeze, allowUnknownExt); + this.decoder = new Decoder(ctx.runtime, registry, byteList.unsafeBytes(), byteList.begin(), byteList.length(), symbolizeKeys, freeze, allowUnknownExt); return getStream(ctx); } } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/msgpack/buffer.c new/ext/msgpack/buffer.c --- old/ext/msgpack/buffer.c 2021-02-01 04:16:37.000000000 +0100 +++ new/ext/msgpack/buffer.c 2022-01-22 10:08:54.000000000 +0100 @@ -164,12 +164,7 @@ b->head->mapped_string != NO_MAPPED_STRING && length >= b->read_reference_threshold) { VALUE s = _msgpack_buffer_refer_head_mapped_string(b, length); -#ifndef HAVE_RB_STR_REPLACE - /* TODO MRI 1.8 */ - rb_funcall(string, s_replace, 1, s); -#else rb_str_replace(string, s); -#endif /* here doesn't have to call ENCODING_SET because * encoding of s is always ASCII-8BIT */ _msgpack_buffer_consumed(b, length); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/msgpack/buffer.h new/ext/msgpack/buffer.h --- old/ext/msgpack/buffer.h 2021-02-01 04:16:37.000000000 +0100 +++ new/ext/msgpack/buffer.h 2022-01-22 10:08:54.000000000 +0100 @@ -494,4 +494,9 @@ #endif // HAVE_RB_ENC_INTERNED_STR } +static inline VALUE msgpack_buffer_read_top_as_symbol(msgpack_buffer_t* b, size_t length) +{ + return rb_str_intern(msgpack_buffer_read_top_as_string(b, length, true, false)); +} + #endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/msgpack/extconf.rb new/ext/msgpack/extconf.rb --- old/ext/msgpack/extconf.rb 2021-02-01 04:16:37.000000000 +0100 +++ new/ext/msgpack/extconf.rb 2022-01-22 10:08:54.000000000 +0100 @@ -2,14 +2,7 @@ have_header("ruby/st.h") have_header("st.h") -have_func("rb_str_replace", ["ruby.h"]) -have_func("rb_intern_str", ["ruby.h"]) have_func("rb_enc_interned_str", "ruby.h") -have_func("rb_sym2str", ["ruby.h"]) -have_func("rb_str_intern", ["ruby.h"]) -have_func("rb_block_lambda", ["ruby.h"]) -have_func("rb_hash_dup", ["ruby.h"]) -have_func("rb_hash_clear", ["ruby.h"]) unless RUBY_PLATFORM.include? 'mswin' $CFLAGS << %[ -I.. -Wall -O3 -g -std=gnu99] diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/msgpack/factory_class.c new/ext/msgpack/factory_class.c --- old/ext/msgpack/factory_class.c 2021-02-01 04:16:37.000000000 +0100 +++ new/ext/msgpack/factory_class.c 2022-01-22 10:08:54.000000000 +0100 @@ -32,6 +32,8 @@ msgpack_packer_ext_registry_t pkrg; msgpack_unpacker_ext_registry_t ukrg; bool has_symbol_ext_type; + bool optimized_symbol_ext_type; + int symbol_ext_type; }; #define FACTORY(from, name) \ @@ -114,6 +116,8 @@ msgpack_unpacker_ext_registry_destroy(&uk->ext_registry); msgpack_unpacker_ext_registry_dup(&fc->ukrg, &uk->ext_registry); + uk->optimized_symbol_ext_type = fc->optimized_symbol_ext_type; + uk->symbol_ext_type = fc->symbol_ext_type; return unpacker; } @@ -128,11 +132,7 @@ rb_hash_aset(uk_mapping, INT2FIX(i - 128), fc->ukrg.array[i]); } } -#ifdef HAVE_RB_HASH_DUP return rb_ary_new3(2, rb_hash_dup(fc->pkrg.hash), uk_mapping); -#else - return rb_ary_new3(2, rb_funcall(fc->pkrg.hash, rb_intern("dup"), 0), uk_mapping); -#endif } static VALUE Factory_register_type(int argc, VALUE* argv, VALUE self) @@ -141,7 +141,7 @@ int ext_type; VALUE ext_module; - VALUE options; + VALUE options = Qnil; VALUE packer_arg, unpacker_arg; VALUE packer_proc, unpacker_proc; @@ -188,6 +188,8 @@ if(unpacker_arg != Qnil) { if(rb_type(unpacker_arg) == T_SYMBOL || rb_type(unpacker_arg) == T_STRING) { unpacker_proc = rb_obj_method(ext_module, unpacker_arg); + } else if (rb_respond_to(unpacker_arg, rb_intern("call"))) { + unpacker_proc = unpacker_arg; } else { unpacker_proc = rb_funcall(unpacker_arg, rb_intern("method"), 1, ID2SYM(rb_intern("call"))); } @@ -197,6 +199,9 @@ if (ext_module == rb_cSymbol) { fc->has_symbol_ext_type = true; + if(RB_TEST(options) && RB_TEST(rb_hash_aref(options, ID2SYM(rb_intern("optimized_symbols_parsing"))))) { + fc->optimized_symbol_ext_type = true; + } } msgpack_unpacker_ext_registry_put(&fc->ukrg, ext_module, ext_type, unpacker_proc, unpacker_arg); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/msgpack/packer.c new/ext/msgpack/packer.c --- old/ext/msgpack/packer.c 2021-02-01 04:16:37.000000000 +0100 +++ new/ext/msgpack/packer.c 2022-01-22 10:08:54.000000000 +0100 @@ -121,7 +121,7 @@ #endif } -void msgpack_packer_write_other_value(msgpack_packer_t* pk, VALUE v) +bool msgpack_packer_try_write_with_ext_type_lookup(msgpack_packer_t* pk, VALUE v) { int ext_type; @@ -131,7 +131,14 @@ VALUE payload = rb_funcall(proc, s_call, 1, v); StringValue(payload); msgpack_packer_write_ext(pk, ext_type, payload); - } else { + return true; + } + return false; +} + +void msgpack_packer_write_other_value(msgpack_packer_t* pk, VALUE v) +{ + if(!(msgpack_packer_try_write_with_ext_type_lookup(pk, v))) { rb_funcall(v, pk->to_msgpack_method, 1, pk->to_msgpack_arg); } } @@ -155,13 +162,19 @@ msgpack_packer_write_symbol_value(pk, v); break; case T_STRING: - msgpack_packer_write_string_value(pk, v); + if(rb_class_of(v) == rb_cString || !msgpack_packer_try_write_with_ext_type_lookup(pk, v)) { + msgpack_packer_write_string_value(pk, v); + } break; case T_ARRAY: - msgpack_packer_write_array_value(pk, v); + if(rb_class_of(v) == rb_cArray || !msgpack_packer_try_write_with_ext_type_lookup(pk, v)) { + msgpack_packer_write_array_value(pk, v); + } break; case T_HASH: - msgpack_packer_write_hash_value(pk, v); + if(rb_class_of(v) == rb_cHash || !msgpack_packer_try_write_with_ext_type_lookup(pk, v)) { + msgpack_packer_write_hash_value(pk, v); + } break; case T_BIGNUM: msgpack_packer_write_bignum_value(pk, v); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/msgpack/packer.h new/ext/msgpack/packer.h --- old/ext/msgpack/packer.h 2021-02-01 04:16:37.000000000 +0100 +++ new/ext/msgpack/packer.h 2022-01-22 10:08:54.000000000 +0100 @@ -444,16 +444,7 @@ 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 */ msgpack_packer_write_string_value(pk, rb_sym2str(v)); -#else - VALUE str = rb_id2str(SYM2ID(v)); - if (!str) { - rb_raise(rb_eRuntimeError, "could not convert a symbol to string"); - } - msgpack_packer_write_string_value(pk, str); -#endif } void msgpack_packer_write_other_value(msgpack_packer_t* pk, VALUE v); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/msgpack/packer_class.c new/ext/msgpack/packer_class.c --- old/ext/msgpack/packer_class.c 2021-02-01 04:16:37.000000000 +0100 +++ new/ext/msgpack/packer_class.c 2022-01-22 10:08:54.000000000 +0100 @@ -339,11 +339,7 @@ static VALUE Packer_registered_types_internal(VALUE self) { PACKER(self, pk); -#ifdef HAVE_RB_HASH_DUP return rb_hash_dup(pk->ext_registry.hash); -#else - return rb_funcall(pk->ext_registry.hash, rb_intern("dup"), 0); -#endif } static VALUE Packer_register_type(int argc, VALUE* argv, VALUE self) @@ -359,12 +355,7 @@ case 2: /* register_type(0x7f, Time) {|obj| block... } */ rb_need_block(); -#ifdef HAVE_RB_BLOCK_LAMBDA proc = rb_block_lambda(); -#else - /* MRI 1.8 */ - proc = rb_block_proc(); -#endif arg = proc; break; case 3: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/msgpack/packer_ext_registry.c new/ext/msgpack/packer_ext_registry.c --- old/ext/msgpack/packer_ext_registry.c 2021-02-01 04:16:37.000000000 +0100 +++ new/ext/msgpack/packer_ext_registry.c 2022-01-22 10:08:54.000000000 +0100 @@ -43,37 +43,15 @@ void msgpack_packer_ext_registry_dup(msgpack_packer_ext_registry_t* src, msgpack_packer_ext_registry_t* dst) { -#ifdef HAVE_RB_HASH_DUP dst->hash = rb_hash_dup(src->hash); dst->cache = rb_hash_dup(src->cache); -#else - dst->hash = rb_funcall(src->hash, rb_intern("dup"), 0); - dst->cache = rb_funcall(src->cache, rb_intern("dup"), 0); -#endif } -#ifndef HAVE_RB_HASH_CLEAR - -static int -__rb_hash_clear_clear_i(key, value, dummy) - VALUE key, value, dummy; -{ - return ST_DELETE; -} - -#endif - VALUE msgpack_packer_ext_registry_put(msgpack_packer_ext_registry_t* pkrg, VALUE ext_module, int ext_type, VALUE proc, VALUE arg) { VALUE e = rb_ary_new3(3, INT2FIX(ext_type), proc, arg); /* clear lookup cache not to miss added type */ -#ifdef HAVE_RB_HASH_CLEAR rb_hash_clear(pkrg->cache); -#else - if(FIX2INT(rb_funcall(pkrg->cache, rb_intern("size"), 0)) > 0) { - rb_hash_foreach(pkrg->cache, __rb_hash_clear_clear_i, 0); - } -#endif return rb_hash_aset(pkrg->hash, ext_module, e); } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/msgpack/unpacker.c new/ext/msgpack/unpacker.c --- old/ext/msgpack/unpacker.c 2021-02-01 04:16:37.000000000 +0100 +++ new/ext/msgpack/unpacker.c 2022-01-22 10:08:54.000000000 +0100 @@ -151,8 +151,19 @@ return PRIMITIVE_OBJECT_COMPLETE; } +static inline int object_complete_symbol(msgpack_unpacker_t* uk, VALUE object) +{ + uk->last_object = object; + reset_head_byte(uk); + return PRIMITIVE_OBJECT_COMPLETE; +} + static inline int object_complete_ext(msgpack_unpacker_t* uk, int ext_type, VALUE str) { + if (uk->optimized_symbol_ext_type && ext_type == uk->symbol_ext_type) { + return object_complete_symbol(uk, rb_str_intern(str)); + } + VALUE proc = msgpack_unpacker_ext_registry_lookup(&uk->ext_registry, ext_type); if(proc != Qnil) { VALUE obj = rb_funcall(proc, s_call, 1, str); @@ -273,22 +284,27 @@ /* try optimized read */ size_t length = uk->reading_raw_remaining; if(length <= msgpack_buffer_top_readable_size(UNPACKER_BUFFER_(uk))) { - /* don't use zerocopy for hash keys but get a frozen string directly - * because rb_hash_aset freezes keys and it causes copying */ - bool will_freeze = uk->freeze || is_reading_map_key(uk); - VALUE string = msgpack_buffer_read_top_as_string(UNPACKER_BUFFER_(uk), length, will_freeze, raw_type == RAW_TYPE_STRING); int ret; - if(raw_type == RAW_TYPE_STRING || raw_type == RAW_TYPE_BINARY) { - ret = object_complete(uk, string); + if ((uk->optimized_symbol_ext_type && uk->symbol_ext_type == raw_type) || (uk->symbolize_keys && is_reading_map_key(uk))) { + VALUE symbol = msgpack_buffer_read_top_as_symbol(UNPACKER_BUFFER_(uk), length); + ret = object_complete_symbol(uk, symbol); } else { - ret = object_complete_ext(uk, 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 */ + bool will_freeze = uk->freeze || is_reading_map_key(uk); + VALUE string = msgpack_buffer_read_top_as_string(UNPACKER_BUFFER_(uk), length, will_freeze, raw_type == RAW_TYPE_STRING); + if(raw_type == RAW_TYPE_STRING || raw_type == RAW_TYPE_BINARY) { + ret = object_complete(uk, string); + } else { + ret = object_complete_ext(uk, raw_type, string); + } # if !HASH_ASET_DEDUPE - if(will_freeze) { - rb_obj_freeze(string); - } + if(will_freeze) { + rb_obj_freeze(string); + } # endif + } uk->reading_raw_remaining = 0; return ret; } @@ -705,18 +721,8 @@ break; case STACK_TYPE_MAP_VALUE: if(uk->symbolize_keys && rb_type(top->key) == T_STRING) { - /* here uses rb_intern_str instead of rb_intern so that Ruby VM can GC unused symbols */ -#ifdef HAVE_RB_STR_INTERN - /* rb_str_intern is added since MRI 2.2.0 */ + /* here uses rb_str_intern instead of rb_intern so that Ruby VM can GC unused symbols */ rb_hash_aset(top->object, rb_str_intern(top->key), uk->last_object); -#else -#ifndef HAVE_RB_INTERN_STR - /* MRI 1.8 doesn't have rb_intern_str or rb_intern2 */ - rb_hash_aset(top->object, ID2SYM(rb_intern(RSTRING_PTR(top->key))), uk->last_object); -#else - rb_hash_aset(top->object, ID2SYM(rb_intern_str(top->key)), uk->last_object); -#endif -#endif } else { rb_hash_aset(top->object, top->key, uk->last_object); } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/msgpack/unpacker.h new/ext/msgpack/unpacker.h --- old/ext/msgpack/unpacker.h 2021-02-01 04:16:37.000000000 +0100 +++ new/ext/msgpack/unpacker.h 2022-01-22 10:08:54.000000000 +0100 @@ -66,6 +66,8 @@ bool symbolize_keys; bool freeze; bool allow_unknown_ext; + bool optimized_symbol_ext_type; + int symbol_ext_type; }; #define UNPACKER_BUFFER_(uk) (&(uk)->buffer) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/msgpack/unpacker_class.c new/ext/msgpack/unpacker_class.c --- old/ext/msgpack/unpacker_class.c 2021-02-01 04:16:37.000000000 +0100 +++ new/ext/msgpack/unpacker_class.c 2022-01-22 10:08:54.000000000 +0100 @@ -369,12 +369,7 @@ case 1: /* register_type(0x7f) {|data| block... } */ rb_need_block(); -#ifdef HAVE_RB_BLOCK_LAMBDA proc = rb_block_lambda(); -#else - /* MRI 1.8 */ - proc = rb_block_proc(); -#endif arg = proc; ext_module = Qnil; break; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/msgpack/symbol.rb new/lib/msgpack/symbol.rb --- old/lib/msgpack/symbol.rb 2021-02-01 04:16:37.000000000 +0100 +++ new/lib/msgpack/symbol.rb 2022-01-22 10:08:54.000000000 +0100 @@ -1,9 +1,19 @@ class Symbol - def to_msgpack_ext - [to_s].pack('A*') + # to_msgpack_ext is supposed to return a binary string. + # The canonical way to do it for symbols would be: + # [to_s].pack('A*') + # However in this instance we can take a shortcut + if method_defined?(:name) + alias_method :to_msgpack_ext, :name + else + alias_method :to_msgpack_ext, :to_s end def self.from_msgpack_ext(data) - data.unpack('A*').first.to_sym + # from_msgpack_ext is supposed to parse a binary string. + # The canonical way to do it for symbols would be: + # data.unpack1('A*').to_sym + # However in this instance we can take a shortcut + data.to_sym end -end \ No newline at end of file +end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/msgpack/time.rb new/lib/msgpack/time.rb --- old/lib/msgpack/time.rb 2021-02-01 04:16:37.000000000 +0100 +++ new/lib/msgpack/time.rb 2022-01-22 10:08:54.000000000 +0100 @@ -18,7 +18,7 @@ else lambda do |payload| tv = MessagePack::Timestamp.from_msgpack_ext(payload) - ::Time.at(tv.sec, tv.nsec / 1000.0) + ::Time.at(tv.sec, tv.nsec / 1000.0r) end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/msgpack/version.rb new/lib/msgpack/version.rb --- old/lib/msgpack/version.rb 2021-02-01 04:16:37.000000000 +0100 +++ new/lib/msgpack/version.rb 2022-01-22 10:08:54.000000000 +0100 @@ -1,5 +1,5 @@ module MessagePack - VERSION = "1.4.2" + VERSION = "1.4.4" # 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. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/msgpack.rb new/lib/msgpack.rb --- old/lib/msgpack.rb 2021-02-01 04:16:37.000000000 +0100 +++ new/lib/msgpack.rb 2022-01-22 10:08:54.000000000 +0100 @@ -1,9 +1,8 @@ require "msgpack/version" if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby" # This is same with `/java/ =~ RUBY_VERSION` - require "java" require "msgpack/msgpack.jar" - org.msgpack.jruby.MessagePackLibrary.new.load(JRuby.runtime, false) + JRuby::Util.load_ext("org.msgpack.jruby.MessagePackLibrary") else require "msgpack/msgpack" end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/metadata new/metadata --- old/metadata 2021-02-01 04:16:37.000000000 +0100 +++ new/metadata 2022-01-22 10:08:54.000000000 +0100 @@ -1,7 +1,7 @@ --- !ruby/object:Gem::Specification name: msgpack version: !ruby/object:Gem::Version - version: 1.4.2 + version: 1.4.4 platform: ruby authors: - Sadayuki Furuhashi @@ -10,7 +10,7 @@ autorequire: bindir: bin cert_chain: [] -date: 2021-02-01 00:00:00.000000000 Z +date: 2022-01-22 00:00:00.000000000 Z dependencies: - !ruby/object:Gem::Dependency name: bundler @@ -46,14 +46,14 @@ requirements: - - ">=" - !ruby/object:Gem::Version - version: '0' + version: 1.1.9 type: :development prerelease: false version_requirements: !ruby/object:Gem::Requirement requirements: - - ">=" - !ruby/object:Gem::Version - version: '0' + version: 1.1.9 - !ruby/object:Gem::Dependency name: rspec requirement: !ruby/object:Gem::Requirement @@ -108,9 +108,9 @@ - ext/msgpack/extconf.rb extra_rdoc_files: [] files: +- ".github/workflows/ci.yaml" - ".gitignore" - ".rubocop.yml" -- ".travis.yml" - ChangeLog - Gemfile - LICENSE @@ -229,32 +229,8 @@ - !ruby/object:Gem::Version version: '0' requirements: [] -rubygems_version: 3.2.3 +rubygems_version: 3.3.3 signing_key: specification_version: 4 summary: MessagePack, a binary-based efficient data interchange format. -test_files: -- spec/cases.json -- spec/cases.msg -- spec/cases_compact.msg -- spec/cases_spec.rb -- spec/cruby/buffer_io_spec.rb -- spec/cruby/buffer_packer.rb -- spec/cruby/buffer_spec.rb -- spec/cruby/buffer_unpacker.rb -- spec/cruby/unpacker_spec.rb -- spec/ext_value_spec.rb -- spec/exttypes.rb -- spec/factory_spec.rb -- spec/format_spec.rb -- spec/jruby/benchmarks/shootout_bm.rb -- spec/jruby/benchmarks/symbolize_keys_bm.rb -- spec/jruby/unpacker_spec.rb -- spec/msgpack_spec.rb -- spec/pack_spec.rb -- spec/packer_spec.rb -- spec/random_compat.rb -- spec/spec_helper.rb -- spec/timestamp_spec.rb -- spec/unpack_spec.rb -- spec/unpacker_spec.rb +test_files: [] diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/msgpack.gemspec new/msgpack.gemspec --- old/msgpack.gemspec 2021-02-01 04:16:37.000000000 +0100 +++ new/msgpack.gemspec 2022-01-22 10:08:54.000000000 +0100 @@ -18,13 +18,12 @@ s.files = `git ls-files`.split("\n") s.extensions = ["ext/msgpack/extconf.rb"] end - s.test_files = `git ls-files -- {test,spec}/*`.split("\n") s.required_ruby_version = ">= 2.4" s.add_development_dependency 'bundler' s.add_development_dependency 'rake' - s.add_development_dependency 'rake-compiler' + s.add_development_dependency 'rake-compiler', ['>= 1.1.9'] s.add_development_dependency 'rspec', ['~> 3.3'] s.add_development_dependency 'yard' s.add_development_dependency 'json' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spec/factory_spec.rb new/spec/factory_spec.rb --- old/spec/factory_spec.rb 2021-02-01 04:16:37.000000000 +0100 +++ new/spec/factory_spec.rb 2022-01-22 10:08:54.000000000 +0100 @@ -280,6 +280,23 @@ unpacker.feed(packed_symbol).unpack end + context 'using the optimized symbol unpacker' do + before do + skip if IS_JRUBY # JRuby implementation doesn't support the optimized symbols unpacker for now + subject.register_type( + 0x00, + ::Symbol, + packer: :to_msgpack_ext, + unpacker: :from_msgpack_ext, + optimized_symbols_parsing: true, + ) + end + + it 'lets symbols survive a roundtrip' do + expect(symbol_after_roundtrip).to be :symbol + end + end + context 'if no ext type is registered for symbols' do it 'converts symbols to string' do expect(symbol_after_roundtrip).to eq 'symbol' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spec/msgpack_spec.rb new/spec/msgpack_spec.rb --- old/spec/msgpack_spec.rb 2021-02-01 04:16:37.000000000 +0100 +++ new/spec/msgpack_spec.rb 2022-01-22 10:08:54.000000000 +0100 @@ -115,7 +115,7 @@ expect { MessagePack.pack(self) }.to raise_error(NoMethodError, /^undefined method `to_msgpack'/) end - it 'rasies an error on #unpack with garbage' do + it 'raises an error on #unpack with garbage' do skip "but nothing was raised. why?" expect { MessagePack.unpack('asdka;sd') }.to raise_error(MessagePack::UnpackError) end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spec/packer_spec.rb new/spec/packer_spec.rb --- old/spec/packer_spec.rb 2021-02-01 04:16:37.000000000 +0100 +++ new/spec/packer_spec.rb 2022-01-22 10:08:54.000000000 +0100 @@ -488,6 +488,24 @@ it { is_expected.to eq "\xC7\x0F\x01value_msgpacked" } end + shared_examples_for 'extension subclasses core type' do |klass| + before { stub_const('Value', Class.new(klass)) } + let(:object) { Value.new } + subject { packer.pack(object).to_s } + + it "defaults to #{klass.name} packer if no extension is present" do + expect(subject).to eq(MessagePack.dump(klass.new)) + end + + it "uses core type extension for #{klass.name}" do + packer.register_type(0x01, Value, ->(_) { 'value_msgpacked' }) + expect(subject).to eq("\xC7\x0F\x01value_msgpacked") + end + end + it_behaves_like 'extension subclasses core type', Hash + it_behaves_like 'extension subclasses core type', Array + it_behaves_like 'extension subclasses core type', String + context 'when registering a type for symbols' do before { packer.register_type(0x00, ::Symbol, :to_msgpack_ext) } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spec/spec_helper.rb new/spec/spec_helper.rb --- old/spec/spec_helper.rb 2021-02-01 04:16:37.000000000 +0100 +++ new/spec/spec_helper.rb 2022-01-22 10:08:54.000000000 +0100 @@ -15,6 +15,16 @@ require 'msgpack' +if GC.respond_to?(:verify_compaction_references) + # This method was added in Ruby 3.0.0. Calling it this way asks the GC to + # move objects around, helping to find object movement bugs. + GC.verify_compaction_references(double_heap: true, toward: :empty) +end + +if GC.respond_to?(:auto_compact=) + GC.auto_compact = true +end + def java? /java/ =~ RUBY_PLATFORM end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spec/timestamp_spec.rb new/spec/timestamp_spec.rb --- old/spec/timestamp_spec.rb 2021-02-01 04:16:37.000000000 +0100 +++ new/spec/timestamp_spec.rb 2022-01-22 10:08:54.000000000 +0100 @@ -2,6 +2,8 @@ require 'spec_helper' +IS_JRUBY = Kernel.const_defined?(:JRUBY_VERSION) + describe MessagePack::Timestamp do describe 'malformed format' do it do @@ -60,6 +62,44 @@ it 'runs correctly (regression)' do expect(factory.unpack(factory.pack(Time.utc(2200)))).to eq(Time.utc(2200)) end + + let(:time32_max) { Time.new(2106, 2, 7, 6, 28, 15, "+00:00") } + it 'is serialized into timestamp32' do + expect(factory.pack(time32_max).size).to be 6 + expect(factory.unpack(factory.pack(time32_max)).utc).to eq(time32_max) + end + + let(:time64_min) { Time.new(2106, 2, 7, 6, 28, 16, "+00:00") } + it 'is serialized into timestamp64' do + expect(factory.pack(time64_min).size).to be 10 + expect(factory.unpack(factory.pack(time64_min)).utc).to eq(time64_min) + end + + let(:time64_max) { Time.at(Time.new(2514, 5, 30, 1, 53, 3, "+00:00").to_i, 999999999 / 1000.0r).utc } # TODO: use Time.at(sec, nsec, :nsec) when removing Ruby 2.4 from the list + it 'is serialized into timestamp64' do + expect(factory.pack(time64_max).size).to be 10 + expect(factory.unpack(factory.pack(time64_max)).utc).to eq(time64_max) + end + + let(:time96_positive_min) { Time.new(2514, 5, 30, 1, 53, 4, "+00:00") } + it 'is serialized into timestamp96' do + expect(factory.pack(time96_positive_min).size).to be 15 + expect(factory.unpack(factory.pack(time96_positive_min)).utc).to eq(time96_positive_min) + end + + let(:time96_min) { Time.at(-2**63).utc } + it 'is serialized into timestamp96' do + skip if IS_JRUBY # JRuby cannot handle numerics larger than long + expect(factory.pack(time96_min).size).to be 15 + expect(factory.unpack(factory.pack(time96_min)).utc).to eq(time96_min) + end + + let(:time96_max) { Time.at(2**63 - 1).utc } + it 'is serialized into timestamp96' do + skip if IS_JRUBY # JRuby cannot handle numerics larger than long + expect(factory.pack(time96_max).size).to be 15 + expect(factory.unpack(factory.pack(time96_max)).utc).to eq(time96_max) + end end describe 'register_type with MessagePack::Timestamp' do diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spec/unpacker_spec.rb new/spec/unpacker_spec.rb --- old/spec/unpacker_spec.rb 2021-02-01 04:16:37.000000000 +0100 +++ new/spec/unpacker_spec.rb 2022-01-22 10:08:54.000000000 +0100 @@ -36,6 +36,15 @@ unpacker.each { |obj| hashes = obj } expect(hashes[0].keys.first).to equal(hashes[1].keys.first) end + + it 'ensure strings are not deduplicated' do + sample_data = ["foo"] + sample_packed = MessagePack.pack(sample_data).force_encoding('ASCII-8BIT') + unpacker.feed(sample_packed) + ary = nil + unpacker.each { |obj| ary = obj } + expect(ary.first.frozen?).to eq(false) + end end it 'gets IO or object which has #read to read data from it' do @@ -635,7 +644,7 @@ MessagePack.unpack(MessagePack.pack(array)).size.should == 10_000 end - it 'preserve string encoding (issue #200)' do + it 'preserves string encoding (issue #200)' do string = 'a'.force_encoding(Encoding::UTF_8) MessagePack.unpack(MessagePack.pack(string)).encoding.should == string.encoding