Removed the struct

src/lib.rs

@@ -1,20 +1,7 @@
-#[allow(dead_code)]
-pub struct NumText {
-    number: u32,
-    text: String,
-}
-
-#[allow(dead_code, unused_variables)]
-impl NumText {
-    fn new(number: u32) -> Self {
-        NumText {
-            number,
-            text: NumText::to_text(number),
-        }
-    }
-    fn digit_to_text(digit: u8) -> Option<String> {
+mod test;
+/// Convert digit to text.
+pub fn digit_to_text(digit: u8) -> Option<String> {
     match digit {
-            // 0 => Some("zero".to_string()),
         0 => Some("".to_string()),
         1 => Some("one".to_string()),
         2 => Some("two".to_string()),
@@ -27,11 +14,11 @@ impl NumText {
         9 => Some("nine".to_string()),
         _ => None,
     }
-    }
+}
 
-    fn tens_place(tens: u8, ones: u8) -> Option<String> {
+fn tens_place(tens: u8, ones: u8) -> Option<String> {
     match tens {
-            0 => NumText::digit_to_text(ones),
+        0 => digit_to_text(ones),
         1 => match ones {
             0 => Some("ten".to_string()),
             1 => Some("eleven".to_string()),
@@ -55,21 +42,21 @@ impl NumText {
                 8 => buffer.push_str("eighty"),
                 _ => (),
             }
-                buffer.push_str(NumText::digit_to_text(ones).unwrap().as_str());
+            buffer.push_str(digit_to_text(ones).unwrap().as_str());
             buffer
         }),
         d @ 6..=9 => Some({
-                let mut string = NumText::digit_to_text(d).unwrap() + "ty";
-                string.push_str(NumText::digit_to_text(ones).unwrap().as_str());
+            let mut string = digit_to_text(d).unwrap() + "ty";
+            string.push_str(digit_to_text(ones).unwrap().as_str());
             string
         }),
         _ => None,
     }
-    }
-    fn place_value(number: u8, place: u8) -> Option<String> {
+}
+fn place_value(number: u8, place: u8) -> Option<String> {
     match place {
         p @ 3..=6 => Some({
-                let mut value = Self::digit_to_text(number).unwrap();
+            let mut value = digit_to_text(number).unwrap();
             match p {
                 3 => value.push_str("hundred"),
                 4 => value.push_str("thousand"),
@@ -81,9 +68,9 @@ impl NumText {
         }),
         _ => None,
     }
-    }
-
-    fn to_text(number: u32) -> String {
+}
+/// Convert u32 to words in a string.
+pub fn to_text(number: u32) -> String {
     let mut numtext: String = String::new();
     let digits: Vec<u8> = number
         .to_string()
@@ -99,57 +86,20 @@ impl NumText {
         }
         if let Some(last_digit) = last {
             let mut buffer = String::new();
-                buffer.push_str(
-                    Self::tens_place(digit.clone(), last_digit)
-                        .unwrap()
-                        .as_str(),
-                );
+            buffer.push_str(tens_place(digit.clone(), last_digit).unwrap().as_str());
             if index > 2 {
-                    buffer.push_str(Self::place_value(0, index as u8).unwrap().as_str());
+                buffer.push_str(place_value(0, index as u8).unwrap().as_str());
             }
             numtext.insert_str(0, buffer.as_str());
             last = None;
         } else {
             numtext.insert_str(
                 0,
-                    Self::place_value(digit.clone(), index as u8 + 1)
+                place_value(digit.clone(), index as u8 + 1)
                     .unwrap()
                     .as_str(),
             )
         }
     }
     numtext
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn digits() {
-        use crate::NumText;
-        assert_eq!(NumText::digit_to_text(9).unwrap(), "nine");
-    }
-    #[test]
-    fn numbers() {
-        use crate::NumText;
-        assert_eq!(
-            NumText::to_text(12345),
-            "twelvethousandthreehundredfortyfive"
-        );
-        assert_eq!(
-            NumText::to_text(81123),
-            "eightyonethousandonehundredtwentythree"
-        );
-        assert_eq!(NumText::to_text(12), "twelve");
-    }
-    #[test]
-    fn tens() {
-        use crate::NumText;
-        assert_eq!(NumText::tens_place(1, 2).unwrap(), "twelve");
-        assert_eq!(NumText::tens_place(7, 6).unwrap(), "seventysix");
-        assert_eq!(NumText::tens_place(5, 7).unwrap(), "fiftyseven");
-        assert_eq!(NumText::tens_place(2, 3).unwrap(), "twentythree");
-        assert_eq!(NumText::tens_place(6, 9).unwrap(), "sixtynine");
-        assert_eq!(NumText::tens_place(0, 9).unwrap(), "nine");
-    }
 }

src/test.rs

@@ -0,0 +1,25 @@
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn digits() {
+        use crate::digit_to_text;
+        assert_eq!(digit_to_text(9).unwrap(), "nine");
+    }
+    #[test]
+    fn numbers() {
+        use crate::to_text;
+        assert_eq!(to_text(12345), "twelvethousandthreehundredfortyfive");
+        assert_eq!(to_text(81123), "eightyonethousandonehundredtwentythree");
+        assert_eq!(to_text(12), "twelve");
+    }
+    #[test]
+    fn tens() {
+        use crate::tens_place;
+        assert_eq!(tens_place(1, 2).unwrap(), "twelve");
+        assert_eq!(tens_place(7, 6).unwrap(), "seventysix");
+        assert_eq!(tens_place(5, 7).unwrap(), "fiftyseven");
+        assert_eq!(tens_place(2, 3).unwrap(), "twentythree");
+        assert_eq!(tens_place(6, 9).unwrap(), "sixtynine");
+        assert_eq!(tens_place(0, 9).unwrap(), "nine");
+    }
+}