lingo 1.8.0

data/lib/lingo/attendee/textreader.rb

@@ -0,0 +1,237 @@
+# encoding: utf-8
+
+#--
+# LINGO ist ein Indexierungssystem mit Grundformreduktion, Kompositumzerlegung,
+# Mehrworterkennung und Relationierung.
+#
+# Copyright (C) 2005-2007 John Vorhauer
+# Copyright (C) 2007-2011 John Vorhauer, Jens Wille
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation; either version 3 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
+#
+# For more information visit http://www.lex-lingo.de or contact me at
+# welcomeATlex-lingoDOTde near 50°55'N+6°55'E.
+#
+# Lex Lingo rules from here on
+#++
+
+%w[filemagic mime/types hpricot pdf-reader].each { |lib|
+  begin
+    require lib
+  rescue LoadError
+  end
+}
+
+class Lingo
+
+  # Der Textreader ist eine klassische Datenquelle. Er liest eine oder mehrere Dateien
+  # und gibt sie Zeilenweise in den Ausgabekanal. Der Start bzw. Wechsel einer Datei
+  # wird dabei über den Kommandokanal angekündigt, ebenso wie das Ende.
+  #
+  # Der Textreader kann ebenfalls ein spezielles Dateiformat verarbeiten, welches zum
+  # Austausch mit dem LIR-System dient. Dabei enthält die Datei Record-basierte Informationen,
+  # die wie mehrere Dateien verarbeitet werden.
+  #
+  # === Mögliche Verlinkung
+  # Erzeugt:: Daten des Typs *String* (Textzeile) z.B. für Tokenizer, Textwriter
+  #
+  # === Parameter
+  # Kursiv dargestellte Parameter sind optional (ggf. mit Angabe der Voreinstellung).
+  # Alle anderen Parameter müssen zwingend angegeben werden.
+  # <b>out</b>:: siehe allgemeine Beschreibung des Attendee
+  # <b>files</b>:: Es können eine oder mehrere Dateien angegeben werden, die nacheinander
+  #                eingelesen und zeilenweise weitergeleitet werden. Die Dateien werden mit
+  #                Komma voneinander getrennt, z.B.
+  #                  files: 'readme.txt'
+  #                  files: 'readme.txt,lingo.cfg'
+  # <b><i>lir-record-pattern</i></b>:: Mit diesem Parameter wird angegeben, woran der Anfang
+  #                                    eines neuen Records erkannt werden kann und wie die
+  #                                    Record-Nummer identifiziert wird. Das Format einer
+  #                                    LIR-Datei ist z.B.
+  #                                      [00001.]
+  #                                      020: ¬Die Aufgabenteilung zwischen Wortschatz und Grammatik.
+  #
+  #                                      [00002.]
+  #                                      020: Nicht-konventionelle Thesaurusrelationen als Orientierungshilfen.
+  #                                    Mit der Angabe von
+  #                                      lir-record-pattern: "^\[(\d+)\.\]"
+  #                                    werden die Record-Zeilen erkannt und jeweils die Record-Nummer +00001+,
+  #                                    bzw. +00002+ erkannt.
+  #
+  # === Generierte Kommandos
+  # Damit der nachfolgende Datenstrom einwandfrei verarbeitet werden kann, generiert der Textreader
+  # Kommandos, die mit in den Datenstrom eingefügt werden.
+  # <b>*FILE(<dateiname>)</b>:: Kennzeichnet den Beginn der Datei <dateiname>
+  # <b>*EOF(<dateiname>)</b>:: Kennzeichnet das Ende der Datei <dateiname>
+  # <b>*LIR_FORMAT('')</b>:: Kennzeichnet die Verarbeitung einer Datei im LIR-Format (nur bei LIR-Format).
+  # <b>*RECORD(<nummer>)</b>:: Kennzeichnet den Beginn eines neuen Records (nur bei LIR-Format).
+  # === Beispiele
+  # Bei der Verarbeitung einer normalen Textdatei mit der Ablaufkonfiguration <tt>t1.cfg</tt>
+  #   meeting:
+  #     attendees:
+  #       - textreader: { out: lines, files: '$(files)' }
+  #       - debugger:   { in: lines, prompt: 'out>' }
+  # ergibt die Ausgabe über den Debugger: <tt>lingo -c t1 test.txt</tt>
+  #   out> *FILE('test.txt')
+  #   out> "Dies ist eine Zeile."
+  #   out> "Dies ist noch eine."
+  #   out> *EOF('test.txt')
+  # Bei der Verarbeitung einer LIR-Datei mit der Ablaufkonfiguration <tt>t2.cfg</tt>
+  #   meeting:
+  #     attendees:
+  #       - textreader: { out: lines,  files: '$(files)', lir-record-pattern: "^\[(\d+)\.\]" }
+  #       - debugger:   { in: lines, prompt: 'out>'}
+  # ergibt die Ausgabe mit <tt>lingo -c t2 lir.txt</tt>
+  #   out> *LIR-FORMAT('')
+  #   out> *FILE('lir.txt')
+  #   out> *RECORD('00001')
+  #   out> "020: \254Die Aufgabenteilung zwischen Wortschatz und Grammatik."
+  #   out> *RECORD('00002')
+  #   out> "020: Nicht-konventionelle Thesaurusrelationen als Orientierungshilfen."
+  #   out> *EOF('lir.txt')
+
+  class Attendee::Textreader < Attendee
+
+    protected
+
+    # TODO: FILE und LIR-FILE
+    # TODO: lir-record-pattern abkürzen
+    # Interpretation der Parameter
+    def init
+      @files = Array(get_key('files', '-'))
+      @rec_pat = Regexp.new(get_key('lir-record-pattern', ''))
+      @is_LIR_file = has_key?('lir-record-pattern')
+      @chomp = get_key('chomp', true)
+      @filter = get_key('filter', false)
+    end
+
+    def control(cmd, param)
+      if cmd==STR_CMD_TALK
+        forward(STR_CMD_LIR, '') if @is_LIR_file
+        @files.each { |filename| spool(filename) }
+      end
+    end
+
+    private
+
+    # Gibt eine Datei zeilenweise in den Ausgabekanal
+    def spool(filename)
+      unless stdin?(filename)
+        FileTest.exist?(filename) || forward(STR_CMD_ERR, "Datei #{filename} nicht gefunden")
+
+        inc('Anzahl Dateien')
+        add('Anzahl Bytes', File.stat(filename).size)
+      end
+
+      forward(STR_CMD_FILE, filename)
+
+      filter(filename) { |line|
+        inc('Anzahl Zeilen')
+        line.chomp! if @chomp
+        line.gsub!(/\303\237/, "ß")
+    ### HACK
+        if @is_LIR_file && line =~ @rec_pat
+          forward(STR_CMD_RECORD, $1)
+        else
+          forward(line) if line.size>0
+        end
+      }
+
+      forward(STR_CMD_EOF, filename)
+    end
+
+    def filter(filename, &block)
+      file = stdin?(filename) ?
+        @lingo.config.stdin.set_encoding(ENC) :
+        File.open(filename, 'rb', encoding: ENC)
+
+      file = case @filter == true ? file_type(filename, file) : @filter.to_s
+        when /html/ then filter_html(file)
+        when /xml/  then filter_html(file, true)
+        when /pdf/  then filter_pdf(file, &block) or return
+        else file
+      end if @filter
+
+      file.each_line(&block)
+    end
+
+    def filter_pdf(file, &block)
+      if Object.const_defined?(:PDF) && PDF.const_defined?(:Reader)
+        PDFFilter.filter(file, &block)
+        nil
+      else
+        warn "PDF filter not available. Please install `pdf-reader'."
+        file
+      end
+    end
+
+    def filter_html(file, xml = false)
+      if Object.const_defined?(:Hpricot)
+        Hpricot(file, xml: xml).inner_text
+      else
+        warn "#{xml ? 'X' : 'HT'}ML filter not available. Please install `hpricot'."
+        file
+      end
+    end
+
+    def file_type(filename, file)
+      if Object.const_defined?(:FileMagic) && file.respond_to?(:rewind)
+        type = FileMagic.fm(:mime, simplified: true).buffer(file.read(256))
+        file.rewind
+        type
+      elsif Object.const_defined?(:MIME) && MIME.const_defined?(:Types)
+        if type = MIME::Types.of(filename).first
+          type.content_type
+        else
+          warn 'Filters not available. File type could not be determined.'
+          nil
+        end
+      else
+        warn "Filters not available. Please install `ruby-filemagic' or `mime-types'."
+        nil
+      end
+    end
+
+    def stdin?(filename)
+      %w[STDIN -].include?(filename)
+    end
+
+    class PDFFilter
+
+      def self.filter(file, &block)
+        PDF::Reader.new.parse(file, new(&block))
+      end
+
+      def initialize(&block)
+        @block = block
+      end
+
+      def show_text(string, *params)
+        @block[string << '|']
+      end
+
+      alias_method :super_show_text,                 :show_text
+      alias_method :move_to_next_line_and_show_text, :show_text
+      alias_method :set_spacing_next_line_show_text, :show_text
+
+      def show_text_with_positioning(params, *)
+        params.each { |param| show_text(param) if param.is_a?(String) }
+      end
+
+    end
+
+  end
+
+end

