nwn-lib 0.3.2 → 0.3.3

data/CHANGELOG

@@ -1,44 +1,77 @@
-=== 0.3.2
-
-* Gff: fix reading some type fields raising an exception in rare conditions
-* Add NWN::Gff::Struct#set for easy label setting
-
-=== 0.3.1
-
-* Bugfix release only
-* Gff: fix struct delegator bug not passing on blocks (yuk!)
-
-=== 0.3.0
-
-* Binary: nwn-gff-import
-* Binary: nwn-gff-print supports -m, ruby marshalling
-* helper: NWN::Gff::Helpers.item_property
-* TwoDA: Cache, more compatibility to slightly broken 2da files
-* CExoLocString: now has its own proper class for a more convenient API
-* Gff::Struct: has changed its internal API (transparent to the outside)
-
-=== 0.2.2
+=== 0.1
+Bernhard Stoeckner <elven@swordcoast.net> (15):
+      Add proper struct support, fix some values
+      Suspected to be fully-working Gff::Reader
+      Add working rudimentary Gff::Writer
+      Add substruct support
+      Add untested support for complex datatypes
+      add gff_to_yaml.rb
+      Add COPYING, LICENCE, README, Rakefile, spec/
+      Update README
+      add nwn-gff-print.rb binary, update gff lib
+      rename nwn-gff-print.rb to nwn-gff-print
+      nwn-gff-print: allow proper printing of sub-structs/lists
+      Add proper get/set support for Gff, add Element validations
+      Rakefile/gem: add nwn-gff-print to binary list
+      Rename project to nwn-lib
+      Fix Writer method scope
 
-* Binary: nwn-gff-irb: interactive gff inspection/editing shell
-* Gff: Errors are now RuntimeErrors instead of Exceptions
-* Gff::Reader: properly read structures with no labels inside
-* Gff::Reader: void datatype support
+=== 0.2
+Bernhard Stoeckner <elven@swordcoast.net> (6):
+      Fix stupid typo in Rakefile
+      Add a basic 2da parser
+      twoda: Read windows-linebreaks as well.
+      Twoda: add .to_2da
+      nwn-gff-print/Gff: kivinen_format is now a member of the Gff module and supports printing types
+      0.2-rel, add CHANGELOG
 
 === 0.2.1
+Bernhard Stoeckner <elven@swordcoast.net> (6):
+      TwoDA: Update API for new schema
+      Gff: minor documentation update
+      Gff/kivinen_print: be more compatible
+      Gff/kivinen_format: add filetype-override for custom headers, add documentation
+      Add cheatsheet
+      Version 0.2.1-rel
 
-* TwoDA allows creation of tables and proper writing, HAS NEW API. (sorry!)
-* NWN::Gff.kivinen_print takes more options, compatibility updates.
-* nwn-gff-print takes option --type: override file type, prints a custom header.
-* nwn-gff-print takes option -f: print full path. (formerly -k)
-* nwn-gff-print takes option --struct: override struct id
-* Added CHEATSHEET
+=== 0.3.0
+Bernhard Stoeckner <elven@swordcoast.net> (16):
+      Gff::Reader: Fix reading structs with no subvalues
+      Gff::Reader: void datatype support
+      add nwn-gff-irb
+      Gff: raise RuntimeError instead of generic Exceptions
+      Update CHEATSHEET for gff-irb
+      0.2.2-rel
+      TwoDA: Do not parse empty lines
+      Add global, optional, 2da cache, add NWN::Gff.item_property helper
+      item_property: resolve unique partial matches
+      CExoLocString: more comfortable class to manage (API change)
+      compatibility fixes: allow non-empty-line-2das, be slightly more verbose
+      Gff::Struct is a delegator to Hash to allow seamless YAML marshalling
+      nwn-gff-print: -m: add support for native ruby marshalling
+      Binary: add nwn-gff-import
+      TwoDA: compatibility fixes (just warn on double ID assignments)
+      0.3.0-rel
 
-=== 0.2
+=== 0.3.1
+Bernhard Stoeckner <elven@swordcoast.net> (2):
+      Gff: fix struct delegator bug not passing on blocks (yuk!)
+      0.3.1-rel
 
