nbtfile 0.0.8 → 0.1.0

data/Rakefile

@@ -41,6 +41,7 @@ require 'rake/rdoctask'
 Rake::RDocTask.new do |rdoc|
   version = File.exist?('VERSION') ? File.read('VERSION') : ""
 
+  rdoc.main = 'README.rdoc'
   rdoc.rdoc_dir = 'rdoc'
   rdoc.title = "nbtfile #{version}"
   rdoc.rdoc_files.include('README*')

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.1.0

data/lib/nbtfile.rb

@@ -23,8 +23,10 @@
 
 require 'zlib'
 require 'stringio'
+require 'yaml'
+require 'enumerator'
 
-class String
+class String #:nodoc: all
   begin
     alias_method :_nbtfile_getbyte, :getbyte
   rescue NameError
@@ -67,28 +69,57 @@ end
 
 module NBTFile
 
+# Raised when an invalid string encoding is encountered
 class EncodingError < RuntimeError
 end
 
+module Private #:nodoc: all
 TOKEN_CLASSES_BY_INDEX = []
 TOKEN_INDICES_BY_CLASS = {}
 
 BaseToken = Struct.new :name, :value
+end
 
+# Classes representing NBT tokens.  Each has a constructor with
+# two arguments, name and value, and corresponding accessors.
 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)
+    token_class = Class.new(Private::BaseToken)
 
     const_set tag_name, token_class
 
-    TOKEN_CLASSES_BY_INDEX[index] = token_class 
-    TOKEN_INDICES_BY_CLASS[token_class] = index
+    Private::TOKEN_CLASSES_BY_INDEX[index] = token_class 
+    Private::TOKEN_INDICES_BY_CLASS[token_class] = index
+  end
+  class TAG_End
+  end
+  class TAG_Byte
+  end
+  class TAG_Short
+  end
+  class TAG_Int
+  end
+  class TAG_Long
+  end
+  class TAG_Float
+  end
+  class TAG_Double
+  end
+  class TAG_String
+  end
+  class TAG_Byte_Array
+  end
+  class TAG_List
+  end
+  class TAG_Compound
   end
 end
 
+
+module Private #:nodoc: all
 module CommonMethods
   def sign_bit(n_bytes)
     1 << ((n_bytes << 3) - 1)
@@ -192,17 +223,17 @@ module ReadMethods
       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)
+      next_state = ListTokenizerState.new(state, list_type, list_length)
       value = list_type
     when type == TAG_Compound
-      next_state = CompoundReaderState.new(state)
+      next_state = CompoundTokenizerState.new(state)
     end
 
     [next_state, type[name, value]]
   end
 end
 
-class TopReaderState
+class TopTokenizerState
   include ReadMethods
   include Tokens
 
@@ -210,13 +241,13 @@ class TopReaderState
     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)
+    end_state = EndTokenizerState.new()
+    next_state = CompoundTokenizerState.new(end_state)
     [next_state, type[name, nil]]
   end
 end
 
-class CompoundReaderState
+class CompoundTokenizerState
   include ReadMethods
   include Tokens
 
@@ -237,7 +268,7 @@ class CompoundReaderState
   end
 end
 
-class ListReaderState
+class ListTokenizerState
   include ReadMethods
   include Tokens
 
@@ -262,16 +293,16 @@ class ListReaderState
   end
 end
 
-class EndReaderState
+class EndTokenizerState
   def get_token(io)
     [self, nil]
   end
 end
 
-class Reader
+class Tokenizer
   def initialize(io)
     @gz = Zlib::GzipReader.new(io)
-    @state = TopReaderState.new()
+    @state = TopTokenizerState.new()
   end
 
   def each_token
@@ -286,7 +317,7 @@ class Reader
   end
 end
 
-module WriteMethods
+module EmitMethods
   include Tokens
   include CommonMethods
 
@@ -372,9 +403,9 @@ module WriteMethods
     when type == TAG_Double
       emit_double(io, value)
     when type == TAG_List
-      next_state = ListWriterState.new(state, value, capturing)
+      next_state = ListEmitterState.new(state, value, capturing)
     when type == TAG_Compound
-      next_state = CompoundWriterState.new(state, capturing)
+      next_state = CompoundEmitterState.new(state, capturing)
     when type == TAG_End
       next_state = cont
     else
@@ -385,8 +416,8 @@ module WriteMethods
   end
 end
 
-class TopWriterState
-  include WriteMethods
+class TopEmitterState
+  include EmitMethods
   include Tokens
 
   def emit_token(io, token)
@@ -394,15 +425,15 @@ class TopWriterState
     when TAG_Compound
       emit_type(io, token.class)
       emit_string(io, token.name)
