nwn-lib 0.1 → 0.2

data/CHANGELOG

@@ -0,0 +1,8 @@
+=== 0.2
+
+* Add TwoDA reading/writing support.
+* nwn-gff-print supports kivinen-style ____type printing.
+=== 0.1
+
+* 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.1"
+VERS = "0.2"
 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', \
@@ -18,7 +18,7 @@ RDOC_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', \
 Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_dir = "rdoc"
   rdoc.options += RDOC_OPTS
-  rdoc.rdoc_files.add ["README", "COPYING", "CHANGELOG", "doc/*.rdoc", "lib/**/*.rb"]
+  rdoc.rdoc_files.add ["README", "CHANGELOG", "COPYING", "doc/*.rdoc", "lib/**/*.rb"]
 end
 
 desc "Packages up nwn-lib"
@@ -30,7 +30,7 @@ spec = Gem::Specification.new do |s|
   s.version = VERS
   s.platform = Gem::Platform::RUBY
   s.has_rdoc = true
-  s.extra_rdoc_files = ["README", "COPYING"] + Dir["doc/*.rdoc"]
+  s.extra_rdoc_files = ["README", "CHANGELOG", "COPYING"] + Dir["doc/*.rdoc"]
   s.rdoc_options += RDOC_OPTS + ["--exclude", "^(examples|extras)\/"]
   s.summary = "a ruby library for accessing Neverwinter Nights resource files"
   s.description = s.summary
@@ -39,7 +39,7 @@ spec = Gem::Specification.new do |s|
   s.homepage = "http://nwn-lib.elv.es"
   s.executables = ["nwn-gff-print"]
   s.required_ruby_version = ">= 1.8.4"
-  s.files = %w(COPYING README Rakefile) + Dir.glob("{bin,doc,spec,lib}/**/*")
+  s.files = %w(COPYING CHANGELOG README Rakefile) + Dir.glob("{bin,doc,spec,lib}/**/*")
   s.require_path = "lib"
   s.bindir = "bin"
 end

data/bin/nwn-gff-print

@@ -5,6 +5,7 @@ require 'nwn/gff'
 require 'yaml'
 
 format = nil
+types_too = false
 
 OptionParser.new do |o|
   o.banner = "Usage: nwn-gff-print [options] file/- [path]"
@@ -14,6 +15,9 @@ OptionParser.new do |o|
   o.on "-k", "--kivinen", "Dump as kivinens dump format (like the perl tools)" do
     format = :kivinen
   end
+  o.on "-t", "--types", "Dump types as well (only applies to -k, for now)" do
+    types_too = true
+  end
 end.parse!
 
 file = ARGV.shift or begin
@@ -40,46 +44,11 @@ if path
   end
 end
 
-def k_format_struct s, prefix = "/", &block
-  if s.is_a?(NWN::Gff::Gff)
-    s = NWN::Gff::Element.new("", :struct, s.root_struct)
-  end
-  if s.is_a?(Array)
-    v = NWN::Gff::Element.new("(unlabeled list)", :list, s)
-  end
-  if s.is_a?(NWN::Gff::Struct)
-    s = NWN::Gff::Element.new("(unlabeled struct)", :struct, s)
-  end
-  case s.type
-    when :struct
-      s.value.each {|k,v|
-    k_format_struct v, prefix + s.label + (s.label == "" ? "" : "/") do |l,v|
-          yield(l, v)
-    end
-      }
-    when :cexolocstr
-      s.value.each {|vv|  
-        yield(prefix + s.label + "/" + vv.language.to_s, vv.text)
-      }
-      yield(prefix + s.label + ". ___string_ref", s._str_ref)
-    when :list
-      s.value.each_with_index {|vv, idx|
-        vv.each {|kkk, vvv|
-          k_format_struct vvv, prefix + s.label + "[#{idx}]/" do |l,v|
-            yield(l,v)
-          end
-        }
-      }
-    else
-      yield(prefix + s.label, s.value)
-  end
-end
-
 case format
   when :yaml
     y g
   when :kivinen
-    k_format_struct g do |label, value|
+    NWN::Gff.kivinen_format g, "/", types_too do |label, value|
       puts "%s:\t%s" % [label, value]
     end
   else

