nayutaya-msgpack-pure 0.0.1 → 0.0.2

data/README.md

@@ -5,6 +5,4 @@ msgpack_pureは、MessagePackのPure Rubyによる実装です。
 
 ## インストール
 
-↓まだgemパッケージは作っていないため、下記はできません
-
   $ gem install nayutaya-msgpack_pure

data/lib/msgpack_pure/core.rb

@@ -7,12 +7,14 @@ require "msgpack_pure/unpacker"
 module MessagePackPure
   def self.pack(value)
     io = StringIO.new
-    Packer.write(io, value)
+    packer = Packer.new(io)
+    packer.write(value)
     return io.string
   end
 
   def self.unpack(binary)
     io = StringIO.new(binary, "r")
-    return Unpacker.read(io)
+    unpacker = Unpacker.new(io)
+    return unpacker.read
   end
 end

data/lib/msgpack_pure/packer.rb

@@ -4,189 +4,198 @@
 # http://msgpack.sourceforge.jp/spec
 
 module MessagePackPure
-  module Packer
+  class Packer
   end
 end
 
-module MessagePackPure::Packer
-  def self.write(io, value)
+class MessagePackPure::Packer
+  def initialize(io)
+    @io = io
+  end
+
+  attr_reader :io
+
+  def write(value)
     case value
-    when Integer    then self.write_integer(io, value)
-    when NilClass   then self.write_nil(io)
-    when TrueClass  then self.write_true(io)
-    when FalseClass then self.write_false(io)
-    when Float      then self.write_float(io, value)
-    when String     then self.write_string(io, value)
-    when Array      then self.write_array(io, value)
-    when Hash       then self.write_hash(io, value)
+    when Integer    then self.write_integer(value)
+    when NilClass   then self.write_nil
+    when TrueClass  then self.write_true
+    when FalseClass then self.write_false
+    when Float      then self.write_float(value)
+    when String     then self.write_string(value)
+    when Array      then self.write_array(value)
+    when Hash       then self.write_hash(value)
     else raise("unknown type")
     end
-    return io
+
+    return @io
   end
 
-  def self.write_integer(io, num)
+  protected
+
+  def write_integer(num)
     case num
     when (-0x20..0x7F)
       # positive fixnum, negative fixnum
-      io.write(self.pack_int8(num))
+      @io.write(self.pack_int8(num))
     when (0x00..0xFF)
       # uint8
-      io.write("\xCC")
-      io.write(self.pack_uint8(num))
+      @io.write("\xCC")
+      @io.write(self.pack_uint8(num))
     when (-0x80..0x7F)
       # int8
-      io.write("\xD0")
-      io.write(self.pack_int8(num))
+      @io.write("\xD0")
+      @io.write(self.pack_int8(num))
     when (0x0000..0xFFFF)
       # uint16
-      io.write("\xCD")
-      io.write(self.pack_uint16(num))
+      @io.write("\xCD")
+      @io.write(self.pack_uint16(num))
     when (-0x8000..0x7FFF)
       # int16
-      io.write("\xD1")
-      io.write(self.pack_int16(num))
+      @io.write("\xD1")
+      @io.write(self.pack_int16(num))
     when (0x00000000..0xFFFFFFFF)
       # uint32
-      io.write("\xCE")
-      io.write(self.pack_uint32(num))
+      @io.write("\xCE")
+      @io.write(self.pack_uint32(num))
     when (-0x80000000..0x7FFFFFFF)
       # int32
-      io.write("\xD2")
-      io.write(self.pack_int32(num))
+      @io.write("\xD2")
+      @io.write(self.pack_int32(num))
     when (0x0000000000000000..0xFFFFFFFFFFFFFFFF)
       # uint64
-      io.write("\xCF")
-      io.write(self.pack_uint64(num))
+      @io.write("\xCF")
+      @io.write(self.pack_uint64(num))
     when (-0x8000000000000000..0x7FFFFFFFFFFFFFFF)
       # int64
-      io.write("\xD3")
-      io.write(self.pack_int64(num))
+      @io.write("\xD3")
+      @io.write(self.pack_int64(num))
     else
       raise("invalid integer")
     end
   end
 
-  def self.write_nil(io)
-    io.write("\xC0")
+  def write_nil
+    @io.write("\xC0")
   end
 
