athena 0.0.2.56 → 0.0.3.58

data/lib/athena/formats/sisis.rb

@@ -3,9 +3,9 @@
 #                                                                             #
 # A component of athena, the database file converter.                         #
 #                                                                             #
-# Copyright (C) 2007 University of Cologne,                                   #
-#                    Albertus-Magnus-Platz,                                   #
-#                    50932 Cologne, Germany                                   #
+# Copyright (C) 2007-2008 University of Cologne,                              #
+#                         Albertus-Magnus-Platz,                              #
+#                         50932 Cologne, Germany                              #
 #                                                                             #
 # Authors:                                                                    #
 #     Jens Wille <jens.wille@uni-koeln.de>                                    #
@@ -26,56 +26,52 @@
 ###############################################################################
 #++
 
-module Athena
+class Athena::Formats
 
-  class Formats
+  class Sisis < Athena::Formats
 
-    class Sisis < Athena::Formats
+    register_format :in, 'sisis'
 
-      register_format :in, 'sisis'
+    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}"
-        end
-
-        @config = config
-        @parser = parser
+      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
 
-      def parse(source)
-        record = nil
+      @config = config
+      @parser = parser
+    end
 
-        source.each { |line|
-          element, value = line.match(/(\d+).*?:\s*(.*)/)[1, 2]
+    def parse(source)
+      record = nil
 
-          case element
-            when record_element
-              record.close if record
-              record = Athena::Record.new(parser.block, value)
-            else
-              record.update(element, value, config[element])
-          end
-        }
+      source.each { |line|
+        element, value = line.match(/(\d+).*?:\s*(.*)/)[1, 2]
 
-        record.close if record
-      end
+        case element
+          when record_element
+            record.close if record
+            record = Athena::Record.new(parser.block, value)
+          else
+            record.update(element, value, config[element])
+        end
+      }
 
-      class NoRecordElementError < StandardError
-      end
+      record.close if record
+    end
 
-      class IllegalRecordElementError < StandardError
-      end
+    class NoRecordElementError < StandardError
+    end
 
+    class IllegalRecordElementError < StandardError
     end
 
   end

data/lib/athena/formats/xml.rb

@@ -3,9 +3,9 @@
 #                                                                             #
 # A component of athena, the database file converter.                         #
 #                                                                             #
-# Copyright (C) 2007 University of Cologne,                                   #
-#                    Albertus-Magnus-Platz,                                   #
-#                    50932 Cologne, Germany                                   #
+# Copyright (C) 2007-2008 University of Cologne,                              #
+#                         Albertus-Magnus-Platz,                              #
+#                         50932 Cologne, Germany                              #
 #                                                                             #
 # Authors:                                                                    #
 #     Jens Wille <jens.wille@uni-koeln.de>                                    #
@@ -33,244 +33,240 @@ require 'rubygems'
 require 'xmlstreamin'
 require 'nuggets/hash/insert'
 
-module Athena
+class Athena::Formats
 
-  class Formats
+  class XML < Athena::Formats
 
-    class XML < Athena::Formats
+    include Athena::Util
 
-      include Util
+    register_format :in, 'xml'
 
-      register_format :in, 'xml'
+    attr_reader :spec, :listener
 
-      attr_reader :spec, :listener
-
-      def initialize(parser)
-        @spec     = build_spec(parser)
-        @listener = XMLStreamin::XMLStreamListener.new(@spec)
-      end
+    def initialize(parser)
+      @spec     = build_spec(parser)
+      @listener = XMLStreamin::XMLStreamListener.new(@spec)
+    end
 
-      def parse(source)
-        REXML::Document.parse_stream(source, listener)
-      end
+    def parse(source)
+      REXML::Document.parse_stream(source, listener)
+    end
 
-      private
+    private
 
-      def build_spec(parser)
-        config = parser.config.dup
+    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
+      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)
-            }
+      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)
+        specs
+      }
 
-        root_spec   = BaseSpec.new
-        root_spec.specs!(record_element => record_spec)
+      record_spec = RecordSpec.new(parser)
+      record_spec.specs!(element_specs)
 
-        spec        = BaseSpec.new
-        spec.default!(root_spec)
+      root_spec   = BaseSpec.new
+      root_spec.specs!(record_element => record_spec)
 
-        verbose(:spec, BaseSpec) do
-          spec.inspect_spec
-        end
+      spec        = BaseSpec.new
+      spec.default!(root_spec)
 
-        spec
+      verbose(:spec, BaseSpec) do
+        spec.inspect_spec
       end
 
-      def define_spec(element, field, config, arg)
-        spec = ElementSpec.new(element, field, config)
+      spec
+    end
 
-        case arg
-          when Hash
-            spec.specs!(arg)
-          else
-            spec.default!(SubElementSpec.new(spec))
-        end
+    def define_spec(element, field, config, arg)
+      spec = ElementSpec.new(element, field, config)
 
