Proc macro for tedge config

crates/common/tedge_config_macros/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "tedge_config_macros"
+version = "0.1.0"
+edition = "2021"
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+camino = { version = "*", features = ["serde1"] }
+doku = "0.21.0"
+once_cell = "*"
+serde = "*"
+tedge_config_macros-macro = { path = "macro" }
+thiserror = "1.0"
+tracing = "*"
+url = "*"

crates/common/tedge_config_macros/impl/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "tedge_config_macros-impl"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+darling = "0.14.4"
+heck = "0.4.1"
+optional-error = "0.1.1"
+proc-macro2 = "1"
+quote = "1"
+syn = { version = "1", features = ["full", "extra-traits"] }

crates/common/tedge_config_macros/impl/src/dto.rs

@@ -0,0 +1,96 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::parse_quote_spanned;
+use syn::spanned::Spanned;
+
+use crate::input::FieldOrGroup;
+use crate::prefixed_type_name;
+
+pub fn generate(name: proc_macro2::Ident, items: &[FieldOrGroup]) -> TokenStream {
+    let mut idents = Vec::new();
+    let mut tys = Vec::<syn::Type>::new();
+    let mut sub_dtos = Vec::new();
+    let mut attrs = Vec::new();
+
+    for item in items {
+        match item {
+            FieldOrGroup::Field(field) => {
+                if !field.dto().skip && field.read_only().is_none() {
+                    idents.push(field.ident());
+                    tys.push({
+                        let ty = field.ty();
+                        parse_quote_spanned!(ty.span()=> Option<#ty>)
+                    });
+                    sub_dtos.push(None);
+                    attrs.push(field.attrs().iter().filter(is_preserved).collect());
+                }
+            }
+            FieldOrGroup::Group(group) => {
+                if !group.dto.skip {
+                    let sub_dto_name = prefixed_type_name(&name, group);
+                    idents.push(&group.ident);
+                    tys.push(parse_quote_spanned!(group.ident.span()=> #sub_dto_name));
+                    sub_dtos.push(Some(generate(sub_dto_name, &group.contents)));
+                    attrs.push(Vec::new());
+                }
+            }
+        }
+    }
+
+    quote! {
+        #[derive(Debug, Default, ::serde::Deserialize, ::serde::Serialize)]
+        #[non_exhaustive]
+        pub struct #name {
+            #(
+                #(#attrs)*
+                #idents: #tys,
+            )*
+        }
+
+        #(#sub_dtos)*
+    }
+}
+
+fn is_preserved(attr: &&syn::Attribute) -> bool {
+    match attr.parse_meta() {
+        // Maybe cfg is useful. Certainly seems sensible to preserve it
+        Ok(syn::Meta::List(list)) => list.path.is_ident("serde") || list.path.is_ident("cfg"),
+        Ok(syn::Meta::NameValue(nv)) => nv.path.is_ident("doc"),
+        _ => false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use syn::parse_quote;
+
+    use super::*;
+
+    #[test]
+    fn doc_comments_are_preserved() {
+        assert!(is_preserved(&&parse_quote!(
+            /// Test
+        )))
+    }
+
+    #[test]
+    fn serde_attributes_are_preserved() {
+        assert!(is_preserved(&&parse_quote!(
+            #[serde(rename = "something")]
+        )))
+    }
+
+    #[test]
+    fn unrecognised_attributes_are_not_preserved() {
+        assert!(!is_preserved(&&parse_quote!(
+            #[unknown_crate(unknown_bool)]
+        )))
+    }
+
+    #[test]
+    fn unrecognised_attributes_of_the_wrong_type_are_not_preserved() {
+        assert!(!is_preserved(&&parse_quote!(
+            #[unknown_attribute = "some value"]
+        )))
+    }
+}

crates/common/tedge_config_macros/impl/src/error.rs

@@ -0,0 +1,15 @@
+use optional_error::OptionalError;
+
+pub fn combine_errors<T>(
+    items: impl Iterator<Item = Result<T, syn::Error>>,
+) -> Result<Vec<T>, syn::Error> {
+    let mut error = OptionalError::default();
+    let mut successful_values = Vec::new();
+    for item in items {
+        match item {
+            Ok(value) => successful_values.push(value),
+            Err(e) => error.combine(e),
+        }
+    }
+    error.try_throw().and(Ok(successful_values))
+}

crates/common/tedge_config_macros/impl/src/input/mod.rs

@@ -0,0 +1,4 @@
+mod parse;
+mod validate;
+
+pub use validate::*;