-  def self.write_true(io)
-    io.write("\xC3")
+  def write_true
+    @io.write("\xC3")
   end
 
-  def self.write_false(io)
-    io.write("\xC2")
+  def write_false
+    @io.write("\xC2")
   end
 
-  def self.write_float(io, value)
-    io.write("\xCB")
-    io.write(self.pack_double(value))
+  def write_float(value)
+    @io.write("\xCB")
+    @io.write(self.pack_double(value))
   end
 
-  def self.write_string(io, value)
+  def write_string(value)
     case value.size
     when (0x00..0x1F)
       # fixraw
-      io.write(self.pack_uint8(0b10100000 + value.size))
-      io.write(value)
+      @io.write(self.pack_uint8(0b10100000 + value.size))
+      @io.write(value)
     when (0x0000..0xFFFF)
       # raw16
-      io.write("\xDA")
-      io.write(self.pack_uint16(value.size))
-      io.write(value)
+      @io.write("\xDA")
+      @io.write(self.pack_uint16(value.size))
+      @io.write(value)
     when (0x00000000..0xFFFFFFFF)
       # raw32
-      io.write("\xDB")
-      io.write(self.pack_uint32(value.size))
-      io.write(value)
+      @io.write("\xDB")
+      @io.write(self.pack_uint32(value.size))
+      @io.write(value)
     else
       raise("invalid length")
     end
   end
 
-  def self.write_array(io, value)
+  def write_array(value)
     case value.size
     when (0x00..0x0F)
       # fixarray
-      io.write(self.pack_uint8(0b10010000 + value.size))
+      @io.write(self.pack_uint8(0b10010000 + value.size))
     when (0x0000..0xFFFF)
       # array16
-      io.write("\xDC")
-      io.write(self.pack_uint16(value.size))
+      @io.write("\xDC")
+      @io.write(self.pack_uint16(value.size))
     when (0x00000000..0xFFFFFFFF)
       # array32
-      io.write("\xDD")
-      io.write(self.pack_uint32(value.size))
+      @io.write("\xDD")
+      @io.write(self.pack_uint32(value.size))
     else
       raise("invalid length")
     end
 
     value.each { |item|
-      self.write(io, item)
+      self.write(item)
     }
   end
 
-  def self.write_hash(io, value)
+  def write_hash(value)
     case value.size
     when (0x00..0x0F)
       # fixmap
-      io.write(self.pack_uint8(0b10000000 + value.size))
+      @io.write(self.pack_uint8(0b10000000 + value.size))
     when (0x0000..0xFFFF)
       # map16
-      io.write("\xDE")
-      io.write(self.pack_uint16(value.size))
+      @io.write("\xDE")
+      @io.write(self.pack_uint16(value.size))
     when (0x00000000..0xFFFFFFFF)
       # map32
-      io.write("\xDF")
-      io.write(self.pack_uint32(value.size))
+      @io.write("\xDF")
+      @io.write(self.pack_uint32(value.size))
     else
       raise("invalid length")
     end
 
     value.sort_by { |key, value| key }.each { |key, value|
-      self.write(io, key)
-      self.write(io, value)
+      self.write(key)
+      self.write(value)
     }
   end
 
-  def self.pack_uint8(value)
+  def pack_uint8(value)
     return [value].pack("C")
   end
 
-  def self.pack_int8(value)
+  def pack_int8(value)
     return [value].pack("c")
   end
 
-  def self.pack_uint16(value)
+  def pack_uint16(value)
     return [value].pack("n")
   end
 
-  def self.pack_int16(value)
+  def pack_int16(value)
     value += (2 ** 16) if value < 0
     return self.pack_uint16(value)
   end
 
-  def self.pack_uint32(value)
+  def pack_uint32(value)
     return [value].pack("N")
   end
 
-  def self.pack_int32(value)
+  def pack_int32(value)
     value += (2 ** 32) if value < 0
     return self.pack_uint32(value)
   end
 
-  def self.pack_uint64(value)
+  def pack_uint64(value)
     high = (value >> 32)
     low  = (value & 0xFFFFFFFF)
     return self.pack_uint32(high) + self.pack_uint32(low)
   end
 
-  def self.pack_int64(value)
+  def pack_int64(value)
     value += (2 ** 64) if value < 0
     return self.pack_uint64(value)
   end
 
