msgpack 0.7.4 → 1.3.3

data/lib/msgpack/core_ext.rb

@@ -0,0 +1,139 @@
+module MessagePack
+  module CoreExt
+    def to_msgpack(packer_or_io = nil)
+      if packer_or_io
+        if packer_or_io.is_a?(MessagePack::Packer)
+          to_msgpack_with_packer packer_or_io
+        else
+          MessagePack.pack(self, packer_or_io)
+        end
+      else
+        MessagePack.pack(self)
+      end
+    end
+  end
+end
+
+class NilClass
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_nil
+    packer
+  end
+end
+
+class TrueClass
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_true
+    packer
+  end
+end
+
+class FalseClass
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_false
+    packer
+  end
+end
+
+class Float
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_float self
+    packer
+  end
+end
+
+class String
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_string self
+    packer
+  end
+end
+
+class Array
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_array self
+    packer
+  end
+end
+
+class Hash
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_hash self
+    packer
+  end
+end
+
+class Symbol
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_symbol self
+    packer
+  end
+end
+
+if 1.class.name == "Integer"
+  class Integer
+    include MessagePack::CoreExt
+
+    private
+    def to_msgpack_with_packer(packer)
+      packer.write_int self
+      packer
+    end
+  end
+else
+  class Fixnum
+    include MessagePack::CoreExt
+
+    private
+    def to_msgpack_with_packer(packer)
+      packer.write_int self
+      packer
+    end
+  end
+
+  class Bignum
+    include MessagePack::CoreExt
+
+    private
+    def to_msgpack_with_packer(packer)
+      packer.write_int self
+      packer
+    end
+  end
+end
+
+module MessagePack
+  class ExtensionValue
+    include CoreExt
+
+    private
+    def to_msgpack_with_packer(packer)
+      packer.write_extension self
+      packer
+    end
+  end
+end

data/lib/msgpack/factory.rb

@@ -56,5 +56,26 @@ module MessagePack
         raise ArgumentError, "class or type id"
       end
     end
+
+    def load(src, param = nil)
+      unpacker = nil
+
+      if src.is_a? String
+        unpacker = unpacker(param)
+        unpacker.feed(src)
+      else
+        unpacker = unpacker(src, param)
+      end
+
+      unpacker.full_unpack
+    end
+    alias :unpack :load
+
+    def dump(v, *rest)
+      packer = packer(*rest)
+      packer.write(v)
+      packer.full_pack
+    end
+    alias :pack :dump
   end
 end

data/lib/msgpack/symbol.rb

@@ -0,0 +1,9 @@
+class Symbol
+  def to_msgpack_ext
+    [to_s].pack('A*')
+  end
+
+  def self.from_msgpack_ext(data)
+    data.unpack('A*').first.to_sym
+  end
+end

data/lib/msgpack/time.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# MessagePack extention packer and unpacker for built-in Time class
+module MessagePack
+  module Time
+    # 3-arg Time.at is available Ruby >= 2.5
+    TIME_AT_3_AVAILABLE = begin
+                            !!::Time.at(0, 0, :nanosecond)
+                          rescue ArgumentError
+                            false
+                          end
+
+    Unpacker = if TIME_AT_3_AVAILABLE
+                 lambda do |payload|
+                   tv = MessagePack::Timestamp.from_msgpack_ext(payload)
+                   ::Time.at(tv.sec, tv.nsec, :nanosecond)
+                 end
+               else
+                 lambda do |payload|
+                   tv = MessagePack::Timestamp.from_msgpack_ext(payload)
+                   ::Time.at(tv.sec, tv.nsec / 1000.0)
+                 end
+               end
+
+    Packer = lambda { |time|
+      MessagePack::Timestamp.to_msgpack_ext(time.tv_sec, time.tv_nsec)
+    }
+  end
+end

