Attempt at refactoring to_currency into base (#135)

* Attempt at refactoring lv to base

* Remove dead files.

* Use static props.

* Convert doctests, move utils out.

* Refactor lt

* Update and move ru doctests.

* Refactor ru.

* Refactor pl.

* Move uk doctests.

* Refactor uk.

* DRY

* Cleanup.

tests/test_en.py

@@ -50,7 +50,7 @@ class Num2WordsENTest(TestCase):
 
         self.assertEqual(
             num2words('4778.00', lang='en', to='currency', seperator=' and',
-                      cents=True, currency='USD', prefix=True),
+                      cents=True, currency='USD', adjective=True),
             'four thousand, seven hundred and seventy-eight US dollars'
             ' and zero cents')
 

tests/test_lt.py

@@ -0,0 +1,80 @@
+# -*- encoding: utf-8 -*-
+from __future__ import unicode_literals
+
+from unittest import TestCase
+
+from num2words import num2words
+
+
+class Num2WordsLTTest(TestCase):
+    def test_to_cardinal(self):
+        self.assertEqual(num2words(100, lang='lt'), 'vienas šimtas')
+        self.assertEqual(num2words(101, lang='lt'), 'vienas šimtas vienas')
+        self.assertEqual(num2words(110, lang='lt'), 'vienas šimtas dešimt')
+        self.assertEqual(num2words(115, lang='lt'),
+                         'vienas šimtas penkiolika')
+        self.assertEqual(num2words(123, lang='lt'),
+                         'vienas šimtas dvidešimt trys')
+        self.assertEqual(num2words(1000, lang='lt'), 'vienas tūkstantis')
+        self.assertEqual(num2words(1001, lang='lt'),
+                         'vienas tūkstantis vienas')
+        self.assertEqual(num2words(2012, lang='lt'),
+                         'du tūkstančiai dvylika')
+        self.assertEqual(
+            num2words(1234567890, lang='lt'),
+            "vienas milijardas du šimtai trisdešimt keturi milijonai "
+            "penki šimtai šešiasdešimt septyni tūkstančiai aštuoni šimtai "
+            "devyniasdešimt")
+        self.assertEqual(
+            num2words(215461407892039002157189883901676, lang='lt'),
+            "du šimtai penkiolika naintilijonų keturi šimtai šešiasdešimt "
+            "vienas oktilijonas keturi šimtai septyni septilijonai aštuoni "
+            "šimtai devyniasdešimt du sikstilijonai trisdešimt devyni "
+            "kvintilijonai du kvadrilijonai vienas šimtas penkiasdešimt "
+            "septyni trilijonai vienas šimtas aštuoniasdešimt devyni "
+            "milijardai aštuoni šimtai aštuoniasdešimt trys milijonai "
+            "devyni šimtai vienas tūkstantis šeši šimtai "
+            "septyniasdešimt šeši")
+        self.assertEqual(
+            num2words(719094234693663034822824384220291, lang='lt'),
+            "septyni šimtai devyniolika naintilijonų devyniasdešimt keturi "
+            "oktilijonai du šimtai trisdešimt keturi septilijonai šeši "
+            "šimtai devyniasdešimt trys sikstilijonai šeši šimtai "
+            "šešiasdešimt trys kvintilijonai trisdešimt keturi kvadrilijonai "
+            "aštuoni šimtai dvidešimt du trilijonai aštuoni šimtai dvidešimt "
+            "keturi milijardai trys šimtai aštuoniasdešimt keturi milijonai "
+            "du šimtai dvidešimt tūkstančių du šimtai devyniasdešimt vienas")
+
+        # print(fill(n2w(1000000000000000000000000000000)))
+        # naintilijonas
+
+    def test_to_ordinal(self):
+        # @TODO: implement to_ordinal
+        with self.assertRaises(NotImplementedError):
+            num2words(1, lang='lt', to='ordinal')
+
+    def test_to_currency(self):
+        self.assertEqual(
+            num2words(1.0, lang='lt', to='currency', currency='LTL'),
+            'vienas litas, nulis centų'
+        )
+        self.assertEqual(
+            num2words(1234.56, lang='lt', to='currency', currency='LTL'),
+            'vienas tūkstantis du šimtai trisdešimt keturi litai, '
+            'penkiasdešimt šeši centai'
+        )
+        self.assertEqual(
+            num2words(-1251985, lang='lt', to='currency', currency='EUR',
+                      cents=False),
+            'minus dvylika tūkstančių penki šimtai devyniolika eurų, '
+            '85 centai'
+        )
+        self.assertEqual(
+            num2words(1.0, lang='lt', to='currency', currency='EUR'),
+            'vienas euras, nulis centų'
+        )
+        self.assertEqual(
+            num2words(1234.56, lang='lt', to='currency', currency='EUR'),
+            'vienas tūkstantis du šimtai trisdešimt keturi eurai, '
+            'penkiasdešimt šeši centai'
+        )

