hessian2 2.0.5 → 2.0.6

data/spec/null_spec.rb

@@ -1,17 +1,17 @@
-require File.expand_path('../spec_helper', __FILE__)
-
-module Hessian2
-  describe Writer do
-    context "when null" do
-      
-      it "should write null ('N') ::= 'N'" do
-        val = nil
-        bin = Hessian2.write(val)
-
-        expect(bin).to eq('N')
-        expect(Hessian2.parse(bin)).to eq(val)
-      end
-
-    end
-  end
-end
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe Writer do
+    context "when null" do
+      
+      it "should write null ('N') ::= 'N'" do
+        val = nil
+        bin = Hessian2.write(val)
+
+        expect(bin).to eq('N')
+        expect(Hessian2.parse(bin)).to eq(val)
+      end
+
+    end
+  end
+end

data/spec/object_spec.rb

@@ -1,78 +1,78 @@
-require File.expand_path('../spec_helper', __FILE__)
-
-module Hessian2
-  describe Writer do
-    context "when object" do
-      hash = { id: nil, born_at: Time.new(2009, 5, 8), name: '大鸡', price: 99.99 }
-
-      it "should write object type definition ('C') ::= 'C' string int string* and object with direct type ::= [x60-x6f] value*" do
-        [ 'Monkey', 'AnotherMonkey' ].each do |klass|
-          bin = Hessian2.write(Kernel.const_get(klass).new(hash))
-
-          bytes = bin.each_byte
-          expect([ bytes.next ].pack('C')).to eq('C')
-          expect(Hessian2.parse_string(bytes)).to eq(klass)
-          expect(Hessian2.parse_int(bytes)).to eq(4)
-          4.times{ Hessian2.parse_string(bytes) }
-          expect(bytes.next - 0x60).to eq(0)
-          _monkey = Hessian2.parse(bin)
-          expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
-        end
-      end
-
-
-      it "should write object instance ('O') ::= 'O' int value*" do
-        arr = []
-        17.times do |i|
-          arr << Hessian2::ClassWrapper.new("com.sun.java.Monkey#{i}", hash)
-        end
-        bin = Hessian2.write(arr)
-
-        bytes = bin.each_byte
-
-        # skip x58 int
-        bytes.next
-        Hessian2.parse_int(bytes)
-
-        # skip top 16
-        16.times do
-          bytes.next
-          Hessian2.parse_string(bytes)
-          Hessian2.parse_int(bytes)
-          4.times{ Hessian2.parse_string(bytes) }
-          bytes.next
-          4.times{ Hessian2.parse_bytes(bytes) }
-        end
-
-        # skip 17th class definition
-        bytes.next
-        Hessian2.parse_string(bytes)
-        Hessian2.parse_int(bytes)
-        4.times{ Hessian2.parse_string(bytes) }
-
-        expect([ bytes.next ].pack('C')).to eq('O')
-        expect(Hessian2.parse_int(bytes)).to eq(16)
-
-        _monkeys = Hessian2.parse(bin)
-        expect(_monkeys.size).to eq(17)
-        _monkeys.each do |_monkey|
-          expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
-        end
-      end
-
-      it "should write ActiveRecord::Relation" do
-        val = Monkey.where(true).limit(2)
-        bin = Hessian2.write(val)
-
-        bytes = bin.each_byte
-        expect(bytes.next - 0x78).to eq(val.size)
-
-        born_at = Time.new(1989, 5, 8)
-        Hessian2.parse(bin).each_with_index do |_monkey, i|
-          expect([ _monkey.id, _monkey.name, _monkey.price, _monkey.born_at ]).to eq([ i + 1, "#{i}号猴", 0.25 * i, born_at + 86400 * i ])
-        end
-      end
-
-    end
-  end
-end
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe Writer do
+    context "when object" do
+      hash = { id: nil, born_at: Time.new(2009, 5, 8), name: '大鸡', price: 99.99 }
+
+      it "should write object type definition ('C') ::= 'C' string int string* and object with direct type ::= [x60-x6f] value*" do
+        [ 'Monkey', 'AnotherMonkey' ].each do |klass|
+          bin = Hessian2.write(Kernel.const_get(klass).new(hash))
+
+          bytes = bin.each_byte
+          expect([ bytes.next ].pack('C')).to eq('C')
+          expect(Hessian2.parse_string(bytes)).to eq(klass)
+          expect(Hessian2.parse_int(bytes)).to eq(4)
+          4.times{ Hessian2.parse_string(bytes) }
+          expect(bytes.next - 0x60).to eq(0)
+          _monkey = Hessian2.parse(bin)
+          expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
+        end
+      end
+
+
+      it "should write object instance ('O') ::= 'O' int value*" do
+        arr = []
+        17.times do |i|
+          arr << Hessian2::ClassWrapper.new("com.sun.java.Monkey#{i}", hash)
+        end
+        bin = Hessian2.write(arr)
+
+        bytes = bin.each_byte
+
+        # skip x58 int
+        bytes.next
+        Hessian2.parse_int(bytes)
+
+        # skip top 16
+        16.times do
+          bytes.next
+          Hessian2.parse_string(bytes)
+          Hessian2.parse_int(bytes)
+          4.times{ Hessian2.parse_string(bytes) }
+          bytes.next
+          4.times{ Hessian2.parse_bytes(bytes) }
+        end
+
+        # skip 17th class definition
+        bytes.next
+        Hessian2.parse_string(bytes)
+        Hessian2.parse_int(bytes)
+        4.times{ Hessian2.parse_string(bytes) }
+
+        expect([ bytes.next ].pack('C')).to eq('O')
+        expect(Hessian2.parse_int(bytes)).to eq(16)
+
+        _monkeys = Hessian2.parse(bin)
+        expect(_monkeys.size).to eq(17)
+        _monkeys.each do |_monkey|
+          expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
+        end
+      end
+
+      it "should write ActiveRecord::Relation" do
+        val = Monkey.where(true).limit(2)
+        bin = Hessian2.write(val)
+
+        bytes = bin.each_byte
+        expect(bytes.next - 0x78).to eq(val.size)
+
+        born_at = Time.new(1989, 5, 8)
+        Hessian2.parse(bin).each_with_index do |_monkey, i|
+          expect([ _monkey.id, _monkey.name, _monkey.price, _monkey.born_at ]).to eq([ i + 1, "#{i}号猴", 0.25 * i, born_at + 86400 * i ])
+        end
+      end
+
+    end
+  end
+end