-* Add TwoDA reading/writing support.
-* nwn-gff-print supports kivinen-style ____type printing.
+=== 0.3.2
+Bernhard Stoeckner <elven@swordcoast.net> (3):
+      Add NWN::Gff::Struct#set for easy label setting
+      Gff: fix reading some type fields raising an exception in rare conditions
+      0.3.2-rel
 
-=== 0.1
+=== 0.3.3
+Bernhard Stoeckner <elven@swordcoast.net> (8):
+      Gff#get_or_set: fix addressing exolocstr languages (/Description/0)
+      Helpers.item_property: ? expands the full list
+      fix private method `select' called while accessing ExoLocStr/Language
+      add support for sorted and cleaned-up yaml output
+      writer: void written properly
+      nwn-gff-print: add support for multiple files
+      nwn-gff-import: add support for multiple files
+      0.3.3-rel
 
-* Add basic functionality for reading and writing arbitary gff files.
-* Binaries: nwn-gff-print for simple display of gff files.

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "nwn-lib"
-VERS = "0.3.2"
+VERS = "0.3.3"
 CLEAN.include ["**/.*.sw?", "pkg", ".config", "rdoc", "coverage"]
 RDOC_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', \
   'nwn-lib: a ruby library for accessing NWN resource files', \

data/bin/nwn-gff-import

@@ -6,49 +6,65 @@ require 'nwn/helpers'
 require 'yaml'
 
 format = nil
+postfix = nil
+outfile = nil
 
 OptionParser.new do |o|
-  o.banner = "Usage: nwn-gff-import [options] file/- outfile/-"
+  o.banner = "Usage: nwn-gff-import [options] file/- [file, file, file]"
+
   o.on "-y", "--yaml", "Import as yaml" do
     format = :yaml
   end
   o.on "-m", "--marshal", "Import as native ruby marshal data" do
     format = :marshal
   end
+
+  o.on "-o", "--outfile F", "Write to outfile instead of stdout" do |out|
+    outfile = out
+  end
+
+  o.on "--postfix P", "Strip the given postfix from file and write to that instead of stdout (overrides -o)" do |p|
+    postfix = p
+  end
+
 end.parse!
 
-infile = ARGV.shift or begin
+ARGV.size > 0 or begin
   $stderr.puts "Required argument: filename to read, or - for stdin (try -h)."
   exit 1
 end
-outfile = ARGV.shift or begin
-  $stderr.puts "Required argument: filename to write, or - for stdout (try -h)."
-  exit 1
-end
 
-if infile == "-"
-  inbytes = $stdin.read
-else
+ARGV.each do |infile|
+  data = nil
+
+  if !postfix && !outfile
+    outfile = $stdout
+  elsif postfix && outfile
+    outfile = outfile.gsub(/#{Regexp.escape(postfix)}$/, "")
+    outfile = File.new(outfile, "w")
+  elsif outfile && !postfix
+    outfile = File.new(outfile, "w")
+  end
+
+  infile = $stdin if infile == "-"
   inbytes = IO.read(infile)
-end
 
-data = nil
+  case format
+    when :yaml
+      data = YAML.load(inbytes)
+    when :marshal
+      data = Marshal.load(inbytes)
+    else
+      raise ArgumentError, "Unknown format; try -h"
+  end
+
+  raise ArgumentError, "Input stream is NOT a valid gff object" unless
+    data.is_a?(NWN::Gff::Gff)
+
+  outbytes = NWN::Gff::Writer.dump(data)
 
-case format
-  when :yaml
-    data = YAML.load(inbytes)
-  when :marshal
-    data = Marshal.load(inbytes)
-  else
-    raise ArgumentError, "Unknown format; try -h"
-end
 
-raise ArgumentError, "Input stream is NOT a valid gff object" unless
-  data.is_a?(NWN::Gff::Gff)
+  outfile.write(outbytes)
 
-outbytes = NWN::Gff::Writer.dump(data)
-if outfile == "-"
-  puts outbytes
-else
-  File.open(outfile, "w") {|f| f.write(outbytes) }
+  outfile.close
 end

data/bin/nwn-gff-print

@@ -10,25 +10,45 @@ types_too = false
 full = false
 file_type = nil
 struct_id = nil
+path = nil
+prefix = :none
+postfix = nil
+verbose = false
 
 OptionParser.new do |o|
-  o.banner = "Usage: nwn-gff-print [options] file/- [path]"
+  o.banner = "Usage: nwn-gff-print [options] file/- [file, file, ..]"
+
   o.on "-y", "--yaml", "Dump as yaml" do
     format = :yaml
   end
+
   o.on "-k", "--kivinen", "Dump as kivinens dump format (like the perl tools)" do
     format = :kivinen
   end
-  o.on "-f", "--kivinen-full-path", "Print the full path (implies -k)" do
+  o.on "--kivinen-full-path", "Print the full path (implies -k)" do
     format = :kivinen
     full = true
   end
+
+  o.on "-b", "--print-basename", "Prefix the file basename to the output" do |b|
+    prefix = :base
+  end
+  o.on "-f", "--print-filename", "Prefix the full filename to the output" do |b|
+    prefix = :full
+  end
+
+  o.on "-t", "--print-types", "Print types as well" do
+    types_too = true
+  end
+
   o.on "-m", "--marshal", "Native ruby marshalling. Warning: raw bytes" do
     format = :marshal
   end
-  o.on "-t", "--types", "Dump types as well (only applies to -k, for now)" do
-    types_too = true
+
+  o.on "--postfix P", "Write output to file postfixed with P instead of stdout" do |p|
+    postfix = p
   end
+
   o.on "--type filetype", "Override the file type (implies --struct 0xffffffff)" do |t|
     if t.size != 3
       $stderr.puts "Invalid type #{t} passwd."
@@ -37,44 +57,67 @@ OptionParser.new do |o|
     file_type = t.upcase + " "
     struct_id = 0xffffffff
   end
+
   o.on "--struct id", "Override struct id (as hex, please)" do |s|
     struct_id = s.hex
   end
+  o.on "-p=path", "--path path", "Only print the given path" do |p|
+    path = p
+  end
+
+  o.on "-v" "--verbose", "Be verbose" do
+    verbose = true
+  end
 end.parse!
 
-file = ARGV.shift or begin
-  $stderr.puts "Required argument: filename to process, or - for stdin (try -h)."
+ARGV.size > 0 or begin
+  $stderr.puts "Required argument: filename to read, or - for stdin (try -h)."
   exit 1
 end
 
-path = ARGV.shift
+ARGV.each {|file|
 
-if file == "-"
-  bytes = $stdin.read
-else
-  bytes = IO.read(file)
-end
+  if file == "-"
+    bytes = $stdin.read
+  else
+    bytes = IO.read(file)
+  end
 
-g = NWN::Gff::Reader.read(bytes)
+  g = NWN::Gff::Reader.read(bytes)
 
-if path
-  begin
-    g = g[path]
-  rescue Exception => e
-    $stderr.puts "Error: " + e.to_s
-    exit 1
+  if path
+    begin
+      g = g[path]
+    rescue Exception => e
+      $stderr.puts "Error: " + e.to_s
+      exit 1
+    end
   end
-end
 
-case format
-  when :yaml
-    y g
-  when :kivinen
-    NWN::Gff.kivinen_format g, "/", types_too, full, file_type, struct_id do |label, value|
-      puts "%s:\t%s" % [label, value]
-    end
-  when :marshal
-    puts Marshal.dump(g)
-  else
-    puts "Unknown format; try -h"
-end
+  my_prefix = case prefix
+    when :none
+      ""
+    when :base
+      File.basename(file) + ": "
+    when :full
+      File.expand_path(file) + ": "
+  end
+
+  write_to = postfix ? File.new(file + postfix, "w") : $stdout
+  $stderr.puts "Processing `#{file}`" if verbose
+  case format
+    when :yaml
+      write_to.puts g.to_yaml.split("\n").map {|ln| my_prefix + ln }.join("\n")
+    when :kivinen
+      NWN::Gff.kivinen_format g, my_prefix + "/", types_too, full, file_type, struct_id do |label, value|
+        write_to.puts "%s:\t%s" % [label, value]
+      end
+    when :marshal
+      write_to.print Marshal.dump(g)
+    else
+      $stderr.puts "Unknown format; try -h"
+      exit 1
+  end
+
+  write_to.close if postfix
+}