tests/test_lv.py

@@ -8,6 +8,41 @@ from num2words import num2words
 
 class Num2WordsLVTest(TestCase):
     def test_to_cardinal(self):
+        self.assertEqual(num2words(100, lang='lv'), 'simts')
+        self.assertEqual(num2words(101, lang='lv'), 'simtu viens')
+        self.assertEqual(num2words(110, lang='lv'), 'simts desmit')
+        self.assertEqual(num2words(115, lang='lv'), 'simts piecpadsmit')
+        self.assertEqual(num2words(123, lang='lv'), 'simts divdesmit trīs')
+        self.assertEqual(num2words(1000, lang='lv'), 'tūkstotis')
+        self.assertEqual(num2words(1001, lang='lv'), 'tūkstotis viens')
+        self.assertEqual(num2words(2012, lang='lv'),
+                         'divi tūkstoši divpadsmit')
+        self.assertEqual(
+            num2words(1234567890, lang='lv'),
+            'miljards divi simti trīsdesmit četri miljoni pieci simti '
+            'sešdesmit septiņi tūkstoši astoņi simti deviņdesmit')
+        self.assertEqual(
+            num2words(215461407892039002157189883901676, lang='lv'),
+            'divi simti piecpadsmit nontiljoni četri simti sešdesmit '
+            'viens oktiljons četri simti septiņi septiljoni astoņi '
+            'simti deviņdesmit divi sikstiljoni trīsdesmit deviņi '
+            'kvintiljoni divi kvadriljoni simts piecdesmit septiņi '
+            'triljoni simts astoņdesmit deviņi miljardi astoņi simti '
+            'astoņdesmit trīs miljoni deviņi simti viens tūkstotis '
+            'seši simti septiņdesmit seši')
+        self.assertEqual(
+            num2words(719094234693663034822824384220291, lang='lv'),
+            'septiņi simti deviņpadsmit nontiljoni deviņdesmit četri '
+            'oktiljoni divi simti trīsdesmit četri septiljoni seši simti '
+            'deviņdesmit trīs sikstiljoni seši simti sešdesmit trīs '
+            'kvintiljoni trīsdesmit četri kvadriljoni astoņi simti '
+            'divdesmit divi triljoni astoņi simti divdesmit četri '
+            'miljardi trīs simti astoņdesmit četri miljoni divi simti '
+            'divdesmit tūkstoši divi simti deviņdesmit viens')
+
+        # >>> print(fill(n2w(1000000000000000000000000000000)))
+        # nontiljons
+
         self.assertEqual(num2words(0, lang='lv'), 'nulle')
         self.assertEqual(num2words(5, lang='lv'), "pieci")
         self.assertEqual(num2words(15, lang='lv'), "piecpadsmit")
@@ -25,7 +60,46 @@ class Num2WordsLVTest(TestCase):
             "miljons simts trīsdesmit deviņi"
         )
 
+    def test_to_ordinal(self):
+        # @TODO: implement to_ordinal
+        with self.assertRaises(NotImplementedError):
+            num2words(1, lang='lv', to='ordinal')
+
     def test_to_currency(self):
+        self.assertEqual(
+            num2words(1.0, lang='lv', to='currency', currency='EUR'),
+            "viens eiro, nulle centu"
+        )
+        self.assertEqual(
+            num2words(1.0, lang='lv', to='currency', currency='LVL'),
+            "viens lats, nulle santīmu"
+        )
+        self.assertEqual(
+            num2words(1234.56, lang='lv', to='currency', currency='EUR'),
+            "tūkstotis divi simti trīsdesmit četri eiro, piecdesmit seši centi"
+        )
+        self.assertEqual(
+            num2words(1234.56, lang='lv', to='currency', currency='LVL'),
+            "tūkstotis divi simti trīsdesmit četri lati, "
+            "piecdesmit seši santīmi"
+        )
+
+        self.assertEqual(
+            num2words(10111, lang='lv', to='currency', seperator=' un',
+                      currency='EUR'),
+            "simtu viens eiro un vienpadsmit centi"
+        )
+        self.assertEqual(
+            num2words(10121, lang='lv', to='currency', seperator=' un',
+                      currency='LVL'),
+            "simtu viens lats un divdesmit viens santīms"
+        )
+        self.assertEqual(
+            num2words(-1251985, lang='lv', to='currency', cents=False,
+                      currency='EUR'),
+            "mīnus divpadsmit tūkstoši pieci simti deviņpadsmit eiro,"
+            " 85 centi"
+        )
         self.assertEqual(
             num2words('38.4', lang='lv', to='currency', seperator=' un',
                       cents=False, currency='EUR'),
@@ -41,13 +115,13 @@ class Num2WordsLVTest(TestCase):
 
         self.assertEqual(
             num2words('38.4', lang='lv', to='currency', seperator=' un',
-                      cents=False, currency='USD', prefix=False),
+                      cents=False, currency='USD', adjective=False),
             "trīsdesmit astoņi dolāri un 40 centi"
         )
 
         self.assertEqual(
             num2words('38.4', lang='lv', to='currency', seperator=' un',
-                      cents=False, currency='USD', prefix=True),
+                      cents=False, currency='USD', adjective=True),
             "trīsdesmit astoņi ASV dolāri un 40 centi"
         )
 

