nayutaya-msgpack-pure 0.0.1

data/README.md

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

data/Rakefile

@@ -0,0 +1,58 @@
+
+require "rake/testtask"
+require "lib/msgpack_pure/version"
+
+NAME = "nayutaya-msgpack-pure"
+
+task :default => :test
+
+Rake::TestTask.new do |test|
+  test.libs << "test"
+  test.test_files = Dir.glob("test/**/*_test.rb")
+  test.verbose    =  true
+end
+
+desc "bump version"
+task :bump do
+  cur_version  = MessagePackPure::VERSION
+  next_version = cur_version.succ
+  puts("#{cur_version} -> #{next_version}")
+
+  filename = File.join(File.dirname(__FILE__), "lib", "msgpack_pure", "version.rb")
+  File.open(filename, "wb") { |file|
+    file.puts(%|# coding: utf-8|)
+    file.puts(%||)
+    file.puts(%|module MessagePackPure|)
+    file.puts(%|  VERSION = "#{next_version}"|)
+    file.puts(%|end|)
+  }
+end
+
+desc "generate gemspec"
+task :gemspec do
+  require "erb"
+
+  src  = File.open("#{NAME}.gemspec.erb", "rb") { |file| file.read }
+  erb  = ERB.new(src, nil, "-")
+
+  version = MessagePackPure::VERSION
+  date    = Time.now.strftime("%Y-%m-%d")
+
+  files      = Dir.glob("**/*").select { |s| File.file?(s) }.reject { |s| /\.gem\z/ =~ s }
+  test_files = Dir.glob("test/**").select { |s| File.file?(s) }
+
+  File.open("#{NAME}.gemspec", "wb") { |file|
+    file.write(erb.result(binding))
+  }
+end
+
+desc "build gem"
+task :build do
+  sh "gem build #{NAME}.gemspec"
+end
+
+desc "push gem"
+task :push do
+  target = "#{NAME}-#{MessagePackPure::VERSION}.gem"
+  sh "gem push #{target}"
+end

data/lib/msgpack_pure/core.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+
+require "stringio"
+require "msgpack_pure/packer"
+require "msgpack_pure/unpacker"
+
+module MessagePackPure
+  def self.pack(value)
+    io = StringIO.new
+    Packer.write(io, value)
+    return io.string
+  end
+
+  def self.unpack(binary)
+    io = StringIO.new(binary, "r")
+    return Unpacker.read(io)
+  end
+end

data/lib/msgpack_pure/packer.rb

@@ -0,0 +1,192 @@
+# coding: utf-8
+
+# MessagePack format specification
+# http://msgpack.sourceforge.jp/spec
+
+module MessagePackPure
+  module Packer
+  end
+end
+
+module MessagePackPure::Packer
+  def self.write(io, 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)
+    else raise("unknown type")
+    end
+    return io
+  end
+
+  def self.write_integer(io, num)
+    case num
+    when (-0x20..0x7F)
+      # positive fixnum, negative fixnum
+      io.write(self.pack_int8(num))
+    when (0x00..0xFF)
+      # uint8
+      io.write("\xCC")
+      io.write(self.pack_uint8(num))
+    when (-0x80..0x7F)
+      # int8
+      io.write("\xD0")
+      io.write(self.pack_int8(num))
+    when (0x0000..0xFFFF)
+      # uint16
+      io.write("\xCD")
+      io.write(self.pack_uint16(num))
+    when (-0x8000..0x7FFF)
+      # int16
+      io.write("\xD1")
+      io.write(self.pack_int16(num))
+    when (0x00000000..0xFFFFFFFF)
+      # uint32
+      io.write("\xCE")
+      io.write(self.pack_uint32(num))
+    when (-0x80000000..0x7FFFFFFF)
+      # int32
+      io.write("\xD2")
+      io.write(self.pack_int32(num))
+    when (0x0000000000000000..0xFFFFFFFFFFFFFFFF)
+      # uint64
+      io.write("\xCF")
+      io.write(self.pack_uint64(num))
+    when (-0x8000000000000000..0x7FFFFFFFFFFFFFFF)
+      # int64
+      io.write("\xD3")
+      io.write(self.pack_int64(num))
+    else
+      raise("invalid integer")
+    end
+  end
+
+  def self.write_nil(io)
+    io.write("\xC0")
+  end
+
+  def self.write_true(io)
+    io.write("\xC3")
+  end
+
+  def self.write_false(io)
+    io.write("\xC2")
+  end
+
+  def self.write_float(io, value)
+    io.write("\xCB")
+    io.write(self.pack_double(value))
+  end
+
+  def self.write_string(io, value)
+    case value.size
+    when (0x00..0x1F)
+      # fixraw
+      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)
+    when (0x00000000..0xFFFFFFFF)
+      # raw32
+      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)
+    case value.size
+    when (0x00..0x0F)
+      # fixarray
+      io.write(self.pack_uint8(0b10010000 + value.size))
+    when (0x0000..0xFFFF)
+      # array16
+      io.write("\xDC")
+      io.write(self.pack_uint16(value.size))
+    when (0x00000000..0xFFFFFFFF)
+      # array32
+      io.write("\xDD")
+      io.write(self.pack_uint32(value.size))
+    else
+      raise("invalid length")
+    end
+
+    value.each { |item|
+      self.write(io, item)
+    }
+  end
+
+  def self.write_hash(io, value)
+    case value.size
+    when (0x00..0x0F)
+      # fixmap
+      io.write(self.pack_uint8(0b10000000 + value.size))
+    when (0x0000..0xFFFF)
+      # map16
+      io.write("\xDE")
+      io.write(self.pack_uint16(value.size))
+    when (0x00000000..0xFFFFFFFF)
+      # map32
+      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)
+    }
+  end
+
+  def self.pack_uint8(value)
+    return [value].pack("C")
+  end
+
+  def self.pack_int8(value)
+    return [value].pack("c")
+  end
+
+  def self.pack_uint16(value)
+    return [value].pack("n")
+  end
+
+  def self.pack_int16(value)
+    value += (2 ** 16) if value < 0
+    return self.pack_uint16(value)
+  end
+
+  def self.pack_uint32(value)
+    return [value].pack("N")
+  end
+
+  def self.pack_int32(value)
+    value += (2 ** 32) if value < 0
+    return self.pack_uint32(value)
+  end
+
+  def self.pack_uint64(value)
+    high = (value >> 32)
+    low  = (value & 0xFFFFFFFF)
+    return self.pack_uint32(high) + self.pack_uint32(low)
+  end
+
+  def self.pack_int64(value)
+    value += (2 ** 64) if value < 0
+    return self.pack_uint64(value)
+  end
+
+  def self.pack_double(value)
+    return [value].pack("G")
+  end
+end

