Skip to main content

summa_propisyu/
lib.rs

1#![doc = include_str!("../README.md")]
2
3use std::fmt;
4use std::str::FromStr;
5
6/// Output language.
7#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8pub enum Lang {
9    Ru,
10    Uk,
11    Lt,
12    En,
13    Fr,
14}
15
16/// Supported currencies.
17#[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/// Grammatical gender of the counted noun (matters for ru, uk, lt).
30#[derive(Debug, Clone, Copy, PartialEq, Eq)]
31pub enum Gender {
32    Masculine,
33    Feminine,
34    /// Neuter (Russian and Ukrainian only; Lithuanian treats it as masculine).
35    Neuter,
36}
37
38/// How to write the minor unit (kopecks, cents).
39#[derive(Debug, Clone, Copy, PartialEq, Eq)]
40pub enum Minor {
41    /// `40 копеек`, the usual form in documents.
42    Digits,
43    /// `сорок копеек`.
44    Words,
45    /// Whole units only.
46    None,
47}
48
49/// Formatting options for [`amount_in_words_with`].
50#[derive(Debug, Clone, Copy, PartialEq, Eq)]
51pub struct Options {
52    pub minor: Minor,
53    /// First letter in upper case, as at the start of a sentence.
54    pub capitalize: bool,
55}
56
57impl Default for Options {
58    fn default() -> Self {
59        Options { minor: Minor::Digits, capitalize: true }
60    }
61}
62
63/// Errors returned by this crate.
64#[derive(Debug, Clone, PartialEq, Eq)]
65pub enum Error {
66    /// The amount string is not a decimal number.
67    InvalidAmount(String),
68    /// The absolute value is 10^15 or more.
69    TooLarge,
70    /// Unknown language or currency code in `FromStr`.
71    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
128// ------------------------------------------------------------ Russian, Ukrainian
129
130/// 0 = "один рубль", 1 = "два рубля", 2 = "пять рублей".
131fn 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
235// ------------------------------------------------------------ Lithuanian
236
237/// 0 = "vienas euras", 1 = "du eurai", 2 = "dešimt eurų".
238fn 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
304// ------------------------------------------------------------ English
305
306const 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
345// ------------------------------------------------------------ French
346
347const 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
353/// `last`: nothing follows inside the number, so "quatre-vingts" and "deux cents" take an s.
354fn 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                // "mille" is invariable and takes no "un"
413                if v != 1 {
414                    out.push(fr_triplet(v, false));
415                }
416                out.push("mille".to_string());
417            }
418            _ => {
419                // million, milliard, billion are nouns: "quatre-vingts millions"
420                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
428// ------------------------------------------------------------ public: numbers
429
430/// A whole number in words. `gender` matters for ru, uk and lt only.
431///
432/// ```
433/// use summa_propisyu::{number_in_words, Gender, Lang};
434/// assert_eq!(number_in_words(2, Lang::Ru, Gender::Feminine).unwrap(), "две");
435/// assert_eq!(number_in_words(91, Lang::Fr, Gender::Masculine).unwrap(), "quatre-vingt-onze");
436/// ```
437pub 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
465// ------------------------------------------------------------ currency names
466
467type Forms3 = [&'static str; 3];
468
469/// (major forms, major gender, minor forms, minor gender) for ru, uk, lt.
470fn 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
522/// (singular, plural) for major and minor units in en and fr.
523fn 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
550// ------------------------------------------------------------ public: amounts
551
552/// Parse "1521.40", "-5,5", "1 000.005" into cents, rounding half up.
553fn 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
586/// Amount in words with default options: minor units in digits, capitalized.
587///
588/// `amount` is a decimal string (`"1521.40"`, `"1521,4"`, `"-5"`). It is rounded
589/// half up to two decimals, so `"99.995"` becomes 100.00.
590pub 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
594/// Amount in words with explicit [`Options`].
595///
596/// ```
597/// use summa_propisyu::{amount_in_words_with, Currency, Lang, Minor, Options};
598/// let opts = Options { minor: Minor::Words, capitalize: true };
599/// assert_eq!(
600///     amount_in_words_with("31.31", Currency::Uah, Lang::Uk, opts).unwrap(),
601///     "Тридцять одна гривня тридцять одна копійка"
602/// );
603/// ```
604pub 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
609/// Same as [`amount_in_words_with`], but the amount is given in minor units
610/// (152140 = 1521.40). Useful when money is stored as integers.
611///
612/// # Panics
613/// If `|cents|` is 10^17 or more.
614pub 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            // "un million d'euros": a round million or milliard is a noun and needs "de"
653            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                // "zéro centime" in words, but "00 centimes" in digits reads better
664                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}