msgpack 0.6.2-x64-mingw32 → 0.7.0dev1-x64-mingw32

data/lib/msgpack.rb

@@ -11,3 +11,7 @@ else
     require "msgpack/msgpack"
   end
 end
+
+require "msgpack/packer"
+require "msgpack/unpacker"
+require "msgpack/factory"

data/lib/msgpack/factory.rb

@@ -0,0 +1,60 @@
+module MessagePack
+  class Factory
+    # see ext for other methods
+
+    # [ {type: id, class: Class(or nil), packer: arg, unpacker: arg}, ... ]
+    def registered_types(selector=:both)
+      packer, unpacker = registered_types_internal
+      # packer: Class -> [tid, proc, arg]
+      # unpacker: tid -> [klass, proc, arg]
+
+      list = []
+
+      case selector
+      when :both
+        packer.each_pair do |klass, ary|
+          type = ary[0]
+          packer_arg = ary[2]
+          unpacker_arg = nil
+          if unpacker.has_key?(type) && unpacker[type][0] == klass
+            unpacker_arg = unpacker.delete(type)[2]
+          end
+          list << {type: type, class: klass, packer: packer_arg, unpacker: unpacker_arg}
+        end
+
+        # unpacker definition only
+        unpacker.each_pair do |type, ary|
+          list << {type: type, class: ary[0], packer: nil, unpacker: ary[2]}
+        end
+
+      when :packer
+        packer.each_pair do |klass, ary|
+          list << {type: ary[0], class: klass, packer: ary[2]}
+        end
+
+      when :unpacker
+        unpacker.each_pair do |type, ary|
+          list << {type: type, class: ary[0], unpacker: ary[2]}
+        end
+
+      else
+        raise ArgumentError, "invalid selector #{selector}"
+      end
+
+      list.sort{|a, b| a[:type] <=> b[:type] }
+    end
+
+    def type_registered?(klass_or_type, selector=:both)
+      case klass_or_type
+      when Class
+        klass = klass_or_type
+        registered_types(selector).any?{|entry| klass <= entry[:class] }
+      when Integer
+        type = klass_or_type
+        registered_types(selector).any?{|entry| type == entry[:type] }
+      else
+        raise ArgumentError, "class or type id"
+      end
+    end
+  end
+end

data/lib/msgpack/packer.rb

@@ -0,0 +1,28 @@
+module MessagePack
+  class Packer
+    # see ext for other methods
+
+    def registered_types
+      list = []
+
+      registered_types_internal.each_pair do |klass, ary|
+        list << {type: ary[0], class: klass, packer: ary[2]}
+      end
+
+      list.sort{|a, b| a[:type] <=> b[:type] }
+    end
+
+    def type_registered?(klass_or_type)
+      case klass_or_type
+      when Class
+        klass = klass_or_type
+        registered_types.any?{|entry| klass <= entry[:class] }
+      when Integer
+        type = klass_or_type
+        registered_types.any?{|entry| type == entry[:type] }
+      else
+        raise ArgumentError, "class or type id"
+      end
+    end
+  end
+end

data/lib/msgpack/unpacker.rb

@@ -0,0 +1,28 @@
+module MessagePack
+  class Unpacker
+    # see ext for other methods
+
+    def registered_types
+      list = []
+
+      registered_types_internal.each_pair do |type, ary|
+        list << {type: type, class: ary[0], unpacker: ary[2]}
+      end
+
+      list.sort{|a, b| a[:type] <=> b[:type] }
+    end
+
+    def type_registered?(klass_or_type)
+      case klass_or_type
+      when Class
+        klass = klass_or_type
+        registered_types.any?{|entry| klass == entry[:class] }
+      when Integer
+        type = klass_or_type
+        registered_types.any?{|entry| type == entry[:type] }
+      else
+        raise ArgumentError, "class or type id"
+      end
+    end
+  end
+end

data/lib/msgpack/version.rb

@@ -1,3 +1,3 @@
 module MessagePack
-	VERSION = "0.6.2"
+  VERSION = "0.7.0dev1"
 end

data/msgpack.gemspec

@@ -24,8 +24,9 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'bundler', ['~> 1.0']
   s.add_development_dependency 'rake', ['~> 0.9.2']
