lingo 1.8.0 → 1.8.1

data/lib/lingo/attendee/tokenizer.rb

@@ -1,216 +1,217 @@
 # 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/>.               #
+#                                                                             #
+###############################################################################
 #++
 
 class Lingo
 
-  # Der Tokenizer zerlegt eine Textzeile in einzelne Token. Dies ist notwendig,
-  # damit nachfolgende Attendees die Textdatei häppchenweise verarbeiten können.
-  #
-  # === Mögliche Verlinkung
-  # Erwartet:: Daten des Typs *String* (Textzeilen) z.B. von Textreader
-  # Erzeugt:: Daten des Typs *Token* z.B. für Abbreviator, Wordsearcher
-  #
-  # === Parameter
-  # Kursiv dargestellte Parameter sind optional (ggf. mit Angabe der Voreinstellung).
-  # Alle anderen Parameter müssen zwingend angegeben werden.
-  # <b>in</b>:: siehe allgemeine Beschreibung des Attendee.
-  # <b>out</b>:: siehe allgemeine Beschreibung des Attendee
-  #
-  # === Konfiguration
-  # Der Tokenizer benötigt zur Identifikation einzelner Token Regeln, nach denen er
-  # arbeiten soll. Die benötigten Regeln werden aufgrund des Umfangs nicht als Parameter,
-  # sondern in der Sprachkonfiguration hinterlegt, die sich standardmäßig in der Datei
-  # <tt>de.lang</tt> befindet (YAML-Format).
-  #   language:
-  #     attendees:
-  #       tokenizer:
-  #         regulars:
-  #           - _CHR_: '\wÄÖÜÁÂÀÉÊÈÍÎÌÓÔÒÚÛÙÝäöüáâàéêèíîìóôòúûùý'
-  #           - NUMS:  '[+-]?(\d{4,}|\d{1,3}(\.\d{3,3})*)(\.|(,\d+)?%?)'
-  #           - URLS:  '((mailto:|(news|http|https|ftp|ftps)://)\S+|^(www(\.\S+)+)|\S+([\._]\S+)+@\S+(\.\S+)+)'
-  #           - ABRV:  '(([_CHR_]+\.)+)[_CHR_]+'
-  #           - ABRS:  '(([_CHR_]{1,1}\.)+)(?!\.\.)'
-  #           - WORD:  '[_CHR_\d]+'
-  #           - PUNC:  '[!,\.:;?]'
-  #           - OTHR:  '[—„!\"#$%&()*\+,\-\./:;<=>?@\[\\\]^_`{|}~´]'
-  #           - HELP:  '.*'
-  # Die Regeln werden in der angegebenen Reihenfolge abgearbeitet, solange bis ein Token
-  # erkannt wurde. Sollte keine Regel zutreffen, so greift die letzt Regel +HELP+ in jedem
-  # Fall.
-  # Regeln, deren Name in Unterstriche eingefasst sind, werden als Makro interpretiert.
-  # Makros werden genutzt, um lange oder sich wiederholende Bestandteile von Regeln
-  # einmalig zu definieren und in den Regeln über den Makronamen eine Auflösung zu forcieren.
-  # Makros werden selber nicht für die Erkennung von Token eingesetzt.
-  #
-  # === Generierte Kommandos
-  # Damit der nachfolgende Datenstrom einwandfrei verarbeitet werden kann, generiert der Tokenizer
-  # Kommandos, die mit in den Datenstrom eingefügt werden.
-  # <b>*EOL(<dateiname>)</b>:: Kennzeichnet das Ende einer Textzeile, da die Information ansonsten
-  # für nachfolgende Attendees verloren wäre.
-  #
-  # === Beispiele
-  # Bei der Verarbeitung einer normalen Textdatei mit der Ablaufkonfiguration <tt>t1.cfg</tt>
-  #   meeting:
-  #     attendees:
-  #       - textreader: { out: lines, files: '$(files)' }
-  #       - tokenizer:  { in: lines, out: token }
-  #       - debugger:   { in: token, prompt: 'out>' }
-  # ergibt die Ausgabe über den Debugger: <tt>lingo -c t1 test.txt</tt>
-  #   out> *FILE('test.txt')
-  #   out> :Dies/WORD:
-  #   out> :ist/WORD:
-  #   out> :eine/WORD:
-  #   out> :Zeile/WORD:
-  #   out> :./PUNC:
-  #   out> *EOL('test.txt')
-  #   out> :Dies/WORD:
-  #   out> :ist/WORD:
-  #   out> :noch/WORD:
-  #   out> :eine/WORD:
-  #   out> :./PUNC:
-  #   out> *EOL('test.txt')
-  #   out> *EOF('test.txt')
-
-  class Attendee::Tokenizer < Attendee
-
-    protected
-
-    def init
-      # Regular Expressions für Token-Erkennung einlesen
-      regulars = get_key('regulars', '')
-      forward(STR_CMD_ERR, 'regulars nicht definiert') unless regulars
-
-      @space = get_key('space', false)
-      @tags  = get_key('tags',  true)
-      @wiki  = get_key('wiki',  true)
-
-      # default rules
-      @rules = [['SPAC', /^\s+/]]
-      @rules << ['HTML', /^<[^>]+>/]       unless @tags
-      @rules << ['WIKI', /^\[\[.+?\]\]/]   unless @wiki
-      @rules.unshift(['WIKI', /^=+.+=+$/]) unless @wiki
-
-      # Mit _xxx_ gekennzeichnete Makros anwenden und Expressions ergänzen und umwandeln
-      macros = {}
-
-      regulars.each { |rule|
-        name = rule.keys[0]
-        expr = rule.values[0].gsub(/_(\w+?)_/) {
-          macros[$&] || begin
-            Lingo.const_get("UTF_8_#{$1.upcase}")
-          rescue NameError
+  class Attendee
+
+    # Der Tokenizer zerlegt eine Textzeile in einzelne Token. Dies ist notwendig,
+    # damit nachfolgende Attendees die Textdatei häppchenweise verarbeiten können.
+    #
+    # === Mögliche Verlinkung
+    # Erwartet:: Daten des Typs *String* (Textzeilen) z.B. von TextReader
+    # Erzeugt:: Daten des Typs *Token* z.B. für Abbreviator, Wordsearcher
+    #
+    # === Parameter
+    # Kursiv dargestellte Parameter sind optional (ggf. mit Angabe der Voreinstellung).
+    # Alle anderen Parameter müssen zwingend angegeben werden.
+    # <b>in</b>:: siehe allgemeine Beschreibung des Attendee.
+    # <b>out</b>:: siehe allgemeine Beschreibung des Attendee
+    #
+    # === Konfiguration
+    # Der Tokenizer benötigt zur Identifikation einzelner Token Regeln, nach denen er
+    # arbeiten soll. Die benötigten Regeln werden aufgrund des Umfangs nicht als Parameter,
+    # sondern in der Sprachkonfiguration hinterlegt, die sich standardmäßig in der Datei
+    # <tt>de.lang</tt> befindet (YAML-Format).
+    #   language:
+    #     attendees:
+    #       tokenizer:
+    #         regulars:
+    #           - _CHR_: '\wÄÖÜÁÂÀÉÊÈÍÎÌÓÔÒÚÛÙÝäöüáâàéêèíîìóôòúûùý'
+    #           - NUMS:  '[+-]?(\d{4,}|\d{1,3}(\.\d{3,3})*)(\.|(,\d+)?%?)'
+    #           - URLS:  '((mailto:|(news|http|https|ftp|ftps)://)\S+|^(www(\.\S+)+)|\S+([\._]\S+)+@\S+(\.\S+)+)'
+    #           - ABRV:  '(([_CHR_]+\.)+)[_CHR_]+'
+    #           - ABRS:  '(([_CHR_]{1,1}\.)+)(?!\.\.)'
+    #           - WORD:  '[_CHR_\d]+'
+    #           - PUNC:  '[!,\.:;?]'
+    #           - OTHR:  '[—„!\"#$%&()*\+,\-\./:;<=>?@\[\\\]^_`{|}~´]'
+    #           - HELP:  '.*'
+    # Die Regeln werden in der angegebenen Reihenfolge abgearbeitet, solange bis ein Token
+    # erkannt wurde. Sollte keine Regel zutreffen, so greift die letzt Regel +HELP+ in jedem
+    # Fall.
+    # Regeln, deren Name in Unterstriche eingefasst sind, werden als Makro interpretiert.
+    # Makros werden genutzt, um lange oder sich wiederholende Bestandteile von Regeln
+    # einmalig zu definieren und in den Regeln über den Makronamen eine Auflösung zu forcieren.
+    # Makros werden selber nicht für die Erkennung von Token eingesetzt.
+    #
+    # === Generierte Kommandos
+    # Damit der nachfolgende Datenstrom einwandfrei verarbeitet werden kann, generiert der Tokenizer
+    # Kommandos, die mit in den Datenstrom eingefügt werden.
+    # <b>*EOL(<dateiname>)</b>:: Kennzeichnet das Ende einer Textzeile, da die Information ansonsten
+    # für nachfolgende Attendees verloren wäre.
+    #
+    # === Beispiele
+    # Bei der Verarbeitung einer normalen Textdatei mit der Ablaufkonfiguration <tt>t1.cfg</tt>
+    #   meeting:
+    #     attendees:
+    #       - text_reader: { out: lines, files: '$(files)' }
+    #       - tokenizer:   { in: lines, out: token }
+    #       - debugger:    { in: token, prompt: 'out>' }
+    # ergibt die Ausgabe über den Debugger: <tt>lingo -c t1 test.txt</tt>
+    #   out> *FILE('test.txt')
+    #   out> :Dies/WORD:
+    #   out> :ist/WORD:
+    #   out> :eine/WORD:
+    #   out> :Zeile/WORD:
+    #   out> :./PUNC:
+    #   out> *EOL('test.txt')
+    #   out> :Dies/WORD:
+    #   out> :ist/WORD:
+    #   out> :noch/WORD:
+    #   out> :eine/WORD:
+    #   out> :./PUNC:
+    #   out> *EOL('test.txt')
+    #   out> *EOF('test.txt')
+
+    class Tokenizer < self
+
+      protected
+
+      def init
+        # Regular Expressions für Token-Erkennung einlesen
+        regulars = get_key('regulars', '')
+        raise NoConfigKeyError.new(:regulars) unless regulars
+
+        @space = get_key('space', false)
+        @tags  = get_key('tags',  true)
+        @wiki  = get_key('wiki',  true)
+
+        # default rules
+        @rules = [['SPAC', /^\s+/]]
+        @rules << ['HTML', /^<[^>]+>/]       unless @tags
+        @rules << ['WIKI', /^\[\[.+?\]\]/]   unless @wiki
+        @rules.unshift(['WIKI', /^=+.+=+$/]) unless @wiki
+
+        # Mit _xxx_ gekennzeichnete Makros anwenden und Expressions ergänzen und umwandeln
+        macros = {}
+
+        regulars.each { |rule|
+          name = rule.keys[0]
+          expr = rule.values[0].gsub(/_(\w+?)_/) {
+            macros[$&] || begin
+              Database::Source.const_get("UTF8_#{$1.upcase}")
+            rescue NameError
+            end
+          }
+
+          if name =~ /^_\w+_$/    # is a macro
+            macros[name] = expr if name =~ /^_\w+_$/
+          else
+            @rules << [name, Regexp.new('^'+expr)]
           end
         }
 
-        if name =~ /^_\w+_$/    # is a macro
-          macros[name] = expr if name =~ /^_\w+_$/
-        else
-          @rules << [name, Regexp.new('^'+expr)]
-        end
-      }
-
-      # Der Tokenizer gibt jedes Zeilenende als Information weiter, sofern es sich
-      # nicht um die Verarbeitung einer LIR-Datei handelt. Im Falle einer normalen Datei
-      # wird der Dateiname gespeichert und als Kennzeichen für die Erzeugung von
-      # Zeilenende-Nachrichten herangezogen.
-      @filename = nil
-    end
+        # Der Tokenizer gibt jedes Zeilenende als Information weiter, sofern es sich
+        # nicht um die Verarbeitung einer LIR-Datei handelt. Im Falle einer normalen Datei
+        # wird der Dateiname gespeichert und als Kennzeichen für die Erzeugung von
+        # Zeilenende-Nachrichten herangezogen.
+        @filename = nil
+      end
 
-    def control(cmd, param)
-      case cmd
-        when STR_CMD_FILE then @filename = param
-        when STR_CMD_LIR  then @filename = nil
-        when STR_CMD_EOF  then @cont     = nil
+      def control(cmd, param)
+        case cmd
+          when STR_CMD_FILE then @filename = param
+          when STR_CMD_LIR  then @filename = nil
+          when STR_CMD_EOF  then @cont     = nil
+        end
       end
-    end
 
-    def process(obj)
-      if obj.is_a?(String)
-        inc('Anzahl Zeilen')
+      def process(obj)
+        if obj.is_a?(String)
+          inc('Anzahl Zeilen')
 
-        tokenize(obj) { |form, attr|
-          token = Token.new(form, attr)
+          tokenize(obj) { |form, attr|
+            token = Token.new(form, attr)
 
-          inc('Anzahl Muster '+token.attr)
-          inc('Anzahl Token')
+            inc('Anzahl Muster '+token.attr)
+            inc('Anzahl Token')
 
-          forward(token)
-        }
+            forward(token)
+          }
 
-        forward(STR_CMD_EOL, @filename) if @filename
-      else
-        forward(obj)
+          forward(STR_CMD_EOL, @filename) if @filename
+        else
+          forward(obj)
+        end
       end
-    end
 
-    private
-
-    # tokenize("Eine Zeile.")  ->  [:Eine/WORD:, :Zeile/WORD:, :./PUNC:]
-    def tokenize(textline)
-      case @cont
-        when 'HTML'
-          if textline =~ /^[^<>]*>/
-            yield $~[0], @cont
-            textline, @cont = $', nil
-          else
-            yield textline, @cont
-            return
-          end
-        when 'WIKI'
-          if textline =~ /^[^\[\]]*\]\]/
-            yield $~[0], @cont
-            textline, @cont = $', nil
-          else
-            yield textline, @cont
-            return
-          end
-        when nil
-          if !@tags && textline =~ /<[^<>]*$/
-            yield $~[0], @cont = 'HTML'
-            textline = $`
-          end
+      private
+
+      # tokenize("Eine Zeile.")  ->  [:Eine/WORD:, :Zeile/WORD:, :./PUNC:]
+      def tokenize(textline)
+        case @cont
+          when 'HTML'
+            if textline =~ /^[^<>]*>/
+              yield $~[0], @cont
+              textline, @cont = $', nil
+            else
+              yield textline, @cont
+              return
+            end
+          when 'WIKI'
+            if textline =~ /^[^\[\]]*\]\]/
+              yield $~[0], @cont
+              textline, @cont = $', nil
+            else
+              yield textline, @cont
+              return
+            end
+          when nil
+            if !@tags && textline =~ /<[^<>]*$/
+              yield $~[0], @cont = 'HTML'
+              textline = $`
+            end
+
+            if !@wiki && textline =~ /\[\[[^\[\]]*$/
+              yield $~[0], @cont = 'WIKI'
+              textline = $`
+            end
+        end
 
-          if !@wiki && textline =~ /\[\[[^\[\]]*$/
-            yield $~[0], @cont = 'WIKI'
-            textline = $`
-          end
+        until textline.empty?
+          @rules.each { |name, expr|
+            if textline =~ expr
+              yield $~[0], name if name != 'SPAC' || @space
+              textline = $'
+              break
+            end
+          }
+        end
       end
 
-      until textline.empty?
-        @rules.each { |name, expr|
-          if textline =~ expr
-            yield $~[0], name if name != 'SPAC' || @space
-            textline = $'
-            break
-          end
-        }
-      end
     end
 
   end

data/lib/lingo/attendee/variator.rb

@@ -1,183 +1,179 @@
 # 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/>.               #
+#                                                                             #
+###############################################################################
 #++
 
 class Lingo
 
-  # Der Variator ermöglicht bei nicht erkannten Wörtern den listenbasierten
-  # Austausch einzelner Wortteile einchließlich erneuter Wörterbuchsuche zur
-  # Verbesserung der Worterkennungsquote.
-  #
-  # Ursprünglich wurde der Variator entwickelt, um die mangelnde Qualität bei der
-  # OCR-Erkennung altdeutscher 's'-Konsonanten zu optimieren. Er kann ebenso bei
-  # alternativen Umlautschreibweisen z.B. zur Wandlung von 'Koeln' in 'Köln' dienen.
-  #
-  # === Mögliche Verlinkung
-  # Erwartet:: Daten vom Typ *Word* (andere werden einfach durchgereicht) z.B. von Wordsearcher
-  # Erzeugt:: Daten vom Typ *Word* zur Weiterleitung z.B. an Synonymer, Decomposer, Multiworder, Sequencer, Noneword_filter oder Vector_filter
-  #
-  # === Parameter
-  # Kursiv dargestellte Parameter sind optional (ggf. mit Angabe der Voreinstellung).
-  # Alle anderen Parameter müssen zwingend angegeben werden.
-  # <b>in</b>:: siehe allgemeine Beschreibung des Attendee
-  # <b>out</b>:: siehe allgemeine Beschreibung des Attendee
-  # <b>source</b>:: siehe allgemeine Beschreibung des Dictionary
-  # <b><i>mode</i></b>:: (Standard: all) siehe allgemeine Beschreibung des Dictionary
-  # <b><i>^check</i></b>:: (Standard: WA_UNKNOWN) Gebrenzt die zu variierenden Worttypen
-  # <b><i>marker</i></b>:: (Standard: '*') Kennzeichnung durch Variation erkannter Wörter
-  # <b><i>max-var</i></b>:: (Standard: '10000') Begrenzung der maximal zu prüfenden Permutationen bei der vollständigen Kombination aller auf ein Wort anzuwendenen aufgelisteten Wortteile.
-  #
-  # === Beispiele
-  # Bei der Verarbeitung einer normalen Textdatei mit der Ablaufkonfiguration <tt>t1.cfg</tt>
-  #   meeting:
-  #     attendees:
-  #       - textreader:   { out: lines, files: '$(files)' }
-  #       - tokenizer:    { in: lines, out: token }
-  #       - wordsearcher: { in: abbrev, out: words, source: 'sys-dic' }
-  #       - variator:     { in: words, out: varios, source: 'sys-dic' }
-  #       - debugger:     { in: varios, prompt: 'out>' }
-  # ergibt die Ausgabe über den Debugger: <tt>lingo -c t1 test.txt</tt>
-  #   out> *FILE('test.txt')
-  #   out> <*Dies = [(dies/w)]>
-  #   out> <*ist = [(ist/t)]>
-  #   out> <ein = [(ein/t)]>
-  #   out> <*Tisch = [(tisch/s)]>
-  #   out> :./PUNC:
-  #   out> *EOL('test.txt')
-  #   out> *EOF('test.txt')
-
-  class Attendee::Variator < Attendee
-
-    protected
-
-    def init
-      # Parameter verarbeiten
-      @marker  = get_key('marker', '*')
-      @max_var = get_key('max-var', '10000').to_i
-      filter = get_array('check', WA_UNKNOWN)
-
-      src = get_array('source')
-      mod = get_key('mode', 'all')
-
-      # Daten verarbeiten
-      @var_strings = get_key('variations')
-      forward(STR_CMD_ERR, 'Ocr-variator: Konfiguration <ocr-variator> ist leer') if @var_strings.size==0
-
-      # Initialisierungen
-      @check = Hash.new(false)
-      filter.each { |s| @check[s.upcase] = true }
-
-      # Wörterbuchzugriff
-      @dic = Dictionary.new({'source'=>src, 'mode'=>mod}, @lingo)
-      @gra = Grammar.new({'source'=>src, 'mode'=>mod}, @lingo)
-
-      # Optimierungen
-      if @max_var == 0
-        forward( STR_CMD_WARN, 'Ocr-variator: max-var ist 0, setze es auf 10.000' )
-        @max_var = 10000
-      end
-    end
+  class Attendee
 
-    def control(cmd, par)
-      # Status wird abgefragt
-      if cmd == STR_CMD_STATUS
-        # Eigenen Status um Status von Dictionary und Grammer erweitern
-        @dic.report.each_pair { | k, v | set( k, v ) }
-        @gra.report.each_pair { | k, v | set( k, v ) }
+    # Der Variator ermöglicht bei nicht erkannten Wörtern den listenbasierten
+    # Austausch einzelner Wortteile einchließlich erneuter Wörterbuchsuche zur
+    # Verbesserung der Worterkennungsquote.
+    #
+    # Ursprünglich wurde der Variator entwickelt, um die mangelnde Qualität bei der
+    # OCR-Erkennung altdeutscher 's'-Konsonanten zu optimieren. Er kann ebenso bei
+    # alternativen Umlautschreibweisen z.B. zur Wandlung von 'Koeln' in 'Köln' dienen.
+    #
+    # === Mögliche Verlinkung
+    # Erwartet:: Daten vom Typ *Word* (andere werden einfach durchgereicht) z.B. von Wordsearcher
+    # Erzeugt:: Daten vom Typ *Word* zur Weiterleitung z.B. an Synonymer, Decomposer, Multiworder, Sequencer, Noneword_filter oder Vector_filter
+    #
+    # === Parameter
+    # Kursiv dargestellte Parameter sind optional (ggf. mit Angabe der Voreinstellung).
+    # Alle anderen Parameter müssen zwingend angegeben werden.
+    # <b>in</b>:: siehe allgemeine Beschreibung des Attendee
+    # <b>out</b>:: siehe allgemeine Beschreibung des Attendee
+    # <b>source</b>:: siehe allgemeine Beschreibung des Dictionary
+    # <b><i>mode</i></b>:: (Standard: all) siehe allgemeine Beschreibung des Dictionary
+    # <b><i>^check</i></b>:: (Standard: WA_UNKNOWN) Gebrenzt die zu variierenden Worttypen
+    # <b><i>marker</i></b>:: (Standard: '*') Kennzeichnung durch Variation erkannter Wörter
+    # <b><i>max-var</i></b>:: (Standard: '10000') Begrenzung der maximal zu prüfenden Permutationen bei der vollständigen Kombination aller auf ein Wort anzuwendenen aufgelisteten Wortteile.
+    #
+    # === Beispiele
+    # Bei der Verarbeitung einer normalen Textdatei mit der Ablaufkonfiguration <tt>t1.cfg</tt>
+    #   meeting:
+    #     attendees:
+    #       - text_reader:   { out: lines, files: '$(files)' }
+    #       - tokenizer:     { in: lines, out: token }
+    #       - word_searcher: { in: abbrev, out: words, source: 'sys-dic' }
+    #       - variator:      { in: words, out: varios, source: 'sys-dic' }
+    #       - debugger:      { in: varios, prompt: 'out>' }
+    # ergibt die Ausgabe über den Debugger: <tt>lingo -c t1 test.txt</tt>
+    #   out> *FILE('test.txt')
+    #   out> <*Dies = [(dies/w)]>
+    #   out> <*ist = [(ist/t)]>
+    #   out> <ein = [(ein/t)]>
+    #   out> <*Tisch = [(tisch/s)]>
+    #   out> :./PUNC:
+    #   out> *EOL('test.txt')
+    #   out> *EOF('test.txt')
+
+    class Variator < self
+
+      protected
+
+      def init
+        # Parameter verarbeiten
+        @marker  = get_key('marker', '*')
+        @max_var = get_key('max-var', '10000').to_i
+        filter = get_array('check', WA_UNKNOWN)
+
+        # Daten verarbeiten
+        @var_strings = get_key('variations')
+        raise MissingConfigError.new(:variations) if @var_strings.empty?
+
+        # Initialisierungen
+        @check = Hash.new(false)
+        filter.each { |s| @check[s.upcase] = true }
+
+        set_dic
+        set_gra
+
+        if @max_var.zero?
+          @max_var = 10000
+          @lingo.warn "#{self.class}: max-var is 0, setting to #{@max_var}"
+        end
       end
-    end
 
-    def process(obj)
-      # Zu prüfende Wörter filtern
-      if obj.is_a?(Word) && @check[obj.attr]
-        # Statistik für Report
-        inc('Anzahl gesuchter Wörter')
-
-        # Erzeuge Variationen einer Wortform
-        variations = [obj.form]
-        @var_strings.each do |switch|
-          from, to = switch
-          variations = variate(variations, from, to)
+      def control(cmd, par)
+        # Status wird abgefragt
+        if cmd == STR_CMD_STATUS
+          # Eigenen Status um Status von Dictionary und Grammer erweitern
+          @dic.report.each_pair { | k, v | set( k, v ) }
+          @gra.report.each_pair { | k, v | set( k, v ) }
         end
+      end
 
-        # Prüfe Variation auf bekanntes Wort
-        variations[0...@max_var].each do |var|
-          # Variiertes Wort im Wörterbuch suchen
-          word = @dic.find_word(var)
-          word = @gra.find_compositum(var) if word.attr == WA_UNKNOWN
-          next if word.attr == WA_UNKNOWN || (
-            word.attr == WA_KOMPOSITUM && word.lexicals.any? { |lex|
-              lex.attr[0..0] == LA_TAKEITASIS
-            }
-          )
-
-          # Das erste erkannte Wort beendet die Suche
-          inc('Anzahl gefundener Wörter')
-          word.form = @marker + var
-          forward(word)
-          return
+      def process(obj)
+        # Zu prüfende Wörter filtern
+        if obj.is_a?(Word) && @check[obj.attr]
+          # Statistik für Report
+          inc('Anzahl gesuchter Wörter')
+
+          # Erzeuge Variationen einer Wortform
+          variations = [obj.form]
+          @var_strings.each do |switch|
+            from, to = switch
+            variations = variate(variations, from, to)
+          end
+
+          # Prüfe Variation auf bekanntes Wort
+          variations[0...@max_var].each do |var|
+            # Variiertes Wort im Wörterbuch suchen
+            word = @dic.find_word(var)
+            word = @gra.find_compositum(var) if word.unknown?
+            next if word.unknown? || (
+              word.attr == WA_KOMPOSITUM && word.lexicals.any? { |lex|
+                lex.attr[0..0] == LA_TAKEITASIS
+              }
+            )
+
+            # Das erste erkannte Wort beendet die Suche
+            inc('Anzahl gefundener Wörter')
+            word.form = @marker + var
+            forward(word)
+            return
+          end
         end
-      end
 
-      forward(obj)
-    end
+        forward(obj)
+      end
 
-    private
+      private
 
-    # Variiere die Bestandteile eines Arrays gemäß den Austauschvorgaben.
-    #
-    # variate( 'Tiieh', 'ieh', 'sch' ) => ['Tiieh', 'Tisch']
-    def variate(variation_list, from, to)
-      # neue Varianten sammeln
-      add_variations = []
-      from_re = Regexp.new(from)
+      # Variiere die Bestandteile eines Arrays gemäß den Austauschvorgaben.
+      #
+      # variate( 'Tiieh', 'ieh', 'sch' ) => ['Tiieh', 'Tisch']
+      def variate(variation_list, from, to)
+        # neue Varianten sammeln
+        add_variations = []
+        from_re = Regexp.new(from)
 
-      # alle Wörter in der variation_list permutieren
-      variation_list.each do |wordform|
+        # alle Wörter in der variation_list permutieren
+        variation_list.each do |wordform|
 
-        # Wortform in Teile zerlegen und anschließend Dimension feststellen
-        wordpart = " #{wordform} ".split( from_re )
-        n = wordpart.size - 1
+          # Wortform in Teile zerlegen und anschließend Dimension feststellen
+          wordpart = " #{wordform} ".split( from_re )
+          n = wordpart.size - 1
 
-        # Austauschketten in Matrix hinterlegen
-        change = [from, to]
+          # Austauschketten in Matrix hinterlegen
+          change = [from, to]
 
-        # Austauschketten auf alle Teile anwenden
-        (1..(2**n-1)).each do |i|
-          variation = wordpart[0]
-          # i[x] = Wert des x.ten Bit von Integer i
-          (1..n).each { |j| variation += change[i[j-1]] + wordpart[j]  }
+          # Austauschketten auf alle Teile anwenden
+          (1..(2**n-1)).each do |i|
+            variation = wordpart[0]
+            # i[x] = Wert des x.ten Bit von Integer i
+            (1..n).each { |j| variation += change[i[j-1]] + wordpart[j]  }
 
-          add_variations << variation.strip
+            add_variations << variation.strip
+          end
         end
+
+        variation_list + add_variations
       end
 
-      variation_list + add_variations
     end
 
   end