-        spec
+      case arg
+        when Hash
+          spec.specs!(arg)
+        else
+          spec.default!(SubElementSpec.new(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
+      spec
+    end
 
-      class BaseSpec < XMLStreamin::XMLSpec
+    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
 
-        include Util
+    class BaseSpec < XMLStreamin::XMLSpec
 
-        @level = 0
+      include Athena::Util
 
-        def start(context, name, attrs)
-          verbose(:xml) do
-            spit "#{indent(level)}<#{name}>"
-            step :down
+      @level = 0
 
-            attrs.each { |attr|
-              spit "#{indent(level + 1)}[#{attr[0]} = #{attr[1]}]"
-            }
-          end
+      def start(context, name, attrs)
+        verbose(:xml) do
+          spit "#{indent(level)}<#{name}>"
+          step :down
 
-          return context
+          attrs.each { |attr|
+            spit "#{indent(level + 1)}[#{attr[0]} = #{attr[1]}]"
+          }
         end
 
-        def text(context, data)
-          verbose(:xml) do
-            content = data.strip
-            spit "#{indent(level)}#{content}" unless content.empty?
-          end
+        return context
+      end
 
-          return context
+      def text(context, data)
+        verbose(:xml) do
+          content = data.strip
+          spit "#{indent(level)}#{content}" unless content.empty?
         end
 
-        def done(context, name)
-          verbose(:xml) do
-            step :up
-            spit "#{indent(level)}</#{name}>"
-          end
+        return context
+      end
 
-          return context
+      def done(context, name)
+        verbose(:xml) do
+          step :up
+          spit "#{indent(level)}</#{name}>"
         end
 
-        def empty(context)
-          verbose(:xml) do
-            step :up
-          end
+        return context
+      end
 
-          return context
+      def empty(context)
+        verbose(:xml) do
+          step :up
         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)
+        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 + 1)
+              s.inspect_spec(e, level)
             }
-          else
-            if specs.empty?
-              specs.default.inspect_spec('?', level)
-            else
-              specs.each { |e, s|
-                s.inspect_spec(e, level)
-              }
-            end
           end
         end
+      end
 
-        private
-
-        def level
-          BaseSpec.instance_variable_get(:@level)
-        end
+      private
 
-        def step(direction)
-          steps = { :down => 1, :up => -1 }
-          BaseSpec.instance_variable_set(:@level, level + steps[direction])
-        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
 
-      class RecordSpec < BaseSpec
+    end
 
-        attr_reader   :parser
-        attr_accessor :record
+    class RecordSpec < BaseSpec
 
-        def initialize(parser)
-          super()
+      attr_reader   :parser
+      attr_accessor :record
 
-          @parser = parser
-        end
+      def initialize(parser)
+        super()
 
-        def start(context, name, attrs)
-          super
+        @parser = parser
+      end
 
-          self.record = Athena::Record.new(parser.block)
-        end
+      def start(context, name, attrs)
+        super
 
-        def done(context, name)
-          super
+        self.record = Athena::Record.new(parser.block)
+      end
 
-          record.close
-        end
+      def done(context, name)
+        super
 
+        record.close
       end
 
-      class ElementSpec < BaseSpec
+    end
 
-        attr_reader   :name, :field, :config
-        attr_accessor :record
+    class ElementSpec < BaseSpec
 
-        def initialize(name, field, config)
-          super()
+      attr_reader   :name, :field, :config
+      attr_accessor :record
 
-          @name   = name
-          @field  = field
-          @config = config
-        end
+      def initialize(name, field, config)
+        super()
 
-        def start(context, name, attrs)
-          super
+        @name   = name
+        @field  = field
+        @config = config
+      end
 
-          self.record = Athena::Record[field, config]
-        end
+      def start(context, name, attrs)
+        super
 
-        def text(context, data)
-          super
+        self.record = Athena::Record[field, config]
+      end
 
-          record.update(name, data)
-        end
+      def text(context, data)
+        super
 
+        record.update(name, data)
       end
 
-      class SubElementSpec < BaseSpec
+    end
 
-        extend Forwardable
+    class SubElementSpec < BaseSpec
 
-        # Forward to parent element; need to specify *all* its attributes and methods
-        def_delegators :@parent, :name, :field, :config, :record, :start, :text
+      extend Forwardable
 
-        def initialize(parent)
-          super()
+      # Forward to parent element; need to specify *all* its attributes and methods
+      def_delegators :@parent, :name, :field, :config, :record, :start, :text
 
-          @parent = parent
-          default!(self)
-        end
+      def initialize(parent)
+        super()
 
+        @parent = parent
+        default!(self)
       end
 
-      class NoRecordElementError < StandardError
-      end
+    end
 
-      class IllegalRecordElementError < StandardError
-      end
+    class NoRecordElementError < StandardError
+    end
 
+    class IllegalRecordElementError < StandardError
     end
 
   end