data/lib/nwn/gff.rb

@@ -55,7 +55,61 @@ module NWN
       :float => 'f',
       :double => 'd',
     }.freeze
+
+    # Parses +s+ as an arbitary GFF object and yields for each field found,
+    # with the proper prefix.
+    def self.kivinen_format s, prefix = "/", types_too = false, &block
+      if s.is_a?(NWN::Gff::Gff)
+        if types_too
+          yield("/ ____file_type", s.type)
+          yield("/ ____file_version", s.version)
+        end
+        s = NWN::Gff::Element.new("", :struct, s.root_struct)
+      end
+
+      if s.is_a?(Array)
+        v = NWN::Gff::Element.new("(unlabeled list)", :list, s)
+      end
+
+      if s.is_a?(NWN::Gff::Struct)
+        yield(prefix + " ____struct_type", s.struct_id) if types_too
+        s = NWN::Gff::Element.new("(unlabeled struct)", :struct, s)
+      end
+
+      case s.type
+        when :struct
+          yield(prefix + " ____struct_type", s.value.struct_id) if types_too
+          s.value.each {|k,v|
+            kivinen_format v, prefix + s.label + (s.label == "" ? "" : "/"), types_too do |l,v|
+              yield(l, v)
+            end
+          }
+
+        when :cexolocstr
+
+          s.value.each {|vv|
+            yield(prefix + s.label + "/" + vv.language.to_s, vv.text)
+          }
+          yield(prefix + s.label + ". ___string_ref", s._str_ref)
+
+        when :list
+          s.value.each_with_index {|vv, idx|
+            vv.each {|kkk, vvv|
+              kivinen_format vvv, prefix + s.label + "[#{idx}]/", types_too do |l,v|
+                yield(l,v)
+              end
+            }
+          }
+        else
+          yield(prefix + s.label, s.value)
+      end
+
+      if types_too && s.label != ""
+        yield(prefix + s.label + ". ____type", Types.index(s.type).to_s)
+      end
+    end
   end
+
 end
 
 # A GFF object encapsulates a whole GFF identity, with a type,

data/lib/nwn/twoda.rb

@@ -1,9 +1,104 @@
+require 'shellwords'
+
 module NWN
   module TwoDA
     class Table
-    end
 
-    class Reader
+      # An array of all column names present in this 2da table.
+      attr_reader :columns
+
+      # An array of row arrays, without headers.
+      attr_reader :rows
+
+
+      # Creates a new Table object from a given file.
+      #
+      # [+file+] A readable, valid .2da file.
+      def self.new_from_file file
+        self.new IO.read(file)
+      end
+
+
+      # Parses a string that represents a valid 2da definition.
+      def initialize bytes
+        magic, empty, header, *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 avalid 2da: Second line should be empty."  unless
+            empty == ""
+
+        header = Shellwords.shellwords(header.strip)
+        data.map! {|line|
+          Shellwords.shellwords(line.strip)
+        }
+
+        data.each_with_index {|row, idx|
+          raise ArgumentError, "2da non-continoous: row #{idx} has a non-matching ID #{row[0]}." if idx != row[0].to_i
+          # [1..-1]: Strip off the ID
+          data[idx] = row = row[1..-1]
+
+          raise ArgumentError,
+            "Row #{idx} does not have the appropriate amount of cells (has: #{row.size}, want: #{header.size})." if
+              row.size != header.size
+        }
+
+        @columns = header
+        @rows = data
+      end
+
+
+      # Retrieve data by row.
+      #
+      # [+row+]    The row to retrieve (starts at 0)
+      # [+column+] The column to retrieve (name or id), or nil for all columns.
+      def by_row row, column = nil
+        column = column_name_to_id column
+        column.nil? ? @rows[row.to_i] : @rows[row.to_i][column]
+      end
+
+
+      # Retrieve data by column.
+      #
+      # [+column+] The column to retrieve (name or id).
+      # [+row+]    The row to retrieve (starts at 0), or nil for all rows.
+      def by_col column, row = nil
+        column = column_name_to_id column
+        raise ArgumentError, "column must not be nil." if column.nil?
+        row.nil? ? @rows.map {|v| v[column] } : @rows[row.to_i][column]
+      end
+
+
+      # Translate a column name to its array offset; will validate
+      # and raise an ArgumentError if the given argument is invalid
+      # or the column cannot be resolved.
+      def column_name_to_id column
+         case column
+          when String
+            @columns.index(column) or raise ArgumentError, "Not a valid column name: #{column}"
+          when Fixnum
+            column
+          when NilClass
+            nil
+          else
+            raise ArgumentError, "Invalid column type: #{column} as #{column.class}"
+        end
+      end
+
+      # Returns this table as a valid 2da to be written to a file.
+      def to_2da
+        ret = []
+        ret << "2DA V2.0"
+        ret << ""
+        ret << @columns.join("\t")
+        @rows.each_with_index {|row, idx|
+          ret << [idx].concat(row).join("\t")
+        }
+        ret.join("\r\n")
+      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.1"
-date: 2008-06-28 00:00:00 +02:00
+  version: "0.2"
+date: 2008-06-29 00:00:00 +02:00
 summary: a ruby library for accessing Neverwinter Nights resource files
 require_paths: 
 - lib
