Add with attribute for field transformations in valuable derive macro

Introduces a new `#[valuable(with = "function")]` attribute that allows
custom field transformations during valuable serialization. Functions
take a reference to the field and return any type implementing Valuable.

Author: lukas-reineke

valuable-derive/examples/comprehensive_demo.rs

@@ -0,0 +1,79 @@
+use valuable::Valuable;
+
+/// Stack copy: bool -> bool
+fn invert_flag(active: &bool) -> bool {
+    !*active
+}
+
+/// Heap allocation: u64 -> String
+fn format_id(id: &u64) -> String {
+    format!("ID-{:06}", id)
+}
+
+/// Complex transformation: Vec<String> -> Box<[String]>
+fn uppercase_list(items: &[String]) -> Box<[String]> {
+    items
+        .iter()
+        .map(|s| s.to_uppercase())
+        .collect::<Vec<_>>()
+        .into_boxed_slice()
+}
+
+#[derive(Valuable, Debug)]
+struct Example {
+    id: u64,
+
+    #[valuable(with = "invert_flag")]
+    active: bool,
+
+    #[valuable(with = "format_id")]
+    user_id: u64,
+
+    #[valuable(with = "uppercase_list")]
+    tags: Vec<String>,
+
+    #[valuable(skip)]
+    #[allow(dead_code)]
+    secret: String,
+}
+
+fn main() {
+    let example = Example {
+        id: 42,
+        active: false,
+        user_id: 12345,
+        tags: vec!["admin".to_string(), "user".to_string()],
+        secret: "hidden".to_string(),
+    };
+
+    println!("Debug: {example:?}");
+
+    struct TestVisitor {
+        fields: Vec<(String, String)>,
+    }
+
+    impl valuable::Visit for TestVisitor {
+        fn visit_value(&mut self, _value: valuable::Value<'_>) {}
+
+        fn visit_named_fields(&mut self, named_values: &valuable::NamedValues<'_>) {
+            for (field, value) in named_values {
+                self.fields
+                    .push((field.name().to_string(), format!("{value:?}")));
+            }
+        }
+
+        fn visit_unnamed_fields(&mut self, values: &[valuable::Value<'_>]) {
+            for (i, value) in values.iter().enumerate() {
+                self.fields.push((i.to_string(), format!("{value:?}")));
+            }
+        }
+    }
+
+    let mut visitor = TestVisitor { fields: Vec::new() };
+    example.visit(&mut visitor);
+
+    println!("Valuable fields:");
+    for (name, value) in visitor.fields {
+        println!("  {}: {}", name, value);
+    }
+}

valuable-derive/src/attr.rs

@@ -33,7 +33,7 @@ static ATTRS: &[AttrDef] = &[
     // #[valuable(skip)]
     AttrDef {
         name: "skip",
-        conflicts_with: &["rename"],
+        conflicts_with: &["rename", "with"],
         position: &[
             // TODO: How do we implement Enumerable::variant and Valuable::as_value if a variant is skipped?
             // Position::Variant,
@@ -42,12 +42,20 @@ static ATTRS: &[AttrDef] = &[
         ],
         style: &[MetaStyle::Ident],
     },
+    // #[valuable(with = "...")]
+    AttrDef {
+        name: "with",
+        conflicts_with: &["skip"],
+        position: &[Position::NamedField, Position::UnnamedField],
+        style: &[MetaStyle::NameValue],
+    },
 ];
 
 pub(crate) struct Attrs {
     rename: Option<(syn::MetaNameValue, syn::LitStr)>,
     transparent: Option<Span>,
     skip: Option<Span>,
+    with: Option<(syn::MetaNameValue, syn::LitStr)>,
 }
 
 impl Attrs {
@@ -65,12 +73,20 @@ impl Attrs {
     pub(crate) fn skip(&self) -> bool {
         self.skip.is_some()
     }
+
+    pub(crate) fn with(&self) -> Option<syn::Expr> {
+        self.with.as_ref().map(|(_, lit_str)| {
+            let path_str = lit_str.value();
+            syn::parse_str(&path_str).expect("failed to parse with function path")
+        })
+    }
 }
 
 pub(crate) fn parse_attrs(cx: &Context, attrs: &[syn::Attribute], pos: Position) -> Attrs {
     let mut rename = None;
     let mut transparent = None;
     let mut skip = None;
+    let mut with = None;
 
     let attrs = filter_attrs(cx, attrs, pos);
     for (def, meta) in &attrs {
@@ -104,6 +120,8 @@ pub(crate) fn parse_attrs(cx: &Context, attrs: &[syn::Attribute], pos: Position)
             "transparent" => transparent = Some(meta.span()),
             // #[valuable(skip)]
             "skip" => skip = Some(meta.span()),
+            // #[valuable(with = "...")]
+            "with" => lit_str!(with),
 
             _ => unreachable!("{}", def.name),
         }
@@ -113,6 +131,7 @@ pub(crate) fn parse_attrs(cx: &Context, attrs: &[syn::Attribute], pos: Position)
         rename,
         transparent,
         skip,
+        with,
     }
 }