From 3c5aa5a0209db59443d759b3ec5cdadbaabbe37f Mon Sep 17 00:00:00 2001
From: Noud de Brouwer <noud4@home.nl>
Date: Sun, 6 Sep 2020 13:28:36 +0200
Subject: [PATCH 01/17] dutch

---
 docs/en/index.rst                             |   1 +
 lib/Doctrine/Inflector/InflectorFactory.php   |   3 +
 lib/Doctrine/Inflector/Language.php           |   1 +
 .../Inflector/Rules/Dutch/Inflectible.php     | 164 ++++++++++++++++++
 .../Rules/Dutch/InflectorFactory.php          |  21 +++
 lib/Doctrine/Inflector/Rules/Dutch/Rules.php  |  31 ++++
 .../Inflector/Rules/Dutch/Uninflected.php     |  66 +++++++
 .../Tests/Inflector/InflectorFactoryTest.php  |   2 +
 .../Rules/Dutch/DutchFunctionalTest.php       |  57 ++++++
 9 files changed, 346 insertions(+)
 create mode 100644 lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
 create mode 100644 lib/Doctrine/Inflector/Rules/Dutch/InflectorFactory.php
 create mode 100644 lib/Doctrine/Inflector/Rules/Dutch/Rules.php
 create mode 100644 lib/Doctrine/Inflector/Rules/Dutch/Uninflected.php
 create mode 100644 tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php

diff --git a/docs/en/index.rst b/docs/en/index.rst
index 29866f4d..8cd76827 100644
--- a/docs/en/index.rst
+++ b/docs/en/index.rst
@@ -38,6 +38,7 @@ you want to create an inflector for to the ``createForLanguage()`` method:
 
 The supported languages are as follows:
 
+- ``Language::DUTCH``
 - ``Language::ENGLISH``
 - ``Language::FRENCH``
 - ``Language::NORWEGIAN_BOKMAL``
diff --git a/lib/Doctrine/Inflector/InflectorFactory.php b/lib/Doctrine/Inflector/InflectorFactory.php
index 44bba5d7..6a18960c 100644
--- a/lib/Doctrine/Inflector/InflectorFactory.php
+++ b/lib/Doctrine/Inflector/InflectorFactory.php
@@ -4,6 +4,7 @@
 
 namespace Doctrine\Inflector;
 
+use Doctrine\Inflector\Rules\Dutch;
 use Doctrine\Inflector\Rules\English;
 use Doctrine\Inflector\Rules\French;
 use Doctrine\Inflector\Rules\NorwegianBokmal;
@@ -23,6 +24,8 @@ public static function create() : LanguageInflectorFactory
     public static function createForLanguage(string $language) : LanguageInflectorFactory
     {
         switch ($language) {
+            case Language::DUTCH:
+                return new Dutch\InflectorFactory();
             case Language::ENGLISH:
                 return new English\InflectorFactory();
             case Language::FRENCH:
diff --git a/lib/Doctrine/Inflector/Language.php b/lib/Doctrine/Inflector/Language.php
index 78c3cc75..7ab66f78 100644
--- a/lib/Doctrine/Inflector/Language.php
+++ b/lib/Doctrine/Inflector/Language.php
@@ -6,6 +6,7 @@
 
 final class Language
 {
+    public const DUTCH            = 'dutch';
     public const ENGLISH          = 'english';
     public const FRENCH           = 'french';
     public const NORWEGIAN_BOKMAL = 'norwegian-bokmal';
diff --git a/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php b/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
new file mode 100644
index 00000000..d681d413
--- /dev/null
+++ b/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
@@ -0,0 +1,164 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Dutch;
+
+use Doctrine\Inflector\Rules\Pattern;
+use Doctrine\Inflector\Rules\Substitution;
+use Doctrine\Inflector\Rules\Transformation;
+use Doctrine\Inflector\Rules\Word;
+
+/**
+ *  // http://nl.wikipedia.org/wiki/Klinker_(klank)
+ *  private $klinker = '(a|e|i|o|u|ij)';
+ *  private $korteKlinker = '(u|i|e|a|o)';          // @todo '(ie|oe)'. $plofKlank
+ *
+ *  // http://nl.wikipedia.org/wiki/Medeklinker
+ *  private $plofKlank = '(p|t|k|b|d)';
+ *  private $wrijfKlank = '(f|s|ch|sj|v|z|g|j)';    // journaal
+ *  private $neusKlank = '(m|n|ng)';
+ *  private $vloeiKlank = '(l|r)';
+ *  private $glijKlank = '(j|w)';                   // jaar
+ *  private $affricate = '(ts|zz|tsj|g)';           // /d3/ gin
+ *  private $missingFromWiki = '(c|h|p|q|x|y|z)';
+ *
+ *  public function __construct()
+ *  {
+ *      $this->medeklinker = '(' . $this->missingFromWiki . '|' . $this->plofKlank . '|' . $this->wrijfKlank . '|' . $this->neusKlank . '|' . $this->vloeiKlank . '|' . $this->glijKlank . '|' . $this->affricate . ')';
+ *      $this->medeklinker = '((c|h|p|q|x|y|z)|(p|t|k|b|d)|(f|s|ch|sj|v|z|g|j)|(m|n|ng)|(l|r)|(j|w)|(ts|zz|tsj|g))';
+ *  }
+ */
+class Inflectible
+{
+    /**
+     * @return Transformation[]
+     */
+    public static function getSingular() : iterable
+    {
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Klinkerverandering
+        yield new Transformation(new Pattern('()heden$'), '\1heid');
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Beroepen_eindigend_op_-man
+        yield new Transformation(new Pattern('()mannen$'), '\1man');
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Latijnse_meervoudsvormen
+        yield new Transformation(new Pattern('()ices$'), '\1ex');
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Stapelmeervoud
+        yield new Transformation(new Pattern('^(ei|gemoed|goed|hoen|kind|lied|rad|rund)eren$'), '\1');
+
+        // http://nl.wikipedia.org/wiki/Nederlandse_grammatica
+        yield new Transformation(new Pattern('()ijen$'), '\1ij');
+
+        yield new Transformation(new Pattern('()ieen$'), '\1ie');       // ën
+
+        yield new Transformation(new Pattern('()((a|e|i|o|u|ij))s$'), '\1\2');
+
+        yield new Transformation(new Pattern('()((s)s)en$'), '\1s');
+
+        yield new Transformation(new Pattern('()((c|h|p|q|x|y|z)|(p|t|k|b|d)|(f|s|ch|sj|v|z|g|j)|(m|n|ng)|(l|r)|(j|w)|(ts|zz|tsj|g))en$'), '\1\2');
+    }
+
+    /**
+     * @return Transformation[]
+     */
+    public static function getPlural() : iterable
+    {
+        // @todo already in plural (?)
+        // @todo refine
+        yield new Transformation(new Pattern('()(e)(s)$'), '\1\2\3\3en');
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Klinkerverandering
+        yield new Transformation(new Pattern('()heid$'), '\1heden');
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Beroepen_eindigend_op_-man
+        yield new Transformation(new Pattern('()man$'), '\1mannen');
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Latijnse_meervoudsvormen
+        yield new Transformation(new Pattern('()ix$'), '\1ices');
+
+        yield new Transformation(new Pattern('()ex$'), '\1ices');
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Stapelmeervoud
+        yield new Transformation(new Pattern('^(ei|gemoed|goed|hoen|kind|lied|rad|rund)$'), '\1eren');
+
+        // http://nl.wikipedia.org/wiki/Nederlandse_grammatica
+        yield new Transformation(new Pattern('()ij$'), '\1ijen');
+
+        yield new Transformation(new Pattern('()orie$'), '\1orieen');   // ën klemtoon
+
+        yield new Transformation(new Pattern('()io$'), '\1io\'s');
+
+        yield new Transformation(new Pattern('()(a|e|i|o|u|ij)$'), '\1\2s');
+
+        yield new Transformation(new Pattern('()(((c|h|p|q|x|y|z)|(p|t|k|b|d)|(f|s|ch|sj|v|z|g|j)|(m|n|ng)|(l|r)|(j|w)|(ts|zz|tsj|g))e((c|h|p|q|x|y|z)|(p|t|k|b|d)|(f|s|ch|sj|v|z|g|j)|(m|n|ng)|(l|r)|(j|w)|(ts|zz|tsj|g)))$'), '\1\2s');
+
+        yield new Transformation(new Pattern('()(((c|h|p|q|x|y|z)|(p|t|k|b|d)|(f|s|ch|sj|v|z|g|j)|(m|n|ng)|(l|r)|(j|w)|(ts|zz|tsj|g))(u|i|e|a|o)s)$'), '\1\2sen');
+
+        yield new Transformation(new Pattern('()(((c|h|p|q|x|y|z)|(p|t|k|b|d)|(f|s|ch|sj|v|z|g|j)|(m|n|ng)|(l|r)|(j|w)|(ts|zz|tsj|g))s)$'), '\1\2en');
+
+        yield new Transformation(new Pattern('()s$'), '\1zen');
+
+        yield new Transformation(new Pattern('()((c|h|p|q|x|y|z)|(p|t|k|b|d)|(f|s|ch|sj|v|z|g|j)|(m|n|ng)|(l|r)|(j|w)|(ts|zz|tsj|g))$'), '\1\2en');
+    }
+
+    /**
+     * @return Substitution[]
+     */
+    public static function getIrregular() : iterable
+    {
+        // http://nl.wikipedia.org/wiki/Klemtoon
+        yield new Substitution(new Word('olie'), new Word('oliën'));
+
+        yield new Substitution(new Word('industrie'), new Word('industrieën'));
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Klinkerverandering
+        yield new Substitution(new Word('lid'), new Word('leden'));
+
+        yield new Substitution(new Word('smid'), new Word('smeden'));
+
+        yield new Substitution(new Word('schip'), new Word('schepen'));
+
+        yield new Substitution(new Word('stad'), new Word('steden'));
+
+        yield new Substitution(new Word('gelid'), new Word('gelederen'));
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Stapelmeervoud
+        yield new Substitution(new Word('gelid'), new Word('gelederen'));
+
+        yield new Substitution(new Word('kalf'), new Word('kalveren'));
+
+        yield new Substitution(new Word('lam'), new Word('lammeren'));
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Onregelmatige_meervoudsvorming
+        yield new Substitution(new Word('koe'), new Word('koeien'));
+
+        yield new Substitution(new Word('vlo'), new Word('vlooien'));
+
+        yield new Substitution(new Word('leerrede'), new Word('leerredenen'));
+
+        yield new Substitution(new Word('lende'), new Word('lendenen'));
+
+        yield new Substitution(new Word('epos'), new Word('epen'));
+
+        yield new Substitution(new Word('genius'), new Word('geniën'));
+
+        yield new Substitution(new Word('aanbod'), new Word('aanbiedingen'));
+
+        yield new Substitution(new Word('beleg'), new Word('belegeringen'));
+
+        yield new Substitution(new Word('dank'), new Word('dankbetuigingen'));
+
+        yield new Substitution(new Word('gedrag'), new Word('gedragingen'));
+
+        yield new Substitution(new Word('genot'), new Word('genietingen'));
+
+        yield new Substitution(new Word('lof'), new Word('lofbetuigingen'));
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Latijnse_meervoudsvormen
+        yield new Substitution(new Word('qaestrices'), new Word('quaestrix'));
+
+        yield new Substitution(new Word('matrices'), new Word('matrix'));
+    }
+}
diff --git a/lib/Doctrine/Inflector/Rules/Dutch/InflectorFactory.php b/lib/Doctrine/Inflector/Rules/Dutch/InflectorFactory.php
new file mode 100644
index 00000000..41cac0e3
--- /dev/null
+++ b/lib/Doctrine/Inflector/Rules/Dutch/InflectorFactory.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Dutch;
+
+use Doctrine\Inflector\GenericLanguageInflectorFactory;
+use Doctrine\Inflector\Rules\Ruleset;
+
+final class InflectorFactory extends GenericLanguageInflectorFactory
+{
+    protected function getSingularRuleset() : Ruleset
+    {
+        return Rules::getSingularRuleset();
+    }
+
+    protected function getPluralRuleset() : Ruleset
+    {
+        return Rules::getPluralRuleset();
+    }
+}
diff --git a/lib/Doctrine/Inflector/Rules/Dutch/Rules.php b/lib/Doctrine/Inflector/Rules/Dutch/Rules.php
new file mode 100644
index 00000000..6a645ced
--- /dev/null
+++ b/lib/Doctrine/Inflector/Rules/Dutch/Rules.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Dutch;
+
+use Doctrine\Inflector\Rules\Patterns;
+use Doctrine\Inflector\Rules\Ruleset;
+use Doctrine\Inflector\Rules\Substitutions;
+use Doctrine\Inflector\Rules\Transformations;
+
+final class Rules
+{
+    public static function getSingularRuleset() : Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getSingular()),
+            new Patterns(...Uninflected::getSingular()),
+            (new Substitutions(...Inflectible::getIrregular()))->getFlippedSubstitutions()
+        );
+    }
+
+    public static function getPluralRuleset() : Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getPlural()),
+            new Patterns(...Uninflected::getPlural()),
+            new Substitutions(...Inflectible::getIrregular())
+        );
+    }
+}
diff --git a/lib/Doctrine/Inflector/Rules/Dutch/Uninflected.php b/lib/Doctrine/Inflector/Rules/Dutch/Uninflected.php
new file mode 100644
index 00000000..a03bb18a
--- /dev/null
+++ b/lib/Doctrine/Inflector/Rules/Dutch/Uninflected.php
@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Dutch;
+
+use Doctrine\Inflector\Rules\Pattern;
+
+final class Uninflected
+{
+    /**
+     * @return Pattern[]
+     */
+    public static function getSingular() : iterable
+    {
+        yield from self::getDefault();
+
+        // http://nl.wikipedia.org/wiki/Plurale_tantum
+        yield new Pattern('hersenen');
+        yield new Pattern('ingewanden');
+        yield new Pattern('mazelen');
+        yield new Pattern('pokken');
+        yield new Pattern('waterpokken');
+        yield new Pattern('financiën');
+        yield new Pattern('activa');
+        yield new Pattern('passiva');
+        yield new Pattern('onkosten');
+        yield new Pattern('kosten');
+        yield new Pattern('bescheiden');
+        yield new Pattern('paperassen');
+        yield new Pattern('notulen');
+        yield new Pattern('Roma');
+        yield new Pattern('Sinti');
+        yield new Pattern('Inuit');
+        yield new Pattern('taliban');
+        yield new Pattern('illuminati');
+        yield new Pattern('aanstalten');
+        yield new Pattern('hurken');
+        yield new Pattern('lurven');
+        yield new Pattern('luren');
+    }
+
+    /**
+     * @return Pattern[]
+     */
+    public static function getPlural() : iterable
+    {
+        yield from self::getDefault();
+
+        // http://nl.wikipedia.org/wiki/Singulare_tantum
+        yield new Pattern('letterkunde');
+        yield new Pattern('muziek');
+        yield new Pattern('heelal');
+        yield new Pattern('vastgoed');
+        yield new Pattern('have');
+        yield new Pattern('nageslacht');
+    }
+
+    /**
+     * @return Pattern[]
+     */
+    private static function getDefault() : iterable
+    {
+        yield new Pattern('twitter');
+    }
+}
diff --git a/tests/Doctrine/Tests/Inflector/InflectorFactoryTest.php b/tests/Doctrine/Tests/Inflector/InflectorFactoryTest.php
index 2720c06c..32745d2d 100644
--- a/tests/Doctrine/Tests/Inflector/InflectorFactoryTest.php
+++ b/tests/Doctrine/Tests/Inflector/InflectorFactoryTest.php
@@ -6,6 +6,7 @@
 
 use Doctrine\Inflector\InflectorFactory;
 use Doctrine\Inflector\Language;
+use Doctrine\Inflector\Rules\Dutch\InflectorFactory as DutchInflectorFactory;
 use Doctrine\Inflector\Rules\English\InflectorFactory as EnglishInflectorFactory;
 use Doctrine\Inflector\Rules\French\InflectorFactory as FrenchInflectorFactory;
 use Doctrine\Inflector\Rules\NorwegianBokmal\InflectorFactory as NorwegianBokmalInflectorFactory;