data/lib/msgpack_pure/unpacker.rb

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

data/lib/msgpack_pure/version.rb

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

data/lib/msgpack_pure.rb

@@ -0,0 +1,4 @@
+# coding: utf-8
+
+require "msgpack_pure/version"
+require "msgpack_pure/core"

data/nayutaya-msgpack-pure.gemspec

@@ -0,0 +1,44 @@
+
+Gem::Specification.new do |s|
+  s.specification_version     = 2
+  s.required_rubygems_version = Gem::Requirement.new(">= 0")
+  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.authors = ["Yuya Kato"]
+  s.email   = "yuyakato@gmail.com"
+
+  s.summary     = "MessagePack"
+  s.description = "pure ruby implementation of MessagePack"
+  s.homepage    = "http://github.com/nayutaya/msgpack-pure/"
+
+  s.rubyforge_project = nil
+  s.has_rdoc          = false
+  s.require_paths     = ["lib"]
+
+  s.files = [
+    "lib/msgpack_pure/core.rb",
+    "lib/msgpack_pure/packer.rb",
+    "lib/msgpack_pure/unpacker.rb",
+    "lib/msgpack_pure/version.rb",
+    "lib/msgpack_pure.rb",
+    "nayutaya-msgpack-pure.gemspec",
+    "nayutaya-msgpack-pure.gemspec.erb",
+    "Rakefile",
+    "README.md",
+    "test/core_test.rb",
+    "test/packer_test.rb",
+    "test/test_helper.rb",
+    "test/unpacker_test.rb",
+  ]
+  s.test_files = [
+    "test/core_test.rb",
+    "test/packer_test.rb",
+    "test/test_helper.rb",
+    "test/unpacker_test.rb",
+  ]
+  s.extra_rdoc_files = []
+end

data/nayutaya-msgpack-pure.gemspec.erb

