lingo 1.8.4.2 → 1.8.5

data/test/ts_database.rb

@@ -2,16 +2,6 @@
 
 require_relative 'test_helper'
 
-class Lingo::Database
-
-  alias_method :original_convert, :convert
-
-  def convert(verbose = false)
-    original_convert(verbose)
-  end
-
-end
-
 class TestDatabase < LingoTestCase
 
   def setup
@@ -29,6 +19,28 @@ ganz großer und blöder mist
 ganz großer und blöder schwach sinn
     EOT
 
+    @singleword_inflect = <<-EOT
+Wort1
+Wort2
+juristisch person
+natürliche personen
+natürlichen quatsches
+klug abel
+lang essay
+große kiefer
+warm abendluft
+klar abendluft
+gut abitur
+gut abitur schaffen
+ein gut abitur
+schmal rund zylinder
+der schmal zylinder
+wort mist
+alt bibliothekskatalog
+neu bibliothekskatalög
+neu alttitelkatalog
+    EOT
+
     @keyvalue = <<-EOT
 Wort1*Projektion1
 Wort2*Projektion2
@@ -55,14 +67,14 @@ Wort2=
     compare({
       'txt-format' => 'SingleWord'
     }, @singleword, {
-      'wort1'                               => '#s',
-      'wort2'                               => '#s',
-      'juristische personen'                => '#s',
-      'höher schneller weiter'              => '#s',
-      'höher schneller weiter größer'       => '#s',
-      'ganz großer und blöder quatsch'      => '#s',
-      'ganz großer und blöder mist'         => '#s',
-      'ganz großer und blöder schwach sinn' => '#s'
+      'wort1'                               => 'wort1#s',
+      'wort2'                               => 'wort2#s',
+      'juristische personen'                => 'juristische personen#s',
+      'höher schneller weiter'              => 'höher schneller weiter#s',
+      'höher schneller weiter größer'       => 'höher schneller weiter größer#s',
+      'ganz großer und blöder quatsch'      => 'ganz großer und blöder quatsch#s',
+      'ganz großer und blöder mist'         => 'ganz großer und blöder mist#s',
+      'ganz großer und blöder schwach sinn' => 'ganz großer und blöder schwach sinn#s'
     })
   end
 
@@ -71,14 +83,14 @@ Wort2=
       'txt-format' => 'SingleWord',
       'def-wc'     => '*'
     }, @singleword, {
-      'wort1'                               => '#*',
-      'wort2'                               => '#*',
-      'juristische personen'                => '#*',
-      'höher schneller weiter'              => '#*',
-      'höher schneller weiter größer'       => '#*',
-      'ganz großer und blöder quatsch'      => '#*',
-      'ganz großer und blöder mist'         => '#*',
-      'ganz großer und blöder schwach sinn' => '#*'
+      'wort1'                               => 'wort1#*',
+      'wort2'                               => 'wort2#*',
+      'juristische personen'                => 'juristische personen#*',
+      'höher schneller weiter'              => 'höher schneller weiter#*',
+      'höher schneller weiter größer'       => 'höher schneller weiter größer#*',
+      'ganz großer und blöder quatsch'      => 'ganz großer und blöder quatsch#*',
+      'ganz großer und blöder mist'         => 'ganz großer und blöder mist#*',
+      'ganz großer und blöder schwach sinn' => 'ganz großer und blöder schwach sinn#*'
     })
   end
 
