Merge pull request #260 from mariaS210/romanian-issues-259

Romanian issues 259

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()
@@ -48,13 +49,13 @@ class Num2Word_RO(lang_EU.Num2Word_EU):
                              "unu", "zero"]
         self.gen_numwords = ["", "o", "două", "trei", "patru", "cinci",
                              "șase", "șapte", "opt", "nouă"]
-        self.gen_numwords_m = ["", "un", "două", "trei", "patru", "cinci",
+        self.gen_numwords_n = ["", "un", "două", "trei", "patru", "cinci",
                                "șase", "șapte", "opt", "nouă"]
         self.numwords_inflections = {
             100: self.gen_numwords,
             1000: self.gen_numwords,
-            1000000: self.gen_numwords_m,
+            1000000: self.gen_numwords_n,
-            1000000000: self.gen_numwords_m
+            1000000000: self.gen_numwords_n
         }
         self.ords = {"unu": "primul",
                      "doi": "al doilea",
@@ -67,24 +68,29 @@ class Num2Word_RO(lang_EU.Num2Word_EU):
     def merge(self, lpair, rpair):
         ltext, lnum = lpair
         rtext, rnum = rpair
-        rtext_i = self.inflect(rnum, rtext)
+        rtext_i = self.inflect(rnum, rtext, lnum)
-        if lnum > 1 and rtext_i.endswith(self.MEGA_SUFFIX):
-            rtext_i = rtext_i.replace(self.MEGA_SUFFIX, self.MEGA_SUFFIX_I)
         if 1 <= lnum < 10:
             if rnum not in self.numwords_inflections:
                 return (rtext, rnum)
             else:
-                rtext_i = self.inflect(lnum * rnum, rtext)
+                rtext_i = self.inflect(lnum * rnum, rtext, lnum)
                 lresult = (self.numwords_inflections[rnum][lnum], rtext_i)
                 return ("%s %s" % lresult, rnum)
         elif 10 < lnum < 100:
             if lnum % 10 == 0:
-                return ("%s și %s" % (ltext, rtext), lnum + rnum)
+                if rnum in self.numwords_inflections:
-            else:
+                    rtext_i = self.inflect(lnum * rnum, rtext, lnum)
                     return ("%s %s" % (ltext, rtext_i), lnum * rnum)
+                else:
+                    return ("%s și %s" % (ltext, rtext), lnum + rnum)
+            else:
+                rtext_i = self.inflect(lnum * rnum, rtext, lnum)
+                ltext_i = ltext if lnum % 10 != 2 \
+                    else ltext.replace("doi", "două")
+                return ("%s %s" % (ltext_i, rtext_i), lnum * rnum)
         else:
             if rnum in self.numwords_inflections:
-                rtext_i = self.inflect(lnum * rnum, rtext)
+                rtext_i = self.inflect(lnum * rnum, rtext, lnum)
             return ("%s %s" % (ltext, rtext_i), lnum * rnum)
 
     def to_ordinal(self, value):
@@ -101,21 +107,52 @@ class Num2Word_RO(lang_EU.Num2Word_EU):
             return "1-ul"
         return "al %s-lea" % (value)
 
-    def inflect(self, value, text):
+    def pluralize(self, n, forms):
-        text = text.split("/")
+        if n == 1:
-        if value in (1, 100, 1000, 100000, 1000000000):
+            form = 0
-            return text[0]
+        elif n == 0 or (n % 100 > 0 and n % 100 < 20):
-        if len(text) > 1 and text[0][-1] in "aăeiou":
+            form = 1
-            text[0] = text[0][:-1]
+        else:
-        return "".join(text)
+            form = 2
+        return forms[form]
 
-    def to_currency(self, val, longval=True, old=False):
+    def inflect(self, value, text, side_effect=-1):
-        cents = int(round(val*100))
+        text = text.split("/")
-        result = self.to_splitnum(cents, hightxt="leu/i", lowtxt="ban/i",
+        result = text[0]
-                                  divisor=100, jointxt="și", longval=longval)
+        if len(text) > 1:
+            forms = [
+                text[0],
+                text[0][:-1] + text[1],
+                "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, currency="RON", cents=False, separator=" și",
+                    adjective=False):
+        # romanian currency has a particularity for numeral: one
+        self.gen_numwords[1] = "una"
+        result = super(Num2Word_RO, self).to_currency(
+            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(
+            "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):
         result = super(Num2Word_RO, self).to_year(

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):
@@ -117,23 +117,45 @@ class Num2WordsROTest(TestCase):
 
     def test_to_currency(self):
         self.assertEqual(
-            num2words(38.4, lang='ro', to='currency'),
+            num2words(1000, lang='ro', to='currency'),
-            u'treizeci și opt lei și patruzeci bani'
+            u'una mie de lei'
+        )
+        self.assertEqual(
+            num2words(101, lang='ro', to='currency'),
+            u'una sută unu lei'
+        )
+        self.assertEqual(
+            num2words(100, lang='ro', to='currency'),
+            u'una sută de lei'
+        )
+        self.assertEqual(
+            num2words(38.4, lang='ro', to='currency'),
+            u'treizeci și opt de lei și patruzeci de bani'
         )
-
         self.assertEqual(
             num2words(1.01, lang='ro', to='currency'),
             u'un leu și un ban'
         )
-
         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(1207, lang='ro', to='currency'),
+            u'una mie două sute șapte lei')
+        self.assertEqual(
+            num2words(22000, lang='ro', to='currency'),
+            u'douăzeci și două de mii de lei')
+        self.assertEqual(
+            num2words(80000, lang='ro', to='currency'),
+            u'optzeci de 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 de mii șapte sute optzeci și nouă de lei')
 
     def test_to_year(self):
         self.assertEqual(num2words(1989, lang='ro', to='year'),