msgpack 0.6.2-java → 0.7.0dev1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3b998a195a0aaeb32b2c24895e9dd8749f5462c5
-  data.tar.gz: 9e68941aa0f00733cd0369c8e3769b0002e62f3a
+  metadata.gz: 1074cd38a1217bb758be1ce482c293956f051c29
+  data.tar.gz: 53cac06789fb384cf3407e61e7cbb5d4ef2f263b
 SHA512:
-  metadata.gz: b96a3334af1c4a758c5f57e4d0cc921825fac3bab974d4431669be75fd2056771b9ba724cd71d0f51ec29a8a0235fb959fadf15a88db62ccc913c2329d533d59
-  data.tar.gz: ed88e2008f43ba77de7ad12ad2cd60b2784e2b26c0acce61d2e12aa710a0868b1e296077fc4899247ce9f8d499a378e18454181695c812703371cc4fb7b763a7
+  metadata.gz: 0d311e9a8d3729e29398660f0416d83a93e1d6c751851a0b240e11ec6ee18bd904d9b3ab2a249028a9591b8cb13281493eaf1fe7c97148ab56999be9bbea19f5
+  data.tar.gz: 274602def6f21adeb764c70ac6b506ef72f245983c9c63ab12d977bbd981da9e94976858d583750cd55c2d4c93c4a5333f2103ed04fa8feaa68079261ea8a8b4

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/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

data/spec/jruby/msgpack/unpacker_spec.rb

@@ -72,6 +72,31 @@ describe ::MessagePack::Unpacker do
       subject.should_not be_finished
     end
   end
+
+  describe '#read' do
+    context 'with a buffer' do
+      it 'reads objects' do
+        objects = []
+        subject.feed(buffer1)
+        subject.feed(buffer2)
+        subject.feed(buffer3)
+        objects << subject.read
+        objects << subject.read
+        objects << subject.read
+        objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
+      end
+
+      it 'reads map header' do
+        subject.feed({}.to_msgpack)
+        subject.read_map_header.should == 0
+      end
+
+      it 'reads array header' do
+        subject.feed([].to_msgpack)
+        subject.read_array_header.should == 0
+      end
+    end
+  end
   
   describe '#each' do
     context 'with a buffer' do

data/spec/{jruby/msgpack_spec.rb → msgpack_spec.rb}

@@ -112,7 +112,7 @@ describe MessagePack do
 
   context 'with other things' do
     it 'raises an error on #pack with an unsupported type' do
