feat: v1.13.1

Author: eastspire

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lombok-macros"
-version = "1.12.2"
+version = "1.13.1"
 edition = "2024"
 authors = ["root@ltpp.vip"]
 license = "MIT"

debug/src/main.rs

@@ -4,64 +4,86 @@ use lombok_macros::*;
 use std::fmt::Debug;
 
 #[derive(Data, Debug, Clone, DisplayDebugFormat)]
-struct LombokTest<'a, 'b, T: Clone>
-where
-    T: Debug,
-{
+struct LombokTest<'a, T: Clone + Debug> {
     #[get(pub(crate))]
     #[set(pub(crate))]
     list: Vec<String>,
     #[get(pub(crate))]
-    opt_str_lifetime_a: Option<&'a T>,
-    #[set(private)]
+    opt_value: Option<&'a T>,
     #[get_mut(pub(crate))]
-    opt_str_lifetime_b: Option<&'b str>,
-    r#type: &'a str,
+    #[set(private)]
+    name: String,
 }
 
-#[derive(Data, Debug, Clone, DisplayDebugFormat)]
-struct r#type<'a, 'b, T: Clone>
-where
-    T: Debug,
-{
-    #[get(pub(crate))]
-    #[set(pub(crate))]
-    list: Vec<String>,
-    #[get(pub(crate))]
-    opt_str_lifetime_a: Option<&'a T>,
-    #[set(private)]
-    #[get_mut(pub(crate))]
-    opt_str_lifetime_b: Option<&'b str>,
-    r#type: &'a str,
+#[derive(CustomDebug)]
+struct User {
+    name: String,
+    #[debug(skip)]
+    password: String,
+    email: String,
 }
 
-impl<'a, 'b, T: Clone + Debug> LombokTest<'a, 'b, T> {
-    pub fn test_type(&self) {
-        self.r#type;
-    }
+#[derive(Data, Debug, Clone)]
+struct TupleStruct(
+    #[get(pub)] String,
+    #[set(pub)] i32,
+    #[get(pub)]
+    #[set(pub)]
+    bool,
+);
+
+#[derive(CustomDebug)]
+enum Response {
+    Success {
+        data: String,
+    },
+    Error {
+        message: String,
+        #[debug(skip)]
+        internal_code: u32,
+    },
 }
 
 fn main() {
     let mut data: LombokTest<usize> = LombokTest {
         list: Vec::new(),
-        opt_str_lifetime_a: None,
-        opt_str_lifetime_b: None,
-        r#type: "type",
+        opt_value: None,
+        name: "test".to_string(),
     };
     let list: Vec<String> = vec!["hello".to_string(), "world".to_string()];
     data.set_list(list.clone());
-    match data.get_list() {
-        left_val => {
-            assert_eq!(*left_val, list);
-        }
-    }
-    let get_opt_str_lifetime_a: Option<usize> = data.get_opt_str_lifetime_a().cloned();
-    assert_eq!(get_opt_str_lifetime_a, None);
-    let get_mut_opt_str_lifetime_b: &mut Option<&str> = data.get_mut_opt_str_lifetime_b();
-    *get_mut_opt_str_lifetime_b = Some("opt_str_lifetime_b");
-    assert_eq!(
-        data.get_mut_opt_str_lifetime_b().clone(),
-        Some("opt_str_lifetime_b")
-    );
-    println!("{}", data.to_string());
+    assert_eq!(*data.get_list(), list);
+    let opt_value: &Option<&usize> = data.get_opt_value();
+    assert_eq!(*opt_value, None);
+    let name_mut: &mut String = data.get_mut_name();
+    *name_mut = "updated".to_string();
+    assert!(!data.to_string().is_empty());
+    let mut tuple_data: TupleStruct = TupleStruct("hello".to_string(), 42, true);
+    let field0: &String = tuple_data.get_0();
+    assert_eq!(field0, "hello");
+    tuple_data.set_1(100);
+    let field2: &bool = tuple_data.get_2();
+    assert_eq!(*field2, true);
+    tuple_data.set_2(false);
+    let user: User = User {
+        name: "Alice".to_string(),
+        password: "secret123".to_string(),
+        email: "alice@example.com".to_string(),
+    };
+    let user_debug: String = format!("{:?}", user);
+    assert!(user_debug.contains("Alice"));
+    assert!(user_debug.contains("alice@example.com"));
+    assert!(!user_debug.contains("secret123"));
+    let success: Response = Response::Success {
+        data: "Operation completed".to_string(),
+    };
+    let success_debug: String = format!("{:?}", success);
+    assert!(success_debug.contains("Operation completed"));
+    let error: Response = Response::Error {
+        message: "Something went wrong".to_string(),
+        internal_code: 500,
+    };
+    let error_debug: String = format!("{:?}", error);
+    assert!(error_debug.contains("Something went wrong"));
+    assert!(!error_debug.contains("500"));
 }