data/spec/ref_spec.rb

@@ -1,43 +1,43 @@
-require File.expand_path('../spec_helper', __FILE__)
-
-module Hessian2
-  describe Writer do
-    context "when ref" do
-      hash1 = { id: nil, born_at: Time.new(2009, 5, 8), name: '大鸡', price: 99.99 }
-
-      it "should write reference to map/list/object - integer ('Q') ::= x51 int" do
-        monkey1 = Monkey.new(hash1)
-        monkey2 = Hessian2::ClassWrapper.new("com.sun.java.Monkey", hash1)
-        monkey3 = Hessian2::TypeWrapper.new("com.sun.java.Monkey", hash1)
-        monkeys1 = [ monkey1, monkey2, monkey3 ]
-        monkeys2 = Hessian2::ClassWrapper.new("[com.sun.java.Monkey", monkeys1)
-        monkeys3 = Hessian2::TypeWrapper.new("[com.sun.java.Monkey", monkeys1)
-
-        arr = [ hash1, monkey1, monkey2, monkey3, monkeys1, monkeys2, monkeys3 ] * 2
-        
-        bin = Hessian2.write(arr)
-
-        _hash1, _monkey1, _monkey2, _monkey3, _monkeys1, _monkeys2, _monkeys3, \
-        _hash1r, _monkey1r, _monkey2r, _monkey3r, _monkeys1r, _monkeys2r, _monkeys3r = Hessian2.parse(bin, nil, symbolize_keys: true)
-
-        [ _hash1, _hash1r, _monkey3, _monkey3r ].each do |_hash|
-          expect([ _hash[:born_at], _hash[:name], _hash[:price] ]).to eq([ hash1[:born_at], hash1[:name], hash1[:price] ])
-        end
-
-        [ _monkey1, _monkey2, _monkey1r, _monkey2r ].each do |_monkey|
-          expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash1[:born_at], hash1[:name], hash1[:price] ])
-        end
-        
-        [ _monkeys1, _monkeys2, _monkeys3, _monkeys1r, _monkeys2r, _monkeys3r ].each do |_monkeys|
-          [ _monkeys[0], _monkeys[1] ].each do |_monkey|
-            expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash1[:born_at], hash1[:name], hash1[:price] ])
-          end
-          last = _monkeys.last
-          expect([ last[:born_at], last[:name], last[:price] ]).to eq([ hash1[:born_at], hash1[:name], hash1[:price] ])
-        end
-
-      end
-
-    end
-  end
-end
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe Writer do
+    context "when ref" do
+      hash1 = { id: nil, born_at: Time.new(2009, 5, 8), name: '大鸡', price: 99.99 }
+
+      it "should write reference to map/list/object - integer ('Q') ::= x51 int" do
+        monkey1 = Monkey.new(hash1)
+        monkey2 = Hessian2::ClassWrapper.new("com.sun.java.Monkey", hash1)
+        monkey3 = Hessian2::TypeWrapper.new("com.sun.java.Monkey", hash1)
+        monkeys1 = [ monkey1, monkey2, monkey3 ]
+        monkeys2 = Hessian2::ClassWrapper.new("[com.sun.java.Monkey", monkeys1)
+        monkeys3 = Hessian2::TypeWrapper.new("[com.sun.java.Monkey", monkeys1)
+
+        arr = [ hash1, monkey1, monkey2, monkey3, monkeys1, monkeys2, monkeys3 ] * 2
+        
+        bin = Hessian2.write(arr)
+
+        _hash1, _monkey1, _monkey2, _monkey3, _monkeys1, _monkeys2, _monkeys3, \
+        _hash1r, _monkey1r, _monkey2r, _monkey3r, _monkeys1r, _monkeys2r, _monkeys3r = Hessian2.parse(bin, nil, symbolize_keys: true)
+
+        [ _hash1, _hash1r, _monkey3, _monkey3r ].each do |_hash|
+          expect([ _hash[:born_at], _hash[:name], _hash[:price] ]).to eq([ hash1[:born_at], hash1[:name], hash1[:price] ])
+        end
+
+        [ _monkey1, _monkey2, _monkey1r, _monkey2r ].each do |_monkey|
+          expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash1[:born_at], hash1[:name], hash1[:price] ])
+        end
+        
+        [ _monkeys1, _monkeys2, _monkeys3, _monkeys1r, _monkeys2r, _monkeys3r ].each do |_monkeys|
+          [ _monkeys[0], _monkeys[1] ].each do |_monkey|
+            expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash1[:born_at], hash1[:name], hash1[:price] ])
+          end
+          last = _monkeys.last
+          expect([ last[:born_at], last[:name], last[:price] ]).to eq([ hash1[:born_at], hash1[:name], hash1[:price] ])
+        end
+
+      end
+
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,23 +1,23 @@
-lib_path = File.expand_path('../../lib', __FILE__)
-$:.unshift(lib_path)
-
-require 'hessian2'
-
-require 'active_record'
-require 'mysql2'
-
-MonkeyStruct = Struct.new(:born_at, :id, :name, :price)
-
-options = YAML.load_file(File.expand_path('../database.yml', __FILE__))
-ActiveRecord::Base.establish_connection(options)
-ActiveRecord::Base.default_timezone = :local
-
-class Monkey < ActiveRecord::Base; end
-
-class AnotherMonkey
-  attr_accessor :born_at, :id, :name, :price
-
-  def initialize(attrs = {})
-    attrs.each { |k, v| send("#{k}=", v) if respond_to?("#{k}=") }
-  end
-end
+lib_path = File.expand_path('../../lib', __FILE__)
+$:.unshift(lib_path)
+
+require 'hessian2'
+
+require 'active_record'
+require 'mysql2'
+
+MonkeyStruct = Struct.new(:born_at, :id, :name, :price)
+
+options = YAML.load_file(File.expand_path('../database.yml', __FILE__))
+ActiveRecord::Base.establish_connection(options)
+ActiveRecord::Base.default_timezone = :local
+
+class Monkey < ActiveRecord::Base; end
+
+class AnotherMonkey
+  attr_accessor :born_at, :id, :name, :price
+
+  def initialize(attrs = {})
+    attrs.each { |k, v| send("#{k}=", v) if respond_to?("#{k}=") }
+  end
+end