data/lib/msgpack/timestamp.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module MessagePack
+  class Timestamp # a.k.a. "TimeSpec"
+    # Because the byte-order of MessagePack is big-endian in,
+    # pack() and unpack() specifies ">".
+    # See https://docs.ruby-lang.org/en/trunk/Array.html#method-i-pack for details.
+
+    # The timestamp extension type defined in the MessagePack spec.
+    # See https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type for details.
+    TYPE = -1
+
+    TIMESTAMP32_MAX_SEC = (1 << 32) - 1
+    TIMESTAMP64_MAX_SEC = (1 << 34) - 1
+
+    # @return [Integer]
+    attr_reader :sec
+
+    # @return [Integer]
+    attr_reader :nsec
+
+    # @param [Integer] sec
+    # @param [Integer] nsec
+    def initialize(sec, nsec)
+      @sec = sec
+      @nsec = nsec
+    end
+
+    def self.from_msgpack_ext(data)
+      case data.length
+      when 4
+        # timestamp32 (sec: uint32be)
+        sec, = data.unpack('L>')
+        new(sec, 0)
+      when 8
+        # timestamp64 (nsec: uint30be, sec: uint34be)
+        n, s = data.unpack('L>2')
+        sec = ((n & 0b11) << 32) | s
+        nsec = n >> 2
+        new(sec, nsec)
+      when 12
+        # timestam96 (nsec: uint32be, sec: int64be)
+        nsec, sec = data.unpack('L>q>')
+        new(sec, nsec)
+      else
+        raise MalformedFormatError, "Invalid timestamp data size: #{data.length}"
+      end
+    end
+
+    def self.to_msgpack_ext(sec, nsec)
+      if sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC
+        if nsec === 0 && sec <= TIMESTAMP32_MAX_SEC
+          # timestamp32 = (sec: uint32be)
+          [sec].pack('L>')
+        else
+          # timestamp64 (nsec: uint30be, sec: uint34be)
+          nsec30 = nsec << 2
+          sec_high2 = sec >> 32 # high 2 bits (`x & 0b11` is redandunt)
+          sec_low32 = sec & 0xffffffff # low 32 bits
+          [nsec30 | sec_high2, sec_low32].pack('L>2')
+        end
+      else
+        # timestamp96 (nsec: uint32be, sec: int64be)
+        [nsec, sec].pack('L>q>')
+      end
+    end
+
+    def to_msgpack_ext
+      self.class.to_msgpack_ext(sec, nsec)
+    end
+
+    def ==(other)
+      other.class == self.class && sec == other.sec && nsec == other.nsec
+    end
+  end
+end

data/lib/msgpack/version.rb

@@ -1,3 +1,10 @@
 module MessagePack
-  VERSION = "0.7.4"
+  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
 end

data/msgpack.gemspec

@@ -10,8 +10,6 @@ Gem::Specification.new do |s|
   s.email = ["frsyuki@gmail.com", "theo@iconara.net", "tagomoris@gmail.com"]
   s.license = "Apache 2.0"
   s.homepage = "http://msgpack.org/"
-  s.rubyforge_project = "msgpack"
-  s.has_rdoc = false
   s.require_paths = ["lib"]
   if /java/ =~ RUBY_PLATFORM
     s.files = Dir['lib/**/*.rb', 'lib/**/*.jar']
@@ -22,13 +20,14 @@ Gem::Specification.new do |s|
   end
   s.test_files = `git ls-files -- {test,spec}/*`.split("\n")
 
-  s.add_development_dependency 'bundler', ['~> 1.0']
-  s.add_development_dependency 'rake', ['~> 0.9.2']
-  s.add_development_dependency 'rake-compiler', ['~> 0.9.4']
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rake-compiler', ['~> 1.0']
   if /java/ !~ RUBY_PLATFORM
-    s.add_development_dependency 'rake-compiler-dock', ['~> 0.5.0']
+    # NOTE: rake-compiler-dock SHOULD be updated for new Ruby versions
+    s.add_development_dependency 'rake-compiler-dock', ['~> 1.0']
   end
   s.add_development_dependency 'rspec', ['~> 3.3']
-  s.add_development_dependency 'yard', ['~> 0.8.2']
+  s.add_development_dependency 'yard'
   s.add_development_dependency 'json'
 end

data/spec/cruby/buffer_spec.rb

@@ -1,6 +1,11 @@
 require 'spec_helper'
 require 'random_compat'
 
+require 'stringio'
+if defined?(Encoding)
+  Encoding.default_external = 'ASCII-8BIT'
+end
+
 describe Buffer do
   STATIC_EXAMPLES = {}
   STATIC_EXAMPLES[:empty01] = ''
@@ -45,7 +50,7 @@ describe Buffer do
         b.read(n)
         s.slice!(0, n)
       end
-      key = :"random#{"%02d"%i}"
+      key = :"random#{"%02d" % i}"
       cases[key] = b
       examples[key] = s
     end

data/spec/factory_spec.rb

@@ -44,6 +44,32 @@ describe MessagePack::Factory do
     end
   end
 