-      end_state = EndWriterState.new()
-      next_state = CompoundWriterState.new(end_state, nil)
+      end_state = EndEmitterState.new()
+      next_state = CompoundEmitterState.new(end_state, nil)
       next_state
     end
   end
 end
 
-class CompoundWriterState
-  include WriteMethods
+class CompoundEmitterState
+  include EmitMethods
   include Tokens
 
   def initialize(cont, capturing)
@@ -426,8 +457,8 @@ class CompoundWriterState
   end
 end
 
-class ListWriterState
-  include WriteMethods
+class ListEmitterState
+  include EmitMethods
   include Tokens
 
   def initialize(cont, type, capturing)
@@ -462,7 +493,7 @@ class ListWriterState
   end
 end
 
-class EndWriterState
+class EndEmitterState
   def emit_token(io, token)
     raise RuntimeError, "unexpected token #{token.class} after end"
   end
@@ -472,19 +503,26 @@ class EndWriterState
   end
 end
 
-class Writer
+end
+include Private
+
+class Emitter
+  include Private
   include Tokens
 
-  def initialize(stream)
+  def initialize(stream) #:nodoc:
     @gz = Zlib::GzipWriter.new(stream)
-    @state = TopWriterState.new()
+    @state = TopEmitterState.new()
   end
 
+  # Emit a token.  See the Tokens module for a list of token types.
   def emit_token(token)
     @state = @state.emit_token(@gz, token)
   end
 
-  def emit_compound(name)
+  # Emit a TAG_Compound token, call the block, and then emit a matching
+  # TAG_End token.
+  def emit_compound(name) #:yields:
     emit_token(TAG_Compound[name, nil])
     begin
       yield
@@ -493,7 +531,9 @@ class Writer
     end
   end
 
-  def emit_list(name, type)
+  # Emit a TAG_List token, call the block, and then emit a matching TAG_End
+  # token.
+  def emit_list(name, type) #:yields:
     emit_token(TAG_List[name, type])
     begin
       yield
@@ -502,21 +542,24 @@ class Writer
     end
   end
 
+  # Emits a list item, given a value (the token type is assumed based on
+  # the element type of the enclosing list).
   def emit_item(value)
     @state = @state.emit_item(@gz, value)
   end
 
-  def finish
+  def finish #:nodoc:
     @gz.close
   end
 end
 
+# Produce a sequence of NBT tokens from a stream
 def self.tokenize(io)
   case io
   when String
     io = StringIO.new(io, "rb")
   end
-  reader = Reader.new(io)
+  reader = Tokenizer.new(io)
 
   if block_given?
     reader.each_token { |token| yield token }
@@ -527,15 +570,18 @@ def self.tokenize(io)
   end
 end
 
-def self.emit(io)
-  writer = Writer.new(io)
+# Emit a NBT tokens to a stream
+def self.emit(io) #:yields: emitter
+  emitter = Emitter.new(io)
   begin
-    yield writer
+    yield emitter
   ensure
-    writer.finish
+    emitter.finish
   end
 end
 
+# Load an NBT file as a Ruby data structure; returns a pair containing
+# the name of the top-level compound tag and its value
 def self.load(io)
   root = {}
   stack = [root]
@@ -564,4 +610,416 @@ def self.load(io)
   root.first
 end
 
