lingo 1.8.0 → 1.8.1

data/lib/lingo/attendee/abbreviator.rb

@@ -1,117 +1,115 @@
 # 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
 
-  # Die Erkennung von Abkürzungen kann auf vielfältige Weise erfolgen. In jedem Fall
-  # sollte eine sichere Unterscheidung von einem Satzende-Punkt möglich sein.
-  # Der in Lingo gewählte Ansatz befreit den Tokenizer von dieser Arbeit und konzentriert
-  # die Erkennung in diesem Attendee.
-  # Sobald der Abbreviator im Datenstrom auf ein Punkt trifft (Token = <tt>:./PUNC:</tt>),
-  # prüft er das vorhergehende Token auf eine gültige Abkürzung im Abkürzungs-Wörterbuch.
-  # Wird es als Abkürzung erkannt, dann wird das Token in ein Word gewandelt und das
-  # Punkt-Token aus dem Zeichenstrom entfernt.
-  #
-  # === Mögliche Verlinkung
-  # Erwartet:: Daten des Typs *Token* z.B. von Tokenizer
-  # Erzeugt:: Leitet Token weiter und wandelt erkannte Abkürzungen in den Typ *Word* z.B. für 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
-  # <b>source</b>:: siehe allgemeine Beschreibung des Dictionary
-  # <b><i>mode</i></b>:: (Standard: all) siehe allgemeine Beschreibung des Dictionary
-  #
-  # === 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 }
-  #       - abbreviator: { in: token, out: abbrev, source: 'sys-abk' }
-  #       - debugger:    { in: abbrev, 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> <ggf. = [(gegebenenfalls/w)]>
-  #   out> :eine/WORD:
-  #   out> :Abk³rzung/WORD:
-  #   out> :./PUNC:
-  #   out> *EOL('test.txt')
-  #   out> *EOF('test.txt')
-
-  class Attendee::Abbreviator < BufferedAttendee
-
-    protected
-
-    def init
-      # Wörterbuch bereitstellen
-      src = get_array('source')
-      mod = get_key('mode', 'all')
-      @dic = Dictionary.new({'source'=>src, 'mode'=>mod}, @lingo)
-    end
+  class Attendee
 
-    def control(cmd, par)
-      @dic.report.each_pair { |key, value| set(key, value) } if cmd == STR_CMD_STATUS
+    # Die Erkennung von Abkürzungen kann auf vielfältige Weise erfolgen. In jedem Fall
+    # sollte eine sichere Unterscheidung von einem Satzende-Punkt möglich sein.
+    # Der in Lingo gewählte Ansatz befreit den Tokenizer von dieser Arbeit und konzentriert
+    # die Erkennung in diesem Attendee.
+    # Sobald der Abbreviator im Datenstrom auf ein Punkt trifft (Token = <tt>:./PUNC:</tt>),
+    # prüft er das vorhergehende Token auf eine gültige Abkürzung im Abkürzungs-Wörterbuch.
+    # Wird es als Abkürzung erkannt, dann wird das Token in ein Word gewandelt und das
+    # Punkt-Token aus dem Zeichenstrom entfernt.
+    #
+    # === Mögliche Verlinkung
+    # Erwartet:: Daten des Typs *Token* z.B. von Tokenizer
+    # Erzeugt:: Leitet Token weiter und wandelt erkannte Abkürzungen in den Typ *Word* z.B. für 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
+    # <b>source</b>:: siehe allgemeine Beschreibung des Dictionary
+    # <b><i>mode</i></b>:: (Standard: all) siehe allgemeine Beschreibung des Dictionary
+    #
+    # === 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 }
+    #       - abbreviator:  { in: token, out: abbrev, source: 'sys-abk' }
+    #       - debugger:     { in: abbrev, 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> <ggf. = [(gegebenenfalls/w)]>
+    #   out> :eine/WORD:
+    #   out> :Abk³rzung/WORD:
+    #   out> :./PUNC:
+    #   out> *EOL('test.txt')
+    #   out> *EOF('test.txt')
 
