lingo 1.8.0

data/porter/stem.rb

@@ -0,0 +1,150 @@
+# encoding: utf-8
+
+require "yaml"
+class String
+  def to_shadow
+    shadow = self.gsub(/[^aeiouy]/, 'c')
+    shadow.gsub!(/[aeiou]/, 'v')
+    shadow.gsub!(/cy/, 'cv')
+    shadow.gsub!(/y/, 'c')
+    shadow
+  end
+end
+
+
+
+# => condition nil oder eine evaluierbare regel
+# => matchExp eine Regexp
+# => replacement ist downcase
+# => return new stem or nil, if rule didn't match
+def checkSingleRule(word, condition, matchExp, replacement)
+
+  # => check for matching rule
+  return nil unless matchExp.match(word)
+
+  # => remember stem
+  stem = $1
+
+  # => check condition for rule
+  unless condition.nil?
+    evalCondition = condition.dup
+
+    stemShadow = stem.to_shadow
+    
+    unless condition.index("m").nil?
+      m = stemShadow.squeeze.scan(/vc/).size
+      evalCondition.gsub!(/m/, m.to_s)
+    end
+    
+    unless condition.index("*v*").nil?
+      evalCondition.gsub!(/\*v\*/, stemShadow.index("v").nil? ? "false" : "true")
+    end
+    
+    unless condition.index("*d").nil?
+      evalCondition.gsub!(/\*d/, (stemShadow[-1..-1]=="c" && stem[-1]==stem[-2]) ? "true" : "false")
+    end
+    
+    unless condition.index("*o").nil?
+      bool = /cvc$/.match(stemShadow) && "wxy".index(stemShadow[-1..-1]).nil?
+      evalCondition.gsub!(/\*o/, bool ? "true" : "false")
+    end
+
+    while /\*(\w)/.match(evalCondition)
+      char = $1
+      if char.downcase == char
+        abort "unbekannter Buchstabe %s in Regel: %" % [char, condition]
+      end
+      
+      bool = (stem[-1..-1].upcase == char)
+      evalCondition.gsub!(Regexp.new(Regexp.escape("*#{char}")), bool ? "true" : "false")
+    end
+
+    evalCondition.gsub!(/and/, '&&')
+    evalCondition.gsub!(/or/, '||')
+    evalCondition.gsub!(/not/, '!')
+    evalCondition.gsub!(/=/, '==')
+p evalCondition
+    return unless eval(evalCondition)
+  end
+
+  # => stem with replacement
+  if /^(-\d+)$/.match(replacement)
+    # => delete last characters from stem, if replacement looks like '-1' oder '-2'
+    stem[0...($1.to_i)]
+  else
+    # => append replacement to stem
+    stem + replacement
+  end
+    
+end
+
+def checkAllRules(word, rules)
+  sequence = rules.keys.sort.reverse
+
+  actualRuleSet = sequence.pop.to_s
+
+  begin
+    label = nil
+
+    rules[actualRuleSet].each do |rule|
+      unless /^(\(.+\)){0,1}\s*(\S*)\s*->\s*(\S*?)\s*(?:goto\((\S+)\))*\s*$/.match(rule)
+        unless /^\s*goto\s*\(\s*(\S+)\s*\)$/.match(rule)
+          abort "ungültige Regel: %s" % rule
+        else
+          label = $1
+          break
+        end
+      end
+      
+      condition, ending, replacement, label = $1, $2.downcase, $3.downcase, $4     
+      p   [rule, word, condition, ending, replacement, label ]
+      result = checkSingleRule(word, condition, Regexp.new("(.+)#{ending}$"), replacement)
+
+      unless result.nil?
+        p [word, actualRuleSet, rule]
+        word = result
+        break
+      end
+    end
+    
+    if label.nil?
+      actualRuleSet = sequence.pop.to_s
+    else
+      while label != actualRuleSet && !actualRuleSet.nil?
+        actualRuleSet = sequence.pop.to_s
+      end
+    end
+  end until actualRuleSet.empty?
+
+  word
+end
+
+stemmerConfig = YAML::load_file("stem.cfg")
+
+$rules = stemmerConfig["stemmer"]
+
+word = $*[0]
+p checkAllRules(word, $rules)
+
+def test(word, stem)
+  result = checkAllRules(word, $rules)
+  if stem != result
+    warn "Falsches Wort %s, Stem %s, Result %s" % [word, stem, result]
+  else
+    warn "Korrekt: Wort %s, Stem %s" % [word, stem]
+  end
+end
+
+
+#test("caresses", "caress")
+#test("ponies", "poni")
+#test("ties", "ti")
+#test("caress", "caress")
+#test("cats", "cat")
+
+#test("feed", "feed")
+#?test("agreed", "agree")
+#test("plastered", "plaster")
+#test("bled", "bled")
+#test("motoring", "motor")
+#test("sing", "sing")