+# Utility helper which transcodes a stream directly to YAML
+def self.transcode_to_yaml(input, output)
+  YAML.dump(load(input), output)
+end
+
+# Reads an NBT stream as a data structure and returns a pair containing the
+# name of the top-level compound tag and its value.
+def self.read(io)
+  root = {}
+  stack = [root]
+
+  self.tokenize(io) do |token|
+    case token
+    when Tokens::TAG_Byte
+      value = Types::Byte.new(token.value)
+    when Tokens::TAG_Short
+      value = Types::Short.new(token.value)
+    when Tokens::TAG_Int
+      value = Types::Int.new(token.value)
+    when Tokens::TAG_Long
+      value = Types::Long.new(token.value)
+    when Tokens::TAG_Float
+      value = Types::Float.new(token.value)
+    when Tokens::TAG_Double
+      value = Types::Double.new(token.value)
+    when Tokens::TAG_String
+      value = Types::String.new(token.value)
+    when Tokens::TAG_Byte_Array
+      value = Types::ByteArray.new(token.value)
+    when Tokens::TAG_List
+      tag = token.value
+      case
+      when tag == Tokens::TAG_Byte
+        type = Types::Byte
+      when tag == Tokens::TAG_Short
+        type = Types::Short
+      when tag == Tokens::TAG_Int
+        type = Types::Int
+      when tag == Tokens::TAG_Long
+        type = Types::Long
+      when tag == Tokens::TAG_Float
+        type = Types::Float
+      when tag == Tokens::TAG_Double
+        type = Types::Double
+      when tag == Tokens::TAG_String
+        type = Types::String
+      when tag == Tokens::TAG_Byte_Array
+        type = Types::ByteArray
+      when tag == Tokens::TAG_List
+        type = Types::List
+      when tag == Tokens::TAG_Compound
+        type = Types::Compound
+      else
+        raise TypeError, "Unexpected list type #{token.value}"
+      end
+      value = Types::List.new(type)
+    when Tokens::TAG_Compound
+      value = Types::Compound.new
+    when Tokens::TAG_End
+      stack.pop
+      next
+    else
+      raise TypeError, "Unexpected token type #{token.class}"
+    end
+
+    current = stack.last
+    case current
+    when Types::List
+      current << value
+    else
+      current[token.name] = value
+    end
+
+    case token
+    when Tokens::TAG_Compound, Tokens::TAG_List
+      stack.push value
+    end
+  end
+
+  root.first
+end
+
+module Private #:nodoc: all
+class Writer
+  def initialize(emitter)
+    @emitter = emitter
+  end
+
+  def type_to_token(type)
+    case
+    when type == Types::Byte
+      token = Tokens::TAG_Byte
+    when type == Types::Short
+      token = Tokens::TAG_Short
+    when type == Types::Int
+      token = Tokens::TAG_Int
+    when type == Types::Long
+      token = Tokens::TAG_Long
+    when type == Types::Float
+      token = Tokens::TAG_Float
+    when type == Types::Double
+      token = Tokens::TAG_Double
+    when type == Types::String
+      token = Tokens::TAG_String
+    when type == Types::ByteArray
+      token = Tokens::TAG_Byte_Array
+    when type == Types::List
+      token = Tokens::TAG_List
+    when type == Types::Compound
+      token = Tokens::TAG_Compound
+    else
+      raise TypeError, "Unexpected list type #{type}"
+    end
+    return token
+  end
+
+  def write_pair(name, value)
+    case value
+    when Types::Byte
+      @emitter.emit_token(Tokens::TAG_Byte[name, value.value])
+    when Types::Short
+      @emitter.emit_token(Tokens::TAG_Short[name, value.value])
+    when Types::Int
+      @emitter.emit_token(Tokens::TAG_Int[name, value.value])
+    when Types::Long
+      @emitter.emit_token(Tokens::TAG_Long[name, value.value])
+    when Types::Float
+      @emitter.emit_token(Tokens::TAG_Float[name, value.value])
+    when Types::Double
+      @emitter.emit_token(Tokens::TAG_Double[name, value.value])
+    when Types::String
+      @emitter.emit_token(Tokens::TAG_String[name, value.value])
+    when Types::ByteArray
+      @emitter.emit_token(Tokens::TAG_Byte_Array[name, value.value])
+    when Types::List
+      token = type_to_token(value.type)
+      @emitter.emit_token(Tokens::TAG_List[name, token])
+      for item in value
+        write_pair(nil, item)
+      end
+      @emitter.emit_token(Tokens::TAG_End[nil, nil])
+    when Types::Compound
+      @emitter.emit_token(Tokens::TAG_Compound[name, nil])
+      for k, v in value
+        write_pair(k, v)
+      end
+      @emitter.emit_token(Tokens::TAG_End[nil, nil])
+    end
+  end
+end
+end
+
+def self.write(io, name, body)
+  emit(io) do |emitter|
+    writer = Writer.new(emitter)
+    writer.write_pair(name, body)
+  end
+end
+
+module Types
+  module Private #:nodoc: all
+  module Base
+  end
+
+  class BaseScalar
+    include Private::Base
+    include Comparable
+
+    attr_reader :value
+
+    def <=>(other)
+      if other.kind_of? BaseScalar
+        @value <=> other.value
+      else
+        @value <=> other
+      end
+    end
+  end
+
+  class BaseInteger < BaseScalar
+    def self.make_subclass(n_bits)
+      subclass = Class.new(self)
+      limit = 1 << (n_bits - 1)
+      subclass.const_set(:RANGE, -limit..(limit-1))
+      subclass
+    end
+
+    def initialize(value)
+      unless self.class::RANGE.include? value
+        raise RangeError, "Value out of range"
+      end
+      int_value = value.to_int
+      if int_value != value
+        raise TypeError, "Not an integer"
+      end
+      @value = value
+    end
+
+    def ==(other)
+      if other.respond_to? :to_int
+        self.to_int == other.to_int
+      else
+        false
+      end
+    end
+
+    def eql?(other)
+      other.class == self.class and other.value == @value
+    end
+
+    def hash
+      [self.class, @value].hash
+    end
+
+    alias_method :to_int, :value
+    alias_method :to_i, :value
+  end
+
+  class BaseFloat < BaseScalar
+    def initialize(value)
+      unless Numeric === value
+        raise TypeError
+      end
+      float_value = value.to_f
+      @value = float_value
+    end
+
+    def ==(other)
+      if Numeric === other or BaseFloat === other
+        @value == other.to_f
+      else
+        false
+      end
+    end
+
+    def eql?(other)
+      other.class == self.class and other.value == @value
+    end
+
+    def hash
+      [self.class, @value].hash
+    end
+
+    alias_method :to_f, :value
+  end
+  end
+  include Private
+
+  Byte = BaseInteger.make_subclass(8)
+  class Byte
+  end
+  Short = BaseInteger.make_subclass(16)
+  class Short
+  end
+  Int = BaseInteger.make_subclass(32)
+  class Int
+  end
+  Long = BaseInteger.make_subclass(64)
+  class Long
+  end
+
+  class Float < BaseFloat
+  end
+
+  class Double < BaseFloat
+  end
+
+  class String < BaseScalar
+    def initialize(value)
+      unless value.respond_to? :to_str
+        raise TypeError, "String or string-like expected"
+      end
+      @value = value.to_str
+    end
+
+    def to_s ; @value.dup ; end
+    alias_method :to_str, :to_s
+  end
+
+  class ByteArray
+    include Private::Base
+
+    attr_reader :value
+
+    def initialize(value)
+      unless value.respond_to? :to_str
+        raise TypeError, "String or string-like expected"
+      end
+      @value = value.to_str
+    end
+
+    def ==(other)
+      self.class == other.class && @value == other.value
+    end
+
+    def to_s ; @value.dup ; end
+    alias_method :to_str, :to_s
+  end
+
+  class List
+    include Private::Base
+    include Enumerable
+
+    attr_reader :type
+
+    def initialize(type, items=[])
+      @type = type
+      @items = []
+      for item in items
+        self << item
+      end
+    end
+
+    def <<(item)
+      unless item.instance_of? @type
+        raise TypeError, "Items should be instances of #{@type}"
+      end
+      @items << item
+      self
+    end
+
+    def each
+      if block_given?
+        @items.each { |item| yield item }
+        self
+      else
+        @items.each
+      end
+    end
+
+    def to_a
+      @items.dup
+    end
+
+    def length
+      @items.length
+    end
+    alias_method :size, :length
+
+    def ==(other)
+      self.class == other.class && @items == other.to_a
+    end
+  end
+
+  class Compound
+    include Private::Base
+    include Enumerable
+
+    def initialize(contents={})
+      @hash = {}
+      @key_order = []
+      for key, value in contents
+        self[key] = value
+      end
+    end
+
+    def has_key?(key)
+      @hash.has_key? key
+    end
+    alias_method :include?, :has_key?
+
+    def []=(key, value)
+      unless key.instance_of? ::String
+        raise TypeError, "Key must be a string"
+      end
+      unless value.kind_of? Private::Base
+        raise TypeError, "#{value.class} is not an NBT type"
+      end
+      @key_order << key unless @hash.has_key? key
+      @hash[key] = value
+      value
+    end
+
+    def [](key)
+      @hash[key]
+    end
+
+    def delete(key)
+      if @hash.has_key? key
+        @key_order.delete key
+        @hash.delete key
+      end
+      self
+    end
+
+    def keys
+      @key_order.dup
+    end
+
+    def values
+      @key_order.map { |k| @hash[k] }
+    end
+
+    def each
+      if block_given?
+        @key_order.each { |k| yield k, @hash[k] }
+        self
+      else
+        Enumerable::Enumerator.new(self, :each)
+      end
+    end
+
+    def to_hash
+      @hash.dup
+    end
+
+    def ==(other)
+      self.class == other.class && @hash == other.to_hash
+    end
+  end
+end
+
 end