@@ -30,10 +30,10 @@ authors:
 - Bernhard Stoeckner
 files: 
 - COPYING
+- CHANGELOG
 - README
 - Rakefile
 - bin/nwn-gff-print
-- bin/nwn-gff-set
 - spec/spec.opts
 - spec/rcov.opts
 - lib/nwn
@@ -53,6 +53,7 @@ rdoc_options:
 - ^(examples|extras)/
 extra_rdoc_files: 
 - README
+- CHANGELOG
 - COPYING
 executables: 
 - nwn-gff-print

data/bin/nwn-gff-set

@@ -1,87 +0,0 @@
-#!/usr/bin/ruby
-require 'rubygems'
-require 'optparse'
-require 'nwn/gff'
-require 'yaml'
-
-format = nil
-
-OptionParser.new do |o|
-  o.banner = "Usage: nwn-gff-print [options] file/- [path]"
-  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
-end.parse!
-
-file = ARGV.shift or begin
-  $stderr.puts "Required argument: filename to process, or - for stdin (try -h)."
-  exit 1
-end
-
-path = ARGV.shift
-
-if file == "-"
-  bytes = $stdin.read
-else
-  bytes = IO.read(file)
-end
-
-g = NWN::Gff::Reader.read(bytes)
-
-if path
-  begin
-    g = g[path]
-  rescue Exception => e
-    $stderr.puts "Error: " + e.to_s
-    exit 1
-  end
-end
-
-def k_format_struct s, prefix = "/", &block
-  if s.is_a?(NWN::Gff::Gff)
-    s = NWN::Gff::Element.new("", :struct, s.root_struct)
-  end
-  if s.is_a?(Array)
-    v = NWN::Gff::Element.new("(unlabeled list)", :list, s)
-  end
-  if s.is_a?(NWN::Gff::Struct)
-    s = NWN::Gff::Element.new("(unlabeled struct)", :struct, s)
-  end
-  case s.type
-    when :struct
-      s.value.each {|k,v|
-    k_format_struct v, prefix + s.label + (s.label == "" ? "" : "/") do |l,v|
-          yield(l, v)
-    end
-      }
-    when :cexolocstr
-      s.value.each {|vv|  
-        yield(prefix + s.label + "/" + vv.language.to_s, vv.text)
-      }
-      yield(prefix + s.label + ". ___string_ref", s._str_ref)
-    when :list
-      s.value.each_with_index {|vv, idx|
-        vv.each {|kkk, vvv|
-          k_format_struct vvv, prefix + s.label + "[#{idx}]/" do |l,v|
-            yield(l,v)
-          end
-        }
-      }
-    else
-      yield(prefix + s.label, s.value)
-  end
-end
-
-case format
-  when :yaml
-    y g
-  when :kivinen
-    k_format_struct g do |label, value|
-      puts "%s:\t%s" % [label, value]
-    end
-  else
-    puts "Unknown format; try -h"
-end