@@ -87,14 +99,14 @@ Wort2=
       'txt-format' => 'SingleWord',
       'def-mul-wc' => 'm'
     }, @singleword, {
-      'wort1'                               => '#s',
-      'wort2'                               => '#s',
-      'juristische personen'                => '#m',
-      'höher schneller weiter'              => '#m',
-      'höher schneller weiter größer'       => '#m',
-      'ganz großer und blöder quatsch'      => '#m',
-      'ganz großer und blöder mist'         => '#m',
-      'ganz großer und blöder schwach sinn' => '#m'
+      'wort1'                               => 'wort1#s',
+      'wort2'                               => 'wort2#s',
+      'juristische personen'                => 'juristische personen#m',
+      'höher schneller weiter'              => 'höher schneller weiter#m',
+      'höher schneller weiter größer'       => 'höher schneller weiter größer#m',
+      'ganz großer und blöder quatsch'      => 'ganz großer und blöder quatsch#m',
+      'ganz großer und blöder mist'         => 'ganz großer und blöder mist#m',
+      'ganz großer und blöder schwach sinn' => 'ganz großer und blöder schwach sinn#m'
     })
   end
 
@@ -107,11 +119,11 @@ Wort2=
         'separator'  => '='
       )
     }, @singleword, {
-      'wort1'                           => '#s',
-      'wort2'                           => '#s',
+      'wort1'                           => 'wort1#s',
+      'wort2'                           => 'wort2#s',
       'ganz groß und blöd mist'         => 'ganz großer und blöder mist#s',
       'juristisch person'               => 'juristische personen#s',
-      'hoch schnell weit'               => '*4|höher schneller weiter#s',
+      'hoch schnell weit'               => 'höher schneller weiter#s|*4',
       'ganz groß und blöd quatsch'      => 'ganz großer und blöder quatsch#s',
       'hoch schnell weit groß'          => 'höher schneller weiter größer#s',
       'ganz groß und blöd schwach sinn' => 'ganz großer und blöder schwach sinn#s',
@@ -119,33 +131,125 @@ Wort2=
     })
   end
 
