athena 0.2.1 → 0.2.2

data/lib/athena/formats/dbm.rb

@@ -38,8 +38,6 @@ module Athena::Formats
 
     ICONV_TO_LATIN1 = Iconv.new('latin1//TRANSLIT//IGNORE', 'utf-8')
 
-    register_format :out, 'midos'
-
     def convert(record)
       dbm = ["ID:#{record.id}"]
 
@@ -70,4 +68,6 @@ module Athena::Formats
 
   end
 
+  Midos = DBM
+
 end

data/lib/athena/formats/ferret.rb

@@ -43,27 +43,8 @@ module Athena::Formats
 
   class Ferret < Base
 
-    register_format :in do
-
-      attr_reader :record_element, :config, :match_all_query
-
-      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}"
-        end
-      end
-
-    end if Object.const_defined?(:Ferret)
-
-    def parse(source, &block)
-      path = source.path
+    def parse(input, &block)
+      path = input.path
 
       # make sure the index can be opened
       begin
@@ -100,6 +81,8 @@ module Athena::Formats
       index.num_docs
     end
 
+    private :parse unless Object.const_defined?(:Ferret)
+
   end
 
 end

data/lib/athena/formats/lingo.rb

@@ -34,51 +34,8 @@ module Athena::Formats
 
   class Lingo < Base
 
-    KV_SEPARATOR = '*'
-    WC_SEPARATOR = ','
-    MV_SEPARATOR = ';'
-
-    def convert(record)
-      terms = []
-
-      record.struct.each { |field, struct|
-        struct_values = struct[:values]
-        struct_values.default = []
-
-        values = []
-
-        struct[:elements].each { |element|
-          struct_values[element].each { |value|
-            if value
-              value = value.strip.gsub(CRLF_RE, ' ')
-              values << value unless value.empty?
-            end
-          }
-        }
-
-        terms << values
-      }
-
-      terms
-    end
-
-    def deferred?
-      true
-    end
-
-    private
-
-    def check_args(expected, actual, &block)
-      if block ? block[actual] : expected == actual
-        true
-      else
-        warn "wrong number of arguments for #{self} (#{actual} for #{expected})"
-        false
-      end
-    end
-
-    # "Nasenbär\n"
-    register_format! :out, 'lingo/single_word' do
+    # "Nasenbär"
+    class SingleWord < Lingo
 
       def convert(record)
         super.flatten
@@ -86,25 +43,29 @@ module Athena::Formats
 
     end
 
-    # "John Vorhauer*Vorhauer, John\n"
-    register_format! :out, 'lingo/key_value' do
+    # "John Vorhauer*Vorhauer, John"
+    class KeyValue < Lingo
+
+      SEPARATOR = '*'
 
       def convert(record)
         super.map { |terms|
-          terms.join(KV_SEPARATOR) if check_args(2, terms.size)
+          terms.join(SEPARATOR) if check_args(2, terms.size)
         }.compact
       end
 
     end
 
-    # "Essen,essen #v Essen #s Esse #s\n"
-    register_format! :out, 'lingo/word_class' do
+    # "Essen,essen #v Essen #s Esse #s"
+    class WordClass < Lingo
+
+      SEPARATOR = ','
 
       def convert(record)
         super.map { |terms|
           [ terms.shift,
             terms.to_enum(:each_slice, 2).map { |w, c| "#{w} ##{c}" }.join(' ')
-          ].join(WC_SEPARATOR) if check_args('odd, > 1', terms.size) { |actual|
+          ].join(SEPARATOR) if check_args('odd, > 1', terms.size) { |actual|
             actual > 1 && actual % 2 == 1
           }
         }.compact
@@ -112,12 +73,14 @@ module Athena::Formats
 
     end
 
-    # "Fax;Faxkopie;Telefax\n"
-    register_format! :out, 'lingo/multi_value', 'lingo/multi_key' do
+    # "Fax;Faxkopie;Telefax"
+    class MultiValue < Lingo
+
+      SEPARATOR = ';'
 
       def convert(record)
         super.map { |terms|
-          terms.join(MV_SEPARATOR) if check_args('> 1', terms.size) { |actual|
+          terms.join(SEPARATOR) if check_args('> 1', terms.size) { |actual|
             actual > 1
           }
         }.compact
@@ -125,6 +88,47 @@ module Athena::Formats
 
     end
 
+    MultiKey = MultiValue
+
+    def deferred?
+      true
+    end
+
+    private
+
+    def convert(record)
+      terms = []
+
+      record.struct.each { |field, struct|
+        struct_values = struct[:values]
+        struct_values.default = []
+
+        values = []
+
+        struct[:elements].each { |element|
+          struct_values[element].each { |value|
+            if value
+              value = value.strip.gsub(CRLF_RE, ' ')
+              values << value unless value.empty?
+            end
+          }
+        }
+
+        terms << values
+      }
+
+      terms
+    end
+
+    def check_args(expected, actual, &block)
+      if block ? block[actual] : expected == actual
+        true
+      else
+        warn "wrong number of arguments for #{self} (#{actual} for #{expected})"
+        false
+      end
+    end
+
   end
 
 end

data/lib/athena/formats/sisis.rb

@@ -34,29 +34,10 @@ module Athena::Formats
 
     RECORD_RE = %r{(\d+).*?:\s*(.*)}
 
-    register_format :in do
-
-      attr_reader :record_element, :config
-
-      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}"
-        end
-      end
-
-    end
-
-    def parse(source, &block)
+    def parse(input, &block)
       record, num = nil, 0
 