-  s.add_development_dependency 'rake-compiler', ['~> 0.8.3']
-  s.add_development_dependency 'rspec', ['~> 2.11']
-  s.add_development_dependency 'json', ['~> 1.7']
+  s.add_development_dependency 'rake-compiler', ['~> 0.9.4']
+  s.add_development_dependency 'rake-compiler-dock', ['~> 0.4.3']
+  s.add_development_dependency 'rspec', ['~> 3.3']
   s.add_development_dependency 'yard', ['~> 0.8.2']
+  s.add_development_dependency 'json'
 end

data/spec/cruby/buffer_io_spec.rb

@@ -32,7 +32,7 @@ describe Buffer do
   end
 
   it 'close closes internal io' do
-    io.should_receive(:close)
+    expect(io).to receive(:close)
     buffer.close
   end
 
@@ -137,7 +137,7 @@ describe Buffer do
 
     50.times {
       fragments = []
-      sx = r.bytes(0)
+      r.bytes(0)
 
       r.rand(4).times do
         n = r.rand(1024*1400)
@@ -253,4 +253,3 @@ describe Buffer do
     }
   end
 end
-

data/spec/cruby/buffer_spec.rb

@@ -379,7 +379,6 @@ describe Buffer do
   end
 
   it 'big write -> short write' do
-    biglen = 1024*1024 + 2
     big1 = "a" * (1024*1024 + 2)
 
     case_keys.each {|k|
@@ -557,7 +556,7 @@ describe Buffer do
         n = r.rand(1024*1400)
         begin
           b.skip_all(n)
-          ex = s.slice!(0, n)
+          s.slice!(0, n)
           b.size.should == s.size
         ensure EOFError
           b.size.should == s.size
@@ -569,4 +568,3 @@ describe Buffer do
     }
   end
 end
-

data/spec/cruby/unpacker_spec.rb

@@ -21,7 +21,10 @@ describe Unpacker do
     unpacker.feed("\x81")
     lambda {
       unpacker.read_array_header
-    }.should raise_error(MessagePack::TypeError)
+    }.should raise_error(MessagePack::TypeError)  # TypeError is included in UnexpectedTypeError
+    lambda {
+      unpacker.read_array_header
+    }.should raise_error(MessagePack::UnexpectedTypeError)
   end
 
   it 'read_map_header converts an map to key-value sequence' do
@@ -55,7 +58,10 @@ describe Unpacker do
     unpacker.feed("\x91")
     lambda {
       unpacker.read_map_header
-    }.should raise_error(MessagePack::TypeError)
+    }.should raise_error(MessagePack::TypeError)  # TypeError is included in UnexpectedTypeError
+    lambda {
+      unpacker.read_map_header
+    }.should raise_error(MessagePack::UnexpectedTypeError)
   end
 
   it 'skip_nil succeeds' do
@@ -134,6 +140,12 @@ describe Unpacker do
     objects.should == [sample_object] * 4
   end
 
+  it 'feed_each enumerator' do
+    raw = sample_object.to_msgpack.to_s * 4
+
+    unpacker.feed_each(raw).to_a.should == [sample_object] * 4
+  end
+
   it 'reset clears internal buffer' do
     # 1-element array
     unpacker.feed("\x91")

data/spec/ext_value_spec.rb