@@ -33,6 +34,7 @@ public function testCreateForLanguageWithCustomLanguage(string $expectedClass, s
 
     public static function provideLanguages() : Generator
     {
+        yield 'Dutch' => [DutchInflectorFactory::class, Language::DUTCH];
         yield 'English' => [EnglishInflectorFactory::class, Language::ENGLISH];
         yield 'French' => [FrenchInflectorFactory::class, Language::FRENCH];
         yield 'Norwegian Bokmal' => [NorwegianBokmalInflectorFactory::class, Language::NORWEGIAN_BOKMAL];
diff --git a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
new file mode 100644
index 00000000..8d65b194
--- /dev/null
+++ b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Inflector\Rules\Dutch;
+
+use Doctrine\Inflector\Inflector;
+use Doctrine\Inflector\InflectorFactory;
+use Doctrine\Inflector\Language;
+use Doctrine\Tests\Inflector\Rules\LanguageFunctionalTest;
+
+class DutchFunctionalTest extends LanguageFunctionalTest
+{
+    /**
+     * @return string[][]
+     */
+    public function dataSampleWords() : array
+    {
+        return [
+            ['weerman', 'weermannen'],
+            ['ei', 'eieren'],
+            ['rij', 'rijen'],
+            ['mogelijkheid', 'mogelijkheden'],
+            ['adres', 'adressen'],
+            ['olie', 'oliën'],
+            ['industrie', 'industrieën'],
+            ['lid', 'leden'],
+            ['smid', 'smeden'],
+            ['schip', 'schepen'],
+            ['stad', 'steden'],
+            ['gelid', 'gelederen'],
+            ['gelid', 'gelederen'],
+            ['kalf', 'kalveren'],
+            ['lam', 'lammeren'],
+            ['koe', 'koeien'],
+            ['vlo', 'vlooien'],
+            ['leerrede', 'leerredenen'],
+            ['lende', 'lendenen'],
+            ['epos', 'epen'],
+            ['genius', 'geniën'],
+            ['aanbod', 'aanbiedingen'],
+            ['beleg', 'belegeringen'],
+            ['dank', 'dankbetuigingen'],
+            ['gedrag', 'gedragingen'],
+            ['genot', 'genietingen'],
+            ['lof', 'lofbetuigingen'],
+            ['qaestrices', 'quaestrix'],
+            ['matrices', 'matrix'],
+            ['twitter', 'twitter'],
+        ];
+    }
+
+    protected function createInflector() : Inflector
+    {
+        return InflectorFactory::createForLanguage(Language::DUTCH)->build();
+    }
+}

From 4a7b0ee4de47164b900cd226abd583eeb72783e3 Mon Sep 17 00:00:00 2001
From: Noud de Brouwer <noud4@home.nl>
Date: Wed, 28 Oct 2020 16:54:42 +0100
Subject: [PATCH 02/17] eick point

---
 .../Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php  | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
index 8d65b194..6ce3c5ff 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
@@ -17,6 +17,10 @@ class DutchFunctionalTest extends LanguageFunctionalTest
     public function dataSampleWords() : array
     {
         return [
+            // @todo: ask for not-sort, cause that's them (ssst) sometimes do, if them do and all that
+            ['schip', 'schepen'],
+            ['stad', 'steden'],
+            ['gelid', 'gelederen'],
             ['weerman', 'weermannen'],
             ['ei', 'eieren'],
             ['rij', 'rijen'],
@@ -27,16 +31,13 @@ public function dataSampleWords() : array
             ['lid', 'leden'],
             ['smid', 'smeden'],
             ['schip', 'schepen'],
-            ['stad', 'steden'],
-            ['gelid', 'gelederen'],
-            ['gelid', 'gelederen'],
             ['kalf', 'kalveren'],
             ['lam', 'lammeren'],
             ['koe', 'koeien'],
             ['vlo', 'vlooien'],
             ['leerrede', 'leerredenen'],
             ['lende', 'lendenen'],
-            ['epos', 'epen'],
+            ['epos', 'epen'],   // @todo: make the multiplitudes arrays w/o sort order as well, epossen
             ['genius', 'geniën'],
             ['aanbod', 'aanbiedingen'],
             ['beleg', 'belegeringen'],

From 838df5bd5e7f1ed745903b35e65568f05d8005f0 Mon Sep 17 00:00:00 2001
From: Noud de Brouwer <noud4@home.nl>
Date: Sun, 6 Sep 2020 13:28:36 +0200
Subject: [PATCH 03/17] dutch

---
 docs/en/index.rst                             |   1 +
 lib/Doctrine/Inflector/InflectorFactory.php   |   4 +
 lib/Doctrine/Inflector/Language.php           |   1 +
 .../Inflector/Rules/Dutch/Inflectible.php     | 164 ++++++++++++++++++
 .../Rules/Dutch/InflectorFactory.php          |  21 +++
 lib/Doctrine/Inflector/Rules/Dutch/Rules.php  |  31 ++++
 .../Inflector/Rules/Dutch/Uninflected.php     |  66 +++++++
 .../Tests/Inflector/InflectorFactoryTest.php  |   2 +
 .../Rules/Dutch/DutchFunctionalTest.php       |  56 ++++++
 9 files changed, 346 insertions(+)
 create mode 100644 lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
 create mode 100644 lib/Doctrine/Inflector/Rules/Dutch/InflectorFactory.php
 create mode 100644 lib/Doctrine/Inflector/Rules/Dutch/Rules.php
 create mode 100644 lib/Doctrine/Inflector/Rules/Dutch/Uninflected.php
 create mode 100644 tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php

diff --git a/docs/en/index.rst b/docs/en/index.rst
index 29866f4d..8cd76827 100644
--- a/docs/en/index.rst
+++ b/docs/en/index.rst
@@ -38,6 +38,7 @@ you want to create an inflector for to the ``createForLanguage()`` method:
 
 The supported languages are as follows:
 
+- ``Language::DUTCH``
 - ``Language::ENGLISH``
 - ``Language::FRENCH``
 - ``Language::NORWEGIAN_BOKMAL``
diff --git a/lib/Doctrine/Inflector/InflectorFactory.php b/lib/Doctrine/Inflector/InflectorFactory.php
index a0740a74..d4053ed3 100644
--- a/lib/Doctrine/Inflector/InflectorFactory.php
+++ b/lib/Doctrine/Inflector/InflectorFactory.php
@@ -4,6 +4,7 @@
 
 namespace Doctrine\Inflector;
 
+use Doctrine\Inflector\Rules\Dutch;
 use Doctrine\Inflector\Rules\English;
 use Doctrine\Inflector\Rules\French;
 use Doctrine\Inflector\Rules\NorwegianBokmal;
@@ -24,6 +25,9 @@ public static function create(): LanguageInflectorFactory
     public static function createForLanguage(string $language): LanguageInflectorFactory
     {
         switch ($language) {
+            case Language::DUTCH:
+                return new Dutch\InflectorFactory();
+
             case Language::ENGLISH:
                 return new English\InflectorFactory();
 
diff --git a/lib/Doctrine/Inflector/Language.php b/lib/Doctrine/Inflector/Language.php
index 78c3cc75..7ab66f78 100644
--- a/lib/Doctrine/Inflector/Language.php
+++ b/lib/Doctrine/Inflector/Language.php
@@ -6,6 +6,7 @@
 
 final class Language
 {
+    public const DUTCH            = 'dutch';
     public const ENGLISH          = 'english';
     public const FRENCH           = 'french';
     public const NORWEGIAN_BOKMAL = 'norwegian-bokmal';
diff --git a/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php b/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
new file mode 100644
index 00000000..34fdfd8f
--- /dev/null
+++ b/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
@@ -0,0 +1,164 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Dutch;
+
+use Doctrine\Inflector\Rules\Pattern;
+use Doctrine\Inflector\Rules\Substitution;
+use Doctrine\Inflector\Rules\Transformation;
+use Doctrine\Inflector\Rules\Word;
+
+/**
+ *  // http://nl.wikipedia.org/wiki/Klinker_(klank)
+ *  private $klinker = '(a|e|i|o|u|ij)';
+ *  private $korteKlinker = '(u|i|e|a|o)';          // @todo '(ie|oe)'. $plofKlank
+ *
+ *  // http://nl.wikipedia.org/wiki/Medeklinker
+ *  private $plofKlank = '(p|t|k|b|d)';
+ *  private $wrijfKlank = '(f|s|ch|sj|v|z|g|j)';    // journaal
+ *  private $neusKlank = '(m|n|ng)';
+ *  private $vloeiKlank = '(l|r)';
+ *  private $glijKlank = '(j|w)';                   // jaar
+ *  private $affricate = '(ts|zz|tsj|g)';           // /d3/ gin
+ *  private $missingFromWiki = '(c|h|p|q|x|y|z)';
+ *
+ *  public function __construct()
+ *  {
+ *      $this->medeklinker = '(' . $this->missingFromWiki . '|' . $this->plofKlank . '|' . $this->wrijfKlank . '|' . $this->neusKlank . '|' . $this->vloeiKlank . '|' . $this->glijKlank . '|' . $this->affricate . ')';
+ *      $this->medeklinker = '((c|h|p|q|x|y|z)|(p|t|k|b|d)|(f|s|ch|sj|v|z|g|j)|(m|n|ng)|(l|r)|(j|w)|(ts|zz|tsj|g))';
+ *  }
+ */
+class Inflectible
+{
+    /**
+     * @return iterable<Transformation>
+     */
+    public static function getSingular(): iterable
+    {
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Klinkerverandering
+        yield new Transformation(new Pattern('()heden$'), '\1heid');
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Beroepen_eindigend_op_-man
+        yield new Transformation(new Pattern('()mannen$'), '\1man');
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Latijnse_meervoudsvormen
+        yield new Transformation(new Pattern('()ices$'), '\1ex');
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Stapelmeervoud
+        yield new Transformation(new Pattern('^(ei|gemoed|goed|hoen|kind|lied|rad|rund)eren$'), '\1');
+
+        // http://nl.wikipedia.org/wiki/Nederlandse_grammatica
+        yield new Transformation(new Pattern('()ijen$'), '\1ij');
+
+        yield new Transformation(new Pattern('()ieen$'), '\1ie');       // ën
+
+        yield new Transformation(new Pattern('()((a|e|i|o|u|ij))s$'), '\1\2');
+
+        yield new Transformation(new Pattern('()((s)s)en$'), '\1s');
+
+        yield new Transformation(new Pattern('()((c|h|p|q|x|y|z)|(p|t|k|b|d)|(f|s|ch|sj|v|z|g|j)|(m|n|ng)|(l|r)|(j|w)|(ts|zz|tsj|g))en$'), '\1\2');
+    }
+
+    /**
+     * @return iterable<Transformation>
+     */
+    public static function getPlural(): iterable
+    {
+        // @todo already in plural (?)
+        // @todo refine
+        yield new Transformation(new Pattern('()(e)(s)$'), '\1\2\3\3en');
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Klinkerverandering
+        yield new Transformation(new Pattern('()heid$'), '\1heden');
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Beroepen_eindigend_op_-man
+        yield new Transformation(new Pattern('()man$'), '\1mannen');
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Latijnse_meervoudsvormen
+        yield new Transformation(new Pattern('()ix$'), '\1ices');
+
+        yield new Transformation(new Pattern('()ex$'), '\1ices');
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Stapelmeervoud
+        yield new Transformation(new Pattern('^(ei|gemoed|goed|hoen|kind|lied|rad|rund)$'), '\1eren');
+
+        // http://nl.wikipedia.org/wiki/Nederlandse_grammatica
+        yield new Transformation(new Pattern('()ij$'), '\1ijen');
+
+        yield new Transformation(new Pattern('()orie$'), '\1orieen');   // ën klemtoon
+
+        yield new Transformation(new Pattern('()io$'), '\1io\'s');
+
+        yield new Transformation(new Pattern('()(a|e|i|o|u|ij)$'), '\1\2s');
+
+        yield new Transformation(new Pattern('()(((c|h|p|q|x|y|z)|(p|t|k|b|d)|(f|s|ch|sj|v|z|g|j)|(m|n|ng)|(l|r)|(j|w)|(ts|zz|tsj|g))e((c|h|p|q|x|y|z)|(p|t|k|b|d)|(f|s|ch|sj|v|z|g|j)|(m|n|ng)|(l|r)|(j|w)|(ts|zz|tsj|g)))$'), '\1\2s');
+
+        yield new Transformation(new Pattern('()(((c|h|p|q|x|y|z)|(p|t|k|b|d)|(f|s|ch|sj|v|z|g|j)|(m|n|ng)|(l|r)|(j|w)|(ts|zz|tsj|g))(u|i|e|a|o)s)$'), '\1\2sen');
+
+        yield new Transformation(new Pattern('()(((c|h|p|q|x|y|z)|(p|t|k|b|d)|(f|s|ch|sj|v|z|g|j)|(m|n|ng)|(l|r)|(j|w)|(ts|zz|tsj|g))s)$'), '\1\2en');
+
+        yield new Transformation(new Pattern('()s$'), '\1zen');
+
+        yield new Transformation(new Pattern('()((c|h|p|q|x|y|z)|(p|t|k|b|d)|(f|s|ch|sj|v|z|g|j)|(m|n|ng)|(l|r)|(j|w)|(ts|zz|tsj|g))$'), '\1\2en');
+    }
+
+    /**
+     * @return iterable<Substitution>
+     */
+    public static function getIrregular(): iterable
+    {
+        // http://nl.wikipedia.org/wiki/Klemtoon
+        yield new Substitution(new Word('olie'), new Word('oliën'));
+
+        yield new Substitution(new Word('industrie'), new Word('industrieën'));
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Klinkerverandering
+        yield new Substitution(new Word('lid'), new Word('leden'));
+
+        yield new Substitution(new Word('smid'), new Word('smeden'));
+
+        yield new Substitution(new Word('schip'), new Word('schepen'));
+
+        yield new Substitution(new Word('stad'), new Word('steden'));
+
+        yield new Substitution(new Word('gelid'), new Word('gelederen'));
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Stapelmeervoud
+        yield new Substitution(new Word('gelid'), new Word('gelederen'));
+
+        yield new Substitution(new Word('kalf'), new Word('kalveren'));
+
+        yield new Substitution(new Word('lam'), new Word('lammeren'));
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Onregelmatige_meervoudsvorming
+        yield new Substitution(new Word('koe'), new Word('koeien'));
+
+        yield new Substitution(new Word('vlo'), new Word('vlooien'));
+
+        yield new Substitution(new Word('leerrede'), new Word('leerredenen'));
+
+        yield new Substitution(new Word('lende'), new Word('lendenen'));
+
+        yield new Substitution(new Word('epos'), new Word('epen'));
+
+        yield new Substitution(new Word('genius'), new Word('geniën'));
+
+        yield new Substitution(new Word('aanbod'), new Word('aanbiedingen'));
+
+        yield new Substitution(new Word('beleg'), new Word('belegeringen'));
+
+        yield new Substitution(new Word('dank'), new Word('dankbetuigingen'));
+
+        yield new Substitution(new Word('gedrag'), new Word('gedragingen'));
+
+        yield new Substitution(new Word('genot'), new Word('genietingen'));
+
+        yield new Substitution(new Word('lof'), new Word('lofbetuigingen'));
+
+        // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Latijnse_meervoudsvormen
+        yield new Substitution(new Word('qaestrices'), new Word('quaestrix'));
+
+        yield new Substitution(new Word('matrices'), new Word('matrix'));
+    }
+}
diff --git a/lib/Doctrine/Inflector/Rules/Dutch/InflectorFactory.php b/lib/Doctrine/Inflector/Rules/Dutch/InflectorFactory.php
new file mode 100644
index 00000000..742233bc
--- /dev/null
+++ b/lib/Doctrine/Inflector/Rules/Dutch/InflectorFactory.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Dutch;
+
+use Doctrine\Inflector\GenericLanguageInflectorFactory;
+use Doctrine\Inflector\Rules\Ruleset;
+
+final class InflectorFactory extends GenericLanguageInflectorFactory
+{
+    protected function getSingularRuleset(): Ruleset
+    {
+        return Rules::getSingularRuleset();
+    }
+
+    protected function getPluralRuleset(): Ruleset
+    {
+        return Rules::getPluralRuleset();
+    }
+}
diff --git a/lib/Doctrine/Inflector/Rules/Dutch/Rules.php b/lib/Doctrine/Inflector/Rules/Dutch/Rules.php
new file mode 100644
index 00000000..86755451
--- /dev/null
+++ b/lib/Doctrine/Inflector/Rules/Dutch/Rules.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Dutch;
+
+use Doctrine\Inflector\Rules\Patterns;
+use Doctrine\Inflector\Rules\Ruleset;
+use Doctrine\Inflector\Rules\Substitutions;
+use Doctrine\Inflector\Rules\Transformations;
+
+final class Rules
+{
+    public static function getSingularRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getSingular()),
+            new Patterns(...Uninflected::getSingular()),
+            (new Substitutions(...Inflectible::getIrregular()))->getFlippedSubstitutions()
+        );
+    }
+
+    public static function getPluralRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getPlural()),
+            new Patterns(...Uninflected::getPlural()),
+            new Substitutions(...Inflectible::getIrregular())
+        );
+    }
+}
diff --git a/lib/Doctrine/Inflector/Rules/Dutch/Uninflected.php b/lib/Doctrine/Inflector/Rules/Dutch/Uninflected.php
new file mode 100644
index 00000000..0a670954
--- /dev/null
+++ b/lib/Doctrine/Inflector/Rules/Dutch/Uninflected.php
@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Dutch;
+
+use Doctrine\Inflector\Rules\Pattern;
+
+final class Uninflected
+{
+    /**
+     * @return iterable<Pattern>
+     */
+    public static function getSingular(): iterable
+    {
+        yield from self::getDefault();
+
+        // http://nl.wikipedia.org/wiki/Plurale_tantum
+        yield new Pattern('hersenen');
+        yield new Pattern('ingewanden');
+        yield new Pattern('mazelen');
+        yield new Pattern('pokken');
+        yield new Pattern('waterpokken');
+        yield new Pattern('financiën');
+        yield new Pattern('activa');
+        yield new Pattern('passiva');
+        yield new Pattern('onkosten');
+        yield new Pattern('kosten');
+        yield new Pattern('bescheiden');
+        yield new Pattern('paperassen');
+        yield new Pattern('notulen');
+        yield new Pattern('Roma');
+        yield new Pattern('Sinti');
+        yield new Pattern('Inuit');
+        yield new Pattern('taliban');
+        yield new Pattern('illuminati');
+        yield new Pattern('aanstalten');
+        yield new Pattern('hurken');
+        yield new Pattern('lurven');
+        yield new Pattern('luren');
+    }
+
+    /**
+     * @return iterable<Pattern>
+     */
+    public static function getPlural(): iterable
+    {
+        yield from self::getDefault();
+
+        // http://nl.wikipedia.org/wiki/Singulare_tantum
+        yield new Pattern('letterkunde');
+        yield new Pattern('muziek');
+        yield new Pattern('heelal');
+        yield new Pattern('vastgoed');
+        yield new Pattern('have');
+        yield new Pattern('nageslacht');
+    }
+
+    /**
+     * @return Pattern[]
+     */
+    private static function getDefault(): iterable
+    {
+        yield new Pattern('twitter');
+    }
+}
diff --git a/tests/Doctrine/Tests/Inflector/InflectorFactoryTest.php b/tests/Doctrine/Tests/Inflector/InflectorFactoryTest.php
index abb91792..bcebf44a 100644
--- a/tests/Doctrine/Tests/Inflector/InflectorFactoryTest.php
+++ b/tests/Doctrine/Tests/Inflector/InflectorFactoryTest.php
@@ -7,6 +7,7 @@
 use Doctrine\Inflector\InflectorFactory;
 use Doctrine\Inflector\Language;
 use Doctrine\Inflector\LanguageInflectorFactory;
+use Doctrine\Inflector\Rules\Dutch\InflectorFactory as DutchInflectorFactory;
 use Doctrine\Inflector\Rules\English\InflectorFactory as EnglishInflectorFactory;
 use Doctrine\Inflector\Rules\French\InflectorFactory as FrenchInflectorFactory;
 use Doctrine\Inflector\Rules\NorwegianBokmal\InflectorFactory as NorwegianBokmalInflectorFactory;
@@ -38,6 +39,7 @@ public function testCreateForLanguageWithCustomLanguage(string $expectedClass, s
      */
     public static function provideLanguages(): Generator
     {
+        yield 'Dutch' => [DutchInflectorFactory::class, Language::DUTCH];
         yield 'English' => [EnglishInflectorFactory::class, Language::ENGLISH];
         yield 'French' => [FrenchInflectorFactory::class, Language::FRENCH];
         yield 'Norwegian Bokmal' => [NorwegianBokmalInflectorFactory::class, Language::NORWEGIAN_BOKMAL];
diff --git a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
new file mode 100644
index 00000000..c7ec644c
--- /dev/null
+++ b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Inflector\Rules\Dutch;
+
+use Doctrine\Inflector\Inflector;
+use Doctrine\Inflector\InflectorFactory;
+use Doctrine\Inflector\Language;
+use Doctrine\Tests\Inflector\Rules\LanguageFunctionalTest;
+
+class DutchFunctionalTest extends LanguageFunctionalTest
+{
+    /**
+     * @return list<array{string, string}>
+     */
+    public function dataSampleWords(): array
+    {
+        return [
+            ['aanbod', 'aanbiedingen'],
+            ['adres', 'adressen'],
+            ['beleg', 'belegeringen'],
+            ['dank', 'dankbetuigingen'],
+            ['ei', 'eieren'],
+            ['epos', 'epen'],
+            ['gedrag', 'gedragingen'],
+            ['gelid', 'gelederen'],
+            ['genius', 'geniën'],
+            ['genot', 'genietingen'],
+            ['industrie', 'industrieën'],
+            ['kalf', 'kalveren'],
+            ['koe', 'koeien'],
+            ['lam', 'lammeren'],
+            ['leerrede', 'leerredenen'],
+            ['lende', 'lendenen'],
+            ['lid', 'leden'],
+            ['lof', 'lofbetuigingen'],
+            ['matrices', 'matrix'],
+            ['mogelijkheid', 'mogelijkheden'],
+            ['olie', 'oliën'],
+            ['qaestrices', 'quaestrix'],
+            ['rij', 'rijen'],
+            ['schip', 'schepen'],
+            ['smid', 'smeden'],
+            ['stad', 'steden'],
+            ['twitter', 'twitter'],
+            ['vlo', 'vlooien'],
+            ['weerman', 'weermannen'],
+        ];
+    }
+
+    protected function createInflector(): Inflector
+    {
+        return InflectorFactory::createForLanguage(Language::DUTCH)->build();
+    }
+}

From 01215314d8e030d6b34d7dda57e11041a51a7a6a Mon Sep 17 00:00:00 2001
From: Noud de Brouwer <noud4@home.nl>
Date: Wed, 28 Oct 2020 16:54:42 +0100
Subject: [PATCH 04/17] eick point

and recorrected and added greg's doc remarks
---
 lib/Doctrine/Inflector/InflectorFactory.php        | 12 ++++++++++--
 lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php | 12 ++++++------
 .../Inflector/Rules/Dutch/InflectorFactory.php     |  4 ++--
 lib/Doctrine/Inflector/Rules/Dutch/Rules.php       |  4 ++--
 lib/Doctrine/Inflector/Rules/Dutch/Uninflected.php | 12 ++++++------
 .../Tests/Inflector/InflectorFactoryTest.php       | 13 +++++++++----
 .../Inflector/Rules/Dutch/DutchFunctionalTest.php  | 14 ++++++++------
 7 files changed, 43 insertions(+), 28 deletions(-)

diff --git a/lib/Doctrine/Inflector/InflectorFactory.php b/lib/Doctrine/Inflector/InflectorFactory.php
index 6a18960c..d4053ed3 100644
--- a/lib/Doctrine/Inflector/InflectorFactory.php
+++ b/lib/Doctrine/Inflector/InflectorFactory.php
@@ -12,32 +12,40 @@
 use Doctrine\Inflector\Rules\Spanish;
 use Doctrine\Inflector\Rules\Turkish;
 use InvalidArgumentException;
+
 use function sprintf;
 
 final class InflectorFactory
 {
-    public static function create() : LanguageInflectorFactory
+    public static function create(): LanguageInflectorFactory
     {
         return self::createForLanguage(Language::ENGLISH);
     }
 
-    public static function createForLanguage(string $language) : LanguageInflectorFactory
+    public static function createForLanguage(string $language): LanguageInflectorFactory
     {
         switch ($language) {
             case Language::DUTCH:
                 return new Dutch\InflectorFactory();
+
             case Language::ENGLISH:
                 return new English\InflectorFactory();
+
             case Language::FRENCH:
                 return new French\InflectorFactory();
+
             case Language::NORWEGIAN_BOKMAL:
                 return new NorwegianBokmal\InflectorFactory();
+
             case Language::PORTUGUESE:
                 return new Portuguese\InflectorFactory();
+
             case Language::SPANISH:
                 return new Spanish\InflectorFactory();
+
             case Language::TURKISH:
                 return new Turkish\InflectorFactory();
+
             default:
                 throw new InvalidArgumentException(sprintf(
                     'Language "%s" is not supported.',
diff --git a/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php b/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
index d681d413..34fdfd8f 100644
--- a/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
+++ b/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
@@ -32,9 +32,9 @@
 class Inflectible
 {
     /**
-     * @return Transformation[]
+     * @return iterable<Transformation>
      */
-    public static function getSingular() : iterable
+    public static function getSingular(): iterable
     {
         // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Klinkerverandering
         yield new Transformation(new Pattern('()heden$'), '\1heid');
@@ -61,9 +61,9 @@ public static function getSingular() : iterable
     }
 
     /**
-     * @return Transformation[]
+     * @return iterable<Transformation>
      */
-    public static function getPlural() : iterable
+    public static function getPlural(): iterable
     {
         // @todo already in plural (?)
         // @todo refine
@@ -104,9 +104,9 @@ public static function getPlural() : iterable
     }
 
     /**
-     * @return Substitution[]
+     * @return iterable<Substitution>
      */
-    public static function getIrregular() : iterable
+    public static function getIrregular(): iterable
     {
         // http://nl.wikipedia.org/wiki/Klemtoon
         yield new Substitution(new Word('olie'), new Word('oliën'));
diff --git a/lib/Doctrine/Inflector/Rules/Dutch/InflectorFactory.php b/lib/Doctrine/Inflector/Rules/Dutch/InflectorFactory.php
index 41cac0e3..742233bc 100644
--- a/lib/Doctrine/Inflector/Rules/Dutch/InflectorFactory.php
+++ b/lib/Doctrine/Inflector/Rules/Dutch/InflectorFactory.php
@@ -9,12 +9,12 @@
 
 final class InflectorFactory extends GenericLanguageInflectorFactory
 {
-    protected function getSingularRuleset() : Ruleset
+    protected function getSingularRuleset(): Ruleset
     {
         return Rules::getSingularRuleset();
     }
 
-    protected function getPluralRuleset() : Ruleset
+    protected function getPluralRuleset(): Ruleset
     {
         return Rules::getPluralRuleset();
     }
diff --git a/lib/Doctrine/Inflector/Rules/Dutch/Rules.php b/lib/Doctrine/Inflector/Rules/Dutch/Rules.php
index 6a645ced..86755451 100644
--- a/lib/Doctrine/Inflector/Rules/Dutch/Rules.php
+++ b/lib/Doctrine/Inflector/Rules/Dutch/Rules.php
@@ -11,7 +11,7 @@
 
 final class Rules
 {
-    public static function getSingularRuleset() : Ruleset
+    public static function getSingularRuleset(): Ruleset
     {
         return new Ruleset(
             new Transformations(...Inflectible::getSingular()),
@@ -20,7 +20,7 @@ public static function getSingularRuleset() : Ruleset
         );
     }
 
-    public static function getPluralRuleset() : Ruleset
+    public static function getPluralRuleset(): Ruleset
     {
         return new Ruleset(
             new Transformations(...Inflectible::getPlural()),
diff --git a/lib/Doctrine/Inflector/Rules/Dutch/Uninflected.php b/lib/Doctrine/Inflector/Rules/Dutch/Uninflected.php
index a03bb18a..7c984057 100644
--- a/lib/Doctrine/Inflector/Rules/Dutch/Uninflected.php
+++ b/lib/Doctrine/Inflector/Rules/Dutch/Uninflected.php
@@ -9,9 +9,9 @@
 final class Uninflected
 {
     /**
-     * @return Pattern[]
+     * @return iterable<Pattern>
      */
-    public static function getSingular() : iterable
+    public static function getSingular(): iterable
     {
         yield from self::getDefault();
 
@@ -41,9 +41,9 @@ public static function getSingular() : iterable
     }
 
     /**
-     * @return Pattern[]
+     * @return iterable<Pattern>
      */
-    public static function getPlural() : iterable
+    public static function getPlural(): iterable
     {
         yield from self::getDefault();
 
@@ -57,9 +57,9 @@ public static function getPlural() : iterable
     }
 
     /**
-     * @return Pattern[]
+     * @return iterable<Pattern>
      */
-    private static function getDefault() : iterable
+    private static function getDefault(): iterable
     {
         yield new Pattern('twitter');
     }
diff --git a/tests/Doctrine/Tests/Inflector/InflectorFactoryTest.php b/tests/Doctrine/Tests/Inflector/InflectorFactoryTest.php
index 32745d2d..bcebf44a 100644
--- a/tests/Doctrine/Tests/Inflector/InflectorFactoryTest.php
+++ b/tests/Doctrine/Tests/Inflector/InflectorFactoryTest.php
@@ -6,6 +6,7 @@
 
 use Doctrine\Inflector\InflectorFactory;
 use Doctrine\Inflector\Language;
+use Doctrine\Inflector\LanguageInflectorFactory;
 use Doctrine\Inflector\Rules\Dutch\InflectorFactory as DutchInflectorFactory;
 use Doctrine\Inflector\Rules\English\InflectorFactory as EnglishInflectorFactory;
 use Doctrine\Inflector\Rules\French\InflectorFactory as FrenchInflectorFactory;
@@ -19,20 +20,24 @@
 
 class InflectorFactoryTest extends TestCase
 {
-    public function testCreateUsesEnglishByDefault() : void
+    public function testCreateUsesEnglishByDefault(): void
     {
         self::assertInstanceOf(EnglishInflectorFactory::class, InflectorFactory::create());
     }
 
     /**
+     * @phpstan-param class-string<LanguageInflectorFactory> $expectedClass
      * @dataProvider provideLanguages
      */
-    public function testCreateForLanguageWithCustomLanguage(string $expectedClass, string $language) : void
+    public function testCreateForLanguageWithCustomLanguage(string $expectedClass, string $language): void
     {
         self::assertInstanceOf($expectedClass, InflectorFactory::createForLanguage($language));
     }
 
-    public static function provideLanguages() : Generator
+    /**
+     * @phpstan-return Generator<string, array{class-string<LanguageInflectorFactory>, Language::*}>
+     */
+    public static function provideLanguages(): Generator
     {
         yield 'Dutch' => [DutchInflectorFactory::class, Language::DUTCH];
         yield 'English' => [EnglishInflectorFactory::class, Language::ENGLISH];
@@ -43,7 +48,7 @@ public static function provideLanguages() : Generator
         yield 'Turkish' => [TurkishInflectorFactory::class, Language::TURKISH];
     }
 
-    public function testCreateForLanguageThrowsInvalidArgumentExceptionForUnsupportedLanguage() : void
+    public function testCreateForLanguageThrowsInvalidArgumentExceptionForUnsupportedLanguage(): void
     {
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Language "invalid" is not supported.');
diff --git a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
index 6ce3c5ff..1a793341 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
@@ -12,15 +12,15 @@
 class DutchFunctionalTest extends LanguageFunctionalTest
 {
     /**
-     * @return string[][]
+     * @return list<array{string, string}>
      */
     public function dataSampleWords() : array
     {
         return [
-            // @todo: ask for not-sort, cause that's them (ssst) sometimes do, if them do and all that
             ['schip', 'schepen'],
             ['stad', 'steden'],
             ['gelid', 'gelederen'],
+            // @todo more
             ['weerman', 'weermannen'],
             ['ei', 'eieren'],
             ['rij', 'rijen'],
@@ -30,17 +30,19 @@ public function dataSampleWords() : array
             ['industrie', 'industrieën'],
             ['lid', 'leden'],
             ['smid', 'smeden'],
-            ['schip', 'schepen'],
             ['kalf', 'kalveren'],
             ['lam', 'lammeren'],
             ['koe', 'koeien'],
             ['vlo', 'vlooien'],
             ['leerrede', 'leerredenen'],
             ['lende', 'lendenen'],
-            ['epos', 'epen'],   // @todo: make the multiplitudes arrays w/o sort order as well, epossen
+            ['epos', 'epen'],           // @todo: make the multiplitudes arrays w/o sort order as well, epossen
+            ['epos', 'epossen'],
             ['genius', 'geniën'],
             ['aanbod', 'aanbiedingen'],
-            ['beleg', 'belegeringen'],
+            ['beleg', 'belegeringen'],  // @todo: meening: past to circumvent a camp to concor
+            ['beleg', 'beleggen'],      // @todo: meening: present
+            ['beleg', 'belegjes'],      // @todo: meening: the slices food on a sandwich
             ['dank', 'dankbetuigingen'],
             ['gedrag', 'gedragingen'],
             ['genot', 'genietingen'],
@@ -51,7 +53,7 @@ public function dataSampleWords() : array
         ];
     }
 
-    protected function createInflector() : Inflector
+    protected function createInflector(): Inflector
     {
         return InflectorFactory::createForLanguage(Language::DUTCH)->build();
     }

From c69d15eb28a4f059686ebc3ea00ee9392bc40990 Mon Sep 17 00:00:00 2001
From: Noud de Brouwer <noud4@home.nl>
Date: Tue, 1 Dec 2020 20:23:13 +0100
Subject: [PATCH 05/17] recorrected 2

---
 .doctrine-project.json                        | 28 ++++++++++---
 .github/workflows/coding-standards.yml        | 39 +++++++++++++++++++
 README.md                                     |  2 +-
 composer.json                                 | 13 ++-----
 .../Inflector/CachedWordInflector.php         |  2 +-
 .../GenericLanguageInflectorFactory.php       | 11 +++---
 lib/Doctrine/Inflector/Inflector.php          | 19 ++++-----
 .../Inflector/LanguageInflectorFactory.php    |  6 +--
 lib/Doctrine/Inflector/NoopWordInflector.php  |  2 +-
 .../Inflector/Rules/English/Inflectible.php   |  6 +--
 .../Rules/English/InflectorFactory.php        |  4 +-
 .../Inflector/Rules/English/Rules.php         |  4 +-
 .../Inflector/Rules/English/Uninflected.php   |  6 +--
 .../Inflector/Rules/French/Inflectible.php    |  6 +--
 .../Rules/French/InflectorFactory.php         |  4 +-
 lib/Doctrine/Inflector/Rules/French/Rules.php |  4 +-
 .../Inflector/Rules/French/Uninflected.php    |  6 +--
 .../Rules/NorwegianBokmal/Inflectible.php     |  6 +--
 .../NorwegianBokmal/InflectorFactory.php      |  4 +-
 .../Inflector/Rules/NorwegianBokmal/Rules.php |  4 +-
 .../Rules/NorwegianBokmal/Uninflected.php     |  6 +--
 lib/Doctrine/Inflector/Rules/Pattern.php      |  6 +--
 lib/Doctrine/Inflector/Rules/Patterns.php     |  4 +-
 .../Rules/Portuguese/Inflectible.php          |  6 +--
 .../Rules/Portuguese/InflectorFactory.php     |  4 +-
 .../Inflector/Rules/Portuguese/Rules.php      |  4 +-
 .../Rules/Portuguese/Uninflected.php          |  6 +--
 lib/Doctrine/Inflector/Rules/Ruleset.php      |  6 +--
 .../Inflector/Rules/Spanish/Inflectible.php   |  6 +--
 .../Rules/Spanish/InflectorFactory.php        |  4 +-
 .../Inflector/Rules/Spanish/Rules.php         |  4 +-
 .../Inflector/Rules/Spanish/Uninflected.php   |  6 +--
 lib/Doctrine/Inflector/Rules/Substitution.php |  4 +-
 .../Inflector/Rules/Substitutions.php         |  5 ++-
 .../Inflector/Rules/Transformation.php        |  7 ++--
 .../Inflector/Rules/Transformations.php       |  2 +-
 .../Inflector/Rules/Turkish/Inflectible.php   |  6 +--
 .../Rules/Turkish/InflectorFactory.php        |  4 +-
 .../Inflector/Rules/Turkish/Rules.php         |  4 +-
 .../Inflector/Rules/Turkish/Uninflected.php   |  6 +--
 lib/Doctrine/Inflector/Rules/Word.php         |  2 +-
 lib/Doctrine/Inflector/RulesetInflector.php   |  3 +-
 lib/Doctrine/Inflector/WordInflector.php      |  2 +-
 .../Inflector/CachedWordInflectorTest.php     |  4 +-
 .../Inflector/InflectorFunctionalTest.php     | 18 ++++-----
 .../Tests/Inflector/InflectorTest.php         | 22 +++++------
 .../Tests/Inflector/NoopWordInflectorTest.php |  4 +-
 .../Rules/Dutch/DutchFunctionalTest.php       |  2 +-
 .../Rules/English/EnglishFunctionalTest.php   | 13 ++++---
 .../Rules/French/FrenchFunctionalTest.php     |  4 +-
 .../Rules/LanguageFunctionalTest.php          |  9 +++--
 .../NorwegianBokmalFunctionalTest.php         |  4 +-
 .../Tests/Inflector/Rules/PatternTest.php     | 10 ++---
 .../Tests/Inflector/Rules/PatternsTest.php    |  4 +-
 .../Portuguese/PortugueseFunctionalTest.php   |  4 +-
 .../Tests/Inflector/Rules/RulesetTest.php     |  8 ++--
 .../Rules/Spanish/SpanishFunctionalTest.php   |  4 +-
 .../Inflector/Rules/SubstitutionTest.php      |  6 +--
 .../Inflector/Rules/SubstitutionsTest.php     |  6 +--
 .../Inflector/Rules/TransformationTest.php    |  8 ++--
 .../Inflector/Rules/TransformationsTest.php   |  4 +-
 .../Rules/Turkish/TurkishFunctionalTest.php   |  4 +-
 .../Tests/Inflector/Rules/WordTest.php        |  4 +-
 .../Tests/Inflector/RulesetInflectorTest.php  | 16 ++++----
 64 files changed, 249 insertions(+), 192 deletions(-)
 create mode 100644 .github/workflows/coding-standards.yml

diff --git a/.doctrine-project.json b/.doctrine-project.json
index 0b8518ca..bf0f1ec5 100644
--- a/.doctrine-project.json
+++ b/.doctrine-project.json
@@ -6,12 +6,9 @@
     "versions": [
         {
             "name": "2.1",
-            "branchName": "master",
+            "branchName": "2.1.x",
             "slug": "2.1",
-            "upcoming": true,
-            "aliases": [
-                "latest"
-            ]
+            "upcoming": true
         },
         {
             "name": "2.0",
@@ -26,13 +23,32 @@
         {
             "name": "1.4",
             "branchName": "1.4.x",
-            "slug": "1.4"
+            "slug": "1.4",
+            "maintained": false
         },
         {
             "name": "1.3",
             "branchName": "1.3.x",
             "slug": "1.3",
             "maintained": false
+        },
+        {
+            "name": "1.2",
+            "branchName": "1.2.x",
+            "slug": "1.2",
+            "maintained": false
+        },
+        {
+            "name": "1.1",
+            "branchName": "1.1.x",
+            "slug": "1.1",
+            "maintained": false
+        },
+        {
+            "name": "1.0",
+            "branchName": "1.0.x",
+            "slug": "1.0",
+            "maintained": false
         }
     ]
 }
diff --git a/.github/workflows/coding-standards.yml b/.github/workflows/coding-standards.yml
new file mode 100644
index 00000000..7df68899
--- /dev/null
+++ b/.github/workflows/coding-standards.yml
@@ -0,0 +1,39 @@
+
+name: "Coding Standards"
+
+on: ["pull_request", "push"]
+
+jobs:
+  coding-standards:
+    name: "Coding Standards"
+    runs-on: "ubuntu-20.04"
+
+    strategy:
+      matrix:
+        php-version:
+          - "7.4"
+
+    steps:
+      - name: "Checkout"
+        uses: "actions/checkout@v2"
+
+      - name: "Install PHP"
+        uses: "shivammathur/setup-php@v2"
+        with:
+          coverage: "none"
+          php-version: "${{ matrix.php-version }}"
+          tools: "cs2pr"
+
+      - name: "Cache dependencies installed with Composer"
+        uses: "actions/cache@v2"
+        with:
+          path: "~/.composer/cache"
+          key: "php-${{ matrix.php-version }}-composer-locked-${{ hashFiles('composer.lock') }}"
+          restore-keys: "php-${{ matrix.php-version }}-composer-locked-"
+
+      - name: "Install dependencies with Composer"
+        run: "composer install --no-interaction --no-progress --no-suggest"
+
+      # https://github.com/doctrine/.github/issues/3
+      - name: "Run PHP_CodeSniffer"
+        run: "vendor/bin/phpcs -q --no-colors --report=checkstyle | cs2pr"
diff --git a/README.md b/README.md
index c0d225ce..ff174d67 100644
--- a/README.md
+++ b/README.md
@@ -4,4 +4,4 @@ Doctrine Inflector is a small library that can perform string manipulations
 with regard to uppercase/lowercase and singular/plural forms of words.
 
 [![Build Status](https://travis-ci.org/doctrine/inflector.svg)](https://travis-ci.org/doctrine/inflector)
-[![Code Coverage](https://codecov.io/gh/doctrine/inflector/branch/master/graph/badge.svg)](https://codecov.io/gh/doctrine/inflector/branch/master)
+[![Code Coverage](https://codecov.io/gh/doctrine/inflector/branch/2.0.x/graph/badge.svg)](https://codecov.io/gh/doctrine/inflector/branch/2.0.x)
diff --git a/composer.json b/composer.json
index 9bed05de..a3e17ca2 100644
--- a/composer.json
+++ b/composer.json
@@ -16,10 +16,10 @@
         "php": "^7.2 || ^8.0"
     },
     "require-dev": {
-        "doctrine/coding-standard": "^7.0",
-        "phpstan/phpstan": "^0.11",
-        "phpstan/phpstan-phpunit": "^0.11",
-        "phpstan/phpstan-strict-rules": "^0.11",
+        "doctrine/coding-standard": "^8.2",
+        "phpstan/phpstan": "^0.12",
+        "phpstan/phpstan-phpunit": "^0.12",
+        "phpstan/phpstan-strict-rules": "^0.12",
         "phpunit/phpunit": "^7.0 || ^8.0 || ^9.0"
     },
     "autoload": {
@@ -31,10 +31,5 @@
         "psr-4": {
             "Doctrine\\Tests\\Inflector\\": "tests/Doctrine/Tests/Inflector"
         }
-    },
-    "extra": {
-        "branch-alias": {
-            "dev-master": "2.1.x-dev"
-        }
     }
 }
diff --git a/lib/Doctrine/Inflector/CachedWordInflector.php b/lib/Doctrine/Inflector/CachedWordInflector.php
index b59ac46c..2d529087 100644
--- a/lib/Doctrine/Inflector/CachedWordInflector.php
+++ b/lib/Doctrine/Inflector/CachedWordInflector.php
@@ -17,7 +17,7 @@ public function __construct(WordInflector $wordInflector)
         $this->wordInflector = $wordInflector;
     }
 
-    public function inflect(string $word) : string
+    public function inflect(string $word): string
     {
         return $this->cache[$word] ?? $this->cache[$word] = $this->wordInflector->inflect($word);
     }
diff --git a/lib/Doctrine/Inflector/GenericLanguageInflectorFactory.php b/lib/Doctrine/Inflector/GenericLanguageInflectorFactory.php
index 1b15061a..166061d2 100644
--- a/lib/Doctrine/Inflector/GenericLanguageInflectorFactory.php
+++ b/lib/Doctrine/Inflector/GenericLanguageInflectorFactory.php
@@ -5,6 +5,7 @@
 namespace Doctrine\Inflector;
 
 use Doctrine\Inflector\Rules\Ruleset;
+
 use function array_unshift;
 
 abstract class GenericLanguageInflectorFactory implements LanguageInflectorFactory
@@ -21,7 +22,7 @@ final public function __construct()
         $this->pluralRulesets[]   = $this->getPluralRuleset();
     }
 
-    final public function build() : Inflector
+    final public function build(): Inflector
     {
         return new Inflector(
             new CachedWordInflector(new RulesetInflector(
@@ -33,7 +34,7 @@ final public function build() : Inflector
         );
     }
 
-    final public function withSingularRules(?Ruleset $singularRules, bool $reset = false) : LanguageInflectorFactory
+    final public function withSingularRules(?Ruleset $singularRules, bool $reset = false): LanguageInflectorFactory
     {
         if ($reset) {
             $this->singularRulesets = [];
@@ -46,7 +47,7 @@ final public function withSingularRules(?Ruleset $singularRules, bool $reset = f
         return $this;
     }
 
-    final public function withPluralRules(?Ruleset $pluralRules, bool $reset = false) : LanguageInflectorFactory
+    final public function withPluralRules(?Ruleset $pluralRules, bool $reset = false): LanguageInflectorFactory
     {
         if ($reset) {
             $this->pluralRulesets = [];
@@ -59,7 +60,7 @@ final public function withPluralRules(?Ruleset $pluralRules, bool $reset = false
         return $this;
     }
 
-    abstract protected function getSingularRuleset() : Ruleset;
+    abstract protected function getSingularRuleset(): Ruleset;
 
-    abstract protected function getPluralRuleset() : Ruleset;
+    abstract protected function getPluralRuleset(): Ruleset;
 }
diff --git a/lib/Doctrine/Inflector/Inflector.php b/lib/Doctrine/Inflector/Inflector.php
index 24119185..610a4cf4 100644
--- a/lib/Doctrine/Inflector/Inflector.php
+++ b/lib/Doctrine/Inflector/Inflector.php
@@ -5,6 +5,7 @@
 namespace Doctrine\Inflector;
 
 use RuntimeException;
+
 use function chr;
 use function function_exists;
 use function lcfirst;
@@ -228,7 +229,7 @@ public function __construct(WordInflector $singularizer, WordInflector $pluraliz
     /**
      * Converts a word into the format for a Doctrine table name. Converts 'ModelName' to 'model_name'.
      */
-    public function tableize(string $word) : string
+    public function tableize(string $word): string
     {
         $tableized = preg_replace('~(?<=\\w)([A-Z])~u', '_$1', $word);
 
@@ -245,7 +246,7 @@ public function tableize(string $word) : string
     /**
      * Converts a word into the format for a Doctrine class name. Converts 'table_name' to 'TableName'.
      */
-    public function classify(string $word) : string
+    public function classify(string $word): string
     {
         return str_replace([' ', '_', '-'], '', ucwords($word, ' _-'));
     }
@@ -253,7 +254,7 @@ public function classify(string $word) : string
     /**
      * Camelizes a word. This uses the classify() method and turns the first character to lowercase.
      */
-    public function camelize(string $word) : string
+    public function camelize(string $word): string
     {
         return lcfirst($this->classify($word));
     }
@@ -283,7 +284,7 @@ public function camelize(string $word) : string
      *
      * @return string The string with all delimiter-separated words capitalized.
      */
-    public function capitalize(string $string, string $delimiters = " \n\t\r\0\x0B-") : string
+    public function capitalize(string $string, string $delimiters = " \n\t\r\0\x0B-"): string
     {
         return ucwords($string, $delimiters);
     }
@@ -293,7 +294,7 @@ public function capitalize(string $string, string $delimiters = " \n\t\r\0\x0B-"
      *
      * @param string $string The string to check for utf8 characters in.
      */
-    public function seemsUtf8(string $string) : bool
+    public function seemsUtf8(string $string): bool
     {
         for ($i = 0; $i < strlen($string); $i++) {
             if (ord($string[$i]) < 0x80) {
@@ -331,7 +332,7 @@ public function seemsUtf8(string $string) : bool
      *
      * @return string Unaccented string
      */
-    public function unaccent(string $string) : string
+    public function unaccent(string $string): string
     {
         if (preg_match('/[\x80-\xff]/', $string) === false) {
             return $string;
@@ -444,7 +445,7 @@ public function unaccent(string $string) : string
      *
      * @return string Urlized string.
      */
-    public function urlize(string $string) : string
+    public function urlize(string $string): string
     {
         // Remove all non url friendly characters with the unaccent function
         $unaccented = $this->unaccent($string);
@@ -487,7 +488,7 @@ public function urlize(string $string) : string
      *
      * @return string The word in singular form.
      */
-    public function singularize(string $word) : string
+    public function singularize(string $word): string
     {
         return $this->singularizer->inflect($word);
     }
@@ -499,7 +500,7 @@ public function singularize(string $word) : string
      *
      * @return string The word in plural form.
      */
-    public function pluralize(string $word) : string
+    public function pluralize(string $word): string
     {
         return $this->pluralizer->inflect($word);
     }
diff --git a/lib/Doctrine/Inflector/LanguageInflectorFactory.php b/lib/Doctrine/Inflector/LanguageInflectorFactory.php
index a80dd6c4..a58f43c0 100644
--- a/lib/Doctrine/Inflector/LanguageInflectorFactory.php
+++ b/lib/Doctrine/Inflector/LanguageInflectorFactory.php
@@ -15,7 +15,7 @@ interface LanguageInflectorFactory
      *
      * @return $this
      */
-    public function withSingularRules(?Ruleset $singularRules, bool $reset = false) : self;
+    public function withSingularRules(?Ruleset $singularRules, bool $reset = false): self;
 
     /**
      * Applies custom rules for pluralisation
@@ -24,10 +24,10 @@ public function withSingularRules(?Ruleset $singularRules, bool $reset = false)
      *
      * @return $this
      */
-    public function withPluralRules(?Ruleset $pluralRules, bool $reset = false) : self;
+    public function withPluralRules(?Ruleset $pluralRules, bool $reset = false): self;
 
     /**
      * Builds the inflector instance with all applicable rules
      */
-    public function build() : Inflector;
+    public function build(): Inflector;
 }
diff --git a/lib/Doctrine/Inflector/NoopWordInflector.php b/lib/Doctrine/Inflector/NoopWordInflector.php
index 63806ecc..2fdf5353 100644
--- a/lib/Doctrine/Inflector/NoopWordInflector.php
+++ b/lib/Doctrine/Inflector/NoopWordInflector.php
@@ -6,7 +6,7 @@
 
 class NoopWordInflector implements WordInflector
 {
-    public function inflect(string $word) : string
+    public function inflect(string $word): string
     {
         return $word;
     }
diff --git a/lib/Doctrine/Inflector/Rules/English/Inflectible.php b/lib/Doctrine/Inflector/Rules/English/Inflectible.php
index 0de97a27..8f0919fc 100644
--- a/lib/Doctrine/Inflector/Rules/English/Inflectible.php
+++ b/lib/Doctrine/Inflector/Rules/English/Inflectible.php
@@ -14,7 +14,7 @@ class Inflectible
     /**
      * @return Transformation[]
      */
-    public static function getSingular() : iterable
+    public static function getSingular(): iterable
     {
         yield new Transformation(new Pattern('(s)tatuses$'), '\1\2tatus');
         yield new Transformation(new Pattern('(s)tatus$'), '\1\2tatus');
@@ -62,7 +62,7 @@ public static function getSingular() : iterable
     /**
      * @return Transformation[]
      */
-    public static function getPlural() : iterable
+    public static function getPlural(): iterable
     {
         yield new Transformation(new Pattern('(s)tatus$'), '\1\2tatuses');
         yield new Transformation(new Pattern('(quiz)$'), '\1zes');
@@ -94,7 +94,7 @@ public static function getPlural() : iterable
     /**
      * @return Substitution[]
      */
-    public static function getIrregular() : iterable
+    public static function getIrregular(): iterable
     {
         yield new Substitution(new Word('atlas'), new Word('atlases'));
         yield new Substitution(new Word('axe'), new Word('axes'));
diff --git a/lib/Doctrine/Inflector/Rules/English/InflectorFactory.php b/lib/Doctrine/Inflector/Rules/English/InflectorFactory.php
index cd40021f..85f92aa8 100644
--- a/lib/Doctrine/Inflector/Rules/English/InflectorFactory.php
+++ b/lib/Doctrine/Inflector/Rules/English/InflectorFactory.php
@@ -9,12 +9,12 @@
 
 final class InflectorFactory extends GenericLanguageInflectorFactory
 {
-    protected function getSingularRuleset() : Ruleset
+    protected function getSingularRuleset(): Ruleset
     {
         return Rules::getSingularRuleset();
     }
 
-    protected function getPluralRuleset() : Ruleset
+    protected function getPluralRuleset(): Ruleset
     {
         return Rules::getPluralRuleset();
     }
diff --git a/lib/Doctrine/Inflector/Rules/English/Rules.php b/lib/Doctrine/Inflector/Rules/English/Rules.php
index fcc1d19c..7ccc1038 100644
--- a/lib/Doctrine/Inflector/Rules/English/Rules.php
+++ b/lib/Doctrine/Inflector/Rules/English/Rules.php
@@ -11,7 +11,7 @@
 
 final class Rules
 {
-    public static function getSingularRuleset() : Ruleset
+    public static function getSingularRuleset(): Ruleset
     {
         return new Ruleset(
             new Transformations(...Inflectible::getSingular()),
@@ -20,7 +20,7 @@ public static function getSingularRuleset() : Ruleset
         );
     }
 
-    public static function getPluralRuleset() : Ruleset
+    public static function getPluralRuleset(): Ruleset
     {
         return new Ruleset(
             new Transformations(...Inflectible::getPlural()),
diff --git a/lib/Doctrine/Inflector/Rules/English/Uninflected.php b/lib/Doctrine/Inflector/Rules/English/Uninflected.php
index be37a97b..e2656cc4 100644
--- a/lib/Doctrine/Inflector/Rules/English/Uninflected.php
+++ b/lib/Doctrine/Inflector/Rules/English/Uninflected.php
@@ -11,7 +11,7 @@ final class Uninflected
     /**
      * @return Pattern[]
      */
-    public static function getSingular() : iterable
+    public static function getSingular(): iterable
     {
         yield from self::getDefault();
 
@@ -33,7 +33,7 @@ public static function getSingular() : iterable
     /**
      * @return Pattern[]
      */
-    public static function getPlural() : iterable
+    public static function getPlural(): iterable
     {
         yield from self::getDefault();
 
@@ -46,7 +46,7 @@ public static function getPlural() : iterable
     /**
      * @return Pattern[]
      */
-    private static function getDefault() : iterable
+    private static function getDefault(): iterable
     {
         yield new Pattern('\w+media');
         yield new Pattern('advice');
diff --git a/lib/Doctrine/Inflector/Rules/French/Inflectible.php b/lib/Doctrine/Inflector/Rules/French/Inflectible.php
index b3f22ed2..c73d3dee 100644
--- a/lib/Doctrine/Inflector/Rules/French/Inflectible.php
+++ b/lib/Doctrine/Inflector/Rules/French/Inflectible.php
@@ -14,7 +14,7 @@ class Inflectible
     /**
      * @return Transformation[]
      */
-    public static function getSingular() : iterable
+    public static function getSingular(): iterable
     {
         yield new Transformation(new Pattern('/(b|cor|ém|gemm|soupir|trav|vant|vitr)aux$/'), '\1ail');
         yield new Transformation(new Pattern('/ails$/'), 'ail');
@@ -26,7 +26,7 @@ public static function getSingular() : iterable
     /**
      * @return Transformation[]
      */
-    public static function getPlural() : iterable
+    public static function getPlural(): iterable
     {
         yield new Transformation(new Pattern('/(s|x|z)$/'), '\1');
         yield new Transformation(new Pattern('/(b|cor|ém|gemm|soupir|trav|vant|vitr)ail$/'), '\1aux');
@@ -40,7 +40,7 @@ public static function getPlural() : iterable
     /**
      * @return Substitution[]
      */
-    public static function getIrregular() : iterable
+    public static function getIrregular(): iterable
     {
         yield new Substitution(new Word('monsieur'), new Word('messieurs'));
         yield new Substitution(new Word('madame'), new Word('mesdames'));
diff --git a/lib/Doctrine/Inflector/Rules/French/InflectorFactory.php b/lib/Doctrine/Inflector/Rules/French/InflectorFactory.php
index 7042d498..62e31f08 100644
--- a/lib/Doctrine/Inflector/Rules/French/InflectorFactory.php
+++ b/lib/Doctrine/Inflector/Rules/French/InflectorFactory.php
@@ -9,12 +9,12 @@
 
 final class InflectorFactory extends GenericLanguageInflectorFactory
 {
-    protected function getSingularRuleset() : Ruleset
+    protected function getSingularRuleset(): Ruleset
     {
         return Rules::getSingularRuleset();
     }
 
-    protected function getPluralRuleset() : Ruleset
+    protected function getPluralRuleset(): Ruleset
     {
         return Rules::getPluralRuleset();
     }
diff --git a/lib/Doctrine/Inflector/Rules/French/Rules.php b/lib/Doctrine/Inflector/Rules/French/Rules.php
index d25f8a8c..6cd45bc5 100644
--- a/lib/Doctrine/Inflector/Rules/French/Rules.php
+++ b/lib/Doctrine/Inflector/Rules/French/Rules.php
@@ -11,7 +11,7 @@
 
 final class Rules
 {
-    public static function getSingularRuleset() : Ruleset
+    public static function getSingularRuleset(): Ruleset
     {
         return new Ruleset(
             new Transformations(...Inflectible::getSingular()),
@@ -20,7 +20,7 @@ public static function getSingularRuleset() : Ruleset
         );
     }
 
-    public static function getPluralRuleset() : Ruleset
+    public static function getPluralRuleset(): Ruleset
     {
         return new Ruleset(
             new Transformations(...Inflectible::getPlural()),
diff --git a/lib/Doctrine/Inflector/Rules/French/Uninflected.php b/lib/Doctrine/Inflector/Rules/French/Uninflected.php
index 2fdc020a..3cf2444a 100644
--- a/lib/Doctrine/Inflector/Rules/French/Uninflected.php
+++ b/lib/Doctrine/Inflector/Rules/French/Uninflected.php
@@ -11,7 +11,7 @@ final class Uninflected
     /**
      * @return Pattern[]
      */
-    public static function getSingular() : iterable
+    public static function getSingular(): iterable
     {
         yield from self::getDefault();
     }
@@ -19,7 +19,7 @@ public static function getSingular() : iterable
     /**
      * @return Pattern[]
      */
-    public static function getPlural() : iterable
+    public static function getPlural(): iterable
     {
         yield from self::getDefault();
     }
@@ -27,7 +27,7 @@ public static function getPlural() : iterable
     /**
      * @return Pattern[]
      */
-    private static function getDefault() : iterable
+    private static function getDefault(): iterable
     {
         yield new Pattern('');
     }
diff --git a/lib/Doctrine/Inflector/Rules/NorwegianBokmal/Inflectible.php b/lib/Doctrine/Inflector/Rules/NorwegianBokmal/Inflectible.php
index 9fae0f36..c00317dc 100644
--- a/lib/Doctrine/Inflector/Rules/NorwegianBokmal/Inflectible.php
+++ b/lib/Doctrine/Inflector/Rules/NorwegianBokmal/Inflectible.php
@@ -14,7 +14,7 @@ class Inflectible
     /**
      * @return Transformation[]
      */
-    public static function getSingular() : iterable
+    public static function getSingular(): iterable
     {
         yield new Transformation(new Pattern('/re$/i'), 'r');
         yield new Transformation(new Pattern('/er$/i'), '');
@@ -23,7 +23,7 @@ public static function getSingular() : iterable
     /**
      * @return Transformation[]
      */
-    public static function getPlural() : iterable
+    public static function getPlural(): iterable
     {
         yield new Transformation(new Pattern('/e$/i'), 'er');
         yield new Transformation(new Pattern('/r$/i'), 're');
@@ -33,7 +33,7 @@ public static function getPlural() : iterable
     /**
      * @return Substitution[]
      */
-    public static function getIrregular() : iterable
+    public static function getIrregular(): iterable
     {
         yield new Substitution(new Word('konto'), new Word('konti'));
     }
diff --git a/lib/Doctrine/Inflector/Rules/NorwegianBokmal/InflectorFactory.php b/lib/Doctrine/Inflector/Rules/NorwegianBokmal/InflectorFactory.php
index 41b9b384..912ae41b 100644
--- a/lib/Doctrine/Inflector/Rules/NorwegianBokmal/InflectorFactory.php
+++ b/lib/Doctrine/Inflector/Rules/NorwegianBokmal/InflectorFactory.php
@@ -9,12 +9,12 @@
 
 final class InflectorFactory extends GenericLanguageInflectorFactory
 {
-    protected function getSingularRuleset() : Ruleset
+    protected function getSingularRuleset(): Ruleset
     {
         return Rules::getSingularRuleset();
     }
 
-    protected function getPluralRuleset() : Ruleset
+    protected function getPluralRuleset(): Ruleset
     {
         return Rules::getPluralRuleset();
     }
diff --git a/lib/Doctrine/Inflector/Rules/NorwegianBokmal/Rules.php b/lib/Doctrine/Inflector/Rules/NorwegianBokmal/Rules.php
index 5a92132a..9902d353 100644
--- a/lib/Doctrine/Inflector/Rules/NorwegianBokmal/Rules.php
+++ b/lib/Doctrine/Inflector/Rules/NorwegianBokmal/Rules.php
@@ -11,7 +11,7 @@
 
 final class Rules
 {
-    public static function getSingularRuleset() : Ruleset
+    public static function getSingularRuleset(): Ruleset
     {
         return new Ruleset(
             new Transformations(...Inflectible::getSingular()),
@@ -20,7 +20,7 @@ public static function getSingularRuleset() : Ruleset
         );
     }
 
-    public static function getPluralRuleset() : Ruleset
+    public static function getPluralRuleset(): Ruleset
     {
         return new Ruleset(
             new Transformations(...Inflectible::getPlural()),
diff --git a/lib/Doctrine/Inflector/Rules/NorwegianBokmal/Uninflected.php b/lib/Doctrine/Inflector/Rules/NorwegianBokmal/Uninflected.php
index c6b9fc79..5d878c6d 100644
--- a/lib/Doctrine/Inflector/Rules/NorwegianBokmal/Uninflected.php
+++ b/lib/Doctrine/Inflector/Rules/NorwegianBokmal/Uninflected.php
@@ -11,7 +11,7 @@ final class Uninflected
     /**
      * @return Pattern[]
      */
-    public static function getSingular() : iterable
+    public static function getSingular(): iterable
     {
         yield from self::getDefault();
     }
@@ -19,7 +19,7 @@ public static function getSingular() : iterable
     /**
      * @return Pattern[]
      */
-    public static function getPlural() : iterable
+    public static function getPlural(): iterable
     {
         yield from self::getDefault();
     }
@@ -27,7 +27,7 @@ public static function getPlural() : iterable
     /**
      * @return Pattern[]
      */
-    private static function getDefault() : iterable
+    private static function getDefault(): iterable
     {
         yield new Pattern('barn');
         yield new Pattern('fjell');
diff --git a/lib/Doctrine/Inflector/Rules/Pattern.php b/lib/Doctrine/Inflector/Rules/Pattern.php
index 3486eba5..a5f0ef77 100644
--- a/lib/Doctrine/Inflector/Rules/Pattern.php
+++ b/lib/Doctrine/Inflector/Rules/Pattern.php
@@ -25,17 +25,17 @@ public function __construct(string $pattern)
         }
     }
 
-    public function getPattern() : string
+    public function getPattern(): string
     {
         return $this->pattern;
     }
 
-    public function getRegex() : string
+    public function getRegex(): string
     {
         return $this->regex;
     }
 
-    public function matches(string $word) : bool
+    public function matches(string $word): bool
     {
         return preg_match($this->getRegex(), $word) === 1;
     }
diff --git a/lib/Doctrine/Inflector/Rules/Patterns.php b/lib/Doctrine/Inflector/Rules/Patterns.php
index a71f1ed2..e8d45cb7 100644
--- a/lib/Doctrine/Inflector/Rules/Patterns.php
+++ b/lib/Doctrine/Inflector/Rules/Patterns.php
@@ -20,14 +20,14 @@ public function __construct(Pattern ...$patterns)
     {
         $this->patterns = $patterns;
 
-        $patterns = array_map(static function (Pattern $pattern) : string {
+        $patterns = array_map(static function (Pattern $pattern): string {
             return $pattern->getPattern();
         }, $this->patterns);
 
         $this->regex = '/^(?:' . implode('|', $patterns) . ')$/i';
     }
 
-    public function matches(string $word) : bool
+    public function matches(string $word): bool
     {
         return preg_match($this->regex, $word, $regs) === 1;
     }
diff --git a/lib/Doctrine/Inflector/Rules/Portuguese/Inflectible.php b/lib/Doctrine/Inflector/Rules/Portuguese/Inflectible.php
index 155055f7..95564d49 100644
--- a/lib/Doctrine/Inflector/Rules/Portuguese/Inflectible.php
+++ b/lib/Doctrine/Inflector/Rules/Portuguese/Inflectible.php
@@ -14,7 +14,7 @@ class Inflectible
     /**
      * @return Transformation[]
      */
-    public static function getSingular() : iterable
+    public static function getSingular(): iterable
     {
         yield new Transformation(new Pattern('/^(g|)ases$/i'), '\1ás');
         yield new Transformation(new Pattern('/(japon|escoc|ingl|dinamarqu|fregu|portugu)eses$/i'), '\1ês');
@@ -37,7 +37,7 @@ public static function getSingular() : iterable
     /**
      * @return Transformation[]
      */
-    public static function getPlural() : iterable
+    public static function getPlural(): iterable
     {
         yield new Transformation(new Pattern('/^(alem|c|p)ao$/i'), '\1aes');
         yield new Transformation(new Pattern('/^(irm|m)ao$/i'), '\1aos');
@@ -61,7 +61,7 @@ public static function getPlural() : iterable
     /**
      * @return Substitution[]
      */
-    public static function getIrregular() : iterable
+    public static function getIrregular(): iterable
     {
         yield new Substitution(new Word('abdomen'), new Word('abdomens'));
         yield new Substitution(new Word('alemão'), new Word('alemães'));
diff --git a/lib/Doctrine/Inflector/Rules/Portuguese/InflectorFactory.php b/lib/Doctrine/Inflector/Rules/Portuguese/InflectorFactory.php
index 536587e0..bf12d54f 100644
--- a/lib/Doctrine/Inflector/Rules/Portuguese/InflectorFactory.php
+++ b/lib/Doctrine/Inflector/Rules/Portuguese/InflectorFactory.php
@@ -9,12 +9,12 @@
 
 final class InflectorFactory extends GenericLanguageInflectorFactory
 {
-    protected function getSingularRuleset() : Ruleset
+    protected function getSingularRuleset(): Ruleset
     {
         return Rules::getSingularRuleset();
     }
 
-    protected function getPluralRuleset() : Ruleset
+    protected function getPluralRuleset(): Ruleset
     {
         return Rules::getPluralRuleset();
     }
diff --git a/lib/Doctrine/Inflector/Rules/Portuguese/Rules.php b/lib/Doctrine/Inflector/Rules/Portuguese/Rules.php
index de69b7ec..897f1776 100644
--- a/lib/Doctrine/Inflector/Rules/Portuguese/Rules.php
+++ b/lib/Doctrine/Inflector/Rules/Portuguese/Rules.php
@@ -11,7 +11,7 @@
 
 final class Rules
 {
-    public static function getSingularRuleset() : Ruleset
+    public static function getSingularRuleset(): Ruleset
     {
         return new Ruleset(
             new Transformations(...Inflectible::getSingular()),
@@ -20,7 +20,7 @@ public static function getSingularRuleset() : Ruleset
         );
     }
 
-    public static function getPluralRuleset() : Ruleset
+    public static function getPluralRuleset(): Ruleset
     {
         return new Ruleset(
             new Transformations(...Inflectible::getPlural()),
diff --git a/lib/Doctrine/Inflector/Rules/Portuguese/Uninflected.php b/lib/Doctrine/Inflector/Rules/Portuguese/Uninflected.php
index 52360c45..58c34f9b 100644
--- a/lib/Doctrine/Inflector/Rules/Portuguese/Uninflected.php
+++ b/lib/Doctrine/Inflector/Rules/Portuguese/Uninflected.php
@@ -11,7 +11,7 @@ final class Uninflected
     /**
      * @return Pattern[]
      */
-    public static function getSingular() : iterable
+    public static function getSingular(): iterable
     {
         yield from self::getDefault();
     }
@@ -19,7 +19,7 @@ public static function getSingular() : iterable
     /**
      * @return Pattern[]
      */
-    public static function getPlural() : iterable
+    public static function getPlural(): iterable
     {
         yield from self::getDefault();
     }
@@ -27,7 +27,7 @@ public static function getPlural() : iterable
     /**
      * @return Pattern[]
      */
-    private static function getDefault() : iterable
+    private static function getDefault(): iterable
     {
         yield new Pattern('tórax');
         yield new Pattern('tênis');
diff --git a/lib/Doctrine/Inflector/Rules/Ruleset.php b/lib/Doctrine/Inflector/Rules/Ruleset.php
index a2d32c1d..39889b79 100644
--- a/lib/Doctrine/Inflector/Rules/Ruleset.php
+++ b/lib/Doctrine/Inflector/Rules/Ruleset.php
@@ -22,17 +22,17 @@ public function __construct(Transformations $regular, Patterns $uninflected, Sub
         $this->irregular   = $irregular;
     }
 
-    public function getRegular() : Transformations
+    public function getRegular(): Transformations
     {
         return $this->regular;
     }
 
-    public function getUninflected() : Patterns
+    public function getUninflected(): Patterns
     {
         return $this->uninflected;
     }
 
-    public function getIrregular() : Substitutions
+    public function getIrregular(): Substitutions
     {
         return $this->irregular;
     }
diff --git a/lib/Doctrine/Inflector/Rules/Spanish/Inflectible.php b/lib/Doctrine/Inflector/Rules/Spanish/Inflectible.php
index 6cace86a..c6862fa4 100644
--- a/lib/Doctrine/Inflector/Rules/Spanish/Inflectible.php
+++ b/lib/Doctrine/Inflector/Rules/Spanish/Inflectible.php
@@ -14,7 +14,7 @@ class Inflectible
     /**
      * @return Transformation[]
      */
-    public static function getSingular() : iterable
+    public static function getSingular(): iterable
     {
         yield new Transformation(new Pattern('/ereses$/'), 'erés');
         yield new Transformation(new Pattern('/iones$/'), 'ión');
@@ -26,7 +26,7 @@ public static function getSingular() : iterable
     /**
      * @return Transformation[]
      */
-    public static function getPlural() : iterable
+    public static function getPlural(): iterable
     {
         yield new Transformation(new Pattern('/ú([sn])$/i'), 'u\1es');
         yield new Transformation(new Pattern('/ó([sn])$/i'), 'o\1es');
@@ -42,7 +42,7 @@ public static function getPlural() : iterable
     /**
      * @return Substitution[]
      */
-    public static function getIrregular() : iterable
+    public static function getIrregular(): iterable
     {
         yield new Substitution(new Word('el'), new Word('los'));
         yield new Substitution(new Word('papá'), new Word('papás'));
diff --git a/lib/Doctrine/Inflector/Rules/Spanish/InflectorFactory.php b/lib/Doctrine/Inflector/Rules/Spanish/InflectorFactory.php
index da643bda..85084ca3 100644
--- a/lib/Doctrine/Inflector/Rules/Spanish/InflectorFactory.php
+++ b/lib/Doctrine/Inflector/Rules/Spanish/InflectorFactory.php
@@ -9,12 +9,12 @@
 
 final class InflectorFactory extends GenericLanguageInflectorFactory
 {
-    protected function getSingularRuleset() : Ruleset
+    protected function getSingularRuleset(): Ruleset
     {
         return Rules::getSingularRuleset();
     }
 
-    protected function getPluralRuleset() : Ruleset
+    protected function getPluralRuleset(): Ruleset
     {
         return Rules::getPluralRuleset();
     }
diff --git a/lib/Doctrine/Inflector/Rules/Spanish/Rules.php b/lib/Doctrine/Inflector/Rules/Spanish/Rules.php
index f77a739b..d7399725 100644
--- a/lib/Doctrine/Inflector/Rules/Spanish/Rules.php
+++ b/lib/Doctrine/Inflector/Rules/Spanish/Rules.php
@@ -11,7 +11,7 @@
 
 final class Rules
 {
-    public static function getSingularRuleset() : Ruleset
+    public static function getSingularRuleset(): Ruleset
     {
         return new Ruleset(
             new Transformations(...Inflectible::getSingular()),
@@ -20,7 +20,7 @@ public static function getSingularRuleset() : Ruleset
         );
     }
 
-    public static function getPluralRuleset() : Ruleset
+    public static function getPluralRuleset(): Ruleset
     {
         return new Ruleset(
             new Transformations(...Inflectible::getPlural()),
diff --git a/lib/Doctrine/Inflector/Rules/Spanish/Uninflected.php b/lib/Doctrine/Inflector/Rules/Spanish/Uninflected.php
index b13281e8..c743b393 100644
--- a/lib/Doctrine/Inflector/Rules/Spanish/Uninflected.php
+++ b/lib/Doctrine/Inflector/Rules/Spanish/Uninflected.php
@@ -11,7 +11,7 @@ final class Uninflected
     /**
      * @return Pattern[]
      */
-    public static function getSingular() : iterable
+    public static function getSingular(): iterable
     {
         yield from self::getDefault();
     }
@@ -19,7 +19,7 @@ public static function getSingular() : iterable
     /**
      * @return Pattern[]
      */
-    public static function getPlural() : iterable
+    public static function getPlural(): iterable
     {
         yield from self::getDefault();
     }
@@ -27,7 +27,7 @@ public static function getPlural() : iterable
     /**
      * @return Pattern[]
      */
-    private static function getDefault() : iterable
+    private static function getDefault(): iterable
     {
         yield new Pattern('lunes');
         yield new Pattern('rompecabezas');
diff --git a/lib/Doctrine/Inflector/Rules/Substitution.php b/lib/Doctrine/Inflector/Rules/Substitution.php
index 681ab631..471aff9e 100644
--- a/lib/Doctrine/Inflector/Rules/Substitution.php
+++ b/lib/Doctrine/Inflector/Rules/Substitution.php
@@ -18,12 +18,12 @@ public function __construct(Word $from, Word $to)
         $this->to   = $to;
     }
 
-    public function getFrom() : Word
+    public function getFrom(): Word
     {
         return $this->from;
     }
 
-    public function getTo() : Word
+    public function getTo(): Word
     {
         return $this->to;
     }
diff --git a/lib/Doctrine/Inflector/Rules/Substitutions.php b/lib/Doctrine/Inflector/Rules/Substitutions.php
index 24cc34a8..17ee2961 100644
--- a/lib/Doctrine/Inflector/Rules/Substitutions.php
+++ b/lib/Doctrine/Inflector/Rules/Substitutions.php
@@ -5,6 +5,7 @@
 namespace Doctrine\Inflector\Rules;
 
 use Doctrine\Inflector\WordInflector;
+
 use function strtolower;
 use function strtoupper;
 use function substr;
@@ -21,7 +22,7 @@ public function __construct(Substitution ...$substitutions)
         }
     }
 
-    public function getFlippedSubstitutions() : Substitutions
+    public function getFlippedSubstitutions(): Substitutions
     {
         $substitutions = [];
 
@@ -35,7 +36,7 @@ public function getFlippedSubstitutions() : Substitutions
         return new Substitutions(...$substitutions);
     }
 
-    public function inflect(string $word) : string
+    public function inflect(string $word): string
     {
         $lowerWord = strtolower($word);
 
diff --git a/lib/Doctrine/Inflector/Rules/Transformation.php b/lib/Doctrine/Inflector/Rules/Transformation.php
index 84ef08b8..30dcd594 100644
--- a/lib/Doctrine/Inflector/Rules/Transformation.php
+++ b/lib/Doctrine/Inflector/Rules/Transformation.php
@@ -5,6 +5,7 @@
 namespace Doctrine\Inflector\Rules;
 
 use Doctrine\Inflector\WordInflector;
+
 use function preg_replace;
 
 final class Transformation implements WordInflector
@@ -21,17 +22,17 @@ public function __construct(Pattern $pattern, string $replacement)
         $this->replacement = $replacement;
     }
 
-    public function getPattern() : Pattern
+    public function getPattern(): Pattern
     {
         return $this->pattern;
     }
 
-    public function getReplacement() : string
+    public function getReplacement(): string
     {
         return $this->replacement;
     }
 
-    public function inflect(string $word) : string
+    public function inflect(string $word): string
     {
         return (string) preg_replace($this->pattern->getRegex(), $this->replacement, $word);
     }
diff --git a/lib/Doctrine/Inflector/Rules/Transformations.php b/lib/Doctrine/Inflector/Rules/Transformations.php
index 9f4724e5..b6a48fa8 100644
--- a/lib/Doctrine/Inflector/Rules/Transformations.php
+++ b/lib/Doctrine/Inflector/Rules/Transformations.php
@@ -16,7 +16,7 @@ public function __construct(Transformation ...$transformations)
         $this->transformations = $transformations;
     }
 
-    public function inflect(string $word) : string
+    public function inflect(string $word): string
     {
         foreach ($this->transformations as $transformation) {
             if ($transformation->getPattern()->matches($word)) {
diff --git a/lib/Doctrine/Inflector/Rules/Turkish/Inflectible.php b/lib/Doctrine/Inflector/Rules/Turkish/Inflectible.php
index 74900cb9..d7b7064c 100644
--- a/lib/Doctrine/Inflector/Rules/Turkish/Inflectible.php
+++ b/lib/Doctrine/Inflector/Rules/Turkish/Inflectible.php
@@ -14,7 +14,7 @@ class Inflectible
     /**
      * @return Transformation[]
      */
-    public static function getSingular() : iterable
+    public static function getSingular(): iterable
     {
         yield new Transformation(new Pattern('/l[ae]r$/i'), '');
     }
@@ -22,7 +22,7 @@ public static function getSingular() : iterable
     /**
      * @return Transformation[]
      */
-    public static function getPlural() : iterable
+    public static function getPlural(): iterable
     {
         yield new Transformation(new Pattern('/([eöiü][^aoıueöiü]{0,6})$/u'), '\1ler');
         yield new Transformation(new Pattern('/([aoıu][^aoıueöiü]{0,6})$/u'), '\1lar');
@@ -31,7 +31,7 @@ public static function getPlural() : iterable
     /**
      * @return Substitution[]
      */
-    public static function getIrregular() : iterable
+    public static function getIrregular(): iterable
     {
         yield new Substitution(new Word('ben'), new Word('biz'));
         yield new Substitution(new Word('sen'), new Word('siz'));
diff --git a/lib/Doctrine/Inflector/Rules/Turkish/InflectorFactory.php b/lib/Doctrine/Inflector/Rules/Turkish/InflectorFactory.php
index 83b80467..c6cdebe9 100644
--- a/lib/Doctrine/Inflector/Rules/Turkish/InflectorFactory.php
+++ b/lib/Doctrine/Inflector/Rules/Turkish/InflectorFactory.php
@@ -9,12 +9,12 @@
 
 final class InflectorFactory extends GenericLanguageInflectorFactory
 {
-    protected function getSingularRuleset() : Ruleset
+    protected function getSingularRuleset(): Ruleset
     {
         return Rules::getSingularRuleset();
     }
 
-    protected function getPluralRuleset() : Ruleset
+    protected function getPluralRuleset(): Ruleset
     {
         return Rules::getPluralRuleset();
     }
diff --git a/lib/Doctrine/Inflector/Rules/Turkish/Rules.php b/lib/Doctrine/Inflector/Rules/Turkish/Rules.php
index dd0840c5..ea564ac7 100644
--- a/lib/Doctrine/Inflector/Rules/Turkish/Rules.php
+++ b/lib/Doctrine/Inflector/Rules/Turkish/Rules.php
@@ -11,7 +11,7 @@
 
 final class Rules
 {
-    public static function getSingularRuleset() : Ruleset
+    public static function getSingularRuleset(): Ruleset
     {
         return new Ruleset(
             new Transformations(...Inflectible::getSingular()),
@@ -20,7 +20,7 @@ public static function getSingularRuleset() : Ruleset
         );
     }
 
-    public static function getPluralRuleset() : Ruleset
+    public static function getPluralRuleset(): Ruleset
     {
         return new Ruleset(
             new Transformations(...Inflectible::getPlural()),
diff --git a/lib/Doctrine/Inflector/Rules/Turkish/Uninflected.php b/lib/Doctrine/Inflector/Rules/Turkish/Uninflected.php
index c95ccbf9..a75d2486 100644
--- a/lib/Doctrine/Inflector/Rules/Turkish/Uninflected.php
+++ b/lib/Doctrine/Inflector/Rules/Turkish/Uninflected.php
@@ -11,7 +11,7 @@ final class Uninflected
     /**
      * @return Pattern[]
      */
-    public static function getSingular() : iterable
+    public static function getSingular(): iterable
     {
         yield from self::getDefault();
     }
@@ -19,7 +19,7 @@ public static function getSingular() : iterable
     /**
      * @return Pattern[]
      */
-    public static function getPlural() : iterable
+    public static function getPlural(): iterable
     {
         yield from self::getDefault();
     }
@@ -27,7 +27,7 @@ public static function getPlural() : iterable
     /**
      * @return Pattern[]
      */
-    private static function getDefault() : iterable
+    private static function getDefault(): iterable
     {
         yield new Pattern('lunes');
         yield new Pattern('rompecabezas');
diff --git a/lib/Doctrine/Inflector/Rules/Word.php b/lib/Doctrine/Inflector/Rules/Word.php
index 5156e934..98e93ba2 100644
--- a/lib/Doctrine/Inflector/Rules/Word.php
+++ b/lib/Doctrine/Inflector/Rules/Word.php
@@ -14,7 +14,7 @@ public function __construct(string $word)
         $this->word = $word;
     }
 
-    public function getWord() : string
+    public function getWord(): string
     {
         return $this->word;
     }
diff --git a/lib/Doctrine/Inflector/RulesetInflector.php b/lib/Doctrine/Inflector/RulesetInflector.php
index 0e3a5ebd..12b2ed5b 100644
--- a/lib/Doctrine/Inflector/RulesetInflector.php
+++ b/lib/Doctrine/Inflector/RulesetInflector.php
@@ -5,6 +5,7 @@
 namespace Doctrine\Inflector;
 
 use Doctrine\Inflector\Rules\Ruleset;
+
 use function array_merge;
 
 /**
@@ -26,7 +27,7 @@ public function __construct(Ruleset $ruleset, Ruleset ...$rulesets)
         $this->rulesets = array_merge([$ruleset], $rulesets);
     }
 
-    public function inflect(string $word) : string
+    public function inflect(string $word): string
     {
         if ($word === '') {
             return '';
diff --git a/lib/Doctrine/Inflector/WordInflector.php b/lib/Doctrine/Inflector/WordInflector.php
index f2570558..b88b1d69 100644
--- a/lib/Doctrine/Inflector/WordInflector.php
+++ b/lib/Doctrine/Inflector/WordInflector.php
@@ -6,5 +6,5 @@
 
 interface WordInflector
 {
-    public function inflect(string $word) : string;
+    public function inflect(string $word): string;
 }
diff --git a/tests/Doctrine/Tests/Inflector/CachedWordInflectorTest.php b/tests/Doctrine/Tests/Inflector/CachedWordInflectorTest.php
index cab3b6eb..fedfb922 100644
--- a/tests/Doctrine/Tests/Inflector/CachedWordInflectorTest.php
+++ b/tests/Doctrine/Tests/Inflector/CachedWordInflectorTest.php
@@ -17,7 +17,7 @@ class CachedWordInflectorTest extends TestCase
     /** @var CachedWordInflector */
     private $cachedWordInflector;
 
-    public function testInflect() : void
+    public function testInflect(): void
     {
         $this->wordInflector->expects(self::once())
             ->method('inflect')
@@ -28,7 +28,7 @@ public function testInflect() : void
         self::assertSame('out', $this->cachedWordInflector->inflect('in'));
     }
 
-    protected function setUp() : void
+    protected function setUp(): void
     {
         $this->wordInflector = $this->createMock(WordInflector::class);
 
diff --git a/tests/Doctrine/Tests/Inflector/InflectorFunctionalTest.php b/tests/Doctrine/Tests/Inflector/InflectorFunctionalTest.php
index 84b3f400..569b52e5 100644
--- a/tests/Doctrine/Tests/Inflector/InflectorFunctionalTest.php
+++ b/tests/Doctrine/Tests/Inflector/InflectorFunctionalTest.php
@@ -10,7 +10,7 @@
 
 class InflectorFunctionalTest extends TestCase
 {
-    public function testCapitalize() : void
+    public function testCapitalize(): void
     {
         self::assertSame(
             'Top-O-The-Morning To All_of_you!',
@@ -18,7 +18,7 @@ public function testCapitalize() : void
         );
     }
 
-    public function testCapitalizeWithCustomDelimiters() : void
+    public function testCapitalizeWithCustomDelimiters(): void
     {
         self::assertSame(
             'Top-O-The-Morning To All_Of_You!',
@@ -29,7 +29,7 @@ public function testCapitalizeWithCustomDelimiters() : void
     /**
      * @dataProvider dataStringsTableize
      */
-    public function testTableize(string $expected, string $word) : void
+    public function testTableize(string $expected, string $word): void
     {
         self::assertSame($expected, $this->createInflector()->tableize($word));
     }
@@ -39,7 +39,7 @@ public function testTableize(string $expected, string $word) : void
      *
      * @return string[][]
      */
-    public function dataStringsTableize() : array
+    public function dataStringsTableize(): array
     {
         // In the format array('expected', 'word')
         return [
@@ -52,7 +52,7 @@ public function dataStringsTableize() : array
     /**
      * @dataProvider dataStringsClassify
      */
-    public function testClassify(string $expected, string $word) : void
+    public function testClassify(string $expected, string $word): void
     {
         self::assertSame($expected, $this->createInflector()->classify($word));
     }
@@ -62,7 +62,7 @@ public function testClassify(string $expected, string $word) : void
      *
      * @return string[][]
      */
-    public function dataStringsClassify() : array
+    public function dataStringsClassify(): array
     {
         // In the format array('expected', 'word')
         return [
@@ -78,7 +78,7 @@ public function dataStringsClassify() : array
     /**
      * @dataProvider dataStringsCamelize
      */
-    public function testCamelize(string $expected, string $word) : void
+    public function testCamelize(string $expected, string $word): void
     {
         self::assertSame($expected, $this->createInflector()->camelize($word));
     }
@@ -88,7 +88,7 @@ public function testCamelize(string $expected, string $word) : void
      *
      * @return string[][]
      */
-    public function dataStringsCamelize() : array
+    public function dataStringsCamelize(): array
     {
         // In the format array('expected', 'word')
         return [
@@ -100,7 +100,7 @@ public function dataStringsCamelize() : array
         ];
     }
 
-    private function createInflector() : Inflector
+    private function createInflector(): Inflector
     {
         return InflectorFactory::create()->build();
     }
diff --git a/tests/Doctrine/Tests/Inflector/InflectorTest.php b/tests/Doctrine/Tests/Inflector/InflectorTest.php
index 77f245d6..c917d2cc 100644
--- a/tests/Doctrine/Tests/Inflector/InflectorTest.php
+++ b/tests/Doctrine/Tests/Inflector/InflectorTest.php
@@ -20,28 +20,28 @@ class InflectorTest extends TestCase
     /** @var Inflector */
     private $inflector;
 
-    public function testTableize() : void
+    public function testTableize(): void
     {
         self::assertSame('model_name', $this->inflector->tableize('ModelName'));
         self::assertSame('model_name', $this->inflector->tableize('modelName'));
         self::assertSame('model_name', $this->inflector->tableize('model_name'));
     }
 
-    public function testClassify() : void
+    public function testClassify(): void
     {
         self::assertSame('ModelName', $this->inflector->classify('model_name'));
         self::assertSame('ModelName', $this->inflector->classify('modelName'));
         self::assertSame('ModelName', $this->inflector->classify('ModelName'));
     }
 
-    public function testCamelize() : void
+    public function testCamelize(): void
     {
         self::assertSame('modelName', $this->inflector->camelize('ModelName'));
         self::assertSame('modelName', $this->inflector->camelize('model_name'));
         self::assertSame('modelName', $this->inflector->camelize('modelName'));
     }
 
-    public function testCapitalize() : void
+    public function testCapitalize(): void
     {
         self::assertSame(
             'Top-O-The-Morning To All_of_you!',
@@ -49,14 +49,14 @@ public function testCapitalize() : void
         );
     }
 
-    public function testSeemsUtf8() : void
+    public function testSeemsUtf8(): void
     {
         self::assertTrue($this->inflector->seemsUtf8('teléfono'));
         self::assertTrue($this->inflector->seemsUtf8('král'));
         self::assertTrue($this->inflector->seemsUtf8('telephone'));
     }
 
-    public function testUnaccent() : void
+    public function testUnaccent(): void
     {
         self::assertSame('telefono', $this->inflector->unaccent('teléfono'));
         self::assertSame('telephone', $this->inflector->unaccent('telephone'));
@@ -65,7 +65,7 @@ public function testUnaccent() : void
     /**
      * @dataProvider dataStringsUrlize
      */
-    public function testUrlize(string $expected, string $string) : void
+    public function testUrlize(string $expected, string $string): void
     {
         self::assertSame(
             $expected,
@@ -78,7 +78,7 @@ public function testUrlize(string $expected, string $string) : void
      *
      * @return string[][]
      */
-    public function dataStringsUrlize() : array
+    public function dataStringsUrlize(): array
     {
         return [
             [
@@ -116,7 +116,7 @@ public function dataStringsUrlize() : array
         ];
     }
 
-    public function testPluralize() : void
+    public function testPluralize(): void
     {
         $this->pluralInflector->expects(self::once())
             ->method('inflect')
@@ -126,7 +126,7 @@ public function testPluralize() : void
         self::assertSame('out', $this->inflector->pluralize('in'));
     }
 
-    public function testSingularize() : void
+    public function testSingularize(): void
     {
         $this->singularInflector->expects(self::once())
             ->method('inflect')
@@ -136,7 +136,7 @@ public function testSingularize() : void
         self::assertSame('out', $this->inflector->singularize('in'));
     }
 
-    protected function setUp() : void
+    protected function setUp(): void
     {
         $this->singularInflector = $this->createMock(WordInflector::class);
         $this->pluralInflector   = $this->createMock(WordInflector::class);
diff --git a/tests/Doctrine/Tests/Inflector/NoopWordInflectorTest.php b/tests/Doctrine/Tests/Inflector/NoopWordInflectorTest.php
index 6e414913..378edd34 100644
--- a/tests/Doctrine/Tests/Inflector/NoopWordInflectorTest.php
+++ b/tests/Doctrine/Tests/Inflector/NoopWordInflectorTest.php
@@ -12,13 +12,13 @@ class NoopWordInflectorTest extends TestCase
     /** @var NoopWordInflector */
     private $inflector;
 
-    public function testInflect() : void
+    public function testInflect(): void
     {
         self::assertSame('foo', $this->inflector->inflect('foo'));
         self::assertSame('bar', $this->inflector->inflect('bar'));
     }
 
-    protected function setUp() : void
+    protected function setUp(): void
     {
         $this->inflector = new NoopWordInflector();
     }
diff --git a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
index 1a793341..0ce65637 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
@@ -14,7 +14,7 @@ class DutchFunctionalTest extends LanguageFunctionalTest
     /**
      * @return list<array{string, string}>
      */
-    public function dataSampleWords() : array
+    public function dataSampleWords(): array
     {
         return [
             ['schip', 'schepen'],
diff --git a/tests/Doctrine/Tests/Inflector/Rules/English/EnglishFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/English/EnglishFunctionalTest.php
index f5c6adb7..e84c8559 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/English/EnglishFunctionalTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/English/EnglishFunctionalTest.php
@@ -8,6 +8,7 @@
 use Doctrine\Inflector\InflectorFactory;
 use Doctrine\Inflector\Language;
 use Doctrine\Tests\Inflector\Rules\LanguageFunctionalTest;
+
 use function sprintf;
 
 class EnglishFunctionalTest extends LanguageFunctionalTest
@@ -15,7 +16,7 @@ class EnglishFunctionalTest extends LanguageFunctionalTest
     /**
      * @return string[][]
      */
-    public function dataSampleWords() : array
+    public function dataSampleWords(): array
     {
         return [
             ['', ''],
@@ -445,7 +446,7 @@ public function dataSampleWords() : array
      *
      * @return string[][]
      */
-    public function dataSingularsUninflectedWhenSingularized() : array
+    public function dataSingularsUninflectedWhenSingularized(): array
     {
         // In the format array('singular', 'notEquals')
         return [
@@ -466,7 +467,7 @@ public function dataSingularsUninflectedWhenSingularized() : array
     /**
      * @dataProvider dataSingularsUninflectedWhenSingularized
      */
-    public function testSingularsWhenSingularizedShouldBeUninflected(string $singular, string $notEquals) : void
+    public function testSingularsWhenSingularizedShouldBeUninflected(string $singular, string $notEquals): void
     {
         self::assertNotSame(
             $notEquals,
@@ -482,7 +483,7 @@ public function testSingularsWhenSingularizedShouldBeUninflected(string $singula
      *
      * @return string[][]
      */
-    public function dataPluralUninflectedWhenPluralized() : array
+    public function dataPluralUninflectedWhenPluralized(): array
     {
         return [
             ['media'],
@@ -492,7 +493,7 @@ public function dataPluralUninflectedWhenPluralized() : array
     /**
      * @dataProvider dataPluralUninflectedWhenPluralized
      */
-    public function testPluralsWhenPluralizedShouldBeUninflected(string $plural) : void
+    public function testPluralsWhenPluralizedShouldBeUninflected(string $plural): void
     {
         $pluralized = $this->createInflector()->pluralize($plural);
 
@@ -503,7 +504,7 @@ public function testPluralsWhenPluralizedShouldBeUninflected(string $plural) : v
         );
     }
 
-    protected function createInflector() : Inflector
+    protected function createInflector(): Inflector
     {
         return InflectorFactory::createForLanguage(Language::ENGLISH)->build();
     }
diff --git a/tests/Doctrine/Tests/Inflector/Rules/French/FrenchFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/French/FrenchFunctionalTest.php
index 8d7975c4..4ead07e6 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/French/FrenchFunctionalTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/French/FrenchFunctionalTest.php
@@ -14,7 +14,7 @@ class FrenchFunctionalTest extends LanguageFunctionalTest
     /**
      * @return string[][]
      */
-    public function dataSampleWords() : array
+    public function dataSampleWords(): array
     {
         return [
             ['ami', 'amis'],
@@ -56,7 +56,7 @@ public function dataSampleWords() : array
         ];
     }
 
-    protected function createInflector() : Inflector
+    protected function createInflector(): Inflector
     {
         return InflectorFactory::createForLanguage(Language::FRENCH)->build();
     }
diff --git a/tests/Doctrine/Tests/Inflector/Rules/LanguageFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/LanguageFunctionalTest.php
index fca58f26..ecefcf01 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/LanguageFunctionalTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/LanguageFunctionalTest.php
@@ -6,6 +6,7 @@
 
 use Doctrine\Inflector\Inflector;
 use PHPUnit\Framework\TestCase;
+
 use function sprintf;
 
 abstract class LanguageFunctionalTest extends TestCase
@@ -13,12 +14,12 @@ abstract class LanguageFunctionalTest extends TestCase
     /**
      * @return string[][]
      */
-    abstract public function dataSampleWords() : array;
+    abstract public function dataSampleWords(): array;
 
     /**
      * @dataProvider dataSampleWords
      */
-    public function testInflectingSingulars(string $singular, string $plural) : void
+    public function testInflectingSingulars(string $singular, string $plural): void
     {
         self::assertSame(
             $singular,
@@ -30,7 +31,7 @@ public function testInflectingSingulars(string $singular, string $plural) : void
     /**
      * @dataProvider dataSampleWords
      */
-    public function testInflectingPlurals(string $singular, string $plural) : void
+    public function testInflectingPlurals(string $singular, string $plural): void
     {
         self::assertSame(
             $plural,
@@ -39,5 +40,5 @@ public function testInflectingPlurals(string $singular, string $plural) : void
         );
     }
 
-    abstract protected function createInflector() : Inflector;
+    abstract protected function createInflector(): Inflector;
 }
diff --git a/tests/Doctrine/Tests/Inflector/Rules/NorwegianBokmal/NorwegianBokmalFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/NorwegianBokmal/NorwegianBokmalFunctionalTest.php
index 077e6e0e..de9059e2 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/NorwegianBokmal/NorwegianBokmalFunctionalTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/NorwegianBokmal/NorwegianBokmalFunctionalTest.php
@@ -14,7 +14,7 @@ class NorwegianBokmalFunctionalTest extends LanguageFunctionalTest
     /**
      * @return string[][]
      */
-    public function dataSampleWords() : array
+    public function dataSampleWords(): array
     {
         return [
             ['dag', 'dager'],
@@ -31,7 +31,7 @@ public function dataSampleWords() : array
         ];
     }
 
-    protected function createInflector() : Inflector
+    protected function createInflector(): Inflector
     {
         return InflectorFactory::createForLanguage(Language::NORWEGIAN_BOKMAL)->build();
     }
diff --git a/tests/Doctrine/Tests/Inflector/Rules/PatternTest.php b/tests/Doctrine/Tests/Inflector/Rules/PatternTest.php
index 673e6355..7d59d158 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/PatternTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/PatternTest.php
@@ -12,29 +12,29 @@ class PatternTest extends TestCase
     /** @var Pattern */
     private $pattern;
 
-    public function testGetPattern() : void
+    public function testGetPattern(): void
     {
         self::assertSame('test', $this->pattern->getPattern());
     }
 
-    public function testGetRegex() : void
+    public function testGetRegex(): void
     {
         self::assertSame('/test/i', $this->pattern->getRegex());
     }
 
-    public function testPatternWithExplicitRegex() : void
+    public function testPatternWithExplicitRegex(): void
     {
         $pattern = new Pattern('/test/');
 
         self::assertSame('/test/', $pattern->getRegex());
     }
 
-    public function testMatches() : void
+    public function testMatches(): void
     {
         self::assertTrue($this->pattern->matches('test'));
     }
 
-    protected function setUp() : void
+    protected function setUp(): void
     {
         $this->pattern = new Pattern('test');
     }
diff --git a/tests/Doctrine/Tests/Inflector/Rules/PatternsTest.php b/tests/Doctrine/Tests/Inflector/Rules/PatternsTest.php
index 8b901065..704f4bc0 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/PatternsTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/PatternsTest.php
@@ -13,13 +13,13 @@ class PatternsTest extends TestCase
     /** @var Patterns */
     private $patterns;
 
-    public function testMatches() : void
+    public function testMatches(): void
     {
         self::assertTrue($this->patterns->matches('test1'));
         self::assertFalse($this->patterns->matches('test2'));
     }
 
-    protected function setUp() : void
+    protected function setUp(): void
     {
         $this->patterns = new Patterns(new Pattern('test1'));
     }
diff --git a/tests/Doctrine/Tests/Inflector/Rules/Portuguese/PortugueseFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/Portuguese/PortugueseFunctionalTest.php
index 9d5ad860..72bf9198 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/Portuguese/PortugueseFunctionalTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/Portuguese/PortugueseFunctionalTest.php
@@ -14,7 +14,7 @@ class PortugueseFunctionalTest extends LanguageFunctionalTest
     /**
      * @return string[][]
      */
-    public function dataSampleWords() : array
+    public function dataSampleWords(): array
     {
         return [
             ['livro', 'livros'],
@@ -47,7 +47,7 @@ public function dataSampleWords() : array
         ];
     }
 
-    protected function createInflector() : Inflector
+    protected function createInflector(): Inflector
     {
         return InflectorFactory::createForLanguage(Language::PORTUGUESE)->build();
     }
diff --git a/tests/Doctrine/Tests/Inflector/Rules/RulesetTest.php b/tests/Doctrine/Tests/Inflector/Rules/RulesetTest.php
index bf03f41e..f44c5822 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/RulesetTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/RulesetTest.php
@@ -25,22 +25,22 @@ class RulesetTest extends TestCase
     /** @var Ruleset */
     private $ruleset;
 
-    public function testGetRegular() : void
+    public function testGetRegular(): void
     {
         self::assertSame($this->regular, $this->ruleset->getRegular());
     }
 
-    public function testGetUninflected() : void
+    public function testGetUninflected(): void
     {
         self::assertSame($this->uninflected, $this->ruleset->getUninflected());
     }
 
-    public function testGetIrregular() : void
+    public function testGetIrregular(): void
     {
         self::assertSame($this->irregular, $this->ruleset->getIrregular());
     }
 
-    protected function setUp() : void
+    protected function setUp(): void
     {
         $this->regular     = $this->createMock(Transformations::class);
         $this->uninflected = $this->createMock(Patterns::class);
diff --git a/tests/Doctrine/Tests/Inflector/Rules/Spanish/SpanishFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/Spanish/SpanishFunctionalTest.php
index 16a4186a..c881e91e 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/Spanish/SpanishFunctionalTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/Spanish/SpanishFunctionalTest.php
@@ -14,7 +14,7 @@ class SpanishFunctionalTest extends LanguageFunctionalTest
     /**
      * @return string[][]
      */
-    public function dataSampleWords() : array
+    public function dataSampleWords(): array
     {
         return [
             ['libro', 'libros'],
@@ -56,7 +56,7 @@ public function dataSampleWords() : array
         ];
     }
 
-    protected function createInflector() : Inflector
+    protected function createInflector(): Inflector
     {
         return InflectorFactory::createForLanguage(Language::SPANISH)->build();
     }
diff --git a/tests/Doctrine/Tests/Inflector/Rules/SubstitutionTest.php b/tests/Doctrine/Tests/Inflector/Rules/SubstitutionTest.php
index 25b0a2f5..0f366ca1 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/SubstitutionTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/SubstitutionTest.php
@@ -13,17 +13,17 @@ class SubstitutionTest extends TestCase
     /** @var Substitution */
     private $substitution;
 
-    public function testGetFrom() : void
+    public function testGetFrom(): void
     {
         self::assertSame('from', $this->substitution->getFrom()->getWord());
     }
 
-    public function testGetTo() : void
+    public function testGetTo(): void
     {
         self::assertSame('to', $this->substitution->getTo()->getWord());
     }
 
-    protected function setUp() : void
+    protected function setUp(): void
     {
         $this->substitution = new Substitution(new Word('from'), new Word('to'));
     }
diff --git a/tests/Doctrine/Tests/Inflector/Rules/SubstitutionsTest.php b/tests/Doctrine/Tests/Inflector/Rules/SubstitutionsTest.php
index 44139dee..2c779bb2 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/SubstitutionsTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/SubstitutionsTest.php
@@ -17,19 +17,19 @@ class SubstitutionsTest extends TestCase
     /** @var Substitutions */
     private $irregular;
 
-    public function testGetFlippedSubstitutions() : void
+    public function testGetFlippedSubstitutions(): void
     {
         $substitutions = $this->irregular->getFlippedSubstitutions();
 
         self::assertSame('spins', $substitutions->inflect('spinor'));
     }
 
-    public function testInflect() : void
+    public function testInflect(): void
     {
         self::assertSame('spinor', $this->irregular->inflect('spins'));
     }
 
-    protected function setUp() : void
+    protected function setUp(): void
     {
         $this->substitutions = [
             new Substitution(new Word('spins'), new Word('spinor')),
diff --git a/tests/Doctrine/Tests/Inflector/Rules/TransformationTest.php b/tests/Doctrine/Tests/Inflector/Rules/TransformationTest.php
index 2234c337..48002801 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/TransformationTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/TransformationTest.php
@@ -13,22 +13,22 @@ class TransformationTest extends TestCase
     /** @var Transformation */
     private $transformation;
 
-    public function testGetPattern() : void
+    public function testGetPattern(): void
     {
         self::assertSame('s$', $this->transformation->getPattern()->getPattern());
     }
 
-    public function testGetReplacement() : void
+    public function testGetReplacement(): void
     {
         self::assertSame('', $this->transformation->getReplacement());
     }
 
-    public function testInflect() : void
+    public function testInflect(): void
     {
         self::assertSame('test', $this->transformation->inflect('tests'));
     }
 
-    protected function setUp() : void
+    protected function setUp(): void
     {
         $this->transformation = new Transformation(new Pattern('s$'), '');
     }
diff --git a/tests/Doctrine/Tests/Inflector/Rules/TransformationsTest.php b/tests/Doctrine/Tests/Inflector/Rules/TransformationsTest.php
index 57c25e30..9f842490 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/TransformationsTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/TransformationsTest.php
@@ -14,12 +14,12 @@ class TransformationsTest extends TestCase
     /** @var Transformations */
     private $transformations;
 
-    public function testInflect() : void
+    public function testInflect(): void
     {
         self::assertSame('customizables', $this->transformations->inflect('custom'));
     }
 
-    protected function setUp() : void
+    protected function setUp(): void
     {
         $this->transformations = new Transformations(new Transformation(new Pattern('/^(custom)$/i'), '\1izables'));
     }
diff --git a/tests/Doctrine/Tests/Inflector/Rules/Turkish/TurkishFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/Turkish/TurkishFunctionalTest.php
index c9577f85..ac29e2c8 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/Turkish/TurkishFunctionalTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/Turkish/TurkishFunctionalTest.php
@@ -14,7 +14,7 @@ class TurkishFunctionalTest extends LanguageFunctionalTest
     /**
      * @return string[][]
      */
-    public function dataSampleWords() : array
+    public function dataSampleWords(): array
     {
         return [
             ['gün', 'günler'],
@@ -29,7 +29,7 @@ public function dataSampleWords() : array
         ];
     }
 
-    protected function createInflector() : Inflector
+    protected function createInflector(): Inflector
     {
         return InflectorFactory::createForLanguage(Language::TURKISH)->build();
     }
diff --git a/tests/Doctrine/Tests/Inflector/Rules/WordTest.php b/tests/Doctrine/Tests/Inflector/Rules/WordTest.php
index d3351524..994031de 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/WordTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/WordTest.php
@@ -12,12 +12,12 @@ class WordTest extends TestCase
     /** @var Word */
     private $word;
 
-    public function testGetWord() : void
+    public function testGetWord(): void
     {
         self::assertSame('test', $this->word->getWord());
     }
 
-    protected function setUp() : void
+    protected function setUp(): void
     {
         $this->word = new Word('test');
     }
diff --git a/tests/Doctrine/Tests/Inflector/RulesetInflectorTest.php b/tests/Doctrine/Tests/Inflector/RulesetInflectorTest.php
index dd495b49..a3e0fcd5 100644
--- a/tests/Doctrine/Tests/Inflector/RulesetInflectorTest.php
+++ b/tests/Doctrine/Tests/Inflector/RulesetInflectorTest.php
@@ -26,7 +26,7 @@ class RulesetInflectorTest extends TestCase
     /** @var RulesetInflector */
     private $rulesetInflector;
 
-    public function testInflectIrregularUsesFirstMatch() : void
+    public function testInflectIrregularUsesFirstMatch(): void
     {
         $firstIrregular  = $this->createMock(Substitutions::class);
         $secondIrregular = $this->createMock(Substitutions::class);
@@ -50,7 +50,7 @@ public function testInflectIrregularUsesFirstMatch() : void
         self::assertSame('first', $this->rulesetInflector->inflect('in'));
     }
 
-    public function testInflectIrregularContinuesIfFirstRulesetReturnsOriginalValue() : void
+    public function testInflectIrregularContinuesIfFirstRulesetReturnsOriginalValue(): void
     {
         $firstRuleset = new Ruleset(
             new Transformations(),
@@ -69,7 +69,7 @@ public function testInflectIrregularContinuesIfFirstRulesetReturnsOriginalValue(
         self::assertSame('second', $inflector->inflect('in'));
     }
 
-    public function testInflectUninflectedSkipsOnFirstMatch() : void
+    public function testInflectUninflectedSkipsOnFirstMatch(): void
     {
         $firstUninflected  = $this->createMock(Patterns::class);
         $secondUninflected = $this->createMock(Patterns::class);
@@ -93,7 +93,7 @@ public function testInflectUninflectedSkipsOnFirstMatch() : void
         self::assertSame('in', $this->rulesetInflector->inflect('in'));
     }
 
-    public function testIrregularIsInflectedEvenIfLaterRulesetIgnores() : void
+    public function testIrregularIsInflectedEvenIfLaterRulesetIgnores(): void
     {
         $firstIrregular    = new Substitutions(new Substitution(new Word('travel'), new Word('travels')));
         $secondUninflected = new Patterns(new Pattern('travel'));
@@ -109,7 +109,7 @@ public function testIrregularIsInflectedEvenIfLaterRulesetIgnores() : void
         self::assertSame('travels', $this->rulesetInflector->inflect('travel'));
     }
 
-    public function testInflectRegularUsesFirstMatch() : void
+    public function testInflectRegularUsesFirstMatch(): void
     {
         $irregular = $this->createMock(Substitutions::class);
 
@@ -163,7 +163,7 @@ public function testInflectRegularUsesFirstMatch() : void
         self::assertSame('first', $this->rulesetInflector->inflect('in'));
     }
 
-    public function testInflectRegularContinuesIfFirstRulesetReturnsOriginalValue() : void
+    public function testInflectRegularContinuesIfFirstRulesetReturnsOriginalValue(): void
     {
         $irregular = $this->createMock(Substitutions::class);
 
@@ -219,7 +219,7 @@ public function testInflectRegularContinuesIfFirstRulesetReturnsOriginalValue()
         self::assertSame('second', $this->rulesetInflector->inflect('in'));
     }
 
-    public function testInflectReturnsOriginalValueOnNoMatches() : void
+    public function testInflectReturnsOriginalValueOnNoMatches(): void
     {
         $irregular = $this->createMock(Substitutions::class);
 
@@ -269,7 +269,7 @@ public function testInflectReturnsOriginalValueOnNoMatches() : void
         self::assertSame('in', $this->rulesetInflector->inflect('in'));
     }
 
-    protected function setUp() : void
+    protected function setUp(): void
     {
         $this->firstRuleset  = $this->createMock(Ruleset::class);
         $this->secondRuleset = $this->createMock(Ruleset::class);

From ab6bae40648b112435a13bebe105a7b258c91d41 Mon Sep 17 00:00:00 2001
From: Noud de Brouwer <noud4@home.nl>
Date: Tue, 1 Dec 2020 20:43:30 +0100
Subject: [PATCH 06/17] correction to php 7.4 try 1

---
 .github/workflows/coding-standards.yml | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/coding-standards.yml b/.github/workflows/coding-standards.yml
index 06d0aa89..38a80295 100644
--- a/.github/workflows/coding-standards.yml
+++ b/.github/workflows/coding-standards.yml
@@ -1,15 +1,16 @@
 
 name: "Coding Standards"
 
-on:
-  pull_request:
-    branches:
-      - "*.x"
-      - "master"
-  push:
-    branches:
-      - "*.x"
-      - "master"
+on: ["pull_request", "push"]
+# on:
+#   pull_request:
+#     branches:
+#       - "*.x"
+#       - "master"
+#   push:
+#     branches:
+#       - "*.x"
+#       - "master"
 
 jobs:
   coding-standards:

From 45aad5b29231f489578f4f401df7738cb005b38c Mon Sep 17 00:00:00 2001
From: Noud de Brouwer <noud4@home.nl>
Date: Tue, 1 Dec 2020 20:59:03 +0100
Subject: [PATCH 07/17] no php 7.4 correction but resulting plural not plurals

---
 .github/workflows/coding-standards.yml        | 19 +++++++++----------
 .../Rules/Dutch/DutchFunctionalTest.php       | 12 +++++++-----
 2 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/.github/workflows/coding-standards.yml b/.github/workflows/coding-standards.yml
index 38a80295..06d0aa89 100644
--- a/.github/workflows/coding-standards.yml
+++ b/.github/workflows/coding-standards.yml
@@ -1,16 +1,15 @@
 
 name: "Coding Standards"
 
-on: ["pull_request", "push"]
-# on:
-#   pull_request:
-#     branches:
-#       - "*.x"
-#       - "master"
-#   push:
-#     branches:
-#       - "*.x"
-#       - "master"
+on:
+  pull_request:
+    branches:
+      - "*.x"
+      - "master"
+  push:
+    branches:
+      - "*.x"
+      - "master"
 
 jobs:
   coding-standards:
diff --git a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
index 0ce65637..3644f67f 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
@@ -36,13 +36,8 @@ public function dataSampleWords(): array
             ['vlo', 'vlooien'],
             ['leerrede', 'leerredenen'],
             ['lende', 'lendenen'],
-            ['epos', 'epen'],           // @todo: make the multiplitudes arrays w/o sort order as well, epossen
-            ['epos', 'epossen'],
             ['genius', 'geniën'],
             ['aanbod', 'aanbiedingen'],
-            ['beleg', 'belegeringen'],  // @todo: meening: past to circumvent a camp to concor
-            ['beleg', 'beleggen'],      // @todo: meening: present
-            ['beleg', 'belegjes'],      // @todo: meening: the slices food on a sandwich
             ['dank', 'dankbetuigingen'],
             ['gedrag', 'gedragingen'],
             ['genot', 'genietingen'],
@@ -50,6 +45,13 @@ public function dataSampleWords(): array
             ['qaestrices', 'quaestrix'],
             ['matrices', 'matrix'],
             ['twitter', 'twitter'],
+            // @todo: multiplitudes array w/o sort order for multiple plural same possibilities
+            ['epos', 'epen'],           
+            // ['epos', 'epossen'],
+            // @todo: multiplitudes array w/o sort order for multiple plural different meenings
+            ['beleg', 'belegeringen'],     // @todo: meening: invest a city and then conquer it
+            // ['beleg', 'beleggen'],      // @todo: meening: call a meeting
+            // ['beleg', 'belegjes'],      // @todo: meening: the slices food on a sandwich
         ];
     }
 

From 8e76ff803b359d6198616cef92ed30ccdafd07f7 Mon Sep 17 00:00:00 2001
From: Noud de Brouwer <noud4@home.nl>
Date: Tue, 1 Dec 2020 21:21:28 +0100
Subject: [PATCH 08/17] code guidelines

---
 .../Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
index 3644f67f..52f90625 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
@@ -46,7 +46,7 @@ public function dataSampleWords(): array
             ['matrices', 'matrix'],
             ['twitter', 'twitter'],
             // @todo: multiplitudes array w/o sort order for multiple plural same possibilities
-            ['epos', 'epen'],           
+            ['epos', 'epen'],
             // ['epos', 'epossen'],
             // @todo: multiplitudes array w/o sort order for multiple plural different meenings
             ['beleg', 'belegeringen'],     // @todo: meening: invest a city and then conquer it

From 04d6ecfda9157c14690f545aa01a9d016b19c871 Mon Sep 17 00:00:00 2001
From: Noud de Brouwer <noud4@home.nl>
Date: Tue, 1 Dec 2020 22:25:55 +0100
Subject: [PATCH 09/17] meaning spelling

---
 .../Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php   | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
index 52f90625..a1aee46d 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
@@ -48,10 +48,10 @@ public function dataSampleWords(): array
             // @todo: multiplitudes array w/o sort order for multiple plural same possibilities
             ['epos', 'epen'],
             // ['epos', 'epossen'],
-            // @todo: multiplitudes array w/o sort order for multiple plural different meenings
-            ['beleg', 'belegeringen'],     // @todo: meening: invest a city and then conquer it
-            // ['beleg', 'beleggen'],      // @todo: meening: call a meeting
-            // ['beleg', 'belegjes'],      // @todo: meening: the slices food on a sandwich
+            // @todo: multiplitudes array w/o sort order for multiple plural different meanings
+            ['beleg', 'belegeringen'],     // @todo: meaning: invest a city and then conquer it
+            // ['beleg', 'beleggen'],      // @todo: meaning: call a meeting
+            // ['beleg', 'belegjes'],      // @todo: meaning: the slices food on a sandwich
         ];
     }
 

From 3d61fb691b81e14ec3147278f0a3745ebe9815b4 Mon Sep 17 00:00:00 2001
From: Noud de Brouwer <noud4@home.nl>
Date: Tue, 1 Dec 2020 23:10:04 +0100
Subject: [PATCH 10/17] swapped singular plural correction & possoble rule

---
 lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php        | 8 ++++++--
 .../Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php   | 5 +++--
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php b/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
index 34fdfd8f..004daa3d 100644
--- a/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
+++ b/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
@@ -113,6 +113,10 @@ public static function getIrregular(): iterable
 
         yield new Substitution(new Word('industrie'), new Word('industrieën'));
 
+        yield new Substitution(new Word('idee'), new Word('ideeën'));
+
+        // @todo: above 3 examples maybe could be compacted into a rule
+
         // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Klinkerverandering
         yield new Substitution(new Word('lid'), new Word('leden'));
 
@@ -157,8 +161,8 @@ public static function getIrregular(): iterable
         yield new Substitution(new Word('lof'), new Word('lofbetuigingen'));
 
         // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Latijnse_meervoudsvormen
-        yield new Substitution(new Word('qaestrices'), new Word('quaestrix'));
+        yield new Substitution(new Word('quaestrix'), new Word('qaestrices'));
 
-        yield new Substitution(new Word('matrices'), new Word('matrix'));
+        yield new Substitution(new Word('matrix'), new Word('matrices'));
     }
 }
diff --git a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
index a1aee46d..ea04a3ba 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
@@ -18,6 +18,7 @@ public function dataSampleWords(): array
     {
         return [
             ['schip', 'schepen'],
+            ['idee', 'ideeën'],
             ['stad', 'steden'],
             ['gelid', 'gelederen'],
             // @todo more
@@ -42,8 +43,8 @@ public function dataSampleWords(): array
             ['gedrag', 'gedragingen'],
             ['genot', 'genietingen'],
             ['lof', 'lofbetuigingen'],
-            ['qaestrices', 'quaestrix'],
-            ['matrices', 'matrix'],
+            ['quaestrix', 'quaestrices'],
+            ['matrix', 'matrices'],
             ['twitter', 'twitter'],
             // @todo: multiplitudes array w/o sort order for multiple plural same possibilities
             ['epos', 'epen'],

From 65478344be5337fad422c95117a3ab9e85057eff Mon Sep 17 00:00:00 2001
From: Noud de Brouwer <noud4@home.nl>
Date: Tue, 1 Dec 2020 23:30:42 +0100
Subject: [PATCH 11/17] removed duplicat row

---
 lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php | 2 --
 1 file changed, 2 deletions(-)

diff --git a/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php b/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
index 004daa3d..7060c2e6 100644
--- a/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
+++ b/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
@@ -126,8 +126,6 @@ public static function getIrregular(): iterable
 
         yield new Substitution(new Word('stad'), new Word('steden'));
 
-        yield new Substitution(new Word('gelid'), new Word('gelederen'));
-
         // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Stapelmeervoud
         yield new Substitution(new Word('gelid'), new Word('gelederen'));
 

From 4a1054b2121d8b0fac10db44db2cb8d97c51cae3 Mon Sep 17 00:00:00 2001
From: Noud de Brouwer <noud4@home.nl>
Date: Tue, 1 Dec 2020 23:36:49 +0100
Subject: [PATCH 12/17] extra asked test words

---
 .../Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php        | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
index ea04a3ba..7f61a95f 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
@@ -45,6 +45,9 @@ public function dataSampleWords(): array
             ['lof', 'lofbetuigingen'],
             ['quaestrix', 'quaestrices'],
             ['matrix', 'matrices'],
+            ['meer', 'meren'],
+            ['baas', 'bazen'],
+            ['oog', 'ogen'],
             ['twitter', 'twitter'],
             // @todo: multiplitudes array w/o sort order for multiple plural same possibilities
             ['epos', 'epen'],

From 6d2b403dbfa25cf9091284129007947b16950130 Mon Sep 17 00:00:00 2001
From: Noud de Brouwer <noud4@home.nl>
Date: Tue, 1 Dec 2020 23:38:23 +0100
Subject: [PATCH 13/17] extra asked test words 2

---
 .../Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
index 7f61a95f..d5159f94 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
@@ -48,6 +48,7 @@ public function dataSampleWords(): array
             ['meer', 'meren'],
             ['baas', 'bazen'],
             ['oog', 'ogen'],
+            ['as', 'assen'],
             ['twitter', 'twitter'],
             // @todo: multiplitudes array w/o sort order for multiple plural same possibilities
             ['epos', 'epen'],

From 9a6bc70946123a74a9d26064bb7dda4061d3b39f Mon Sep 17 00:00:00 2001
From: Noud de Brouwer <noud4@home.nl>
Date: Tue, 1 Dec 2020 23:42:15 +0100
Subject: [PATCH 14/17] possible extra rule

---
 lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php b/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
index 7060c2e6..4b235293 100644
--- a/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
+++ b/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
@@ -122,6 +122,9 @@ public static function getIrregular(): iterable
 
         yield new Substitution(new Word('smid'), new Word('smeden'));
 
+        // @todo: above 2 examples might be compacted into a rule
+        // @todo: also f.i. ooglid oogleden
+
         yield new Substitution(new Word('schip'), new Word('schepen'));
 
         yield new Substitution(new Word('stad'), new Word('steden'));

From 7f6a1b435cdcd14cf1e24dabfb2951c69e04be2c Mon Sep 17 00:00:00 2001
From: Noud de Brouwer <noud4@home.nl>
Date: Tue, 1 Dec 2020 23:45:05 +0100
Subject: [PATCH 15/17] extra asked test words 3

---
 .../Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php         | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
index d5159f94..386223d2 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
@@ -45,10 +45,12 @@ public function dataSampleWords(): array
             ['lof', 'lofbetuigingen'],
             ['quaestrix', 'quaestrices'],
             ['matrix', 'matrices'],
+            // @todo: newly check next 5 words
             ['meer', 'meren'],
             ['baas', 'bazen'],
             ['oog', 'ogen'],
             ['as', 'assen'],
+            ['kies', 'kiezen'],
             ['twitter', 'twitter'],
             // @todo: multiplitudes array w/o sort order for multiple plural same possibilities
             ['epos', 'epen'],

From b8a2e59c19763a7abd713ed2ac92057b38b3b8dc Mon Sep 17 00:00:00 2001
From: Noud de Brouwer <noud4@home.nl>
Date: Wed, 2 Dec 2020 08:35:10 +0100
Subject: [PATCH 16/17] comment text added for github web checks

---
 .../Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
index 386223d2..d5589d7c 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
@@ -21,7 +21,7 @@ public function dataSampleWords(): array
             ['idee', 'ideeën'],
             ['stad', 'steden'],
             ['gelid', 'gelederen'],
-            // @todo more
+            // @todo more words
             ['weerman', 'weermannen'],
             ['ei', 'eieren'],
             ['rij', 'rijen'],

From d610fd842f770a25a84f0655b47e0879c9294ef4 Mon Sep 17 00:00:00 2001
From: Noud de Brouwer <noud4@home.nl>
Date: Wed, 2 Dec 2020 08:44:51 +0100
Subject: [PATCH 17/17] word typo and new words outcommented rule need

---
 lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php  |  2 +-
 .../Inflector/Rules/Dutch/DutchFunctionalTest.php   | 13 +++++++------
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php b/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
index 4b235293..04f96003 100644
--- a/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
+++ b/lib/Doctrine/Inflector/Rules/Dutch/Inflectible.php
@@ -162,7 +162,7 @@ public static function getIrregular(): iterable
         yield new Substitution(new Word('lof'), new Word('lofbetuigingen'));
 
         // http://nl.wikipedia.org/wiki/Meervoud_(Nederlands)#Latijnse_meervoudsvormen
-        yield new Substitution(new Word('quaestrix'), new Word('qaestrices'));
+        yield new Substitution(new Word('quaestrix'), new Word('quaestrices'));
 
         yield new Substitution(new Word('matrix'), new Word('matrices'));
     }
diff --git a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
index d5589d7c..923f9307 100644
--- a/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
+++ b/tests/Doctrine/Tests/Inflector/Rules/Dutch/DutchFunctionalTest.php
@@ -45,12 +45,13 @@ public function dataSampleWords(): array
             ['lof', 'lofbetuigingen'],
             ['quaestrix', 'quaestrices'],
             ['matrix', 'matrices'],
-            // @todo: newly check next 5 words
-            ['meer', 'meren'],
-            ['baas', 'bazen'],
-            ['oog', 'ogen'],
-            ['as', 'assen'],
-            ['kies', 'kiezen'],
+            // @todo: newly added, create exceptions or rules
+            // @todo: check next 5 words
+            // ['meer', 'meren'],
+            // ['baas', 'bazen'],
+            // ['oog', 'ogen'],
+            // ['as', 'assen'],
+            // ['kies', 'kiezen'],
             ['twitter', 'twitter'],
             // @todo: multiplitudes array w/o sort order for multiple plural same possibilities
             ['epos', 'epen'],