data/spec/nbtfile_spec.rb

@@ -6,11 +6,12 @@ require 'zlib'
 
 shared_examples_for "readers and writers" do
   Tokens = NBTFile::Tokens unless defined? Tokens
+  Types = NBTFile::Types unless defined? Types
 
-  def self.a_reader_or_writer(desc, serialized, tokens)
+  def self.a_reader_or_writer(desc, serialized, tokens, tree)
     it desc do
       serialized._nbtfile_force_encoding("BINARY")
-      check_reader_or_writer(serialized, tokens)
+      check_reader_or_writer(serialized, tokens, tree)
     end
   end
 
@@ -18,7 +19,8 @@ shared_examples_for "readers and writers" do
                      "\x0a\x00\x03foo" \
                      "\x00",
                      [Tokens::TAG_Compound["foo", nil],
-                      Tokens::TAG_End["", nil]]
+                      Tokens::TAG_End["", nil]],
+                     ["foo", Types::Compound.new()]
 
   a_reader_or_writer "should treat integers as signed",
                      "\x0a\x00\x03foo" \
@@ -26,7 +28,10 @@ shared_examples_for "readers and writers" do
                      "\x00",
                      [Tokens::TAG_Compound["foo", nil],
                       Tokens::TAG_Int["bar", -2],
-                      Tokens::TAG_End["", nil]]
+                      Tokens::TAG_End["", nil]],
+                     ["foo",
+                      Types::Compound.new({
+                        "bar" => Types::Int.new(-2)})]
 
   a_reader_or_writer "should handle integer fields",
                      "\x0a\x00\x03foo" \