-  def self.pack_double(value)
+  def pack_double(value)
     return [value].pack("G")
   end
 end

data/lib/msgpack_pure/unpacker.rb

@@ -4,13 +4,19 @@
 # http://msgpack.sourceforge.jp/spec
 
 module MessagePackPure
-  module Unpacker
+  class Unpacker
   end
 end
 
-module MessagePackPure::Unpacker
-  def self.read(io)
-    type = self.unpack_uint8(io)
+class MessagePackPure::Unpacker
+  def initialize(io)
+    @io = io
+  end
+
+  attr_reader :io
+
+  def read
+    type = self.unpack_uint8
 
     case
     when (type & 0b10000000) == 0b00000000 # positive fixnum
@@ -19,13 +25,13 @@ module MessagePackPure::Unpacker
       return (type & 0b00011111) - (2 ** 5)
     when (type & 0b11100000) == 0b10100000 # fixraw
       size = (type & 0b00011111)
-      return io.read(size)
+      return @io.read(size)
     when (type & 0b11110000) == 0b10010000 # fixarray
       size = (type & 0b00001111)
-      return self.read_array(io, size)
+      return self.read_array(size)
     when (type & 0b11110000) == 0b10000000 # fixmap
       size = (type & 0b00001111)
-      return self.read_hash(io, size)
+      return self.read_hash(size)
     end
 
     case type
@@ -36,101 +42,101 @@ module MessagePackPure::Unpacker
     when 0xC3 # true
       return true
     when 0xCA # float
-      return self.unpack_float(io)
+      return self.unpack_float
     when 0xCB # double
-      return self.unpack_double(io)
+      return self.unpack_double
     when 0xCC # uint8
-      return self.unpack_uint8(io)
+      return self.unpack_uint8
     when 0xCD # uint16
-      return self.unpack_uint16(io)
+      return self.unpack_uint16
     when 0xCE # uint32
-      return self.unpack_uint32(io)
+      return self.unpack_uint32
     when 0xCF # uint64
-      return self.unpack_uint64(io)
+      return self.unpack_uint64
     when 0xD0 # int8
-      return self.unpack_int8(io)
+      return self.unpack_int8
     when 0xD1 # int16
-      return self.unpack_int16(io)
+      return self.unpack_int16
     when 0xD2 # int32
-      return self.unpack_int32(io)
+      return self.unpack_int32
     when 0xD3 # int64
-      return self.unpack_int64(io)
+      return self.unpack_int64
     when 0xDA # raw16
-      size = self.unpack_uint16(io)
-      return io.read(size)
+      size = self.unpack_uint16
+      return @io.read(size)
     when 0xDB # raw32
-      size = self.unpack_uint32(io)
-      return io.read(size)
+      size = self.unpack_uint32
+      return @io.read(size)
     when 0xDC # array16
-      size = self.unpack_uint16(io)
-      return self.read_array(io, size)
+      size = self.unpack_uint16
+      return self.read_array(size)
     when 0xDD # array32
-      size = self.unpack_uint32(io)
-      return self.read_array(io, size)
+      size = self.unpack_uint32
+      return self.read_array(size)
     when 0xDE # map16
-      size = self.unpack_uint16(io)
-      return self.read_hash(io, size)
+      size = self.unpack_uint16
+      return self.read_hash(size)
     when 0xDF # map32
-      size = self.unpack_uint32(io)
-      return self.read_hash(io, size)
+      size = self.unpack_uint32
+      return self.read_hash(size)
     else
       raise("Unknown Type -- #{'0x%02X' % type}")
     end
   end
 
-  def self.read_array(io, size)
-    return size.times.map { self.read(io) }
+  def read_array(size)
+    return size.times.map { self.read }
   end
 
-  def self.read_hash(io, size)
+  def read_hash(size)
     return size.times.inject({}) { |memo,|
-      memo[self.read(io)] = self.read(io)
+      memo[self.read] = self.read
       memo
     }
   end
 
-  def self.unpack_uint8(io)
-    return io.read(1).unpack("C")[0]
+  def unpack_uint8
+    return @io.read(1).unpack("C")[0]
   end
 
-  def self.unpack_int8(io)
-    return io.read(1).unpack("c")[0]
+  def unpack_int8
+    return @io.read(1).unpack("c")[0]
   end
 