tests/test_pl.py

@@ -19,7 +19,6 @@ from __future__ import unicode_literals
 from unittest import TestCase
 
 from num2words import num2words
-from num2words.lang_PL import to_currency
 
 
 class Num2WordsPLTest(TestCase):
@@ -66,36 +65,48 @@ class Num2WordsPLTest(TestCase):
             "tysięcy dwieście dziewięćdzisiąt jeden"
         )
 
+    def test_to_ordinal(self):
+        # @TODO: implement to_ordinal
+        with self.assertRaises(NotImplementedError):
+            num2words(1, lang='pl', to='ordinal')
+
     def test_currency(self):
-        self.assertEqual(to_currency(1.0, 'EUR'), "jeden euro, zero centów")
-        self.assertEqual(to_currency(1.0, 'PLN'), "jeden złoty, zero groszy")
         self.assertEqual(
-            to_currency(1234.56, 'EUR'),
+            num2words(1.0, lang='pl', to='currency', currency='EUR'),
+            "jeden euro, zero centów")
+        self.assertEqual(
+            num2words(1.0, lang='pl', to='currency', currency='PLN'),
+            "jeden złoty, zero groszy")
+        self.assertEqual(
+            num2words(1234.56, lang='pl', to='currency', currency='EUR'),
             "tysiąc dwieście trzydzieści cztery euro, pięćdziesiąt sześć "
             "centów"
         )
         self.assertEqual(
-            to_currency(1234.56, 'PLN'),
+            num2words(1234.56, lang='pl', to='currency', currency='PLN'),
             "tysiąc dwieście trzydzieści cztery złote, pięćdziesiąt sześć "
             "groszy"
         )
         self.assertEqual(
-            to_currency(10111, 'EUR', seperator=' i'),
+            num2words(10111, lang='pl', to='currency', currency='EUR',
+                      seperator=' i'),
             "sto jeden euro i jedenaście centów"
         )
         self.assertEqual(
-            to_currency(10121, 'PLN', seperator=' i'),
+            num2words(10121, lang='pl', to='currency', currency='PLN',
+                      seperator=' i'),
             "sto jeden złotych i dwadzieścia jeden groszy"
         )
         self.assertEqual(
-            to_currency(-1251985, cents=False),
+            num2words(-1251985, lang='pl', to='currency', cents=False),
             "minus dwanaście tysięcy pięćset dziewiętnaście euro, 85 centów"
         )
         self.assertEqual(
-            to_currency(123.50, 'PLN', seperator=' i'),
+            num2words(123.50, lang='pl', to='currency', currency='PLN',
+                      seperator=' i'),
             "sto dwadzieścia trzy złote i pięćdziesiąt groszy"
         )
         self.assertEqual(
-            to_currency(1950, cents=False),
+            num2words(1950, lang='pl', to='currency', cents=False),
             "dziewiętnaście euro, 50 centów"
         )

tests/test_ru.py

@@ -23,6 +23,37 @@ from num2words import num2words
 class Num2WordsRUTest(TestCase):
 
     def test_cardinal(self):
