msgpack 0.7.4 → 1.3.3

data/spec/msgpack_spec.rb

@@ -159,4 +159,56 @@ describe MessagePack do
       packed.should start_with("\xDA\x00\x20")
     end
   end
+
+  context 'when a Bignum has a small value' do
+    tests['numbers'].take(10).each do |desc, unpacked, packed|
+      it("encodes #{desc} to the smallest representation") do
+        bignum = (1 << 64).coerce(unpacked)[0]
+        MessagePack.pack(bignum).should eq(packed)
+      end
+    end
+  end
+
+  context 'when the source is na IO-like object' do
+    require 'tempfile'
+    require 'stringio'
+
+    it 'work with IO destination object as 2nd argument of MessagePack.pack' do
+      Tempfile.create("pack-test") do |io|
+        return_value = MessagePack.pack(utf8enc('hello world'), io)
+        return_value.should be_nil
+
+        io.rewind
+        io.read.force_encoding(Encoding::ASCII_8BIT).should eq("\xABhello world".force_encoding(Encoding::ASCII_8BIT))
+      end
+    end
+
+    it 'work with IO-like StringIO destination object as 2nd argument of MessagePack.pack' do
+      io = StringIO.new
+      return_value = MessagePack.pack(utf8enc('hello world'), io)
+      return_value.should be_nil
+
+      io.rewind
+      io.read.force_encoding(Encoding::ASCII_8BIT).should eq("\xABhello world".force_encoding(Encoding::ASCII_8BIT))
+    end
+
+    it 'work with IO source object as source of MessagePack.unpack' do
+      Tempfile.create("unpack-test") do |io|
+        MessagePack.pack(utf8enc('hello world'), io)
+        io.rewind
+
+        return_value = MessagePack.unpack(io)
+        return_value.should eq(utf8enc('hello world'))
+      end
+    end
+
+    it 'work with IO-like StringIO object of MessagePack.unpack' do
+      io = StringIO.new
+      MessagePack.pack(utf8enc('hello world'), io)
+      io.rewind
+
+      return_value = MessagePack.unpack(io)
+      return_value.should eq(utf8enc('hello world'))
+    end
+  end
 end

data/spec/packer_spec.rb

@@ -134,6 +134,41 @@ describe MessagePack::Packer do
     packer.to_s.should == "\x81"
   end
 
