msgpack 1.3.3-java → 1.4.3-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd83394ab16cee94026b1022400f09a82074ddd7f9380f647f6f89d8c1613197
-  data.tar.gz: ddf9c1a2de71f9581edb08433f61022ec5ada2e934e22587f808c419cac759aa
+  metadata.gz: c13610f5243e8a0bbcb5be9d2e4cec62e5f90f443a90c61501b088ebd8d958c9
+  data.tar.gz: 5afe456db4aa4cf41795d8bd62b66b6ce94887408edc2629ec896a69f31b9741
 SHA512:
-  metadata.gz: '09552bad837d481738eeadeb80a047310a4568be65e625ff75157a995432ee2b6b40b0d4462eb3392293c1c5855d982169ed218a56c2380a9c9f3290a7233d2b'
-  data.tar.gz: 1608b50ebc75284b5f698b6ae2c8afc2cb05e33e4a395d895afbe9bc747e57084d46e11f554bbcd61475972e7420e72c68f040aa369a53dfcfdc53f26652f1c2
+  metadata.gz: c1760ab752e904de9d80651134c92a21763bf161d64de9c7564b1e9532bb84ff0b31b5006eb78790c9c49293cf017a222806dfbc9a6c282ef242ebbb6c2d6a4b
+  data.tar.gz: 4d9c0f170b9aeff8e08f74aa9103c7ba2949132d3aa3772f0b6db596ed085738c8f98d78b5f6d35c09b98bb264de6c82f43ebe9b0689ca468f57cbeba85061bc

data/lib/msgpack/symbol.rb

@@ -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
+end

data/lib/msgpack/time.rb

@@ -18,7 +18,7 @@ module MessagePack
                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
 

data/lib/msgpack/version.rb

@@ -1,10 +1,6 @@
 module MessagePack
-  VERSION = "1.3.3"
-
-  # NOTE for msgpack-ruby maintainer:
-  # Check these things to release new binaryes for new Ruby versions (especially for Windows):
-  # * versions/supports of rake-compiler & rake-compiler-dock
-  #   https://github.com/rake-compiler/rake-compiler-dock/blob/master/History.md
-  # * update RUBY_CC_VERSION in Rakefile
-  # * check Ruby dependency of released mswin gem details
+  VERSION = "1.4.3"
+  # 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.
 end

data/lib/msgpack.rb

@@ -1,15 +1,10 @@
 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
-  begin
-    require "msgpack/#{RUBY_VERSION[/\d+.\d+/]}/msgpack"
-  rescue LoadError
-    require "msgpack/msgpack"
-  end
+  require "msgpack/msgpack"
 end
 
 require "msgpack/packer"

data/spec/factory_spec.rb

@@ -280,6 +280,23 @@ describe MessagePack::Factory do
       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'

data/spec/msgpack_spec.rb

@@ -115,7 +115,7 @@ describe MessagePack do
       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

data/spec/packer_spec.rb

@@ -488,6 +488,24 @@ describe MessagePack::Packer do
       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) }
 

data/spec/spec_helper.rb

@@ -15,10 +15,37 @@ end
 
 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
 