+  def test_singleword_inflect
+    compare({
+      'txt-format' => 'SingleWord',
+      'use-lex'    => set_config('lex',
+        'name'       => 'de/lingo-dic.txt',
+        'txt-format' => 'WordClass',
+        'separator'  => '='
+      ),
+      'inflect'    => true
+    }, @singleword_inflect, {
+      'wort1'                           => 'wort1#s',
+      'wort2'                           => 'wort2#s',
+      'juristisch person'               => 'juristische person#s',
+      'natürlich person'                => 'natürliche personen#s',
+      'natürlich quatsch'               => 'natürlichen quatsches#s',
+      'lang essay'                      => 'langer essay#s',
+      'groß kiefer'                     => 'große kiefer#s',
+      'klug abel'                       => 'kluger abel#s',
+      'warm abendluft'                  => 'warme abendluft#s',
+      'klar abendluft'                  => 'klare abendluft#s',
+      'gut abitur'                      => 'gutes abitur#s',
+      'gut abitur schaff'               => 'gutes abitur schaffen#s',
+      'ein gut abitur'                  => 'ein gut abitur#s',
+      'schmal rund zylinder'            => 'schmaler runder zylinder#s',
+      'der schmal zylinder'             => 'der schmal zylinder#s',
+      'wort mist'                       => 'wort mist#s',
+      'alt bibliothekskatalog'          => 'alter bibliothekskatalog#s',
+      'neu bibliothekskatalög'          => 'neu bibliothekskatalög#s',
+      'neu alttitelkatalog'             => 'neuer alttitelkatalog#s'
+    })
+  end
+
+  def test_singleword_inflect_s
+    compare({
+      'txt-format' => 'SingleWord',
+      'use-lex'    => set_config('lex',
+        'name'       => 'de/lingo-dic.txt',
+        'txt-format' => 'WordClass',
+        'separator'  => '='
+      ),
+      'inflect'    => 's'
+    }, @singleword_inflect, {
+      'wort1'                           => 'wort1#s',
+      'wort2'                           => 'wort2#s',
+      'juristisch person'               => 'juristische person#s',
+      'natürlich person'                => 'natürliche personen#s',
+      'natürlich quatsch'               => 'natürlichen quatsches#s',
+      'lang essay'                      => 'langer essay#s',
+      'groß kiefer'                     => 'große kiefer#s',
+      'klug abel'                       => 'klug abel#s',
+      'warm abendluft'                  => 'warme abendluft#s',
+      'klar abendluft'                  => 'klare abendluft#s',
+      'gut abitur'                      => 'gutes abitur#s',
+      'gut abitur schaff'               => 'gutes abitur schaffen#s',
+      'ein gut abitur'                  => 'ein gut abitur#s',
+      'schmal rund zylinder'            => 'schmaler runder zylinder#s',
+      'der schmal zylinder'             => 'der schmal zylinder#s',
+      'wort mist'                       => 'wort mist#s',
+      'alt bibliothekskatalog'          => 'alter bibliothekskatalog#s',
+      'neu bibliothekskatalög'          => 'neu bibliothekskatalög#s',
+      'neu alttitelkatalog'             => 'neuer alttitelkatalog#s'
+    })
+  end
+
+  def test_singleword_inflect_e
+    compare({
+      'txt-format' => 'SingleWord',
+      'use-lex'    => set_config('lex',
+        'name'       => 'de/lingo-dic.txt',
+        'txt-format' => 'WordClass',
+        'separator'  => '='
+      ),
+      'inflect'    => 'e'
+    }, @singleword_inflect, {
+      'wort1'                           => 'wort1#s',
+      'wort2'                           => 'wort2#s',
+      'juristisch person'               => 'juristisch person#s',
+      'natürlich person'                => 'natürliche personen#s',
+      'natürlich quatsch'               => 'natürlichen quatsches#s',
+      'lang essay'                      => 'lang essay#s',
+      'klug abel'                       => 'kluger abel#s',
+      'groß kiefer'                     => 'große kiefer#s',
+      'warm abendluft'                  => 'warm abendluft#s',
+      'klar abendluft'                  => 'klar abendluft#s',
+      'gut abitur'                      => 'gut abitur#s',
+      'gut abitur schaff'               => 'gut abitur schaffen#s',
+      'ein gut abitur'                  => 'ein gut abitur#s',
+      'schmal rund zylinder'            => 'schmal rund zylinder#s',
+      'der schmal zylinder'             => 'der schmal zylinder#s',
+      'wort mist'                       => 'wort mist#s',
+      'alt bibliothekskatalog'          => 'alt bibliothekskatalog#s',
+      'neu bibliothekskatalög'          => 'neu bibliothekskatalög#s',
+      'neu alttitelkatalog'             => 'neu alttitelkatalog#s'
+    })
+  end
+
   def test_singleword_crypt
-    config = {
+    compare({
       'txt-format' => 'SingleWord',
       'crypt'      => true
-    }
+    }, @singleword) { |db| hash = db.to_h; {
+      'wort1'                               => 'wort1#s',
+      'wort2'                               => 'wort2#s',
+      'juristische personen'                => 'juristische personen#s',
+      'höher schneller weiter'              => 'höher schneller weiter#s',
+      'höher schneller weiter größer'       => 'höher schneller weiter größer#s',
+      'ganz großer und blöder quatsch'      => 'ganz großer und blöder quatsch#s',
+      'ganz großer und blöder mist'         => 'ganz großer und blöder mist#s',
+      'ganz großer und blöder schwach sinn' => 'ganz großer und blöder schwach sinn#s'
+    }.each { |key, val|
+      assert_nil(hash[key])
+      assert_equal([val], db[key])
 
-    compare(config, @singleword, {
-      'd8ac4360a5f707d518212e27dcba9dd42d980f96' => '5116',
-      '81463f9c7e0ad40e329e83d3358232851d50ed9a' => '4d16',
-      '8da4a0c30c912543be2d88da64c0192e577efa9d' => '1107',
-      '2c24b4707e77c74abfb12748317693dc1e43c215' => '5700',
-      '810ff7a76f39febcb1cf67993d4fb29819ce40a6' => '5116',
-      'a28b4ca84ac08aeef4e420445f94f632ad010a30' => '1207',
-      '1496f4febbc647f3ac74b0af11dadbd6322f6732' => '4d1d',
-      'b7501a62cb083be6730a7a179a4ab346d23efe53' => '4b10'
-    })
+      assert_nil(db[digest = Lingo::Database::Crypter.digest(key)])
+      assert_not_equal(key, digest)
 
-    compare(config, @singleword) { |db| {
-      'wort1'                               => '#s',
-      'wort2'                               => '#s',
-      'juristische personen'                => '#s',
-      'höher schneller weiter'              => '#s',
-      'höher schneller weiter größer'       => '#s',
-      'ganz großer und blöder quatsch'      => '#s',
-      'ganz großer und blöder mist'         => '#s',
-      'ganz großer und blöder schwach sinn' => '#s'
-    }.each { |key, val| assert_equal([val], db[key]) } }
+      assert_instance_of(String, encrypted = hash[digest])
+      assert_not_equal(val, encrypted)
+    } }
   end
 
   def test_keyvalue
