Merge branch 'release/0.1.0-beta'

Author: GavZheng

README.md

@@ -26,12 +26,13 @@ In our daily project development, we frequently encounter situations where we ne
 ## How to Install Wutong
 > [!NOTE]  
 > During the test phase, Wutong does not provide installation methods. If you wish to experience it, please compile it yourself. Upon the release of the official version, Wutong will provide installation methods.
+> Version 0.1.0 we will launch Wutong at HomeBrew
 
 ---
 
 ## How to Use Wutong
 You can obtain detailed information by typing `wutong --help` in the command line.  
-The general functions of Wutong are listed below (v0.1.0-alpha):
+The general functions of Wutong are listed below (v0.1.0-beta):
 
 | Function | Description                                                  |
 |----------|--------------------------------------------------------------|

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(), "");
     }
 }