@@ -34,7 +39,10 @@ shared_examples_for "readers and writers" do
                      "\x00",
                      [Tokens::TAG_Compound["foo", nil],
                       Tokens::TAG_Int["bar", 0x01020304],
-                      Tokens::TAG_End["", nil]]
+                      Tokens::TAG_End["", nil]],
+                     ["foo",
+                      Types::Compound.new({
+                        "bar" => Types::Int.new(0x01020304)})]
 
   a_reader_or_writer "should handle short fields",
                      "\x0a\x00\x03foo" \
@@ -42,7 +50,10 @@ shared_examples_for "readers and writers" do
                      "\x00",
                      [Tokens::TAG_Compound["foo", nil],
                       Tokens::TAG_Short["bar", 0x4e5a],
-                      Tokens::TAG_End["", nil]]
+                      Tokens::TAG_End["", nil]],
+                     ["foo",
+                      Types::Compound.new({
+                        "bar" => Types::Short.new(0x4e5a)})]
 
   a_reader_or_writer "should handle byte fields",
                      "\x0a\x00\x03foo" \
@@ -50,7 +61,10 @@ shared_examples_for "readers and writers" do
                      "\x00",
                      [Tokens::TAG_Compound["foo", nil],
                       Tokens::TAG_Byte["bar", 0x4e],
-                      Tokens::TAG_End["", nil]]
+                      Tokens::TAG_End["", nil]],
+                     ["foo",
+                      Types::Compound.new({
+                        "bar" => Types::Byte.new(0x4e)})]
 
   a_reader_or_writer "should handle string fields",
                      "\x0a\x00\x03foo" \
@@ -58,7 +72,10 @@ shared_examples_for "readers and writers" do
                      "\x00",
                      [Tokens::TAG_Compound["foo", nil],
                       Tokens::TAG_String["bar", "hoge"],
-                      Tokens::TAG_End["", nil]]
+                      Tokens::TAG_End["", nil]],
+                     ["foo",
+                      Types::Compound.new({
+                        "bar" => Types::String.new("hoge")})]
 
   a_reader_or_writer "should handle byte array fields",
                      "\x0a\x00\x03foo" \
@@ -66,7 +83,10 @@ shared_examples_for "readers and writers" do
                      "\x00",
                      [Tokens::TAG_Compound["foo", nil],
                       Tokens::TAG_Byte_Array["bar", "\x01\x02\x03\x04\x05"],
-                      Tokens::TAG_End["", nil]]
+                      Tokens::TAG_End["", nil]],
+                     ["foo",
+                      Types::Compound.new({
+                        "bar" => Types::ByteArray.new("\x01\x02\x03\x04\x05")})]
 
   a_reader_or_writer "should handle long fields",
                      "\x0a\x00\x03foo" \
@@ -74,7 +94,10 @@ shared_examples_for "readers and writers" do
                      "\x00",
                      [Tokens::TAG_Compound["foo", nil],
                       Tokens::TAG_Long["bar", 0x0102030405060708],
-                      Tokens::TAG_End["", nil]]
+                      Tokens::TAG_End["", nil]],
+                     ["foo",
+                      Types::Compound.new({
+                        "bar" => Types::Long.new(0x0102030405060708)})]
 
   a_reader_or_writer "should handle float fields",
                      "\x0a\x00\x03foo" \
@@ -82,7 +105,10 @@ shared_examples_for "readers and writers" do
                      "\x00",
                      [Tokens::TAG_Compound["foo", nil],
                       Tokens::TAG_Float["bar", "\x3f\xa0\x00\x00".unpack("g").first],
-                      Tokens::TAG_End["", nil]]
+                      Tokens::TAG_End["", nil]],
+                     ["foo",
+                      Types::Compound.new({
+                        "bar" => Types::Float.new("\x3f\xa0\x00\x00".unpack("g").first)})]
 
   a_reader_or_writer "should handle double fields",
                      "\x0a\x00\x03foo" \
