nwn-lib 0.4.5 → 0.4.6

data/lib/nwn/settings.rb

@@ -1,7 +1,3 @@
-if ENV['NWN_LIB_INFER_DATA_FILE'] && ENV['NWN_LIB_INFER_DATA_FILE'] != ""
-  NWN::Gff.load_struct_defaults(ENV['NWN_LIB_INFER_DATA_FILE'])
-end
-
 if ENV['NWN_LIB_2DA_LOCATION'] && ENV['NWN_LIB_2DA_LOCATION'] != ""
   NWN::TwoDA::Cache.setup ENV['NWN_LIB_2DA_LOCATION']
 end

data/lib/nwn/tlk.rb

@@ -59,7 +59,7 @@ module NWN
 
         return @cache[id] if @cache[id]
 
-        raise ArgumentError, "No such string ID: #{id.inspect}" if id >= self.highest_id || id < 0
+        raise ArgumentError, "No such string ID: #{id.inspect}" if id > self.highest_id || id < 0
         seek_to = HEADER_SIZE + (id) * DATA_ELEMENT_SIZE
         @io.seek(seek_to)
         data = @io.read(DATA_ELEMENT_SIZE)

data/lib/nwn/twoda.rb

@@ -1,6 +1,8 @@
 require 'shellwords'
 
 class Integer
+  # Returns the level that this amount experience resolves to.
+  # Depends on a set-up TwoDA::Cache, and reads from <tt>exptable</tt>.
   def xp_to_level
     NWN::TwoDA.get('exptable').rows.each {|row|
       level, exp = row.Level.to_i, row.XP.to_i
@@ -9,6 +11,8 @@ class Integer
     return nil
   end
 
+  # Returns the amount of experience that this level resolves to.
+  # Depends on a set-up TwoDA::Cache, and reads from <tt>exptable</tt>.
   def level_to_xp
     NWN::TwoDA.get('exptable').by_col("XP", self - 1).to_i
   end
@@ -97,11 +101,22 @@ module NWN
 
       # Parses a string that represents a valid 2da definition.
       # Replaces any content this table may already have.
+      # This will cope with all misformatting in the same way
+      # that NWN1 itself does. NWN2 employs slightly different
+      # parsing rules, and may or may not be compatible in the
+      # fringe cases.
+      #
+      # Will raise an ArgumentError if the given +bytes+ do
+      # not contain a valid 2DA header, or the file is so badly
+      # misshaped that it will not ever be parsed correctly by NWN1.
+      #
+      # Will complain about everything mismatching it finds
+      # on $stderr if $DEBUG is set (-d).
       def parse bytes
         magic, *data = *bytes.split(/\r?\n/).map {|v| v.strip }
 
-        raise ArgumentError, "Not valid 2da: No valid header found" if
-          magic != "2DA V2.0"
+        raise ArgumentError, "Not valid 2da: No valid header found (got: #{magic[0,20].inspect}..)" if
+          magic !~ /^2DA\s+V2.0$/
 
         # strip all empty lines; they are regarded as comments
         data.reject! {|ln| ln.strip == ""}
@@ -110,10 +125,7 @@ module NWN
 
         header = Shellwords.shellwords(header.strip)
         data.map! {|line|
-          r = Shellwords.shellwords(line.strip)
-          # The last cell can be without double quotes even if it contains whitespace
-          r[header.size..-1] = r[header.size..-1].join(" ") if r.size > header.size
-          r
+          Shellwords.shellwords(line.strip)
         }
 
         new_row_data = []
@@ -121,24 +133,30 @@ module NWN
         id_offset = 0
         idx_offset = 0
         data.each_with_index {|row, idx|
-          id = row.shift.to_i + id_offset
+          id = row.shift
+
+          $stderr.puts "Warning: invalid ID in line #{idx}: #{id.inspect}" if $DEBUG && $id !~ /^\d+$/
 
-          raise ArgumentError, "Invalid ID in row #{idx}" unless id >= 0
+          id = id.to_i + id_offset
 
-          # Its an empty row - this is actually valid; we'll fill it up and dump it later.
+          # Its an empty row - NWN strictly numbers by counted lines - then so do we.
           while id > idx + idx_offset
-            new_row_data << Row.new([""] * header.size)
+            $stderr.puts "Warning: missing ID at #{id - id_offset}, fixing that for you." if $DEBUG
             idx_offset += 1
           end
 
           # NWN automatically increments duplicate IDs - so do we.
-          while id + id_offset < idx
-            $stderr.puts "Warning: duplicate ID found at row #{idx} (id: #{id}); fixing that for you."
+          while id < idx + idx_offset
+            $stderr.puts "Warning: duplicate ID found at row #{idx} (id: #{id}); fixing that for you." if $DEBUG
             id_offset += 1
             id += 1
           end
 
           # NWN fills in missing columns with an empty value - so do we.
+          $stderr.puts "Warning: row #{id} (real: #{id - id_offset}) misses " +
+            "#{header.size - row.size} columns at the end, fixed" if
+              row.size < header.size if $DEBUG
+
           row << "" while row.size < header.size
 
           new_row_data << k_row = Row.new(row)
@@ -146,15 +164,16 @@ module NWN
 
           k_row.map! {|cell|
             cell = case cell
-              when nil; nil
+              when nil; raise "Bug in parser: nil-value for cell"
               when "****"; ""
               else cell
             end
           }
 
-          raise ArgumentError,
-            "Row #{idx} has too many cells for the given header (has #{k_row.size}, want <= #{header.size})" if
-              k_row.size != header.size
+          $stderr.puts "Warning: row #{idx} has too many cells (has #{k_row.size}, want <= #{header.size})" if
+            $DEBUG && k_row.size > header.size
+
+          k_row.pop while k_row.size > header.size
         }
 
         @columns = header
@@ -277,7 +296,7 @@ module NWN
           when "2"
             "\r"
           when nil
-            @newlines
+            @newline
         end)
       end
     end