data/spec/string_spec.rb

@@ -1,61 +1,61 @@
-require File.expand_path('../spec_helper', __FILE__)
-
-module Hessian2
-  describe Writer do
-    context "when string" do
-      
-      it "should write utf-8 string length 0-31 ::= [x00-x1f] <utf8-data>" do
-        (0..31).each do |len|
-          val = '啦' * len
-          bin = Hessian2.write(val)
-
-          expect(bin[0].unpack('C').first).to eq(val.size)
-          expect(bin[1..-1]).to eq(val.b)
-          expect(Hessian2.parse(bin)).to eq(val)
-        end
-      end
-
-
-      it "should write utf-8 string length 0-1023 ::= [x30-x33] b0 <utf8-data>" do
-        [ 33, 256, 512, 1023 ].each do |len|
-          val = '啦' * len
-          bin = Hessian2.write(val)
-
-          b1, b0 = bin[0, 2].unpack('CC')
-          expect(256 * (b1 - 0x30) + b0).to eq(val.size)
-          expect(bin[2..-1]).to eq(val.b)
-          expect(Hessian2.parse(bin)).to eq(val)
-        end
-      end
-
-      it "should write utf-8 string final chunk ('S') ::= S b1 b0 <utf8-data>" do
-        val = '啦' * 0x400
-        bin = Hessian2.write(val)
-        
-        expect(bin[0]).to eq('S')
-        expect(bin[1, 2].unpack('n').first).to eq(0x400)
-        expect(Hessian2.parse(bin)).to eq(val)
-      end
-
-
-      it "should write utf-8 string non-final chunk ('R') ::= x52 b1 b0 <utf8-data>" do
-        val = '啦' * 0x10400
-        bin = Hessian2.write(val)
-
-        chunks = val.size / 0x8000
-        i = 0
-
-        chunks.times do |c|
-          expect(bin[i]).to eq('R')
-          expect(bin[i + 1, 2].unpack('n').first).to eq(0x8000)
-          i += (3 + val[c * 0x8000, 0x8000].bytesize)
-        end
-        
-        expect(bin[i]).to eq('S')
-        expect(bin[i + 1, 2].unpack('n').first).to eq(val.size - 0x8000 * chunks)
-        expect(Hessian2.parse(bin)).to eq(val)
-      end
-
-    end
-  end
-end
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe Writer do
+    context "when string" do
+      
+      it "should write utf-8 string length 0-31 ::= [x00-x1f] <utf8-data>" do
+        (0..31).each do |len|
+          val = '啦' * len
+          bin = Hessian2.write(val)
+
+          expect(bin[0].unpack('C').first).to eq(val.size)
+          expect(bin[1..-1]).to eq(val.b)
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+
+      it "should write utf-8 string length 0-1023 ::= [x30-x33] b0 <utf8-data>" do
+        [ 33, 256, 512, 1023 ].each do |len|
+          val = '啦' * len
+          bin = Hessian2.write(val)
+
+          b1, b0 = bin[0, 2].unpack('CC')
+          expect(256 * (b1 - 0x30) + b0).to eq(val.size)
+          expect(bin[2..-1]).to eq(val.b)
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+      it "should write utf-8 string final chunk ('S') ::= S b1 b0 <utf8-data>" do
+        val = '啦' * 0x400
+        bin = Hessian2.write(val)
+        
+        expect(bin[0]).to eq('S')
+        expect(bin[1, 2].unpack('n').first).to eq(0x400)
+        expect(Hessian2.parse(bin)).to eq(val)
+      end
+
+
+      it "should write utf-8 string non-final chunk ('R') ::= x52 b1 b0 <utf8-data>" do
+        val = '啦' * 0x10400
+        bin = Hessian2.write(val)
+
+        chunks = val.size / 0x8000
+        i = 0
+
+        chunks.times do |c|
+          expect(bin[i]).to eq('R')
+          expect(bin[i + 1, 2].unpack('n').first).to eq(0x8000)
+          i += (3 + val[c * 0x8000, 0x8000].bytesize)
+        end
+        
+        expect(bin[i]).to eq('S')
+        expect(bin[i + 1, 2].unpack('n').first).to eq(val.size - 0x8000 * chunks)
+        expect(Hessian2.parse(bin)).to eq(val)
+      end
+
+    end
+  end
+end

