lingo 1.8.0 → 1.8.1

data/lib/lingo/database.rb

@@ -1,585 +1,237 @@
 # encoding: utf-8
 
 #--
-# LINGO ist ein Indexierungssystem mit Grundformreduktion, Kompositumzerlegung,
-# Mehrworterkennung und Relationierung.
-#
-# Copyright (C) 2005-2007 John Vorhauer
-# Copyright (C) 2007-2011 John Vorhauer, Jens Wille
-#
-# This program 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.
-#
-# This program 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 this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
-#
-# For more information visit http://www.lex-lingo.de or contact me at
-# welcomeATlex-lingoDOTde near 50°55'N+6°55'E.
-#
-# Lex Lingo rules from here on
+###############################################################################
+#                                                                             #
+# Lingo -- A full-featured automatic indexing system                          #
+#                                                                             #
+# Copyright (C) 2005-2007 John Vorhauer                                       #
+# Copyright (C) 2007-2012 John Vorhauer, Jens Wille                           #
+#                                                                             #
+# Lingo 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.                                                          #
+#                                                                             #
+# Lingo 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 Lingo. If not, see <http://www.gnu.org/licenses/>.               #
+#                                                                             #
+###############################################################################
 #++
 
-require 'sdbm'
 require 'pathname'
 require 'fileutils'
 require 'digest/sha1'
 
-require_relative 'const'
-require_relative 'types'
-require_relative 'utilities'
-require_relative 'modules'
+require_relative 'database/show_progress'
+require_relative 'database/crypter'
+require_relative 'database/source'
+require_relative 'database/hash_store'
+require_relative 'database/sdbm_store'
+require_relative 'database/gdbm_store'
+require_relative 'database/libcdb_store'
 
 class Lingo
 
-  class ShowProgress
-
-    def initialize(msg, active = true, out = $stderr)
-      @active, @out, format = active, out, ' [%3d%%]'
-
-      # To get the length of the formatted string we have
-      # to actually substitute the placeholder.
-      length = (format % 0).length
-
-      # Now we know how far to "go back" to
-      # overwrite the formatted string...
-      back = "\b" * length
-
-      @format = format       + back
-      @clear  = ' ' * length + back
-
-      print msg, ': '
-    end
-
-    def start(msg, max)
-      @ratio, @count, @next_step = max / 100.0, 0, 0
-      print msg, ' '
-      step
-    end
-
-    def stop(msg)
-      print @clear
-      print msg, "\n"
-    end
-
-    def tick(value)
-      @count = value
-      step if @count >= @next_step
-    end
-
-    private
-
-    def step
-      percent = @count / @ratio
-      @next_step = (percent + 1) * @ratio
-
-      print @format % percent
-    end
-
-    def print(*args)
-      @out.print(*args) if @active
-    end
-
-  end
-
-  # Crypter ermöglicht die Ver- und Entschlüsselung von Wörterbüchern
-
-  class Crypter
-
-    HEX_CHARS = '0123456789abcdef'.freeze
-
-    def digest(key)
-      Digest::SHA1.hexdigest(key)
-    end
-
-    def encode(key, val)
-      hex = ''
-
-      crypt(key, val).each_byte { |byte|
-        # To get a hex representation for a char we just utilize
-        # the quotient and the remainder of division by base 16.
-        q, r = byte.divmod(16)
-        hex << HEX_CHARS[q] << HEX_CHARS[r]
-      }
+  # Die Klasse Database stellt eine einheitliche Schnittstelle auf Lingo-Datenbanken bereit.
+  # Die Identifizierung der Datenbank erfolgt über die ID der Datenbank, so wie sie in der
+  # Sprachkonfigurationsdatei <tt>de.lang</tt> unter <tt>language/dictionary/databases</tt>
+  # hinterlegt ist.
+  #
+  # Das Lesen und Schreiben der Datenbank erfolgt über die Funktionen []() und []=().
 
-      [digest(key), hex]
-    end
+  class Database
 
-    def decode(key, val)
-      str, q, first = '', 0, false
+    include Cachable
 