+        self.assertEqual(num2words(100, lang='ru'), "сто")
+        self.assertEqual(num2words(101, lang='ru'), "сто один")
+        self.assertEqual(num2words(110, lang='ru'), "сто десять")
+        self.assertEqual(num2words(115, lang='ru'), "сто пятнадцать")
+        self.assertEqual(num2words(123, lang='ru'), "сто двадцать три")
+        self.assertEqual(num2words(1000, lang='ru'), "одна тысяча")
+        self.assertEqual(num2words(1001, lang='ru'), "одна тысяча один")
+        self.assertEqual(num2words(2012, lang='ru'), "две тысячи двенадцать")
+        self.assertEqual(
+            num2words(12519.85, lang='ru'),
+            "двенадцать тысяч пятьсот девятнадцать запятая восемьдесят пять")
+        self.assertEqual(
+            num2words(1234567890, lang='ru'),
+            "один миллиард двести тридцать четыре миллиона пятьсот "
+            "шестьдесят семь тысяч восемьсот девяносто")
+        self.assertEqual(
+            num2words(215461407892039002157189883901676, lang='ru'),
+            "двести пятнадцать нониллионов четыреста шестьдесят один "
+            "октиллион четыреста семь септиллионов восемьсот девяносто "
+            "два секстиллиона тридцать девять квинтиллионов два квадриллиона "
+            "сто пятьдесят семь триллионов сто восемьдесят девять миллиардов "
+            "восемьсот восемьдесят три миллиона девятьсот одна тысяча "
+            "шестьсот семьдесят шесть")
+        self.assertEqual(
+            num2words(719094234693663034822824384220291, lang='ru'),
+            "семьсот девятнадцать нониллионов девяносто четыре октиллиона "
+            "двести тридцать четыре септиллиона шестьсот девяносто три "
+            "секстиллиона шестьсот шестьдесят три квинтиллиона тридцать "
+            "четыре квадриллиона восемьсот двадцать два триллиона восемьсот "
+            "двадцать четыре миллиарда триста восемьдесят четыре миллиона "
+            "двести двадцать тысяч двести девяносто один")
         self.assertEqual(num2words(5, lang='ru'), "пять")
         self.assertEqual(num2words(15, lang='ru'), "пятнадцать")
         self.assertEqual(num2words(154, lang='ru'), "сто пятьдесят четыре")
@@ -44,7 +75,53 @@ class Num2WordsRUTest(TestCase):
             "пятьсот шестьдесят один запятая сорок два"
         )
 
+    def test_to_ordinal(self):
+        # @TODO: implement to_ordinal
+        with self.assertRaises(NotImplementedError):
+            num2words(1, lang='ru', to='ordinal')
+
     def test_to_currency(self):
+        self.assertEqual(
+            num2words(1.0, lang='ru', to='currency', currency='EUR'),
+            'один евро, ноль центов'
+        )
+        self.assertEqual(
+            num2words(1.0, lang='ru', to='currency', currency='RUB'),
+            'один рубль, ноль копеек'
+        )
+        self.assertEqual(
+            num2words(1234.56, lang='ru', to='currency', currency='EUR'),
+            'одна тысяча двести тридцать четыре евро, пятьдесят шесть центов'
+        )
+        self.assertEqual(
+            num2words(1234.56, lang='ru', to='currency', currency='RUB'),
+            'одна тысяча двести тридцать четыре рубля, пятьдесят шесть копеек'
+        )
+        self.assertEqual(
+            num2words(10111, lang='ru', to='currency', currency='EUR',
+                      seperator=' и'),
+            'сто один евро и одиннадцать центов'
+        )
+        self.assertEqual(
+            num2words(10121, lang='ru', to='currency', currency='RUB',
+                      seperator=' и'),
+            'сто один рубль и двадцать одна копейка'
+        )
+        self.assertEqual(
+            num2words(10122, lang='ru', to='currency', currency='RUB',
+                      seperator=' и'),
+            'сто один рубль и двадцать две копейки'
+        )
+        self.assertEqual(
+            num2words(10121, lang='ru', to='currency', currency='EUR',
+                      seperator=' и'),
+            'сто один евро и двадцать один цент'
+        )
+        self.assertEqual(
+            num2words(-1251985, lang='ru', to='currency', currency='EUR',
+                      cents=False),
+            'минус двенадцать тысяч пятьсот девятнадцать евро, 85 центов'
+        )
         self.assertEqual(
             num2words('38.4', lang='ru', to='currency', seperator=' и',
                       cents=False, currency='EUR'),

tests/test_uk.py

@@ -21,6 +21,41 @@ from num2words import num2words
 
 
 class Num2WordsUKTest(TestCase):
+    def test_to_cardinal(self):
+        self.maxDiff = None
+        self.assertEqual(num2words(100, lang='uk'), 'сто')
+        # self.assertEqual(num2words(101, lang='uk'), 'сто один')
+        self.assertEqual(num2words(110, lang='uk'), 'сто десять')
+        self.assertEqual(num2words(115, lang='uk'), "сто п'ятнадцять")
+        self.assertEqual(num2words(123, lang='uk'), 'сто двадцять три')
+        self.assertEqual(num2words(1000, lang='uk'), 'одна тисяча')
+        # self.assertEqual(num2words(1001, lang='uk'), 'одна тисяча один')
+        self.assertEqual(num2words(2012, lang='uk'), 'двi тисячi дванадцять')
+        self.assertEqual(
+            num2words(12519.85, lang='uk'),
+            "дванадцять тисяч п'ятсот дев'ятнадцять кома вiсiмдесят п'ять")
+        # self.assertEqual(
+        #    num2words(1234567890, lang='uk'),
+        #    "мiльярд двiстi тридцать чотири мiльйона п'ятсот шiстдесят сiмь "
+        #    "тисяч вiсiмсот дев'яносто")
+        # self.assertEqual(
+        #     num2words(215461407892039002157189883901676, lang='uk'),
+        #     "двiстi п'ятнадцять нонiльйонiв чотириста шiстдесят один "
+        #     "октильйон чотириста сiм септильйонiв вiсiмсот дев'яносто "
+        #     "два секстильйони тридцять дев'ять квiнтильйонiв два "
+        #     "квадрильйони сто п'ятдесят сiм трильйонiв сто вiсiмдесят "
+        #     "дев'ять мiльярдiв вiсiмсот вiсiмдесят три мiльйона "
+        #     "дев'ятсот одна тисяча шiстсот "
+        #     "сiмдесят шiсть")
+        # self.assertEqual(
+        #     num2words(719094234693663034822824384220291, lang='uk'),
+        #     "сiмсот дев'ятнадцять нонiльйонiв дев'яносто чотири октильйони "
+        #     "двiстi тридцять чотири септильйони шiстсот дев'яносто три "
+        #     "секстильйони шiстсот шiстдесят три квiнтильйони тридцять "
+        #     "чотири квадрильйони вiсiмсот двадцять два трильйони вiсiмсот "
+        #     "двадцять чотири мiльярди триста вiсiмдесят чотири мiльйона "
+        #     "двiстi двадцять тисяч двiстi дев'яносто один")
+
     def test_and_join_199(self):
         self.assertEqual(num2words(187, lang='uk'), "сто вiсiмдесят сiм")
 
@@ -38,7 +73,59 @@ class Num2WordsUKTest(TestCase):
             num2words(12.31, lang='uk'), "дванадцять кома тридцять одна"
         )
 