@@ -0,0 +1,33 @@
+
+Gem::Specification.new do |s|
+  s.specification_version     = 2
+  s.required_rubygems_version = Gem::Requirement.new(">= 0")
+  s.required_ruby_version     = Gem::Requirement.new(">= 1.8.6")
+
+  s.name    = <%= NAME.dump %>
+  s.version = <%= version.dump %>
+  s.date    = <%= date.dump %>
+
+  s.authors = ["Yuya Kato"]
+  s.email   = "yuyakato@gmail.com"
+
+  s.summary     = "MessagePack"
+  s.description = "pure ruby implementation of MessagePack"
+  s.homepage    = "http://github.com/nayutaya/msgpack-pure/"
+
+  s.rubyforge_project = nil
+  s.has_rdoc          = false
+  s.require_paths     = ["lib"]
+
+  s.files = [
+<%- files.each { |path| -%>
+    <%= path.dump %>,
+<%- } -%>
+  ]
+  s.test_files = [
+<%- test_files.each { |path| -%>
+    <%= path.dump %>,
+<%- } -%>
+  ]
+  s.extra_rdoc_files = []
+end

data/test/core_test.rb

@@ -0,0 +1,73 @@
+#! ruby -Ku
+# coding: utf-8
+
+require "test_helper"
+require "msgpack_pure/core"
+require "rubygems"
+require "msgpack"
+
+class CoreTest < Test::Unit::TestCase
+  def setup
+    @module = MessagePackPure
+  end
+
+  def test_pack
+    assert_equal("\x00", @module.pack(0))
+    assert_equal("\xC0", @module.pack(nil))
+  end
+
+  def test_unpack
+    assert_equal(0,   @module.unpack("\x00"))
+    assert_equal(nil, @module.unpack("\xC0"))
+  end
+
+  def test_cross__primitive
+    [
+      0,                   # positive fixnum
+      -1,                  # negative fixnum
+      0xFF,                # uint8
+      0xFFFF,              # uint16
+      0xFFFFFFFF,          # uint32
+      0xFFFFFFFFFFFFFFFF,  # uint64
+      -0x80,               # int8
+      -0x8000,             # int16
+      -0x80000000,         # int32
+      -0x8000000000000000, # int64
+      nil,                 # nil
+      true,                # true
+      false,               # false
+      0.5,                 # double
+      "",                  # fixraw
+      "A" * 0xFFFF,        # raw16
+      "A" * 0x00010000,    # raw32
+      [],                  # fixarray
+      {},                  # fixmap
+    ].each { |value|
+      bin1   = MessagePack.pack(value)
+      bin2   = MessagePackPure.pack(value)
+      value1 = MessagePackPure.unpack(bin1)
+      value2 = MessagePack.unpack(bin2)
+      assert_equal(value, value1)
+      assert_equal(value, value2)
+      assert_equal(bin1, bin2)
+    }
+  end
+
+  def test_cross__collection
+    [
+      (0..      0x0F).to_a, # fixarray
+      (0..    0xFFFF).to_a, # array16
+      (0..0x00010000).to_a, # array32
+      (0..      0x0F).inject({}) { |memo, i| memo[i] = i; memo }, # fixmap
+      (0..    0xFFFF).inject({}) { |memo, i| memo[i] = i; memo }, # map16
+      (0..0x00010000).inject({}) { |memo, i| memo[i] = i; memo }, # map32
+    ].each { |value|
+      bin1   = MessagePack.pack(value)
+      bin2   = MessagePackPure.pack(value)
+      value1 = MessagePackPure.unpack(bin1)
+      value2 = MessagePack.unpack(bin2)
+      assert_equal(value, value1)
+      assert_equal(value, value2)
+    }
+  end
+end

data/test/packer_test.rb