-      # Jedes Control-Object ist auch Auslöser der Verarbeitung
-      process_buffer
-    end
+    class Abbreviator < BufferedAttendee
 
-    private
+      protected
 
-    def process_buffer?
-      @buffer[-1].kind_of?(Token) && @buffer[-1].form == CHAR_PUNCT
-    end
+      def init
+        set_dic
+      end
 
-    def process_buffer
-      if @buffer.size < 2
-        forward_buffer
-        return
+      def control(cmd, par)
+        @dic.report.each_pair { |key, value| set(key, value) } if cmd == STR_CMD_STATUS
+
+        # Jedes Control-Object ist auch Auslöser der Verarbeitung
+        process_buffer
       end
 
-      # Wort vor dem Punkt im Abkürzungswörterbuch suchen
-      if @buffer[-2].kind_of?(Token)
-        inc('Anzahl gesuchter Abkürzungen')
-        abbr = @dic.find_word(@buffer[-2].form)
-        if abbr.attr == WA_IDENTIFIED
-          inc('Anzahl gefundener Abkürzungen')
-          abbr.form += CHAR_PUNCT
-          @buffer[-2] = abbr
-          @buffer.delete_at(-1)
+      private
+
+      def process_buffer?
+        @buffer[-1].kind_of?(Token) && @buffer[-1].form == CHAR_PUNCT
+      end
+
+      def process_buffer
+        if @buffer.size < 2
+          forward_buffer
+          return
+        end
+
+        # Wort vor dem Punkt im Abkürzungswörterbuch suchen
+        if @buffer[-2].kind_of?(Token)
+          inc('Anzahl gesuchter Abkürzungen')
+          abbr = @dic.find_word(@buffer[-2].form)
+          if abbr.identified?
+            inc('Anzahl gefundener Abkürzungen')
+            abbr.form += CHAR_PUNCT
+            @buffer[-2] = abbr
+            @buffer.delete_at(-1)
+          end
         end
+
+        forward_buffer
       end
 
-      forward_buffer
     end
 
   end

data/lib/lingo/attendee/debugger.rb

@@ -1,109 +1,110 @@
 # 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
 
-  # Die Attendees von Lingo übergeben Daten über ihre Kommunikationskanäle und entweder kommt bei
-  # einer komplexen Konfiguration hinten das gewünschte Ergebnis raus oder aber auch nicht. Für den
-  # letzeren Fall ist der Debugger primär gedacht. Er kann an beliebige Stelle in den Datenstrom
-  # eingeschleust werden, um Schritt für Schritt zu schauen, durch welchen Attendee das Ergebnis
-  # verfälscht wird um so den Fehler einzugrenzen und schließlich zu lösen.
-  #
-  # Der Debugger wird jedoch auch gerne für die Verfolgung der Verarbeitung am Bildschirm verwendet.
-  #
-  # Achtung: Um Irritationen bei der Anwendung mehrerer Debugger zu vermeiden wird empfohlen, den
-  # Debugger in der Konfiguration immer unmittelbar nach dem Attendee zu platzieren, dessen Ausgabe
-  # debugt werden soll. Ansonsten kann es zu scheinbar unerklärlichen Interferrenzen bei der Ausgabe
-  # kommen.
-  #
-  # === Mögliche Verlinkung
-  # Erwartet:: Daten beliebigen Typs
-  #
-  # === 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>eval</i></b>:: (Standard: true) Gibt eine Bedingung an, die erfüllt sein muss, damit ein
-  #                      Datenobjekt ausgegeben wird (siehe Beschreibung Objectfilter)
-  # <b><i>ceval</i></b>:: (Standard: true) Gibt eiune Bedingung an, die erfüllt sein muss, damit ein
-  #                      Kommandoobjekt ausgegeben wird.
-  # <b><i>prompt</i></b>:: (Standard: 'lex:) ') Gibt an, mit welchem Prefix die Ausgabe versehen werden
-  #                        soll. Insbesondere wenn mit mehreren Debuggern gearbeitet wird, sollte dies
-  #                        genutzt werden.
-  #
-  # === Beispiele
-  # Bei der Verarbeitung der oben angegebenen Funktionsbeschreibung des Textwriters mit der Ablaufkonfiguration <tt>t1.cfg</tt>
-  #   meeting:
-  #     attendees:
-  #       - textreader: { out: lines, files: '$(files)' }
-  #       - debugger:   { in: lines, prompt: 'LINES:) ' }
-  #       - tokenizer:  { in: lines, out: token }
-  #       - debugger:   { in: token, prompt: 'TOKEN:) ' }
-  # ergibt die Ausgabe
-  #   LINES:)  *FILE('test.txt')
-  #   TOKEN:)  *FILE('test.txt')
-  #   LINES:)  "Der Debugger kann was."
-  #   TOKEN:)  :Der/WORD:
-  #   TOKEN:)  :Debugger/WORD:
-  #   TOKEN:)  :kann/WORD:
-  #   TOKEN:)  :was/WORD:
-  #   TOKEN:)  :./PUNC:
-  #   TOKEN:)  *EOL('test.txt')
-  #   LINES:)  "Lingo auch :o)"
-  #   TOKEN:)  :Lingo/WORD:
-  #   TOKEN:)  :auch/WORD:
-  #   TOKEN:)  ::/PUNC:
-  #   TOKEN:)  :o/WORD:
-  #   TOKEN:)  :)/OTHR:
-  #   TOKEN:)  *EOL('test.txt')
-  #   LINES:)  *EOF('test.txt')
-  #   TOKEN:)  *EOF('test.txt')
+  class Attendee
 