@@ -198,10 +302,39 @@ Wort2=
       Wort1=Projektion4 #e
       Wort1=#s
       Wort2=
+      Wort4.illegal
+      Wort4=still illegal
+      Wort4=still illegal#s!
+      Wort4=now we're talking#s+
+    }, {
+      'wort1' => 'projektion1#h#|projektion4#e#',
+      'wort2' => 'projektion2#i#',
+      'wort3' => 'projektion3#e#',
+      'wort4' => "now we're talking#s+#"
+    })
+  end
+
+  def test_wordclass_gender
+    compare({
+      'txt-format' => 'WordClass'
+    }, %q{
+      substantiv,substantiv #a substantiv #s.n
+      mehr,mehr #w mehr #s.n mehren #v
+      wort,wort #s.n
+      gruppe,gruppe #s.f
+      modul,modul #s.m|n
+      nocken,nock #s.f|m|n nocke #s.f nocken #s.m
+      albern,albern #a|v
+      fortuna,fortuna #e|s.f
     }, {
-      'wort1' => 'projektion1#h|projektion4#e',
-      'wort2' => 'projektion2#i',
-      'wort3' => 'projektion3#e'
+      'substantiv' => 'substantiv#a#|substantiv#s#n',
+      'mehr'       => 'mehr#w#|mehr#s#n|mehren#v#',
+      'wort'       => 'wort#s#n',
+      'gruppe'     => 'gruppe#s#f',
+      'modul'      => 'modul#s#m|modul#s#n',
+      'nocken'     => 'nock#s#f|nock#s#m|nock#s#n|nocke#s#f|nocken#s#m',
+      'albern'     => 'albern#a#|albern#v#',
+      'fortuna'    => 'fortuna#e#f|fortuna#s#f'
     })
   end
 
@@ -215,21 +348,17 @@ Wort2=
       Rasen;Gras;Grüne Fläche
       Rasen;Rennen;Wettrennen
     }, {
-      '^0'           => 'hasen|nasen|rasen|vasen',
-      '^1'           => 'edelmetall|gold|mehrwert',
-      '^2'           => 'gras|grüne fläche|rasen',
-      '^3'           => 'rasen|rennen|wettrennen',
-      'hasen'        => '^0',
-      'nasen'        => '^0',
-      'rasen'        => '^0|^2|^3',
-      'vasen'        => '^0',
-      'edelmetall'   => '^1',
-      'gold'         => '^1',
-      'mehrwert'     => '^1',
-      'gras'         => '^2',
-      'grüne fläche' => '^2',
-      'wettrennen'   => '^3',
-      'rennen'       => '^3'
+      'hasen'        => 'hasen|nasen|vasen|rasen',
+      'nasen'        => 'hasen|nasen|vasen|rasen',
+      'vasen'        => 'hasen|nasen|vasen|rasen',
+      'rasen'        => 'hasen|nasen|vasen|rasen|gras|grüne fläche|rennen|wettrennen',
+      'gold'         => 'gold|edelmetall|mehrwert',
+      'edelmetall'   => 'gold|edelmetall|mehrwert',
+      'mehrwert'     => 'gold|edelmetall|mehrwert',
+      'gras'         => 'rasen|gras|grüne fläche',
+      'grüne fläche' => 'rasen|gras|grüne fläche',
+      'rennen'       => 'rasen|rennen|wettrennen',
+      'wettrennen'   => 'rasen|rennen|wettrennen'
     })
   end
 