@@ -90,7 +116,10 @@ shared_examples_for "readers and writers" do
                      "\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]]
+                      Tokens::TAG_End["", nil]],
+                     ["foo",
+                      Types::Compound.new({
+                        "bar" => Types::Double.new("\x3f\xf4\x00\x00\x00\x00\x00\x00".unpack("G").first)})]
 
   a_reader_or_writer "should handle nested compound fields",
                      "\x0a\x00\x03foo" \
@@ -102,30 +131,39 @@ shared_examples_for "readers and writers" do
                       Tokens::TAG_Compound["bar", nil],
                       Tokens::TAG_Byte["hoge", 0x4e],
                       Tokens::TAG_End["", nil],
-                      Tokens::TAG_End["", nil]]
+                      Tokens::TAG_End["", nil]],
+                     ["foo",
+                      Types::Compound.new({
+                        "bar" => Types::Compound.new({
+                          "hoge" => Types::Byte.new(0x4e)})})]
 
   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*") }]
+    ["bytes", Types::Byte, Tokens::TAG_Byte, 0x01, lambda { |ns| ns.pack("C*") }],
+    ["shorts", Types::Short, Tokens::TAG_Short, 0x02, lambda { |ns| ns.pack("n*") }],
+    ["ints", Types::Int, Tokens::TAG_Int, 0x03, lambda { |ns| ns.pack("N*") }],
+    ["longs", Types::Long, Tokens::TAG_Long, 0x04, lambda { |ns| ns.map { |n| [n].pack("x4N") }.join("") }],
+    ["floats", Types::Float, Tokens::TAG_Float, 0x05, lambda { |ns| ns.pack("g*") }],
+    ["doubles", Types::Double, Tokens::TAG_Double, 0x06, lambda { |ns| ns.pack("G*") }]
   ]
 
-  for label, type, token, pack in simple_list_types
+  for label, type, token, repr, 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" \
+                       "\x09\x00\x03bar#{[repr].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_List["bar", token],
+                        token[0, values[0]],
+                        token[1, values[1]],
                         Tokens::TAG_End[2, nil],
-                      Tokens::TAG_End["", nil]] 
+                        Tokens::TAG_End["", nil]],
+                       ["foo",
+                        Types::Compound.new({
+                          "bar" =>
+                            Types::List.new(type,
+                                            values.map { |v| type.new(v) })})]
   end
 
   a_reader_or_writer "should handle nested lists",
@@ -140,7 +178,12 @@ shared_examples_for "readers and writers" do
                       Tokens::TAG_Byte[0, 0x4a],
                       Tokens::TAG_End[1, nil],
                       Tokens::TAG_End[1, nil],
-                      Tokens::TAG_End["", nil]]
+                      Tokens::TAG_End["", nil]],
+                     ["foo",
+                      Types::Compound.new({
+                        "bar" => Types::List.new(Types::List, [
+                          Types::List.new(Types::Byte,
+                                          [Types::Byte.new(0x4a)])])})]
 end
 
 describe "NBTFile::tokenize" do
@@ -148,7 +191,7 @@ describe "NBTFile::tokenize" do
 
   it_should_behave_like "readers and writers"
 
-  def check_reader_or_writer(input, tokens)
+  def check_reader_or_writer(input, tokens, tree)
     io = make_zipped_stream(input)
     actual_tokens = []
     NBTFile.tokenize(io) do |token|
@@ -163,7 +206,7 @@ describe "NBTFile::tokenize without a block" do
 
   it_should_behave_like "readers and writers"
 
-  def check_reader_or_writer(input, tokens)
+  def check_reader_or_writer(input, tokens, tree)
     io = make_zipped_stream(input)
     actual_tokens = NBTFile.tokenize(io)
     actual_tokens.should be_a_kind_of(Enumerable)
@@ -176,7 +219,7 @@ describe "NBTFile::emit" do
 
   it_should_behave_like "readers and writers"
 
-  def check_reader_or_writer(output, tokens)
+  def check_reader_or_writer(output, tokens, tree)
     io = StringIO.new()
     NBTFile.emit(io) do |writer|
       for token in tokens
@@ -202,7 +245,8 @@ describe "NBTFile::emit" do
                            "\x00",
                            [Tokens::TAG_Compound["foo", nil],
                             Tokens::TAG_String["bar", "hoge"._nbtfile_encode("UTF-16LE")],
-                            Tokens::TAG_End["", nil]]
+                            Tokens::TAG_End["", nil]],
+                           nil
   end
 
   it "should reject malformed UTF-8 strings" do
@@ -247,6 +291,30 @@ describe "NBTFile::emit" do
   end
 end
 