data/lib/nwn/gff.rb

@@ -87,6 +87,11 @@ module NWN
         s = NWN::Gff::Element.new(add_prefix ? "(unlabeled struct)" : "", :struct, s)
       end
 
+      if s.is_a?(String)
+        yield("(unlabeled string)" + prefix, s)
+        return
+      end
+
       case s.type
         when :struct
           yield(prefix + " ____struct_type", struct_id.nil? ? s.value.struct_id : struct_id) if types_too
@@ -101,7 +106,7 @@ module NWN
           s.value.each {|kk,vv|
             yield(prefix + s.label + "/" + kk.to_s, vv.gsub(/([\000-\037\177-\377%])/) {|v| "%" + v.unpack("H2")[0] })
           }
-          yield(prefix + s.label + ". ____string_ref", s._str_ref)
+          yield(prefix + s.label + ". ____string_ref", s.str_ref)
 
         when :list
           s.value.each_with_index {|vv, idx|
@@ -138,6 +143,10 @@ class NWN::Gff::Gff
   attr_accessor :type
   attr_accessor :version
 
+  def to_yaml_properties
+    [ '@type', '@version', '@hash' ]
+  end
+
   # Create a new GFF object from the given +struct+.
   # This is normally not needed unless you are creating
   # GFF objects entirely from hand.
@@ -174,7 +183,7 @@ class NWN::Gff::Gff
   #    overwrite an existing one with the same label.
   #  gff['/PropertiesList[0]'] = 'Test'
   #    This will raise an error (obviously)
-  def get_or_set k, new_value = nil, new_type = nil, new_label = nil, new_str_ref = nil
+  def get_or_set k, new_value = nil, new_type = nil, new_label = nil, newstr_ref = nil
     h = self.root_struct
     path = []
     value_path = [h]
@@ -192,8 +201,7 @@ class NWN::Gff::Gff
       if h.is_a?(Gff::Element)
         case h.type
           when :cexolocstr
-            current_value = h.value.select {|vx| vx.language.to_i == v.to_i}
-            current_value = current_value[0] != nil ? current_value[0].text : ''
+            current_value = h.value.languages[v.to_i] || ''
 
           when :list
             raise GffPathInvalidError, "List-selector access not implemented yet."
@@ -259,10 +267,10 @@ class NWN::Gff::Gff
 
       end
 
-      if !new_str_ref.nil?
+      if !newstr_ref.nil?
         # Set a new str_ref
         raise GffTypeError, "specified path is not a CExoStr" unless current_value.is_a?(Gff::CExoString)
-        current_value._str_ref = new_str_ref.to_i
+        current_value.str_ref = new_str_ref.to_i
       end
 
       if !new_value.nil?
@@ -276,7 +284,7 @@ class NWN::Gff::Gff
 
           when String #means: cexolocstr assignment
             if value_path[-2].is_a?(Gff::Element) && value_path[-2].type == :cexolocstr
-              value_path[-2].value.select{|xy| xy.language == path[-1].to_i }[0].text = new_value
+              value_path[-2].value[path[-1].to_i] = new_value
             else
               raise GffPathInvalidError, "Dont know how to set #{new_value.class} on #{path.inspect}."
             end
@@ -304,20 +312,36 @@ end
 
 # A Element wraps a GFF label->value pair,
 # provides a +.type+ and, optionally,
-# a +._str_ref+ for CExoLocStrings.
+# a +.str_ref+ for CExoLocStrings.
 #
 # Fields:
 # [+label+]  The label of this element, for reference.
 # [+type+]   The type of this element. (See NWN::Gff)
 # [+value+]  The value of this element.
 class NWN::Gff::Element
-  attr_accessor :label, :type, :value
-  attr_accessor :_str_ref
+  NonInline = [:struct, :list, :cexolocstr]
+
+  attr_accessor :label, :type, :value, :str_ref
+
+  def to_yaml_properties
+    [ '@label', '@type', '@value', '@str_ref' ]
+  end
 
   def initialize label = nil, type = nil, value = nil
     @label, @type, @value = label, type, value
   end
 
+  def to_yaml( opts = {} )
+    YAML::quick_emit( self, opts ) do |out|
+      out.map( taguri, to_yaml_style ) do |map|
+        map.style = :inline unless NonInline.index(self.type)
+        to_yaml_properties.sort.each do |m|
+          map.add( m[1..-1], instance_variable_get( m ) ) unless instance_variable_get( m ).nil?
+        end
+      end
+    end
+  end
+
   def validate path_prefix = "/"
     raise NWN::Gff::GffTypeError, "#{path_prefix}#{self.label}: New value #{self.value} is not compatible with the current type #{self.type}" unless
       self.class.valid_for?(self.value, self.type)
@@ -376,6 +400,10 @@ class NWN::Gff::Struct
   attr_accessor :struct_id
   attr_accessor :hash
 
+  def to_yaml_properties
+    [ '@struct_id', '@hash' ]
+  end
+
   def initialize
     @struct_id = 0
     @hash = {}
@@ -602,7 +630,7 @@ class NWN::Gff::Reader
         total_size, str_ref, str_count =
           @field_data[data_or_offset, 12].unpack("VVV")
         all = @field_data[data_or_offset + 12, total_size]
-        field._str_ref = str_ref
+        field.str_ref = str_ref
 
         str_count.times {
           id, len = all.unpack("VV")
@@ -770,8 +798,6 @@ private
 
         # complex data types
         when :dword64, :int64, :double, :void
-          $stderr.puts "Warning: complex datatypes dword64, int64, double and void are untested."
-
           fields_of_this_struct << add_data_field(v.type, k, @field_data.size)
           format = Formats[v.type]
           @field_data << case v.type
@@ -781,13 +807,11 @@ private
                 v.value % (2**32)
               ].pack("II")
             when :void
-              [ v.value.size, v.value ].pack("VH*")
+              [ v.value.size / 2, v.value ].pack("VH*")
             else
               [v.value].pack(format)
           end
 
-          raise GffError, "unhandled complex datatype #{v.type}"
-
         when :struct
           raise GffError, "type = struct, but value not a hash" unless
             v.value.is_a?(Gff::Struct)
@@ -833,7 +857,7 @@ private
           }
           @field_data << [
             total_size,
-            v._str_ref,
+            v.str_ref,
             v.value.size
           ].pack("VVV")
 