-  class Attendee::Debugger < Attendee
+    # Die Attendees von Lingo übergeben Daten über ihre Kommunikationskanäle und entweder kommt bei
+    # einer komplexen Konfiguration hinten das gewünschte Ergebnis raus oder aber auch nicht. Für den
+    # letzeren Fall ist der Debugger primär gedacht. Er kann an beliebige Stelle in den Datenstrom
+    # eingeschleust werden, um Schritt für Schritt zu schauen, durch welchen Attendee das Ergebnis
+    # verfälscht wird um so den Fehler einzugrenzen und schließlich zu lösen.
+    #
+    # Der Debugger wird jedoch auch gerne für die Verfolgung der Verarbeitung am Bildschirm verwendet.
+    #
+    # Achtung: Um Irritationen bei der Anwendung mehrerer Debugger zu vermeiden wird empfohlen, den
+    # Debugger in der Konfiguration immer unmittelbar nach dem Attendee zu platzieren, dessen Ausgabe
+    # debugt werden soll. Ansonsten kann es zu scheinbar unerklärlichen Interferrenzen bei der Ausgabe
+    # kommen.
+    #
+    # === Mögliche Verlinkung
+    # Erwartet:: Daten beliebigen Typs
+    #
+    # === 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>eval</i></b>:: (Standard: true) Gibt eine Bedingung an, die erfüllt sein muss, damit ein
+    #                      Datenobjekt ausgegeben wird (siehe Beschreibung Objectfilter)
+    # <b><i>ceval</i></b>:: (Standard: true) Gibt eiune Bedingung an, die erfüllt sein muss, damit ein
+    #                      Kommandoobjekt ausgegeben wird.
+    # <b><i>prompt</i></b>:: (Standard: 'lex:) ') Gibt an, mit welchem Prefix die Ausgabe versehen werden
+    #                        soll. Insbesondere wenn mit mehreren Debuggern gearbeitet wird, sollte dies
+    #                        genutzt werden.
+    #
+    # === Beispiele
+    # Bei der Verarbeitung der oben angegebenen Funktionsbeschreibung des Textwriters mit der Ablaufkonfiguration <tt>t1.cfg</tt>
+    #   meeting:
+    #     attendees:
+    #       - text_reader: { out: lines, files: '$(files)' }
+    #       - debugger:    { in: lines, prompt: 'LINES:) ' }
+    #       - tokenizer:   { in: lines, out: token }
+    #       - debugger:    { in: token, prompt: 'TOKEN:) ' }
+    # ergibt die Ausgabe
+    #   LINES:)  *FILE('test.txt')
+    #   TOKEN:)  *FILE('test.txt')
+    #   LINES:)  "Der Debugger kann was."
+    #   TOKEN:)  :Der/WORD:
+    #   TOKEN:)  :Debugger/WORD:
+    #   TOKEN:)  :kann/WORD:
+    #   TOKEN:)  :was/WORD:
+    #   TOKEN:)  :./PUNC:
+    #   TOKEN:)  *EOL('test.txt')
+    #   LINES:)  "Lingo auch :o)"
+    #   TOKEN:)  :Lingo/WORD:
+    #   TOKEN:)  :auch/WORD:
+    #   TOKEN:)  ::/PUNC:
+    #   TOKEN:)  :o/WORD:
+    #   TOKEN:)  :)/OTHR:
+    #   TOKEN:)  *EOL('test.txt')
+    #   LINES:)  *EOF('test.txt')
+    #   TOKEN:)  *EOF('test.txt')
 