@@ -0,0 +1,198 @@
+#! ruby -Ku
+# coding: utf-8
+
+require "test_helper"
+require "stringio"
+require "msgpack_pure/packer"
+
+class PackerTest < Test::Unit::TestCase
+  def setup
+    @module = MessagePackPure::Packer
+  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)
+  end
+
+  def test_write__negative_fixnum
+    assert_equal("\xFF", @module.write(sio, -0x01).string)
+    assert_equal("\xE0", @module.write(sio, -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)
+  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)
+  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)
+  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)
+  end
+
+  def test_write__int8
+    assert_equal("\xD0\xDF", @module.write(sio, -0x21).string)
+    assert_equal("\xD0\x80", @module.write(sio, -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)
+  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)
+  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)
+  end
+
+  def test_write__nil
+    assert_equal("\xC0", @module.write(sio, nil).string)
+  end
+
+  def test_write__true
+    assert_equal("\xC3", @module.write(sio, true).string)
+  end
+
+  def test_write__false
+    assert_equal("\xC2", @module.write(sio, 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)
+  end
+
+  def test_write__fixraw
+    assert_equal("\xA0",    @module.write(sio, "").string)
+    assert_equal("\xA3ABC", @module.write(sio, "ABC").string)
+    assert_equal(
+      "\xBF" + "A" * 31,
+      @module.write(sio, "A" * 31).string)
+  end
+
+  def test_write__raw16
+    assert_equal(
+      "\xDA\x00\x20" + "A" * 0x0020,
+      @module.write(sio, "A" * 0x0020).string)
+    assert_equal(
+      "\xDA\xFF\xFF" + "A" * 0xFFFF,
+      @module.write(sio, "A" * 0xFFFF).string)
+  end
+
+  def test_write__raw32
+    assert_equal(
+      "\xDB\x00\x01\x00\x00" + "A" * 0x00010000,
+      @module.write(sio, "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)
+
+    io = StringIO.new("\x9F", "a+")
+    array = 0x0F.times.map { |i|
+      @module.write(io, i)
+      i
+    }
+    assert_equal(io.string, @module.write(sio, array).string)
+  end
+
+  def test_write__array16_min
+    io = StringIO.new("\xDC\x00\x10", "a+")
+    array = 0x0010.times.map { |i|
+      @module.write(io, i)
+      i
+    }
+    assert_equal(io.string, @module.write(sio, array).string)
+  end
+
+  def test_write__array16_max
+    io = StringIO.new("\xDC\xFF\xFF", "a+")
+    array = 0xFFFF.times.map { |i|
+      @module.write(io, i)
+      i
+    }
+    assert_equal(io.string, @module.write(sio, array).string)
+  end
+
+  def test_write__array32_min
+    io = StringIO.new("\xDD\x00\x01\x00\x00", "a+")
+    array = 0x00010000.times.map { |i|
+      @module.write(io, i)
+      i
+    }
+    assert_equal(io.string, @module.write(sio, array).string)
+  end
+
+  def test_write__fixmap
+    assert_equal("\x80", @module.write(sio, {}).string)
+    assert_equal(
+      "\x82\x00\x01\x02\x03",
+      @module.write(sio, {0 => 1, 2 => 3}).string)
+
+    io = StringIO.new("\x8F", "a+")
+    hash = 0x0F.times.inject({}) { |memo, i|
+      @module.write(io, i)
+      @module.write(io, 0)
+      memo[i] = 0
+      memo
+    }
+    assert_equal(io.string, @module.write(sio, hash).string)
+  end
+
+  def test_write__map16_min
+    io = StringIO.new("\xDE\x00\x10", "a+")
+    hash = 0x0010.times.inject({}) { |memo, i|
+      @module.write(io, i)
+      @module.write(io, 0)
+      memo[i] = 0
+      memo
+    }
+    assert_equal(io.string, @module.write(sio, hash).string)
+  end
+
+  def test_write__map16_max
+    io = StringIO.new("\xDE\xFF\xFF", "a+")
+    hash = 0xFFFF.times.inject({}) { |memo, i|
+      @module.write(io, i)
+      @module.write(io, 0)
+      memo[i] = 0
+      memo
+    }
+    assert_equal(io.string, @module.write(sio, hash).string)
+  end
+
+  def test_write__map32_min
+    io = StringIO.new("\xDF\x00\x01\x00\x00", "a+")
+    hash = 0x00010000.times.inject({}) { |memo, i|
+      @module.write(io, i)
+      @module.write(io, 0)
+      memo[i] = 0
+      memo
+    }
+    assert_equal(io.string, @module.write(sio, hash).string)
+  end
+
+  private
+
+  def sio
+    return StringIO.new
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require "test/unit"
+
+begin
+  require "rubygems"
+  require "redgreen"
+  require "win32console" if /win32/ =~ RUBY_PLATFORM
+rescue LoadError
+  # nop
+end

data/test/unpacker_test.rb

@@ -0,0 +1,215 @@
+#! ruby -Ku
+# coding: utf-8
+
+require "test_helper"
+require "stringio"
+require "msgpack_pure/unpacker"
+
+class UnpackerTest < Test::Unit::TestCase
+  def setup
+    @module = MessagePackPure::Unpacker
+  end
+
+  def test_read__positive_fixnum
+    assert_equal(+0x00, read("\x00"))
+    assert_equal(+0x7F, read("\x7F"))
+  end
+
+  def test_read__negative_fixnum
+    assert_equal(-0x01, read("\xFF"))
+    assert_equal(-0x20, read("\xE0"))
+  end
+
+  def test_read__uint8
+    assert_equal(+0x00, read("\xCC\x00"))
+    assert_equal(+0xFF, read("\xCC\xFF"))
+  end
+
+  def test_read__uint16
+    assert_equal(+0x0000, read("\xCD\x00\x00"))
+    assert_equal(+0x0001, read("\xCD\x00\x01"))
+    assert_equal(+0xFFFF, read("\xCD\xFF\xFF"))
+  end
+
+  def test_read__uint32
+    assert_equal(+0x00000000, read("\xCE\x00\x00\x00\x00"))
+    assert_equal(+0x00000001, read("\xCE\x00\x00\x00\x01"))
+    assert_equal(+0xFFFFFFFF, read("\xCE\xFF\xFF\xFF\xFF"))
+  end
+
+  def test_read__uint64
+    assert_equal(+0x0000000000000000, read("\xCF\x00\x00\x00\x00\x00\x00\x00\x00"))
+    assert_equal(+0x0000000000000001, read("\xCF\x00\x00\x00\x00\x00\x00\x00\x01"))
+    assert_equal(+0xFFFFFFFFFFFFFFFF, read("\xCF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"))
+  end
+
+  def test_read__int8
+    assert_equal(+0x00, read("\xD0\x00"))
+    assert_equal(+0x7F, read("\xD0\x7F"))
+    assert_equal(-0x01, read("\xD0\xFF"))
+    assert_equal(-0x80, read("\xD0\x80"))
+  end
+
+  def test_read__int16
+    assert_equal(+0x0000, read("\xD1\x00\x00"))
+    assert_equal(+0x7FFF, read("\xD1\x7F\xFF"))
+    assert_equal(-0x0001, read("\xD1\xFF\xFF"))
+    assert_equal(-0x8000, read("\xD1\x80\x00"))
+  end
+
+  def test_read__int32
+    assert_equal(+0x00000000, read("\xD2\x00\x00\x00\x00"))
+    assert_equal(+0x7FFFFFFF, read("\xD2\x7F\xFF\xFF\xFF"))
+    assert_equal(-0x00000001, read("\xD2\xFF\xFF\xFF\xFF"))
+    assert_equal(-0x80000000, read("\xD2\x80\x00\x00\x00"))
+  end
+
+  def test_read__int64
+    assert_equal(+0x0000000000000000, read("\xD3\x00\x00\x00\x00\x00\x00\x00\x00"))
+    assert_equal(+0x7FFFFFFFFFFFFFFF, read("\xD3\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF"))
+    assert_equal(-0x0000000000000001, read("\xD3\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"))
+    assert_equal(-0x8000000000000000, read("\xD3\x80\x00\x00\x00\x00\x00\x00\x00"))
+  end
+
+  def test_read__nil
+    assert_equal(nil, read("\xC0"))
+  end
+
+  def test_read__true
+    assert_equal(true, read("\xC3"))
+  end
+
+  def test_read__false
+    assert_equal(false, read("\xC2"))
+  end
+
+  def test_read__float
+    assert_equal(+0.0, read("\xCA\x00\x00\x00\x00"))
+    assert_equal(+0.5, read("\xCA\x3F\x00\x00\x00"))
+    assert_equal(-0.5, read("\xCA\xBF\x00\x00\x00"))
+  end
+
+  def test_read__double
+    assert_equal(+0.0, read("\xCB\x00\x00\x00\x00\x00\x00\x00\x00"))
+    assert_equal(+0.5, read("\xCB\x3F\xE0\x00\x00\x00\x00\x00\x00"))
+    assert_equal(-0.5, read("\xCB\xBF\xE0\x00\x00\x00\x00\x00\x00"))
+  end
+
+  def test_read__fixraw
+    assert_equal("",       read("\xA0"))
+    assert_equal("ABC",    read("\xA3ABC"))
+    assert_equal("A" * 31, read("\xBF" + "A" * 31))
+  end
+
+  def test_read__raw16
+    assert_equal("",    read("\xDA\x00\x00"))
+    assert_equal("ABC", read("\xDA\x00\x03ABC"))
+    assert_equal(
+      "A" * 0xFFFF,
+      read("\xDA\xFF\xFF" + "A" * 0xFFFF))
+  end
+
+  def test_read__raw32
+    assert_equal("",    read("\xDB\x00\x00\x00\x00"))
+    assert_equal("ABC", read("\xDB\x00\x00\x00\x03ABC"))
+    assert_equal(
+      "A" * 0x10000,
+      read("\xDB\x00\x01\x00\x00" + "A" * 0x10000))
+  end
+
+  def test_read__fixarray
+    assert_equal([],        read("\x90"))
+    assert_equal([0, 1, 2], read("\x93\x00\x01\x02"))
+
+    io = StringIO.new("\x9F", "a+")
+    array = 15.times.map { |i|
+      io.write("\xCD" + [i].pack("n")) # uint16: i
+      i
+    }
+    io.rewind
+    assert_equal(array, @module.read(io))
+  end
+
+  def test_read__array16
+    assert_equal([],        read("\xDC\x00\x00"))
+    assert_equal([0, 1, 2], read("\xDC\x00\x03\x00\x01\x02"))
+
+    io = StringIO.new("\xDC\xFF\xFF", "a+")
+    array = 0xFFFF.times.map { |i|
+      io.write("\xCD" + [i].pack("n")) # uint16: i
+      i
+    }
+    io.rewind
+    assert_equal(array, @module.read(io))
+  end
+
+  def test_read__array32
+    assert_equal([],        read("\xDD\x00\x00\x00\x00"))
+    assert_equal([0, 1, 2], read("\xDD\x00\x00\x00\x03\x00\x01\x02"))
+
+    io = StringIO.new("\xDD\x00\x01\x00\x00", "a+")
+    array = 0x10000.times.map { |i|
+      io.write("\xCD" + [i].pack("n")) # uint16: i
+      i
+    }
+    io.rewind
+    assert_equal(array, @module.read(io))
+  end
+
+  def test_read__fixmap
+    assert_equal({}, read("\x80"))
+    assert_equal(
+      {0 => 1, 2 => 3},
+      read("\x82\x00\x01\x02\x03"))
+
+    io = StringIO.new("\x8F", "a+")
+    hash = 15.times.inject({}) { |memo, i|
+      io.write("\xCD" + [i].pack("n")) # uint16: i
+      io.write("\x00")                 # fixnum: 0
+      memo[i] = 0
+      memo
+    }
+    io.rewind
+    assert_equal(hash, @module.read(io))
+  end
+
+  def test_read__map16
+    assert_equal({}, read("\xDE\x00\x00"))
+    assert_equal(
+      {0 => 1, 2 => 3},
+      read("\xDE\x00\x02\x00\x01\x02\x03"))
+
+    io = StringIO.new("\xDE\xFF\xFF", "a+")
+    hash = 0xFFFF.times.inject({}) { |memo, i|
+      io.write("\xCD" + [i].pack("n")) # uint16: i
+      io.write("\x00")                 # fixnum: 0
+      memo[i] = 0
+      memo
+    }
+    io.rewind
+    assert_equal(hash, @module.read(io))
+  end
+
+  def test_read__map32
+    assert_equal({}, read("\xDF\x00\x00\x00\x00"))
+    assert_equal(
+      {0 => 1, 2 => 3},
+      read("\xDF\x00\x00\x00\x02\x00\x01\x02\x03"))
+
+    io = StringIO.new("\xDF\x00\x01\x00\x00", "a+")
+    hash = 0x10000.times.inject({}) { |memo, i|
+      io.write("\xCD" + [i].pack("n")) # uint16: i
+      io.write("\x00")                 # fixnum: 0
+      memo[i] = 0
+      memo
+    }
+    io.rewind
+    assert_equal(hash, @module.read(io))
+  end
+
+  private
+
+  def read(binary)
+    return @module.read(StringIO.new(binary, "r"))
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: nayutaya-msgpack-pure
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Yuya Kato
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-08 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: pure ruby implementation of MessagePack
+email: yuyakato@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/msgpack_pure/core.rb
+- lib/msgpack_pure/packer.rb
+- lib/msgpack_pure/unpacker.rb
+- lib/msgpack_pure/version.rb
+- lib/msgpack_pure.rb
+- nayutaya-msgpack-pure.gemspec
+- nayutaya-msgpack-pure.gemspec.erb
+- Rakefile
+- README.md
+- test/core_test.rb
+- test/packer_test.rb
+- test/test_helper.rb
+- test/unpacker_test.rb
+has_rdoc: true
+homepage: http://github.com/nayutaya/msgpack-pure/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.6
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: MessagePack
+test_files: 
+- test/core_test.rb
+- test/packer_test.rb
+- test/test_helper.rb
+- test/unpacker_test.rb