+describe "NBTFile::read" do
+  include ZlibHelpers
+  it_should_behave_like "readers and writers"
+
+  def check_reader_or_writer(input, tokens, tree)
+    io = make_zipped_stream(input)
+    actual_tree = NBTFile.read(io)
+    actual_tree.should == tree
+  end
+end
+
+describe "NBTFile::write" do
+  include ZlibHelpers
+  it_should_behave_like "readers and writers"
+
+  def check_reader_or_writer(output, tokens, tree)
+    io = StringIO.new()
+    name, body = tree
+    NBTFile.write(io, name, body)
+    actual_output = unzip_string(io.string)
+    actual_output.should == output
+  end
+end
+
 describe "NBTFile::load" do
   include ZlibHelpers
 
@@ -288,3 +356,27 @@ describe "NBTFile::load" do
                 Tokens::TAG_End["", nil]],
                ["foo", {"bar" => [32, 45]}]
 end
+
+describe "NBTFile::transcode_to_yaml" do
+  def self.nbtfile_transcode(description, tokens, result)
+    it description do
+      io = StringIO.new()
+      NBTFile.emit(io) do |writer|
+        for token in tokens
+          writer.emit_token(token)
+        end
+      end
+      out = StringIO.new()
+      NBTFile.transcode_to_yaml(StringIO.new(io.string), out)
+      actual_result = YAML.load(out.string)
+      actual_result.should == result
+    end
+  end
+
+  nbtfile_transcode "should transcode to YAML",
+                    [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}]
+end

data/spec/roundtrip_spec.rb

@@ -9,28 +9,41 @@ describe NBTFile do
 
   sample_pattern = File.join(File.dirname(__FILE__), '..', 'samples', '*.nbt')
 
+  def perform_and_check_roundtrip(file)
+    input = StringIO.new(File.read(file))
+    output = StringIO.new()
+    yield input, output
+    input_bytes = unzip_string(input.string)
+    output_bytes = unzip_string(output.string)
+
+    input_digest = Digest::SHA1.hexdigest(input_bytes)
+    output_digest = Digest::SHA1.hexdigest(output_bytes)
+
+    output_digest.should == input_digest
+  end
+
   def self.check_file(file)
-    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)
+    basename = File.basename(file)
+
+    it "should roundtrip #{basename} at the token level" do
+      perform_and_check_roundtrip(file) do |input, output|
+        tokenizer = NBTFile::Tokenizer.new(input)
+        emitter = NBTFile::Emitter.new(output)
+        begin
+          tokenizer.each_token do |token|
+            emitter.emit_token(token)
+          end
+        ensure
+          emitter.finish
         end
-      ensure
-        writer.finish
       end
+    end
 
-      input_bytes = unzip_string(input.string)
-      output_bytes = unzip_string(output.string)
-
-      input_digest = Digest::SHA1.hexdigest(input_bytes)
-      output_digest = Digest::SHA1.hexdigest(output_bytes)
-
-      output_digest.should == input_digest
+    it "should roundtrip #{basename} at the data model level" do
+      perform_and_check_roundtrip(file) do |input, output|
+        name, body = NBTFile.read(input)
+        NBTFile.write(output, name, body)
+      end
     end
   end
 

data/spec/types_spec.rb

