feat: rename

Author: eastspire

Cargo.lock

@@ -1,13 +1,13 @@
 [package]
-name = "bin-encrypt-decrypt"
-version = "2.2.9"
+name = "bin-encode-decode"
+version = "0.0.1"
 edition = "2021"
 authors = ["ltpp-universe <root@ltpp.vip>"] 
 license = "MIT"
-description = "A high-performance binary encryption and decryption library that supports customizable character sets beyond Base64."
-keywords = ["binaryencryption", "decryption", "customcharset", "highperformance", "base64alternative"]
-repository = "https://github.com/ltpp-universe/bin-crypt-decrypt"
-categories = ["cryptography", "encoding"]
+description = "A high-performance binary encode and decode library that supports customizable character sets beyond Base64."
+keywords = ["binaryencode", "decode", "customcharset", "highperformance", "base64alternative"]
+repository = "https://github.com/ltpp-universe/bin-crypt-decode"
+categories = ["encoding"]
 
 [profile.dev]
 incremental = false

Cargo.toml

@@ -1,78 +1,81 @@
 <center>
 
-# bin-encrypt-decrypt
+# bin-encode-decode
 
-[![](https://img.shields.io/crates/v/bin-encrypt-decrypt.svg)](https://crates.io/crates/bin-encrypt-decrypt)
-[![](https://docs.rs/bin-encrypt-decrypt/badge.svg)](https://docs.rs/bin-encrypt-decrypt)
-[![](https://github.com/ltpp-universe/bin-encrypt-decrypt/workflows/Rust/badge.svg)](https://github.com/ltpp-universe/bin-encrypt-decrypt/actions?query=workflow:Rust)
-[![](https://img.shields.io/crates/l/bin-encrypt-decrypt.svg)](./LICENSE)
+[![](https://img.shields.io/crates/v/bin-encode-decode.svg)](https://crates.io/crates/bin-encode-decode)
+[![](https://docs.rs/bin-encode-decode/badge.svg)](https://docs.rs/bin-encode-decode)
+[![](https://github.com/ltpp-universe/bin-encode-decode/workflows/Rust/badge.svg)](https://github.com/ltpp-universe/bin-encode-decode/actions?query=workflow:Rust)
+[![](https://img.shields.io/crates/l/bin-encode-decode.svg)](./LICENSE)
 
 </center>
 
-[Official Documentation](https://docs.ltpp.vip/BIN-ENCRYPT-DECRYPT/)
+[Official Documentation](https://docs.ltpp.vip/bin-encode-decode/)
 
-A high-performance binary encryption and decryption library that supports customizable character sets beyond Base64.
+A high-performance binary encode and decode library that supports customizable character sets beyond Base64.
 
 ## Features
 
 - **Custom Character Sets**: Define your own character set for encoding and decoding, allowing for flexible data representation.
 - **High Performance**: Optimized for speed, making it suitable for applications requiring efficient cryptographic operations.
-- **Simple API**: Intuitive and easy-to-use interface for both encryption and decryption processes.
+- **Simple API**: Intuitive and easy-to-use interface for both encode and decode processes.
 - **Robust Error Handling**: Provides clear and descriptive error messages to facilitate debugging.
 - **Extensive Documentation**: Comprehensive guides and examples to help you get started quickly.
 
 ## Installation
 
-To install `bin-encrypt-decrypt` run cmd:
+To install `bin-encode-decode` run cmd:
 
 ```sh
-cargo add bin-encrypt-decrypt
+cargo add bin-encode-decode
 ```
 
 ## Usage
 
-### Encrypt
+### encode
 
 #### Use Struct
 
 ```rust
-use bin_encrypt_decrypt::*;
-let mut crypt_decrypt: CryptDecrypt<'_> = CryptDecrypt::new();
+use bin_encode_decode::*;
+let mut en_decode: Endecode<'_> = Endecode::new();
 let test_str: &str = "test";
 let mut charset: String = String::from("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_=");
-crypt_decrypt.charset(&charset);
-let encode: Result<String, CryptError> = crypt_decrypt.encrypt(test_str);
+en_decode.charset(&charset);
+let encode: Result<String, EncodeError> = en_decode.encode(test_str);
 ```
 
 #### Use Function
 
 ```rust
-use bin_encrypt_decrypt::*;
+use bin_encode_decode::*;
 let test_str: &str = "test";
 let mut charset: String = String::from("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_=");
-let encode: Result<String, CryptError> = encrypt(&charset, test_str);
+let encode: Result<String, EncodeError> = encode(&charset, test_str);
 ```
 
-### Decrypt
+### decode
 
 #### Use Struct
 
 ```rust
-use bin_encrypt_decrypt::*;
-let mut crypt_decrypt: CryptDecrypt<'_> = CryptDecrypt::new();
+use bin_encode_decode::*;
+let mut en_decode: Endecode<'_> = Endecode::new();
 let test_str: &str = "aab0aabLaabZaab0";
 let mut charset: String = String::from("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_=");
-crypt_decrypt.charset(&charset);
-let decode: Result<String, DecryptError> = crypt_decrypt.decrypt(test_str);
+en_decode.charset(&charset);
+let decode: Result<String, DecodeError> = en_decode.decode(test_str);
 ```
 
 #### Use Function
 
 ```rust
-use bin_encrypt_decrypt::*;
-let test_str: &str = "aab0aabLaabZaab0";
-let mut charset: String = String::from("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_=");
-let decode: Result<String, DecryptError> = decrypt(&charset, test_str);
+use bin_encode_decode::*;
+let charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_=";
+let encoded_str = "aab0aabLaabZaab0";
+let decoded_str = decode(charset, encoded_str);
+let charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_=";
+let original_str = "test";
+let encoded_str = encode(charset, original_str);
 ```
 
 ## License

readme.md

@@ -1,8 +1,8 @@
 use crate::*;
 
 #[test]
-fn test_crypt_decrypt() {
-    let mut crypt_decrypt: CryptDecrypt<'_> = CryptDecrypt::new();
+fn test_crypt_decode() {
+    let mut en_decode: Endecode<'_> = Endecode::new();
     let test_str: &str = "test";
     let mut charset: String = String::new();
     for i in 0..26 {
@@ -18,8 +18,8 @@ fn test_crypt_decrypt() {
         charset.push(ch);
     }
     charset.push_str("_=");
-    crypt_decrypt.charset(&charset);
-    let encode: Result<String, CryptError> = crypt_decrypt.encrypt(test_str);
-    let decode: Result<String, DecryptError> = crypt_decrypt.decrypt(&encode.clone().unwrap());
+    en_decode.charset(&charset);
+    let encode: Result<String, EncodeError> = en_decode.encode(test_str);
+    let decode: Result<String, DecodeError> = en_decode.decode(&encode.clone().unwrap());
     assert_eq!(decode.unwrap(), test_str);
 }

src/crypt_decrypt/cfg.rs src/common/cfg.rssrc/crypt_decrypt/cfg.rs renamed to src/common/cfg.rs

@@ -1,29 +1,29 @@
 use crate::*;
 
 #[derive(Debug, Clone)]
-pub enum CryptError {
+pub enum EncodeError {
     CharsetError,
 }
 
-impl fmt::Display for CryptError {
+impl fmt::Display for EncodeError {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            CryptError::CharsetError => write!(f, "CryptError: Charset is invalid. Please ensure the charset contains exactly {} unique characters.",CHARSET_LEN ),
+            EncodeError::CharsetError => write!(f, "EncodeError: Charset is invalid. Please ensure the charset contains exactly {} unique characters.",CHARSET_LEN ),
         }
     }
 }
 
 #[derive(Debug, Clone)]
-pub enum DecryptError {
+pub enum DecodeError {
     CharsetError,
 }
 
-impl fmt::Display for DecryptError {
+impl fmt::Display for DecodeError {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            DecryptError::CharsetError => write!(f, "CryptError: Charset is invalid. Please ensure the charset contains exactly {} unique characters.", CHARSET_LEN),
+            DecodeError::CharsetError => write!(f, "DecodeError: Charset is invalid. Please ensure the charset contains exactly {} unique characters.", CHARSET_LEN),
         }
     }
 }

src/crypt_decrypt/error.rs src/common/error.rssrc/crypt_decrypt/error.rs renamed to src/common/error.rs

@@ -1,17 +1,17 @@
 use crate::*;
 
-impl<'a> Default for CryptDecrypt<'a> {
+impl<'a> Default for Endecode<'a> {
     #[inline]
     fn default() -> Self {
-        CryptDecrypt { charset: "" }
+        Endecode { charset: "" }
     }
 }
 
-impl<'a> CryptDecrypt<'a> {
-    /// Creates a new instance of `CryptDecrypt` with a default charset.
+impl<'a> Endecode<'a> {
+    /// Creates a new instance of `Endecode` with a default charset.
     #[inline]
     pub fn new() -> Self {
-        CryptDecrypt::default()
+        Endecode::default()
     }
 
     /// Checks if the `charset` contains `CHARSET_LEN` unique characters.
@@ -30,7 +30,7 @@ impl<'a> CryptDecrypt<'a> {
         true
     }
 
-    /// Sets the `charset` for the current `CryptDecrypt` instance, if it is not already set.
+    /// Sets the `charset` for the current `Endecode` instance, if it is not already set.
     ///
     /// # Parameters
     /// - `charset`: A string slice representing the charset to be used.
@@ -42,34 +42,34 @@ impl<'a> CryptDecrypt<'a> {
     where
         'b: 'a,
     {
-        if self.charset != CryptDecrypt::default().charset {
+        if self.charset != Endecode::default().charset {
             return self;
         }
         self.charset = charset;
         self
     }
 
-    /// Encrypts a string based on the current `charset`.
+    /// encodes a string based on the current `charset`.
     ///
     /// # Parameters
-    /// - `encode_str`: The string slice to be encrypted.
+    /// - `encode_str`: The string slice to be encodeed.
     ///
     /// # Returns
-    /// Returns a `Result` containing the encrypted `String` if successful, or a `CryptError` if the charset is invalid.
+    /// Returns a `Result` containing the encodeed `String` if successful, or a `EncodeError` if the charset is invalid.
     #[inline]
-    pub fn encrypt(&self, encode_str: &str) -> Result<String, CryptError> {
-        encrypt(self.charset, encode_str)
+    pub fn encode(&self, encode_str: &str) -> Result<String, EncodeError> {
+        encode(self.charset, encode_str)
     }
 
-    /// Decrypts a string based on the current `charset`.
+    /// decodes a string based on the current `charset`.
     ///
     /// # Parameters
-    /// - `decode_str`: The string slice to be decrypted.
+    /// - `decode_str`: The string slice to be decodeed.
     ///
     /// # Returns
-    /// Returns a `Result` containing the decrypted `String` if successful, or a `DecryptError` if the charset is invalid.
+    /// Returns a `Result` containing the decodeed `String` if successful, or a `DecodeError` if the charset is invalid.
     #[inline]
-    pub fn decrypt(&self, decode_str: &str) -> Result<String, DecryptError> {
-        decrypt(self.charset, decode_str)
+    pub fn decode(&self, decode_str: &str) -> Result<String, DecodeError> {
+        decode(self.charset, decode_str)
     }
 }

src/crypt_decrypt/impl.rs src/common/impl.rssrc/crypt_decrypt/impl.rs renamed to src/common/impl.rs

@@ -1,6 +1,6 @@
-/// Represents a struct for handling both encryption and decryption of strings
+/// Represents a struct for handling both encode and decode of strings
 /// using a custom character set (`charset`). This struct provides methods to
-/// encrypt and decrypt strings based on the provided `charset`.
+/// encode and decode strings based on the provided `charset`.
 ///
 /// # Fields
 /// - `charset`: A reference to the character set used for encoding and decoding.
@@ -9,8 +9,8 @@
 ///
 /// # Lifetimes
 /// - `'a`: The lifetime `'a` is associated with `charset`, ensuring that the `charset` reference
-///   lives at least as long as the `CryptDecrypt` instance.
+///   lives at least as long as the `Endecode` instance.
 #[derive(Debug, Clone)]
-pub struct CryptDecrypt<'a> {
+pub struct Endecode<'a> {
     pub(crate) charset: &'a str,
 }

src/crypt_decrypt/mod.rs src/common/mod.rssrc/crypt_decrypt/mod.rs renamed to src/common/mod.rs

@@ -1,7 +1,7 @@
 use crate::*;
 
 #[test]
-fn test_decrypt() {
+fn test_decode() {
     let mut charset: String = String::new();
     for i in 0..26 {
         let ch: char = ('a' as u8 + i) as char;
@@ -16,6 +16,6 @@ fn test_decrypt() {
         charset.push(ch);
     }
     charset.push_str("_=");
-    let encode_res: Result<String, DecryptError> = decrypt(&charset, "aab0aabLaabZaab0");
+    let encode_res: Result<String, DecodeError> = decode(&charset, "aab0aabLaabZaab0");
     assert_eq!(encode_res.unwrap(), "test");
 }