data/test/ts_language.rb

@@ -27,9 +27,9 @@ class TestLexicalHash < LingoTestCase
 
   def test_cache
     lh('sys-dic') { |ds|
-      assert_equal([lx('regen|s'), lx('regen|v'), lx('rege|a')], ds['regen'])
-      assert_equal([lx('regen|s'), lx('regen|v'), lx('rege|a')], ds['regen'])
-      assert_equal([lx('regen|s'), lx('regen|v'), lx('rege|a')], ds['regen'])
+      assert_equal([lx('regen|s|m'), lx('regen|s|n'), lx('regen|v'), lx('rege|a')], ds['regen'])
+      assert_equal([lx('regen|s|m'), lx('regen|s|n'), lx('regen|v'), lx('rege|a')], ds['regen'])
+      assert_equal([lx('regen|s|m'), lx('regen|s|n'), lx('regen|v'), lx('rege|a')], ds['regen'])
     }
   end
 
@@ -57,7 +57,7 @@ class TestLexicalHash < LingoTestCase
   def test_keyvalue
     lh('sys-mul') { |ds|
       assert_equal([lx('abelscher ring ohne nullteiler|m')], ds['abelscher ring ohne nullteiler'])
-      assert_equal(['*4'], ds['abelscher ring ohne'])
+      assert_equal([4], ds['abelscher ring ohne'])
       assert_equal([lx('alleinreisende frau|m')], ds['alleinreisend frau'])
       assert_equal([lx('abschaltbarer leistungshalbleiter|m')], ds['abschaltbar leistungshalbleiter'])
       assert_equal(nil, ds['abschaltbarer leistungshalbleiter'])
@@ -66,12 +66,25 @@ class TestLexicalHash < LingoTestCase
 
   def test_wordclass
     lh('sys-dic') { |ds|
-      assert_equal([lx('a-dur|s')], ds['a-dur'])
-      assert_equal([lx('aalen|v'), lx('aalen|e')], ds['aalen'])
+      assert_equal([lx('a-dur|s|m'), lx('a-dur|s|n')], ds['a-dur'])
+      assert_equal([lx('aalen|e'), lx('aalen|v')], ds['aalen'])
       assert_equal([lx('abarbeitend|a')], ds['abarbeitend'])
     }
   end
 
+  def test_wordclass_gender
+    lh('tst-gen') { |ds|
+      assert_equal([lx('substantiv|a'), lx('substantiv|s|n')], ds['substantiv'])
+      assert_equal([lx('mehr|w'), lx('mehr|s|n'), lx('mehren|v')], ds['mehr'])
+      assert_equal([lx('wort|s|n')], ds['wort'])
+      assert_equal([lx('gruppe|s|f')], ds['gruppe'])
+      assert_equal([lx('modul|s|m'), lx('modul|s|n')], ds['modul'])
+      assert_equal([lx('nock|s|f'), lx('nock|s|m'), lx('nock|s|n'), lx('nocke|s|f'), lx('nocken|s|m')], ds['nocken'])
+      assert_equal([lx('albern|a'), lx('albern|v')], ds['albern'])
+      assert_equal([lx('fortuna|e|f'), lx('fortuna|s|f')], ds['fortuna'])
+    }
+  end
+
   def test_case
     lh('sys-dic') { |ds|
       assert_equal([lx('abänderung|s')], ds['abänderung'])
@@ -83,7 +96,7 @@ class TestLexicalHash < LingoTestCase
   def test_multivalue
     lh('sys-syn') { |ds|
       assert_equal([lx('abbau <chemie>|y'), lx('chemische abbaureaktion|y'), lx('chemischer abbau|y'), lx('photochemischer abbau|y')], ds['abbaureaktion'])
-      assert_equal([lx('dependenz|y'), lx('unselbstständigkeit|y'), lx('unselbständigkeit|y')], ds['abhängigkeit'])
+      assert_equal([lx('dependenz|y'), lx('unselbständigkeit|y'), lx('unselbstständigkeit|y')], ds['abhängigkeit'])
     }
   end
 
@@ -136,7 +149,7 @@ class TestDictionary < LingoTestCase
       # nur in zweiter Quelle vorhanden
       assert_equal([lx('super indexierungssystem|m')], dic.select('lex-lingo'))
       # in beiden Quellen vorhanden
-      assert_equal([lx('a-dur|s')], dic.select('a-dur'))
+      assert_equal([lx('a-dur|s|m'), lx('a-dur|s|n')], dic.select('a-dur'))
     }
   end
 
@@ -162,8 +175,8 @@ class TestDictionary < LingoTestCase
       # nur in zweiter Quelle vorhanden
       assert_equal([lx('super indexierungssystem|m')], dic.select('lex-lingo'))
       # in beiden Quellen vorhanden
-      assert_equal([lx('a-dur|s'), lx('b-dur|s')], dic.select('a-dur'))
-      assert_equal([lx('aas|s')], dic.select('aas'))
+      assert_equal([lx('a-dur|s|m'), lx('a-dur|s|n'), lx('b-dur|s')], dic.select('a-dur'))
+      assert_equal([lx('aas|s|n'), lx('aas|s')], dic.select('aas'))
     }
   end
 
