nwn-lib 0.4.6 → 0.4.7

data/lib/nwn/res.rb

@@ -11,13 +11,15 @@ module NWN
 
       # Create a new index to +filename+, optionally specifying +io+.
       def self.new_from filename, io = nil
+        FileTest.exists?(filename) or raise Errno::ENOENT unless io
+
         filename = File.expand_path(filename)
         base = File.basename(filename).split(".")[0..-2].join(".").downcase
-        ext = File.extname(filename)[1..-1].downcase
+        ext = File.extname(filename)[1..-1].downcase rescue ""
         res_type = NWN::Resources::Extensions[ext] or raise ArgumentError,
           "Not a valid extension: #{ext.inspect} (while packing #{filename})"
 
-        ContentObject.new(base, res_type, io || filename, 0, io.size || File.stat(filename).size)
+        ContentObject.new(base, res_type, io || filename, 0, io ? io.size : File.stat(filename).size)
       end
 
       def initialize resref, res_type, io = nil, offset = nil, size = nil
@@ -39,7 +41,7 @@ module NWN
       # and do it yourself, observing ContentObject#offset and ContentObject#size.
       def get
         if @io.respond_to?(:read)
-          @io.seek(@offset) if @offset
+          @io.seek(@offset ? @offset : 0)
           d = @io.read(self.size)
           raise IOError,
             "not enough data available while reading #{self.filename}" if
@@ -52,7 +54,7 @@ module NWN
 
       # Get the canonical filename of this object.
       def filename
-        @resref + "." + self.extension
+        @resref + "." + (self.extension || "unknown-#{@res_type}")
       end
 
       # Get the extension of this object.

data/lib/nwn/scripting.rb

@@ -33,7 +33,7 @@ module NWN::Gff::Scripting
     fn, hash = $satisfy_loaded[object.object_id]
     if fn
       if hash != object.hash
-        File.open(fn, "w") {|f|
+        File.open(fn, "wb") {|f|
           NWN::Gff.write(f, NWN::Gff.guess_file_format(fn), object)
         }
         log "saved #{object.to_s} -> #{fn}"
@@ -103,7 +103,7 @@ module NWN::Gff::Scripting
       fn = what.shift
       io = case fn
         when String
-          IO.read(fn)
+          File.new(fn, "r")
         when IO
           fn
         else

data/lib/nwn/settings.rb

@@ -1,3 +1,15 @@
+module NWN
+
+  # This writes a debug message to stderr if the environment
+  # variable +NWN_LIB_DEBUG+ is set to non-nil or $DEBUG is
+  # true (ruby -d).
+  def self.log_debug msg
+    return false unless ENV['NWN_LIB_DEBUG'] || $DEBUG
+    $stderr.puts "(nwn-lib debug) %s: %s" % [caller[0].to_s, msg]
+    true
+  end
+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/twoda.rb

@@ -109,9 +109,6 @@ module NWN
       # 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 }
 
@@ -135,27 +132,27 @@ module NWN
         data.each_with_index {|row, idx|
           id = row.shift
 
-          $stderr.puts "Warning: invalid ID in line #{idx}: #{id.inspect}" if $DEBUG && $id !~ /^\d+$/
+          NWN.log_debug "Warning: invalid ID in line #{idx}: #{id.inspect}" if $id !~ /^\d+$/
 
           id = id.to_i + id_offset
 
           # Its an empty row - NWN strictly numbers by counted lines - then so do we.
           while id > idx + idx_offset
-            $stderr.puts "Warning: missing ID at #{id - id_offset}, fixing that for you." if $DEBUG
+            NWN.log_debug "Warning: missing ID at #{id - id_offset}, fixing that for you."
             idx_offset += 1
           end
 
           # NWN automatically increments duplicate IDs - so do we.
           while id < idx + idx_offset
-            $stderr.puts "Warning: duplicate ID found at row #{idx} (id: #{id}); fixing that for you." if $DEBUG
+            NWN.log_debug "Warning: duplicate ID found at row #{idx} (id: #{id}); fixing that for you."
             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 " +
+          NWN.log_debug "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.size < header.size
 
           row << "" while row.size < header.size
 
@@ -170,8 +167,8 @@ module NWN
             end
           }
 
-          $stderr.puts "Warning: row #{idx} has too many cells (has #{k_row.size}, want <= #{header.size})" if
-            $DEBUG && k_row.size > header.size
+          NWN.log_debug "Warning: row #{idx} has too many cells (has #{k_row.size}, want <= #{header.size})" if
+            k_row.size > header.size
 
           k_row.pop while k_row.size > header.size
         }