-  def self.unpack_uint16(io)
-    return io.read(2).unpack("n")[0]
+  def unpack_uint16
+    return @io.read(2).unpack("n")[0]
   end
 
-  def self.unpack_int16(io)
-    num = self.unpack_uint16(io)
+  def unpack_int16
+    num = self.unpack_uint16
     return (num < 2 ** 15 ? num : num - (2 ** 16))
   end
 
-  def self.unpack_uint32(io)
-    return io.read(4).unpack("N")[0]
+  def unpack_uint32
+    return @io.read(4).unpack("N")[0]
   end
 
-  def self.unpack_int32(io)
-    num = self.unpack_uint32(io)
+  def unpack_int32
+    num = self.unpack_uint32
     return (num < 2 ** 31 ? num : num - (2 ** 32))
   end
 
-  def self.unpack_uint64(io)
-    high = self.unpack_uint32(io)
-    low  = self.unpack_uint32(io)
+  def unpack_uint64
+    high = self.unpack_uint32
+    low  = self.unpack_uint32
     return (high << 32) + low
   end
 
-  def self.unpack_int64(io)
-    num = self.unpack_uint64(io)
+  def unpack_int64
+    num = self.unpack_uint64
     return (num < 2 ** 63 ? num : num - (2 ** 64))
   end
 
-  def self.unpack_float(io)
-    return io.read(4).unpack("g")[0]
+  def unpack_float
+    return @io.read(4).unpack("g")[0]
   end
 
-  def self.unpack_double(io)
-    return io.read(8).unpack("G")[0]
+  def unpack_double
+    return @io.read(8).unpack("G")[0]
   end
 end

data/lib/msgpack_pure/version.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
 
 module MessagePackPure
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/nayutaya-msgpack-pure.gemspec

@@ -5,8 +5,8 @@ Gem::Specification.new do |s|
   s.required_ruby_version     = Gem::Requirement.new(">= 1.8.6")
 
   s.name    = "nayutaya-msgpack-pure"
-  s.version = "0.0.1"
-  s.date    = "2010-03-08"
+  s.version = "0.0.2"
+  s.date    = "2010-03-09"
 
   s.authors = ["Yuya Kato"]
   s.email   = "yuyakato@gmail.com"

data/test/packer_test.rb

@@ -7,187 +7,193 @@ require "msgpack_pure/packer"
 
 class PackerTest < Test::Unit::TestCase
   def setup
-    @module = MessagePackPure::Packer
+    @klass = MessagePackPure::Packer
+  end
+
+  def test_initialize
+    io     = StringIO.new
+    packer = @klass.new(io)
+    assert_same(io, packer.io)
   end
 
   def test_write__positive_fixnum
-    assert_equal("\x00", @module.write(sio, 0x00).string)
-    assert_equal("\x01", @module.write(sio, 0x01).string)
-    assert_equal("\x7F", @module.write(sio, 0x7F).string)
+    assert_equal("\x00", @klass.new(sio).write(0x00).string)
+    assert_equal("\x01", @klass.new(sio).write(0x01).string)
+    assert_equal("\x7F", @klass.new(sio).write(0x7F).string)
   end
 
   def test_write__negative_fixnum
-    assert_equal("\xFF", @module.write(sio, -0x01).string)
-    assert_equal("\xE0", @module.write(sio, -0x20).string)
+    assert_equal("\xFF", @klass.new(sio).write(-0x01).string)
+    assert_equal("\xE0", @klass.new(sio).write(-0x20).string)
   end
 
   def test_write__uint8
-    assert_equal("\xCC\x80", @module.write(sio, 0x80).string)
-    assert_equal("\xCC\xFF", @module.write(sio, 0xFF).string)
+    assert_equal("\xCC\x80", @klass.new(sio).write(0x80).string)
+    assert_equal("\xCC\xFF", @klass.new(sio).write(0xFF).string)
   end
 
   def test_write__uint16
-    assert_equal("\xCD\x01\x00", @module.write(sio, 0x0100).string)
-    assert_equal("\xCD\xFF\xFF", @module.write(sio, 0xFFFF).string)
+    assert_equal("\xCD\x01\x00", @klass.new(sio).write(0x0100).string)
+    assert_equal("\xCD\xFF\xFF", @klass.new(sio).write(0xFFFF).string)
   end
 
   def test_write__uint32