-      expect { MessagePack.pack(self) }.to raise_error(ArgumentError, /^Cannot pack type:/)
+      expect { MessagePack.pack(self) }.to raise_error(NoMethodError, /^undefined method `to_msgpack'/)
     end
 
     it 'rasies an error on #unpack with garbage' do

data/spec/pack_spec.rb

@@ -35,9 +35,6 @@ describe MessagePack do
   end
 
   it 'calls custom to_msgpack method' do
-    if /java/ =~ RUBY_PLATFORM
-      skip "custom to_msgpack fallback is not supported yet in JRuby implementation"
-    end
     MessagePack.pack(CustomPack01.new).should == [1,2].to_msgpack
     MessagePack.pack(CustomPack02.new).should == [1,2].to_msgpack
     CustomPack01.new.to_msgpack.should == [1,2].to_msgpack
@@ -45,9 +42,6 @@ describe MessagePack do
   end
 
   it 'calls custom to_msgpack method with io' do
-    if /java/ =~ RUBY_PLATFORM
-      skip "custom to_msgpack fallback with io is not supported yet in JRuby implementation"
-    end
     s01 = StringIO.new
     MessagePack.pack(CustomPack01.new, s01)
     s01.string.should == [1,2].to_msgpack

data/spec/packer_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe MessagePack::Packer do
+  class ValueOne
+    def initialize(num)
+      @num = num
+    end
+    def num
+      @num
+    end
+    def to_msgpack_ext
+      @num.to_msgpack
+    end
+    def self.from_msgpack_ext(data)
+      self.new(MessagePack.unpack(data))
+    end
+  end
+
+  class ValueTwo
+    def initialize(num)
+      @num_s = num.to_s
+    end
+    def num
+      @num_s.to_i
+    end
+    def to_msgpack_ext
+      @num_s.to_msgpack
+    end
+    def self.from_msgpack_ext(data)
+      self.new(MessagePack.unpack(data))
+    end
+  end
+
+  describe '#type_registered?' do
+    it 'receive Class or Integer, and return bool' do
+      skip("not supported yet in JRuby implementation") if java?
+      expect(subject.type_registered?(0x00)).to be_falsy
+      expect(subject.type_registered?(0x01)).to be_falsy
+      expect(subject.type_registered?(::ValueOne)).to be_falsy
+    end
+
+    it 'returns true if specified type or class is already registered' do
+      skip("not supported yet in JRuby implementation") if java?
+      subject.register_type(0x30, ::ValueOne, :to_msgpack_ext)
+      subject.register_type(0x31, ::ValueTwo, :to_msgpack_ext)
+
+      expect(subject.type_registered?(0x00)).to be_falsy
+      expect(subject.type_registered?(0x01)).to be_falsy
+
+      expect(subject.type_registered?(0x30)).to be_truthy
+      expect(subject.type_registered?(0x31)).to be_truthy
+      expect(subject.type_registered?(::ValueOne)).to be_truthy
+      expect(subject.type_registered?(::ValueTwo)).to be_truthy
+    end
+  end
+
+  describe '#register_type' do
+    it 'get type and class mapping for packing' do
+      skip("not supported yet in JRuby implementation") if java?
+      packer = MessagePack::Packer.new
+      packer.register_type(0x01, ValueOne){|obj| obj.to_msgpack_ext }
+      packer.register_type(0x02, ValueTwo){|obj| obj.to_msgpack_ext }
+
+      packer = MessagePack::Packer.new
+      packer.register_type(0x01, ValueOne, :to_msgpack_ext)
+      packer.register_type(0x02, ValueTwo, :to_msgpack_ext)
+
+      packer = MessagePack::Packer.new
+      packer.register_type(0x01, ValueOne, &:to_msgpack_ext)
+      packer.register_type(0x02, ValueTwo, &:to_msgpack_ext)
+    end
+
+    it 'returns a Hash which contains map of Class and type' do
+      skip("not supported yet in JRuby implementation") if java?
+      packer = MessagePack::Packer.new
+      packer.register_type(0x01, ValueOne, :to_msgpack_ext)
+      packer.register_type(0x02, ValueTwo, :to_msgpack_ext)
+
+      expect(packer.registered_types).to be_a(Array)
+      expect(packer.registered_types.size).to eq(2)
+
+      one = packer.registered_types[0]
+      expect(one.keys.sort).to eq([:type, :class, :packer].sort)
+      expect(one[:type]).to eq(0x01)
+      expect(one[:class]).to eq(ValueOne)
+      expect(one[:packer]).to eq(:to_msgpack_ext)
+
+      two = packer.registered_types[1]
+      expect(two.keys.sort).to eq([:type, :class, :packer].sort)
+      expect(two[:type]).to eq(0x02)
+      expect(two[:class]).to eq(ValueTwo)
+      expect(two[:packer]).to eq(:to_msgpack_ext)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -15,13 +15,24 @@ end
 
 require 'msgpack'
 
-if /java/ =~ RUBY_PLATFORM
+def java?
+  /java/ =~ RUBY_PLATFORM
+end
+
+if java?
   RSpec.configure do |c|
     c.treat_symbols_as_metadata_keys_with_true_values = true
     c.filter_run_excluding :encodings => !(defined? Encoding)
   end
 else
+  RSpec.configure do |config|
+    config.expect_with :rspec do |c|
+      c.syntax = [:should, :expect]
+    end
+  end
   Packer = MessagePack::Packer
   Unpacker = MessagePack::Unpacker
   Buffer = MessagePack::Buffer
+  Factory = MessagePack::Factory
+  ExtensionValue = MessagePack::ExtensionValue
 end

data/spec/unpack_spec.rb

@@ -13,10 +13,7 @@ describe MessagePack do
     MessagePack.unpack(MessagePack.pack(symbolized_hash), :symbolize_keys => true).should == symbolized_hash
   end
 
-  it 'Unpacker#unpack symbolize_keys' do
-    if /java/ =~ RUBY_PLATFORM
-      skip "Unpacker#unpack returns nil in JRuby (incompatible)"
-    end
+  it 'Unpacker#read symbolize_keys' do
     unpacker = MessagePack::Unpacker.new(:symbolize_keys => true)
     symbolized_hash = {:a => 'b', :c => 'd'}
     unpacker.feed(MessagePack.pack(symbolized_hash)).read.should == symbolized_hash

data/spec/unpacker_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe MessagePack::Unpacker do
+  class ValueOne
+    attr_reader :num
+    def initialize(num)
+      @num = num
+    end
+    def ==(obj)
+      self.num == obj.num
+    end
+    def num
+      @num
+    end
+    def to_msgpack_ext
+      @num.to_msgpack
+    end
+    def self.from_msgpack_ext(data)
+      self.new(MessagePack.unpack(data))
+    end
+  end
+
+  class ValueTwo
+    attr_reader :num_s
+    def initialize(num)
+      @num_s = num.to_s
+    end
+    def ==(obj)
+      self.num_s == obj.num_s
+    end
+    def num
+      @num_s.to_i
+    end
+    def to_msgpack_ext
+      @num_s.to_msgpack
+    end
+    def self.from_msgpack_ext(data)
+      self.new(MessagePack.unpack(data))
+    end
+  end
+
+  describe '#type_registered?' do
+    it 'receive Class or Integer, and return bool' do
+      skip("not supported yet in JRuby implementation") if java?
+      expect(subject.type_registered?(0x00)).to be_falsy
+      expect(subject.type_registered?(0x01)).to be_falsy
+      expect(subject.type_registered?(::ValueOne)).to be_falsy
+    end
+
+    it 'returns true if specified type or class is already registered' do
+      skip("not supported yet in JRuby implementation") if java?
+      subject.register_type(0x30, ::ValueOne, :from_msgpack_ext)
+      subject.register_type(0x31, ::ValueTwo, :from_msgpack_ext)
+
+      expect(subject.type_registered?(0x00)).to be_falsy
+      expect(subject.type_registered?(0x01)).to be_falsy
+
+      expect(subject.type_registered?(0x30)).to be_truthy
+      expect(subject.type_registered?(0x31)).to be_truthy
+      expect(subject.type_registered?(::ValueOne)).to be_truthy
+      expect(subject.type_registered?(::ValueTwo)).to be_truthy
+    end
+
+    it 'cannot detect unpack rule with block, not method' do
+      skip("not supported yet in JRuby implementation") if java?
+      subject.register_type(0x40){|data| ValueOne.from_msgpack_ext(data) }
+
+      expect(subject.type_registered?(0x40)).to be_truthy
+      expect(subject.type_registered?(ValueOne)).to be_falsy
+    end
+  end
+
+  context 'with ext definitions' do
+    it 'get type and class mapping for packing' do
+      skip("not supported yet in JRuby implementation") if java?
+      unpacker = MessagePack::Unpacker.new
+      unpacker.register_type(0x01){|data| ValueOne.from_msgpack_ext }
+      unpacker.register_type(0x02){|data| ValueTwo.from_msgpack_ext(data) }
+
+      unpacker = MessagePack::Unpacker.new
+      unpacker.register_type(0x01, ValueOne, :from_msgpack_ext)
+      unpacker.register_type(0x02, ValueTwo, :from_msgpack_ext)
+    end
+
+    it 'returns a Array of Hash which contains :type, :class and :unpacker' do
+      skip("not supported yet in JRuby implementation") if java?
+      unpacker = MessagePack::Unpacker.new
+      unpacker.register_type(0x02, ValueTwo, :from_msgpack_ext)
+      unpacker.register_type(0x01, ValueOne, :from_msgpack_ext)
+
+      list = unpacker.registered_types
+
+      expect(list).to be_a(Array)
+      expect(list.size).to eq(2)
+
+      one = list[0]
+      expect(one.keys.sort).to eq([:type, :class, :unpacker].sort)
+      expect(one[:type]).to eq(0x01)
+      expect(one[:class]).to eq(ValueOne)
+      expect(one[:unpacker]).to eq(:from_msgpack_ext)
+
+      two = list[1]
+      expect(two.keys.sort).to eq([:type, :class, :unpacker].sort)
+      expect(two[:type]).to eq(0x02)
+      expect(two[:class]).to eq(ValueTwo)
+      expect(two[:unpacker]).to eq(:from_msgpack_ext)
+    end
+
+    it 'returns a Array of Hash, which contains nil for class if block unpacker specified' do
+      skip("not supported yet in JRuby implementation") if java?
+      unpacker = MessagePack::Unpacker.new
+      unpacker.register_type(0x01){|data| ValueOne.from_msgpack_ext }
+      unpacker.register_type(0x02, &ValueTwo.method(:from_msgpack_ext))
+
+      list = unpacker.registered_types
+
+      expect(list).to be_a(Array)
+      expect(list.size).to eq(2)
+
+      one = list[0]
+      expect(one.keys.sort).to eq([:type, :class, :unpacker].sort)
+      expect(one[:type]).to eq(0x01)
+      expect(one[:class]).to be_nil
+      expect(one[:unpacker]).to be_instance_of(Proc)
+
+      two = list[1]
+      expect(two.keys.sort).to eq([:type, :class, :unpacker].sort)
+      expect(two[:type]).to eq(0x02)
+      expect(two[:class]).to be_nil
+      expect(two[:unpacker]).to be_instance_of(Proc)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: msgpack
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.0dev1
 platform: java
 authors:
 - Sadayuki Furuhashi
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-07-22 00:00:00.000000000 Z
+date: 2015-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -44,7 +44,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.8.3
+        version: 0.9.4
   name: rake-compiler
   prerelease: false
   type: :development
@@ -52,35 +52,35 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.8.3
+        version: 0.9.4
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.11'
-  name: rspec
+        version: 0.4.3
+  name: rake-compiler-dock
   prerelease: false
   type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.11'
+        version: 0.4.3
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.7'
-  name: json
+        version: '3.3'
+  name: rspec
   prerelease: false
   type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
@@ -95,6 +95,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.8.2
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: json
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: MessagePack is a binary-based efficient object serialization library. It enables to exchange structured objects between many languages like JSON. But unlike JSON, it is very fast and small.
 email:
 - frsyuki@gmail.com
@@ -104,7 +118,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/msgpack.rb
+- lib/msgpack/factory.rb
 - lib/msgpack/msgpack.jar
+- lib/msgpack/packer.rb
+- lib/msgpack/unpacker.rb
 - lib/msgpack/version.rb
 - spec/cases.json
 - spec/cases.msg
@@ -116,15 +133,20 @@ files:
 - spec/cruby/buffer_unpacker.rb
 - spec/cruby/packer_spec.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/msgpack/unpacker_spec.rb
-- spec/jruby/msgpack_spec.rb
+- spec/msgpack_spec.rb
 - spec/pack_spec.rb
+- spec/packer_spec.rb
 - spec/random_compat.rb
 - spec/spec_helper.rb
 - spec/unpack_spec.rb
+- spec/unpacker_spec.rb
 homepage: http://msgpack.org/
 licenses:
 - Apache 2.0
@@ -140,9 +162,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: msgpack
 rubygems_version: 2.4.6
@@ -160,13 +182,18 @@ test_files:
 - spec/cruby/buffer_unpacker.rb
 - spec/cruby/packer_spec.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/msgpack/unpacker_spec.rb
-- spec/jruby/msgpack_spec.rb
+- spec/msgpack_spec.rb
 - spec/pack_spec.rb
+- spec/packer_spec.rb
 - spec/random_compat.rb
 - spec/spec_helper.rb
 - spec/unpack_spec.rb
+- spec/unpacker_spec.rb
 has_rdoc: false