data/lib/lingo/attendee/textwriter.rb

@@ -0,0 +1,196 @@
+# 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 Textwriter ermöglicht die Umleitung des Datenstroms in eine Textdatei. Dabei werden
+  # Objekte, die nicht vom Typ String sind in eine sinnvolle Textrepresentation gewandelt.
+  # Der Name der Ausgabedatei wird durch den Namen der Eingabedatei (des Textreaders) bestimmt.
+  # Es kann lediglich die Extension verändert werden. Der Textwriter kann auch das LIR-Format
+  # erzeugen.
+  #
+  # === Mögliche Verlinkung
+  # Erwartet:: Daten verschiedenen 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>ext</i></b>:: (Standard: txt2) Gibt die Dateinamen-Erweiertung für die Ausgabedatei an.
+  #                     Wird z.B. dem Textreader die Datei <tt>Dokument.txt</tt> angegeben und
+  #                     über die Lingo-Konfiguration alle Indexwörter herausgefiltert, kann mit
+  #                     <tt>ext: 'idx'</tt> der Textwriter veranlasst werden, die Indexwörter in
+  #                     die Datei <tt>Dokument.idx</tt> zu schreiben.
+  # <b><i>sep</i></b>:: (Standard: ' ') Gibt an, mit welchem Trennzeichen zwei aufeinanderfolgende
+  #                     Objekte in der Ausgabedatei getrennt werden sollen. Gängige Werte sind auch
+  #                     noch '\n', welches die Ausgabe jedes Objektes in eine Zeile ermöglicht.
+  # <b><i>lir-format</i></b>:: (Standard: false) Dieser Parameter hat keinen Wert. Wird er angegeben,
+  #                            dann wird er als true ausgewertet. Damit ist es möglich, die Ausgabedatei
+  #                            im für LIR lesbarem Format zu erstellen.
+  #
+  # === Beispiele
+  # Bei der Verarbeitung der oben angegebenen Funktionsbeschreibung des Textwriters 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' }
+  #       - vector_filter: { in: words, out: filtr, sort: 'term_rel' }
+  #       - textwriter:    { in: filtr, ext: 'vec', sep: '\n' }
+  # ergibt die Ausgabe in der Datei <tt>test.vec</tt>
+  #   0.03846 name
+  #   0.01923 ausgabedatei
+  #   0.01923 datenstrom
+  #   0.01923 extension
+  #   0.01923 format
+  #   0.01923 objekt
+  #   0.01923 string
+  #   0.01923 textdatei
+  #   0.01923 typ
+  #   0.01923 umleitung
+
+  class Attendee::Textwriter < Attendee
+
+    protected
+
+    def init
+      @ext = get_key('ext', 'txt2')
+      @lir = get_key('lir-format', false)
+      @sep = @lir ? ' ' : eval("\"#{@config['sep'] || ' '}\"")
+      @no_sep, @no_puts = true, false
+    end
+
+    def control(cmd, par)
+      case cmd
+        when STR_CMD_LIR
+          @lir = true
+        when STR_CMD_FILE
+          @no_sep = true
+
+          if stdout?(@ext)
+            @filename = @ext
+            @file = @lingo.config.stdout
+          else
+            @filename = par.sub(/(\.[^.]+)?$/, '.'+@ext)
+            @file = File.new(@filename,'w')
+            inc('Anzahl Dateien')
+          end
+
+          @lir_rec_no = ''
+          @lir_rec_buf = Array.new
+        when STR_CMD_RECORD
+          @no_sep = true
+          if @lir
+            flush_lir_buffer
+            @lir_rec_no = par
+          end
+        when STR_CMD_EOL
+          @no_sep = true
+          unless @lir
+            @file.puts unless @no_puts # unless @sep=="\n"
+            inc('Anzahl Zeilen')
+          end
+        when STR_CMD_EOF
+          flush_lir_buffer if @lir
+
+          unless stdout?(@filename)
+            @file.close
+            add('Anzahl Bytes', File.stat(@filename).size)
+          end
+      end
+    end
+
+    def process(obj)
+      if @lir
+        @lir_rec_buf << (obj.kind_of?(Token) ? obj.form : obj.to_s)
+      else
+        @file.print @sep unless @no_sep
+        @no_sep=false if @no_sep
+        if obj.is_a?(Word) || obj.is_a?(Token)
+          @file.print obj.form
+        else
+          @file.print obj
+        end
+      end
+    end
+
+    private
+
+    def flush_lir_buffer
+      unless @lir_rec_no.empty? || @lir_rec_buf.empty?
+        if @sep =~ /\n/
+          @file.print '*', @lir_rec_no, "\n", @lir_rec_buf.join(@sep), "\n"
+        else
+          @file.print @lir_rec_no, '*', @lir_rec_buf.join(@sep), "\n"
+        end
+      end
+      @lir_rec_no = ''
+      @lir_rec_buf.clear
+    end
+
+    def stdout?(filename)
+      %w[STDOUT -].include?(filename)
+    end
+
+  end
+
+  class Attendee::Formatter < Attendee::Textwriter
+
+    protected
+
+    def init
+      super
+
+      @ext    = get_key('ext', '-')
+      @format = get_key('format', '%s')
+      @map    = get_key('map', Hash.new { |h, k| h[k] = k })
+
+      @no_puts = true
+    end
+
+    def process(obj)
+      if obj.is_a?(Word) || obj.is_a?(Token)
+        str = obj.form
+
+        if obj.respond_to?(:lexicals)
+          lex = obj.lexicals.first  # TODO
+          att = @map[lex.attr] if lex
+          str = @format % [str, lex.form, att] if att
+        end
+      else
+        str = obj.to_s
+      end
+
+      @lir ? @lir_rec_buf << str : @file.print(str)
+    end
+
+  end
+
+end

data/lib/lingo/attendee/tokenizer.rb

@@ -0,0 +1,218 @@
+# 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 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
+          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
+
+    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
+
+    def process(obj)
+      if obj.is_a?(String)
+        inc('Anzahl Zeilen')
+
+        tokenize(obj) { |form, attr|
+          token = Token.new(form, attr)
+
+          inc('Anzahl Muster '+token.attr)
+          inc('Anzahl Token')
+
+          forward(token)
+        }
+
+        forward(STR_CMD_EOL, @filename) if @filename
+      else
+        forward(obj)
+      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
+
+          if !@wiki && textline =~ /\[\[[^\[\]]*$/
+            yield $~[0], @cont = 'WIKI'
+            textline = $`
+          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
+
+end