msgpack 0.7.0dev1-java → 0.7.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1074cd38a1217bb758be1ce482c293956f051c29
-  data.tar.gz: 53cac06789fb384cf3407e61e7cbb5d4ef2f263b
+  metadata.gz: c1d1fa6b2057865db28f74f3aea49b89ef699c98
+  data.tar.gz: 3c9a9f7ffcf915ef89719801269bee1582dd0c8a
 SHA512:
-  metadata.gz: 0d311e9a8d3729e29398660f0416d83a93e1d6c751851a0b240e11ec6ee18bd904d9b3ab2a249028a9591b8cb13281493eaf1fe7c97148ab56999be9bbea19f5
-  data.tar.gz: 274602def6f21adeb764c70ac6b506ef72f245983c9c63ab12d977bbd981da9e94976858d583750cd55c2d4c93c4a5333f2103ed04fa8feaa68079261ea8a8b4
+  metadata.gz: 4aafb7193dc1418a1dfa0d83307b057c747035e06824f6acd9b577b413ce55c123371b861541987894469cc784e5e9a08236d57126708f33a169507b2ecb46d8
+  data.tar.gz: a6be87fb55c743a644e5efbda54944a2d1b84f39f01e896e04c2e974ab5d0e1a404f6428985750c9f2a33d283aa6592f913abb1aea7030673045146e43dd958b

data/lib/msgpack/version.rb

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

data/spec/cruby/unpacker_spec.rb

@@ -10,60 +10,6 @@ describe Unpacker do
     Packer.new
   end
 
-  # TODO initialize
-
-  it 'read_array_header succeeds' do
-    unpacker.feed("\x91")
-    unpacker.read_array_header.should == 1
-  end
-
-  it 'read_array_header fails' do
-    unpacker.feed("\x81")
-    lambda {
-      unpacker.read_array_header
-    }.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
-    packer.write_array_header(2)
-    packer.write("e")
-    packer.write(1)
-    unpacker = Unpacker.new
-    unpacker.feed(packer.to_s)
-    unpacker.read_array_header.should == 2
-    unpacker.read.should == "e"
-    unpacker.read.should == 1
-  end
-
-  it 'read_map_header succeeds' do
-    unpacker.feed("\x81")
-    unpacker.read_map_header.should == 1
-  end
-
-  it 'read_map_header converts an map to key-value sequence' do
-    packer.write_map_header(1)
-    packer.write("k")
-    packer.write("v")
-    unpacker = Unpacker.new
-    unpacker.feed(packer.to_s)
-    unpacker.read_map_header.should == 1
-    unpacker.read.should == "k"
-    unpacker.read.should == "v"
-  end
-
-  it 'read_map_header fails' do
-    unpacker.feed("\x91")
-    lambda {
-      unpacker.read_map_header
-    }.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
     unpacker.feed("\xc0")
     unpacker.skip_nil.should == true
@@ -91,12 +37,6 @@ describe Unpacker do
     unpacker.read.should == 5
   end
 
-  it 'read raises EOFError' do
-    lambda {
-      unpacker.read
-    }.should raise_error(EOFError)
-  end
-
   it 'skip raises EOFError' do
     lambda {
       unpacker.skip
@@ -109,88 +49,6 @@ describe Unpacker do
     }.should raise_error(EOFError)
   end
 
