adding custom macro attributes for mapping fields

Author: douggynix

src/dto_builder.rs

@@ -138,11 +138,7 @@ fn build_into_fields(
 
     // let selected_fields =
     //   get_selected_fields(&st_entry, &ignore_fields, &map_fields);
-    let selected_fields = if mp_entry.exactly && map_fields.len() == 0 && ignore_fields.len() == 0 {
-        get_all_fields(&st_entry)
-    } else {
-        get_selected_fields(&st_entry, &ignore_fields, &map_fields)
-    };
+    let selected_fields = extract_selected_fields(&st_entry, mp_entry, &map_fields, &ignore_fields);
 
     selected_fields
         .iter()
@@ -182,37 +178,61 @@ fn build_into_fields(
         .collect()
 }
 
+fn extract_selected_fields(
+    st_entry: &StructEntry,
+    mp_entry: &MapperEntry,
+    map_fields: &HashMap<String, MapValue>,
+    ignore_fields: &HashSet<String>,
+) -> Vec<FieldEntry> {
+    if mp_entry.exactly && map_fields.len() == 0 && ignore_fields.len() == 0 {
+        get_all_fields(&st_entry)
+    } else {
+        get_selected_fields(&st_entry, &ignore_fields, &map_fields)
+    }
+}
+
 fn build_fields(st_entry: &StructEntry, mp_entry: &MapperEntry) -> Vec<TokenStream> {
     //we retrieve a hashmap of MapValue with key=source_field_name in the struct , and the the value as MapValue
     let map_fields = get_map_of_mapvalue(mp_entry);
 
     // Let us retrieve the ignore fields
     let ignore_fields = get_ignore_fields(mp_entry);
 
-    let selected_fields = if mp_entry.exactly && map_fields.len() == 0 && ignore_fields.len() == 0 {
-        get_all_fields(&st_entry)
-    } else {
-        get_selected_fields(&st_entry, &ignore_fields, &map_fields)
-    };
+    let selected_fields = extract_selected_fields(&st_entry, mp_entry, &map_fields, &ignore_fields);
 
     let tk_stream_iterator = selected_fields.iter().map(|field| {
         let mut name = format!("{}", field.field_name.to_string());
         let mut name_ident = format_ident!("{}", name.as_str());
 
         let ty = &field.field_type;
+
+        let mut attributes: Vec<TokenStream> = Vec::new();
+
         if let Some(m_value) = map_fields.get(&name) {
             //let's rename the struct field if there is a mapping for it
             if let Some(ref new_name) = m_value.to_field {
                 name = new_name.clone();
                 name_ident = format_ident!("{}", name.as_str())
             }
 
+            attributes = m_value
+                .macro_attr
+                .iter()
+                .map(|attr| parse_str(attr).unwrap())
+                .collect();
+
             if !m_value.required && !field.is_optional {
-                return quote! { pub #name_ident: Option<#ty> };
+                return quote! {
+                    #(#attributes)*
+                    pub #name_ident: Option<#ty>
+                };
             }
         }
 
-        quote! { pub #name_ident: #ty }
+        quote! {
+            #(#attributes)*
+            pub #name_ident: #ty
+        }
     });
 
     let mut struct_fields = tk_stream_iterator.collect::<Vec<TokenStream>>();

src/mapper_entry.rs

@@ -6,7 +6,7 @@ use syn::{
 use crate::utils;
 use crate::utils::isblank;
 
-pub type MapTuple = (String, bool);
+pub type MapTuple = (String, bool, Vec<String>);
 #[derive(Debug, Default)]
 pub struct MapperEntry {
     pub dto: String,
@@ -20,12 +20,13 @@ pub struct MapperEntry {
 }
 
 //DataStructure for the type of mapper values found in each entry
-#[derive(Debug, Clone)]
+#[derive(Debug, Default, Clone)]
 pub struct MapValue {
     //Literal value are consited of properties with key=value
     // dto="MyDto" , ignore="true"
     pub from_field: String,
     pub to_field: Option<String>,
+    pub macro_attr: Vec<String>,
     pub required: bool,
 }
 
@@ -49,16 +50,6 @@ impl NewField {
     }
 }
 
-impl Default for MapValue {
-    fn default() -> Self {
-        Self {
-            from_field: "".into(),
-            to_field: None,
-            required: true,
-        }
-    }
-}
-
 impl MapValue {
     fn new(map_tuple: &MapTuple) -> Self {
         let fields = map_tuple.0.as_str().split(":");
@@ -69,13 +60,15 @@ impl MapValue {
         if fields.len() > 1 && !fields[1].trim().is_empty() {
             to_field = Some(fields[1].trim().to_string());
         }
+        let macro_attr: Vec<String> = map_tuple.2.clone();
 
         let required = map_tuple.1;
 
         Self {
             from_field,
             to_field,
             required,
+            macro_attr,
         }
     }
 }
@@ -287,29 +280,36 @@ impl MapperEntry {
     }
 
     fn parse_array_of_tuple(expr_arr: &ExprArray) -> Vec<MapTuple> {
-        let mut vec_tuple: Vec<(String, bool)> = Vec::new();
+        let mut vec_tuple: Vec<(String, bool, Vec<String>)> = Vec::new();
 
         for elem in expr_arr.elems.iter() {
             if let Expr::Tuple(el_exp) = elem {
                 //println!("{} content  is a Tuple",keyname);
                 let mut str_val: Option<String> = None;
                 let mut flag: Option<bool> = None;
+                let mut attrs: Vec<String> = Vec::new();
                 for content_expr in el_exp.elems.iter() {
                     if let Expr::Lit(content_lit) = content_expr {
                         if let Lit::Str(content) = &content_lit.lit {
                             //print!("valueStr={}",content.value());
                             str_val = utils::remove_white_space(&content.value()).into();
                         }
 
+                        //There can only exist one boolean
                         if let Lit::Bool(content) = &content_lit.lit {
                             //print!("  valueBool={}",content.value());
                             flag = content.value.into();
                         }
                     }
+
+                    //this will parse macro attributes for mapped fields
+                    if let Expr::Array(content_arr) = content_expr {
+                        attrs = Self::parse_array_of_macro_attr(&content_arr);
+                    }
                 }
 
                 if str_val.is_some() && flag.is_some() {
-                    let tuple: MapTuple = (str_val.unwrap(), flag.unwrap());
+                    let tuple: MapTuple = (str_val.unwrap(), flag.unwrap(), attrs);
                     vec_tuple.push(tuple);
                 }
                 //println!("");

tests/test_dto_creation.rs

@@ -22,12 +22,12 @@ mod test_dto_creation {
     #[mapper(
     dto="CustomDtoWithAttribute" ,
     no_builder=true ,
-    map=[ ("email",false) ],
+    map=[ ("email", false, ["#[serde(rename = \"email_address\")]"] ) ],
     derive=(Debug, Clone, Serialize, Deserialize),
     new_fields=[(
         "name: String",
         "concat_str( self.firstname.as_str(), self.lastname.as_str() )",
-        ["#[serde(rename = \"renamed_name\")]"],
+        ["#[serde(rename = \"full_name\")]"],
     )],
     macro_attr=["serde(rename_all = \"UPPERCASE\")"]
   )]
@@ -161,7 +161,7 @@ mod test_dto_creation {
         let json_string = serde_json::to_string(&custom_dto).unwrap();
         assert_eq!(
             json_string,
-            r#"{"EMAIL":"Dessalines@gmail.com","renamed_name":"Jean Jacques"}"#
+            r#"{"email_address":"Dessalines@gmail.com","full_name":"Jean Jacques"}"#
         );
     }
 }