-      val.each_byte { |byte|
-        byte = byte.chr(ENC)
+    BACKENDS = %w[LibCDB SDBM GDBM].unshift(ENV['LINGO_BACKEND']).compact.uniq
 
-        # Our hex chars are 2 bytes wide, so we have to keep track
-        # of whether it's the first or the second of the two.
-        if first = !first
-          q = HEX_CHARS.index(byte)
-        else
-          # Now we got both parts, so let's revert the divmod(16)
-          str << q * 16 + HEX_CHARS.index(byte)
-        end
-      }
+    FLD_SEP = '|'
+    IDX_REF = '^'
+    KEY_REF = '*'
+    SYS_KEY = '~'
 
-      crypt(key, str)
-    end
-
-    private
+    INDEX_PATTERN = %r{\A#{Regexp.escape(IDX_REF)}\d+\z}
 
-    def crypt(k, v)
-      c, y = '', k.codepoints.reverse_each.cycle
-      v.each_codepoint { |x| c << (x ^ y.next).chr(ENC) }
-      c
+    def self.open(*args, &block)
+      new(*args).open(&block)
     end
 
-  end
-
-  # Die Klasse TxtFile stellt eine einheitliche Schnittstelle auf die unterschiedlichen Formate
-  # von Wörterbuch-Quelldateien bereit. Die Identifizierung der Quelldatei erfolgt über die ID
-  # der Datei, so wie sie in der Sprachkonfigurationsdatei <tt>de.lang</tt> unter
-  # <tt>language/dictionary/databases</tt> hinterlegt ist.
-  #
-  # Die Verarbeitung der Wörterbücher erfolgt mittels des Iterators <b>each</b>, der für jede
-  # Zeile der Quelldatei ein Array bereitstellt in der Form <tt>[ key, [val1, val2, ...] ]</tt>.
-  #
-  # Nicht korrekt erkannte Zeilen werden abgewiesen und in eine Revoke-Datei gespeichert, die
-  # an der Dateiendung <tt>.rev</tt> zu erkennen ist.
-
-  class TxtFile
-
-    attr_reader :position
-
     def initialize(id, lingo)
-      # Konfiguration der Datenbank auslesen
       @config = lingo.database_config(id)
 
-      source_file = Lingo.find(:dict, name = @config['name'])
-
-      @pn_source = Pathname.new(source_file)
-      @pn_reject = Pathname.new(Lingo.find(:store, source_file) << '.rev')
+      @id, @lingo = id, lingo
+      @src_file   = Lingo.find(:dict, @config['name'])
+      @crypter    = Crypter.new if @config.has_key?('crypt')
 
-      Lingo.error("No such source file `#{name}' for `#{id}'.") unless @pn_source.exist?
-
-      @wordclass = @config.fetch('def-wc', '?').downcase
-      @separator = @config['separator']
-
-      @legal_word = '(?:' + PRINTABLE_CHAR + '|[' + Regexp.escape('- /&()[].,') + '])+'  # TODO: v1.60 - ',' bei TxtFile zulassen; in const.rb einbauen
-      @line_pattern = Regexp.new('^'+@legal_word+'$')
-
-      @position = 0
-    end
-
-    def size
-      @pn_source.size
-    end
-
-    def each
-      # Reject-Datei öffnen
-      fail_msg = "Fehler beim öffnen der Reject-Datei '#{@pn_reject.to_s}'"
-      reject_file = @pn_reject.open('w', encoding: ENC)
-
-      # Alle Zeilen der Quelldatei verarbeiten
-      fail_msg = "Fehler beim öffnen der Wörterbuch-Quelldatei '#{@pn_source.to_s}'"
-
-      @pn_source.each_line($/, encoding: ENC) do |raw_line|
-        @position += raw_line.size      # Position innerhalb der Datei aktualisieren
-        line = raw_line.chomp.downcase  # Zeile normieren
-
-        next if line =~ /^\s*\043/ || line.strip == ''  # Kommentarzeilen und leere Zeilen überspringen
-
-        # Ungültige Zeilen protokollieren
-        unless line.length < 4096 && line =~ @line_pattern
-          fail_msg = "Fehler beim schreiben der Reject-Datei '#{@pn_reject.to_s}'"
-          reject_file.puts line
-          next
-        end
-
-        # Zeile in Werte konvertieren
-        yield convert_line(line, $1, $2)
+      begin
+        @dbm_name = Lingo.find(:store, @src_file)
+        FileUtils.mkdir_p(File.dirname(@dbm_name))
+      rescue NoWritableStoreError
+        @backend  = HashStore
       end
 
-      fail_msg = "Fehler beim Schließen der Reject-Datei '#{@pn_reject.to_s}'"
-      reject_file.close
-      @pn_reject.delete if @pn_reject.size == 0
-
-      self
-    rescue RuntimeError
-      Lingo.error(fail_msg)
-    end
-
-  end
-
-  # Abgeleitet von TxtFile behandelt die Klasse Dateien mit dem Format <tt>SingleWord</tt>.
-  # Eine Zeile <tt>"Fachbegriff\n"</tt> wird gewandelt in <tt>[ 'fachbegriff', ['#s'] ]</tt>.
-  # Die Wortklasse kann über den Parameter <tt>def-wc</tt> beeinflusst werden.
-
-  class TxtFile_Singleword < TxtFile
-
-    def initialize(id, lingo)
-      super
-
-      @wc     = @config.fetch('def-wc',     's').downcase
-      @mul_wc = @config.fetch('def-mul-wc', @wc).downcase
+      extend(backend)
 
-      @line_pattern = %r{^(#{@legal_word})$}
-    end
-
-    private
+      @dbm_name << store_ext if respond_to?(:store_ext, true)
 
-    def convert_line(line, key, val)
-      [key = key.strip, %W[##{key =~ /\s/ ? @mul_wc : @wc}]]
+      init_cachable
+      convert unless uptodate?
     end
 
-  end
-
-  # Abgeleitet von TxtFile behandelt die Klasse Dateien mit dem Format <tt>KeyValue</tt>.
-  # Eine Zeile <tt>"Fachbegriff*Fachterminus\n"</tt> wird gewandelt in <tt>[ 'fachbegriff', ['fachterminus#s'] ]</tt>.
-  # Die Wortklasse kann über den Parameter <tt>def-wc</tt> beeinflusst werden.
-  # Der Trenner zwischen Schlüssel und Projektion kann über den Parameter <tt>separator</tt> geändert werden.
-
-  class TxtFile_Keyvalue < TxtFile
-
-    def initialize(id, lingo)
-      super
-
-      @separator = @config.fetch('separator', '*')
-      @line_pattern = Regexp.new('^(' + @legal_word + ')' + Regexp.escape(@separator) + '(' + @legal_word + ')$')
+    def backend
+      @backend ||= BACKENDS.find { |mod|
+        break self.class.const_get("#{mod}Store") if Object.const_defined?(mod)
+      } || HashStore
     end
 
-    private
-
-    def convert_line(line, key, val)
-      key, val = key.strip, val.strip
-      val = '' if key == val
-      val = [val + '#' + @wordclass]
-      [key, val]
+    def closed?
+      @db.nil? || _closed?
     end
 
-  end
-
-  # Abgeleitet von TxtFile behandelt die Klasse Dateien mit dem Format <tt>WordClass</tt>.
-  # Eine Zeile <tt>"essen,essen #v essen #o esse #s\n"</tt> wird gewandelt in <tt>[ 'essen', ['esse#s', 'essen#v', 'essen#o'] ]</tt>.
-  # Der Trenner zwischen Schlüssel und Projektion kann über den Parameter <tt>separator</tt> geändert werden.
-
-  class TxtFile_Wordclass < TxtFile
-
-    def initialize(id, lingo)
-      super
-
-      @separator = @config.fetch('separator', ',')
-      @line_pattern = Regexp.new('^(' + @legal_word + ')' + Regexp.escape(@separator) + '((?:' + @legal_word + '\043\w)+)$')
+    def open
+      @db = _open if closed?
+      block_given? ? yield(self) : self
+    ensure
+      close if @db && block_given?
     end
 
-    private
+    def close
+      @db.close unless closed?
+      @db = nil
 
-    def convert_line(line, key, val)
-      key, valstr = key.strip, val.strip
-      val = valstr.gsub(/\s+\043/, '#').scan(/\S.+?\s*\043\w/)
-      val = val.map do |str|
-        str =~ /^(.+)\043(.)/
-        ($1 == key ? '' : $1) + '#' + $2
-      end
-      [key, val]
+      self
     end
 
-  end
-
-  # Abgeleitet von TxtFile behandelt die Klasse Dateien mit dem Format <tt>MultiValue</tt>.
-  # Eine Zeile <tt>"Triumph;Sieg;Erfolg\n"</tt> wird gewandelt in <tt>[ nil, ['triumph', 'sieg', 'erfolg'] ]</tt>.
-  # Der Trenner zwischen Schlüssel und Projektion kann über den Parameter <tt>separator</tt> geändert werden.
-
-  class TxtFile_Multivalue < TxtFile
-
-    def initialize(id, lingo)
-      super
-
-      @separator = @config.fetch('separator', ';')
-      @line_pattern = Regexp.new('^' + @legal_word + '(?:' + Regexp.escape(@separator) + @legal_word + ')*$')
+    def to_h
+      {}.tap { |hash| @db.each { |key, val|
+        hash[key.force_encoding(ENC).freeze] = val.force_encoding(ENC)
+      } unless closed? }
     end
 
-    private
+    def [](key)
+      val = _val(key) unless closed?
+      return unless val
 
-    def convert_line(line, key, val)
-      [nil, line.split(@separator).map { |value| value.strip }]
+      # Äquvalenzklassen behandeln
+      val.split(FLD_SEP).map { |v|
+        v =~ INDEX_PATTERN ? _val(v) : v
+      }.compact.join(FLD_SEP).split(FLD_SEP)
     end
 
-  end
+    def []=(key, val)
+      return if closed?
 
-  # Abgeleitet von TxtFile behandelt die Klasse Dateien mit dem Format <tt>MultiKey</tt>.
-  # Eine Zeile <tt>"Triumph;Sieg;Erfolg\n"</tt> wird gewandelt in <tt>[ 'triumph', ['sieg', 'erfolg'] ]</tt>.
-  # Die Sonderbehandlung erfolgt in der Klasse Txt2DbmConverter, wo daraus Schlüssel-Werte-Paare in der Form
-  # <tt>[ 'sieg', ['triumph'] ]</tt> und <tt>[ 'erfolg', ['triumph'] ]</tt> erzeugt werden.
-  # Der Trenner zwischen Schlüssel und Projektion kann über den Parameter <tt>separator</tt> geändert werden.
+      val = val.dup
+      val.concat(retrieve(key)) if hit?(key)
 
-  class TxtFile_Multikey < TxtFile
+      val.sort!
+      val.uniq!
+      store(key, val)
 
-    def initialize(id, lingo)
-      super
+      val = val.join(FLD_SEP)
+      key, val = @crypter.encode(key, val) if @crypter
 
-      @separator = @config.fetch('separator', ';')
-      @line_pattern = Regexp.new('^' + @legal_word + '(?:' + Regexp.escape(@separator) + @legal_word + ')*$')
+      _set(key, val)
     end
 
     private
 
-    def convert_line(line, key, val)
-      values = line.split(@separator).map { |value| value.strip }
-      [values[0], values[1..-1]]
-    end
-
-  end
+    def uptodate?(file = @dbm_name)
+      src = Pathname.new(@src_file)
+      @source_key = lambda { [src.size, src.mtime].join(FLD_SEP) }
 
-  # Die Klasse DbmFile stellt eine einheitliche Schnittstelle auf Lingo-Datenbanken bereit.
-  # Die Identifizierung der Datenbank erfolgt über die ID der Datenbank, so wie sie in der
-  # Sprachkonfigurationsdatei <tt>de.lang</tt> unter <tt>language/dictionary/databases</tt>
-  # hinterlegt ist.
-  #
-  # Das Lesen und Schreiben der Datenbank erfolgt über die Funktionen []() und []=().
-
-  class DbmFile
-
-    include Cachable
-
-    INDEX_PATTERN = %r{\A#{Regexp.escape(IDX_REF)}\d+\z}
-
-    def self.open(*args)
-      dbm = new(*args)
-      dbm.open { yield dbm }
+      sys_key = open { @db[SYS_KEY] } if File.exist?(file)
+      sys_key && (!src.exist? || sys_key == @source_key.call)
     end
 
-    def initialize(id, lingo, read_mode = true)
-      @lingo = lingo
-
-      init_cachable
-
-      config = lingo.database_config(id)
-      raise "No such database `#{id}'." unless config && config.has_key?('name')
-
-      @id, @dbm = id, nil
-      @src_file = Lingo.find(:dict, config['name'])
-      @dbm_name = Lingo.find(:store, @src_file)
-
-      Txt2DbmConverter.new(id, lingo).convert if read_mode && !uptodate?
-
-      @crypter = config.has_key?('crypt') ? Crypter.new : nil
-
-      FileUtils.mkdir_p(File.dirname(@dbm_name))
+    def uptodate!
+      @db[SYS_KEY] = @source_key.call
     end
 
-    # Überprüft die Aktualität des DbmFile
-    def uptodate?
-      begin
-        key = open { @dbm[SYS_KEY] }
-      rescue RuntimeError
-      end if File.exist?("#{@dbm_name}.pag")
-
-      key && (!(pn = Pathname.new(@src_file)).exist? || key == source_key(pn))
+    def create
+      _clear
+      open { yield }
     end
 
-    def open
-      if closed?
-        @dbm = SDBM.open(@dbm_name)
-        block_given? ? yield : self
-      else
-        Lingo.error("DbmFile #{@dbm_name} bereits geöffnet")
-      end
-    ensure
-      close if @dbm && block_given?
+    def _clear
+      File.delete(@dbm_name) if File.exist?(@dbm_name)
     end
 
-    def to_h
-      hash = {}
-
-      @dbm.each { |key, val|
-        [key, val].each { |x| x.encode!(ENC) }
-        hash[key.freeze] = val
-      } unless closed?
-
-      hash
+    def _open
+      raise NotImplementedError
     end
 
-    def clear
-      files = %w[pag dir].map { |ext| "#{@dbm_name}.#{ext}" }
-
-      if closed?
-        files.each { |file| File.delete(file) if File.exist?(file) }
-      else
-        close
-        files.each { |file| File.delete(file) }
-        open
-      end
-
-      self
-    end
-
-    def close
-      unless closed?
-        @dbm.close
-        @dbm = nil
-
-        self
-      else
-        #Lingo.error("DbmFile #{@dbm_name} nicht geöffnet")
-      end
-    end
-
-    def closed?
-      @dbm.nil? || @dbm.closed?
+    def _closed?
+      @db.closed?
     end
 
-    def [](key)
-      return if closed?
-
-      if val = _get(key)
-        # Äquvalenzklassen behandeln
-        val.split(FLD_SEP).map { |v|
-          v =~ INDEX_PATTERN ? _get(v) : v
-        }.compact.join(FLD_SEP).split(FLD_SEP)
-      end
-    end
-
-    def []=(key, val)
-      return if closed?
-
-      val += retrieve(key) if hit?(key)
-
-      store(key, val = val.sort.uniq)
-      _set(key, val.join(FLD_SEP))
+    def _set(key, val)
+      @db[key] = val
     end
 
-    def set_source_file(filename)
-      return if closed?
-      @dbm[SYS_KEY] = source_key(Pathname.new(Lingo.find(:dict, filename)))
+    def _get(key)
+      @db[key]
     end
 
-    private
-
-    def _get(key)
-      if val = @dbm[@crypter ? @crypter.digest(key) : key]
-        val.encode!(ENC)
+    def _val(key)
+      if val = _get(@crypter ? @crypter.digest(key) : key)
+        val.force_encoding(ENC)
         @crypter ? @crypter.decode(key, val) : val
       end
     end
 
-    def _set(key, val)
-      key, val = @crypter.encode(key, val) if @crypter
-      @dbm[key] = (val.length < 950) ? val : val[0, 950]
-    end
-
-    def source_key(src)
-      [src.size, src.mtime].join(FLD_SEP)
-    end
-
-  end
-
-  # Die Klasse Txt2DbConverter steuert die Konvertierung von Wörterbuch-Quelldateien in
-  # Lingo-Datenbanken. Die Identifizierung der Quelldatei erfolgt über die ID
-  # der Datei, so wie sie in der Sprachkonfigurationsdatei <tt>de.lang</tt> unter
-  # <tt>language/dictionary/databases</tt> hinterlegt ist.
-
-  class Txt2DbmConverter
+    def convert(verbose = @lingo.config.stderr.tty?)
+      src = Source.get(@config.fetch('txt-format', 'KeyValue'), @id, @lingo)
 
-    def initialize(id, lingo, verbose = lingo.config.stderr.tty?)
-      # Konfiguration der Datenbanken auslesen
-      @config, @index = lingo.database_config(id), 0
+      if lex = @config['use-lex']
+        a, s = [{
+          'source' => lex.split(STRING_SEPARATOR_RE),
+          'mode'   => @config['lex-mode']
+        }, @lingo], ' '
 
-      # Objekt für Quelldatei erzeugen
-      @format = @config.fetch( 'txt-format', 'KeyValue' ).downcase
-      @source = case @format
-        when 'singleword' then TxtFile_Singleword
-        when 'keyvalue'   then TxtFile_Keyvalue
-        when 'wordclass'  then TxtFile_Wordclass
-        when 'multivalue' then TxtFile_Multivalue
-        when 'multikey'   then TxtFile_Multikey
-        else
-          Lingo.error("Unbekanntes Textformat '#{config['txt-format'].downcase}' bei '#{'language/dictionary/databases/' + id}'")
-      end.new(id, lingo)
+        dic = Language::Dictionary.new(*a)
+        gra = Language::Grammar.new(*a)
 
-      # Zielobjekt erzeugen
-      @destination = DbmFile.new(id, lingo, false)
+        block = lambda { |form|
+          res = dic.find_word(form)
 
-      # Ausgabesteuerung
-      @progress = ShowProgress.new(@config['name'], verbose, lingo.config.stderr)
+          if res.unknown?
+            res = gra.find_compositum(form)
+            com = res.compo_form
+          end
 
-      # Lexikalisierungen für Mehrwortgruppen vorbereiten
-      lex_dic = @config['use-lex']
-      lex_mod = @config['lex-mode']
-
-      begin
-        @lexicalize = true
-        @dictionary = Dictionary.new({ 'source' => lex_dic.split(STRING_SEPERATOR_PATTERN), 'mode' => lex_mod }, lingo)
-        @grammar = Grammar.new({ 'source' => lex_dic.split(STRING_SEPERATOR_PATTERN), 'mode' => lex_mod }, lingo)
-      rescue RuntimeError
-        Lingo.error("Auf das Wörterbuch (#{lex_dic}) für die Lexikalisierung der Mehrwortgruppen in (#{@config['name']}) konnte nicht zugegriffen werden")
-      end if lex_dic
-    end
-
-    def convert
-      @progress.start('convert', @source.size)
-
-      @destination.open
-      @destination.clear
+          com ? com.form : res.norm
+        }
+      end
 
-      @source.each do |key, value|
-        @progress.tick(@source.position)
+      ShowProgress.new(self, src.size, verbose) { |progress| create {
+        src.each { |key, val|
+          progress[src.position]
 
-        # Behandle Mehrwortschlüssel
-        if @lexicalize && key =~ / /
-          # Schlüssel in Grundform wandeln
-          gkey = key.split(' ').map do |form|
+          if key
+            key.chomp!('.')
 
-            # => Wortform ohne Satzendepunkt benutzen
-            wordform = form.gsub(/\.$/, '')
+            if lex && key.include?(s)
+              k = key.split(s).map!(&block).join(s)
 
-            # => Wort suchen
-            result = @dictionary.find_word(wordform)
+              c = k.count(s) + 1
+              self[k.split(s)[0, 3].join(s)] = ["#{KEY_REF}#{c}"] if c > 3
 
-            # => Kompositum suchen, wenn Wort nicht erkannt
-            if result.attr == WA_UNKNOWN
-              result = @grammar.find_compositum(wordform)
-              compo = result.compo_form
+              key, val = k, val.map { |v| v.start_with?('#') ? key + v : v }
             end
+          end
 
-            compo ? compo.form : result.norm
-          end.join(' ')
-
-          skey = gkey.split
-          # Zusatzschlüssel einfügen, wenn Anzahl Wörter > 3
-          @destination[skey[0...3].join(' ')] = [KEY_REF + skey.size.to_s] if skey.size > 3
-
-          value = value.map { |v| v =~ /^\043/ ? key + v : v }
-          key = gkey
-        end
-
-        # Format Sonderbehandlungen
-        key.gsub!(/\.$/, '') if key
-        case @format
-        when 'multivalue'    # Äquvalenzklassen behandeln
-          key = IDX_REF + @index.to_s
-          @index += 1
-          @destination[key] = value
-          value.each { |v| @destination[v] = [key] }
-        when 'multikey'      # Äquvalenzklassen behandeln
-          value.each { |v| @destination[v] = [key] }
-        else
-          @destination[key] = value
-        end
+          src.set(self, key, val)
+        }
 
-      end
-
-      @destination.set_source_file(@config['name'])
-      @destination.close
-
-      @progress.stop('ok')
-
-      self
+        uptodate!
+      } }
     end
 
   end