-    protected
+    class Debugger < self
 
-    def init
-      @obj_eval = get_key('eval', 'true')
-      @cmd_eval = get_key('ceval', 'true')
-      @prompt = get_key('prompt', 'lex:) ')
-    end
+      protected
 
-    def control(cmd, par)
-      if cmd!=STR_CMD_STATUS
-        @lingo.config.stderr.puts "#{@prompt} #{AgendaItem.new(cmd, par).inspect}" if eval(@cmd_eval)
+      def init
+        @obj_eval = get_key('eval',   'true')
+        @cmd_eval = get_key('ceval',  'true')
+        @prompt   = get_key('prompt', 'lex:) ')
+      end
+
+      def control(cmd, par)
+        if cmd != STR_CMD_STATUS
+          @lingo.warn "#{@prompt} #{AgendaItem.new(cmd, par).inspect}" if eval(@cmd_eval)
+        end
+      end
+
+      def process(obj)
+        @lingo.warn "#{@prompt} #{obj.inspect}" if eval(@obj_eval)
       end
-    end
 
-    def process(obj)
-      @lingo.config.stderr.puts "#{@prompt} #{obj.inspect}" if eval(@obj_eval)
     end
 
   end

data/lib/lingo/attendee/decomposer.rb

@@ -1,99 +1,92 @@
 # 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
 
-  # Komposita, also zusammengesetzte Wörter, sind eine Spezialität der deutschen Sprache
-  # (z.B. Indexierungssystem oder Kompositumerkennung).
-  # Könnte man alle Kombinationen in den Wörterbüchern hinterlegen, dann würde der
-  # Wordsearcher die Erkennung bereits erledigt haben. Die hohe Anzahl der möglichen
-  # Kombinationen verbietet jedoch einen solchen Ansatz aufgrund des immensen Pflegeaufwands,
-  # eine algorithmische Lösung erscheint sinnvoller.
-  # Der Decomposer wertet alle vom Wordsearcher nicht erkannten Wörter aus und prüft sie
-  # auf Kompositum.
-  #
-  # === Mögliche Verlinkung
-  # Erwartet:: Daten vom Typ *Word* (andere werden einfach durchgereicht) z.B. von Wordsearcher
-  # Erzeugt:: Daten vom Typ *Word* (erkannte Komposita werden entsprechend erweitert) z.B. für Synonymer, Ocr_variator, Multiworder, 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>source</b>:: siehe allgemeine Beschreibung des Dictionary
-  # <b><i>mode</i></b>:: (Standard: all) siehe allgemeine Beschreibung des Dictionary
-  #
-  # === 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 }
-  #       - abbreviator:  { in: token, out: abbrev, source: 'sys-abk' }
-  #       - wordsearcher: { in: abbrev, out: words, source: 'sys-dic' }
-  #       - decomposer:   { in: words, out: comps, source: 'sys-dic' }
-  #       - debugger:     { in: comps, prompt: 'out>' }
-  # ergibt die Ausgabe über den Debugger: <tt>lingo -c t1 test.txt</tt>
-  #   out> *FILE('test.txt')
-  #   out> <Lingo|?>
-  #   out> :,/PUNC:
-  #   out> <ein = [(ein/w)]>
-  #   out> <Indexierungssystem|KOM = [(indexierungssystem/k), (indexierung/s), (system/s)]>
-  #   out> <mit = [(mit/w)]>
-  #   out> <Kompositumerkennung|KOM = [(kompositumerkennung/k), (erkennung/s), (kompositum/s)]>
-  #   out> :./PUNC:
-  #   out> *EOL('test.txt')
-  #   out> *EOF('test.txt')
+  class Attendee
 