+  describe '#dump and #load' do
+    it 'can be used like a standard coder' do
+      subject.register_type(0x00, Symbol)
+      expect(subject.load(subject.dump(:symbol))).to be == :symbol
+    end
+
+    it 'is alias as pack and unpack' do
+      subject.register_type(0x00, Symbol)
+      expect(subject.unpack(subject.pack(:symbol))).to be == :symbol
+    end
+
+    it 'accept options' do
+      hash = subject.unpack(MessagePack.pack('k' => 'v'), symbolize_keys: true)
+      expect(hash).to be == { k: 'v' }
+    end
+  end
+
+  describe '#freeze' do
+    it 'can freeze factory instance to deny new registrations anymore' do
+      subject.register_type(0x00, Symbol)
+      subject.freeze
+      expect(subject.frozen?).to be_truthy
+      expect{ subject.register_type(0x01, Array) }.to raise_error(RuntimeError, "can't modify frozen Factory")
+    end
+  end
+
   class MyType
     def initialize(a, b)
       @a = a
@@ -208,6 +234,114 @@ describe MessagePack::Factory do
       my.a.should == 1
       my.b.should == 2
     end
+
+    describe "registering an ext type for a module" do
+      before do
+        mod = Module.new do
+          def self.from_msgpack_ext(data)
+            "unpacked #{data}"
+          end
+
+          def to_msgpack_ext
+            'value_msgpacked'
+          end
+        end
+        stub_const('Mod', mod)
+      end
+      let(:factory) { described_class.new }
+      before { factory.register_type(0x01, Mod) }
+
+      describe "packing an object whose class included the module" do
+        subject { factory.packer.pack(value).to_s }
+        before { stub_const('Value', Class.new{ include Mod }) }
+        let(:value) { Value.new }
+        it { is_expected.to eq "\xC7\x0F\x01value_msgpacked" }
+      end
+
+      describe "packing an object which has been extended by the module" do
+        subject { factory.packer.pack(object).to_s }
+        let(:object) { Object.new.extend Mod }
+        it { is_expected.to eq "\xC7\x0F\x01value_msgpacked" }
+      end
+
+      describe "unpacking with the module" do
+        subject { factory.unpacker.feed("\xC7\x06\x01module").unpack }
+        it { is_expected.to eq "unpacked module" }
+      end
+    end
+  end
+
+  describe 'the special treatment of symbols with ext type' do
+    let(:packer) { subject.packer }
+    let(:unpacker) { subject.unpacker }
+
+    def symbol_after_roundtrip
+      packed_symbol = packer.pack(:symbol).to_s
+      unpacker.feed(packed_symbol).unpack
+    end
+
+    context 'if no ext type is registered for symbols' do
+      it 'converts symbols to string' do
+        expect(symbol_after_roundtrip).to eq 'symbol'
+      end
+    end
+
+    context 'if an ext type is registered for symbols' do
+      context 'if using the default serializer' do
+        before { subject.register_type(0x00, ::Symbol) }
+
+        it 'lets symbols survive a roundtrip' do
+          expect(symbol_after_roundtrip).to be :symbol
+        end
+      end
+
+      context 'if using a custom serializer' do
+        before do
+          class Symbol
+            alias_method :to_msgpack_ext_orig, :to_msgpack_ext
+            def to_msgpack_ext
+              self.to_s.codepoints.to_a.pack('n*')
+            end
+          end
+
+          class << Symbol
+            alias_method :from_msgpack_ext_orig, :from_msgpack_ext
+            def from_msgpack_ext(data)
+              data.unpack('n*').map(&:chr).join.to_sym
+            end
+          end
+        end
+
+        before { subject.register_type(0x00, ::Symbol) }
+
+        it 'lets symbols survive a roundtrip' do
+          expect(symbol_after_roundtrip).to be :symbol
+        end
+
+        after do
+          class Symbol
+            alias_method :to_msgpack_ext, :to_msgpack_ext_orig
+          end
+
+          class << Symbol
+            alias_method :from_msgpack_ext, :from_msgpack_ext_orig
+          end
+        end
+      end
+    end
+  end
+
+  describe 'under stressful GC' do
+    it 'works well' do
+      begin
+        GC.stress = true
+
+        f = MessagePack::Factory.new
+        f.register_type(0x0a, Symbol)
+      ensure
+        GC.stress = false
+      end
+    end
   end
 
   describe 'DefaultFactory' do