lingo 1.8.0

data/lib/lingo/attendee/noneword_filter.rb

@@ -0,0 +1,103 @@
+# 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
+#++
+
+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::Noneword_filter < Attendee
+
+    protected
+
+    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
+          deleteCmd
+        when STR_CMD_RECORD, STR_CMD_EOF
+          nones = @nonewords.sort.uniq
+          nones.each { |nw| forward(nw) }
+          add('Objekte gefiltert', nones.size)
+          @nonewords.clear
+      end
+    end
+
+    def process(obj)
+      if obj.is_a?(Word) && obj.attr==WA_UNKNOWN
+        inc('Anzahl nicht erkannter Wörter')
+        @nonewords << obj.form.downcase
+      end
+    end
+
+  end
+
+end

data/lib/lingo/attendee/objectfilter.rb

@@ -0,0 +1,86 @@
+# 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
+#++
+
+class Lingo
+
+  # 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:
+  #       - textreader:   { out: lines, files: '$(files)' }
+  #       - tokenizer:    { in: lines, out: token }
+  #       - wordsearcher: { in: token, out: words, source: 'sys-dic' }
+  #       - objectfilter: { 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 Attendee::Objectfilter < Attendee
+
+    protected
+
+    def init
+      @obj_eval = get_key('objects', 'true')
+    end
+
+    def process(obj)
+      forward(obj) if eval(@obj_eval)
+    end
+
+  end
+
+end

data/lib/lingo/attendee/sequencer.rb

@@ -0,0 +1,190 @@
+# 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
+#++
+
+class Lingo
+
+  class WordSequence
+
+    attr_reader :classes, :format, :string
+
+    def initialize(wordclasses, format)
+      @string  = wordclasses.downcase
+      @classes = @string.split(//)
+      @format  = format
+    end
+
+    def scan(sequence)
+      pos = 0
+
+      while pos = sequence.index(string, pos)
+        yield pos, format.dup, classes
+        pos += 1
+      end
+    end
+
+  end
+
+  # 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
+
+    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
+
+    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
+
+    def process_buffer
+      return if @buffer.empty?
+
+      unless @buffer.size < 2
+        matches = Hash.new { |h, k| h[k] = [] }
+
+        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')
+
+              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
+            }
+          }
+        }
+
+        matches.sort.each { |pos, forms|
+          forms.uniq.each { |form|
+            deferred_insert(pos, Word.new_lexical(form, WA_SEQUENCE, LA_SEQUENCE))
+          }
+        }
+      end
+
+      forward_buffer
+    end
+
+    private
+
+    def sequences(map)
+      res = map.shift
+
+      map.each { |classes|
+        temp = []
+        res.each { |wc1| classes.each { |wc2| temp << (wc1 + wc2) } }
+        res = temp
+      }
+
+      res
+    end
+
+  end
+
+end

data/lib/lingo/attendee/synonymer.rb

@@ -0,0 +1,105 @@
+# 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
+#++
+
+class Lingo
+
+  # Der Synonymer untersucht die von anderen Attendees ermittelten Grundformen eines Wortes
+  # und sucht in den angegebenen Wörterbüchern nach Relationen zu anderen Grundformen.
+  # Gefundene Relationen erweitern die Liste des Word-Objektes und werden zur späteren
+  # Identifizierung mit der Wortklasse 'y' gekennzeichnet.
+  #
+  # === Mögliche Verlinkung
+  # Erwartet:: Daten vom Typ *Word* z.B. von Wordsearcher, Decomposer, Ocr_variator, Multiworder
+  # Erzeugt:: Daten vom Typ *Word* (ggf. um Relationen ergänzt) z.B. für Decomposer, 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
+  # <b><i>skip</i></b>:: (Standard: WA_UNKNOWN [siehe strings.rb]) Veranlasst den Synonymer
+  #                      Wörter mit diesem Attribut zu überspringen.
+  #
+  # === 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' }
+  #       - synonymer:    { in: words, out: synos, source: 'sys-syn' }
+  #       - debugger:     { in: words, prompt: 'out>' }
+  # ergibt die Ausgabe über den Debugger: <tt>lingo -c t1 test.txt</tt>
+  #   out> *FILE('test.txt')
+  #   out> <Dies = [(dies/w), (das/y), (dies/y)]>
+  #   out> <ist = [(sein/v), ((sich) befinden/y), (dasein/y), (existenz/y), (sein/y), (vorhandensein/y)]>
+  #   out> <ggf. = [(gegebenenfalls/w), (bei bedarf/y), (gegebenenfalls/y), (ggf./y), (notfalls/y)]>
+  #   out> <eine = [(einen/v), (ein/w)]>
+  #   out> <Abk³rzung = [(abk³rzung/s), (abbreviation/y), (abbreviatur/y), (abk³rzung/y), (akronym/y), (kurzbezeichnung/y)]>
+  #   out> :./PUNC:
+  #   out> *EOL('test.txt')
+  #   out> *EOF('test.txt')
+
+  class Attendee::Synonymer < Attendee
+
+    protected
+
+    def init
+      # Wörterbuch bereitstellen
+      src = get_array('source')
+      mod = get_key('mode', 'all')
+      @dic = Dictionary.new({'source'=>src, 'mode'=>mod}, @lingo)
+
+      @skip = get_array('skip', WA_UNKNOWN).collect {|s| s.upcase }
+    end
+
+    def control(cmd, par)
+      @dic.report.each_pair { |k, v| set( k, v ) } if cmd == STR_CMD_STATUS
+    end
+
+    def process(obj)
+      if obj.is_a?(Word) && @skip.index(obj.attr).nil?
+        inc('Anzahl gesuchter Wörter')
+
+        # finde die Synonyme für alle Lexicals des Wortes
+        synos = @dic.find_synonyms(obj)
+        obj.lexicals += synos.sort.uniq
+
+        inc('Anzahl erweiteter Wörter') if synos.size>0
+        add('Anzahl gefundener Synonyme', synos.size)
+      end
+      forward(obj)
+    end
+
+  end
+
+end