data/spec/struct_wrapper_spec.rb

@@ -1,47 +1,47 @@
-require File.expand_path('../spec_helper', __FILE__)
-
-module Hessian2
-  describe StructWrapper do
-		hash = { id: nil, born_at: Time.new(2009, 5, 8), name: '大鸡', price: 99.99 }
-		
-		# it "should raise error" do
-		# 	expect(lambda{ Hessian2::StructWrapper.new(MonkeyStruct) }).to raise_error
-		# end
-
-
-		# it "should wrap nil" do
-		# 	bin = Hessian2.write(Hessian2::StructWrapper.new(MonkeyStruct, nil))
-
-		# 	_monkey = Hessian2.parse(bin, MonkeyStruct)
-		# 	expect(_monkey).to eq(nil)
-		# end
-
-
-		# it "should wrap hash, monkey, another monkey" do
-		# 	[ MonkeyStruct, 'MonkeyStruct' ].each do |klass|
-		# 		[ hash, Monkey.new(hash), AnotherMonkey.new(hash) ].each do |val|
-		# 			bin = Hessian2.write(Hessian2::StructWrapper.new(klass, val))
-					
-		# 			_monkey = Hessian2.parse(bin, klass)
-		# 			expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
-		# 		end
-		# 	end
-		# end
-
-
-		it "should wrap array" do
-			[ [MonkeyStruct], '[MonkeyStruct' ].each do |klass|
-				arr = [ nil, hash, Monkey.new(hash), AnotherMonkey.new(hash) ]
-				bin = Hessian2.write(Hessian2::StructWrapper.new(klass, arr))
-				
-				_monkey1, _monkey2, _monkey3, _monkey4 = Hessian2.parse(bin, klass, symbolize_keys: true)
-				expect(_monkey1).to eq(nil)
-				expect([ _monkey2[:born_at], _monkey2[:name], _monkey2[:price] ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
-				[ _monkey3, _monkey4 ].each do |_monkey|
-					expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
-				end
-			end
-		end
-		
-	end
-end
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe StructWrapper do
+		hash = { id: nil, born_at: Time.new(2009, 5, 8), name: '大鸡', price: 99.99 }
+		
+		# it "should raise error" do
+		# 	expect(lambda{ Hessian2::StructWrapper.new(MonkeyStruct) }).to raise_error
+		# end
+
+
+		# it "should wrap nil" do
+		# 	bin = Hessian2.write(Hessian2::StructWrapper.new(MonkeyStruct, nil))
+
+		# 	_monkey = Hessian2.parse(bin, MonkeyStruct)
+		# 	expect(_monkey).to eq(nil)
+		# end
+
+
+		# it "should wrap hash, monkey, another monkey" do
+		# 	[ MonkeyStruct, 'MonkeyStruct' ].each do |klass|
+		# 		[ hash, Monkey.new(hash), AnotherMonkey.new(hash) ].each do |val|
+		# 			bin = Hessian2.write(Hessian2::StructWrapper.new(klass, val))
+					
+		# 			_monkey = Hessian2.parse(bin, klass)
+		# 			expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
+		# 		end
+		# 	end
+		# end
+
+
+		it "should wrap array" do
+			[ [MonkeyStruct], '[MonkeyStruct' ].each do |klass|
+				arr = [ nil, hash, Monkey.new(hash), AnotherMonkey.new(hash) ]
+				bin = Hessian2.write(Hessian2::StructWrapper.new(klass, arr))
+				
+				_monkey1, _monkey2, _monkey3, _monkey4 = Hessian2.parse(bin, klass, symbolize_keys: true)
+				expect(_monkey1).to eq(nil)
+				expect([ _monkey2[:born_at], _monkey2[:name], _monkey2[:price] ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
+				[ _monkey3, _monkey4 ].each do |_monkey|
+					expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
+				end
+			end
+		end
+		
+	end
+end