data/lib/nwn/helpers.rb

@@ -68,6 +68,8 @@ module NWN
       def self.resolve_or_match_partial name_spec, list #:nodoc:
         name_spec = name_spec.downcase
 
+        raise ArgumentError, "?-expand: #{list.inspect}" if name_spec == '?'
+
         list.each {|l|
           return l if l.downcase == name_spec
         }

data/lib/nwn/yaml.rb

@@ -0,0 +1,17 @@
+require 'yaml'
+
+class Hash
+  # Replacing the to_yaml function so it'll serialize hashes sorted (by their keys)
+  # Original function is in /usr/lib/ruby/1.8/yaml/rubytypes.rb
+  def to_yaml( opts = {} )
+    YAML::quick_emit( object_id, opts ) do |out|
+      out.map( taguri, to_yaml_style ) do |map|
+        sort.each do |k, v|
+          map.add( k, v )
+        end
+      end
+    end
+  end
+end
+
+

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: nwn-lib
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
-date: 2008-07-10 00:00:00 +02:00
+  version: 0.3.3
+date: 2008-08-07 00:00:00 +02:00
 summary: a ruby library for accessing Neverwinter Nights resource files
 require_paths: 
 - lib
@@ -39,6 +39,7 @@ files:
 - spec/spec.opts
 - spec/rcov.opts
 - lib/nwn
+- lib/nwn/yaml.rb
 - lib/nwn/twoda.rb
 - lib/nwn/gff.rb
 - lib/nwn/helpers.rb