+    def test_to_ordinal(self):
+        # @TODO: implement to_ordinal
+        with self.assertRaises(NotImplementedError):
+            num2words(1, lang='uk', to='ordinal')
+
     def test_to_currency(self):
+        # self.assertEqual(
+        #     num2words(1.0, lang='uk', to='currency', currency='EUR'),
+        #     "один евро, нуль центiв"
+        # )
+        self.assertEqual(
+            num2words(1.0, lang='uk', to='currency', currency='UAH'),
+            "одна гривня, нуль копiйок"
+        )
+        self.assertEqual(
+            num2words(1234.56, lang='uk', to='currency', currency='EUR'),
+            "одна тисяча двiстi тридцять чотири евро, п'ятдесят шiсть центiв"
+        )
+        self.assertEqual(
+            num2words(1234.56, lang='uk', to='currency', currency='UAH'),
+            "одна тисяча двiстi тридцять чотири гривнi, п'ятдесят шiсть "
+            "копiйок"
+        )
+        # self.assertEqual(
+        #     num2words(10111, lang='uk', to='currency', currency='EUR',
+        #               seperator=u' та'),
+        #     "сто один евро та одинадцять центiв"
+        # )
+        self.assertEqual(
+            num2words(10121, lang='uk', to='currency', currency='UAH',
+                      seperator=u' та'),
+            "сто одна гривня та двадцять одна копiйка"
+        )
+        self.assertEqual(
+            num2words(10121, lang='uk', to='currency', currency='UAH',
+                      seperator=u' та'),
+            "сто одна гривня та двадцять одна копiйка"
+        )
+        self.assertEqual(
+            num2words(10122, lang='uk', to='currency', currency='UAH',
+                      seperator=u' та'),
+            "сто одна гривня та двадцять двi копiйки"
+        )
+        # self.assertEqual(
+        #     num2words(10121, lang='uk', to='currency', currency='EUR',
+        #               seperator=u' та'),
+        #     "сто один евро та двадцять один цент"
+        # )
+        self.assertEqual(
+            num2words(-1251985, lang='uk', to='currency', currency='EUR',
+                      cents=False),
+            "мiнус дванадцять тисяч п'ятсот дев'ятнадцять евро, 85 центiв"
+        )
         self.assertEqual(
             num2words('38.4', lang='uk', to='currency', seperator=' и',
                       cents=False, currency='EUR'),