-      source.each { |line|
+      input.each { |line|
         element, value = line.match(RECORD_RE)[1, 2]
 
         if element == record_element

data/lib/athena/formats/sql.rb

@@ -33,29 +33,12 @@ module Athena::Formats
 
   class MYSQL < Base
 
-    register_format :in do
+    attr_reader :sql_parser
 
-      attr_reader :record_element, :config, :sql_parser
-
-      def initialize(parser)
-        @config = parser.config.dup
-
-        case @record_element = @config.delete(:__record_element)
-          when String, nil
-            # fine!
-          else
-            raise IllegalRecordElementError, "illegal record element #{@record_element.inspect}"
-        end
-
-        @sql_parser = SQLParser.new
-      end
-
-    end
-
-    def parse(source, &block)
+    def parse(input, &block)
       columns, table, num = Hash.new { |h, k| h[k] = [] }, nil, 0
 
-      source.each { |line|
+      input.each { |line|
         case line = line.chomp
           when /\ACREATE\s+TABLE\s+`(.+?)`/i
             table = $1
@@ -88,6 +71,14 @@ module Athena::Formats
       num
     end
 
+    private
+
+    def init_in(*)
+      @__record_element_ok__ = [String, nil]
+      super
+      @sql_parser = SQLParser.new
+    end
+
     class SQLParser
 
       AST = Struct.new(:value)
@@ -104,7 +95,7 @@ module Athena::Formats
         while result = parse_row
           row = result.value
           block_given ? yield(row) : rows << row
-          break unless @input.scan(/,/)
+          break unless @input.scan(/,\s*/)
         end
 
         @input.scan(/;/)  # optional
@@ -114,8 +105,6 @@ module Athena::Formats
         rows unless block_given
       end
 
-      private
-
       def parse_row
         return unless @input.scan(/\(/)
 
@@ -123,7 +112,7 @@ module Athena::Formats
 
         while result = parse_value
           row << result.value
-          break unless @input.scan(/,/)
+          break unless @input.scan(/,\s*/)
         end
 
         error('Unclosed row') unless @input.scan(/\)/)
@@ -191,27 +180,10 @@ module Athena::Formats
 
   class PGSQL < Base
 
-    register_format :in do
-
-      attr_reader :record_element, :config
-
-      def initialize(parser)
-        @config = parser.config.dup
-
-        case @record_element = @config.delete(:__record_element)
-          when String, nil
-            # fine!
-          else
-            raise IllegalRecordElementError, "illegal record element #{@record_element.inspect}"
-        end
-      end
-
-    end
-
-    def parse(source, &block)
+    def parse(input, &block)
       columns, table, num = Hash.new { |h, k| h[k] = [] }, nil, 0
 
-      source.each { |line|
+      input.each { |line|
         case line = line.chomp
           when /\ACOPY\s+(\S+)\s+\((.+?)\)\s+FROM\s+stdin;\z/i
             columns[table = $1] = $2.split(/\s*,\s*/)
@@ -242,9 +214,16 @@ module Athena::Formats
       num
     end
 
+    private
+
+    def init_in(*)
+      @__record_element_ok__ = [String, nil]
+      super
+    end
+
   end
 
-  MySQL = MYSQL
-  PgSQL = PGSQL
+  class MySQL < MYSQL; private :parse; end
+  class PgSQL < PGSQL; private :parse; end
 
 end

data/lib/athena/formats/xml.rb

@@ -42,22 +42,13 @@ module Athena::Formats
 
     VALUE_SEPARATOR = '|'
 
-    register_format :in do
-
-      attr_reader :specs, :record_element
-
-      def initialize(parser)
-        @specs = setup_specs(parser.config.dup)
-      end
+    attr_reader :specs
 
+    def parse(input, &block)
+      REXML::Document.parse_stream(input, listener(&block))
+      Athena::Record.records.size
     end
 
-    def parse(source, &block)
-      REXML::Document.parse_stream(source, listener(&block))
-    end
-
-    register_format :out
-
     def convert(record)
       builder.row {
         builder.id record.id
@@ -79,7 +70,7 @@ module Athena::Formats
       }
     end
 
-    register_format! :out, 'xml/flat' do
+    class Flat < XML
 
       def convert(record)
         super { |field, struct|
@@ -99,18 +90,43 @@ module Athena::Formats
 
     end
 
-    def wrap(out = nil)
-      res = nil
-      builder(:target => out).database { res = super() }
-      res
-    end
-
     def raw?
       true
     end
 
     private
 
+    def init_in(*)
+      @__record_element_ok__ = [String, Array]
+      super
+
+      case @skip_hierarchy = @config.delete(:__skip_hierarchy)
+        when Integer
+          # fine!
+        when nil
+          @skip_hierarchy = 0
+        else
+          raise ConfigError, "illegal value #{@skip_hierarchy.inspect} for skip hierarchy"
+      end
+
+      @specs = {}
+
+      @config.each { |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)
+        }
+      } }
+    end
+
+    def wrap
+      res = nil
+      builder(:target => output).database { res = super() }
+      res
+    end
+
     def builder(options = {})
       @builder ||= begin
         builder = Builder::XmlMarkup.new({ :indent => 2 }.merge(options))
@@ -129,39 +145,6 @@ module Athena::Formats
       end
     end
 
-    def setup_specs(config)
-      case @record_element = config.delete(:__record_element)
-        when String, Array
-          # fine!
-        when nil
-          raise NoRecordElementError, 'no record element specified'
-        else
-          raise IllegalRecordElementError, "illegal record element #{@record_element.inspect}"
-      end
-
-      case @skip_hierarchy = config.delete(:__skip_hierarchy)
-        when Integer
-          # fine!
-        when nil
-          @skip_hierarchy = 0
-        else
-          raise ConfigError, "illegal value #{@skip_hierarchy.inspect} for skip hierarchy"
-      end
-
-      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
-      }
-    end
-
     def listener(&block)
       record_spec = RecordSpec.new(&block)
       record_spec.specs!(specs)