athena 0.0.9 → 0.1.0

data/README

@@ -2,7 +2,7 @@
 
 == VERSION
 
-This documentation refers to athena version 0.0.9
+This documentation refers to athena version 0.1.0
 
 
 == DESCRIPTION

data/bin/athena

@@ -77,12 +77,10 @@ OptionParser.new { |opts|
   }
 
   opts.on('-L', '--list-specs', "List available input formats (specs) and exit") {
-    puts "Available input formats (specs):"
+    puts 'Available input formats (specs):'
 
-    formats = Athena.input_formats
-    max     = formats.map { |a, _| a.length }.max
-    formats.each { |f, k|
-      puts "  - %-#{max}s = %s" % [f, k]
+    Athena.input_formats.each { |f, k|
+      puts "  - #{f}#{" (= #{k})" if f != k.to_s}"
     }
 
     exit 0
@@ -101,12 +99,10 @@ OptionParser.new { |opts|
   }
 
   opts.on('-l', '--list-formats', "List available output formats and exit") {
-    puts "Available output formats:"
+    puts 'Available output formats:'
 
-    formats = Athena.output_formats
-    max     = formats.map { |a, _| a.length }.max
-    formats.each { |f, k|
-      puts "  - %-#{max}s = %s" % [f, k]
+    Athena.output_formats.each { |f, k|
+      puts "  - #{f}#{" (= #{k})" if f != k.to_s}"
     }
 
     exit 0
@@ -173,8 +169,10 @@ if Athena.deferred_output?(format)
     options[:output].puts line
   }
 else
-  res = parser.parse(options[:input]) { |record|
-    options[:output].puts record.to(format)
+  res = Athena.with_format(format) { |_format|
+    parser.parse(options[:input]) { |record|
+      options[:output].puts record.to(_format)
+    }
   }
 end
 

data/lib/athena.rb

@@ -30,9 +30,9 @@
 # output formats. It's accompanied by a corresponding script that gives access
 # to all its converting features.
 #
-# In order to support additional input and/or output formats, Athena::Formats
-# needs to be sub-classed and, respectively, an instance method _parse_ or a
-# class method _convert_ supplied. This way, a specific format can even function
+# In order to support additional input and/or output formats, Athena::Formats::Base
+# needs to be sub-classed and, respectively, an instance method _parse_ or an
+# instance method _convert_ supplied. This way, a specific format can even function
 # as both input and output format.
 
 module Athena
@@ -53,23 +53,27 @@ module Athena
   end
 
   def input_formats
-    Formats.formats[:in].sort
+    Formats::Base.formats[:in].sort
   end
 
   def valid_input_format?(format)
-    Formats.valid_format?(:in, format)
+    Formats::Base.valid_format?(:in, format)
   end
 
   def output_formats
-    Formats.formats[:out].sort
+    Formats::Base.formats[:out].sort
   end
 
   def valid_output_format?(format)
-    Formats.valid_format?(:out, format)
+    Formats::Base.valid_format?(:out, format)
   end
 
   def deferred_output?(format)
     Formats[:out, format].deferred?
   end
 
+  def with_format(format, &block)
+    Formats[:out, format].wrap(&block)
+  end
+
 end

data/lib/athena/formats.rb

@@ -3,7 +3,7 @@
 #                                                                             #
 # A component of athena, the database file converter.                         #
 #                                                                             #
-# Copyright (C) 2007-2008 University of Cologne,                              #
+# Copyright (C) 2007-2009 University of Cologne,                              #
 #                         Albertus-Magnus-Platz,                              #
 #                         50932 Cologne, Germany                              #
 #                                                                             #
@@ -26,56 +26,99 @@
 ###############################################################################
 #++
 
-class Athena::Formats
+module Athena::Formats
+
+  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
+        Base.formats[direction][format].new
+      end
+    else
+      Base.formats[direction][format]
+    end
+  end
 
-  @formats = { :in => {}, :out => {} }
+  class Base
 
-  class << self
+    @formats = { :in => {}, :out => {} }
 
-    def formats
-      Athena::Formats.instance_variable_get(:@formats)
-    end
+    class << self
 
-    def [](direction, format)
-      formats[direction][format]
-    end
+      def formats
+        Base.instance_variable_get(:@formats)
+      end
 
-    def valid_format?(direction, format)
-      formats[direction].has_key?(format)
-    end
+      def valid_format?(direction, format)
+        if format.class < Base
+          direction == format.class.direction
+        else
+          formats[direction].has_key?(format)
+        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
+
+        register_format!(direction, format, *aliases, &block)
+      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
 
-    def deferred?
-      false
     end
 
-    def convert(*args)
+    def parse(*args)
       raise NotImplementedError, 'must be defined by sub-class'
     end
 
-    private
-
-    def register_format(direction, format)
-      if existing = formats[direction][format]
-        raise DuplicateFormatDefinitionError,
-          "format already defined (#{direction}): #{format} = #{existing}"
-      end
+    def convert(record)
+      raise NotImplementedError, 'must be defined by sub-class'
+    end
 
-      formats[direction][format] = self
+    def wrap
+      yield self
     end
 
-    def register_formats(direction, *formats)
-      formats.each { |format|
-        register_format(direction, format)
-      }
+    def deferred?
+      false
     end
 
   end
 
-  def parse(*args)
-    raise NotImplementedError, 'must be defined by sub-class'
+  class DuplicateFormatDefinitionError < StandardError
   end
 
-  class DuplicateFormatDefinitionError < StandardError
+  class DirectionMismatchError < ArgumentError
   end
 
   class FormatArgumentError < ArgumentError
@@ -83,6 +126,4 @@ class Athena::Formats
 
 end
 
-Dir[__FILE__.sub(/\.rb$/, '/**/*.rb')].each { |rb|
-  require rb
-}
+Dir[__FILE__.sub(/\.rb\z/, '/**/*.rb')].sort.each { |rb| require rb }

data/lib/athena/formats/dbm.rb

@@ -28,11 +28,9 @@
 
 require 'iconv'
 
-class Athena::Formats
+module Athena::Formats
 
-  class DBM < Athena::Formats
-
-    register_formats :out, 'dbm', 'midos'
+  class DBM < Base
 
     CRLF = "\015\012"
 
@@ -41,7 +39,9 @@ class Athena::Formats
     VALUE_SEPARATOR  = '|'
     RECORD_SEPARATOR = '&&&'
 
-    def self.convert(record)
+    register_format :out, 'midos'
+
+    def convert(record)
       dbm = ["ID:#{record.id}"]
 
       record.struct.each { |field, struct|

data/lib/athena/formats/ferret.rb

@@ -31,31 +31,33 @@ require 'rubygems'
 gem 'ferret', ENV['FERRET_VERSION'] if ENV['FERRET_VERSION']
 require 'ferret'
 
-class Athena::Formats
+module Athena::Formats
 
-  class Ferret < Athena::Formats
+  class Ferret < Base
 
-    register_format :in, 'ferret'
+    register_format :in do
 
-    attr_reader :record_element, :config, :parser, :match_all_query
+      attr_reader :record_element, :config, :parser, :match_all_query
 
-    def initialize(parser)
-      config = parser.config.dup
+      def initialize(parser)
+        config = parser.config.dup
 
-      case @record_element = config.delete(:__record_element)
-        when String
-          # fine!
-        when nil
-          raise NoRecordElementError, 'no record element specified'
-        else
-          raise IllegalRecordElementError, "illegal record element #{@record_element.inspect}"
+        case @record_element = config.delete(:__record_element)
+          when String
+            # fine!
+          when nil
+            raise NoRecordElementError, 'no record element specified'
+          else
+            raise IllegalRecordElementError, "illegal record element #{@record_element.inspect}"
+        end
+
+        @config = config
+        @parser = parser
       end
 
-      @config = config
-      @parser = parser
     end
 
-    def parse(source)
+    def parse(source, &block)
       path = source.path
 
       # make sure the index can be opened
@@ -82,7 +84,7 @@ class Athena::Formats
         unless index.deleted?(i)
           doc = index[i]
 
-          Athena::Record.new(parser.block, doc[record_element]) { |record|
+          Athena::Record.new(doc[record_element], block) { |record|
             config.each { |element, field_config|
               record.update(element, doc[element], field_config)
             }

data/lib/athena/formats/lingo.rb

@@ -29,68 +29,56 @@
 require 'iconv'
 require 'enumerator'
 
-class Athena::Formats
-
-  module Lingo
-
-    class Base < Athena::Formats
-
-      class << self
-
-        def convert(record)
-          record.struct.inject([]) { |terms, (field, struct)|
-            terms << struct[:elements].inject([]) { |array, element|
-              array += (struct[:values][element] || []).map { |v|
-                (v || '').strip.gsub(/(?:\r?\n)+/, ' ')
-              }.reject { |v| v.empty? }
-            }
-          }
-        end
-
-        def deferred?
-          true
-        end
-
-        private
+module Athena::Formats
+
+  class Lingo < Base
+
+    def convert(record)
+      record.struct.inject([]) { |terms, (field, struct)|
+        terms << struct[:elements].inject([]) { |array, element|
+          array += (struct[:values][element] || []).map { |v|
+            (v || '').strip.gsub(/(?:\r?\n)+/, ' ')
+          }.reject { |v| v.empty? }
+        }
+      }
+    end
 
-        def check_number_of_arguments(expected, actual, blow = false, &block)
-          return true if block ? block[actual] : expected == actual
+    def deferred?
+      true
+    end
 
-          msg = "wrong number of arguments for #{self} (#{actual} for #{expected})"
+    private
 
-          if blow
-            raise FormatArgumentError, msg
-          else
-            warn msg
-            return false
-          end
-        end
+    def check_number_of_arguments(expected, actual, blow = false, &block)
+      return true if block ? block[actual] : expected == actual
 
-        def check_number_of_arguments!(expected, actual, &block)
-          check_number_of_arguments(expected, actual, true, &block)
-        end
+      msg = "wrong number of arguments for #{self} (#{actual} for #{expected})"
 
+      if blow
+        raise FormatArgumentError, msg
+      else
+        warn msg
+        return false
       end
+    end
 
+    def check_number_of_arguments!(expected, actual, &block)
+      check_number_of_arguments(expected, actual, true, &block)
     end
 
     # "Nasenbär\n"
-    class SingleWord < Athena::Formats::Lingo::Base
-
-      register_formats :out, 'lingo/single_word'
+    register_format! :out, 'lingo/single_word' do
 
-      def self.convert(record)
+      def convert(record)
         super.flatten
       end
 
     end
 
     # "John Vorhauer*Vorhauer, John\n"
-    class KeyValue < Athena::Formats::Lingo::Base
+    register_format! :out, 'lingo/key_value' do
 
-      register_formats :out, 'lingo/key_value'
-
-      def self.convert(record)
+      def convert(record)
         super.map { |terms|
           next unless check_number_of_arguments(2, terms.size)
 
@@ -101,11 +89,9 @@ class Athena::Formats
     end
 
     # "Essen,essen #v Essen #s Esse #s\n"
-    class WordClass < Athena::Formats::Lingo::Base
-
-      register_formats :out, 'lingo/word_class'
+    register_format! :out, 'lingo/word_class' do
 
-      def self.convert(record)
+      def convert(record)
         super.map { |terms|
           next unless check_number_of_arguments('odd, > 1', terms.size) { |actual|
             actual > 1 && actual % 2 == 1
@@ -120,11 +106,9 @@ class Athena::Formats
     end
 
     # "Fax;Faxkopie;Telefax\n"
-    class MultiValue < Athena::Formats::Lingo::Base
-
-      register_formats :out, 'lingo/multi_value', 'lingo/multi_key'
+    register_format! :out, 'lingo/multi_value', 'lingo/multi_key' do
 
-      def self.convert(record)
+      def convert(record)
         super.map { |terms|
           next unless check_number_of_arguments('> 1', terms.size) { |actual|
             actual > 1

data/lib/athena/formats/sisis.rb

@@ -26,31 +26,33 @@
 ###############################################################################
 #++
 
-class Athena::Formats
+module Athena::Formats
 
-  class Sisis < Athena::Formats
+  class Sisis < Base
 
-    register_format :in, 'sisis'
+    register_format :in do
 
-    attr_reader :record_element, :config, :parser
+      attr_reader :record_element, :config, :parser
 
-    def initialize(parser)
-      config = parser.config.dup
+      def initialize(parser)
+        config = parser.config.dup
 
-      case @record_element = config.delete(:__record_element)
-        when String
-          # fine!
-        when nil
-          raise NoRecordElementError, 'no record element specified'
-        else
-          raise IllegalRecordElementError, "illegal record element #{@record_element.inspect}"
+        case @record_element = config.delete(:__record_element)
+          when String
+            # fine!
+          when nil
+            raise NoRecordElementError, 'no record element specified'
+          else
+            raise IllegalRecordElementError, "illegal record element #{@record_element.inspect}"
+        end
+
+        @config = config
+        @parser = parser
       end
 
-      @config = config
-      @parser = parser
     end
 
-    def parse(source)
+    def parse(source, &block)
       record, num = nil, 0
 
       source.each { |line|
@@ -59,7 +61,7 @@ class Athena::Formats
         case element
           when record_element
             record.close if record
-            record = Athena::Record.new(parser.block, value)
+            record = Athena::Record.new(value, block)
             num += 1
           else
             record.update(element, value, config[element])

data/lib/athena/formats/xml.rb

@@ -33,40 +33,47 @@ require 'rubygems'
 require 'xmlstreamin'
 require 'nuggets/hash/insert'
 
-class Athena::Formats
+module Athena::Formats
 
-  class XML < Athena::Formats
+  class XML < Base
 
     include Athena::Util
 
-    register_format :in, 'xml'
+    register_format :in do
 
-    attr_reader :spec, :listener
+      attr_reader :specs, :record_element
+
+      def initialize(parser)
+        @specs = setup_specs(parser.config.dup)
+      end
 
-    def initialize(parser)
-      @spec     = build_spec(parser)
-      @listener = XMLStreamin::XMLStreamListener.new(@spec)
     end
 
-    def parse(source)
-      REXML::Document.parse_stream(source, listener)
+    def parse(source, &block)
+      REXML::Document.parse_stream(source, listener(&block))
     end
 
-    private
+=begin
+    register_format :out
+
+    def convert(record)
+      # ...
+    end
+=end
 
-    def build_spec(parser)
-      config = parser.config.dup
+    private
 
-      case record_element = config.delete(:__record_element)
+    def setup_specs(config)
+      case @record_element = config.delete(:__record_element)
         when String
           # fine!
         when nil
           raise NoRecordElementError, 'no record element specified'
         else
-          raise IllegalRecordElementError, "illegal record element #{record_element.inspect}"
+          raise IllegalRecordElementError, "illegal record element #{@record_element.inspect}"
       end
 
-      element_specs = config.inject({}) { |specs, (element, element_spec)|
+      config.inject({}) { |specs, (element, element_spec)|
         element_spec.each { |field, c|
           element.split('/').reverse.inject({}) { |hash, part|
             s = define_spec(element, field, c, hash.empty? ? :default : hash)
@@ -78,9 +85,11 @@ class Athena::Formats
 
         specs
       }
+    end
 
-      record_spec = RecordSpec.new(parser)
-      record_spec.specs!(element_specs)
+    def listener(&block)
+      record_spec = RecordSpec.new(&block)
+      record_spec.specs!(specs)
 
       root_spec   = BaseSpec.new
       root_spec.specs!(record_element => record_spec)
@@ -92,7 +101,7 @@ class Athena::Formats
         spec.inspect_spec
       end
 
-      spec
+      XMLStreamin::XMLStreamListener.new(spec)
     end
 
     def define_spec(element, field, config, arg)
@@ -197,19 +206,19 @@ class Athena::Formats
 
     class RecordSpec < BaseSpec
 
-      attr_reader   :parser
+      attr_reader   :block
       attr_accessor :record
 
-      def initialize(parser)
+      def initialize(&block)
         super()
 
-        @parser = parser
+        @block  = block
       end
 
       def start(context, name, attrs)
         super
 
-        self.record = Athena::Record.new(parser.block, nil, true)
+        self.record = Athena::Record.new(nil, block, true)
       end
 
       def done(context, name)

data/lib/athena/parser.rb

@@ -33,8 +33,7 @@ class Athena::Parser
   DEFAULT_SEPARATOR = ', '
   DEFAULT_EMPTY     = '<<EMPTY>>'
 
-  attr_reader   :config, :spec
-  attr_accessor :block
+  attr_reader :config, :spec
 
   def initialize(config, spec)
     @config = build_config(config)
@@ -42,9 +41,7 @@ class Athena::Parser
   end
 
   def parse(source, &block)
-    self.block = block
-
-    res = spec.parse(source)
+    res = spec.parse(source, &block)
     res.is_a?(Numeric) ? res : Athena::Record.records
   end
 

data/lib/athena/record.rb

@@ -50,10 +50,10 @@ class Athena::Record
 
   attr_reader :struct, :block, :id
 
-  def initialize(block, id = nil, _add_record = !block)
-    @struct = {}
-    @block  = block
+  def initialize(id = nil, block = nil, _add_record = !block)
     @id     = id || object_id.abs
+    @block  = block
+    @struct = {}
 
     add_record if _add_record
 

data/lib/athena/version.rb

@@ -29,8 +29,8 @@
 module Athena::Version
 
   MAJOR = 0
-  MINOR = 0
-  TINY  = 9
+  MINOR = 1
+  TINY  = 0
 
   class << self
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: athena
 version: !ruby/object:Gem::Version 
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors: 
 - Jens Wille
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-21 00:00:00 +02:00
+date: 2009-08-24 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -68,15 +68,15 @@ licenses: []
 
 post_install_message: 
 rdoc_options: 
+- --line-numbers
 - --main
 - README
-- --line-numbers
 - --inline-source
 - --title
 - athena Application documentation
-- --all
 - --charset
 - UTF-8
+- --all
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement