lingo 1.8.0 → 1.8.1

data/lib/lingo/attendee/noneword_filter.rb

@@ -1,103 +1,108 @@
 # 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 Noneword_filter ermöglicht es, alle nicht erkannten Wörter aus dem Datenstrom zu
-  # selektieren und weiterzuleiten. Im Prinzip werden alle erkannten Wörter gefiltert.
-  # Bei einem Indexierungslauf können so alle nicht durch den Wordsearcher erkannten Wörter,
-  # also die, die im Wörterbuch nicht enthalten sind, separat ausgegeben werden und als Grundlage für
-  # die Wörterbuchpflege dienen.
-  # Der Noneword_filter ist in einer frühen Entwicklungsphase entstanden. Die gleiche Funktion
-  # kann auch mit dem universelleren Objectfilter mit dem Ausdruck 'obj.kind_of?(Word) && obj.attr==WA_UNKNOWN'
-  # durchgeführt werden, mit dem einzigen Unterschied, dass der Noneword_filter nur die Wortform weiterleitet.
-  # Der Noneword_filter verschluckt ebenfalls alle Kommandos, ausser dem Dateianfang (*FILE) und Ende (*EOF),
-  # sowie dem LIR-Format-Spezifikum (*RECORD).
-  #
-  # *Hinweis* Dieser Attendee sammelt die auszugebenden Daten so lange, bis ein Dateiwechsel oder Record-Wechsel
-  # angekündigt wird. Erst dann werden alle Daten auf einmal weitergeleitet.
-  #
-  # === Mögliche Verlinkung
-  # Erwartet:: Daten vom Typ *Word*, z.B. von Abbreviator, Wordsearcher, Decomposer, Synonymer, Multiworder, Sequencer
-  # Erzeugt:: Daten vom Typ *String*, z.B. für Textwriter
-  #
-  # === 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
-  #
-  # === 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: token, out: words, source: 'sys-dic' }
-  #       - noneword_filter: { in: words, out: filtr }
-  #       - debugger:        { in: filtr, prompt: 'out>' }
-  # ergibt die Ausgabe über den Debugger: <tt>lingo -c t1 test.txt</tt>
-  #   out> *FILE('test.txt')
-  #   out> "lingo"
-  #   out> *EOF('test.txt')
+  class Attendee
 
-  class Attendee::Noneword_filter < Attendee
+    # Der NonewordFilter ermöglicht es, alle nicht erkannten Wörter aus dem Datenstrom zu
+    # selektieren und weiterzuleiten. Im Prinzip werden alle erkannten Wörter gefiltert.
+    # Bei einem Indexierungslauf können so alle nicht durch den Wordsearcher erkannten Wörter,
+    # also die, die im Wörterbuch nicht enthalten sind, separat ausgegeben werden und als Grundlage für
+    # die Wörterbuchpflege dienen.
+    # Der NonewordFilter ist in einer frühen Entwicklungsphase entstanden. Die gleiche Funktion
+    # kann auch mit dem universelleren Objectfilter mit dem Ausdruck 'obj.kind_of?(Word) && obj.attr==WA_UNKNOWN'
+    # durchgeführt werden, mit dem einzigen Unterschied, dass der NonewordFilter nur die Wortform weiterleitet.
+    # Der NonewordFilter verschluckt ebenfalls alle Kommandos, ausser dem Dateianfang (*FILE) und Ende (*EOF),
+    # sowie dem LIR-Format-Spezifikum (*RECORD).
+    #
+    # *Hinweis* Dieser Attendee sammelt die auszugebenden Daten so lange, bis ein Dateiwechsel oder Record-Wechsel
+    # angekündigt wird. Erst dann werden alle Daten auf einmal weitergeleitet.
+    #
+    # === Mögliche Verlinkung
+    # Erwartet:: Daten vom Typ *Word*, z.B. von Abbreviator, Wordsearcher, Decomposer, Synonymer, Multiworder, Sequencer
+    # Erzeugt:: Daten vom Typ *String*, z.B. für Textwriter
+    #
+    # === 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
+    #
+    # === 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: token, out: words, source: 'sys-dic' }
+    #       - noneword_filter:  { in: words, out: filtr }
+    #       - debugger:         { in: filtr, prompt: 'out>' }
+    # ergibt die Ausgabe über den Debugger: <tt>lingo -c t1 test.txt</tt>
+    #   out> *FILE('test.txt')
+    #   out> "lingo"
+    #   out> *EOF('test.txt')
 
-    protected
+    class NonewordFilter < self
 
