athena 0.1.5 → 0.2.1

data/README

@@ -2,7 +2,7 @@
 
 == VERSION
 
-This documentation refers to athena version 0.1.5
+This documentation refers to athena version 0.2.1
 
 
 == DESCRIPTION

data/Rakefile

@@ -14,7 +14,7 @@ begin
       :summary      => %q{Convert database files to various formats.},
       :author       => %q{Jens Wille},
       :email        => %q{jens.wille@uni-koeln.de},
-      :dependencies => ['builder', 'xmlstreamin', ['ruby-nuggets', '>= 0.6.4']]
+      :dependencies => %w[builder xmlstreamin] << ['ruby-nuggets', '>= 0.7.4']
     }
   }}
 rescue LoadError => err

data/bin/athena

@@ -28,158 +28,5 @@
 ###############################################################################
 #++
 
-require 'optparse'
-require 'yaml'
-
-$: << File.join(File.dirname(__FILE__), '..', 'lib')
-
-require 'athena'
-
-USAGE = "Usage: #{$0} [-h|--help] [options]"
-abort USAGE if ARGV.empty?
-
-# Global variable to handle verbosity
-$Verbose = {}
-
-options = {
-  :config => 'config.yaml',
-  :input  => STDIN,
-  :output => STDOUT,
-  :target => nil
-}
-
-OptionParser.new { |opts|
-  opts.banner = USAGE
-
-  opts.separator ''
-  opts.separator 'Options:'
-
-  opts.on('-c', '--config YAML', "Config file [Default: #{options[:config]}#{' (currently not present)' unless File.readable?(options[:config])}]") { |f|
-    abort "Can't find config file: #{f}." unless File.readable?(f)
-
-    options[:config] = f
-  }
-
-  opts.separator ''
-
-  opts.on('-i', '--input FILE',  "Input file [Default: STDIN]") { |f|
-    abort "Can't find input file: #{f}." unless File.readable?(f)
-
-    options[:input] = File.directory?(f) ? Dir.open(f) : File.open(f, 'r')
-
-    p = File.basename(f).split('.')
-    options[:spec_fallback]   = p.last.downcase
-    options[:target_fallback] = p.size > 1 ? p[0..-2].join('.') : p.first
-  }
-
-  opts.on('-s', '--spec SPEC', "Input format (spec) [Default: file extension of <input-file>]") { |s|
-    options[:spec] = s.downcase
-  }
-
-  opts.on('-L', '--list-specs', "List available input formats (specs) and exit") {
-    puts 'Available input formats (specs):'
-
-    Athena.input_formats.each { |f, k|
-      puts "  - #{f}#{" (= #{k})" if f != k.to_s}"
-    }
-
-    exit 0
-  }
-
-  opts.separator ''
-
-  opts.on('-o', '--output FILE',  "Output file [Default: STDOUT]") { |f|
-    options[:output] = File.open(f, 'w')
-
-    options[:format_fallback] = f.split('.').last.downcase
-  }
-
-  opts.on('-f', '--format FORMAT', "Output format [Default: file extension of <output-file>]") { |f|
-    options[:format] = f.downcase
-  }
-
-  opts.on('-l', '--list-formats', "List available output formats and exit") {
-    puts 'Available output formats:'
-
-    Athena.output_formats.each { |f, k|
-      puts "  - #{f}#{" (= #{k})" if f != k.to_s}"
-    }
-
-    exit 0
-  }
-
-  opts.separator ''
-
-  opts.on('-t', '--target ID', "Target whose config to use [Default: <input-file> minus file extension,", "plus '.<spec>', plus ':<format>' (reversely in turn)]") { |t|
-    options[:target] = t
-  }
-
-  opts.separator ''
-  opts.separator 'Generic options:'
-
-  opts.on('-v', '--verbose [WHAT]', "Be verbose about what's being done. Optional argument is a comma-separated", "list of what should be output, or 'all' [Default: 'all']") { |what|
-    if what.nil? || what == 'all'
-      $Verbose.default = true
-    else
-      what.split(',').each { |w|
-        $Verbose[w.to_sym] = true
-      }
-    end
-  }
-
-  opts.on('-h', '--help', 'Print this help message and exit') {
-    abort opts.to_s
-  }
-
-  opts.on('--version', 'Print program version and exit') {
-    abort "#{File.basename($0)} v#{Athena::VERSION}"
-  }
-}.parse!
-
-spec = options[:spec] || options[:spec_fallback]
-abort "No input format (spec) specified and none could be inferred." unless spec
-abort "Invalid input format (spec): #{spec}. Use '-L' to get a list of available specs." unless Athena.valid_input_format?(spec)
-
-format = options[:format] || options[:format_fallback]
-abort "No output format specified and none could be inferred." unless format
-abort "Invalid output format: #{format}. Use '-l' to get a list of available formats." unless Athena.valid_output_format?(format)
-
-yaml = YAML.load_file(options[:config])
-if t = options[:target]
-  target = t
-  config = yaml[t.to_sym]
-else
-  [options[:target_fallback] || 'generic', ".#{spec}", ":#{format}"].inject([]) { |s, t|
-    s << (s.last ? s.last + t : t)
-  }.reverse.find { |t|
-    target = t
-    config = yaml[t.to_sym]
-  }
-end
-abort "Config not found for target: #{target}." unless config
-
-parser = Athena.parser(config, spec)
-
-if Athena.deferred_output?(format)
-  res = parser.parse(options[:input])
-
-  res.map { |record|
-    record.to(format)
-  }.flatten.sort.uniq.each { |line|
-    options[:output].puts line
-  }
-elsif Athena.raw_output?(format)
-  res = Athena.with_format(format, options[:output]) { |_format|
-    parser.parse(options[:input]) { |record|
-      record.to(_format)
-    }
-  }
-else
-  res = Athena.with_format(format) { |_format|
-    parser.parse(options[:input]) { |record|
-      options[:output].puts record.to(_format)
-    }
-  }
-end
-
-Athena::Util.verbose(:count) { spit res.is_a?(Numeric) ? res : res.size }
+require 'athena/cli'
+Athena::CLI.execute

data/lib/athena.rb

@@ -35,17 +35,14 @@
 # instance method _convert_ supplied. This way, a specific format can even function
 # as both input and output format.
 
-module Athena
-end
-
-require 'athena/util'
-require 'athena/parser'
-require 'athena/record'
-require 'athena/formats'
 require 'athena/version'
 
 module Athena
 
+  autoload :Parser,  'athena/parser'
+  autoload :Record,  'athena/record'
+  autoload :Formats, 'athena/formats'
+
   extend self
 
   def parser(config, format)

data/lib/athena/cli.rb

@@ -0,0 +1,166 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of athena, the database file converter.                         #
+#                                                                             #
+# Copyright (C) 2007-2011 University of Cologne,                              #
+#                         Albertus-Magnus-Platz,                              #
+#                         50923 Cologne, Germany                              #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# athena is free software; you can redistribute it and/or modify it under the #
+# terms of the GNU Affero General Public License as published by the Free     #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# athena is distributed in the hope that it will be useful, but WITHOUT ANY   #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with athena. If not, see <http://www.gnu.org/licenses/>.              #
+#                                                                             #
+###############################################################################
+#++
+
+require 'nuggets/util/cli'
+require 'athena'
+
+module Athena
+
+  class CLI < ::Util::CLI
+
+    class << self
+
+      def defaults
+        super.merge(
+          :config => 'config.yaml',
+          :input  => '-',
+          :output => '-',
+          :target => nil
+        )
+      end
+
+    end
+
+    def run(arguments)
+      spec = options[:spec] || options[:spec_fallback]
+      abort "No input format (spec) specified and none could be inferred." unless spec
+      abort "Invalid input format (spec): #{spec}. Use `-L' to get a list of available specs." unless Athena.valid_input_format?(spec)
+
+      format = options[:format] || options[:format_fallback]
+      abort "No output format specified and none could be inferred." unless format
+      abort "Invalid output format: #{format}. Use `-l' to get a list of available formats." unless Athena.valid_output_format?(format)
+
+      target_config = if t = options[:target]
+        config[target = t.to_sym]
+      else
+        [options[:target_fallback] || 'generic', ".#{spec}", ":#{format}"].inject([]) { |s, t|
+          s << (s.last ? s.last + t : t)
+        }.reverse.find { |t| config[target = t.to_sym] }
+      end or abort "Config not found for target: #{target}."
+
+      parser = Athena.parser(target_config, spec)
+
+      input = options[:input]
+      input = arguments.shift unless input != defaults[:input] || arguments.empty?
+      options[:input] = File.directory?(input) ? Dir.open(input) : open_file_or_std(input)
+
+      quit unless arguments.empty?
+
+      options[:output] = open_file_or_std(options[:output], true)
+
+      if Athena.deferred_output?(format)
+        res = parser.parse(options[:input])
+
+        res.map { |record|
+          record.to(format)
+        }.flatten.sort.uniq.each { |line|
+          options[:output].puts line
+        }
+      elsif Athena.raw_output?(format)
+        res = Athena.with_format(format, options[:output]) { |_format|
+          parser.parse(options[:input]) { |record|
+            record.to(_format)
+          }
+        }
+      else
+        res = Athena.with_format(format) { |_format|
+          parser.parse(options[:input]) { |record|
+            options[:output].puts record.to(_format)
+          }
+        }
+      end
+    end
+
+    private
+
+    def merge_config(args = [default])
+      super
+    end
+
+    def opts(opts)
+      opts.on('-c', '--config YAML', "Config file [Default: #{defaults[:config]}#{' (currently not present)' unless File.readable?(defaults[:config])}]") { |config|
+        quit "Can't find config file: #{config}" unless File.readable?(config)
+
+        options[:config] = config
+      }
+
+      opts.separator ''
+
+      opts.on('-i', '--input FILE',  "Input file [Default: STDIN]") { |input|
+        options[:input] = input
+
+        parts = File.basename(input).split('.')
+        options[:spec_fallback]   = parts.last.downcase
+        options[:target_fallback] = parts.size > 1 ? parts[0..-2].join('.') : parts.first
+      }
+
+      opts.on('-s', '--spec SPEC', "Input format (spec) [Default: file extension of <input-file>]") { |spec|
+        options[:spec] = spec.downcase
+      }
+
+      opts.on('-L', '--list-specs', "List available input formats (specs) and exit") {
+        puts 'Available input formats (specs):'
+
+        Athena.input_formats.each { |format, name|
+          puts "  - #{format}#{" (= #{name})" if format != name.to_s}"
+        }
+
+        exit
+      }
+
+      opts.separator ''
+
+      opts.on('-o', '--output FILE',  "Output file [Default: STDOUT]") { |output|
+        options[:output] = output
+        options[:format_fallback] = output.split('.').last.downcase
+      }
+
+      opts.on('-f', '--format FORMAT', "Output format [Default: file extension of <output-file>]") { |format|
+        options[:format] = format.downcase
+      }
+
+      opts.on('-l', '--list-formats', "List available output formats and exit") {
+        puts 'Available output formats:'
+
+        Athena.output_formats.each { |format, name|
+          puts "  - #{format}#{" (= #{name})" if format != name.to_s}"
+        }
+
+        exit
+      }
+
+      opts.separator ''
+
+      opts.on('-t', '--target ID', "Target whose config to use [Default: <input-file> minus file extension,", "plus '.<spec>', plus ':<format>' (reversely in turn)]") { |target|
+        options[:target] = target
+      }
+    end
+
+  end
+
+end

data/lib/athena/formats.rb

@@ -26,114 +26,120 @@
 ###############################################################################
 #++
 
+require 'athena'
+
 module Athena
+
   module Formats
 
-  CRLF    = %Q{\015\012}
-  CRLF_RE = %r{(?:\r?\n)+}
+    CRLF    = %Q{\015\012}
+    CRLF_RE = %r{(?:\r?\n)+}
 
-  def self.[](direction, format)
-    if direction == :out
-      if format.class < Base
-        if format.class.direction != direction
-          raise DirectionMismatchError,
-            "expected #{direction}, got #{format.class.direction}"
+    def self.[](direction, format)
+      if direction == :out
+        if format.class < Base
+          if format.class.direction != direction
+            raise DirectionMismatchError,
+              "expected #{direction}, got #{format.class.direction}"
+          else
+            format
+          end
         else
-          format
+          Base.formats[direction][format].new
         end
       else
-        Base.formats[direction][format].new
+        Base.formats[direction][format]
       end
-    else
-      Base.formats[direction][format]
     end
-  end
-
-  class Base
 
-    @formats = { :in => {}, :out => {} }
+    class Base
 
-    class << self
+      @formats = { :in => {}, :out => {} }
 
-      def formats
-        Base.instance_variable_get(:@formats)
-      end
+      class << self
 
-      def valid_format?(direction, format)
-        if format.class < Base
-          direction == format.class.direction
-        else
-          formats[direction].has_key?(format)
+        def formats
+          Base.instance_variable_get(:@formats)
         end
-      end
 
-      private
-
-      def register_format(direction, *aliases, &block)
-        format = name.split('::').last.
-          gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
-          gsub(/([a-z\d])([A-Z])/, '\1_\2').
-          downcase
+        def valid_format?(direction, format)
+          if format.class < Base
+            direction == format.class.direction
+          else
+            formats[direction].has_key?(format)
+          end
+        end
 
-        register_format!(direction, format, *aliases, &block)
-      end
+        private
 
-      def register_format!(direction, format, *aliases, &block)
-        raise "must be a sub-class of #{Base}" unless self < Base
+        def register_format(direction, *aliases, &block)
+          format = name.split('::').last.
+            gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+            gsub(/([a-z\d])([A-Z])/, '\1_\2').
+            downcase
 
-        klass = Class.new(self, &block)
+          register_format!(direction, format, *aliases, &block)
+        end
 
-        klass.instance_eval %Q{
-          def direction; #{direction.inspect}; end
-          def name; '#{format}::#{direction}'; end
-          def to_s; '#{format}'; end
-        }
+        def register_format!(direction, format, *aliases, &block)
+          raise "must be a sub-class of #{Base}" unless self < Base
+
+          klass = Class.new(self, &block)
+
+          klass.instance_eval %Q{
+            def direction; #{direction.inspect}; end
+            def name; '#{format}::#{direction}'; end
+            def to_s; '#{format}'; end
+          }
+
+          [format, *aliases].each { |name|
+            if existing = formats[direction][name]
+              raise DuplicateFormatDefinitionError,
+                "format already defined (#{direction}): #{name}"
+            else
+              formats[direction][name] = klass
+            end
+          }
+        end
 
-        [format, *aliases].each { |name|
-          if existing = formats[direction][name]
-            raise DuplicateFormatDefinitionError,
-              "format already defined (#{direction}): #{name}"
-          else
-            formats[direction][name] = klass
-          end
-        }
       end
 
-    end
+      def parse(*args)
+        raise NotImplementedError, 'must be defined by sub-class'
+      end
 
-    def parse(*args)
-      raise NotImplementedError, 'must be defined by sub-class'
-    end
+      def convert(record)
+        raise NotImplementedError, 'must be defined by sub-class'
+      end
 
-    def convert(record)
-      raise NotImplementedError, 'must be defined by sub-class'
-    end
+      def wrap
+        yield self
+      end
 
-    def wrap
-      yield self
-    end
+      def deferred?
+        false
+      end
 
-    def deferred?
-      false
-    end
+      def raw?
+        false
+      end
 
-    def raw?
-      false
     end
 
-  end
-
-  class FormatError < StandardError; end
+    class FormatError < StandardError; end
 
-  class DuplicateFormatDefinitionError < FormatError; end
-  class DirectionMismatchError         < FormatError; end
+    class DuplicateFormatDefinitionError < FormatError; end
+    class DirectionMismatchError         < FormatError; end
 
-  ConfigError = Parser::ConfigError
+    ConfigError = Parser::ConfigError
 
-  class NoRecordElementError      < ConfigError; end
-  class IllegalRecordElementError < ConfigError; end
+    class NoRecordElementError      < ConfigError; end
+    class IllegalRecordElementError < ConfigError; end
 
   end
+
 end
 
-Dir[__FILE__.sub(/\.rb\z/, '/**/*.rb')].sort.each { |rb| require rb }
+Dir[__FILE__.sub(/\.rb\z/, '/**/*.rb')].sort.each { |rb|
+  require "athena/formats/#{File.basename(rb, '.rb')}"
+}

data/lib/athena/formats/dbm.rb

@@ -27,9 +27,9 @@
 #++
 
 require 'iconv'
+require 'athena'
 
-module Athena
-  module Formats
+module Athena::Formats
 
   class DBM < Base
 
@@ -70,5 +70,4 @@ module Athena
 
   end
 
-  end
 end

data/lib/athena/formats/ferret.rb

@@ -26,6 +26,8 @@
 ###############################################################################
 #++
 
+require 'athena'
+
 if ferret_version = ENV['FERRET_VERSION']
   require 'rubygems'
   gem 'ferret', ferret_version
@@ -37,8 +39,7 @@ rescue LoadError => err
   warn "ferret#{" #{ferret_version}" if ferret_version} not available (#{err})"
 end
 
-module Athena
-  module Formats
+module Athena::Formats
 
   class Ferret < Base
 
@@ -88,7 +89,7 @@ module Athena
         unless index.deleted?(i)
           doc = index[i]
 
-          Record.new(doc[record_element], block) { |record|
+          Athena::Record.new(doc[record_element], block) { |record|
             config.each { |element, field_config|
               record.update(element, doc[element], field_config)
             }
@@ -101,5 +102,4 @@ module Athena
 
   end
 
-  end
 end

data/lib/athena/formats/lingo.rb

@@ -28,9 +28,9 @@
 
 require 'iconv'
 require 'enumerator'
+require 'athena'
 
-module Athena
-  module Formats
+module Athena::Formats
 
   class Lingo < Base
 
@@ -127,5 +127,4 @@ module Athena
 
   end
 
-  end
 end

data/lib/athena/formats/sisis.rb

@@ -26,8 +26,9 @@
 ###############################################################################
 #++
 
-module Athena
-  module Formats
+require 'athena'
+
+module Athena::Formats
 
   class Sisis < Base
 
@@ -60,7 +61,7 @@ module Athena
 
         if element == record_element
           record.close if record
-          record = Record.new(value, block)
+          record = Athena::Record.new(value, block)
           num += 1
         else
           record.update(element, value, config[element])
@@ -74,5 +75,4 @@ module Athena
 
   end
 
-  end
 end

data/lib/athena/formats/sql.rb

@@ -27,9 +27,9 @@
 #++
 
 require 'strscan'
+require 'athena'
 
-module Athena
-  module Formats
+module Athena::Formats
 
   class MYSQL < Base
 
@@ -68,7 +68,7 @@ module Athena
             next if _columns.empty?
 
             sql_parser.parse($2) { |row|
-              Record.new(nil, block) { |record|
+              Athena::Record.new(nil, block) { |record|
                 row.each_with_index { |value, index|
                   column = _columns[index] or next
 
@@ -158,7 +158,9 @@ module Athena
       end
 
       def parse_string_escape
-        if @input.scan(/\\['\\]|''/)
+        if @input.scan(/\\[abtnvfr]/)
+          AST.new(eval(%Q{"#{@input.matched}"}))
+        elsif @input.scan(/\\.|''/)
           AST.new(@input.matched[-1, 1])
         end
       end
@@ -179,7 +181,7 @@ module Athena
         if @input.eos?
           raise "Unexpected end of input (#{message})."
         else
-          raise "#{message} at #{@input.pos}: #{@input.peek(8).inspect}"
+          raise "#{message} at #{$.}:#{@input.pos}: #{@input.peek(16).inspect}"
         end
       end
 
@@ -221,7 +223,7 @@ module Athena
             cols = columns[table]
             next if cols.empty?
 
-            Record.new(nil, block) { |record|
+            Athena::Record.new(nil, block) { |record|
               line.split(/\t/).each_with_index { |value, index|
                 column = cols[index] or next
 
@@ -245,5 +247,4 @@ module Athena
   MySQL = MYSQL
   PgSQL = PGSQL
 
-  end
 end

data/lib/athena/formats/xml.rb

@@ -27,18 +27,15 @@
 #++
 
 require 'forwardable'
-
 require 'builder'
 require 'xmlstreamin'
 require 'nuggets/hash/insert'
+require 'athena'
 
-module Athena
-  module Formats
+module Athena::Formats
 
   class XML < Base
 
-    include Util
-
     # <http://www.w3.org/TR/2006/REC-xml-20060816/#NT-Name>
     ELEMENT_START_RE    = %r{\A[a-zA-Z_:]}
     NON_ELEMENT_CHAR_RE = %r{[^\w:.-]}
@@ -104,11 +101,7 @@ module Athena
 
     def wrap(out = nil)
       res = nil
-
-      builder(:target => out).database {
-        res = super()
-      }
-
+      builder(:target => out).database { res = super() }
       res
     end
 
@@ -184,89 +177,44 @@ module Athena
         spec.default!(prev_spec)
       }
 
-      verbose(:spec, BaseSpec) { spec.inspect_spec }
-
       XMLStreamin::XMLStreamListener.new(spec)
     end
 
     def define_spec(element, field, config, arg)
       spec = ElementSpec.new(element, field, config)
-
-      case arg
-        when Hash then spec.specs!(arg)
-        else spec.default!(SubElementSpec.new(spec))
-      end
-
+      arg.is_a?(Hash) ? spec.specs!(arg) : spec.default!(SubElementSpec.new(spec))
       spec
     end
 
     def merge_specs(container, key, spec)
-      container.insert!(key => spec) { |_, s1, s2|
-        if s1.respond_to?(:specs!)
-          s1.specs!(s2.respond_to?(:specs) ? s2.specs : s2)
-          s1
+      container.insert!(key => spec) { |_, spec1, spec2|
+        if spec1.respond_to?(:specs!)
+          spec1.specs!(spec2.respond_to?(:specs) ? spec2.specs : spec2)
+          spec1
         else
-          s1.merge(s2)
+          spec1.merge(spec2)
         end
       }
     end
 
     class BaseSpec < XMLStreamin::XMLSpec
 
-      include Util
-
-      @level = 0
-
       def start(context, name, attrs)
-        verbose(:xml) {
-          spit "#{indent(level)}<#{name}>"; step :down
-          attrs.each { |attr| spit "#{indent(level + 1)}[#{attr[0]} = #{attr[1]}]" }
-        }
-
         context
       end
 
       def text(context, data)
-        verbose(:xml) { spit "#{indent(level)}#{data.strip}" unless data.strip.empty?  }
         context
       end
 
       def done(context, name)
-        verbose(:xml) { step :up; spit "#{indent(level)}</#{name}>" }
         context
       end
 
       def empty(context)
-        verbose(:xml) { step :up }
         context
       end
 
-      def inspect_spec(element = nil, level = 0)
-        if respond_to?(:field)
-          msg = "#{indent(level)}[#{element}] #{field.to_s.upcase} -> #{name}"
-          respond_to?(:spit) ? spit(msg) : warn(msg)
-
-          inspect_specs(level + 1)
-        else
-          specs.empty? ? specs.default.inspect_spec('?', level) : inspect_specs(level)
-        end
-      end
-
-      private
-
-      def inspect_specs(level = 0)
-        specs.each { |element, spec| spec.inspect_spec(element, level) }
-      end
-
-      def level
-        BaseSpec.instance_variable_get(:@level)
-      end
-
-      def step(direction)
-        steps = { :down => 1, :up => -1 }
-        BaseSpec.instance_variable_set(:@level, level + steps[direction])
-      end
-
     end
 
     class RecordSpec < BaseSpec
@@ -276,13 +224,12 @@ module Athena
 
       def initialize(&block)
         super()
-
         @block = block
       end
 
       def start(context, name, attrs)
         context = super
-        self.record = Record.new(nil, block, true)
+        self.record = Athena::Record.new(nil, block, true)
         context
       end
 
@@ -301,15 +248,12 @@ module Athena
 
       def initialize(name, field, config)
         super()
-
-        @name   = name
-        @field  = field
-        @config = config
+        @name, @field, @config = name, field, config
       end
 
       def start(context, name, attrs)
         context = super
-        self.record = Record[field, config]
+        self.record = Athena::Record[field, config]
         context
       end
 
@@ -330,9 +274,7 @@ module Athena
 
       def initialize(parent)
         super()
-
         @parent = parent
-
         default!(self)
       end
 
@@ -340,5 +282,4 @@ module Athena
 
   end
 
-  end
 end

data/lib/athena/parser.rb

@@ -26,65 +26,65 @@
 ###############################################################################
 #++
 
-module Athena
-  class Parser
-
-  include Util
-
-  DEFAULT_SEPARATOR = ', '
-  DEFAULT_EMPTY     = '<<EMPTY>>'
-
-  attr_reader :config, :spec
-
-  def initialize(config, spec)
-    @config = build_config(config)
-    @spec   = Formats[:in, spec].new(self)
-  end
-
-  def parse(source, &block)
-    res = spec.parse(source, &block)
-    res.is_a?(Numeric) ? res : Record.records
-  end
+require 'athena'
 
-  private
-
-  def build_config(config)
-    hash = {}
+module Athena
 
-    config.each { |field, value|
-      if field.to_s =~ /\A__/
-        hash[field] = value
-      else
-        case value
-          when String, Array
-            elements, value = [*value], {}
-          when Hash
-            elements = value[:elements] || value[:element].to_a
+  class Parser
 
-            raise ArgumentError, "no elements specified for field #{field}" unless elements.is_a?(Array)
-          else
-            raise ArgumentError, "illegal value for field #{field}"
+    DEFAULT_SEPARATOR = ', '
+    DEFAULT_EMPTY     = '<<EMPTY>>'
+
+    attr_reader :config, :spec
+
+    def initialize(config, spec)
+      @config = build_config(config)
+      @spec   = Formats[:in, spec].new(self)
+    end
+
+    def parse(source, &block)
+      res = spec.parse(source, &block)
+      res.is_a?(Numeric) ? res : Record.records
+    end
+
+    private
+
+    def build_config(config)
+      hash = {}
+
+      config.each { |field, value|
+        if field.to_s =~ /\A__/
+          hash[field] = value
+        else
+          case value
+            when String, Array
+              elements, value = [*value], {}
+            when Hash
+              elements = value[:elements] || value[:element].to_a
+
+              raise ArgumentError, "no elements specified for field #{field}" unless elements.is_a?(Array)
+            else
+              raise ArgumentError, "illegal value for field #{field}"
+          end
+
+          separator = value[:separator] || DEFAULT_SEPARATOR
+
+          elements.each { |element|
+            (hash[element] ||= {})[field] = {
+              :string   => value[:string] || ['%s'] * elements.size * separator,
+              :empty    => value[:empty]  || DEFAULT_EMPTY,
+              :elements => elements
+            }
+          }
         end
+      }
 
-        separator = value[:separator] || DEFAULT_SEPARATOR
+      hash
+    end
 
-        elements.each { |element|
-          verbose(:config) { spit "#{field.to_s.upcase} -> #{element}" }
+    class ConfigError < StandardError
+    end
 
-          (hash[element] ||= {})[field] = {
-            :string   => value[:string] || ['%s'] * elements.size * separator,
-            :empty    => value[:empty]  || DEFAULT_EMPTY,
-            :elements => elements
-          }
-        }
-      end
-    }
-
-    hash
-  end
-
-  class ConfigError < StandardError
   end
 
-  end
 end

data/lib/athena/record.rb

@@ -27,80 +27,74 @@
 #++
 
 require 'nuggets/integer/map'
+require 'athena'
 
 module Athena
+
   class Record
 
-  include Util
+    @records = []
 
-  @records = []
+    class << self
 
-  class << self
+      def records
+        @records
+      end
 
-    def records
-      @records
-    end
+      def [](field = nil, config = nil)
+        record = records.last
+        raise NoRecordError unless record
 
-    def [](field = nil, config = nil)
-      record = records.last
-      raise NoRecordError unless record
+        record.fill(field, config) if field && config
+        record
+      end
 
-      record.fill(field, config) if field && config
-      record
     end
 
-  end
-
-  attr_reader :struct, :block, :id
+    attr_reader :struct, :block, :id
 
-  def initialize(id = nil, block = nil, add = !block)
-    @id     = id || object_id.map_positive
-    @block  = block
-    @struct = {}
+    def initialize(id = nil, block = nil, add = !block)
+      @id     = id || object_id.map_positive
+      @block  = block
+      @struct = {}
 
-    add_record if add
+      add_record if add
 
-    if block_given?
-      begin
-        yield self
-      ensure
-        close
+      if block_given?
+        begin
+          yield self
+        ensure
+          close
+        end
       end
     end
-  end
 
-  def fill(field, config)
-    struct[field] ||= config.merge(:values => Hash.new { |h, k| h[k] = [] })
-  end
-
-  def update(element, data, field_config = nil)
-    field_config.each { |field, config| fill(field, config) } if field_config
+    def fill(field, config)
+      struct[field] ||= config.merge(:values => Hash.new { |h, k| h[k] = [] })
+    end
 
-    struct.each_key { |field|
-      verbose(:data) {
-        spit "#{field.to_s.upcase}[#{element}] << #{data.strip}" unless data.strip.empty?
-      }
+    def update(element, data, field_config = nil)
+      field_config.each { |field, config| fill(field, config) } if field_config
+      struct.each_key { |field| struct[field][:values][element] << data }
+    end
 
-      struct[field][:values][element] << data
-    }
-  end
+    def close
+      block ? block[self] : self
+    end
 
-  def close
-    block ? block[self] : self
-  end
+    def to(format)
+      Formats[:out, format].convert(self)
+    end
 
-  def to(format)
-    Formats[:out, format].convert(self)
-  end
+    private
 
-  private
+    def add_record
+      self.class.records << self
+    end
 
-  def add_record
-    self.class.records << self
-  end
+    class NoRecordError < StandardError
+    end
 
-  class NoRecordError < StandardError
   end
 
-  end
 end

data/lib/athena/version.rb

@@ -3,8 +3,8 @@ module Athena
   module Version
 
     MAJOR = 0
-    MINOR = 1
-    TINY  = 5
+    MINOR = 2
+    TINY  = 1
 
     class << self
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: athena
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 21
   prerelease: 
   segments: 
   - 0
+  - 2
   - 1
-  - 5
-  version: 0.1.5
+  version: 0.2.1
 platform: ruby
 authors: 
 - Jens Wille
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-12 00:00:00 Z
+date: 2011-07-27 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: builder
@@ -53,12 +53,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 15
+        hash: 11
         segments: 
         - 0
-        - 6
+        - 7
         - 4
-        version: 0.6.4
+        version: 0.7.4
   type: :runtime
   version_requirements: *id003
 description: Convert database files to various formats.
@@ -72,8 +72,8 @@ extra_rdoc_files:
 - COPYING
 - ChangeLog
 files: 
-- lib/athena/util.rb
 - lib/athena/record.rb
+- lib/athena/cli.rb
 - lib/athena/formats/xml.rb
 - lib/athena/formats/lingo.rb
 - lib/athena/formats/ferret.rb
@@ -99,14 +99,14 @@ licenses: []
 
 post_install_message: 
 rdoc_options: 
+- --all
+- --main
+- README
 - --charset
 - UTF-8
 - --title
-- athena Application documentation (v0.1.5)
-- --main
-- README
+- athena Application documentation (v0.2.1)
 - --line-numbers
-- --all
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -130,7 +130,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: prometheus
-rubygems_version: 1.8.5
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: Convert database files to various formats.

data/lib/athena/util.rb

@@ -1,49 +0,0 @@
-#--
-###############################################################################
-#                                                                             #
-# A component of athena, the database file converter.                         #
-#                                                                             #
-# Copyright (C) 2007-2011 University of Cologne,                              #
-#                         Albertus-Magnus-Platz,                              #
-#                         50923 Cologne, Germany                              #
-#                                                                             #
-# Authors:                                                                    #
-#     Jens Wille <jens.wille@uni-koeln.de>                                    #
-#                                                                             #
-# athena is free software; you can redistribute it and/or modify it under the #
-# terms of the GNU Affero General Public License as published by the Free     #
-# Software Foundation; either version 3 of the License, or (at your option)   #
-# any later version.                                                          #
-#                                                                             #
-# athena is distributed in the hope that it will be useful, but WITHOUT ANY   #
-# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
-# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for     #
-# more details.                                                               #
-#                                                                             #
-# You should have received a copy of the GNU Affero General Public License    #
-# along with athena. If not, see <http://www.gnu.org/licenses/>.              #
-#                                                                             #
-###############################################################################
-#++
-
-module Athena
-  module Util
-
-  extend self
-
-  def verbose(what, klass = self.class, &block)
-    if $Verbose && $Verbose[what]
-      klass.send(:define_method, :spit) { |msg|
-        warn "*#{what}: #{msg}"
-      }
-
-      klass.send(:define_method, :indent) { |*level|
-        '  ' * (level.first || 0)
-      }
-
-      instance_eval(&block)
-    end
-  end
-
-  end
-end