@@ -175,24 +188,26 @@ class TestDictionary < LingoTestCase
       assert_equal([lx('knaller|s')], dic.select('knaller'))
       # nur in zweiter Quelle vorhanden
       assert_equal([lx('super indexierungssystem|m')], dic.select('lex-lingo'))
+      assert_equal([lx('wirkungsort|s'), lx('wirkung|s+'), lx('ort|s+')], dic.select('wirkungsort'))
+      assert_equal([lx('zettelkatalog|k'), lx('zettel|s+'), lx('katalog|s+')], dic.select('zettelkatalog'))
       # in beiden Quellen vorhanden
-      assert_equal([lx('a-dur|s'), lx('b-dur|s')], dic.select('a-dur'))
-      assert_equal([lx('aas|s')], dic.select('aas'))
+      assert_equal([lx('a-dur|s|m'), lx('a-dur|s|n'), lx('b-dur|s')], dic.select('a-dur'))
+      assert_equal([lx('aas|s|n'), lx('aas|s')], dic.select('aas'))
     }
   end
 
   def test_suffix_lexicals
     ld('source' => %w[sys-dic]) { |dic|
-      assert_equal([lx('mau|s'), lx('mauer|s')], dic.suffix_lexicals('mauern'))
-      assert_equal([lx('hasen|s'), lx('hasen|v'), lx('hasen|e')], dic.suffix_lexicals('hasens'))
-      assert_equal([lx('schönst|s'), lx('schön|a'), lx('schönst|a')], dic.suffix_lexicals('schönster'))
-      assert_equal([lx('segnen|v'), lx('segneen|v')], dic.suffix_lexicals('segnet'))
+      assert_equal([lx('mau|s'), lx('mauer|s')], ax(dic, 'mauern'))
+      assert_equal([lx('hasen|s'), lx('hasen|v'), lx('hasen|e')], ax(dic, 'hasens'))
+      assert_equal([lx('schönst|s'), lx('schön|a'), lx('schönst|a')], ax(dic, 'schönster'))
+      assert_equal([lx('segnen|v'), lx('segneen|v')], ax(dic, 'segnet'))
     }
   end
 
   def test_infix_lexicals
     ld('source' => %w[sys-dic]) { |dic|
-      assert_equal( [lx('information|s'), lx('information|v'), lx('information|e')], dic.suffix_lexicals('informations'))
+      assert_equal( [lx('information|f'), lx('informationsen|f')], ax(dic, 'informations', :infix))
     }
   end
 
