Ukrainian language support

.gitignore

@@ -1,2 +1,3 @@
 /target
 Cargo.lock
+/.vscode

README.md

@@ -77,9 +77,10 @@ $ num2words --help
 
 Here is a list of all of the supported languages:
 
-| Flag | Code            | ISO 639-1 | Language | 42        |
-| ---- | --------------- | --------- | -------- | --------- |
-| 🇺🇸🇬🇧 | `Lang::English` | `en`      | English  | forty-two |
+| Flag | Code              | ISO 639-1 | Language   | 42        |
+| ---- | ----------------- | --------- | ---------- | --------- |
+| 🇺🇸🇬🇧 | `Lang::English`   | `en`      | English    | forty-two |
+| 🇺🇦   | `Lang::Ukrainian` | `ua`      | Ukrainian  | сорок два |
 
 This list can be expanded! Contributions are welcomed.
 

src/bin/bin.rs

@@ -22,6 +22,7 @@ GLOBAL OPTIONS:
 
 AVAILABLE LANGUAGES:
     en: English
+    uk: Ukrainian
 
 AVAILABLE OUTPUTS:
     cardinal:      forty-two (42)
@@ -38,7 +39,7 @@ fn get_version() -> String {
     let version = env!("CARGO_PKG_VERSION");
     let mut words = vec![];
 
-    for num in version.split(".") {
+    for num in version.split('.') {
         if let Ok(i) = String::from(num).parse::<i64>() {
             if let Ok(word) = Num2Words::new(i).prefer("oh").to_words() {
                 words.push(word);
@@ -55,69 +56,66 @@ fn help() {
 
 fn handle_cmd(n: String, mut args: std::env::Args) {
     if let Some(mut num) = Num2Words::parse(&n) {
-        loop {
-            match args.next() {
-                Some(arg) => match arg.as_str() {
-                    "--lang" | "-l" => match args.next() {
-                        Some(l) => {
-                            if let Ok(v) = Lang::from_str(l.as_str()) {
-                                num = num.lang(v);
-                            } else {
-                                eprintln!("Error: invalid language");
-                                return;
-                            }
-                        }
-                        None => {
-                            help();
-                            return;
-                        }
-                    },
-                    "--prefer" | "-p" => match args.next() {
-                        Some(p) => num = num.prefer(p),
-                        None => {
-                            help();
+        while let Some(arg) = args.next() {
+            match arg.as_str() {
+                "--lang" | "-l" => match args.next() {
+                    Some(l) => {
+                        if let Ok(v) = Lang::from_str(l.as_str()) {
+                            num = num.lang(v);
+                        } else {
+                            eprintln!("Error: invalid language");
                             return;
                         }
-                    },
-                    "--to" | "-t" => match args.next() {
-                        Some(t) => {
-                            if let Ok(v) = Currency::from_str(t.as_str()) {
-                                num = num.currency(v);
-                            } else {
-                                match t.as_str() {
-                                    "cardinal" => {
-                                        num = num.cardinal();
-                                    }
-                                    "ordinal" => {
-                                        num = num.ordinal();
-                                    }
-                                    "ordinal_num" => {
-                                        num = num.ordinal_num();
-                                    }
-                                    "year" => {
-                                        num = num.year();
-                                    }
-                                    _ => {
-                                        eprintln!("Error: invalid to tag");
-                                        return;
-                                    }
+                    }
+                    None => {
+                        help();
+                        return;
+                    }
+                },
+                "--prefer" | "-p" => match args.next() {
+                    Some(p) => num = num.prefer(p),
+                    None => {
+                        help();
+                        return;
+                    }
+                },
+                "--to" | "-t" => match args.next() {
+                    Some(t) => {
+                        if let Ok(v) = Currency::from_str(t.as_str()) {
+                            num = num.currency(v);
+                        } else {
+                            match t.as_str() {
+                                "cardinal" => {
+                                    num = num.cardinal();
+                                }
+                                "ordinal" => {
+                                    num = num.ordinal();
+                                }
+                                "ordinal_num" => {
+                                    num = num.ordinal_num();
+                                }
+                                "year" => {
+                                    num = num.year();
+                                }
+                                _ => {
+                                    eprintln!("Error: invalid to tag");
+                                    return;
                                 }
                             }
                         }
-                        None => {
-                            help();
-                            return;
-                        }
-                    },
-                    _ => continue,
+                    }
+                    None => {
+                        help();
+                        return;
+                    }
                 },
-                None => break,
+                _ => continue,
             }
         }
 
         match num.to_words() {
             Ok(v) => println!("{}", v),
-            Err(err) => eprintln!("Error: {}", err.to_string()),
+            Err(err) => eprintln!("Error: {}", err),
         }
     } else {
         eprintln!("Error: cannot parse number");

src/lang/en.rs

@@ -6,15 +6,15 @@ pub struct English {
     prefer_nil: bool,
 }
 
-const UNITS: [&'static str; 9] = [
+const UNITS: [&str; 9] = [
     "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",
 ];
 
-const TENS: [&'static str; 9] = [
+const TENS: [&str; 9] = [
     "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety",
 ];
 
-const TEENS: [&'static str; 10] = [
+const TEENS: [&str; 10] = [
     "ten",
     "eleven",
     "twelve",
@@ -30,7 +30,7 @@ const TEENS: [&'static str; 10] = [
 // As defined by the AHD4, CED, RHD2, W3 and UM authorities
 // For more information, see
 // https://en.wikipedia.org/wiki/Names_of_large_numbers
-const MEGAS: [&'static str; 21] = [
+const MEGAS: [&str; 21] = [
     "thousand",
     "million",
     "billion",
@@ -247,13 +247,15 @@ impl Language for English {
     }
 
     fn to_ordinal_num(&self, num: BigFloat) -> Result<String, Num2Err> {
+        let tail = (num % BigFloat::from(100)).to_u64().unwrap();
+        let last = tail % 10;
         Ok(format!(
             "{}{}",
             num.to_u128().unwrap(),
-            match (num % BigFloat::from(10)).to_u64().unwrap() {
-                1 => "st",
-                2 => "nd",
-                3 => "rd",
+            match (tail / 10 != 1, last) {
+                (true, 1) => "st",
+                (true, 2) => "nd",
+                (true, 3) => "rd",
                 _ => "th",
             }
         ))
@@ -406,6 +408,13 @@ mod tests {
                 .to_words(),
             Ok(String::from("10th"))
         );
+        assert_eq!(
+            Num2Words::new(13)
+                .lang(Lang::English)
+                .ordinal_num()
+                .to_words(),
+            Ok(String::from("13th"))
+        );
         assert_eq!(
             Num2Words::new(21)
                 .lang(Lang::English)
@@ -607,7 +616,7 @@ mod tests {
                     .lang(Lang::English)
                     .cardinal()
                     .to_words(),
-                Ok(String::from(format!("one {}", m)))
+                Ok(format!("one {}", m))
             );
         }
 

src/lang/lang.rs

@@ -23,6 +23,7 @@ pub enum Lang {
     /// );
     /// ```
     English,
+    Ukrainian,
 }
 
 impl FromStr for Lang {
@@ -31,12 +32,14 @@ impl FromStr for Lang {
     /// Parses a string to return a value of this type
     ///
     ///
-    /// | ISO 639-1 | Lang            | 42        |
-    /// | --------- | --------------- | --------- |
-    /// | `en`      | `Lang::English` | forty-two |
+    /// | ISO 639-1 | Lang              | 42        |
+    /// | --------- | ----------------- | --------- |
+    /// | `en`      | `Lang::English`   | forty-two |
+    /// | `uk`      | `Lang::Ukrainian` | сорок два |
     fn from_str(input: &str) -> Result<Self, Self::Err> {
         match input {
             "en" => Ok(Self::English),
+            "uk" => Ok(Self::Ukrainian),
             _ => Err(()),
         }
     }
@@ -47,14 +50,32 @@ pub fn to_language(lang: Lang, preferences: Vec<String>) -> Box<dyn Language> {
         Lang::English => {
             let last = preferences
                 .iter()
-                .filter(|v| vec!["oh", "nil"].contains(&v.as_str()))
-                .last();
+                .rev()
+                .find(|v| ["oh", "nil"].contains(&v.as_str()));
 
             if let Some(v) = last {
                 return Box::new(lang::English::new(v == "oh", v == "nil"));
             }
 
             Box::new(lang::English::new(false, false))
         }
+        Lang::Ukrainian => {
+            let declension: lang::uk::Declension = preferences
+                .iter()
+                .rev()
+                .find_map(|d| d.parse().ok())
+                .unwrap_or_default();
+            let gender: lang::uk::Gender = preferences
+                .iter()
+                .rev()
+                .find_map(|d| d.parse().ok())
+                .unwrap_or_default();
+            let number: lang::uk::GrammaticalNumber = preferences
+                .iter()
+                .rev()
+                .find_map(|d| d.parse().ok())
+                .unwrap_or_default();
+            Box::new(lang::Ukrainian::new(gender, number, declension))
+        }
     }
 }

src/lang/mod.rs

@@ -1,7 +1,10 @@
 mod en;
 mod lang;
+mod uk;
 
 pub use en::English;
-pub use lang::Language;
-pub use lang::Lang;
+pub use uk::Ukrainian;
+
 pub use lang::to_language;
+pub use lang::Lang;
+pub use lang::Language;