1#![doc = include_str!("../README.md")]
2
3use std::fmt;
4use std::str::FromStr;
5
6#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8pub enum Lang {
9 Ru,
10 Uk,
11 Lt,
12 En,
13 Fr,
14}
15
16#[derive(Debug, Clone, Copy, PartialEq, Eq)]
18pub enum Currency {
19 Eur,
20 Usd,
21 Gbp,
22 Pln,
23 Uah,
24 Rub,
25 Byn,
26 Kzt,
27}
28
29#[derive(Debug, Clone, Copy, PartialEq, Eq)]
31pub enum Gender {
32 Masculine,
33 Feminine,
34 Neuter,
36}
37
38#[derive(Debug, Clone, Copy, PartialEq, Eq)]
40pub enum Minor {
41 Digits,
43 Words,
45 None,
47}
48
49#[derive(Debug, Clone, Copy, PartialEq, Eq)]
51pub struct Options {
52 pub minor: Minor,
53 pub capitalize: bool,
55}
56
57impl Default for Options {
58 fn default() -> Self {
59 Options { minor: Minor::Digits, capitalize: true }
60 }
61}
62
63#[derive(Debug, Clone, PartialEq, Eq)]
65pub enum Error {
66 InvalidAmount(String),
68 TooLarge,
70 UnknownCode(String),
72}
73
74impl fmt::Display for Error {
75 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
76 match self {
77 Error::InvalidAmount(s) => write!(f, "invalid amount: {:?}", s),
78 Error::TooLarge => write!(f, "number is too large (max 999 999 999 999 999)"),
79 Error::UnknownCode(s) => write!(f, "unknown code: {:?}", s),
80 }
81 }
82}
83
84impl std::error::Error for Error {}
85
86impl FromStr for Lang {
87 type Err = Error;
88 fn from_str(s: &str) -> Result<Self, Error> {
89 match s.to_ascii_lowercase().as_str() {
90 "ru" => Ok(Lang::Ru),
91 "uk" => Ok(Lang::Uk),
92 "lt" => Ok(Lang::Lt),
93 "en" => Ok(Lang::En),
94 "fr" => Ok(Lang::Fr),
95 _ => Err(Error::UnknownCode(s.to_string())),
96 }
97 }
98}
99
100impl FromStr for Currency {
101 type Err = Error;
102 fn from_str(s: &str) -> Result<Self, Error> {
103 match s.to_ascii_uppercase().as_str() {
104 "EUR" => Ok(Currency::Eur),
105 "USD" => Ok(Currency::Usd),
106 "GBP" => Ok(Currency::Gbp),
107 "PLN" => Ok(Currency::Pln),
108 "UAH" => Ok(Currency::Uah),
109 "RUB" => Ok(Currency::Rub),
110 "BYN" => Ok(Currency::Byn),
111 "KZT" => Ok(Currency::Kzt),
112 _ => Err(Error::UnknownCode(s.to_string())),
113 }
114 }
115}
116
117const LIMIT: u64 = 1_000_000_000_000_000;
118
119fn groups(mut n: u64) -> Vec<u64> {
120 let mut g = Vec::new();
121 while n > 0 {
122 g.push(n % 1000);
123 n /= 1000;
124 }
125 g
126}
127
128fn slavic_plural(n: u64) -> usize {
132 if n % 10 == 1 && n % 100 != 11 {
133 0
134 } else if (2..=4).contains(&(n % 10)) && !(12..=14).contains(&(n % 100)) {
135 1
136 } else {
137 2
138 }
139}
140
141struct Slavic {
142 zero: &'static str,
143 ones_m: [&'static str; 10],
144 ones_f: [&'static str; 10],
145 ones_n: [&'static str; 10],
146 teens: [&'static str; 10],
147 tens: [&'static str; 10],
148 hundreds: [&'static str; 10],
149 scales: [([&'static str; 3], Gender); 4],
150}
151
152const RU: Slavic = Slavic {
153 zero: "ноль",
154 ones_m: ["", "один", "два", "три", "четыре", "пять", "шесть", "семь", "восемь", "девять"],
155 ones_f: ["", "одна", "две", "три", "четыре", "пять", "шесть", "семь", "восемь", "девять"],
156 ones_n: ["", "одно", "два", "три", "четыре", "пять", "шесть", "семь", "восемь", "девять"],
157 teens: ["десять", "одиннадцать", "двенадцать", "тринадцать", "четырнадцать",
158 "пятнадцать", "шестнадцать", "семнадцать", "восемнадцать", "девятнадцать"],
159 tens: ["", "", "двадцать", "тридцать", "сорок", "пятьдесят",
160 "шестьдесят", "семьдесят", "восемьдесят", "девяносто"],
161 hundreds: ["", "сто", "двести", "триста", "четыреста", "пятьсот",
162 "шестьсот", "семьсот", "восемьсот", "девятьсот"],
163 scales: [
164 (["тысяча", "тысячи", "тысяч"], Gender::Feminine),
165 (["миллион", "миллиона", "миллионов"], Gender::Masculine),
166 (["миллиард", "миллиарда", "миллиардов"], Gender::Masculine),
167 (["триллион", "триллиона", "триллионов"], Gender::Masculine),
168 ],
169};
170
171const UK: Slavic = Slavic {
172 zero: "нуль",
173 ones_m: ["", "один", "два", "три", "чотири", "п'ять", "шість", "сім", "вісім", "дев'ять"],
174 ones_f: ["", "одна", "дві", "три", "чотири", "п'ять", "шість", "сім", "вісім", "дев'ять"],
175 ones_n: ["", "одне", "два", "три", "чотири", "п'ять", "шість", "сім", "вісім", "дев'ять"],
176 teens: ["десять", "одинадцять", "дванадцять", "тринадцять", "чотирнадцять",
177 "п'ятнадцять", "шістнадцять", "сімнадцять", "вісімнадцять", "дев'ятнадцять"],
178 tens: ["", "", "двадцять", "тридцять", "сорок", "п'ятдесят",
179 "шістдесят", "сімдесят", "вісімдесят", "дев'яносто"],
180 hundreds: ["", "сто", "двісті", "триста", "чотириста", "п'ятсот",
181 "шістсот", "сімсот", "вісімсот", "дев'ятсот"],
182 scales: [
183 (["тисяча", "тисячі", "тисяч"], Gender::Feminine),
184 (["мільйон", "мільйони", "мільйонів"], Gender::Masculine),
185 (["мільярд", "мільярди", "мільярдів"], Gender::Masculine),
186 (["трильйон", "трильйони", "трильйонів"], Gender::Masculine),
187 ],
188};
189
190fn slavic_triplet(n: u64, g: Gender, d: &Slavic, out: &mut Vec<&'static str>) {
191 let (h, rest) = (n / 100, n % 100);
192 if h > 0 {
193 out.push(d.hundreds[h as usize]);
194 }
195 if (10..=19).contains(&rest) {
196 out.push(d.teens[(rest - 10) as usize]);
197 } else {
198 let (t, o) = (rest / 10, rest % 10);
199 if t > 0 {
200 out.push(d.tens[t as usize]);
201 }
202 if o > 0 {
203 let ones = match g {
204 Gender::Masculine => &d.ones_m,
205 Gender::Feminine => &d.ones_f,
206 Gender::Neuter => &d.ones_n,
207 };
208 out.push(ones[o as usize]);
209 }
210 }
211}
212
213fn slavic_words(n: u64, g: Gender, d: &Slavic) -> String {
214 if n == 0 {
215 return d.zero.to_string();
216 }
217 let gs = groups(n);
218 let mut out = Vec::new();
219 for i in (0..gs.len()).rev() {
220 let v = gs[i];
221 if v == 0 {
222 continue;
223 }
224 if i == 0 {
225 slavic_triplet(v, g, d, &mut out);
226 } else {
227 let (forms, sg) = d.scales[i - 1];
228 slavic_triplet(v, sg, d, &mut out);
229 out.push(forms[slavic_plural(v)]);
230 }
231 }
232 out.join(" ")
233}
234
235fn lt_plural(n: u64) -> usize {
239 if (11..=19).contains(&(n % 100)) || n % 10 == 0 {
240 2
241 } else if n % 10 == 1 {
242 0
243 } else {
244 1
245 }
246}
247
248const LT_ONES_M: [&str; 10] = ["", "vienas", "du", "trys", "keturi", "penki", "šeši", "septyni", "aštuoni", "devyni"];
249const LT_ONES_F: [&str; 10] = ["", "viena", "dvi", "trys", "keturios", "penkios", "šešios", "septynios", "aštuonios", "devynios"];
250const LT_TEENS: [&str; 10] = ["dešimt", "vienuolika", "dvylika", "trylika", "keturiolika",
251 "penkiolika", "šešiolika", "septyniolika", "aštuoniolika", "devyniolika"];
252const LT_TENS: [&str; 10] = ["", "", "dvidešimt", "trisdešimt", "keturiasdešimt", "penkiasdešimt",
253 "šešiasdešimt", "septyniasdešimt", "aštuoniasdešimt", "devyniasdešimt"];
254const LT_SCALES: [[&str; 3]; 4] = [
255 ["tūkstantis", "tūkstančiai", "tūkstančių"],
256 ["milijonas", "milijonai", "milijonų"],
257 ["milijardas", "milijardai", "milijardų"],
258 ["trilijonas", "trilijonai", "trilijonų"],
259];
260
261fn lt_triplet(n: u64, g: Gender, out: &mut Vec<&'static str>) {
262 let (h, rest) = (n / 100, n % 100);
263 if h == 1 {
264 out.push("vienas");
265 out.push("šimtas");
266 } else if h > 1 {
267 out.push(LT_ONES_M[h as usize]);
268 out.push("šimtai");
269 }
270 if (10..=19).contains(&rest) {
271 out.push(LT_TEENS[(rest - 10) as usize]);
272 } else {
273 let (t, o) = (rest / 10, rest % 10);
274 if t > 0 {
275 out.push(LT_TENS[t as usize]);
276 }
277 if o > 0 {
278 out.push(if g == Gender::Feminine { LT_ONES_F[o as usize] } else { LT_ONES_M[o as usize] });
279 }
280 }
281}
282
283fn lt_words(n: u64, g: Gender) -> String {
284 if n == 0 {
285 return "nulis".to_string();
286 }
287 let gs = groups(n);
288 let mut out = Vec::new();
289 for i in (0..gs.len()).rev() {
290 let v = gs[i];
291 if v == 0 {
292 continue;
293 }
294 if i == 0 {
295 lt_triplet(v, g, &mut out);
296 } else {
297 lt_triplet(v, Gender::Masculine, &mut out);
298 out.push(LT_SCALES[i - 1][lt_plural(v)]);
299 }
300 }
301 out.join(" ")
302}
303
304const EN_ONES: [&str; 20] = ["", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",
307 "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen",
308 "seventeen", "eighteen", "nineteen"];
309const EN_TENS: [&str; 10] = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"];
310const EN_SCALES: [&str; 4] = ["thousand", "million", "billion", "trillion"];
311
312fn en_words(n: u64) -> String {
313 if n == 0 {
314 return "zero".to_string();
315 }
316 let gs = groups(n);
317 let mut out: Vec<String> = Vec::new();
318 for i in (0..gs.len()).rev() {
319 let v = gs[i];
320 if v == 0 {
321 continue;
322 }
323 let (h, rest) = (v / 100, v % 100);
324 if h > 0 {
325 out.push(EN_ONES[h as usize].to_string());
326 out.push("hundred".to_string());
327 }
328 if rest > 0 && rest < 20 {
329 out.push(EN_ONES[rest as usize].to_string());
330 } else if rest >= 20 {
331 let (t, o) = (rest / 10, rest % 10);
332 if o > 0 {
333 out.push(format!("{}-{}", EN_TENS[t as usize], EN_ONES[o as usize]));
334 } else {
335 out.push(EN_TENS[t as usize].to_string());
336 }
337 }
338 if i > 0 {
339 out.push(EN_SCALES[i - 1].to_string());
340 }
341 }
342 out.join(" ")
343}
344
345const FR_ONES: [&str; 20] = ["", "un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf",
348 "dix", "onze", "douze", "treize", "quatorze", "quinze", "seize",
349 "dix-sept", "dix-huit", "dix-neuf"];
350const FR_TENS: [&str; 7] = ["", "", "vingt", "trente", "quarante", "cinquante", "soixante"];
351const FR_SCALES: [[&str; 2]; 3] = [["million", "millions"], ["milliard", "milliards"], ["billion", "billions"]];
352
353fn fr_below_100(n: u64, last: bool) -> String {
355 if n < 20 {
356 return FR_ONES[n as usize].to_string();
357 }
358 let (t, o) = (n / 10, n % 10);
359 match t {
360 2..=6 => match o {
361 0 => FR_TENS[t as usize].to_string(),
362 1 => format!("{} et un", FR_TENS[t as usize]),
363 _ => format!("{}-{}", FR_TENS[t as usize], FR_ONES[o as usize]),
364 },
365 7 => {
366 if o == 1 {
367 "soixante et onze".to_string()
368 } else {
369 format!("soixante-{}", FR_ONES[(10 + o) as usize])
370 }
371 }
372 8 => {
373 if o == 0 {
374 if last { "quatre-vingts".to_string() } else { "quatre-vingt".to_string() }
375 } else {
376 format!("quatre-vingt-{}", FR_ONES[o as usize])
377 }
378 }
379 _ => format!("quatre-vingt-{}", FR_ONES[(10 + o) as usize]),
380 }
381}
382
383fn fr_triplet(n: u64, last: bool) -> String {
384 let (h, rest) = (n / 100, n % 100);
385 let mut parts = Vec::new();
386 if h == 1 {
387 parts.push("cent".to_string());
388 } else if h > 1 {
389 let s = if rest == 0 && last { "cents" } else { "cent" };
390 parts.push(format!("{} {}", FR_ONES[h as usize], s));
391 }
392 if rest > 0 {
393 parts.push(fr_below_100(rest, last));
394 }
395 parts.join(" ")
396}
397
398fn fr_words(n: u64) -> String {
399 if n == 0 {
400 return "zéro".to_string();
401 }
402 let gs = groups(n);
403 let mut out = Vec::new();
404 for i in (0..gs.len()).rev() {
405 let v = gs[i];
406 if v == 0 {
407 continue;
408 }
409 match i {
410 0 => out.push(fr_triplet(v, true)),
411 1 => {
412 if v != 1 {
414 out.push(fr_triplet(v, false));
415 }
416 out.push("mille".to_string());
417 }
418 _ => {
419 out.push(fr_triplet(v, true));
421 out.push(FR_SCALES[i - 2][if v == 1 { 0 } else { 1 }].to_string());
422 }
423 }
424 }
425 out.join(" ")
426}
427
428pub fn number_in_words(n: i64, lang: Lang, gender: Gender) -> Result<String, Error> {
438 let abs = n.unsigned_abs();
439 if abs >= LIMIT {
440 return Err(Error::TooLarge);
441 }
442 let words = match lang {
443 Lang::Ru => slavic_words(abs, gender, &RU),
444 Lang::Uk => slavic_words(abs, gender, &UK),
445 Lang::Lt => lt_words(abs, gender),
446 Lang::En => en_words(abs),
447 Lang::Fr => fr_words(abs),
448 };
449 if n < 0 {
450 Ok(format!("{} {}", minus(lang), words))
451 } else {
452 Ok(words)
453 }
454}
455
456fn minus(lang: Lang) -> &'static str {
457 match lang {
458 Lang::Ru => "минус",
459 Lang::Uk => "мінус",
460 Lang::Lt | Lang::En => "minus",
461 Lang::Fr => "moins",
462 }
463}
464
465type Forms3 = [&'static str; 3];
468
469fn names3(lang: Lang, c: Currency) -> (Forms3, Gender, Forms3, Gender) {
471 use Currency::*;
472 use Gender::*;
473 match lang {
474 Lang::Ru => {
475 let kop = ["копейка", "копейки", "копеек"];
476 match c {
477 Rub => (["рубль", "рубля", "рублей"], Masculine, kop, Feminine),
478 Uah => (["гривна", "гривны", "гривен"], Feminine, kop, Feminine),
479 Byn => (["белорусский рубль", "белорусских рубля", "белорусских рублей"], Masculine, kop, Feminine),
480 Kzt => (["тенге", "тенге", "тенге"], Masculine, ["тиын", "тиына", "тиынов"], Masculine),
481 Usd => (["доллар", "доллара", "долларов"], Masculine, ["цент", "цента", "центов"], Masculine),
482 Eur => (["евро", "евро", "евро"], Masculine, ["цент", "цента", "центов"], Masculine),
483 Gbp => (["фунт стерлингов", "фунта стерлингов", "фунтов стерлингов"], Masculine,
484 ["пенс", "пенса", "пенсов"], Masculine),
485 Pln => (["злотый", "злотых", "злотых"], Masculine, ["грош", "гроша", "грошей"], Masculine),
486 }
487 }
488 Lang::Uk => {
489 let kop = ["копійка", "копійки", "копійок"];
490 match c {
491 Uah => (["гривня", "гривні", "гривень"], Feminine, kop, Feminine),
492 Rub => (["рубль", "рублі", "рублів"], Masculine, kop, Feminine),
493 Byn => (["білоруський рубль", "білоруські рублі", "білоруських рублів"], Masculine, kop, Feminine),
494 Kzt => (["теньге", "теньге", "теньге"], Masculine, ["тиїн", "тиїни", "тиїнів"], Masculine),
495 Usd => (["долар", "долари", "доларів"], Masculine, ["цент", "центи", "центів"], Masculine),
496 Eur => (["євро", "євро", "євро"], Neuter, ["цент", "центи", "центів"], Masculine),
497 Gbp => (["фунт стерлінгів", "фунти стерлінгів", "фунтів стерлінгів"], Masculine,
498 ["пенс", "пенси", "пенсів"], Masculine),
499 Pln => (["злотий", "злоті", "злотих"], Masculine, ["грош", "гроші", "грошів"], Masculine),
500 }
501 }
502 _ => {
503 let kap = ["kapeika", "kapeikos", "kapeikų"];
504 let cent = ["centas", "centai", "centų"];
505 match c {
506 Eur => (["euras", "eurai", "eurų"], Masculine, cent, Masculine),
507 Usd => (["JAV doleris", "JAV doleriai", "JAV dolerių"], Masculine, cent, Masculine),
508 Gbp => (["svaras sterlingų", "svarai sterlingų", "svarų sterlingų"], Masculine,
509 ["pensas", "pensai", "pensų"], Masculine),
510 Pln => (["zlotas", "zlotai", "zlotų"], Masculine, ["grašis", "grašiai", "grašių"], Masculine),
511 Uah => (["grivina", "grivinos", "grivinų"], Feminine, kap, Feminine),
512 Rub => (["rublis", "rubliai", "rublių"], Masculine, kap, Feminine),
513 Byn => (["Baltarusijos rublis", "Baltarusijos rubliai", "Baltarusijos rublių"], Masculine, kap, Feminine),
514 Kzt => (["tengė", "tengės", "tengių"], Feminine, ["tyjinas", "tyjinai", "tyjinų"], Masculine),
515 }
516 }
517 }
518}
519
520type Forms2 = [&'static str; 2];
521
522fn names2(lang: Lang, c: Currency) -> (Forms2, Forms2) {
524 use Currency::*;
525 if lang == Lang::En {
526 match c {
527 Usd => (["dollar", "dollars"], ["cent", "cents"]),
528 Eur => (["euro", "euros"], ["cent", "cents"]),
529 Gbp => (["pound sterling", "pounds sterling"], ["penny", "pence"]),
530 Rub => (["ruble", "rubles"], ["kopeck", "kopecks"]),
531 Uah => (["hryvnia", "hryvnias"], ["kopiyka", "kopiykas"]),
532 Byn => (["Belarusian ruble", "Belarusian rubles"], ["kopeck", "kopecks"]),
533 Kzt => (["tenge", "tenge"], ["tiyn", "tiyn"]),
534 Pln => (["zloty", "zlotys"], ["grosz", "groszy"]),
535 }
536 } else {
537 match c {
538 Eur => (["euro", "euros"], ["centime", "centimes"]),
539 Usd => (["dollar", "dollars"], ["cent", "cents"]),
540 Gbp => (["livre sterling", "livres sterling"], ["penny", "pence"]),
541 Rub => (["rouble", "roubles"], ["kopeck", "kopecks"]),
542 Uah => (["hryvnia", "hryvnias"], ["kopiyka", "kopiykas"]),
543 Byn => (["rouble biélorusse", "roubles biélorusses"], ["kopeck", "kopecks"]),
544 Kzt => (["tenge", "tenges"], ["tiyn", "tiyns"]),
545 Pln => (["zloty", "zlotys"], ["grosz", "groszy"]),
546 }
547 }
548}
549
550fn parse_cents(s: &str) -> Result<i64, Error> {
554 let bad = || Error::InvalidAmount(s.to_string());
555 let t: String = s.trim().chars().filter(|c| *c != ' ' && *c != '_' && *c != '\u{a0}').collect();
556 let (neg, t) = match t.strip_prefix('-') {
557 Some(r) => (true, r.to_string()),
558 None => (false, t.trim_start_matches('+').to_string()),
559 };
560 let t = t.replace(',', ".");
561 let mut it = t.splitn(2, '.');
562 let int_part = it.next().unwrap_or("");
563 let frac = it.next().unwrap_or("");
564 if int_part.is_empty() && frac.is_empty() {
565 return Err(bad());
566 }
567 if !int_part.chars().all(|c| c.is_ascii_digit()) || !frac.chars().all(|c| c.is_ascii_digit()) {
568 return Err(bad());
569 }
570 let major: u64 = if int_part.is_empty() { 0 } else { int_part.parse().map_err(|_| Error::TooLarge)? };
571 if major >= LIMIT {
572 return Err(Error::TooLarge);
573 }
574 let f: Vec<u64> = frac.chars().map(|c| c as u64 - '0' as u64).collect();
575 let mut cents = f.first().copied().unwrap_or(0) * 10 + f.get(1).copied().unwrap_or(0);
576 if f.get(2).copied().unwrap_or(0) >= 5 {
577 cents += 1;
578 }
579 let total = major as i64 * 100 + cents as i64;
580 if total as u64 >= LIMIT * 100 {
581 return Err(Error::TooLarge);
582 }
583 Ok(if neg { -total } else { total })
584}
585
586pub fn amount_in_words(amount: &str, currency: Currency, lang: Lang) -> Result<String, Error> {
591 amount_in_words_with(amount, currency, lang, Options::default())
592}
593
594pub fn amount_in_words_with(amount: &str, currency: Currency, lang: Lang, opts: Options) -> Result<String, Error> {
605 let cents = parse_cents(amount)?;
606 Ok(cents_in_words(cents, currency, lang, opts))
607}
608
609pub fn cents_in_words(cents: i64, currency: Currency, lang: Lang, opts: Options) -> String {
615 let abs = cents.unsigned_abs();
616 assert!(abs < LIMIT * 100, "amount is too large (max 999 999 999 999 999.99)");
617 let (major, minor) = (abs / 100, abs % 100);
618
619 let mut out = match lang {
620 Lang::Ru | Lang::Uk | Lang::Lt => {
621 let (mj, mj_g, mn, mn_g) = names3(lang, currency);
622 let (words, pl): (String, fn(u64) -> usize) = match lang {
623 Lang::Ru => (slavic_words(major, mj_g, &RU), slavic_plural),
624 Lang::Uk => (slavic_words(major, mj_g, &UK), slavic_plural),
625 _ => (lt_words(major, mj_g), lt_plural),
626 };
627 let mut s = format!("{} {}", words, mj[pl(major)]);
628 if opts.minor != Minor::None {
629 let num = match (opts.minor, lang) {
630 (Minor::Words, Lang::Ru) => slavic_words(minor, mn_g, &RU),
631 (Minor::Words, Lang::Uk) => slavic_words(minor, mn_g, &UK),
632 (Minor::Words, _) => lt_words(minor, mn_g),
633 _ => format!("{:02}", minor),
634 };
635 s = format!("{} {} {}", s, num, mn[pl(minor)]);
636 }
637 s
638 }
639 Lang::En => {
640 let (mj, mn) = names2(lang, currency);
641 let mut s = format!("{} {}", en_words(major), mj[if major == 1 { 0 } else { 1 }]);
642 if opts.minor != Minor::None {
643 let num = if opts.minor == Minor::Words { en_words(minor) } else { format!("{:02}", minor) };
644 s = format!("{} and {} {}", s, num, mn[if minor == 1 { 0 } else { 1 }]);
645 }
646 s
647 }
648 Lang::Fr => {
649 let (mj, mn) = names2(lang, currency);
650 let unit = mj[if major <= 1 { 0 } else { 1 }];
651 let words = fr_words(major);
652 let mut s = if major >= 1_000_000 && major % 1_000_000 == 0 {
654 if unit.starts_with(|c: char| "aeiouyhé".contains(c)) {
655 format!("{} d'{}", words, unit)
656 } else {
657 format!("{} de {}", words, unit)
658 }
659 } else {
660 format!("{} {}", words, unit)
661 };
662 if opts.minor != Minor::None {
663 let one = if opts.minor == Minor::Words { minor <= 1 } else { minor == 1 };
665 let num = if opts.minor == Minor::Words { fr_words(minor) } else { format!("{:02}", minor) };
666 s = format!("{} et {} {}", s, num, mn[if one { 0 } else { 1 }]);
667 }
668 s
669 }
670 };
671
672 if cents < 0 {
673 out = format!("{} {}", minus(lang), out);
674 }
675 if opts.capitalize {
676 let mut c = out.chars();
677 if let Some(f) = c.next() {
678 out = f.to_uppercase().collect::<String>() + c.as_str();
679 }
680 }
681 out
682}
683
684#[cfg(test)]
685mod tests {
686 use super::*;
687
688 fn a(x: &str, c: Currency, l: Lang) -> String {
689 amount_in_words(x, c, l).unwrap()
690 }
691
692 #[test]
693 fn amounts() {
694 use Currency::*;
695 use Lang::*;
696 assert_eq!(a("1521.40", Rub, Ru), "Одна тысяча пятьсот двадцать один рубль 40 копеек");
697 assert_eq!(a("1.01", Rub, Ru), "Один рубль 01 копейка");
698 assert_eq!(a("22.02", Uah, Ru), "Двадцать две гривны 02 копейки");
699 assert_eq!(a("21.21", Kzt, Ru), "Двадцать один тенге 21 тиын");
700 assert_eq!(a("2", Pln, Ru), "Два злотых 00 грошей");
701 assert_eq!(a("1", Eur, Uk), "Одне євро 00 центів");
702 assert_eq!(a("1000", Eur, Lt), "Vienas tūkstantis eurų 00 centų");
703 assert_eq!(a("2.02", Uah, Lt), "Dvi grivinos 02 kapeikos");
704 assert_eq!(a("1001", Usd, En), "One thousand one dollars and 00 cents");
705 assert_eq!(a("1000000", Eur, Fr), "Un million d'euros et 00 centimes");
706 assert_eq!(a("80", Eur, Fr), "Quatre-vingts euros et 00 centimes");
707 assert_eq!(a("-5,5", Eur, Ru), "Минус пять евро 50 центов");
708 assert_eq!(a("99.995", Usd, En), "One hundred dollars and 00 cents");
709 }
710
711 #[test]
712 fn numbers() {
713 assert_eq!(number_in_words(2000, Lang::Uk, Gender::Masculine).unwrap(), "дві тисячі");
714 assert_eq!(number_in_words(80_000, Lang::Fr, Gender::Masculine).unwrap(), "quatre-vingt mille");
715 assert_eq!(number_in_words(0, Lang::Lt, Gender::Masculine).unwrap(), "nulis");
716 assert_eq!(number_in_words(1_000_000_000_000_000, Lang::Ru, Gender::Masculine), Err(Error::TooLarge));
717 }
718
719 #[test]
720 fn errors() {
721 assert!(amount_in_words("12a", Currency::Eur, Lang::Ru).is_err());
722 assert!(amount_in_words("", Currency::Eur, Lang::Ru).is_err());
723 assert!("JPY".parse::<Currency>().is_err());
724 assert_eq!("lt".parse::<Lang>().unwrap(), Lang::Lt);
725 }
726}