+# checking if Hash#[]= (rb_hash_aset) dedupes string keys
+def automatic_string_keys_deduplication?
+  h = {}
+  x = {}
+  r = rand.to_s
+  h[%W(#{r}).join('')] = :foo
+  x[%W(#{r}).join('')] = :foo
+
+  x.keys[0].equal?(h.keys[0])
+end
+
+def string_deduplication?
+  r1 = rand.to_s
+  r2 = r1.dup
+  (-r1).equal?(-r2)
+end
+
 if java?
   RSpec.configure do |c|
     c.treat_symbols_as_metadata_keys_with_true_values = true

data/spec/timestamp_spec.rb

@@ -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 @@ describe MessagePack::Timestamp do
     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

data/spec/unpacker_spec.rb

@@ -18,13 +18,35 @@ describe MessagePack::Unpacker do
   it 'gets options to specify how to unpack values' do
     u1 = MessagePack::Unpacker.new
     u1.symbolize_keys?.should == false
+    u1.freeze?.should == false
     u1.allow_unknown_ext?.should == false
 
-    u2 = MessagePack::Unpacker.new(symbolize_keys: true, allow_unknown_ext: true)
+    u2 = MessagePack::Unpacker.new(symbolize_keys: true, freeze: true, allow_unknown_ext: true)
     u2.symbolize_keys?.should == true
+    u2.freeze?.should == true
     u2.allow_unknown_ext?.should == true
   end
 
+  if automatic_string_keys_deduplication?
+    it 'ensure string hash keys are deduplicated' do
+      sample_data = [{"foo" => 1}, {"foo" => 2}]
+      sample_packed = MessagePack.pack(sample_data).force_encoding('ASCII-8BIT')
+      unpacker.feed(sample_packed)
+      hashes = nil
+      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
     sample_data = {"message" => "morning!", "num" => 1}
     sample_packed = MessagePack.pack(sample_data).force_encoding('ASCII-8BIT')
@@ -621,6 +643,14 @@ describe MessagePack::Unpacker do
       array = ['foo'] * 10_000
       MessagePack.unpack(MessagePack.pack(array)).size.should == 10_000
     end
+
+    it 'preserves string encoding (issue #200)' do
+      string = 'a'.force_encoding(Encoding::UTF_8)
+      MessagePack.unpack(MessagePack.pack(string)).encoding.should == string.encoding
+
+      string *= 256
+      MessagePack.unpack(MessagePack.pack(string)).encoding.should == string.encoding
+    end
   end
 
   context 'extensions' do
@@ -651,6 +681,88 @@ describe MessagePack::Unpacker do
       end
     end
 
+    context 'freeze' do
+      let :struct do
+        {'hello' => 'world', 'nested' => ['object', {'structure' => true}]}
+      end
+
+      let :buffer do
+        MessagePack.pack(struct)
+      end
+
+      let :unpacker do
+        described_class.new(:freeze => true)
+      end
+
+      it 'can freeze objects when using .unpack' do
+        parsed_struct = MessagePack.unpack(buffer, freeze: true)
+        parsed_struct.should == struct
+
+        parsed_struct.should be_frozen
+        parsed_struct['hello'].should be_frozen
+        parsed_struct['nested'].should be_frozen
+        parsed_struct['nested'][0].should be_frozen
+        parsed_struct['nested'][1].should be_frozen
+
+        if string_deduplication?
+          parsed_struct.keys[0].should be_equal('hello'.freeze)
+          parsed_struct.keys[1].should be_equal('nested'.freeze)
+          parsed_struct.values[0].should be_equal('world'.freeze)
+          parsed_struct.values[1][0].should be_equal('object'.freeze)
+          parsed_struct.values[1][1].keys[0].should be_equal('structure'.freeze)
+        end
+      end
+
+      it 'can freeze objects when using #each' do
+        objs = []
+        unpacker.feed(buffer)
+        unpacker.each do |obj|
+          objs << obj
+        end
+
+        parsed_struct = objs.first
+        parsed_struct.should == struct
+
+        parsed_struct.should be_frozen
+        parsed_struct['hello'].should be_frozen
+        parsed_struct['nested'].should be_frozen
+        parsed_struct['nested'][0].should be_frozen
+        parsed_struct['nested'][1].should be_frozen
+
+        if string_deduplication?
+          parsed_struct.keys[0].should be_equal('hello'.freeze)
+          parsed_struct.keys[1].should be_equal('nested'.freeze)
+          parsed_struct.values[0].should be_equal('world'.freeze)
+          parsed_struct.values[1][0].should be_equal('object'.freeze)
+          parsed_struct.values[1][1].keys[0].should be_equal('structure'.freeze)
+        end
+      end
+
+      it 'can freeze objects when using #feed_each' do
+        objs = []
+        unpacker.feed_each(buffer) do |obj|
+          objs << obj
+        end
+
+        parsed_struct = objs.first
+        parsed_struct.should == struct
+
+        parsed_struct.should be_frozen
+        parsed_struct['hello'].should be_frozen
+        parsed_struct['nested'].should be_frozen
+        parsed_struct['nested'][0].should be_frozen
+        parsed_struct['nested'][1].should be_frozen
+
+        if string_deduplication?
+          parsed_struct.keys[0].should be_equal('hello'.freeze)
+          parsed_struct.keys[1].should be_equal('nested'.freeze)
+          parsed_struct.values[0].should be_equal('world'.freeze)
+          parsed_struct.values[1][0].should be_equal('object'.freeze)
+          parsed_struct.values[1][1].keys[0].should be_equal('structure'.freeze)
+        end
+      end
+    end
+
     context 'binary encoding', :encodings do
       let :buffer do
         MessagePack.pack({'hello' => 'world', 'nested' => ['object', {'structure' => true}]})

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: msgpack
 version: !ruby/object:Gem::Version
-  version: 1.3.3
+  version: 1.4.3
 platform: java
 authors:
 - Sadayuki Furuhashi
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-02-05 00:00:00.000000000 Z
+date: 2022-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -43,17 +43,17 @@ dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
   name: rake-compiler
   prerelease: false
   type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
@@ -153,14 +153,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.2.29
 signing_key:
 specification_version: 4
 summary: MessagePack, a binary-based efficient data interchange format.