data/lib/nwn/yaml.rb

@@ -1,8 +1,10 @@
+# This file contains all YAML-specific loading and dumping code.
 require 'yaml'
 
 # See http://www.taguri.org/ for the exact meaning of this.
 NWN::YAML_DOMAIN = "nwn-lib.elv.es,2008-12"
 
+#:stopdoc:
 class Array
   attr_accessor :to_yaml_style
 end
@@ -45,14 +47,10 @@ module NWN::Gff::Struct
           }.size == 0
 
         map.add('__' + 'data_type', @data_type) if @data_type
-        map.add('__' + 'data_version', @data_version) if @data_version && !can_infer_data_version?
-        map.add('__' + 'struct_id', @struct_id) if @struct_id && !can_infer_struct_id?
+        map.add('__' + 'data_version', @data_version) if @data_version && @data_version != DEFAULT_DATA_VERSION
+        map.add('__' + 'struct_id', @struct_id) if @struct_id
 
-        reject {|k, v|
-          # Dont emit fields that would result in their default values anyways.
-          ENV['NWN_LIB_CLEAR_KNOWN_VALUES'] && v.can_infer_type? &&
-            v.can_infer_str_ref? && v.can_infer_value?
-        }.sort.each {|k,v|
+        sort.each {|k,v|
           map.add(k,v)
         }
       end
@@ -63,57 +61,12 @@ end
 module NWN::Gff::Field
 
   def to_yaml(opts = {})
-
-    if !ENV['NWN_LIB_DONT_COMPACT_LIST_STRUCTS'] && field_type == :list && can_compact_as_list?
-      YAML::quick_emit(nil, opts) do |out|
-        out.seq("!", to_yaml_style) do |seq|
-          field_value.each {|item|
-            struct_id_of_item = NWN::Gff.get_struct_defaults_for(item.path, '__struct_id')
-
-            calf = get_compact_as_list_field
-            case calf
-              when Array
-                style = NWN::Gff.get_struct_defaults_for(item.path, '__inline')
-
-                non_inferrable = (item.keys.reject {|x|
-                  item[x].can_infer_type? && item[x].can_infer_value?
-                } - calf).sort
-                raise NWN::Gff::GffError, "cannot compact list struct at #{item.path}, would " +
-                  "LOSE fields: #{non_inferrable.inspect}" if non_inferrable.size > 0
-
-                ar = calf.map {|ik| item[ik] || NWN::Gff.get_struct_default_value(item.path, ik) }
-                missing = ar.map {|x| x.nil? ? calf[ar.index(x)] : nil }.compact
-
-                raise NWN::Gff::GffError, "cannot compact list-struct at #{item.path}, does not " +
-                  "have all compactable field values set or are inferrable (missing fields: #{missing.inspect})." if
-                  missing.size > 0
-
-                ar.to_yaml_style = :inline if style
-
-                ar.unshift(item.struct_id) if struct_id_of_item == 'inline'
-                seq.add(ar)
-              else
-                isv = NWN::Gff.get_struct_defaults_for(self.path, '__inline')
-                seq.style = :inline if isv.nil? || isv === true
-
-                seq.add(item.struct_id) if struct_id_of_item == 'inline'
-                seq.add(item[calf])
-            end
-          }
-        end
-      end
-
-    elsif !ENV['NWN_LIB_DONT_COMPACT_FIELDS'] && can_compact_print?
-      field_value_as_compact.to_yaml(opts)
-
-    else
-      YAML::quick_emit(nil, opts) do |out|
-        out.map(taguri, to_yaml_style) do |map|
-          map.style = :inline unless NWN::Gff::YAMLNonInlineableFields.index(self['type'])
-          map.add('type', self['type']) unless can_infer_type?
-          map.add('str_ref', self['str_ref']) unless can_infer_str_ref?
-          map.add('value', self['value']) unless can_infer_value?
-        end
+    YAML::quick_emit(nil, opts) do |out|
+      out.map(taguri, to_yaml_style) do |map|
+        map.style = :inline unless NWN::Gff::YAMLNonInlineableFields.index(self['type'])
+        map.add('type', self['type'])
+        map.add('str_ref', self['str_ref']) if has_str_ref?
+        map.add('value', self['value'])
       end
     end
   end
@@ -130,159 +83,21 @@ YAML.add_domain_type(NWN::YAML_DOMAIN,'struct') {|t,hash|
   struct.data_version = hash.delete('__data_version')
   struct.data_version ||= NWN::Gff::Struct::DEFAULT_DATA_VERSION
 
-  if struct.struct_id.nil? && s_id = NWN::Gff.get_struct_defaults_for(struct.path, '__struct_id')
-    struct.struct_id = s_id.to_i
-  elsif struct.struct_id.nil?
-    raise NWN::Gff::GffError, "Cannot infer implicit struct_id for struct at #{struct.path}."
-  end
+  raise NWN::Gff::GffError, "no struct_id set for struct at #{struct.path}." if struct.struct_id.nil?
 
   hash.each {|label,element|
     label.freeze
-    element = case element
-      when Hash # already uncompacted or a compacted exolocstr
-        default_type = NWN::Gff.get_struct_default_type(struct.path, label)
-        raise NWN::Gff::GffError,
-          "Cannot parse compacted hash with no contents and no infer data at #{struct.path}/#{label}." if
-            element.size == 0 && default_type == nil
-
-        # It has only got numbers as key, we *assume* its a cexoloc.
-        # Thats okay, because type inferration will catch it later and bite us. Hopefully.
-        if element.keys.select {|x| x.to_s !~ /^(str_ref|\d+)$/}.size == 0
-          element = {
-            'type' => :cexolocstr,
-            'str_ref' => element.delete('str_ref') || NWN::Gff::Field::DEFAULT_STR_REF,
-            'value' => element,
-          }
-        end
-
-        element
-
-      when Array # compacted struct-list
-        element = {
-          'type' => :list,
-          'value' => element,
-        }
-        path = struct.data_type + "/" + label
-        unpack_struct_element = NWN::Gff.get_struct_defaults_for(path, '__compact')
-        if unpack_struct_element
-          # If it doesn't have unpack data, we need to assume its a compacted list itself.
-          # Sorry.
-          # Hope this wont bite anyone later on.
-
-          #raise NWN::Gff::GffError,
-          #  "Cannot unpack compacted struct list at #{path}, no infer data available." unless
-          #    unpack_struct_element
-
-          unpack_struct_element_struct_id = NWN::Gff.get_struct_defaults_for(path, "__struct_id")
-
-          unpack_struct_elements = [unpack_struct_element].flatten.freeze
-
-          unpack_struct_element_types = unpack_struct_elements.map {|unpack_struct_element|
-            raise NWN::Gff::GffError, "While unpacking #{path}: " +
-              "#{unpack_struct_element} is not a field-naime, dummy." unless
-                unpack_struct_element.is_a?(String)
-
-            unpack_struct_element_type =
-              NWN::Gff.get_struct_default_type(path, unpack_struct_element)
-
-            unpack_struct_element_type
-          }.freeze
-
-          last_struct_id = -1
-          element['value'].map! {|kv|
-            st = {}
-            st.extend(NWN::Gff::Struct)
-            st.struct_id = case unpack_struct_element_struct_id
-              when 'iterative'
-                last_struct_id += 1
-              when 'inline'
-                kv.shift
-              when Fixnum
-                unpack_struct_element_struct_id
-              else
-                kv['__struct_id'] || raise(NWN::Gff::GffError,
-                  "dont know how to handle struct_id #{unpack_struct_element_struct_id} at #{label} = #{kv.inspect}")
-            end
-            st.data_type = path
-
-            unpack_struct_elements.each_with_index {|use, index|
-              case kv
-                when Hash
-                  if !kv[use]
-                    uset, usev = unpack_struct_element_types[index],
-                      NWN::Gff.get_struct_default_value(path, use)
-                  else
-                    uset = kv[use]['type']
-                    usev = kv[use]['value']
-                  end
-                when Array
-                  uset = unpack_struct_element_types[index]
-                  usev = kv[index]
-                  if usev.is_a?(Hash)
-                    uset, usev = usev['type'], usev['value']
-                  end
-                when String, Numeric, Symbol
-                  uset = unpack_struct_element_types[index]
-                  usev = kv
-                else
-                  raise "Dont know how to unpack list-struct element: #{kv.inspect}"
-              end
-
-              raise NWN::Gff::GffError, "Cannot infer type of #{path}/#{use} (got: #{uset.inspect})" unless
-                uset && NWN::Gff::Types.index(uset)
-              raise NWN::Gff::GffError, "Cannot get or infer value of #{path}/#{use} (got: #{usev.inspect})" unless
-                usev && (usev.is_a?(String) || usev.is_a?(Numeric) || usev.is_a?(Symbol))
-
-              # Figure out the default value (which we'll need to re-add?) if
-              # it was filtered while outputting.
-              #kv[index] = NWN::Gff.get_struct_default_value(path, use) if !kv[index]
-              #raise NWN::Gff::GffError, "field present in compacted struct-list, and cant " +
-              #  "infer default value at #{use}/#{index} (#{kv.inspect})" if !kv[index]
-
-              el = st[use] = {
-                'label' => use,
-                'type' => uset,
-                'value' => usev
-              }
-              el.extend(NWN::Gff::Field)
-              el.extend_meta_classes
-              el.parent = st
-            }
-            st
-          }
-        end
-        element
-
-      when Numeric, String # compacted scalar
-        {'value' => element}
-
-      else
-        fail "Don't know how to un-compact /#{label}: #{element.inspect}, klass #{element.class.to_s}"
-    end
 
     element.extend(NWN::Gff::Field)
     element.field_label = label
     element.parent = struct
     element.str_ref ||= NWN::Gff::Field::DEFAULT_STR_REF if element.respond_to?('str_ref=')
 
-    infer_field_type = NWN::Gff.get_struct_default_type(struct.path, element.field_label)
-
-    if element.field_type && infer_field_type && infer_field_type != element.field_type
-      raise NWN::Gff::GffError, "/#{label} has field_type #{element.field_type.inspect}, but infer data says #{infer_field_type.inspect}."
-
-    elsif element.field_type.nil? && infer_field_type.nil?
-      raise NWN::Gff::GffError, "Cannot infer implicit type for /#{label} while parsing struct-id #{struct.struct_id}."
-
-    elsif element.field_type.nil? && infer_field_type
-      element.field_type = infer_field_type
-    end
-
-
     element.extend_meta_classes
+    element.validate
 
     struct[label] = element.taint
   }
 
-  NWN::Gff.__yaml_postparse nil, struct if struct.data_type
   struct
 }

data/spec/cexolocstr_spec.rb

@@ -0,0 +1,15 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Gff::Cexolocstr" do
+
+  it "should compact nil and empty strings" do
+    str = Gff::Field.new('Test', :cexolocstr, {})
+    str.v[0] = "hi"
+    str.v[1] = nil
+    str.v[4] = ""
+    str.v[8] = "test"
+    str.v.compact!
+    str.v.should == {0=>"hi", 8=>"test"}
+  end
+
+end

data/spec/erf_spec.rb

@@ -0,0 +1,87 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+WELLFORMED_ERF = ([
+  "HAK", "V1.0",
+  locstr_count = 1, locstr_size = 14,
+  entry_count = 3,
+  offset_to_locstr = 160,
+  offset_to_keys = offset_to_locstr + locstr_size,
+  offset_to_res  = offset_to_locstr + locstr_size + entry_count * 24,
+
+  100, 126, # year, dayofyear
+  0xdeadbeef, "" #description strref, 116 bytes 0-padding
+].pack("a4 a4 VV VV VV VV V  a116") + [
+  0, 6, "abcdef" # one locstr
+].pack("V V a*") + [
+  "resref", 0, 10, 0, # keylist: resref.txt, id = 0
+  "help",   1,  1, 0, # keylist: help.bmp, id = 1
+  "yegods", 2,  4, 0, # keylist: yegods.wav, id = 2
+].pack("a16 V v v" * entry_count) + [
+  offset_to_res + entry_count * 8, 6,  # offset, size
+  offset_to_res + entry_count * 8 + 6, 4,  # offset, size
+  offset_to_res + entry_count * 8 + 6 + 4, 6,  # offset, size
+].pack("II" * entry_count) + [
+  "resref", "help", "yegods"
+].pack("a* a* a*")).freeze
+
+
+
+describe "Erf::Erf" do
+
+  def wellformed_verify binary, expect_locstr = true
+    t = nil
+    t = Erf::Erf.new(StringIO.new binary)
+
+    t.file_type.should == "HAK"
+    t.file_version.should == "V1.0"
+    if expect_locstr
+      t.localized_strings.should == {0 => "abcdef"}
+    else
+      t.localized_strings.should == {}
+    end
+    t.content.size.should == 3
+    t.year.should == 100
+    t.day_of_year.should == 126
+    t.description_str_ref.should == 0xdeadbeef
+
+    t.content[0].filename.should == "resref.txt"
+    t.content[1].filename.should == "help.bmp"
+    t.content[2].filename.should == "yegods.wav"
+    t.content[0].size.should == 6
+    t.content[1].size.should == 4
+    t.content[2].size.should == 6
+    t.content[0].get.should == "resref"
+    t.content[1].get.should == "help"
+    t.content[2].get.should == "yegods"
+  end
+
+  it "reads wellformed ERF containers" do
+    wellformed_verify WELLFORMED_ERF
+  end
+
+  it "reproduces correct ERF binary data" do
+    t = Erf::Erf.new(StringIO.new WELLFORMED_ERF)
+    io = StringIO.new
+    t.write_to(io)
+    io.seek(0)
+    proc {
+      wellformed_verify io.read
+    }.should_not raise_error IOError
+  end
+
+  it "does not read ERF with locstr_size = 0 and locstr_count > 0" do
+    b = WELLFORMED_ERF.dup
+    b[12,4] = [0].pack("V")
+    proc {
+      wellformed_verify b
+    }.should raise_error IOError
+  end
+
+  it "reads ERF with locstr_size > 0 and locstr_count = 0" do
+    b = WELLFORMED_ERF.dup
+    b[8,4] = [0].pack("V")
+    proc {
+      wellformed_verify b, false
+    }.should_not raise_error IOError
+  end
+end