data/test.cfg

@@ -0,0 +1,79 @@
+#
+#  Lingo-Konfiguration für den Test mit einer Textdatei
+#
+---
+meeting:
+
+  attendees:
+
+    ########################################
+    #  Text bereitstellen
+    #
+
+    #  Angegebene Datei zeilenweise einlesen und verarbeiten
+    -  textreader:      { files: '$(files)' }
+
+
+    ########################################
+    #  Inhalte verarbeiten
+    #
+
+    #  Zeile in einzelnen Sinnbestandteile (Token) zerlegen
+    -  tokenizer:       { }
+
+    #  Abkürzungen erkennen und auflösen
+#   -  abbreviator:     { source: 'sys-abk' }
+
+    #  Verbleibende Token im Wörterbuch suchen
+    -  wordsearcher:    { source: 'sys-dic', mode: 'first' }
+
+    #  Nicht erkannte Wörter auf Kompositum testen
+    -  decomposer:      { source: 'sys-dic' }
+
+    #  Mehrwortgruppen im Strom erkennen
+    -  multiworder:     { stopper: 'PUNC,OTHR', source: 'sys-mul' }
+
+    #  Wortsequenzen anhand von Regeln identifizieren
+    -  sequencer:       { stopper: 'PUNC,OTHR' }
+
+    #  Relationierungen einfügen
+    -  synonymer:       { skip: '?,t', source: 'sys-syn', out: syn }
+
+
+    ########################################
+    #  Datenstrom anzeigen
+    #
+    -  debugger:        { eval: 'true', ceval: 'cmd!="EOL"', prompt: 'lex:) ' }
+
+
+    ########################################
+    #  Ergebnisse ausgeben
+    #
+
+    #  Erstelle Datei mit Endung .non für nicht erkannte Wörter
+    -  noneword_filter: { in: syn }
+    -  textwriter:      { ext: non, sep: "\n" }
+
+    #  Erstelle Datei mit Endung .vec für erkannte Indexterme
+    -  vector_filter:   { in: syn, lexicals: '^[ksavem]$', sort: 'term_abs' }
+    -  textwriter:      { ext: vec, sep: "\n" }
+
+    #  Erstelle Datei mit Endung .vec für erkannte Indexterme mit absoluter Häufigkeit
+    -  vector_filter:   { in: syn, lexicals: '^[ksavem]$' }
+    -  textwriter:      { ext: ven, sep: "\n" }
+
+    #  Erstelle Datei mit Endung .vec für erkannte Indexterme mit relativer Häufigkeit
+    -  vector_filter:   { in: syn, lexicals: '^[ksavem]$', sort: 'term_rel' }
+    -  textwriter:      { ext: ver, sep: "\n" }
+
+    #  Erstelle Datei mit Endung .mul für erkannte Mehrwortgruppen
+    -  vector_filter:   { in: syn, lexicals: m }
+    -  textwriter:      { ext: mul, sep: "\n" }
+
+    #  Erstelle Datei mit Endung .seq für erkannte Wortsequenzen
+    -  vector_filter:   { in: syn, lexicals: q, sort: 'term_abs' }
+    -  textwriter:      { ext: seq, sep: "\n" }
+
+    #  Erstelle Datei mit Endung .syn für erkannte Synonyme
+    -  vector_filter:   { in: syn, lexicals: y, sort: 'term_abs' }
+    -  textwriter:      { ext: syn, sep: "\n" }