@@ -0,0 +1,99 @@
+# encoding: ascii-8bit
+require 'spec_helper'
+
+describe MessagePack::ExtensionValue do
+  subject do
+    described_class.new(1, "data")
+  end
+
+  describe '#type/#type=' do
+    it 'returns value set by #initialize' do
+      subject.type.should == 1
+    end
+
+    it 'assigns a value' do
+      subject.type = 2
+      subject.type.should == 2
+    end
+  end
+
+  describe '#payload/#payload=' do
+    it 'returns value set by #initialize' do
+      subject.payload.should == "data"
+    end
+
+    it 'assigns a value' do
+      subject.payload = "a"
+      subject.payload.should == "a"
+    end
+  end
+
+  describe '#==/#eql?/#hash' do
+    it 'returns equivalent if the content is same' do
+      ext1 = MessagePack::ExtensionValue.new(1, "data")
+      ext2 = MessagePack::ExtensionValue.new(1, "data")
+      (ext1 == ext2).should be true
+      ext1.eql?(ext2).should be true
+      (ext1.hash == ext2.hash).should be true
+    end
+
+    it 'returns not equivalent if type is not same' do
+      ext1 = MessagePack::ExtensionValue.new(1, "data")
+      ext2 = MessagePack::ExtensionValue.new(2, "data")
+      (ext1 == ext2).should be false
+      ext1.eql?(ext2).should be false
+      (ext1.hash == ext2.hash).should be false
+    end
+
+    it 'returns not equivalent if payload is not same' do
+      ext1 = MessagePack::ExtensionValue.new(1, "data")
+      ext2 = MessagePack::ExtensionValue.new(1, "value")
+      (ext1 == ext2).should be false
+      ext1.eql?(ext2).should be false
+      (ext1.hash == ext2.hash).should be false
+    end
+  end
+
+  describe '#to_msgpack' do
+    it 'serializes very short payload' do
+      ext = MessagePack::ExtensionValue.new(1, "a"*2).to_msgpack
+      ext.should == "\xd5\x01" + "a"*2
+    end
+
+    it 'serializes short payload' do
+      ext = MessagePack::ExtensionValue.new(1, "a"*18).to_msgpack
+      ext.should == "\xc7\x12\x01" + "a"*18
+    end
+
+    it 'serializes long payload' do
+      ext = MessagePack::ExtensionValue.new(1, "a"*65540).to_msgpack
+      ext.should == "\xc9\x00\x01\x00\x04\x01" + "a"*65540
+    end
+
+    it 'with a packer serializes to a packer' do
+      ext = MessagePack::ExtensionValue.new(1, "aa")
+      packer = MessagePack::Packer.new
+      ext.to_msgpack(packer)
+      packer.buffer.to_s.should == "\xd5\x01aa"
+    end
+
+    [-129, -65540, -(2**40), 128, 65540, 2**40].each do |type|
+      context "with invalid type (#{type})" do
+        it 'raises RangeError' do
+          lambda { MessagePack::ExtensionValue.new(type, "a").to_msgpack }.should raise_error(RangeError)
+        end
+      end
+    end
+  end
+
+  describe '#dup' do
+    it 'duplicates' do
+      ext1 = MessagePack::ExtensionValue.new(1, "data")
+      ext2 = ext1.dup
+      ext2.type = 2
+      ext2.payload = "data2"
+      ext1.type.should == 1
+      ext1.payload.should == "data"
+    end
+  end
+end

data/spec/exttypes.rb

@@ -0,0 +1,51 @@
+class DummyTimeStamp1
+  TYPE = 15
+
+  attr_reader :utime, :usec, :time
+
+  def initialize(utime, usec)
+    @utime = utime
+    @usec = usec
+    @time = Time.at(utime, usec)
+  end
+
+  def ==(other)
+    self.utime == other.utime && self.usec == other.usec
+  end
+
+  def self.type_id
+    15
+  end
+
+  def self.from_msgpack_ext(data)
+    new(*data.unpack('I*'))
+  end
+
+  def to_msgpack_ext
+    [@utime,@usec].pack('I*')
+  end
+end
+
+class DummyTimeStamp2
+  TYPE = 16
+
+  attr_reader :utime, :usec, :time
+
+  def initialize(utime, usec)
+    @utime = utime
+    @usec = usec
+    @time = Time.at(utime, usec)
+  end
+
+  def ==(other)
+    self.utime == other.utime && self.usec == other.usec
+  end
+
+  def self.deserialize(data)
+    new(* data.split(',', 2).map(&:to_i))
+  end
+
+  def serialize
+    [@utime,@usec].map(&:to_s).join(',')
+  end
+end

data/spec/factory_spec.rb