-    assert_equal("\xCE\x00\x01\x00\x00", @module.write(sio, 0x00010000).string)
-    assert_equal("\xCE\xFF\xFF\xFF\xFF", @module.write(sio, 0xFFFFFFFF).string)
+    assert_equal("\xCE\x00\x01\x00\x00", @klass.new(sio).write(0x00010000).string)
+    assert_equal("\xCE\xFF\xFF\xFF\xFF", @klass.new(sio).write(0xFFFFFFFF).string)
   end
 
   def test_write__uint64
-    assert_equal("\xCF\x00\x00\x00\x01\x00\x00\x00\x00", @module.write(sio, 0x0000000100000000).string)
-    assert_equal("\xCF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF", @module.write(sio, 0xFFFFFFFFFFFFFFFF).string)
+    assert_equal("\xCF\x00\x00\x00\x01\x00\x00\x00\x00", @klass.new(sio).write(0x0000000100000000).string)
+    assert_equal("\xCF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF", @klass.new(sio).write(0xFFFFFFFFFFFFFFFF).string)
   end
 
   def test_write__int8
-    assert_equal("\xD0\xDF", @module.write(sio, -0x21).string)
-    assert_equal("\xD0\x80", @module.write(sio, -0x80).string)
+    assert_equal("\xD0\xDF", @klass.new(sio).write(-0x21).string)
+    assert_equal("\xD0\x80", @klass.new(sio).write(-0x80).string)
   end
 
   def test_write__int16
-    assert_equal("\xD1\xFF\x7F", @module.write(sio, -0x0081).string)
-    assert_equal("\xD1\x80\x00", @module.write(sio, -0x8000).string)
+    assert_equal("\xD1\xFF\x7F", @klass.new(sio).write(-0x0081).string)
+    assert_equal("\xD1\x80\x00", @klass.new(sio).write(-0x8000).string)
   end
 
   def test_write__int32
-    assert_equal("\xD2\xFF\xFF\x7F\xFF", @module.write(sio, -0x00008001).string)
-    assert_equal("\xD2\x80\x00\x00\x00", @module.write(sio, -0x80000000).string)
+    assert_equal("\xD2\xFF\xFF\x7F\xFF", @klass.new(sio).write(-0x00008001).string)
+    assert_equal("\xD2\x80\x00\x00\x00", @klass.new(sio).write(-0x80000000).string)
   end
 
   def test_write__int64
-    assert_equal("\xD3\xFF\xFF\xFF\xFF\x7F\xFF\xFF\xFF", @module.write(sio, -0x0000000080000001).string)
-    assert_equal("\xD3\x80\x00\x00\x00\x00\x00\x00\x00", @module.write(sio, -0x8000000000000000).string)
+    assert_equal("\xD3\xFF\xFF\xFF\xFF\x7F\xFF\xFF\xFF", @klass.new(sio).write(-0x0000000080000001).string)
+    assert_equal("\xD3\x80\x00\x00\x00\x00\x00\x00\x00", @klass.new(sio).write(-0x8000000000000000).string)
   end
 
   def test_write__nil
-    assert_equal("\xC0", @module.write(sio, nil).string)
+    assert_equal("\xC0", @klass.new(sio).write(nil).string)
   end
 
   def test_write__true
-    assert_equal("\xC3", @module.write(sio, true).string)
+    assert_equal("\xC3", @klass.new(sio).write(true).string)
   end
 
   def test_write__false
-    assert_equal("\xC2", @module.write(sio, false).string)
+    assert_equal("\xC2", @klass.new(sio).write(false).string)
   end
 
   def test_write__float
-    assert_equal("\xCB\x00\x00\x00\x00\x00\x00\x00\x00", @module.write(sio, +0.0).string)
-    assert_equal("\xCB\x3F\xE0\x00\x00\x00\x00\x00\x00", @module.write(sio, +0.5).string)
-    assert_equal("\xCB\xBF\xE0\x00\x00\x00\x00\x00\x00", @module.write(sio, -0.5).string)
+    assert_equal("\xCB\x00\x00\x00\x00\x00\x00\x00\x00", @klass.new(sio).write(+0.0).string)
+    assert_equal("\xCB\x3F\xE0\x00\x00\x00\x00\x00\x00", @klass.new(sio).write(+0.5).string)
+    assert_equal("\xCB\xBF\xE0\x00\x00\x00\x00\x00\x00", @klass.new(sio).write(-0.5).string)
   end
 
   def test_write__fixraw