data/test/attendee/ts_abbreviator.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require_relative '../test_helper'
+
+################################################################################
+#
+# Attendee Abbreviator
+#
+class TestAttendeeAbbreviator < AttendeeTestCase
+
+  def test_basic
+    @input = [
+      tk('z.b|ABRV'), tk('.|PUNC'),
+      tk('im|WORD'),
+      tk('14.|NUMS'),
+      tk('bzw|WORD'), tk('.|PUNC'),
+      tk('15.|NUMS'),
+      tk('Jh|WORD'), tk('.|PUNC'),
+      ai('EOL|')
+    ]
+    @expect = [
+      wd('z.b.|IDF', 'zum beispiel|w'),
+      tk('im|WORD'),
+      tk('14.|NUMS'),
+      wd('bzw.|IDF', 'beziehungsweise|w'),
+      tk('15.|NUMS'),
+      wd('Jh.|IDF', 'jahrhundert|s'),
+      ai('EOL|')
+    ]
+    meet({'source'=>'sys-abk'})
+  end
+
+end
+#
+################################################################################

data/test/attendee/ts_decomposer.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require_relative '../test_helper'
+
+################################################################################
+#
+# Attendee Decomposer
+#
+class TestAttendeeDecomposer < AttendeeTestCase
+
+  def test_basic
+    @input = [
+      wd('Kleinseite|?'),
+      wd('Arrafat-Nachfolger|?'),
+      wd('Afganistan-Reisen|?'),
+      wd('Kompositumzerlegung|?'),
+      wd('Kompositumzerlegung|?')
+    ]
+    @expect = [
+      wd('Kleinseite|KOM', 'kleinseite|k', 'klein|a+', 'seite|s+'),
+      wd('Arrafat-Nachfolger|KOM', 'arrafat-nachfolger|k', 'nachfolger|s+', 'arrafat|x+'),
+      wd('Afganistan-Reisen|KOM', 'afganistan-reise|k', 'reise|s+', 'reisen|v+', 'afganistan|x+'),
+      wd('Kompositumzerlegung|KOM', 'kompositumzerlegung|k', 'kompositum|s+', 'zerlegung|s+'),
+      wd('Kompositumzerlegung|KOM', 'kompositumzerlegung|k', 'kompositum|s+', 'zerlegung|s+')
+    ]
+    meet({'source'=>'sys-dic'})
+  end
+
+end
+#
+################################################################################

data/test/attendee/ts_multiworder.rb

