blackwinter-athena 0.0.6

data/lib/athena/formats/lingo.rb

@@ -0,0 +1,141 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of athena, the database file converter.                         #
+#                                                                             #
+# Copyright (C) 2007-2008 University of Cologne,                              #
+#                         Albertus-Magnus-Platz,                              #
+#                         50932 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 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 General Public License for more       #
+# details.                                                                    #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with athena. If not, see <http://www.gnu.org/licenses/>.                    #
+#                                                                             #
+###############################################################################
+#++
+
+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
+
+        def check_number_of_arguments(expected, actual, blow = false, &block)
+          return true if block ? block[actual] : expected == actual
+
+          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
+
+      end
+
+    end
+
+    # "Nasenbär\n"
+    class SingleWord < Athena::Formats::Lingo::Base
+
+      register_formats :out, 'lingo/single_word'
+
+      def self.convert(record)
+        super.flatten
+      end
+
+    end
+
+    # "John Vorhauer*Vorhauer, John\n"
+    class KeyValue < Athena::Formats::Lingo::Base
+
+      register_formats :out, 'lingo/key_value'
+
+      def self.convert(record)
+        super.map { |terms|
+          next unless check_number_of_arguments(2, terms.size)
+
+          terms.join('*')
+        }.compact
+      end
+
+    end
+
+    # "Essen,essen #v Essen #s Esse #s\n"
+    class WordClass < Athena::Formats::Lingo::Base
+
+      register_formats :out, 'lingo/word_class'
+
+      def self.convert(record)
+        super.map { |terms|
+          next unless check_number_of_arguments('odd, > 1', terms.size) { |actual|
+            actual > 1 && actual % 2 == 1
+          }
+
+          [terms.shift, terms.to_enum(:each_slice, 2).map { |form, wc|
+            "#{form} ##{wc}"
+          }.join(' ')].join(',')
+        }.compact
+      end
+
+    end
+
+    # "Fax;Faxkopie;Telefax\n"
+    class MultiValue < Athena::Formats::Lingo::Base
+
+      register_formats :out, 'lingo/multi_value', 'lingo/multi_key'
+
+      def self.convert(record)
+        super.map { |terms|
+          next unless check_number_of_arguments('> 1', terms.size) { |actual|
+            actual > 1
+          }
+
+          terms.join(';')
+        }.compact
+      end
+
+    end
+
+  end
+
+end

data/lib/athena/formats/sisis.rb

@@ -0,0 +1,79 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of athena, the database file converter.                         #
+#                                                                             #
+# Copyright (C) 2007-2008 University of Cologne,                              #
+#                         Albertus-Magnus-Platz,                              #
+#                         50932 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 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 General Public License for more       #
+# details.                                                                    #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with athena. If not, see <http://www.gnu.org/licenses/>.                    #
+#                                                                             #
+###############################################################################
+#++
+
+class Athena::Formats
+
+  class Sisis < Athena::Formats
+
+    register_format :in, 'sisis'
+
+    attr_reader :record_element, :config, :parser
+
+    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}"
+      end
+
+      @config = config
+      @parser = parser
+    end
+
+    def parse(source)
+      record = nil
+
+      source.each { |line|
+        element, value = line.match(/(\d+).*?:\s*(.*)/)[1, 2]
+
+        case element
+          when record_element
+            record.close if record
+            record = Athena::Record.new(parser.block, value)
+          else
+            record.update(element, value, config[element])
+        end
+      }
+
+      record.close if record
+    end
+
+    class NoRecordElementError < StandardError
+    end
+
+    class IllegalRecordElementError < StandardError
+    end
+
+  end
+
+end

data/lib/athena/formats/xml.rb