data/scripts/extract_all_items.rb

@@ -10,7 +10,7 @@ list += o['Equip_ItemList'].field_value if o['Equip_ItemList']
 list += o['ItemList'].field_value if o['ItemList']
 log "#{list.size} items found."
 list.each_with_index {|item, index|
-  File.open(fname = "item_#{index}.uti", "w") {|file|
+  File.open(fname = "item_#{index}.uti", "wb") {|file|
     file.write item.to_gff("UTI")
     log "Written item: #{item['Tag'].field_value} as #{fname}"
   }

data/scripts/reformat_2da

@@ -4,6 +4,6 @@
 ARGV.each {|f|
   log "Working on #{f} .."
   t = TwoDA::Table.parse(IO.read(f))
-  File.open(f, "w") {|n| n.puts t.to_2da }
+  File.open(f, "wb") {|n| n.puts t.to_2da }
   log "done."
 }

data/spec/bin_dsl_spec.rb

@@ -0,0 +1,36 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "nwn-dsl" do
+  it_should_behave_like "bin helper"
+
+  it "runs empty scripts" do
+    t = Tempfile.new(@tmp)
+    t.close
+    run(t.path)
+  end
+
+  it "runs want/need scripts" do
+    t = Tempfile.new(@tmp)
+    t.write("need ARGV.shift, :bic")
+    t.close
+    run_bin(t.path, WELLFORMED_GFF_PATH) do |i,o,e|
+      e = e.read
+      o = o.read
+      e.should == "#{t.path}: satisfied #{WELLFORMED_GFF_PATH} -> <NWN::Gff::Struct BIC/V3.2, 129 fields>\n"
+      o.should == ""
+    end
+  end
+
+  it "logs to stderr" do
+    t = Tempfile.new(@tmp)
+    t.write("log 'hey'")
+    t.close
+    run_bin(t.path, WELLFORMED_GFF_PATH) do |i,o,e|
+      e = e.read
+      o = o.read
+      e.should == "#{t.path}: hey\n"
+      o.should == ""
+    end
+  end
+
+end

data/spec/bin_erf_spec.rb

@@ -0,0 +1,118 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "nwn-erf" do
+  it_should_behave_like "bin helper"
+
+  # Create temporary testcase files.
+  before do
+    @target = File.join(@tmp, "nwn-lib-spec-target.erf")
+
+    @tmp0s = []
+    @tmp1s = []
+    for x in %w{aaa.tga bbbb.erf ccc.bmp 44.txt} do
+      File.open(File.join(@tmp, x), "w") do |fn|
+        fn.write(x)
+      end
+      @tmp0s << File.join(@tmp, x)
+    end
+    for x in %w{bbbbbbbbbbbbbbbbbbbb.bmp} do
+      File.open(File.join(@tmp, x), "w") do |fn|
+        fn.write(x)
+      end
+      @tmp1s << File.join(@tmp, x)
+    end
+    @tmp0s.sort!
+    @tmp1s.sort!
+  end
+
+  after do
+    @tmp0s.each {|f|
+      File.unlink(f.path) rescue nil
+    }
+    @tmp1s.each {|f|
+      File.unlink(f.path) rescue nil
+    }
+    File.unlink(@target) rescue nil
+  end
+
+  it "packs -0" do
+    run("-0", "-c", "-f", @target, *@tmp0s)
+  end
+
+  it "fails to pack -0 with 1.1 filenames" do
+    run_fail("-0", "-c", "-f", @target, *(@tmp0s + @tmp1s))
+  end
+
+  it "packs -1" do
+    run("-1", "-c", "-f", @target, *(@tmp0s + @tmp1s))
+  end
+
+  it "lists -0" do
+    run("-c", "-f", @target, *@tmp0s)
+    run_bin("-l", "-f", @target) do |i,o,e|
+      o = o.read
+      o.split(/\n/).sort.should == @tmp0s.map {|x| File.basename(x) }
+    end
+  end
+
+  it "lists -1" do
+    run("-1", "-c", "-f", @target, *@tmp1s)
+    run_bin("-l", "-f", @target) do |i,o,e|
+      o = o.read
+      o.split(/\n/).sort.should == @tmp1s.map {|x| File.basename(x) }
+    end
+  end
+
+  it "extracts -0" do
+    run("-c", "-f", @target, *@tmp0s)
+    @tmp0s.each {|f| File.unlink(f) }
+    run("-v", "-x", "-f", @target)
+    @tmp0s.each {|f| FileTest.exists?(f).should == true }
+    @tmp0s.each {|f| IO.read(f).should == File.basename(f) }
+  end
+
+  it "extracts -1" do
+    workon = @tmp0s + @tmp1s
+    run("-1", "-c", "-f", @target, *workon)
+    workon.each {|f| File.unlink(f) }
+    run("-v", "-x", "-f", @target)
+    workon.each {|f| FileTest.exists?(f).should == true }
+    workon.each {|f| IO.read(f).should == File.basename(f) }
+  end
+
+  it "creates haks" do
+    run("-H", "-c", "-f", @target, *@tmp0s)
+    IO.read(@target).should =~ /^HAK/
+  end
+
+  it "creates mods" do
+    run("-M", "-c", "-f", @target, *@tmp0s)
+    IO.read(@target).should =~ /^MOD/
+  end
+
+  it "creates erfs (by default)" do
+    run("-E", "-c", "-f", @target, *@tmp0s)
+    IO.read(@target).should =~ /^ERF/
+    run("-c", "-f", @target, *@tmp0s)
+    IO.read(@target).should =~ /^ERF/
+  end
+
+  it "adds files from existing archives" do
+    run("-c", "-f", @target, *(@tmp0s[1 .. -1]))
+    run("-a", "-f", @target, @tmp0s[0])
+    run_bin("-l", "-f", @target) do |i,o,e|
+      o = o.read
+      o.split(/\n/).sort.should == @tmp0s.map {|x| File.basename(x) }
+    end
+  end
+
+  it "removes files from existing archives" do
+    run("-c", "-f", @target, *@tmp0s)
+    run("-r", "-f", @target, File.basename(@tmp0s[0]))
+    run_bin("-l", "-f", @target) do |i,o,e|
+      o = o.read
+      o.split(/\n/).sort.should == @tmp0s[1 .. -1].map {|x| File.basename(x) }
+    end
+  end
+
+end

data/spec/bin_gff_spec.rb

@@ -0,0 +1,90 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "nwn-gff" do
+  it_should_behave_like "bin helper"
+
+  NWN::Gff::FileFormats.each do |in_format|
+    inf = in_format.to_s
+
+    NWN::Gff::FileFormats.each do |out_format|
+      otf = out_format.to_s
+
+      it "converts #{inf} to #{otf}" do
+        # prepare the temp file
+        t = Tempfile.new(@tmp)
+        t.close
+
+        run("-lg", "-i", WELLFORMED_GFF_PATH, "-k", inf, "-o", t.path)
+        run("-l", inf, "-i", t.path, "-k", otf)
+        t.unlink
+      end
+    end
+  end
+
+  it "supports none GNU-style backup" do
+    t = Tempfile.new(@tmp)
+    t.close
+    run("-b", "none", "-lg", "-i", WELLFORMED_GFF_PATH, "-kg", "-o", t.path)
+    FileTest.exists?(t.path).should == true
+    FileTest.exists?(t.path + "~").should == false
+  end
+
+  it "supports numbered GNU-style backup" do
+    t = Tempfile.new(@tmp)
+    t.close
+
+    run("-b", "numbered", "-lg", "-i", WELLFORMED_GFF_PATH, "-kg", "-o", t.path)
+    FileTest.exists?(t.path).should == true
+    FileTest.exists?(t.path + "~0").should == true
+    FileTest.exists?(t.path + "~1").should == false
+
+    run("-b", "numbered", "-lg", "-i", WELLFORMED_GFF_PATH, "-kg", "-o", t.path)
+    FileTest.exists?(t.path).should == true
+    FileTest.exists?(t.path + "~0").should == true
+    FileTest.exists?(t.path + "~1").should == true
+    FileTest.exists?(t.path + "~2").should == false
+
+    File.unlink(t.path + "~0")
+    File.unlink(t.path + "~1")
+  end
+
+  it "supports existing with no numbered backups GNU-style backup" do
+    t = Tempfile.new(@tmp)
+    t.close
+
+    FileTest.exists?(t.path + "~").should == false
+
+    run("-b", "existing", "-lg", "-i", WELLFORMED_GFF_PATH, "-kg", "-o", t.path)
+    FileTest.exists?(t.path).should == true
+    FileTest.exists?(t.path + "~").should == true
+
+    File.unlink(t.path + "~")
+
+    FileUtils.cp(t.path, t.path + "~0")
+    run("-b", "existing", "-lg", "-i", WELLFORMED_GFF_PATH, "-kg", "-o", t.path)
+    FileTest.exists?(t.path).should == true
+    FileTest.exists?(t.path + "~").should == false
+    FileTest.exists?(t.path + "~0").should == true
+    FileTest.exists?(t.path + "~1").should == true
+    FileTest.exists?(t.path + "~2").should == false
+
+    File.unlink( t.path + "~0")
+    File.unlink( t.path + "~1")
+  end
+
+
+  it "supports simple GNU-style backup" do
+    t = Tempfile.new(@tmp)
+    t.close
+
+    FileTest.exists?(t.path + "~").should == false
+
+    run("-b", "simple", "-lg", "-i", WELLFORMED_GFF_PATH, "-kg", "-o", t.path)
+    FileTest.exists?(t.path).should == true
+    FileTest.exists?(t.path + "~").should == true
+
+    File.unlink(t.path + "~")
+  end
+
+
+end

data/spec/erf_spec.rb

@@ -1,39 +1,10 @@
 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
-
+describe "Erf::Erf", :shared => true 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
@@ -56,32 +27,78 @@ describe "Erf::Erf" do
   end
 
   it "reads wellformed ERF containers" do
-    wellformed_verify WELLFORMED_ERF
+    wellformed_verify @erf
   end
 
   it "reproduces correct ERF binary data" do
-    t = Erf::Erf.new(StringIO.new WELLFORMED_ERF)
+    t = Erf::Erf.new(StringIO.new @erf)
     io = StringIO.new
     t.write_to(io)
     io.seek(0)
-    proc {
-      wellformed_verify io.read
-    }.should_not raise_error IOError
+    n = io.read
+    wellformed_verify n
+    n.should == @erf
   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
+  it "reads ERF with locstr_size = 0 and locstr_count > 0" do
+    @erf[12,4] = [0].pack("V")
+    wellformed_verify @erf, false
   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
+    @erf[8,4] = [0].pack("V")
+    wellformed_verify @erf, false
+  end
+end
+
+describe "Erf V1.0" do
+  before do
+    @erf = WELLFORMED_ERF.dup
+  end
+
+  it_should_behave_like "Erf::Erf"
+
+  it "accepts valid filenames" do
+    t = Erf::Erf.new(StringIO.new @erf)
+    t.add_file("a" * 1 + ".txt", StringIO.new("blargh"))
+    t.add_file("a" * 16 + ".txt", StringIO.new("blargh"))
+  end
+
+  it "fails on invalid filenames" do
+    t = Erf::Erf.new(StringIO.new @erf)
+    proc { t.add_file("a" * 0 + ".txt", StringIO.new("blargh")) }.should raise_error ArgumentError
+    proc { t.add_file("a" * 17 + ".txt", StringIO.new("blargh")) }.should raise_error ArgumentError
+  end
+
+  it "returns unknown for unknown-N file types" do
+    @erf[174 + 16 + 4, 2] = [9995].pack("v")
+    t = Erf::Erf.new(StringIO.new @erf)
+    t.content[0].filename.should == "resref.unknown-9995"
+  end
+end
+
+describe "Erf V1.1" do
+  before do
+    @erf = WELLFORMED_ERF_11.dup
+  end
+
+  it_should_behave_like "Erf::Erf"
+
+  it "accepts valid filenames" do
+    t = Erf::Erf.new(StringIO.new @erf)
+    t.add_file("a" * 1 + ".txt", StringIO.new("blargh"))
+    t.add_file("a" * 32 + ".txt", StringIO.new("blargh"))
+  end
+
+  it "fails on invalid filenames" do
+    t = Erf::Erf.new(StringIO.new @erf)
+    proc { t.add_file("a" * 0 + ".txt", StringIO.new("blargh")) }.should raise_error ArgumentError
+    proc { t.add_file("a" * 33 + ".txt", StringIO.new("blargh")) }.should raise_error ArgumentError
+  end
+
+  it "returns unknown for unknown-N file types" do
+    @erf[174 + 32 + 4, 2] = [9995].pack("v")
+    t = Erf::Erf.new(StringIO.new @erf)
+    t.content[0].filename.should == "resref.unknown-9995"
   end
 end