@@ -0,0 +1,236 @@
+# encoding: ascii-8bit
+require 'spec_helper'
+
+eval("return") if java?
+
+describe MessagePack::Factory do
+  subject do
+    described_class.new
+  end
+
+  describe '#packer' do
+    it 'creates a Packer instance' do
+      subject.packer.should be_kind_of(MessagePack::Packer)
+    end
+
+    it 'creates new instance' do
+      subject.packer.object_id.should_not == subject.packer.object_id
+    end
+  end
+
+  describe '#unpacker' do
+    it 'creates a Unpacker instance' do
+      subject.unpacker.should be_kind_of(MessagePack::Unpacker)
+    end
+
+    it 'creates new instance' do
+      subject.unpacker.object_id.should_not == subject.unpacker.object_id
+    end
+
+    it 'creates unpacker with symbolize_keys option' do
+      unpacker = subject.unpacker(symbolize_keys: true)
+      unpacker.feed(MessagePack.pack({'k'=>'v'}))
+      unpacker.read.should == {:k => 'v'}
+    end
+
+    it 'creates unpacker with allow_unknown_ext option' do
+      unpacker = subject.unpacker(allow_unknown_ext: true)
+      unpacker.feed(MessagePack::ExtensionValue.new(1, 'a').to_msgpack)
+      unpacker.read.should == MessagePack::ExtensionValue.new(1, 'a')
+    end
+
+    it 'creates unpacker without allow_unknown_ext option' do
+      unpacker = subject.unpacker
+      unpacker.feed(MessagePack::ExtensionValue.new(1, 'a').to_msgpack)
+      expect{ unpacker.read }.to raise_error(MessagePack::UnknownExtTypeError)
+    end
+  end
+
+  class MyType
+    def initialize(a, b)
+      @a = a
+      @b = b
+    end
+
+    attr_reader :a, :b
+
+    def to_msgpack_ext
+      [a, b].pack('CC')
+    end
+
+    def self.from_msgpack_ext(data)
+      new(*data.unpack('CC'))
+    end
+
+    def to_msgpack_ext_only_a
+      [a, 0].pack('CC')
+    end
+
+    def self.from_msgpack_ext_only_b(data)
+      a, b = *data.unpack('CC')
+      new(0, b)
+    end
+  end
+
+  class MyType2 < MyType
+  end
+
+  describe '#registered_types' do
+    it 'returns Array' do
+      expect(subject.registered_types).to be_instance_of(Array)
+    end
+
+    it 'returns Array of Hash contains :type, :class, :packer, :unpacker' do
+      subject.register_type(0x20, ::MyType)
+      subject.register_type(0x21, ::MyType2)
+
+      list = subject.registered_types
+
+      expect(list.size).to eq(2)
+      expect(list[0]).to be_instance_of(Hash)
+      expect(list[1]).to be_instance_of(Hash)
+      expect(list[0].keys.sort).to eq([:type, :class, :packer, :unpacker].sort)
+      expect(list[1].keys.sort).to eq([:type, :class, :packer, :unpacker].sort)
+
+      expect(list[0][:type]).to eq(0x20)
+      expect(list[0][:class]).to eq(::MyType)
+      expect(list[0][:packer]).to eq(:to_msgpack_ext)
+      expect(list[0][:unpacker]).to eq(:from_msgpack_ext)
+
+      expect(list[1][:type]).to eq(0x21)
+      expect(list[1][:class]).to eq(::MyType2)
+      expect(list[1][:packer]).to eq(:to_msgpack_ext)
+      expect(list[1][:unpacker]).to eq(:from_msgpack_ext)
+    end
+
+    it 'returns Array of Hash which has nil for unregistered feature' do
+      subject.register_type(0x21, ::MyType2, unpacker: :from_msgpack_ext)
+      subject.register_type(0x20, ::MyType, packer: :to_msgpack_ext)
+
+      list = subject.registered_types
+
+      expect(list.size).to eq(2)
+      expect(list[0]).to be_instance_of(Hash)
+      expect(list[1]).to be_instance_of(Hash)
+      expect(list[0].keys.sort).to eq([:type, :class, :packer, :unpacker].sort)
+      expect(list[1].keys.sort).to eq([:type, :class, :packer, :unpacker].sort)
+
+      expect(list[0][:type]).to eq(0x20)
+      expect(list[0][:class]).to eq(::MyType)
+      expect(list[0][:packer]).to eq(:to_msgpack_ext)
+      expect(list[0][:unpacker]).to be_nil
+
+      expect(list[1][:type]).to eq(0x21)
+      expect(list[1][:class]).to eq(::MyType2)
+      expect(list[1][:packer]).to be_nil
+      expect(list[1][:unpacker]).to eq(:from_msgpack_ext)
+    end
+  end
+
+  describe '#type_registered?' do
+    it 'receive Class or Integer, and return bool' do
+      expect(subject.type_registered?(0x00)).to be_falsy
+      expect(subject.type_registered?(0x01)).to be_falsy
+      expect(subject.type_registered?(::MyType)).to be_falsy
+    end
+
+    it 'has option to specify what types are registered for' do
+      expect(subject.type_registered?(0x00, :both)).to be_falsy
+      expect(subject.type_registered?(0x00, :packer)).to be_falsy
+      expect(subject.type_registered?(0x00, :unpacker)).to be_falsy
+      expect{ subject.type_registered?(0x00, :something) }.to raise_error(ArgumentError)
+    end
+
+    it 'returns true if specified type or class is already registered' do
+      subject.register_type(0x20, ::MyType)
+      subject.register_type(0x21, ::MyType2)
+
+      expect(subject.type_registered?(0x00)).to be_falsy
+      expect(subject.type_registered?(0x01)).to be_falsy
+
+      expect(subject.type_registered?(0x20)).to be_truthy
+      expect(subject.type_registered?(0x21)).to be_truthy
+      expect(subject.type_registered?(::MyType)).to be_truthy
+      expect(subject.type_registered?(::MyType2)).to be_truthy
+    end
+  end
+
+  describe '#register_type' do
+    let :src do
+      ::MyType.new(1, 2)
+    end
+
+    it 'registers #to_msgpack_ext and .from_msgpack_ext by default' do
+      subject.register_type(0x7f, ::MyType)
+
+      data = subject.packer.write(src).to_s
+      my = subject.unpacker.feed(data).read
+      my.a.should == 1
+      my.b.should == 2
+    end
+
+    it 'registers custom packer method name' do
+      subject.register_type(0x7f, ::MyType, packer: :to_msgpack_ext_only_a, unpacker: :from_msgpack_ext)
+
+      data = subject.packer.write(src).to_s
+      my = subject.unpacker.feed(data).read
+      my.a.should == 1
+      my.b.should == 0
+    end
+
+    it 'registers custom unpacker method name' do
+      subject.register_type(0x7f, ::MyType, packer: :to_msgpack_ext, unpacker: 'from_msgpack_ext_only_b')
+
+      data = subject.packer.write(src).to_s
+      my = subject.unpacker.feed(data).read
+      my.a.should == 0
+      my.b.should == 2
+    end
+
+    it 'registers custom proc objects' do
+      pk = lambda {|obj| [obj.a + obj.b].pack('C') }
+      uk = lambda {|data| ::MyType.new(data.unpack('C').first, -1) }
+      subject.register_type(0x7f, ::MyType, packer: pk, unpacker: uk)
+
+      data = subject.packer.write(src).to_s
+      my = subject.unpacker.feed(data).read
+      my.a.should == 3
+      my.b.should == -1
+    end
+
+    it 'does not affect existent packer and unpackers' do
+      subject.register_type(0x7f, ::MyType)
+      packer = subject.packer
+      unpacker = subject.unpacker
+
+      subject.register_type(0x7f, ::MyType, packer: :to_msgpack_ext_only_a, unpacker: :from_msgpack_ext_only_b)
+
+      data = packer.write(src).to_s
+      my = unpacker.feed(data).read
+      my.a.should == 1
+      my.b.should == 2
+    end
+  end
+
+  describe 'DefaultFactory' do
+    it 'is a factory' do
+      MessagePack::DefaultFactory.should be_kind_of(MessagePack::Factory)
+    end
+
+    require_relative 'exttypes'
+
+    it 'should be referred by MessagePack.pack and MessagePack.unpack' do
+      skip("not supported yet in JRuby implementation") if java?
+      MessagePack::DefaultFactory.register_type(DummyTimeStamp1::TYPE, DummyTimeStamp1)
+      MessagePack::DefaultFactory.register_type(DummyTimeStamp2::TYPE, DummyTimeStamp2, packer: :serialize, unpacker: :deserialize)
+
+      t = Time.now
+
+      dm1 = DummyTimeStamp1.new(t.to_i, t.usec)
+      expect(MessagePack.unpack(MessagePack.pack(dm1))).to eq(dm1)
+
+      dm2 = DummyTimeStamp1.new(t.to_i, t.usec)
+      expect(MessagePack.unpack(MessagePack.pack(dm2))).to eq(dm2)
+    end
+  end
+end