@@ -0,0 +1,197 @@
+shared_examples_for "high-level types" do
+  it "should include NBTFile::Types::Base" do
+    @type.should < NBTFile::Types::Base
+  end
+end
+
+INTEGER_TYPE_CASES = {
+  NBTFile::Types::Byte => 8,
+  NBTFile::Types::Short => 16,
+  NBTFile::Types::Int => 32,
+  NBTFile::Types::Long => 64
+}
+
+INTEGER_TYPE_CASES.each do |type, bits|
+  range = (-2**(bits-1))..(2**(bits-1)-1)
+  describe "#{type}" do
+    it_should_behave_like "high-level types"
+
+    before :all do
+      @type = type
+    end
+
+    it "should reject values larger than #{range.end}" do
+      lambda { type.new(range.end+1) }.should raise_error(RangeError)
+    end
+
+    it "should reject values smaller than #{range.begin}" do
+      lambda { type.new(range.begin - 1) }.should raise_error(RangeError)
+    end
+
+    it "should accept integers" do
+      type.new(1)
+    end
+
+    it "should have a value attribute" do
+      type.new(42).value.should == 42
+    end
+
+    it "should reject non-integers" do
+      lambda { type.new(0.5) }.should raise_error(TypeError)
+    end
+
+    it "should support #to_int" do
+      type.new(3).to_int.should == 3
+    end
+
+    it "should support #to_i" do
+      type.new(3).to_i.should == 3
+    end
+
+    it "should support equality by value" do
+      type.new(3).should == 3
+      type.new(3).should_not == 4
+      type.new(3).should == type.new(3)
+      type.new(3).should_not == type.new(4)
+    end
+  end
+end
+
+shared_examples_for "floating-point high-level types" do
+  it "should accept Numerics" do
+    @type.new(3.3)
+    @type.new(3)
+    @type.new(2**68)
+  end
+
+  it "should not accept non-numerics" do
+    lambda { @type.new("3.3") }.should raise_error(TypeError)
+  end
+
+  it "should have a value attribute" do
+    @type.new(3.3).value.should == 3.3
+  end
+
+  it "should support #to_f" do
+    @type.new(3.3).to_f.should == 3.3
+  end
+
+  it "should support equality by value" do
+    @type.new(3.3).should == 3.3
+    @type.new(3.3).should_not == 4
+    @type.new(3.3).should == @type.new(3.3)
+    @type.new(3.3).should_not == @type.new(4)
+  end
+end
+
+describe NBTFile::Types::Float do
+  it_should_behave_like "high-level types"
+  it_should_behave_like "floating-point high-level types"
+
+  before :all do
+    @type = NBTFile::Types::Float
+  end
+end
+
+describe NBTFile::Types::Double do
+  it_should_behave_like "high-level types"
+  it_should_behave_like "floating-point high-level types"
+
+  before :all do
+    @type = NBTFile::Types::Double
+  end
+end
+
+describe NBTFile::Types::String do
+  it_should_behave_like "high-level types"
+
+  before :all do
+    @type = NBTFile::Types::String
+  end
+
+  it "should have a #value accessor" do
+    NBTFile::Types::String.new("foo").value.should == "foo"
+  end
+
+  it "should support #to_s" do
+    NBTFile::Types::String.new("foo").to_s.should == "foo"
+  end
+end
+
+describe NBTFile::Types::ByteArray do
+  it_should_behave_like "high-level types"
+
+  before :all do
+    @type = NBTFile::Types::ByteArray
+  end
+
+  it "should have a #value accessor" do
+    NBTFile::Types::ByteArray.new("foo").value.should == "foo"
+  end
+end
+
+describe NBTFile::Types::List do
+  it_should_behave_like "high-level types"
+
+  before :all do
+    @type = NBTFile::Types::List
+  end
+
+  before :each do
+    @instance = NBTFile::Types::List.new(NBTFile::Types::Int)
+  end
+
+  it "should accept instances of the given type" do
+    @instance << NBTFile::Types::Int.new(3)
+    @instance.length.should == 1
+  end
+
+  it "should reject instances of other types" do
+    lambda {
+      @instance << NBTFile::Types::Byte.new(3)
+    }.should raise_error(TypeError)
+    lambda {
+      @instance << 3
+    }.should raise_error(TypeError)
+    lambda {
+      @instance << nil
+    }.should raise_error(TypeError)
+    @instance.length.should == 0
+  end
+
+  it "should implement Enumerable" do
+    NBTFile::Types::List.should < Enumerable
+  end
+end
+
+describe NBTFile::Types::Compound do
+  it_should_behave_like "high-level types"
+
+  before :all do
+    @type = NBTFile::Types::Compound
+  end
+
+  before :each do
+    @instance = NBTFile::Types::Compound.new
+  end
+
+  it "should allow setting and retrieving a field" do
+    @instance["foo"] = NBTFile::Types::Int.new(3)
+    @instance["foo"].should == NBTFile::Types::Int.new(3)
+  end
+
+  it "should allow removing a field" do
+    @instance["foo"] = NBTFile::Types::Int.new(3)
+    @instance.delete "foo"
+    @instance.delete "foo"
+    @instance["foo"].should be_nil
+  end
+
+  it "should accept values deriving from NBTFile::Types::Base" do
+    @instance["foo"] = NBTFile::Types::Int.new(3)
+  end
+
+  it "should reject values not deriving from NBTFile::Types::Base" do
+    lambda { @instance["foo"] = 3 }.should raise_error(TypeError)
+  end
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 8
-  version: 0.0.8
+  version: 0.1.0
 platform: ruby
 authors: 
 - MenTaLguY
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-05 00:00:00 -07:00
+date: 2011-02-09 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,7 +42,6 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - .document
-- .gitignore
 - LICENSE
 - README.rdoc
 - Rakefile
@@ -54,13 +53,14 @@ files:
 - spec/nbtfile_spec.rb
 - spec/roundtrip_spec.rb
 - spec/spec_helper.rb
+- spec/types_spec.rb
 has_rdoc: true
 homepage: http://github.com/mental/nbtfile
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -90,3 +90,4 @@ test_files:
 - spec/nbtfile_spec.rb
 - spec/roundtrip_spec.rb
 - spec/spec_helper.rb
+- spec/types_spec.rb

data/.gitignore

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