@@ -0,0 +1,390 @@
+# encoding: utf-8
+
+require_relative '../test_helper'
+
+################################################################################
+#
+# Attendee Multiworder
+#
+class TestAttendeeMultiworder < AttendeeTestCase
+
+  def test_basic
+    @input = [
+      ai('FILE|mul.txt'),
+      # John_F_._Kennedy
+      wd('John|IDF', 'john|e'), wd('F|?'), tk('.|PUNC'), wd('Kennedy|IDF', 'kennedy|e'),
+      # John_F_Kennedy
+      wd('John|IDF', 'john|e'), wd('F|?'), wd('Kennedy|IDF', 'kennedy|e'),
+      # John_F_Kennedy_.
+      wd('John|IDF', 'john|e'), wd('F|?'), wd('Kennedy|IDF', 'kennedy|e'), tk('.|PUNC'),
+      # a_priori
+      wd('a|?'), wd('priori|IDF', 'priori|w'),
+      # Ableitung_nicht_ganzzahliger_Ordnung
+      wd('Ableitung|IDF', 'ableitung|s'),
+      wd('nicht|IDF', 'nicht|w'),
+      wd('ganzzahliger|IDF', 'ganzzahlig|a'),
+      wd('Ordnung|IDF', 'ordnung|s'),
+      # Academic_learning_time_in_physical_education
+      wd('academic|?'), wd('learning|?'), wd('time|IDF', 'timen|v'),
+      wd('in|IDF', 'in|t'), wd('physical|?'), wd('education|?'),
+      # Satzende
+      tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    @expect = [
+      ai('FILE|mul.txt'),
+      # John_F_._Kennedy
+      wd('John F. Kennedy|MUL', 'john f. kennedy|m'),
+      wd('John|IDF', 'john|e'), wd('F|MU?'), wd('Kennedy|IDF', 'kennedy|e'),
+      # John_F_Kennedy
+      wd('John F Kennedy|MUL', 'john f. kennedy|m'),
+      wd('John|IDF', 'john|e'), wd('F|MU?'), wd('Kennedy|IDF', 'kennedy|e'),
+      # John_F_Kennedy_.
+      wd('John F Kennedy|MUL', 'john f. kennedy|m'),
+      wd('John|IDF', 'john|e'), wd('F|MU?'), wd('Kennedy|IDF', 'kennedy|e'),
+      tk('.|PUNC'),
+      # a_priori
+      wd('a priori|MUL', 'a priori|m'),
+      wd('a|MU?'), wd('priori|IDF', 'priori|w'),
+      # Ableitung_nicht_ganzzahliger_Ordnung
+      wd('Ableitung nicht ganzzahliger Ordnung|MUL', 'ableitung nicht ganzzahliger ordnung|m'),
+      wd('Ableitung|IDF', 'ableitung|s'),
+      wd('nicht|IDF', 'nicht|w'),
+      wd('ganzzahliger|IDF', 'ganzzahlig|a'),
+      wd('Ordnung|IDF', 'ordnung|s'),
+      # Academic_learning_time_in_physical_education
+      wd('academic learning time in physical education|MUL', 'academic learning time in physical education|m'),
+      wd('academic|MU?'), wd('learning|MU?'), wd('time|IDF', 'timen|v'),
+      wd('in|IDF', 'in|t'), wd('physical|MU?'), wd('education|MU?'),
+      # Satzende
+      tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mul'})
+  end
+
+  def test_multiple_prefix
+    @input = [
+      ai('FILE|mul.txt'),
+      wd('Abelsches|IDF', 'abelsch|a'), wd('Schema|IDF', 'schema|s'), tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    @expect = [
+      ai('FILE|mul.txt'),
+      wd('Abelsches Schema|MUL', 'abelsches schema|m'),
+      wd('Abelsches|IDF', 'abelsch|a'), wd('Schema|IDF', 'schema|s'), tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mul'})
+
+    @input = [
+      ai('FILE|mul.txt'),
+      wd('Tolles|IDF', 'toll|a'), wd('abelsches|IDF', 'abelsch|a'), wd('Schema|IDF', 'schema|s'), tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    @expect = [
+      ai('FILE|mul.txt'),
+      wd('Tolles abelsches Schema|MUL', 'tolles abelsches schema|m'),
+      wd('Tolles|IDF', 'toll|a'), wd('abelsches|IDF', 'abelsch|a'), wd('Schema|IDF', 'schema|s'), tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mul'})
+
+    @input = [
+      ai('FILE|mul.txt'),
+      wd('Super|IDF', 'super|a'), wd('tolles|IDF', 'toll|a'), wd('abelsches|IDF', 'abelsch|a'), wd('Schema|IDF', 'schema|s'), tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    @expect = [
+      ai('FILE|mul.txt'),
+      wd('Super tolles abelsches Schema|MUL', 'super tolles abelsches schema|m'),
+      wd('Super|IDF', 'super|a'), wd('tolles|IDF', 'toll|a'), wd('abelsches|IDF', 'abelsch|a'), wd('Schema|IDF', 'schema|s'), tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mul'})
+
+    @input = [
+      ai('FILE|mul.txt'),
+      wd('Extra|IDF', 'extra|a'), wd('super|IDF', 'super|a'), wd('tolles|IDF', 'toll|a'), wd('abelsches|IDF', 'abelsch|a'), wd('Schema|IDF', 'schema|s'), tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    @expect = [
+      ai('FILE|mul.txt'),
+      wd('Extra super tolles abelsches Schema|MUL', 'extra super tolles abelsches schema|m'),
+      wd('Extra|IDF', 'extra|a'), wd('super|IDF', 'super|a'), wd('tolles|IDF', 'toll|a'), wd('abelsches|IDF', 'abelsch|a'), wd('Schema|IDF', 'schema|s'), tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mul'})
+  end
+
+  def test_multiple_suffix
+    @input = [
+      ai('FILE|mul.txt'),
+      wd('Abelsches|IDF', 'abelsch|a'), wd('Schema|IDF', 'schema|s'), tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    @expect = [
+      ai('FILE|mul.txt'),
+      wd('Abelsches Schema|MUL', 'abelsches schema|m'),
+      wd('Abelsches|IDF', 'abelsch|a'), wd('Schema|IDF', 'schema|s'), tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mul'})
+
+    @input = [
+      ai('FILE|mul.txt'),
+      wd('Abelsches|IDF', 'abelsch|a'), wd('Schema|IDF', 'schema|s'), wd('toll|IDF', 'toll|a'), tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    @expect = [
+      ai('FILE|mul.txt'),
+      wd('Abelsches Schema toll|MUL', 'abelsches schema toll|m'),
+      wd('Abelsches|IDF', 'abelsch|a'), wd('Schema|IDF', 'schema|s'), wd('toll|IDF', 'toll|a'), tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mul'})
+
+    @input = [
+      ai('FILE|mul.txt'),
+      wd('Abelsches|IDF', 'abelsch|a'), wd('Schema|IDF', 'schema|s'), wd('toll|IDF', 'toll|a'), wd('super|IDF', 'super|a'), tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    @expect = [
+      ai('FILE|mul.txt'),
+      wd('Abelsches Schema toll super|MUL', 'abelsches schema toll super|m'),
+      wd('Abelsches|IDF', 'abelsch|a'), wd('Schema|IDF', 'schema|s'), wd('toll|IDF', 'toll|a'), wd('super|IDF', 'super|a'), tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mul'})
+
+    @input = [
+      ai('FILE|mul.txt'),
+      wd('Abelsches|IDF', 'abelsch|a'), wd('Schema|IDF', 'schema|s'), wd('toll|IDF', 'toll|a'), wd('super|IDF', 'super|a'), wd('extra|IDF', 'extra|a'), tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    @expect = [
+      ai('FILE|mul.txt'),
+      wd('Abelsches Schema toll super extra|MUL', 'abelsches schema toll super extra|m'),
+      wd('Abelsches|IDF', 'abelsch|a'), wd('Schema|IDF', 'schema|s'), wd('toll|IDF', 'toll|a'), wd('super|IDF', 'super|a'), wd('extra|IDF', 'extra|a'), tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mul'})
+  end
+
+  def test_ending_count
+    @input = [
+      ai('FILE|mul.txt'),
+      wd('John|IDF', 'john|e'), wd('F|?'), tk('.|PUNC'), wd('Kennedy|IDF', 'kennedy|e'),
+      wd('war|IDF', 'war|w'), wd('einmal|IDF', 'einmal|w'), wd('Präsident|IDF', 'präsident|s'), tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    @expect = [
+      ai('FILE|mul.txt'),
+      wd('John F. Kennedy|MUL', 'john f. kennedy|m'),
+      wd('John|IDF', 'john|e'), wd('F|MU?'), wd('Kennedy|IDF', 'kennedy|e'),
+      wd('war|IDF', 'war|w'), wd('einmal|IDF', 'einmal|w'), wd('Präsident|IDF', 'präsident|s'), tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mul'})
+
+    #
+    @input.delete_at(-3)
+    @expect = [
+      ai('FILE|mul.txt'),
+      wd('John F. Kennedy|MUL', 'john f. kennedy|m'),
+      wd('John|IDF', 'john|e'), wd('F|MU?'), wd('Kennedy|IDF', 'kennedy|e'),
+      wd('war|IDF', 'war|w'), wd('einmal|IDF', 'einmal|w'), tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mul'})
+
+    #
+    @input.delete_at(-3)
+    @expect = [
+      ai('FILE|mul.txt'),
+      wd('John F. Kennedy|MUL', 'john f. kennedy|m'),
+      wd('John|IDF', 'john|e'), wd('F|MU?'), wd('Kennedy|IDF', 'kennedy|e'),
+      wd('war|IDF', 'war|w'), tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mul'})
+
+    #
+    @input.delete_at(-3)
+    @expect = [
+      ai('FILE|mul.txt'),
+      wd('John F. Kennedy|MUL', 'john f. kennedy|m'),
+      wd('John|IDF', 'john|e'), wd('F|MU?'), wd('Kennedy|IDF', 'kennedy|e'),
+      tk('.|PUNC'),
+      ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mul'})
+  end
+
+  def test_two_sources_mode_first
+    # in keinen WB enthalten
+    @input = [
+      wd('intelligente|IDF', 'intelligent|a'), wd('Indexierung|IDF', 'indexierung|s'), ai('EOF|mul.txt')
+    ]
+    @expect = [
+      wd('intelligente|IDF', 'intelligent|a'), wd('Indexierung|IDF', 'indexierung|s'), ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mul,tst-mu2', 'mode'=>'first'})
+
+    # im ersten WB enthalten
+    @input = [
+      wd('abstrakten|IDF', 'abstrakt|a'), wd('Kunst|IDF', 'kunst|s'), ai('EOF|mul.txt')
+    ]
+    @expect = [
+      wd('abstrakten Kunst|MUL', 'abstrakte kunst|m'),
+      wd('abstrakten|IDF', 'abstrakt|a'), wd('Kunst|IDF', 'kunst|s'), ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mul,tst-mu2', 'mode'=>'first'})
+
+    # im zweiten WB enthalten
+    @input = [
+      wd('traumatischer|IDF', 'traumatisch|a'), wd('Angelegenheit|IDF', 'angelegenheit|s'), ai('EOF|mul.txt')
+    ]
+    @expect = [
+      wd('traumatischer Angelegenheit|MUL', 'traumatische angelegenheit|m'),
+      wd('traumatischer|IDF', 'traumatisch|a'), wd('Angelegenheit|IDF', 'angelegenheit|s'), ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mul,tst-mu2', 'mode'=>'first'})
+
+    # in beiden WB enthalten
+    @input = [
+      wd('azyklischen|IDF', 'azyklisch|a'), wd('Bewegungen|IDF', 'bewegung|s'), ai('EOF|mul.txt')
+    ]
+    @expect = [
+      wd('azyklischen Bewegungen|MUL', 'chaotisches movement|m'),
+      wd('azyklischen|IDF', 'azyklisch|a'), wd('Bewegungen|IDF', 'bewegung|s'), ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mul,tst-mu2', 'mode'=>'first'})
+  end
+
+  def test_two_sources_mode_first_flipped
+    # in keinen WB enthalten
+    @input = [
+      wd('intelligente|IDF', 'intelligent|a'), wd('Indexierung|IDF', 'indexierung|s'), ai('EOF|mul.txt')
+    ]
+    @expect = [
+      wd('intelligente|IDF', 'intelligent|a'), wd('Indexierung|IDF', 'indexierung|s'), ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mu2,tst-mul', 'mode'=>'first'})
+
+    # im ersten WB enthalten
+    @input = [
+      wd('abstrakten|IDF', 'abstrakt|a'), wd('Kunst|IDF', 'kunst|s'), ai('EOF|mul.txt')
+    ]
+    @expect = [
+      wd('abstrakten Kunst|MUL', 'abstrakte kunst|m'),
+      wd('abstrakten|IDF', 'abstrakt|a'), wd('Kunst|IDF', 'kunst|s'), ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mu2,tst-mul', 'mode'=>'first'})
+
+    # im zweiten WB enthalten
+    @input = [
+      wd('traumatischer|IDF', 'traumatisch|a'), wd('Angelegenheit|IDF', 'angelegenheit|s'), ai('EOF|mul.txt')
+    ]
+    @expect = [
+      wd('traumatischer Angelegenheit|MUL', 'traumatische angelegenheit|m'),
+      wd('traumatischer|IDF', 'traumatisch|a'), wd('Angelegenheit|IDF', 'angelegenheit|s'), ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mu2,tst-mul', 'mode'=>'first'})
+
+    # in beiden WB enthalten
+    @input = [
+      wd('azyklischen|IDF', 'azyklisch|a'), wd('Bewegungen|IDF', 'bewegung|s'), ai('EOF|mul.txt')
+    ]
+    @expect = [
+      wd('azyklischen Bewegungen|MUL', 'azyklische bewegung|m'),
+      wd('azyklischen|IDF', 'azyklisch|a'), wd('Bewegungen|IDF', 'bewegung|s'), ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mu2,tst-mul', 'mode'=>'first'})
+  end
+
+  def test_select_two_sources_mode_all
+    # in keinen WB enthalten
+    @input = [
+      wd('intelligente|IDF', 'intelligent|a'), wd('Indexierung|IDF', 'indexierung|s'), ai('EOF|mul.txt')
+    ]
+    @expect = [
+      wd('intelligente|IDF', 'intelligent|a'), wd('Indexierung|IDF', 'indexierung|s'), ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mu2,tst-mul', 'mode'=>'all'})
+
+    # im ersten WB enthalten
+    @input = [
+      wd('abstrakten|IDF', 'abstrakt|a'), wd('Kunst|IDF', 'kunst|s'), ai('EOF|mul.txt')
+    ]
+    @expect = [
+      wd('abstrakten Kunst|MUL', 'abstrakte kunst|m'),
+      wd('abstrakten|IDF', 'abstrakt|a'), wd('Kunst|IDF', 'kunst|s'), ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mu2,tst-mul', 'mode'=>'all'})
+
+    # im zweiten WB enthalten
+    @input = [
+      wd('traumatischer|IDF', 'traumatisch|a'), wd('Angelegenheit|IDF', 'angelegenheit|s'), ai('EOF|mul.txt')
+    ]
+    @expect = [
+      wd('traumatischer Angelegenheit|MUL', 'traumatische angelegenheit|m'),
+      wd('traumatischer|IDF', 'traumatisch|a'), wd('Angelegenheit|IDF', 'angelegenheit|s'), ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mu2,tst-mul', 'mode'=>'all'})
+
+    # in beiden WB enthalten
+    @input = [
+      wd('azyklischen|IDF', 'azyklisch|a'), wd('Bewegungen|IDF', 'bewegung|s'), ai('EOF|mul.txt')
+    ]
+    @expect = [
+      wd('azyklischen Bewegungen|MUL', 'azyklische bewegung|m', 'chaotisches movement|m'),
+      wd('azyklischen|IDF', 'azyklisch|a'), wd('Bewegungen|IDF', 'bewegung|s'), ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mu2,tst-mul', 'mode'=>'all'})
+  end
+
+  def test_select_two_sources_mode_def
+    # in keinen WB enthalten
+    @input = [
+      wd('intelligente|IDF', 'intelligent|a'), wd('Indexierung|IDF', 'indexierung|s'), ai('EOF|mul.txt')
+    ]
+    @expect = [
+      wd('intelligente|IDF', 'intelligent|a'), wd('Indexierung|IDF', 'indexierung|s'), ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mu2,tst-mul'})
+
+    # im ersten WB enthalten
+    @input = [
+      wd('abstrakten|IDF', 'abstrakt|a'), wd('Kunst|IDF', 'kunst|s'), ai('EOF|mul.txt')
+    ]
+    @expect = [
+      wd('abstrakten Kunst|MUL', 'abstrakte kunst|m'),
+      wd('abstrakten|IDF', 'abstrakt|a'), wd('Kunst|IDF', 'kunst|s'), ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mu2,tst-mul'})
+
+    # im zweiten WB enthalten
+    @input = [
+      wd('traumatischer|IDF', 'traumatisch|a'), wd('Angelegenheit|IDF', 'angelegenheit|s'), ai('EOF|mul.txt')
+    ]
+    @expect = [
+      wd('traumatischer Angelegenheit|MUL', 'traumatische angelegenheit|m'),
+      wd('traumatischer|IDF', 'traumatisch|a'), wd('Angelegenheit|IDF', 'angelegenheit|s'), ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mu2,tst-mul'})
+
+    # in beiden WB enthalten
+    @input = [
+      wd('azyklischen|IDF', 'azyklisch|a'), wd('Bewegungen|IDF', 'bewegung|s'), ai('EOF|mul.txt')
+    ]
+    @expect = [
+      wd('azyklischen Bewegungen|MUL', 'azyklische bewegung|m', 'chaotisches movement|m'),
+      wd('azyklischen|IDF', 'azyklisch|a'), wd('Bewegungen|IDF', 'bewegung|s'), ai('EOF|mul.txt')
+    ]
+    meet({'source'=>'tst-mu2,tst-mul'})
+  end
+
+end
+#
+################################################################################