@@ -0,0 +1,274 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of athena, the database file converter.                         #
+#                                                                             #
+# Copyright (C) 2007-2008 University of Cologne,                              #
+#                         Albertus-Magnus-Platz,                              #
+#                         50932 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 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 General Public License for more       #
+# details.                                                                    #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with athena. If not, see <http://www.gnu.org/licenses/>.                    #
+#                                                                             #
+###############################################################################
+#++
+
+require 'forwardable'
+
+require 'rubygems'
+
+require 'xmlstreamin'
+require 'nuggets/hash/insert'
+
+class Athena::Formats
+
+  class XML < Athena::Formats
+
+    include Athena::Util
+
+    register_format :in, 'xml'
+
+    attr_reader :spec, :listener
+
+    def initialize(parser)
+      @spec     = build_spec(parser)
+      @listener = XMLStreamin::XMLStreamListener.new(@spec)
+    end
+
+    def parse(source)
+      REXML::Document.parse_stream(source, listener)
+    end
+
+    private
+
+    def build_spec(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}"
+      end
+
+      element_specs = 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)
+            merge_specs(hash, part, s)
+          }.each { |key, s|
+            merge_specs(specs, key, s)
+          }
+        }
+
+        specs
+      }
+
+      record_spec = RecordSpec.new(parser)
+      record_spec.specs!(element_specs)
+
+      root_spec   = BaseSpec.new
+      root_spec.specs!(record_element => record_spec)
+
+      spec        = BaseSpec.new
+      spec.default!(root_spec)
+
+      verbose(:spec, BaseSpec) do
+        spec.inspect_spec
+      end
+
+      spec
+    end
+
+    def define_spec(element, field, config, arg)
+      spec = ElementSpec.new(element, field, config)
+
+      case arg
+        when Hash
+          spec.specs!(arg)
+        else
+          spec.default!(SubElementSpec.new(spec))
+      end
+
+      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
+        else
+          s1.merge(s2)
+        end
+      }
+    end
+
+    class BaseSpec < XMLStreamin::XMLSpec
+
+      include Athena::Util
+
+      @level = 0
+
+      def start(context, name, attrs)
+        verbose(:xml) do
+          spit "#{indent(level)}<#{name}>"
+          step :down
+
+          attrs.each { |attr|
+            spit "#{indent(level + 1)}[#{attr[0]} = #{attr[1]}]"
+          }
+        end
+
+        return context
+      end
+
+      def text(context, data)
+        verbose(:xml) do
+          content = data.strip
+          spit "#{indent(level)}#{content}" unless content.empty?
+        end
+
+        return context
+      end
+
+      def done(context, name)
+        verbose(:xml) do
+          step :up
+          spit "#{indent(level)}</#{name}>"
+        end
+
+        return context
+      end
+
+      def empty(context)
+        verbose(:xml) do
+          step :up
+        end
+
+        return 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)
+          specs.each { |e, s|
+            s.inspect_spec(e, level + 1)
+          }
+        else
+          if specs.empty?
+            specs.default.inspect_spec('?', level)
+          else
+            specs.each { |e, s|
+              s.inspect_spec(e, level)
+            }
+          end
+        end
+      end
+
+      private
+
+      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
+
+      attr_reader   :parser
+      attr_accessor :record
+
+      def initialize(parser)
+        super()
+
+        @parser = parser
+      end
+
+      def start(context, name, attrs)
+        super
+
+        self.record = Athena::Record.new(parser.block)
+      end
+
+      def done(context, name)
+        super
+
+        record.close
+      end
+
+    end
+
+    class ElementSpec < BaseSpec
+
+      attr_reader   :name, :field, :config
+      attr_accessor :record
+
+      def initialize(name, field, config)
+        super()
+
+        @name   = name
+        @field  = field
+        @config = config
+      end
+
+      def start(context, name, attrs)
+        super
+
+        self.record = Athena::Record[field, config]
+      end
+
+      def text(context, data)
+        super
+
+        record.update(name, data)
+      end
+
+    end
+
+    class SubElementSpec < BaseSpec
+
+      extend Forwardable
+
+      # Forward to parent element; need to specify *all* its attributes and methods
+      def_delegators :@parent, :name, :field, :config, :record, :start, :text
+
+      def initialize(parent)
+        super()
+
+        @parent = parent
+        default!(self)
+      end
+
+    end
+
+    class NoRecordElementError < StandardError
+    end
+
+    class IllegalRecordElementError < StandardError
+    end
+
+  end
+
+end

data/lib/athena/formats.rb

@@ -0,0 +1,88 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of athena, the database file converter.                         #
+#                                                                             #
+# Copyright (C) 2007-2008 University of Cologne,                              #
+#                         Albertus-Magnus-Platz,                              #
+#                         50932 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 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 General Public License for more       #
+# details.                                                                    #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with athena. If not, see <http://www.gnu.org/licenses/>.                    #
+#                                                                             #
+###############################################################################
+#++
+
+class Athena::Formats
+
+  @formats = { :in => {}, :out => {} }
+
+  class << self
+
+    def formats
+      Athena::Formats.instance_variable_get(:@formats)
+    end
+
+    def [](direction, format)
+      formats[direction][format]
+    end
+
+    def valid_format?(direction, format)
+      formats[direction].has_key?(format)
+    end
+
+    def deferred?
+      false
+    end
+
+    def convert(*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
+
+      formats[direction][format] = self
+    end
+
+    def register_formats(direction, *formats)
+      formats.each { |format|
+        register_format(direction, format)
+      }
+    end
+
+  end
+
+  def parse(*args)
+    raise NotImplementedError, 'must be defined by sub-class'
+  end
+
+  class DuplicateFormatDefinitionError < StandardError
+  end
+
+  class FormatArgumentError < ArgumentError
+  end
+
+end
+
+Dir[__FILE__.sub(/\.rb$/, '/**/*.rb')].each { |rb|
+  require rb
+}

data/lib/athena/parser.rb

@@ -0,0 +1,90 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of athena, the database file converter.                         #
+#                                                                             #
+# Copyright (C) 2007-2008 University of Cologne,                              #
+#                         Albertus-Magnus-Platz,                              #
+#                         50932 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 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 General Public License for more       #
+# details.                                                                    #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with athena. If not, see <http://www.gnu.org/licenses/>.                    #
+#                                                                             #
+###############################################################################
+#++
+
+class Athena::Parser
+
+  include Athena::Util
+
+  DEFAULT_SEPARATOR = ', '
+  DEFAULT_EMPTY     = '<<EMPTY>>'
+
+  attr_reader   :config, :spec
+  attr_accessor :block
+
+  def initialize(config, spec)
+    @config = build_config(config)
+    @spec   = Athena::Formats[:in, spec].new(self)
+  end
+
+  def parse(source, &block)
+    self.block = block
+
+    spec.parse(source)
+    Athena::Record.records
+  end
+
+  private
+
+  def build_config(config)
+    config.inject({}) { |hash, (field, v)|
+      if field.to_s =~ /^__/
+        hash.merge(field => v)
+      else
+        case v
+          when String, Array
+            elements = [*v]
+            v = {}
+          when Hash
+            elements = v[:elements] || v[: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 = v[:separator] || DEFAULT_SEPARATOR
+
+        elements.each { |element|
+          verbose(:config) do
+            spit "#{field.to_s.upcase} -> #{element}"
+          end
+
+          (hash[element] ||= {})[field] = {
+            :string   => v[:string] || ['%s'] * elements.size * separator,
+            :empty    => v[:empty]  || DEFAULT_EMPTY,
+            :elements => elements
+          }
+        }
+
+        hash
+      end
+    }
+  end
+
+end