+  it 'write_bin_header 0' do
+    packer.write_bin_header(0)
+    packer.to_s.should == "\xC4\x00"
+  end
+
+  it 'write_bin_header 255' do
+    packer.write_bin_header(255)
+    packer.to_s.should == "\xC4\xFF"
+  end
+
+  it 'write_bin_header 256' do
+    packer.write_bin_header(256)
+    packer.to_s.should == "\xC5\x01\x00"
+  end
+
+  it 'write_bin_header 65535' do
+    packer.write_bin_header(65535)
+    packer.to_s.should == "\xC5\xFF\xFF"
+  end
+
+  it 'write_bin_header 65536' do
+    packer.write_bin_header(65536)
+    packer.to_s.should == "\xC6\x00\x01\x00\x00"
+  end
+
+  it 'write_bin_header 999999' do
+    packer.write_bin_header(999999)
+    packer.to_s.should == "\xC6\x00\x0F\x42\x3F"
+  end
+
+  it 'write_bin' do
+    packer.write_bin("hello")
+    packer.to_s.should == "\xC4\x05hello"
+  end
+
   describe '#write_float32' do
     tests = [
       ['small floats', 3.14, "\xCA\x40\x48\xF5\xC3"],
@@ -178,6 +213,29 @@ describe MessagePack::Packer do
     Array.new.to_msgpack.class.should == String
   end
 
+  it 'to_msgpack with packer equals to_msgpack' do
+    nil.to_msgpack(MessagePack::Packer.new).to_str.should == nil.to_msgpack
+    true.to_msgpack(MessagePack::Packer.new).to_str.should == true.to_msgpack
+    false.to_msgpack(MessagePack::Packer.new).to_str.should == false.to_msgpack
+    1.to_msgpack(MessagePack::Packer.new).to_str.should == 1.to_msgpack
+    1.0.to_msgpack(MessagePack::Packer.new).to_str.should == 1.0.to_msgpack
+    "".to_msgpack(MessagePack::Packer.new).to_str.should == "".to_msgpack
+    Hash.new.to_msgpack(MessagePack::Packer.new).to_str.should == Hash.new.to_msgpack
+    Array.new.to_msgpack(MessagePack::Packer.new).to_str.should == Array.new.to_msgpack
+  end
+
+  it 'raises type error on wrong type' do
+    packer = MessagePack::Packer.new
+    expect { packer.write_float "hello" }.to raise_error(TypeError)
+    expect { packer.write_string 1 }.to raise_error(TypeError)
+    expect { packer.write_bin 1 }.to raise_error(TypeError)
+    expect { packer.write_array "hello" }.to raise_error(TypeError)
+    expect { packer.write_hash "hello" }.to raise_error(TypeError)
+    expect { packer.write_symbol "hello" }.to raise_error(TypeError)
+    expect { packer.write_int "hello" }.to raise_error(TypeError)
+    expect { packer.write_extension "hello" }.to raise_error(TypeError)
+  end
+
   class CustomPack01
     def to_msgpack(pk=nil)
       return MessagePack.pack(self, pk) unless pk.class == MessagePack::Packer
@@ -323,6 +381,148 @@ describe MessagePack::Packer do
       expect(two[:class]).to eq(ValueTwo)
       expect(two[:packer]).to eq(:to_msgpack_ext)
     end
+
+    context 'when it has no ext type but a super class has' do
+      before { stub_const('Value', Class.new) }
+      before do
+        Value.class_eval do
+          def to_msgpack_ext
+            'value_msgpacked'
+          end
+        end
+      end
+      before { packer.register_type(0x01, Value, :to_msgpack_ext) }
+
+      context "when it is a child class" do
+        before { stub_const('InheritedValue', Class.new(Value)) }
+        subject { packer.pack(InheritedValue.new).to_s }
+
+        it { is_expected.to eq "\xC7\x0F\x01value_msgpacked" }
+
+        context "when it is a grandchild class" do
+          before { stub_const('InheritedTwiceValue', Class.new(InheritedValue)) }
+          subject { packer.pack(InheritedTwiceValue.new).to_s }
+
+          it { is_expected.to eq "\xC7\x0F\x01value_msgpacked" }
+        end
+      end
+    end
+
+    context 'when it and its super class has an ext type' do
+      before { stub_const('Value', Class.new) }
+      before do
+        Value.class_eval do
+          def to_msgpack_ext
+            'value_msgpacked'
+          end
+        end
+      end
+      before { packer.register_type(0x01, Value, :to_msgpack_ext) }
+
+      context "when it is a child class" do
+        before { stub_const('InheritedValue', Class.new(Value)) }
+        before do
+          InheritedValue.class_eval do
+            def to_msgpack_ext
+              'inherited_value_msgpacked'
+            end
+          end
+        end
+
+        before { packer.register_type(0x02, InheritedValue, :to_msgpack_ext) }
+        subject { packer.pack(InheritedValue.new).to_s }
+
+        it { is_expected.to eq "\xC7\x19\x02inherited_value_msgpacked" }
+      end
+
+      context "even when it is a child class" do
+        before { stub_const('InheritedValue', Class.new(Value)) }
+        before do
+          InheritedValue.class_eval do
+            def to_msgpack_ext
+              'inherited_value_msgpacked'
+            end
+          end
+        end
+
+        before { packer.register_type(0x02, InheritedValue, :to_msgpack_ext) }
+        subject { packer.pack(Value.new).to_s }
+
+        it { is_expected.to eq "\xC7\x0F\x01value_msgpacked" }
+      end
+    end
+
+    context 'when it has no ext type but an included module has' do
+      subject { packer.pack(Value.new).to_s }
+
+      before do
+        mod = Module.new do
+          def to_msgpack_ext
+            'value_msgpacked'
+          end
+        end
+        stub_const('Mod', mod)
+      end
+      before { packer.register_type(0x01, Mod, :to_msgpack_ext) }
+
+      before { stub_const('Value', Class.new{ include Mod }) }
+
+      it { is_expected.to eq "\xC7\x0F\x01value_msgpacked" }
+    end
+
+    context 'when it has no ext type but it was extended by a module which has one' do
+      subject { packer.pack(object).to_s }
+      let(:object) { Object.new.extend Mod }
+
+      before do
+        mod = Module.new do
+          def to_msgpack_ext
+            'value_msgpacked'
+          end
+        end
+        stub_const('Mod', mod)
+      end
+      before { packer.register_type(0x01, Mod, :to_msgpack_ext) }
+
+
+      it { is_expected.to eq "\xC7\x0F\x01value_msgpacked" }
+    end
+
+    context 'when registering a type for symbols' do
+      before { packer.register_type(0x00, ::Symbol, :to_msgpack_ext) }
+
+      it 'packs symbols in an ext type' do
+        expect(packer.pack(:symbol).to_s).to eq "\xc7\x06\x00symbol"
+      end
+    end
+  end
+
+  describe "fixnum and bignum" do
+    it "fixnum.to_msgpack" do
+      23.to_msgpack.should == "\x17"
+    end
+
+    it "fixnum.to_msgpack(packer)" do
+      23.to_msgpack(packer)
+      packer.to_s.should == "\x17"
+    end
+
+    it "bignum.to_msgpack" do
+      -4294967296.to_msgpack.should == "\xD3\xFF\xFF\xFF\xFF\x00\x00\x00\x00"
+    end
+
+    it "bignum.to_msgpack(packer)" do
+      -4294967296.to_msgpack(packer)
+      packer.to_s.should == "\xD3\xFF\xFF\xFF\xFF\x00\x00\x00\x00"
+    end
+
+    it "unpack(fixnum)" do
+      MessagePack.unpack("\x17").should == 23
+    end
+
+    it "unpack(bignum)" do
+      MessagePack.unpack("\xD3\xFF\xFF\xFF\xFF\x00\x00\x00\x00").should == -4294967296
+    end
   end
 
   describe "ext formats" do

data/spec/timestamp_spec.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe MessagePack::Timestamp do
+  describe 'malformed format' do
+    it do
+      expect do
+        MessagePack::Timestamp.from_msgpack_ext([0xd4, 0x00].pack("C*"))
+      end.to raise_error(MessagePack::MalformedFormatError)
+    end
+  end
+
+  describe 'register_type with Time' do
+    let(:factory) do
+      factory = MessagePack::Factory.new
+      factory.register_type(
+        MessagePack::Timestamp::TYPE,
+        Time,
+        packer: MessagePack::Time::Packer,
+        unpacker: MessagePack::Time::Unpacker
+      )
+      factory
+    end
+
+    let(:time) { Time.local(2019, 6, 17, 1, 2, 3, 123_456_789 / 1000.0) }
+    it 'serializes and deserializes Time' do
+      prefix_fixext8_with_type_id = [0xd7, -1].pack("c*")
+
+      packed = factory.pack(time)
+      expect(packed).to start_with(prefix_fixext8_with_type_id)
+      expect(packed.size).to eq(10)
+      unpacked = factory.unpack(packed)
+      expect(unpacked.to_i).to eq(time.to_i)
+      expect(unpacked.to_f).to eq(time.to_f)
+      # expect(unpacked).to eq(time) # we can't do it because of nsec (rational vs float?)
+    end
+
+    let(:time_without_nsec) { Time.local(2019, 6, 17, 1, 2, 3, 0) }
+    it 'serializes time without nanosec as fixext4' do
+      prefix_fixext4_with_type_id = [0xd6, -1].pack("c*")
+
+      packed = factory.pack(time_without_nsec)
+      expect(packed).to start_with(prefix_fixext4_with_type_id)
+      expect(packed.size).to eq(6)
+      unpacked = factory.unpack(packed)
+      expect(unpacked).to eq(time_without_nsec)
+    end
+
+    let(:time_after_2514) { Time.at(1 << 34) } # the max num of 34bit int means 2514-05-30 01:53:04 UTC
+    it 'serializes time after 2038 as ext8' do
+      prefix_ext8_with_12bytes_payload_and_type_id = [0xc7, 12, -1].pack("c*")
+
+      expect(time_after_2514.to_i).to be > 0xffffffff
+      packed = factory.pack(time_after_2514)
+      expect(packed).to start_with(prefix_ext8_with_12bytes_payload_and_type_id)
+      expect(packed.size).to eq(15)
+    end
+
+    it 'runs correctly (regression)' do
+      expect(factory.unpack(factory.pack(Time.utc(2200)))).to eq(Time.utc(2200))
+    end
+  end
+
+  describe 'register_type with MessagePack::Timestamp' do
+    let(:factory) do
+      factory = MessagePack::Factory.new
+      factory.register_type(MessagePack::Timestamp::TYPE, MessagePack::Timestamp)
+      factory
+    end
+
+    let(:timestamp) { MessagePack::Timestamp.new(Time.now.tv_sec, 123_456_789) }
+    it 'serializes and deserializes MessagePack::Timestamp' do
+      packed = factory.pack(timestamp)
+      unpacked = factory.unpack(packed)
+      expect(unpacked).to eq(timestamp)
+    end
+  end
+
+  describe 'timestamp32' do
+    it 'handles [1, 0]' do
+      t = MessagePack::Timestamp.new(1, 0)
+
+      payload = t.to_msgpack_ext
+      unpacked = MessagePack::Timestamp.from_msgpack_ext(payload)
+
+      expect(unpacked).to eq(t)
+    end
+  end
+
+  describe 'timestamp64' do
+    it 'handles [1, 1]' do
+      t = MessagePack::Timestamp.new(1, 1)
+
+      payload = t.to_msgpack_ext
+      unpacked = MessagePack::Timestamp.from_msgpack_ext(payload)
+
+      expect(unpacked).to eq(t)
+    end
+  end
+
+  describe 'timestamp96' do
+    it 'handles [-1, 0]' do
+      t = MessagePack::Timestamp.new(-1, 0)
+
+      payload = t.to_msgpack_ext
+      unpacked = MessagePack::Timestamp.from_msgpack_ext(payload)
+
+      expect(unpacked).to eq(t)
+    end
+
+    it 'handles [-1, 999_999_999]' do
+      t = MessagePack::Timestamp.new(-1, 999_999_999)
+
+      payload = t.to_msgpack_ext
+      unpacked = MessagePack::Timestamp.from_msgpack_ext(payload)
+
+      expect(unpacked).to eq(t)
+    end
+  end
+end

data/spec/unpacker_spec.rb

@@ -477,6 +477,24 @@ describe MessagePack::Unpacker do
       expect(two[:class]).to be_nil
       expect(two[:unpacker]).to be_instance_of(Proc)
     end
+
+    describe "registering an ext type for a module" do
+      subject { unpacker.feed("\xc7\x06\x00module").unpack }
+
+      let(:unpacker) { MessagePack::Unpacker.new }
+
+      before do
+        mod = Module.new do
+          def self.from_msgpack_ext(data)
+            "unpacked #{data}"
+          end
+        end
+        stub_const('Mod', mod)
+      end
+
+      before { unpacker.register_type(0x00, Mod, :from_msgpack_ext) }
+      it { is_expected.to eq "unpacked module" }
+    end
   end
 
   def flatten(struct, results = [])
@@ -564,6 +582,17 @@ describe MessagePack::Unpacker do
         objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
       end
     end
+
+    context 'with a stream and symbolize_keys passed to the constructor' do
+      it 'yields each object in the stream, with symbolized keys' do
+        objects = []
+        unpacker = described_class.new(StringIO.new(buffer1 + buffer2 + buffer3), symbolize_keys: true)
+        unpacker.each do |obj|
+          objects << obj
+        end
+        objects.should == [{:foo => 'bar'}, {:hello => {:world => [1, 2, 3]}}, {:x => 'y'}]
+      end
+    end
   end
 
   describe '#feed_each' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: msgpack
 version: !ruby/object:Gem::Version
-  version: 0.7.4
+  version: 1.3.3
 platform: ruby
 authors:
 - Sadayuki Furuhashi
@@ -10,64 +10,64 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-08 00:00:00.000000000 Z
+date: 2020-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.4
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.4
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rake-compiler-dock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -86,16 +86,16 @@ dependencies:
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.2
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.2
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -134,8 +134,10 @@ files:
 - bench/pack.rb
 - bench/pack_log.rb
 - bench/pack_log_long.rb
+- bench/pack_symbols.rb
 - bench/run.sh
 - bench/run_long.sh
+- bench/run_symbols.sh
 - bench/unpack.rb
 - bench/unpack_log.rb
 - bench/unpack_log_long.rb
@@ -146,6 +148,8 @@ files:
 - doclib/msgpack/extension_value.rb
 - doclib/msgpack/factory.rb
 - doclib/msgpack/packer.rb
+- doclib/msgpack/time.rb
+- doclib/msgpack/timestamp.rb
 - doclib/msgpack/unpacker.rb
 - ext/java/org/msgpack/jruby/Buffer.java
 - ext/java/org/msgpack/jruby/Decoder.java
@@ -162,8 +166,6 @@ files:
 - ext/msgpack/buffer_class.c
 - ext/msgpack/buffer_class.h
 - ext/msgpack/compat.h
-- ext/msgpack/core_ext.c
-- ext/msgpack/core_ext.h
 - ext/msgpack/extconf.rb
 - ext/msgpack/extension_value_class.c
 - ext/msgpack/extension_value_class.h
@@ -188,8 +190,12 @@ files:
 - ext/msgpack/unpacker_ext_registry.c
 - ext/msgpack/unpacker_ext_registry.h
 - lib/msgpack.rb
+- lib/msgpack/core_ext.rb
 - lib/msgpack/factory.rb
 - lib/msgpack/packer.rb
+- lib/msgpack/symbol.rb
+- lib/msgpack/time.rb
+- lib/msgpack/timestamp.rb
 - lib/msgpack/unpacker.rb
 - lib/msgpack/version.rb
 - msgpack.gemspec
@@ -215,6 +221,7 @@ files:
 - spec/packer_spec.rb
 - spec/random_compat.rb
 - spec/spec_helper.rb
+- spec/timestamp_spec.rb
 - spec/unpack_spec.rb
 - spec/unpacker_spec.rb
 homepage: http://msgpack.org/
@@ -236,8 +243,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: msgpack
-rubygems_version: 2.5.1
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: MessagePack, a binary-based efficient data interchange format.
@@ -263,6 +269,6 @@ test_files:
 - spec/packer_spec.rb
 - spec/random_compat.rb
 - spec/spec_helper.rb
+- spec/timestamp_spec.rb
 - spec/unpack_spec.rb
 - spec/unpacker_spec.rb
-has_rdoc: false