romanian-issues-259: implement and use pluralize

num2words/lang_EU.py

@@ -41,7 +41,7 @@ class Num2Word_EU(Num2Word_Base):
         'NOK': (('krone', 'kroner'), ('øre', 'øre')),
         'PLN': (('zloty', 'zlotys', 'zlotu'), ('grosz', 'groszy')),
         'MXN': (('peso', 'pesos'), GENERIC_CENTS),
-        'RON': (('leu', 'lei'), ('ban', 'bani')),
+        'RON': (('leu', 'lei', 'de lei'), ('ban', 'bani', 'de bani')),
         'INR': (('rupee', 'rupees'), ('paisa', 'paise'))
     }
 

num2words/lang_RO.py

@@ -23,8 +23,9 @@ from . import lang_EU
 class Num2Word_RO(lang_EU.Num2Word_EU):
     GIGA_SUFFIX = "iliard/e"
     MEGA_SUFFIX = "ilion"
-    # inflection for million follows different rule
+    # inflection for mi/billion follows different rule
     MEGA_SUFFIX_I = "ilioane"
+    GIGA_SUFFIX_I = "iliarde"
 
     def setup(self):
         super(Num2Word_RO, self).setup()
@@ -106,29 +107,50 @@ class Num2Word_RO(lang_EU.Num2Word_EU):
             return "1-ul"
         return "al %s-lea" % (value)
 
+    def pluralize(self, n, forms):
+        if n == 1:
+            form = 0
+        elif n == 0 or (n % 100 > 0 and n % 100 < 20):
+            form = 1
+        else:
+            form = 2
+        return forms[form]
+
     def inflect(self, value, text, side_effect=-1):
         text = text.split("/")
-        if value in (1, 100, 1000, 100000, 1000000000):
+        result = text[0]
-            return text[0]
+        if len(text) > 1:
-        if len(text) > 1 and text[0][-1] in "aăeiou":
+            forms = [
-            text[0] = text[0][:-1]
+                text[0],
-        result = "".join(text)
+                text[0][:-1] + text[1],
-        # mega inflections are with 'oa' inside, use suffixes
+                "de " + text[0][:-1] + text[1]
+            ]
+            result = self.pluralize(side_effect, forms)
+        # mega inflections are different
         if side_effect > 1 and result.endswith(self.MEGA_SUFFIX):
             result = result.replace(self.MEGA_SUFFIX, self.MEGA_SUFFIX_I)
+        elif side_effect > 1 and result.endswith("iliare"):
+            result = result.replace("iliare", self.GIGA_SUFFIX_I)
         return result
 
-    def to_currency(self, val, longval=True, old=False):
+    def to_currency(self, val, currency="RON", cents=False, separator=" și", adjective=False):
-        cents = int(round(val*100))
         # romanian currency has a particularity for numeral: one
         self.gen_numwords[1] = "una"
-        result = self.to_splitnum(cents, hightxt="leu/i", lowtxt="ban/i",
+        result = super(Num2Word_RO, self).to_currency(
-                                  divisor=100, jointxt="și", longval=longval)
+            int(round(val*100)),
+            currency,
+            True,
+            separator,
+            adjective
+        )
         self.gen_numwords[1] = "o"  # revert numeral
         return result.replace(
             "unu leu", "un leu"
         ).replace(
             "unu ban", "un ban"
+        ).replace(
+            # if the romanian low text is 0, it is not usually printed
+            separator + " zero bani", ""
         )
 
     def to_year(self, val, suffix=None, longval=True):

tests/test_ro.py

@@ -103,7 +103,7 @@ class Num2WordsROTest(TestCase):
         )
         self.assertEqual(
             num2words(247000000000, lang="ro"),
-            u"două sute patruzeci și șapte miliarde"
+            u"două sute patruzeci și șapte de miliarde"
         )
 
     def test_overflow(self):
@@ -116,9 +116,17 @@ class Num2WordsROTest(TestCase):
                       "0000000000000000000000000000000000000")
 
     def test_to_currency(self):
+        self.assertEqual(
+            num2words(1000, lang='ro', to='currency'),
+            u'una mie de lei'
+        )
+        self.assertEqual(
+            num2words(101, lang='ro', to='currency'),
+            u'una sută unu lei'
+        )
         self.assertEqual(
             num2words(38.4, lang='ro', to='currency'),
-            u'treizeci și opt lei și patruzeci bani'
+            u'treizeci și opt de lei și patruzeci de bani'
         )
         self.assertEqual(
             num2words(1.01, lang='ro', to='currency'),
@@ -126,24 +134,24 @@ class Num2WordsROTest(TestCase):
         )
         self.assertEqual(
             num2words(4778.00, lang='ro', to='currency'),
-            u'patru mii șapte sute șaptezeci și opt lei')
+            u'patru mii șapte sute șaptezeci și opt de lei')
         self.assertEqual(
             num2words(4778.32, lang='ro', to='currency'),
-            u'patru mii șapte sute șaptezeci și opt lei'
+            u'patru mii șapte sute șaptezeci și opt de lei'
-            u' și treizeci și doi bani')
+            u' și treizeci și doi de bani')
         self.assertEqual(
-            num2words(1200, lang='ro', to='currency'),
+            num2words(1207, lang='ro', to='currency'),
-            u'una mie două sute lei')
+            u'una mie două sute șapte lei')
         self.assertEqual(
             num2words(22000, lang='ro', to='currency'),
-            u'douăzeci și două mii lei')
+            u'douăzeci și două de mii de lei')
         self.assertEqual(
-            num2words(80000, lang='ro', to='currency'),
+            num2words(13000, lang='ro', to='currency'),
-            u'optzeci mii lei')
+            u'treisprezece mii de lei')
         self.assertEqual(
             num2words(123456789, lang='ro', to='currency'),
             u'una sută douăzeci și trei milioane patru sute '
-            u'cincizeci și șase mii șapte sute optzeci și nouă lei')
+            u'cincizeci și șase de mii șapte sute optzeci și nouă de lei')
 
     def test_to_year(self):
         self.assertEqual(num2words(1989, lang='ro', to='year'),