-    def init
-      @nonewords = []
-    end
+      protected
 
-    # Control behandelt die Kommandos zum Öffnen und Schließen einer Datei.
-    # Für jede Datei wird ein neuer Satz nicht erkannter Wörter registriert.
-    def control(cmd, par)
-      case cmd
-        when STR_CMD_FILE
-          @nonewords.clear
-        when STR_CMD_EOL
-          deleteCmd
-        when STR_CMD_RECORD, STR_CMD_EOF
-          nones = @nonewords.sort.uniq
-          nones.each { |nw| forward(nw) }
-          add('Objekte gefiltert', nones.size)
-          @nonewords.clear
+      def init
+        @nonewords = []
+      end
+
+      # Control behandelt die Kommandos zum Öffnen und Schließen einer Datei.
+      # Für jede Datei wird ein neuer Satz nicht erkannter Wörter registriert.
+      def control(cmd, par)
+        case cmd
+          when STR_CMD_FILE
+            @nonewords.clear
+          when STR_CMD_EOL
+            skip_command
+          when STR_CMD_RECORD, STR_CMD_EOF
+            nones = @nonewords.sort.uniq
+            nones.each(&method(:forward))
+            add('Objekte gefiltert', nones.size)
+            @nonewords.clear
+        end
       end
-    end
 
-    def process(obj)
-      if obj.is_a?(Word) && obj.attr==WA_UNKNOWN
-        inc('Anzahl nicht erkannter Wörter')
-        @nonewords << obj.form.downcase
+      def process(obj)
+        if obj.is_a?(Word) && obj.unknown?
+          inc('Anzahl nicht erkannter Wörter')
+          @nonewords << obj.form.downcase
+        end
       end
+
     end
 
+    # For backwards compatibility.
+    Nonewordfilter  = NonewordFilter
+    Noneword_filter = NonewordFilter
+
   end
 
 end

data/lib/lingo/attendee/object_filter.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+#--
+###############################################################################
+#                                                                             #
+# 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
+
+  class Attendee
+
+    # Der ObjectFilter ermöglicht es, beliebige Objekte aus dem Datenstrom herauszufiltern.
+    # Um die gewünschten Objekte zu identifizieren, sind ein paar Ruby-Kenntnisse und das Wissen
+    # um die Lingo Klassen notwendig. Hier sollen kurz die häufigsten Fälle angesprochen werden:
+    #
+    # Filtern nach einem bestimmten Typ, z.B. Token oder Word wird beispielsweise durch den Ausdruck
+    # 'obj.kind_of?(Word)' ermöglicht. Token und Words haben jeweils ein Attribut +attr+.
+    # Bei Token gibt +attr+ an, mit welcher Tokenizer-Regel das Token erkannt wurde. So können z.B.
+    # alle numerischen Token mit dem Ausdruck 'obj.kind_of?(Token) && obj.attr=="NUMS"' identifiziert
+    # werden. Wie bereits gezeigt, können Bedingungen durch logisches UND (&&) oder ODER (||) verknüpft werden.
+    # Das Attribut +form+ kann genutzt werden, um auf den Text eines Objektes zuzugreifen, z.B.
+    # 'obj.form=="John"'.
+    #
+    # === Mögliche Verlinkung
+    # Erwartet:: Daten beliebigen Typs von allen Attendees
+    # Erzeugt:: Daten, die der als Parameter übergebenen Bedingung entsprechen
+    #
+    # === 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><i>objects</i></b>:: (Standard: true) Gibt einen Ruby-Ausdruck an, der, wenn der Ausdruck
+    #                         als Wahr ausgewertet wird, das Objekt weiterleitet und ansonsten filtert.
+    #
+    # === 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: token, out: words, source: 'sys-dic' }
+    #       - object_filter: { in: words, out: filtr, objects: 'obj.kind_of?(Word) && obj.lexicals.size>0 && obj.lexicals[0].attr==LA_SUBSTANTIV' }
+    #       - debugger:      { in: filtr, prompt: 'out>' }
+    # ergibt die Ausgabe über den Debugger: <tt>lingo -c t1 test.txt</tt>
+    #   out> *FILE('test.txt')
+    #   out> <Indexierung = [(indexierung/s)]>
+    #   out> <Indexierung = [(indexierung/s)]>
+    #   out> *EOL('test.txt')
+    #   out> *EOF('test.txt')
+
+    class ObjectFilter < self
+
+      protected
+
+      def init
+        @obj_eval = get_key('objects', 'true')
+      end
+
+      def process(obj)
+        forward(obj) if eval(@obj_eval)
+      end
+
+    end
+
+    # For backwards compatibility.
+    Objectfilter  = ObjectFilter
+    Object_filter = ObjectFilter
+
+  end
+
+end