-  let :sample_object do
-    [1024, {["a","b"]=>["c","d"]}, ["e","f"], "d", 70000, 4.12, 1.5, 1.5, 1.5]
-  end
-
-  it 'feed and each continue internal state' do
-    raw = sample_object.to_msgpack.to_s * 4
-    objects = []
-
-    raw.split(//).each do |b|
-      unpacker.feed(b)
-      unpacker.each {|c|
-        objects << c
-      }
-    end
-
-    objects.should == [sample_object] * 4
-  end
-
-  it 'feed_each continues internal state' do
-    raw = sample_object.to_msgpack.to_s * 4
-    objects = []
-
-    raw.split(//).each do |b|
-      unpacker.feed_each(b) {|c|
-        objects << c
-      }
-    end
-
-    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")
-    unpacker.reset
-    unpacker.feed("\x01")
-
-    unpacker.each.map {|x| x }.should == [1]
-  end
-
-  it 'reset clears internal state' do
-    # 1-element array
-    unpacker.feed("\x91")
-    unpacker.each.map {|x| x }.should == []
-
-    unpacker.reset
-
-    unpacker.feed("\x01")
-    unpacker.each.map {|x| x }.should == [1]
-  end
-
-  it 'frozen short strings' do
-    raw = sample_object.to_msgpack.to_s.force_encoding('UTF-8')
-    lambda {
-      unpacker.feed_each(raw.freeze) { }
-    }.should_not raise_error
-  end
-
-  it 'frozen long strings' do
-    raw = (sample_object.to_msgpack.to_s * 10240).force_encoding('UTF-8')
-    lambda {
-      unpacker.feed_each(raw.freeze) { }
-    }.should_not raise_error
-  end
-
-  it 'read raises level stack too deep error' do
-    512.times { packer.write_array_header(1) }
-    packer.write(nil)
-
-    unpacker = Unpacker.new
-    unpacker.feed(packer.to_s)
-    lambda {
-      unpacker.read
-    }.should raise_error(MessagePack::StackError)
-  end
-
   it 'skip raises level stack too deep error' do
     512.times { packer.write_array_header(1) }
     packer.write(nil)
@@ -202,116 +60,11 @@ describe Unpacker do
     }.should raise_error(MessagePack::StackError)
   end
 
-  it 'read raises invalid byte error' do
-    unpacker.feed("\xc1")
-    lambda {
-      unpacker.read
-    }.should raise_error(MessagePack::MalformedFormatError)
-  end
-
   it 'skip raises invalid byte error' do
     unpacker.feed("\xc1")
     lambda {
       unpacker.skip
     }.should raise_error(MessagePack::MalformedFormatError)
   end
-
-  it "gc mark" do
-    raw = sample_object.to_msgpack.to_s * 4
-
-    n = 0
-    raw.split(//).each do |b|
-      GC.start
-      unpacker.feed_each(b) {|o|
-        GC.start
-        o.should == sample_object
-        n += 1
-      }
-      GC.start
-    end
-
-    n.should == 4
-  end
-
-  it "buffer" do
-    orig = "a"*32*1024*4
-    raw = orig.to_msgpack.to_s
-
-    n = 655
-    times = raw.size / n
-    times += 1 unless raw.size % n == 0
-
-    off = 0
-    parsed = false
-
-    times.times do
-      parsed.should == false
-
-      seg = raw[off, n]
-      off += seg.length
-
-      unpacker.feed_each(seg) {|obj|
-        parsed.should == false
-        obj.should == orig
-        parsed = true
-      }
-    end
-
-    parsed.should == true
-  end
-
-  it 'MessagePack.unpack symbolize_keys' do
-    symbolized_hash = {:a => 'b', :c => 'd'}
-    MessagePack.load(MessagePack.pack(symbolized_hash), :symbolize_keys => true).should == symbolized_hash
-    MessagePack.unpack(MessagePack.pack(symbolized_hash), :symbolize_keys => true).should == symbolized_hash
-  end
-
-  it 'Unpacker#unpack symbolize_keys' do
-    unpacker = Unpacker.new(:symbolize_keys => true)
-    symbolized_hash = {:a => 'b', :c => 'd'}
-    unpacker.feed(MessagePack.pack(symbolized_hash)).read.should == symbolized_hash
-  end
-
-  it "msgpack str 8 type" do
-    MessagePack.unpack([0xd9, 0x00].pack('C*')).should == ""
-    MessagePack.unpack([0xd9, 0x00].pack('C*')).encoding.should == Encoding::UTF_8
-    MessagePack.unpack([0xd9, 0x01].pack('C*') + 'a').should == "a"
-    MessagePack.unpack([0xd9, 0x02].pack('C*') + 'aa').should == "aa"
-  end
-
-  it "msgpack str 16 type" do
-    MessagePack.unpack([0xda, 0x00, 0x00].pack('C*')).should == ""
-    MessagePack.unpack([0xda, 0x00, 0x00].pack('C*')).encoding.should == Encoding::UTF_8
-    MessagePack.unpack([0xda, 0x00, 0x01].pack('C*') + 'a').should == "a"
-    MessagePack.unpack([0xda, 0x00, 0x02].pack('C*') + 'aa').should == "aa"
-  end
-
-  it "msgpack str 32 type" do
-    MessagePack.unpack([0xdb, 0x00, 0x00, 0x00, 0x00].pack('C*')).should == ""
-    MessagePack.unpack([0xdb, 0x00, 0x00, 0x00, 0x00].pack('C*')).encoding.should == Encoding::UTF_8
-    MessagePack.unpack([0xdb, 0x00, 0x00, 0x00, 0x01].pack('C*') + 'a').should == "a"
-    MessagePack.unpack([0xdb, 0x00, 0x00, 0x00, 0x02].pack('C*') + 'aa').should == "aa"
-  end
-
-  it "msgpack bin 8 type" do
-    MessagePack.unpack([0xc4, 0x00].pack('C*')).should == ""
-    MessagePack.unpack([0xc4, 0x00].pack('C*')).encoding.should == Encoding::ASCII_8BIT
-    MessagePack.unpack([0xc4, 0x01].pack('C*') + 'a').should == "a"
-    MessagePack.unpack([0xc4, 0x02].pack('C*') + 'aa').should == "aa"
-  end
-
-  it "msgpack bin 16 type" do
-    MessagePack.unpack([0xc5, 0x00, 0x00].pack('C*')).should == ""
-    MessagePack.unpack([0xc5, 0x00, 0x00].pack('C*')).encoding.should == Encoding::ASCII_8BIT
-    MessagePack.unpack([0xc5, 0x00, 0x01].pack('C*') + 'a').should == "a"
-    MessagePack.unpack([0xc5, 0x00, 0x02].pack('C*') + 'aa').should == "aa"
-  end
-
-  it "msgpack bin 32 type" do
-    MessagePack.unpack([0xc6, 0x00, 0x00, 0x00, 0x00].pack('C*')).should == ""
-    MessagePack.unpack([0xc6, 0x0, 0x00, 0x00, 0x000].pack('C*')).encoding.should == Encoding::ASCII_8BIT
-    MessagePack.unpack([0xc6, 0x00, 0x00, 0x00, 0x01].pack('C*') + 'a').should == "a"
-    MessagePack.unpack([0xc6, 0x00, 0x00, 0x00, 0x02].pack('C*') + 'aa').should == "aa"
-  end
 end
 

data/spec/factory_spec.rb

@@ -1,8 +1,6 @@
 # encoding: ascii-8bit
 require 'spec_helper'
 
-eval("return") if java?
-
 describe MessagePack::Factory do
   subject do
     described_class.new
@@ -220,7 +218,6 @@ describe MessagePack::Factory do
     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)
 

data/spec/jruby/{msgpack/unpacker_spec.rb → unpacker_spec.rb}

@@ -2,43 +2,35 @@
 
 require 'stringio'
 require 'tempfile'
-require 'spec_helper'
 
+require 'spec_helper'
 
-describe ::MessagePack::Unpacker do
-  def flatten(struct, results = [])
-    case struct
-    when Array
-      struct.each { |v| flatten(v, results) }
-    when Hash
-      struct.each { |k, v| flatten(v, flatten(k, results)) }
-    else
-      results << struct
-    end
-    results
+describe MessagePack::Unpacker do
+  let :unpacker do
+    MessagePack::Unpacker.new
   end
 
-  subject do
-    described_class.new
+  let :packer do
+    MessagePack::Packer.new
   end
-  
+
   let :buffer1 do
     MessagePack.pack(:foo => 'bar')
   end
-    
+
   let :buffer2 do
     MessagePack.pack(:hello => {:world => [1, 2, 3]})
   end
-    
+
   let :buffer3 do
     MessagePack.pack(:x => 'y')
   end
-  
+
   describe '#execute/#execute_limit/#finished?' do
     let :buffer do
       buffer1 + buffer2 + buffer3
     end
-    
+
     it 'extracts an object from the buffer' do
       subject.execute(buffer, 0)
       subject.data.should == {'foo' => 'bar'}
@@ -53,7 +45,7 @@ describe ::MessagePack::Unpacker do
       subject.execute_limit(buffer, buffer1.length, buffer2.length)
       subject.data.should == {'hello' => {'world' => [1, 2, 3]}}
     end
-    
+
     it 'extracts nothing if the limit cuts an object in half' do
       subject.execute_limit(buffer, buffer1.length, 3)
       subject.data.should be_nil
@@ -63,63 +55,17 @@ describe ::MessagePack::Unpacker do
       subject.execute(buffer, 0).should == buffer1.length
       subject.execute(buffer, buffer1.length).should == buffer1.length + buffer2.length
     end
-    
+
     it 'is finished if #data returns an object' do
       subject.execute_limit(buffer, buffer1.length, buffer2.length)
       subject.should be_finished
-      
+
       subject.execute_limit(buffer, buffer1.length, 3)
       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
-      it 'yields each object in the buffer' do
-        objects = []
-        subject.feed(buffer1)
-        subject.feed(buffer2)
-        subject.feed(buffer3)
-        subject.each do |obj|
-          objects << obj
-        end
-        objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
-      end
-      
-      it 'returns an enumerator when no block is given' do
-        subject.feed(buffer1)
-        subject.feed(buffer2)
-        subject.feed(buffer3)
-        enum = subject.each
-        enum.map { |obj| obj.keys.first }.should == %w[foo hello x]
-      end
-    end
-    
     context 'with a StringIO stream' do
       it 'yields each object in the stream' do
         objects = []
@@ -130,7 +76,7 @@ describe ::MessagePack::Unpacker do
         objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
       end
     end
-    
+
     context 'with a File stream' do
       it 'yields each object in the stream' do
         objects = []
@@ -146,40 +92,8 @@ describe ::MessagePack::Unpacker do
         objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
       end
     end
-    
-    context 'with a stream passed to the constructor' do
-      it 'yields each object in the stream' do
-        objects = []
-        unpacker = described_class.new(StringIO.new(buffer1 + buffer2 + buffer3))
-        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
-    it 'feeds the buffer then runs #each' do
-      objects = []
-      subject.feed_each(buffer1 + buffer2 + buffer3) do |obj|
-        objects << obj
-      end
-      objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
-    end
 
-    it 'handles chunked data' do
-      objects = []
-      buffer = buffer1 + buffer2 + buffer3
-      buffer.chars.each do |ch|
-        subject.feed_each(ch) do |obj|
-          objects << obj
-        end
-      end
-      objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
-    end
-  end
-  
   describe '#fill' do
     it 'is a no-op' do
       subject.stream = StringIO.new(buffer1 + buffer2 + buffer3)
@@ -187,22 +101,17 @@ describe ::MessagePack::Unpacker do
       subject.each { |obj| }
     end
   end
-  
-  describe '#reset' do
-    context 'with a buffer' do
-      it 'is unclear what it is supposed to do'
-    end
-    
-    context 'with a stream' do
-      it 'is unclear what it is supposed to do'
-    end
-  end
 
-  context 'regressions' do
-    it 'handles massive arrays (issue #2)' do
-      array = ['foo'] * 10_000
-      MessagePack.unpack(MessagePack.pack(array)).should have(10_000).items
+  def flatten(struct, results = [])
+    case struct
+    when Array
+      struct.each { |v| flatten(v, results) }
+    when Hash
+      struct.each { |k, v| flatten(v, flatten(k, results)) }
+    else
+      results << struct
     end
+    results
   end
 
   context 'encoding', :encodings do
@@ -229,15 +138,15 @@ describe ::MessagePack::Unpacker do
       Encoding.default_external = Encoding::ISO_8859_1
     end
 
-    it 'produces results with default internal encoding' do
+    it 'produces results with encoding as binary or string(utf8)' do
       unpacker.execute(buffer, 0)
       strings = flatten(unpacker.data).grep(String)
-      strings.map(&:encoding).uniq.should == [Encoding.default_internal]
+      strings.map(&:encoding).uniq.sort{|a,b| a.to_s <=> b.to_s}.should == [Encoding::ASCII_8BIT, Encoding::UTF_8]
     end
 
     it 'recodes to internal encoding' do
       unpacker.execute(buffer, 0)
-      unpacker.data['nested'][1].keys.should == ["sk\xC3\xA5l".force_encoding(Encoding.default_internal)]
+      unpacker.data['nested'][1].keys.should == ["sk\xC3\xA5l".force_encoding(Encoding::UTF_8)]
     end
   end
 
@@ -255,23 +164,6 @@ describe ::MessagePack::Unpacker do
         unpacker.execute(buffer, 0)
         unpacker.data.should == {:hello => 'world', :nested => ['object', {:structure => true}]}
       end
-
-      it 'can symbolize keys when using #each' do
-        objs = []
-        unpacker.feed(buffer)
-        unpacker.each do |obj|
-          objs << obj
-        end
-        objs.should == [{:hello => 'world', :nested => ['object', {:structure => true}]}]
-      end
-
-      it 'can symbolize keys when using #feed_each' do
-        objs = []
-        unpacker.feed_each(buffer) do |obj|
-          objs << obj
-        end
-        objs.should == [{:hello => 'world', :nested => ['object', {:structure => true}]}]
-      end
     end
 
     context 'encoding', :encodings do
@@ -280,35 +172,14 @@ describe ::MessagePack::Unpacker do
       end
 
       let :unpacker do
-        described_class.new(:encoding => 'UTF-8')
+        described_class.new()
       end
 
-      it 'can hardcode encoding when using #execute' do
+      it 'decode binary as ascii-8bit string when using #execute' do
         unpacker.execute(buffer, 0)
         strings = flatten(unpacker.data).grep(String)
         strings.should == %w[hello world nested object structure]
-        strings.map(&:encoding).uniq.should == [Encoding::UTF_8]
-      end
-
-      it 'can hardcode encoding when using #each' do
-        objs = []
-        unpacker.feed(buffer)
-        unpacker.each do |obj|
-          objs << obj
-        end
-        strings = flatten(objs).grep(String)
-        strings.should == %w[hello world nested object structure]
-        strings.map(&:encoding).uniq.should == [Encoding::UTF_8]
-      end
-
-      it 'can hardcode encoding when using #feed_each' do
-        objs = []
-        unpacker.feed_each(buffer) do |obj|
-          objs << obj
-        end
-        strings = flatten(objs).grep(String)
-        strings.should == %w[hello world nested object structure]
-        strings.map(&:encoding).uniq.should == [Encoding::UTF_8]
+        strings.map(&:encoding).uniq.should == [Encoding::ASCII_8BIT]
       end
     end
   end