nbtfile 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 MenTaLguY
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,140 @@
+= nbtfile
+
+NBTFile is a low-level library for reading and writing
+NBT-format files, as used by the popular game Minecraft.
+
+== Official Specification
+
+The official (if somewhat confusing) specification for
+the NBT file format may be found at
+http://www.minecraft.net/docs/NBT.txt
+
+== Data Model
+
+The NBT data model has ten different data types:
+
+ - 8-bit signed integers (Tag_Byte)
+ - 16-bit signed integers (Tag_Short)
+ - 32-bit signed integers (Tag_Int)
+ - 64-bit signed integers (Tag_Long)
+ - 32-bit floating-point numbers (Tag_Float)
+ - 64-bit floating-point numbers (Tag_Double)
+ - UTF-8 strings (Tag_String)
+ - raw byte strings (Tag_Byte_Array)
+ - homogenous lists (Tag_List)
+ - compound structures (Tag_Compound)
+
+Compound structures (Tag_Compound) are unordered
+collections where each item ("tag") has a name associated
+with it.  Compound structures are heterogenous; the
+elements of a compound structure may be any mixture of
+types.
+
+Lists (Tag_List) are ordered collections of unnamed items.
+Lists are homogenous; every element of a particular list
+must have the same type.  Note that all lists have the
+same type (Tag_List) regardless of the type of their
+elements.
+
+Items of an eleventh "type" (Tag_End) serve to terminate
+compound structures and lists (of any type).  The wording
+of the official specification could permit lists of
+Tag_End, but this is not supported in practice.
+
+The top level of an NBT file must be a single-element
+compound structure.
+
+== Syntax
+
+NBT files are gzip-compressed; the structure of the
+uncompressed data can be described by the following
+ABNF (see RFC 5234).
+
+ nbt-data = tag-compound
+
+ tag-compound = TAG-COMPOUND name compound-body
+
+ compound-body = *tag TAG-END
+
+ tag = TAG-BYTE name byte /
+       TAG-SHORT name short /
+       TAG-INT name int /
+       TAG-LONG name long /
+       TAG-FLOAT name float /
+       TAG-DOUBLE name double /
+       TAG-STRING name string /
+       TAG-BYTE-ARRAY name byte-array /
+       TAG-LIST name list /
+       tag-compound
+
+ name = string
+
+ list = TAG-BYTE list-length *byte /
+        TAG-SHORT list-length *short /
+        TAG-INT list-length *int /
+        TAG-LONG list-length *long /
+        TAG-FLOAT list-length *float /
+        TAG-DOUBLE list-length *double /
+        TAG-STRING list-length *string /
+        TAG-BYTE-ARRAY list-length *byte-array /
+        TAG-LIST list-length *list /
+        TAG-COMPOUND list-length *compound-body
+
+ list-length = int
+
+ ; see RFC 3629 for definition of UTF8-octets
+ string = string-length UTF8-octets
+
+ string-length = short
+
+ byte-array = byte-array-length *byte
+
+ byte-array-length = int
+
+ byte = OCTET ; 8-bit signed integer
+
+ short = 2OCTET ; 16-bit signed integer, big-endian
+
+ int = 4OCTET ; 32-bit signed integer, big-endian
+
+ long = 8OCTET ; 64-bit signed integer, big-endian
+
+ float = 4OCTET ; 32-bit float, big-endian, IEEE 754-2008
+
+ double = 8OCTET ; 64-bit float, big-endian, IEEE 754-2008
+
+ TAG-END = %x00
+ TAG-BYTE = %x01
+ TAG-SHORT = %x02
+ TAG-INT = %x03
+ TAG-LONG = %x04
+ TAG-FLOAT = %x05
+ TAG-DOUBLE = %x06
+ TAG-BYTE-ARRAY = %x07
+ TAG-STRING = %x08
+ TAG-LIST = %x09
+ TAG-COMPOUND = %x0a
+
+== Interface
+
+== Low-level API
+
+=== NBTFile.tokenize
+
+== High-level API
+
+=== NBTFile.load
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 MenTaLguY. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "nbtfile"
+    gem.summary = %Q{nbtfile provides a low-level API for reading and writing files using Minecraft's NBT serialization format}
+    gem.description = %Q{Library for reading and writing NBT files (as used by Minecraft).}
+    gem.email = "mental@rydia.net"
+    gem.homepage = "http://github.com/mental/nbtfile"
+    gem.authors = ["MenTaLguY"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "nbtfile #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/nbtfile.rb

@@ -0,0 +1,517 @@
+# nbtfile
+#
+# Copyright (c) 2010 MenTaLguY
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'zlib'
+require 'stringio'
+
+class String
+  begin
+    alias_method :_nbtfile_getbyte, :getbyte
+  rescue NameError
+    alias_method :_nbtfile_getbyte, :[]
+  end
+
+  begin
+    alias_method :_nbtfile_force_encoding, :force_encoding
+  rescue NameError
+    def _nbtfile_force_encoding(encoding)
+    end
+  end
+end
+
+module NBTFile
+
+TOKEN_CLASSES_BY_INDEX = []
+TOKEN_INDICES_BY_CLASS = {}
+
+BaseToken = Struct.new :name, :value
+
+module Tokens
+  tag_names = %w(End Byte Short Int Long Float Double
+                 Byte_Array String List Compound)
+  tag_names.each_with_index do |tag_name, index|
+    tag_name = "TAG_#{tag_name}"
+    token_class = Class.new(BaseToken)
+
+    const_set tag_name, token_class
+
+    TOKEN_CLASSES_BY_INDEX[index] = token_class 
+    TOKEN_INDICES_BY_CLASS[token_class] = index
+  end
+end
+
+module CommonMethods
+  def sign_bit(n_bytes)
+    1 << ((n_bytes << 3) - 1)
+  end
+end
+
+module ReadMethods
+  include Tokens
+  include CommonMethods
+
+  def read_raw(io, n_bytes)
+    data = io.read(n_bytes)
+    raise EOFError unless data and data.length == n_bytes
+    data
+  end
+
+  def read_integer(io, n_bytes)
+    raw_value = read_raw(io, n_bytes)
+    value = (0...n_bytes).reduce(0) do |accum, n|
+      (accum << 8) | raw_value._nbtfile_getbyte(n)
+    end
+    value -= ((value & sign_bit(n_bytes)) << 1)
+    value
+  end
+
+  def read_byte(io)
+    read_integer(io, 1)
+  end
+
+  def read_short(io)
+    read_integer(io, 2)
+  end
+
+  def read_int(io)
+    read_integer(io, 4)
+  end
+
+  def read_long(io)
+    read_integer(io, 8)
+  end
+
+  def read_float(io)
+    read_raw(io, 4).unpack("g").first
+  end
+
+  def read_double(io)
+    read_raw(io, 8).unpack("G").first
+  end
+
+  def read_string(io)
+    length = read_short(io)
+    string = read_raw(io, length)
+    string._nbtfile_force_encoding("UTF-8")
+    string
+  end
+
+  def read_byte_array(io)
+    length = read_int(io)
+    read_raw(io, length)
+  end
+
+  def read_list_header(io)
+    list_type = read_type(io)
+    list_length = read_int(io)
+    [list_type, list_length]
+  end
+
+  def read_type(io)
+    byte = read_byte(io)
+    begin
+      TOKEN_CLASSES_BY_INDEX.fetch(byte)
+    rescue IndexError
+      raise RuntimeError, "Unexpected tag ordinal #{byte}"
+    end
+  end
+
+  def read_value(io, type, name, state, cont)
+    next_state = state
+
+    case
+    when type == TAG_End
+      next_state = cont
+      value = nil
+    when type == TAG_Byte
+      value = read_byte(io)
+    when type == TAG_Short
+      value = read_short(io)
+    when type == TAG_Int
+      value = read_int(io)
+    when type == TAG_Long
+      value = read_long(io)
+    when type == TAG_Float
+      value = read_float(io)
+    when type == TAG_Double
+      value = read_double(io)
+    when type == TAG_Byte_Array
+      value = read_byte_array(io)
+    when type == TAG_String
+      value = read_string(io)
+    when type == TAG_List
+      list_type, list_length = read_list_header(io)
+      next_state = ListReaderState.new(state, list_type, list_length)
+      value = list_type
+    when type == TAG_Compound
+      next_state = CompoundReaderState.new(state)
+    end
+
+    [next_state, type[name, value]]
+  end
+end
+
+class TopReaderState
+  include ReadMethods
+  include Tokens
+
+  def get_token(io)
+    type = read_type(io)
+    raise RuntimeError, "expected TAG_Compound" unless type == TAG_Compound
+    name = read_string(io)
+    end_state = EndReaderState.new()
+    next_state = CompoundReaderState.new(end_state)
+    [next_state, type[name, nil]]
+  end
+end
+
+class CompoundReaderState
+  include ReadMethods
+  include Tokens
+
+  def initialize(cont)
+    @cont = cont
+  end
+
+  def get_token(io)
+    type = read_type(io)
+
+    if type != TAG_End
+      name = read_string(io)
+    else
+      name = ""
+    end
+
+    read_value(io, type, name, self, @cont)
+  end
+end
+
+class ListReaderState
+  include ReadMethods
+  include Tokens
+
+  def initialize(cont, type, length)
+    @cont = cont
+    @length = length
+    @offset = 0
+    @type = type
+  end
+
+  def get_token(io)
+    if @offset < @length
+      type = @type
+    else
+      type = TAG_End
+    end
+
+    index = @offset
+    @offset += 1
+
+    read_value(io, type, index, self, @cont)
+  end
+end
+
+class EndReaderState
+  def get_token(io)
+    [self, nil]
+  end
+end
+
+class Reader
+  def initialize(io)
+    @gz = Zlib::GzipReader.new(io)
+    @state = TopReaderState.new()
+  end
+
+  def each_token
+    while token = get_token()
+      yield token
+    end
+  end
+
+  def get_token
+    @state, token = @state.get_token(@gz)
+    token
+  end
+end
+
+module WriteMethods
+  include Tokens
+  include CommonMethods
+
+  def emit_integer(io, n_bytes, value)
+    value -= ((value & sign_bit(n_bytes)) << 1)
+    bytes = (1..n_bytes).map do |n|
+      byte = (value >> ((n_bytes - n) << 3) & 0xff)
+    end
+    io.write(bytes.pack("C*"))
+  end
+
+  def emit_byte(io, value)
+    emit_integer(io, 1, value)
+  end
+
+  def emit_short(io, value)
+    emit_integer(io, 2, value)
+  end
+
+  def emit_int(io, value)
+    emit_integer(io, 4, value)
+  end
+
+  def emit_long(io, value)
+    emit_integer(io, 8, value)
+  end
+
+  def emit_float(io, value)
+    io.write([value].pack("g"))
+  end
+
+  def emit_double(io, value)
+    io.write([value].pack("G"))
+  end
+
+  def emit_byte_array(io, value)
+    emit_int(io, value.length)
+    io.write(value)
+  end
+
+  def emit_string(io, value)
+    emit_short(io, value.length)
+    io.write(value)
+  end
+
+  def emit_type(io, type)
+    emit_byte(io, TOKEN_INDICES_BY_CLASS[type])
+  end
+
+  def emit_list_header(io, type, count)
+    emit_type(io, type)
+    emit_int(io, count)
+  end
+
+  def emit_value(io, type, value, capturing, state, cont)
+    next_state = state
+
+    case
+    when type == TAG_Byte
+      emit_byte(io, value)
+    when type == TAG_Short
+      emit_short(io, value)
+    when type == TAG_Int
+      emit_int(io, value)
+    when type == TAG_Long
+      emit_long(io, value)
+    when type == TAG_Float
+      emit_float(io, value)
+    when type == TAG_Double
+      emit_double(io, value)
+    when type == TAG_Byte_Array
+      emit_byte_array(io, value)
+    when type == TAG_String
+      emit_string(io, value)
+    when type == TAG_Float
+      emit_float(io, value)
+    when type == TAG_Double
+      emit_double(io, value)
+    when type == TAG_List
+      next_state = ListWriterState.new(state, value, capturing)
+    when type == TAG_Compound
+      next_state = CompoundWriterState.new(state, capturing)
+    when type == TAG_End
+      next_state = cont
+    else
+      raise RuntimeError, "Unexpected token #{type}"
+    end
+
+    next_state
+  end
+end
+
+class TopWriterState
+  include WriteMethods
+  include Tokens
+
+  def emit_token(io, token)
+    case token
+    when TAG_Compound
+      emit_type(io, token.class)
+      emit_string(io, token.name)
+      end_state = EndWriterState.new()
+      next_state = CompoundWriterState.new(end_state, nil)
+      next_state
+    end
+  end
+end
+
+class CompoundWriterState
+  include WriteMethods
+  include Tokens
+
+  def initialize(cont, capturing)
+    @cont = cont
+    @capturing = capturing
+  end
+
+  def emit_token(io, token)
+    out = @capturing || io
+
+    type = token.class
+
+    emit_type(out, type)
+    emit_string(out, token.name) unless type == TAG_End
+
+    emit_value(out, type, token.value, @capturing, self, @cont)
+  end
+
+  def emit_item(io, value)
+    raise RuntimeError, "not in a list"
+  end
+end
+
+class ListWriterState
+  include WriteMethods
+  include Tokens
+
+  def initialize(cont, type, capturing)
+    @cont = cont
+    @type = type
+    @count = 0
+    @value = StringIO.new()
+    @capturing = capturing
+  end
+
+  def emit_token(io, token)
+    type = token.class
+
+    if type == TAG_End
+      out = @capturing || io
+      emit_list_header(out, @type, @count)
+      out.write(@value.string)
+    elsif type != @type
+      raise RuntimeError, "unexpected token #{token.class}, expected #{@type}"
+    end
+
+    _emit_item(io, type, token.value)
+  end
+
+  def emit_item(io, value)
+    _emit_item(io, @type, value)
+  end
+
+  def _emit_item(io, type, value)
+    @count += 1
+    emit_value(@value, type, value, @value, self, @cont)
+  end
+end
+
+class EndWriterState
+  def emit_token(io, token)
+    raise RuntimeError, "unexpected token #{token.class} after end"
+  end
+
+  def emit_item(io, value)
+    raise RuntimeError, "not in a list"
+  end
+end
+
+class Writer
+  include WriteMethods
+
+  def initialize(stream)
+    @gz = Zlib::GzipWriter.new(stream)
+    @state = TopWriterState.new()
+  end
+
+  def emit_token(token)
+    @state = @state.emit_token(@gz, token)
+  end
+
+  def emit_compound(name)
+    emit_token(TAG_Compound[name, nil])
+    begin
+      yield
+    ensure
+      emit_token(TAG_End[nil, nil])
+    end
+  end
+
+  def emit_list(name, type)
+    emit_token(TAG_List[name, type])
+    begin
+      yield
+    ensure
+      emit_token(TAG_End[nil, nil])
+    end
+  end
+
+  def emit_item(value)
+    @state = @state.emit_item(@gz, value)
+  end
+
+  def finish
+    @gz.close
+  end
+end
+
+def self.tokenize(io)
+  case io
+  when String
+    io = StringIO.new(io, "rb")
+  end
+  reader = Reader.new(io)
+
+  reader.each_token do |token|
+    yield token
+  end
+end
+
+def self.load(io)
+  root = {}
+  stack = [root]
+
+  self.tokenize(io) do |token|
+    case token
+    when Tokens::TAG_Compound
+      value = {}
+    when Tokens::TAG_List
+      value = []
+    when Tokens::TAG_End
+      stack.pop
+      next
+    else
+      value = token.value
+    end
+
+    stack.last[token.name] = value
+
+    case token
+    when Tokens::TAG_Compound, Tokens::TAG_List
+      stack.push value
+    end
+  end
+
+  root
+end
+
+end

data/spec/nbtfile_spec.rb

@@ -0,0 +1,279 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'enumerator'
+require 'nbtfile'
+require 'stringio'
+require 'zlib'
+
+shared_examples_for "readers and writers" do
+  Tokens = NBTFile::Tokens unless defined? Tokens
+
+  def self.a_reader_or_writer(desc, serialized, tokens)
+    it desc do
+      check_reader_or_writer(serialized, tokens)
+    end
+  end
+
+  a_reader_or_writer "should handle basic documents",
+                     "\x0a\x00\x03foo" \
+                     "\x00",
+                     [Tokens::TAG_Compound["foo", nil],
+                      Tokens::TAG_End["", nil]]
+
+  a_reader_or_writer "should treat integers as signed",
+                     "\x0a\x00\x03foo" \
+                     "\x03\x00\x03bar\xff\xff\xff\xfe" \
+                     "\x00",
+                     [Tokens::TAG_Compound["foo", nil],
+                      Tokens::TAG_Int["bar", -2],
+                      Tokens::TAG_End["", nil]]
+
+  a_reader_or_writer "should handle integer fields",
+                     "\x0a\x00\x03foo" \
+                     "\x03\x00\x03bar\x01\x02\x03\x04" \
+                     "\x00",
+                     [Tokens::TAG_Compound["foo", nil],
+                      Tokens::TAG_Int["bar", 0x01020304],
+                      Tokens::TAG_End["", nil]]
+
+  a_reader_or_writer "should handle short fields",
+                     "\x0a\x00\x03foo" \
+                     "\x02\x00\x03bar\x4e\x5a" \
+                     "\x00",
+                     [Tokens::TAG_Compound["foo", nil],
+                      Tokens::TAG_Short["bar", 0x4e5a],
+                      Tokens::TAG_End["", nil]]
+
+  a_reader_or_writer "should handle byte fields",
+                     "\x0a\x00\x03foo" \
+                     "\x01\x00\x03bar\x4e" \
+                     "\x00",
+                     [Tokens::TAG_Compound["foo", nil],
+                      Tokens::TAG_Byte["bar", 0x4e],
+                      Tokens::TAG_End["", nil]]
+
+  a_reader_or_writer "should handle string fields",
+                     "\x0a\x00\x03foo" \
+                     "\x08\x00\x03bar\x00\x04hoge" \
+                     "\x00",
+                     [Tokens::TAG_Compound["foo", nil],
+                      Tokens::TAG_String["bar", "hoge"],
+                      Tokens::TAG_End["", nil]]
+
+  a_reader_or_writer "should handle byte array fields",
+                     "\x0a\x00\x03foo" \
+                     "\x07\x00\x03bar\x00\x00\x00\x05\x01\x02\x03\x04\x05" \
+                     "\x00",
+                     [Tokens::TAG_Compound["foo", nil],
+                      Tokens::TAG_Byte_Array["bar", "\x01\x02\x03\x04\x05"],
+                      Tokens::TAG_End["", nil]]
+
+  a_reader_or_writer "should handle long fields",
+                     "\x0a\x00\x03foo" \
+                     "\x04\x00\x03bar\x01\x02\x03\x04\x05\x06\x07\x08" \
+                     "\x00",
+                     [Tokens::TAG_Compound["foo", nil],
+                      Tokens::TAG_Long["bar", 0x0102030405060708],
+                      Tokens::TAG_End["", nil]]
+
+  a_reader_or_writer "should handle float fields",
+                     "\x0a\x00\x03foo" \
+                     "\x05\x00\x03bar\x3f\xa0\x00\x00" \
+                     "\x00",
+                     [Tokens::TAG_Compound["foo", nil],
+                      Tokens::TAG_Float["bar", "\x3f\xa0\x00\x00".unpack("g").first],
+                      Tokens::TAG_End["", nil]]
+
+  a_reader_or_writer "should handle double fields",
+                     "\x0a\x00\x03foo" \
+                     "\x06\x00\x03bar\x3f\xf4\x00\x00\x00\x00\x00\x00" \
+                     "\x00",
+                     [Tokens::TAG_Compound["foo", nil],
+                      Tokens::TAG_Double["bar", "\x3f\xf4\x00\x00\x00\x00\x00\x00".unpack("G").first],
+                      Tokens::TAG_End["", nil]]
+
+  a_reader_or_writer "should handle nested compound fields",
+                     "\x0a\x00\x03foo" \
+                     "\x0a\x00\x03bar" \
+                     "\x01\x00\x04hoge\x4e" \
+                     "\x00" \
+                     "\x00",
+                     [Tokens::TAG_Compound["foo", nil],
+                      Tokens::TAG_Compound["bar", nil],
+                      Tokens::TAG_Byte["hoge", 0x4e],
+                      Tokens::TAG_End["", nil],
+                      Tokens::TAG_End["", nil]]
+
+  simple_list_types = [
+    ["bytes", Tokens::TAG_Byte, 0x01, lambda { |ns| ns.pack("C*") }],
+    ["shorts", Tokens::TAG_Short, 0x02, lambda { |ns| ns.pack("n*") }],
+    ["ints", Tokens::TAG_Int, 0x03, lambda { |ns| ns.pack("N*") }],
+    ["longs", Tokens::TAG_Long, 0x04, lambda { |ns| ns.map { |n| [n].pack("x4N") }.join("") }],
+    ["floats", Tokens::TAG_Float, 0x05, lambda { |ns| ns.pack("g*") }],
+    ["doubles", Tokens::TAG_Double, 0x06, lambda { |ns| ns.pack("G*") }]
+  ]
+
+  for label, type, token, pack in simple_list_types
+    values = [9, 5]
+    a_reader_or_writer "should handle lists of #{label}",
+                       "\x0a\x00\x03foo" \
+                       "\x09\x00\x03bar#{[token].pack("C")}\x00\x00\x00\x02" \
+                       "#{pack.call(values)}" \
+                       "\x00",
+                       [Tokens::TAG_Compound["foo", nil],
+                        Tokens::TAG_List["bar", type],
+                        type[0, values[0]],
+                        type[1, values[1]],
+                        Tokens::TAG_End[2, nil],
+                      Tokens::TAG_End["", nil]] 
+  end
+
+  a_reader_or_writer "should handle nested lists",
+                     "\x0a\x00\x03foo" \
+                     "\x09\x00\x03bar\x09\x00\x00\x00\x01" \
+                     "\x01\x00\x00\x00\x01" \
+                     "\x4a" \
+                     "\x00",
+                     [Tokens::TAG_Compound["foo", nil],
+                      Tokens::TAG_List["bar", Tokens::TAG_List],
+                      Tokens::TAG_List[0, Tokens::TAG_Byte],
+                      Tokens::TAG_Byte[0, 0x4a],
+                      Tokens::TAG_End[1, nil],
+                      Tokens::TAG_End[1, nil],
+                      Tokens::TAG_End["", nil]]
+end
+
+describe "NBTFile::tokenize" do
+  include ZlibHelpers
+
+  it_should_behave_like "readers and writers"
+
+  def check_reader_or_writer(input, tokens)
+    io = make_zipped_stream(input)
+    actual_tokens = []
+    NBTFile.tokenize(io) do |token|
+      actual_tokens << token
+    end
+    actual_tokens.should == tokens
+  end
+end
+
+describe "NBTFile::load" do
+  include ZlibHelpers
+
+  def self.nbtfile_load(description, tokens, result)
+    it description do
+      io = StringIO.new
+      writer = NBTFile::Writer.new(io)
+      for token in tokens
+        writer.emit_token(token)
+      end
+      writer.finish
+      actual_result = NBTFile.load(StringIO.new(io.string))
+      actual_result.should == result
+    end
+  end
+
+  nbtfile_load "should generate a top-level hash",
+               [Tokens::TAG_Compound["foo", nil],
+                Tokens::TAG_Byte["a", 19],
+                Tokens::TAG_Byte["b", 23],
+                Tokens::TAG_End[nil, nil]],
+               {"foo" => {"a" => 19, "b" => 23}}
+
+  nbtfile_load "should map compound structures to hashes",
+               [Tokens::TAG_Compound["foo", nil],
+                Tokens::TAG_Compound["bar", nil],
+                Tokens::TAG_Byte["a", 123],
+                Tokens::TAG_Byte["b", 56],
+                Tokens::TAG_End[nil, nil],
+                Tokens::TAG_End[nil, nil]],
+               {"foo" => {"bar" => {"a" => 123, "b" => 56}}}
+
+  nbtfile_load "should map lists to arrays",
+               [Tokens::TAG_Compound["foo", nil],
+                Tokens::TAG_List["bar", Tokens::TAG_Byte],
+                Tokens::TAG_Byte[0, 32],
+                Tokens::TAG_Byte[1, 45],
+                Tokens::TAG_End[2, nil],
+                Tokens::TAG_End["", nil]],
+               {"foo" => {"bar" => [32, 45]}}
+end
+
+describe NBTFile::Reader do
+  include ZlibHelpers
+
+  it_should_behave_like "readers and writers"
+
+  def check_reader_or_writer(input, tokens)
+    io = make_zipped_stream(input)
+    reader = NBTFile::Reader.new(io)
+    actual_tokens = []
+    reader.each_token do |token|
+      actual_tokens << token
+    end
+    actual_tokens.should == tokens
+  end
+end
+
+describe NBTFile::Writer do
+  include ZlibHelpers
+
+  it_should_behave_like "readers and writers"
+
+  def check_reader_or_writer(output, tokens)
+    stream = StringIO.new()
+    writer = NBTFile::Writer.new(stream)
+    begin
+      for token in tokens
+        writer.emit_token(token)
+      end
+    ensure
+      writer.finish
+    end
+    actual_output = unzip_string(stream.string)
+    actual_output.should == output
+  end
+
+  it "should support shorthand for emitting lists" do
+    output = StringIO.new()
+    writer = NBTFile::Writer.new(output)
+    begin
+      writer.emit_token(Tokens::TAG_Compound["test", nil])
+      writer.emit_list("foo", Tokens::TAG_Byte) do
+        writer.emit_item(12)
+        writer.emit_item(43)
+      end
+      writer.emit_token(Tokens::TAG_End[nil, nil])
+    ensure
+      writer.finish
+    end
+
+    actual_output = unzip_string(output.string)
+    actual_output.should == "\x0a\x00\x04test" \
+                            "\x09\x00\x03foo\x01\x00\x00\x00\x02" \
+                            "\x0c\x2b" \
+                            "\x00"
+  end
+
+  it "should support shorthand for emitting compound structures" do
+    output = StringIO.new()
+    writer = NBTFile::Writer.new(output)
+    begin
+      writer.emit_token(Tokens::TAG_Compound["test", nil])
+      writer.emit_compound("xyz") do
+        writer.emit_token(Tokens::TAG_Byte["foo", 0x08])
+        writer.emit_token(Tokens::TAG_Byte["bar", 0x02])
+      end
+      writer.emit_token(Tokens::TAG_End[nil, nil])
+    ensure
+      writer.finish
+    end
+    actual_output = unzip_string(output.string)
+    actual_output.should == "\x0a\x00\x04test" \
+                            "\x0a\x00\x03xyz" \
+                            "\x01\x00\x03foo\x08" \
+                            "\x01\x00\x03bar\x02" \
+                            "\x00" \
+                            "\x00"
+  end
+end

data/spec/roundtrip_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'nbtfile'
+require 'stringio'
+require 'zlib'
+
+
+describe NBTFile do
+  include ZlibHelpers
+
+  sample_pattern = File.join(File.dirname(__FILE__), '..', 'samples', '*.nbt')
+
+  for file in Dir.glob(sample_pattern)
+    it "should roundtrip #{File.basename(file)}" do
+      input = StringIO.new(File.read(file))
+      output = StringIO.new()
+
+      reader = NBTFile::Reader.new(input)
+      writer = NBTFile::Writer.new(output)
+      begin
+        reader.each_token do |token|
+          writer.emit_token(token)
+        end
+      ensure
+        writer.finish
+      end
+
+      input_bytes = unzip_string(input.string)
+      output_bytes = unzip_string(output.string)
+
+      output_bytes.should == input_bytes
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'nbtfile'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end
+
+module ZlibHelpers
+
+  def make_zipped_stream(data)
+    gz = Zlib::GzipWriter.new(StringIO.new())
+    gz << data
+    string = gz.close.string
+    StringIO.new(string, "rb")
+  end
+
+  def unzip_string(string)
+    gz = Zlib::GzipReader.new(StringIO.new(string))
+    begin
+      gz.read
+    ensure
+      gz.close
+    end
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: nbtfile
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- MenTaLguY
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-27 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.9
+    version: 
+description: Library for reading and writing NBT files (as used by Minecraft).
+email: mental@rydia.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/nbtfile.rb
+- samples/bigtest.nbt
+- samples/chunk0.nbt
+- samples/test.nbt
+- spec/nbtfile_spec.rb
+- spec/roundtrip_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/mental/nbtfile
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  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: 3
+summary: nbtfile provides a low-level API for reading and writing files using Minecraft's NBT serialization format
+test_files: 
+- spec/nbtfile_spec.rb
+- spec/roundtrip_spec.rb
+- spec/spec_helper.rb