@@ -207,7 +222,7 @@ class TestDictionary < LingoTestCase
 
   def test_select_with_infix
     ld('source' => %w[sys-dic]) { |dic|
-      assert_equal( [lx('information|s'), lx('information|v'), lx('information|e')], dic.suffix_lexicals('informations'))
+      assert_equal( [lx('information|f'), lx('informationsen|f')], ax(dic, 'informations', :infix))
     }
   end
 
@@ -223,6 +238,10 @@ class TestDictionary < LingoTestCase
     Lingo::Language::Dictionary.open(cfg, @lingo, &block)
   end
 
+  def ax(dic, *args)
+    [].tap { |x| dic.each_affix(*args) { |*a| x << Lingo::Language::Lexical.new(*a) } }
+  end
+
 end
 
 class TestGrammar < LingoTestCase
@@ -260,7 +279,7 @@ class TestGrammar < LingoTestCase
       )
 
       assert_equal(
-        wd('cd-rom-technologie|KOM', 'cd-rom-technologie|k', 'cd-rom|s+', 'technologie|s+'),
+        wd('cd-rom-technologie|KOM', 'cd-rom-technologie|k', 'cd-rom|s+|f', 'cd-rom|s+|m', 'technologie|s+|f'),
         gra.find_compound('cd-rom-technologie')
       )
 
@@ -275,7 +294,7 @@ class TestGrammar < LingoTestCase
       )
 
       assert_equal(
-        wd('benutzerforschung|KOM', 'benutzerforschung|k', 'erforschung|s+', 'benutzen|v+'),
+        wd('benutzerforschung|KOM', 'benutzerforschung|k', 'benutzen|v+', 'erforschung|s+'),
         gra.find_compound('benutzerforschung')
       )
 
@@ -284,6 +303,21 @@ class TestGrammar < LingoTestCase
         gra.find_compound('clustersuche')
       )
 