-    assert_equal("\xA0",    @module.write(sio, "").string)
-    assert_equal("\xA3ABC", @module.write(sio, "ABC").string)
+    assert_equal("\xA0",    @klass.new(sio).write("").string)
+    assert_equal("\xA3ABC", @klass.new(sio).write("ABC").string)
     assert_equal(
       "\xBF" + "A" * 31,
-      @module.write(sio, "A" * 31).string)
+      @klass.new(sio).write("A" * 31).string)
   end
 
   def test_write__raw16
     assert_equal(
       "\xDA\x00\x20" + "A" * 0x0020,
-      @module.write(sio, "A" * 0x0020).string)
+      @klass.new(sio).write("A" * 0x0020).string)
     assert_equal(
       "\xDA\xFF\xFF" + "A" * 0xFFFF,
-      @module.write(sio, "A" * 0xFFFF).string)
+      @klass.new(sio).write("A" * 0xFFFF).string)
   end
 
   def test_write__raw32
     assert_equal(
       "\xDB\x00\x01\x00\x00" + "A" * 0x00010000,
-      @module.write(sio, "A" * 0x00010000).string)
+      @klass.new(sio).write("A" * 0x00010000).string)
   end
 
   def test_write__fixarray
-    assert_equal("\x90",             @module.write(sio, []).string)
-    assert_equal("\x93\x00\x01\x02", @module.write(sio, [0, 1, 2]).string)
+    assert_equal("\x90",             @klass.new(sio).write([]).string)
+    assert_equal("\x93\x00\x01\x02", @klass.new(sio).write([0, 1, 2]).string)
 
-    io = StringIO.new("\x9F", "a+")
+    packer = @klass.new(StringIO.new("\x9F", "a+"))
     array = 0x0F.times.map { |i|
-      @module.write(io, i)
+      packer.write(i)
       i
     }
-    assert_equal(io.string, @module.write(sio, array).string)
+    assert_equal(packer.io.string, @klass.new(sio).write(array).string)
   end
 
   def test_write__array16_min
-    io = StringIO.new("\xDC\x00\x10", "a+")
+    packer = @klass.new(StringIO.new("\xDC\x00\x10", "a+"))
     array = 0x0010.times.map { |i|
-      @module.write(io, i)
+      packer.write(i)
       i
     }
-    assert_equal(io.string, @module.write(sio, array).string)
+    assert_equal(packer.io.string, @klass.new(sio).write(array).string)
   end
 
   def test_write__array16_max
-    io = StringIO.new("\xDC\xFF\xFF", "a+")
+    packer = @klass.new(StringIO.new("\xDC\xFF\xFF", "a+"))
     array = 0xFFFF.times.map { |i|
-      @module.write(io, i)
+      packer.write(i)
       i
     }
-    assert_equal(io.string, @module.write(sio, array).string)
+    assert_equal(packer.io.string, @klass.new(sio).write(array).string)
   end
 
   def test_write__array32_min
-    io = StringIO.new("\xDD\x00\x01\x00\x00", "a+")
+    packer = @klass.new(StringIO.new("\xDD\x00\x01\x00\x00", "a+"))
     array = 0x00010000.times.map { |i|
-      @module.write(io, i)
+      packer.write(i)
       i
     }
-    assert_equal(io.string, @module.write(sio, array).string)
+    assert_equal(packer.io.string, @klass.new(sio).write(array).string)
   end
 
   def test_write__fixmap
-    assert_equal("\x80", @module.write(sio, {}).string)
+    assert_equal("\x80", @klass.new(sio).write({}).string)
     assert_equal(
       "\x82\x00\x01\x02\x03",
-      @module.write(sio, {0 => 1, 2 => 3}).string)
+      @klass.new(sio).write({0 => 1, 2 => 3}).string)
 
-    io = StringIO.new("\x8F", "a+")
+    packer = @klass.new(StringIO.new("\x8F", "a+"))
     hash = 0x0F.times.inject({}) { |memo, i|
-      @module.write(io, i)
-      @module.write(io, 0)
+      packer.write(i)
+      packer.write(0)
       memo[i] = 0
       memo
     }