-  class Attendee::Decomposer < Attendee
+    # Komposita, also zusammengesetzte Wörter, sind eine Spezialität der deutschen Sprache
+    # (z.B. Indexierungssystem oder Kompositumerkennung).
+    # Könnte man alle Kombinationen in den Wörterbüchern hinterlegen, dann würde der
+    # Wordsearcher die Erkennung bereits erledigt haben. Die hohe Anzahl der möglichen
+    # Kombinationen verbietet jedoch einen solchen Ansatz aufgrund des immensen Pflegeaufwands,
+    # eine algorithmische Lösung erscheint sinnvoller.
+    # Der Decomposer wertet alle vom Wordsearcher nicht erkannten Wörter aus und prüft sie
+    # auf Kompositum.
+    #
+    # === Mögliche Verlinkung
+    # Erwartet:: Daten vom Typ *Word* (andere werden einfach durchgereicht) z.B. von Wordsearcher
+    # Erzeugt:: Daten vom Typ *Word* (erkannte Komposita werden entsprechend erweitert) z.B. für Synonymer, Ocr_variator, Multiworder, 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>source</b>:: siehe allgemeine Beschreibung des Dictionary
+    # <b><i>mode</i></b>:: (Standard: all) siehe allgemeine Beschreibung des Dictionary
+    #
+    # === 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 }
+    #       - abbreviator:   { in: token, out: abbrev, source: 'sys-abk' }
+    #       - word_searcher: { in: abbrev, out: words, source: 'sys-dic' }
+    #       - decomposer:    { in: words, out: comps, source: 'sys-dic' }
+    #       - debugger:      { in: comps, prompt: 'out>' }
+    # ergibt die Ausgabe über den Debugger: <tt>lingo -c t1 test.txt</tt>
+    #   out> *FILE('test.txt')
+    #   out> <Lingo|?>
+    #   out> :,/PUNC:
+    #   out> <ein = [(ein/w)]>
+    #   out> <Indexierungssystem|KOM = [(indexierungssystem/k), (indexierung/s), (system/s)]>
+    #   out> <mit = [(mit/w)]>
+    #   out> <Kompositumerkennung|KOM = [(kompositumerkennung/k), (erkennung/s), (kompositum/s)]>
+    #   out> :./PUNC:
+    #   out> *EOL('test.txt')
+    #   out> *EOF('test.txt')
 
-    protected
+    class Decomposer < self
 
-    def init
-      # Wörterbuch bereitstellen
-      src = get_array('source')
-      mod = get_key('mode', 'all')
-      @grammar = Grammar.new({'source'=>src, 'mode'=>mod}, @lingo)
-    end
+      protected
 
-    def control(cmd, par)
-      @grammar.report.each_pair { |key, value|
-        set(key, value)
-      } if cmd == STR_CMD_STATUS
-    end
+      def init
+        set_gra
+      end
 
-    def process(obj)
-      if obj.is_a?(Word) && obj.attr == WA_UNKNOWN
-        obj = @grammar.find_compositum(obj.form)
+      def control(cmd, par)
+        @gra.report.each { |key, val| set(key, val) } if cmd == STR_CMD_STATUS
       end
-      forward(obj)
+
+      def process(obj)
+        forward(obj.is_a?(Word) && obj.unknown? ? @gra.find_compositum(obj.form) : obj)
+      end
+
     end
 
   end