Proc macro for tedge config

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

@@ -160,7 +160,4 @@ pub struct FieldDtoSettings {
 }
 
 #[derive(FromMeta, Debug, Default)]
-pub struct ReaderSettings {
-    #[darling(default)]
-    pub all_or_nothing: bool,
-}
+pub struct ReaderSettings {}

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

@@ -22,19 +22,15 @@ pub fn try_generate(
     root_name: proc_macro2::Ident,
     items: &[FieldOrGroup],
 ) -> syn::Result<TokenStream> {
-    let structs = generate_structs(&root_name, items, false)?;
+    let structs = generate_structs(&root_name, items)?;
     let conversions = generate_conversions(&root_name, items, vec![], items)?;
     Ok(quote! {
         #structs
         #conversions
     })
 }
 
-fn generate_structs(
-    name: &proc_macro2::Ident,
-    items: &[FieldOrGroup],
-    parent_all_or_nothing: bool,
-) -> syn::Result<TokenStream> {
+fn generate_structs(name: &proc_macro2::Ident, items: &[FieldOrGroup]) -> syn::Result<TokenStream> {
     let mut idents = Vec::new();
     let mut tys = Vec::<syn::Type>::new();
     let mut sub_readers = Vec::new();
@@ -46,34 +42,18 @@ fn generate_structs(
                 let ty = field.ty();
                 attrs.push(field.attrs().to_vec());
                 idents.push(field.ident());
-                if Some(&FieldDefault::None) == field.read_write().map(|f| &f.default)
-                    && !parent_all_or_nothing
-                {
+                if Some(&FieldDefault::None) == field.read_write().map(|f| &f.default) {
                     tys.push(parse_quote_spanned!(ty.span()=> OptionalConfig<#ty>));
                 } else {
                     tys.push(ty.to_owned());
                 }
                 sub_readers.push(None);
             }
-            FieldOrGroup::Group(group) if parent_all_or_nothing => {
-                return Err(syn::Error::new(
-                    group.ident.span(),
-                    "Sub-groups inside `#[reader(all_or_nothing)]` are not supported",
-                ));
-            }
             FieldOrGroup::Group(group) => {
                 let sub_reader_name = prefixed_type_name(name, group);
                 idents.push(&group.ident);
-                if group.reader.all_or_nothing {
-                    tys.push(parse_quote_spanned!(group.ident.span()=> OptionalConfigGroup<#sub_reader_name>));
-                } else {
-                    tys.push(parse_quote_spanned!(group.ident.span()=> #sub_reader_name));
-                }
-                sub_readers.push(Some(generate_structs(
-                    &sub_reader_name,
-                    &group.contents,
-                    group.reader.all_or_nothing,
-                )?));
+                tys.push(parse_quote_spanned!(group.ident.span()=> #sub_reader_name));
+                sub_readers.push(Some(generate_structs(&sub_reader_name, &group.contents)?));
                 attrs.push(group.attrs.to_vec());
             }
         }
@@ -242,11 +222,8 @@ fn generate_conversions(
                 let mut parents = parents.clone();
                 parents.push(group.ident.clone());
                 field_conversions.push(quote!(#name: #sub_reader_name::from_dto(dto, location)));
-                let sub_conversions = if group.reader.all_or_nothing {
-                    generate_all_or_nothing_struct(&sub_reader_name, &group.contents, parents)
-                } else {
-                    generate_conversions(&sub_reader_name, &group.contents, parents, root_fields)
-                }?;
+                let sub_conversions =
+                    generate_conversions(&sub_reader_name, &group.contents, parents, root_fields)?;
                 rest.push(sub_conversions);
             }
         }
@@ -266,79 +243,3 @@ fn generate_conversions(
         #(#rest)*
     })
 }
-
-fn generate_all_or_nothing_struct(
-    name: &proc_macro2::Ident,
-    items: &[FieldOrGroup],
-    parents: Vec<syn::Ident>,
-) -> syn::Result<TokenStream> {
-    let fields = items
-        .iter()
-        .filter_map(|field| match field {
-            FieldOrGroup::Field(f) => Some(f),
-            _ => None,
-        })
-        .collect::<Vec<_>>();
-
-    ensure_defaults_not_set_for(&fields)?;
-
-    let names = fields.iter().map(|f| f.ident()).collect::<Vec<_>>();
-    let parentss = std::iter::repeat(&parents)
-        .take(names.len())
-        .collect::<Vec<_>>();
-    let nones = std::iter::repeat(quote!(None)).take(names.len());
-    // TODO this should ideally cope with the fields being renamed
-    let field = parents
-        .iter()
-        .map(|p| p.to_string())
-        .collect::<Vec<_>>()
-        .join(".");
-    let field_strings = names.iter().map(|name| format!("{field}.{name}"));
-    let error = format!("Missing some fields in {field}. ");
-
-    Ok(quote! {
-        impl #name {
-            #[automatically_derived]
-            pub fn from_dto(dto: &TEdgeConfigDto, location: &TEdgeConfigLocation) -> OptionalConfigGroup<Self> {
-                match (#(dto.#(#parentss).*.#names),*) {
-                    (#(Some(#names)),*) => OptionalConfigGroup::Present(Self {
-                        #(#names,)*
-                    }),
-                    (#(#nones),*) => OptionalConfigGroup::Empty(#field),
-                    (#(#names),*) => {
-                        let mut error = #error.to_owned();
-                        let mut filled_fields = vec![];
-                        let mut vacant_fields = vec![];
-                        #(
-                            match #names {
-                                Some(_) => filled_fields.push(#field_strings),
-                                None => vacant_fields.push(#field_strings),
-                            };
-                        )*
-                        error.push_str(&format!("Either set {:?}, or unset {:?}", vacant_fields, filled_fields));
-                        OptionalConfigGroup::Partial(error)
-                    }
-                }
-            }
-        }
-    })
-}
-
-fn ensure_defaults_not_set_for(fields: &Vec<&ConfigurableField>) -> Result<(), syn::Error> {
-    let mut error = OptionalError::default();
-    for field in fields {
-        match field.read_write().map(|f| &f.default) {
-            Some(FieldDefault::None) => (),
-            Some(d) => error.combine(syn::Error::new(
-                // Safe to unwrap because default is not FieldDefault::None
-                d.possible_span().unwrap(),
-                "sub-fields of all or nothing groups are not allowed to have defaults",
-            )),
-            None => error.combine(syn::Error::new(
-                field.ident().span(),
-                "read-only values are not allowed as all or nothing sub-fields",
-            )),
-        }
-    }
-    error.try_throw()
-}

crates/common/tedge_config_macros/src/all_or_nothing.rs

@@ -0,0 +1,87 @@
+use crate::OptionalConfig;
+
+pub fn all_or_nothing<T, U>(
+    t: OptionalConfig<T>,
+    u: OptionalConfig<U>,
+) -> Result<Option<(T, U)>, String> {
+    use OptionalConfig::*;
+
+    match (t, u) {
+        (Present { value: t, .. }, Present { value: u, .. }) => Ok(Some((t, u))),
+        (Empty(..), Empty(..)) => Ok(None),
+        (t, u) => {
+            let all_settings = [t.key(), u.key()];
+            let present = [t.key_if_present(), u.key_if_present()]
+                .into_iter()
+                .filter_map(|id| id)
+                .collect::<Vec<_>>();
+            let missing = [t.key_if_empty(), u.key_if_empty()]
+                .into_iter()
+                .filter_map(|id| id)
+                .collect::<Vec<_>>();
+            Err(format!(
+     "The thin-edge configuration is invalid. The settings {all_settings:?} must either all be configured, or all unset. Currently {present:?} are set, and {missing:?} are unset."))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn all_or_nothing_returns_some_when_both_values_are_configured() {
+        assert_eq!(
+            all_or_nothing(
+                OptionalConfig::Present {
+                    value: "first",
+                    key: "test.key"
+                },
+                OptionalConfig::Present {
+                    value: "second",
+                    key: "test.key2"
+                }
+            ),
+            Ok(Some(("first", "second")))
+        )
+    }
+
+    #[test]
+    fn all_or_nothing_returns_none_when_both_values_when_neither_value_is_configured() {
+        assert_eq!(
+            all_or_nothing::<String, String>(
+                OptionalConfig::Empty("first.key"),
+                OptionalConfig::Empty("second.key"),
+            ),
+            Ok(None)
+        )
+    }
+
+    #[test]
+    fn all_or_nothing_returns_an_error_if_only_the_first_value_is_configured() {
+        assert!(matches!(
+            all_or_nothing::<_, String>(
+                OptionalConfig::Present {
+                    value: "test",
+                    key: "first.key"
+                },
+                OptionalConfig::Empty("second.key"),
+            ),
+            Err(_)
+        ))
+    }
+
+    #[test]
+    fn all_or_nothing_returns_an_error_if_only_the_second_value_is_configured() {
+        assert!(matches!(
+            all_or_nothing::<String, _>(
+                OptionalConfig::Empty("first.key"),
+                OptionalConfig::Present {
+                    value: "test",
+                    key: "second.key"
+                },
+            ),
+            Err(_)
+        ))
+    }
+}

crates/common/tedge_config_macros/src/lib.rs

@@ -1,6 +1,7 @@
 #[doc(inline)]
 pub use tedge_config_macros_macro::define_tedge_config;
 
+pub use all_or_nothing::*;
 pub use connect_url::*;
 pub use default::*;
 pub use doku_aliases::*;

crates/common/tedge_config_macros/src/option.rs

@@ -24,12 +24,6 @@ impl<T> From<OptionalConfig<T>> for Option<T> {
     }
 }
 
-pub enum OptionalConfigGroup<T> {
-    Present(T),
-    Empty(&'static str),
-    Partial(String),
-}
-
 #[derive(thiserror::Error, Debug)]
 #[error(
     r#"A value for '{key}' is missing.\n\
@@ -53,15 +47,30 @@ impl<T> OptionalConfig<T> {
             Self::Empty(key) => Err(ConfigNotSet { key }),
         }
     }
-}
 
-impl<T: doku::Document> doku::Document for OptionalConfig<T> {
-    fn ty() -> doku::Type {
-        Option::<T>::ty()
+    pub fn key(&self) -> &'static str {
+        match self {
+            Self::Present { key, .. } => key,
+            Self::Empty(key) => key,
+        }
+    }
+
+    pub fn key_if_present(&self) -> Option<&'static str> {
+        match self {
+            Self::Present { key, .. } => Some(key),
+            Self::Empty(..) => None,
+        }
+    }
+
+    pub fn key_if_empty(&self) -> Option<&'static str> {
+        match self {
+            Self::Empty(key) => Some(key),
+            Self::Present { .. } => None,
+        }
     }
 }
 
-impl<T: doku::Document> doku::Document for OptionalConfigGroup<T> {
+impl<T: doku::Document> doku::Document for OptionalConfig<T> {
     fn ty() -> doku::Type {
         Option::<T>::ty()
     }