-    assert_equal(io.string, @module.write(sio, hash).string)
+    assert_equal(packer.io.string, @klass.new(sio).write(hash).string)
   end
 
   def test_write__map16_min
-    io = StringIO.new("\xDE\x00\x10", "a+")
+    packer = @klass.new(StringIO.new("\xDE\x00\x10", "a+"))
     hash = 0x0010.times.inject({}) { |memo, i|
-      @module.write(io, i)
-      @module.write(io, 0)
+      packer.write(i)
+      packer.write(0)
       memo[i] = 0
       memo
     }
-    assert_equal(io.string, @module.write(sio, hash).string)
+    assert_equal(packer.io.string, @klass.new(sio).write(hash).string)
   end
 
   def test_write__map16_max
-    io = StringIO.new("\xDE\xFF\xFF", "a+")
+    packer = @klass.new(StringIO.new("\xDE\xFF\xFF", "a+"))
     hash = 0xFFFF.times.inject({}) { |memo, i|
-      @module.write(io, i)
-      @module.write(io, 0)
+      packer.write(i)
+      packer.write(0)
       memo[i] = 0
       memo
     }
-    assert_equal(io.string, @module.write(sio, hash).string)
+    assert_equal(packer.io.string, @klass.new(sio).write(hash).string)
   end
 
   def test_write__map32_min
-    io = StringIO.new("\xDF\x00\x01\x00\x00", "a+")
+    packer = @klass.new(StringIO.new("\xDF\x00\x01\x00\x00", "a+"))
     hash = 0x00010000.times.inject({}) { |memo, i|
-      @module.write(io, i)
-      @module.write(io, 0)
+      packer.write(i)
+      packer.write(0)
       memo[i] = 0
       memo
     }
-    assert_equal(io.string, @module.write(sio, hash).string)
+    assert_equal(packer.io.string, @klass.new(sio).write(hash).string)
   end
 
   private

data/test/unpacker_test.rb

@@ -7,7 +7,13 @@ require "msgpack_pure/unpacker"
 
 class UnpackerTest < Test::Unit::TestCase
   def setup
-    @module = MessagePackPure::Unpacker
+    @klass = MessagePackPure::Unpacker
+  end
+
+  def test_initialize
+    io       = StringIO.new
+    unpacker = @klass.new(io)
+    assert_same(io, unpacker.io)
   end
 
   def test_read__positive_fixnum
@@ -127,7 +133,7 @@ class UnpackerTest < Test::Unit::TestCase
       i
     }
     io.rewind
-    assert_equal(array, @module.read(io))
+    assert_equal(array, @klass.new(io).read)
   end
 
   def test_read__array16
@@ -140,7 +146,7 @@ class UnpackerTest < Test::Unit::TestCase
       i
     }
     io.rewind
-    assert_equal(array, @module.read(io))
+    assert_equal(array, @klass.new(io).read)
   end
 
   def test_read__array32
@@ -153,7 +159,7 @@ class UnpackerTest < Test::Unit::TestCase
       i
     }
     io.rewind
-    assert_equal(array, @module.read(io))
+    assert_equal(array, @klass.new(io).read)
   end
 
   def test_read__fixmap
@@ -170,7 +176,7 @@ class UnpackerTest < Test::Unit::TestCase
       memo
     }
     io.rewind
-    assert_equal(hash, @module.read(io))
+    assert_equal(hash, @klass.new(io).read)
   end
 
   def test_read__map16
@@ -187,7 +193,7 @@ class UnpackerTest < Test::Unit::TestCase
       memo
     }
     io.rewind
-    assert_equal(hash, @module.read(io))
+    assert_equal(hash, @klass.new(io).read)
   end
 
   def test_read__map32
@@ -204,12 +210,12 @@ class UnpackerTest < Test::Unit::TestCase
       memo
     }
     io.rewind
-    assert_equal(hash, @module.read(io))
+    assert_equal(hash, @klass.new(io).read)
   end
 
   private
 
   def read(binary)
-    return @module.read(StringIO.new(binary, "r"))
+    return @klass.new(StringIO.new(binary, "r")).read
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: nayutaya-msgpack-pure
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Yuya Kato
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-08 00:00:00 +09:00
+date: 2010-03-09 00:00:00 +09:00
 default_executable: 
 dependencies: []