+      assert_equal(
+        wd('titelkatalogstitel|KOM', 'titelkatalogstitel|k', 'titel|s+', 'katalog|s+', 'titel|s+'),
+        gra.find_compound('titelkatalogstitel')
+      )
+
+      assert_equal(
+        wd('titelkatalogstiteltitel|KOM', 'titelkatalogstiteltitel|k', 'titel|s+', 'katalog|s+', 'titel|s+', 'titel|s+'),
+        gra.find_compound('titelkatalogstiteltitel')
+      )
+
+      assert_equal(
+        wd('titelbestandsbestände|KOM', 'titelbestandsbestand|k', 'titel|s+', 'bestand|s+', 'bestand|s+', 'bestehen|v+'),
+        gra.find_compound('titelbestandsbestände')
+      )
+
       # hinterer Teil ist ein Wort mit Suffix
       assert_equal(
         wd('hasenbraten|KOM', 'hasenbraten|k', 'hase|s+', 'braten|v+'),
@@ -304,7 +338,7 @@ class TestGrammar < LingoTestCase
 
       # hinterer Teil ist ein Kompositum nach Bindestrich
       assert_equal(
-        wd('arrafat-nachfolgebedarf|KOM', 'arrafat-nachfolgebedarf|k', 'bedarf|s+', 'nachfolge|s+', 'arrafat|x+'),
+        wd('arrafat-nachfolgebedarf|KOM', 'arrafat-nachfolgebedarf|k', 'arrafat|x+', 'nachfolge|s+', 'bedarf|s+'),
         gra.find_compound('arrafat-nachfolgebedarf')
       )
 
@@ -317,19 +351,19 @@ class TestGrammar < LingoTestCase
       # vorderer Teil ist ein Wort mit Suffix => siehe Hasenbraten
       # vorderer Teil ist ein Kompositum
       assert_equal(
-        wd('morgenonkelmantel|KOM', 'morgenonkelmantel|k', 'mantel|s+', 'morgen|s+', 'onkel|s+', 'morgen|w+'),
+        wd('morgenonkelmantel|KOM', 'morgenonkelmantel|k', 'morgen|w+', 'morgen|s+', 'onkel|s+', 'mantel|s+'),
         gra.find_compound('morgenonkelmantel')
       )
 
       # vorderer Teil ist ein TakeItAsIs vor Bindestrich / bindestrichversion
       assert_equal(
-        wd('arrafat-nachfolger|KOM', 'arrafat-nachfolger|k', 'nachfolger|s+', 'arrafat|x+'),
+        wd('arrafat-nachfolger|KOM', 'arrafat-nachfolger|k', 'arrafat|x+', 'nachfolger|s+'),
         gra.find_compound('arrafat-nachfolger')
       )
 
       # bindestrichversion zwei-teilig
       assert_equal(
-        wd('cd-rom-technologie|KOM', 'cd-rom-technologie|k', 'cd-rom|s+', 'technologie|s+'),
+        wd('cd-rom-technologie|KOM', 'cd-rom-technologie|k', 'cd-rom|s+|f', 'cd-rom|s+|m', 'technologie|s+|f'),
         gra.find_compound('cd-rom-technologie')
       )
 
@@ -341,19 +375,45 @@ class TestGrammar < LingoTestCase
 
       # normal mit suggestion
       assert_equal(
-        wd('benutzerforschung|KOM', 'benutzerforschung|k', 'erforschung|s+', 'benutzen|v+'),
+        wd('benutzerforschung|KOM', 'benutzerforschung|k', 'benutzen|v+', 'erforschung|s+'),
         gra.find_compound('benutzerforschung')
       )
     }
   end
 
+  def test_head
+    lg { |gra|
+      assert_equal(
+        wd('suche|-', 'suche|s', 'suchen|v'),
+        gra.find_compound('clustersuche').head
+      )
+
+      assert_equal(
+        wd('titel|-', 'titel|s'),
+        gra.find_compound('titelkatalogstitel').head
+      )
+
+      assert_equal(
+        wd('titel|-', 'titel|s'),
+        gra.find_compound('titelkatalogstiteltitel').head
+      )
+
+      assert_equal(
+        wd('bestand|-', 'bestand|s', 'bestehen|v'),
+        gra.find_compound('titelbestandsbestände').head
+      )
+
+      assert_nil(gra.find_compound('bibliothekskatalög').head)
+    }
+  end
+
   def test_min_word_size
     lg { |gra| assert_equal( wd('undsund|?'), gra.find_compound('undsund')) }
   end
 
   def test_max_parts
     lg { |gra|
-      assert_equal(wd('baumsbaumsbaum|KOM', 'baumsbaumsbaum|k', 'baum|s+'), gra.find_compound('baumsbaumsbaum'))
+      assert_equal(wd('baumsbaumsbaum|KOM', 'baumsbaumsbaum|k', 'baum|s+', 'baum|s+', 'baum|s+'), gra.find_compound('baumsbaumsbaum'))
       assert_equal(wd('baumsbaumsbaumsbaumsbaumsbaum|?'), gra.find_compound('baumsbaumsbaumsbaumsbaumsbaum'))
     }
   end