refactor: optimize error handling

Change error handling to result instead of simple string, which is more
standardized and can handle more types of errors.

Author: GavZheng

src/base/text/decode.rs

@@ -1,60 +1,55 @@
-pub fn base16_decode(input: &str) -> String {
-    const BASE16_CHARS: &str = "0123456789abcdef";
-    let mut char_to_index = [255; 256];
-    for (i, c) in BASE16_CHARS.chars().enumerate() {
+pub fn base16_decode(input: &str) -> Result<String, String> {
+    const BASE16_CHARS: &[u8] = b"0123456789abcdef";
+    let mut char_to_index = [255u8; 256];
+    for (i, &c) in BASE16_CHARS.iter().enumerate() {
         char_to_index[c as usize] = (i % 16) as u8;
     }
 
     if input.len() % 2 != 0 {
-        return String::from("Invalid base16 input: length is not even");
+        return Err("Invalid base16 input: length is not even".to_string());
     }
 
-    let mut result = Vec::new();
+    let mut result = Vec::with_capacity(input.len() / 2);
 
     for (i, chunk) in input.as_bytes().chunks(2).enumerate() {
         if chunk.len() != 2 {
-            return format!(
+            return Err(format!(
                 "Invalid base16 input: chunk at index {} has invalid length",
                 i * 2
-            );
+            ));
         }
 
-        let high_nibble = match char_to_index[chunk[0] as usize] {
-            0..=15 => char_to_index[chunk[0] as usize],
-            _ => {
-                return format!(
-                    "Invalid base16 input: invalid character '{}' at index {}",
-                    char::from(chunk[0]),
-                    i * 2
-                )
-            }
-        };
-
-        let low_nibble = match char_to_index[chunk[1] as usize] {
-            0..=15 => char_to_index[chunk[1] as usize],
-            _ => {
-                return format!(
-                    "Invalid base16 input: invalid character '{}' at index {}",
-                    char::from(chunk[1]),
-                    i * 2 + 1
-                )
-            }
-        };
+        let high_nibble = char_to_index[chunk[0] as usize];
+        if high_nibble == 255 {
+            return Err(format!(
+                "Invalid base16 input: invalid character '{}' at index {}",
+                char::from(chunk[0]),
+                i * 2
+            ));
+        }
+
+        let low_nibble = char_to_index[chunk[1] as usize];
+        if low_nibble == 255 {
+            return Err(format!(
+                "Invalid base16 input: invalid character '{}' at index {}",
+                char::from(chunk[1]),
+                i * 2 + 1
+            ));
+        }
 
         let byte = (high_nibble << 4) | low_nibble;
         result.push(byte);
     }
 
-    String::from_utf8(result)
-        .unwrap_or_else(|_| String::from("Invalid UTF-8 sequence in decoded data"))
+    String::from_utf8(result).map_err(|_| "Invalid UTF-8 sequence in decoded data".to_string())
 }
 
-pub fn base64_decode(input: &str) -> String {
-    const BASE64_CHARS: &str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+pub fn base64_decode(input: &str) -> Result<String, String> {
+    const BASE64_CHARS: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
     let mut result = Vec::new();
 
     if input.len() % 4 != 0 {
-        return String::from("Invalid Base64 input.");
+        return Err("Invalid Base64 input: length not divisible by 4".to_string());
     }
 
     let chunks: Vec<_> = input.as_bytes().chunks(4).collect();
@@ -63,7 +58,7 @@ pub fn base64_decode(input: &str) -> String {
         let is_last_chunk = chunk_idx == chunks.len() - 1;
 
         if chunk.len() != 4 {
-            return String::from("Invalid Base64 input.");
+            return Err("Invalid Base64 input: incomplete chunk".to_string());
         }
 
         let mut values = [0u8; 4];
@@ -74,31 +69,27 @@ pub fn base64_decode(input: &str) -> String {
 
             if c == '=' {
                 if !is_last_chunk || i < 2 {
-                    return String::from("Invalid Base64 input.");
+                    return Err("Invalid Base64 padding".to_string());
                 }
                 pad_count += 1;
                 values[i] = 0;
             } else {
-                match BASE64_CHARS.find(c) {
+                match BASE64_CHARS.iter().position(|&b| b == byte) {
                     Some(idx) => values[i] = idx as u8,
-                    None => return String::from("Invalid Base64 input."),
-                }
-
-                if is_last_chunk && pad_count > 0 {
-                    return String::from("Invalid Base64 input.");
+                    None => return Err(format!("Invalid Base64 character: '{}'", c)),
                 }
             }
         }
 
         if pad_count > 2 {
-            return String::from("Invalid Base64 input.");
+            return Err("Too many padding characters".to_string());
         }
 
         if is_last_chunk {
             match pad_count {
-                1 if chunk[3] != b'=' => return String::from("Invalid Base64 input."),
+                1 if chunk[3] != b'=' => return Err("Invalid padding position".to_string()),
                 2 if chunk[2] != b'=' || chunk[3] != b'=' => {
-                    return String::from("Invalid Base64 input.")
+                    return Err("Invalid padding position".to_string())
                 }
                 _ => (),
             }
@@ -117,12 +108,9 @@ pub fn base64_decode(input: &str) -> String {
         }
     }
 
-    String::from_utf8(result)
-        .unwrap_or_else(|_| String::from("Invalid UTF-8 sequence in decoded data"))
+    String::from_utf8(result).map_err(|_| "Invalid UTF-8 sequence in decoded data".to_string())
 }
 
-pub fn text_decode(input: &str) -> [String; 2] {
-    let base16 = base16_decode(input);
-    let base64 = base64_decode(input);
-    [base16, base64]
+pub fn text_decode(input: &str) -> [Result<String, String>; 2] {
+    [base16_decode(input), base64_decode(input)]
 }

src/base/text/encode.rs

@@ -1,4 +1,6 @@
-pub fn base16_encode(input: &str) -> String {
+use std::string::FromUtf8Error;
+
+pub fn base16_encode(input: &str) -> Result<String, FromUtf8Error> {
     const BASE16_CHARS: &[u8] = b"0123456789abcdef";
 
     let bytes = input.as_bytes();
@@ -9,10 +11,10 @@ pub fn base16_encode(input: &str) -> String {
         result.push(BASE16_CHARS[(byte & 0x0F) as usize]);
     }
 
-    String::from_utf8(result).unwrap()
+    String::from_utf8(result)
 }
 
-pub fn base64_encode(input: &str) -> String {
+pub fn base64_encode(input: &str) -> Result<String, FromUtf8Error> {
     const BASE64_CHARS: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
     let bytes = input.as_bytes();
     let mut result = Vec::with_capacity(((bytes.len() + 2) / 3) * 4);
@@ -52,11 +54,11 @@ pub fn base64_encode(input: &str) -> String {
         }
     }
 
-    String::from_utf8_lossy(&result).to_string()
+    String::from_utf8(result)
 }
 
-pub fn text_encode(input: &str) -> [String; 2] {
-    let base16 = base16_encode(input);
-    let base64 = base64_encode(input);
-    [base16, base64]
+pub fn text_encode(input: &str) -> Result<[String; 2], FromUtf8Error> {
+    let base16 = base16_encode(input)?;
+    let base64 = base64_encode(input)?;
+    Ok([base16, base64])
 }

src/base/text/test.rs

@@ -1,72 +1,94 @@
 #[cfg(test)]
 mod tests {
-    use crate::base;
+    use crate::base::text::decode::{base16_decode, base64_decode, text_decode};
+    use crate::base::text::encode::{base16_encode, base64_encode, text_encode};
+
+    #[test]
+    fn test_base16_encode() {
+        assert_eq!(base16_encode("wutong").unwrap(), "7775746f6e67");
+        assert_eq!(base16_encode("WUTONG").unwrap(), "5755544f4e47");
+        assert_eq!(base16_encode("1234567890").unwrap(), "31323334353637383930");
+        assert_eq!(base16_encode("").unwrap(), "");
+    }
+
+    #[test]
+    fn test_base64_encode() {
+        assert_eq!(base64_encode("wutong").unwrap(), "d3V0b25n");
+        assert_eq!(base64_encode("WUTONG").unwrap(), "V1VUT05H");
+        assert_eq!(base64_encode("1234567890").unwrap(), "MTIzNDU2Nzg5MA==");
+        assert_eq!(base64_encode("").unwrap(), "");
+    }
 
     #[test]
     fn test_base16_decode() {
-        assert_eq!(
-            base::text::decode::base16_decode("7775746f6e67"),
-            "wutong".to_string()
-        );
-        assert_eq!(
-            base::text::decode::base16_decode("5755544f4e47"),
-            "WUTONG".to_string()
-        );
-        assert_eq!(
-            base::text::decode::base16_decode("31323334353637383930"),
-            "1234567890".to_string()
-        );
-        assert_eq!(base::text::decode::base16_decode(""), "".to_string());
+        assert_eq!(base16_decode("7775746f6e67").unwrap(), "wutong");
+        assert_eq!(base16_decode("5755544f4e47").unwrap(), "WUTONG");
+        assert_eq!(base16_decode("31323334353637383930").unwrap(), "1234567890");
+        assert_eq!(base16_decode("").unwrap(), "");
+        assert!(base16_decode("123").is_err());
+        assert!(base16_decode("12345").is_err());
+        assert!(base16_decode("123G").is_err());
     }
 
     #[test]
     fn test_base64_decode() {
-        assert_eq!(
-            base::text::decode::base64_decode("d3V0b25n"),
-            "wutong".to_string()
-        );
-        assert_eq!(
-            base::text::decode::base64_decode("V1VUT05H"),
-            "WUTONG".to_string()
-        );
-        assert_eq!(
-            base::text::decode::base64_decode("MTIzNDU2Nzg5MA=="),
-            "1234567890".to_string()
-        );
-        assert_eq!(base::text::decode::base64_decode(""), "".to_string());
+        assert_eq!(base64_decode("d3V0b25n").unwrap(), "wutong");
+        assert_eq!(base64_decode("V1VUT05H").unwrap(), "WUTONG");
+        assert_eq!(base64_decode("MTIzNDU2Nzg5MA==").unwrap(), "1234567890");
+        assert_eq!(base64_decode("").unwrap(), "");
+        assert!(base64_decode("ABC").is_err());
+        assert!(base64_decode("ABCD==").is_err());
+        assert!(base64_decode("ABCD=").is_err());
+        assert!(base64_decode("ABCG").is_err());
     }
 
     #[test]
-    fn test_base16_encode() {
-        assert_eq!(
-            base::text::encode::base16_encode("wutong"),
-            "7775746f6e67".to_string()
-        );
-        assert_eq!(
-            base::text::encode::base16_encode("WUTONG"),
-            "5755544f4e47".to_string()
-        );
-        assert_eq!(
-            base::text::encode::base16_encode("1234567890"),
-            "31323334353637383930".to_string()
-        );
-        assert_eq!(base::text::encode::base16_encode(""), "".to_string());
+    fn test_text_encode() {
+        let [base16, base64] = text_encode("wutong").unwrap();
+        assert_eq!(base16, "7775746f6e67");
+        assert_eq!(base64, "d3V0b25n");
+
+        let [base16, base64] = text_encode("WUTONG").unwrap();
+        assert_eq!(base16, "5755544f4e47");
+        assert_eq!(base64, "V1VUT05H");
+
+        let [base16, base64] = text_encode("1234567890").unwrap();
+        assert_eq!(base16, "31323334353637383930");
+        assert_eq!(base64, "MTIzNDU2Nzg5MA==");
+
+        let [base16, base64] = text_encode("").unwrap();
+        assert_eq!(base16, "");
+        assert_eq!(base64, "");
     }
 
     #[test]
-    fn test_base64_encode() {
-        assert_eq!(
-            base::text::encode::base64_encode("wutong"),
-            "d3V0b25n".to_string()
-        );
-        assert_eq!(
-            base::text::encode::base64_encode("WUTONG"),
-            "V1VUT05H".to_string()
-        );
-        assert_eq!(
-            base::text::encode::base64_encode("1234567890"),
-            "MTIzNDU2Nzg5MA==".to_string()
-        );
-        assert_eq!(base::text::encode::base64_encode(""), "".to_string());
+    fn test_text_decode() {
+        let [base16_res, base64_res] = text_decode("7775746f6e67");
+        assert_eq!(base16_res.unwrap(), "wutong");
+        assert!(base64_res.is_err());
+
+        let [base16_res, base64_res] = text_decode("d3V0b25n");
+        assert!(base16_res.is_err());
+        assert_eq!(base64_res.unwrap(), "wutong");
+
+        let [base16_res, base64_res] = text_decode("5755544f4e47");
+        assert_eq!(base16_res.unwrap(), "WUTONG");
+        assert!(base64_res.is_err());
+
+        let [base16_res, base64_res] = text_decode("V1VUT05H");
+        assert!(base16_res.is_err());
+        assert_eq!(base64_res.unwrap(), "WUTONG");
+
+        let [base16_res, base64_res] = text_decode("31323334353637383930");
+        assert_eq!(base16_res.unwrap(), "1234567890");
+        assert!(base64_res.is_err());
+
+        let [base16_res, base64_res] = text_decode("MTIzNDU2Nzg5MA==");
+        assert!(base16_res.is_err());
+        assert_eq!(base64_res.unwrap(), "1234567890");
+
+        let [base16_res, base64_res] = text_decode("");
+        assert_eq!(base16_res.unwrap(), "");
+        assert_eq!(base64_res.unwrap(), "");
     }
 }

src/base_conversion/math.rs

@@ -1,27 +1,38 @@
-pub fn binary(input: &str) -> [String; 3] {
+use std::num::ParseIntError;
+
+pub fn binary(input: &str) -> Result<[String; 3], ParseIntError> {
     convert_base(input, 2, [8, 10, 16])
 }
 
-pub fn octal(input: &str) -> [String; 3] {
+pub fn octal(input: &str) -> Result<[String; 3], ParseIntError> {
     convert_base(input, 8, [2, 10, 16])
 }
 
-pub fn decimal(input: &str) -> [String; 3] {
+pub fn decimal(input: &str) -> Result<[String; 3], ParseIntError> {
     convert_base(input, 10, [2, 8, 16])
 }
 
-pub fn hexadecimal(input: &str) -> [String; 3] {
+pub fn hexadecimal(input: &str) -> Result<[String; 3], ParseIntError> {
     convert_base(input, 16, [2, 8, 10])
 }
 
-fn convert_base(input: &str, input_radix: u32, output_radixes: [u32; 3]) -> [String; 3] {
-    let value = u64::from_str_radix(input, input_radix).unwrap_or(0);
+fn convert_base(
+    input: &str,
+    input_radix: u32,
+    output_radixes: [u32; 3],
+) -> Result<[String; 3], ParseIntError> {
+    let value = u64::from_str_radix(input, input_radix)?;
+    let mut results = [String::new(), String::new(), String::new()];
+
+    for (i, radix) in output_radixes.iter().copied().enumerate() {
+        results[i] = match radix {
+            2 => format!("{:b}", value),
+            8 => format!("{:o}", value),
+            10 => value.to_string(),
+            16 => format!("{:x}", value),
+            _ => unreachable!(),
+        };
+    }
 
-    output_radixes.map(|radix| match radix {
-        2 => format!("{:b}", value),
-        8 => format!("{:o}", value),
-        10 => value.to_string(),
-        16 => format!("{:x}", value),
-        _ => unreachable!(),
-    })
+    Ok(results)
 }