data/lib/lingo/attendee/sequencer.rb

@@ -1,188 +1,189 @@
 # 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
 
-  class WordSequence
-
-    attr_reader :classes, :format, :string
-
-    def initialize(wordclasses, format)
-      @string  = wordclasses.downcase
-      @classes = @string.split(//)
-      @format  = format
-    end
+  class Attendee
+
+    # Der Sequencer ist von seiner Funktion her ähnlich dem Multiworder. Der Multiworder
+    # nutzt zur Erkennung von Mehrwortgruppen spezielle Wörterbücher, der Sequencer hingegen
+    # definierte Folgen von Wortklassen. Mit dem Sequencer können Indexterme generiert werden,
+    # die sich über mehrere Wörter erstrecken.
+    # Die Textfolge "automatische Indexierung und geniale Indexierung"
+    # wird bisher in die Indexterme "automatisch", "Indexierung" und "genial" zerlegt.
+    # Über die Konfiguration kann der Sequencer Mehrwortgruppen identifizieren, die
+    # z.B. aus einem Adjektiv und einem Substantiv bestehen. Mit der o.g. Textfolge würde
+    # dann auch "Indexierung, automatisch" und "Indexierung, genial" als Indexterm erzeugt
+    # werden. Welche Wortklassenfolgen erkannt werden sollen und wie die Ausgabe aussehen
+    # soll, wird dem Sequencer über seine Konfiguration mitgeteilt.
+    #
+    # === Mögliche Verlinkung
+    # Erwartet:: Daten vom Typ *Word* z.B. von Wordsearcher, Decomposer, Ocr_variator, Multiworder
+    # Erzeugt:: Daten vom Typ *Word* (mit Attribut WA_SEQUENCE). Je erkannter Mehrwortgruppe wird ein zusätzliches Word-Objekt in den Datenstrom eingefügt. Z.B. für Ocr_variator, Sequencer, Noneword_filter, 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><i>stopper</i></b>:: (Standard: TA_PUNCTUATION, TA_OTHER) Gibt die Begrenzungen an, zwischen
+    #                         denen der Sequencer suchen soll, i.d.R. Satzzeichen und Sonderzeichen,
+    #                         weil sie kaum in einer Mehrwortgruppen vorkommen.
+    #
+    # === Konfiguration
+    # Der Sequencer benötigt zur Identifikation von Mehrwortgruppen Regeln, nach denen er
+    # arbeiten soll. Die benötigten Regeln werden nicht als Parameter, sondern in der
+    # Sprachkonfiguration hinterlegt, die sich standardmäßig in der Datei
+    # <tt>de.lang</tt> befindet (YAML-Format).
+    #   language:
+    #     attendees:
+    #       sequencer:
+    #         sequences: [ [AS, "2, 1"], [AK, "2, 1"] ]
+    # Hiermit werden dem Sequencer zwei Regeln mitgeteilt: Er soll Adjektiv-Substantiv- (AS) und
+    # Adjektiv-Kompositum-Folgen (AK) erkennen. Zusätzlich ist angegeben, in welchem Format die
+    # dadurch ermittelte Wortfolge ausgegeben werden soll. In diesem Beispiel also zuerst das
+    # Substantiv und durch Komma getrennt das Adjektiv.
+    #
+    # === 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: token, out: words, source: 'sys-dic' }
+    #       - sequencer:     { in: words, out: seque }
+    #       - debugger:      { in: seque, prompt: 'out>' }
+    # ergibt die Ausgabe über den Debugger: <tt>lingo -c t1 test.txt</tt>
+    #   out> *FILE('test.txt')
+    #   out> <Lingo|?>
+    #   out> <kann = [(koennen/v)]>
+    #   out> <indexierung, automatisch|SEQ = [(indexierung, automatisch/q)]>
+    #   out> <automatische = [(automatisch/a)]>
+    #   out> <Indexierung = [(indexierung/s)]>
+    #   out> <und = [(und/w)]>
+    #   out> <indexierung, genial|SEQ = [(indexierung, genial/q)]>
+    #   out> <geniale = [(genial/a), (genialisch/a)]>
+    #   out> <Indexierung = [(indexierung/s)]>
+    #   out> :./PUNC:
+    #   out> *EOL('test.txt')
+    #   out> *EOF('test.txt')
+
+    class Sequencer < BufferedAttendee
+
+      protected
+
+      def init
+        # Parameter verwerten
+        @stopper = get_array('stopper', TA_PUNCTUATION + ',' + TA_OTHER).map(&:upcase)
+        @seq_strings = get_key('sequences').map { |e| WordSequence.new(*e) }
+
+        raise MissingConfigError.new(:sequences) if @seq_strings.empty?
+      end
 
-    def scan(sequence)
-      pos = 0
+      def control(cmd, par)
+        # Jedes Control-Object ist auch Auslöser der Verarbeitung
+        process_buffer if [STR_CMD_RECORD, STR_CMD_EOF].include?(cmd)
+      end
 
-      while pos = sequence.index(string, pos)
-        yield pos, format.dup, classes
-        pos += 1
+      def process_buffer?
+        #   start buffer processing when stopper token are found or at unknown words
+        item = @buffer.last
+        (item.is_a?(WordForm) && @stopper.include?(item.attr.upcase)) ||
+        (item.is_a?(Word) && item.unknown?)
       end
-    end
 
-  end
+      def process_buffer
+        return if @buffer.empty?
 
-  # Der Sequencer ist von seiner Funktion her ähnlich dem Multiworder. Der Multiworder
-  # nutzt zur Erkennung von Mehrwortgruppen spezielle Wörterbücher, der Sequencer hingegen
-  # definierte Folgen von Wortklassen. Mit dem Sequencer können Indexterme generiert werden,
-  # die sich über mehrere Wörter erstrecken.
-  # Die Textfolge "automatische Indexierung und geniale Indexierung"
-  # wird bisher in die Indexterme "automatisch", "Indexierung" und "genial" zerlegt.
-  # Über die Konfiguration kann der Sequencer Mehrwortgruppen identifizieren, die
-  # z.B. aus einem Adjektiv und einem Substantiv bestehen. Mit der o.g. Textfolge würde
-  # dann auch "Indexierung, automatisch" und "Indexierung, genial" als Indexterm erzeugt
-  # werden. Welche Wortklassenfolgen erkannt werden sollen und wie die Ausgabe aussehen
-  # soll, wird dem Sequencer über seine Konfiguration mitgeteilt.
-  #
-  # === Mögliche Verlinkung
-  # Erwartet:: Daten vom Typ *Word* z.B. von Wordsearcher, Decomposer, Ocr_variator, Multiworder
-  # Erzeugt:: Daten vom Typ *Word* (mit Attribut WA_SEQUENCE). Je erkannter Mehrwortgruppe wird ein zusätzliches Word-Objekt in den Datenstrom eingefügt. Z.B. für Ocr_variator, Sequencer, Noneword_filter, 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><i>stopper</i></b>:: (Standard: TA_PUNCTUATION, TA_OTHER) Gibt die Begrenzungen an, zwischen
-  #                         denen der Sequencer suchen soll, i.d.R. Satzzeichen und Sonderzeichen,
-  #                         weil sie kaum in einer Mehrwortgruppen vorkommen.
-  #
-  # === Konfiguration
-  # Der Sequencer benötigt zur Identifikation von Mehrwortgruppen Regeln, nach denen er
-  # arbeiten soll. Die benötigten Regeln werden nicht als Parameter, sondern in der
-  # Sprachkonfiguration hinterlegt, die sich standardmäßig in der Datei
-  # <tt>de.lang</tt> befindet (YAML-Format).
-  #   language:
-  #     attendees:
-  #       sequencer:
-  #         sequences: [ [AS, "2, 1"], [AK, "2, 1"] ]
-  # Hiermit werden dem Sequencer zwei Regeln mitgeteilt: Er soll Adjektiv-Substantiv- (AS) und
-  # Adjektiv-Kompositum-Folgen (AK) erkennen. Zusätzlich ist angegeben, in welchem Format die
-  # dadurch ermittelte Wortfolge ausgegeben werden soll. In diesem Beispiel also zuerst das
-  # Substantiv und durch Komma getrennt das Adjektiv.
-  #
-  # === 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: token, out: words, source: 'sys-dic' }
-  #       - sequencer:    { in: words, out: seque }
-  #       - debugger:     { in: seque, prompt: 'out>' }
-  # ergibt die Ausgabe über den Debugger: <tt>lingo -c t1 test.txt</tt>
-  #   out> *FILE('test.txt')
-  #   out> <Lingo|?>
-  #   out> <kann = [(koennen/v)]>
-  #   out> <indexierung, automatisch|SEQ = [(indexierung, automatisch/q)]>
-  #   out> <automatische = [(automatisch/a)]>
-  #   out> <Indexierung = [(indexierung/s)]>
-  #   out> <und = [(und/w)]>
-  #   out> <indexierung, genial|SEQ = [(indexierung, genial/q)]>
-  #   out> <geniale = [(genial/a), (genialisch/a)]>
-  #   out> <Indexierung = [(indexierung/s)]>
-  #   out> :./PUNC:
-  #   out> *EOL('test.txt')
-  #   out> *EOF('test.txt')
-
-  class Attendee::Sequencer < BufferedAttendee
-
-    protected
-
-    def init
-      # Parameter verwerten
-      @stopper = get_array('stopper', TA_PUNCTUATION + ',' + TA_OTHER).map { |s| s.upcase }
-      @seq_strings = get_key('sequences').map { |e| WordSequence.new(*e) }
-
-      forward(STR_CMD_ERR, 'Konfiguration ist leer') if @seq_strings.empty?
-    end
+        unless @buffer.size < 2
+          matches = Hash.new { |h, k| h[k] = [] }
 
-    def control(cmd, par)
-      # Jedes Control-Object ist auch Auslöser der Verarbeitung
-      process_buffer if [STR_CMD_RECORD, STR_CMD_EOF].include?(cmd)
-    end
+          sequences(@buffer.map { |obj|
+            obj.is_a?(Word) && !obj.unknown? ? obj.attrs(false) : ['#']
+          }).uniq.each { |sequence|
+            @seq_strings.each { |wordseq|
+              wordseq.scan(sequence) { |pos, form, classes|
+                inc('Anzahl erkannter Sequenzen')
 
-    def process_buffer?
-      #   start buffer processing when stopper token are found or at unknown words
-      item = @buffer.last
-      (item.is_a?(StringA) && @stopper.include?(item.attr.upcase)) ||
-      (item.is_a?(Word) && item.unknown?)
-    end
+                classes.each_with_index { |wc, index|
+                  @buffer[pos + index].lexicals.find { |lex|
+                    form.gsub!(index.succ.to_s, lex.form) if lex.attr == wc
+                  } or break
+                } or next
+
+                matches[pos] << form
+              }
+            }
+          }
 
-    def process_buffer
-      return if @buffer.empty?
+          matches.sort.each { |pos, forms|
+            forms.uniq.each { |form|
+              deferred_insert(pos, Word.new_lexical(form, WA_SEQUENCE, LA_SEQUENCE))
+            }
+          }
+        end
 
-      unless @buffer.size < 2
-        matches = Hash.new { |h, k| h[k] = [] }
+        forward_buffer
+      end
 
-        sequences(@buffer.map { |obj|
-          obj.is_a?(Word) && !obj.unknown? ? obj.attrs(false) : ['#']
-        }).uniq.each { |sequence|
-          @seq_strings.each { |wordseq|
-            wordseq.scan(sequence) { |pos, form, classes|
-              inc('Anzahl erkannter Sequenzen')
+      private
 
-              classes.each_with_index { |wc, index|
-                @buffer[pos + index].lexicals.find { |lex|
-                  form.gsub!(index.succ.to_s, lex.form) if lex.attr == wc
-                } or break
-              } or next
+      def sequences(map)
+        res = map.shift
 
-              matches[pos] << form
-            }
-          }
+        map.each { |classes|
+          temp = []
+          res.each { |wc1| classes.each { |wc2| temp << (wc1 + wc2) } }
+          res = temp
         }
 
-        matches.sort.each { |pos, forms|
-          forms.uniq.each { |form|
-            deferred_insert(pos, Word.new_lexical(form, WA_SEQUENCE, LA_SEQUENCE))
-          }
-        }
+        res
       end
 
-      forward_buffer
-    end
+      class WordSequence
 
-    private
+        attr_reader :classes, :format, :string
 
-    def sequences(map)
-      res = map.shift
+        def initialize(wordclasses, format)
+          @string  = wordclasses.downcase
+          @classes = @string.split(//)
+          @format  = format
+        end
 
-      map.each { |classes|
-        temp = []
-        res.each { |wc1| classes.each { |wc2| temp << (wc1 + wc2) } }
-        res = temp
-      }
+        def scan(sequence)
+          pos = 0
+
+          while pos = sequence.index(string, pos)
+            yield pos, format.dup, classes
+            pos += 1
+          end
+        end
+
+      end
 
-      res
     end
 
   end