refactor(config): generate scalar validation boundaries

libs/kaptan-config-derive/src/expand.rs

@@ -2,7 +2,7 @@ use proc_macro2::TokenStream;
 use quote::quote;
 use syn::Result;
 
-use crate::parse::{Check, Model};
+use crate::parse::{Check, Model, ModelKind};
 
 pub(crate) fn expand(model: Model) -> Result<TokenStream> {
     let Model {
@@ -10,26 +10,77 @@ pub(crate) fn expand(model: Model) -> Result<TokenStream> {
         generics,
         crate_path,
         post_validate,
+        kind,
         fields,
     } = model;
+    match kind {
+        ModelKind::Scalars => expand_scalars(ident, generics, crate_path, post_validate, fields),
+        ModelKind::Sections => expand_sections(ident, generics, crate_path, post_validate, fields),
+    }
+}
+
+fn expand_scalars(
+    ident: syn::Ident,
+    generics: syn::Generics,
+    crate_path: syn::Path,
+    post_validate: Option<syn::Path>,
+    fields: Vec<crate::parse::FieldModel>,
+) -> Result<TokenStream> {
     let (impl_generics, type_generics, where_clause) = generics.split_for_impl();
     let mut checks = Vec::new();
     let mut descriptors = Vec::new();
-    for field in fields {
+    let mut defaults = Vec::new();
+    let mut reads = Vec::new();
+    let mut writes = Vec::new();
+    for field in &fields {
         let FieldMetadata {
             descriptor,
             checks: field_checks,
-        } = expand_field(&crate_path, &field)?;
+        } = expand_field(&crate_path, field)?;
         if let Some(descriptor) = descriptor {
             descriptors.push(descriptor);
         }
         checks.extend(field_checks);
+        let id = field.id.expect("ConfigValidate requires configured fields");
+        let default = field
+            .default
+            .as_ref()
+            .expect("ConfigValidate requires defaults");
+        let (kind, value) = config_value_tokens(&crate_path, &field.ty)?;
+        let field_ident = &field.ident;
+        defaults.push(quote! { #field_ident: #default });
+        reads.push(quote! {
+            #id => Some(#value(self.#field_ident)),
+        });
+        writes.push(quote! {
+            #id => {
+                let next = match value {
+                    #value(next) => next,
+                    actual => {
+                        return Err(#crate_path::FieldWriteError::WrongType {
+                            field: #crate_path::FieldId::new(#id),
+                            expected: #kind,
+                            actual: actual.kind(),
+                        });
+                    }
+                };
+                let previous = self.#field_ident;
+                self.#field_ident = next;
+                if let Err(violation) =
+                    <Self as #crate_path::ConfigSection>::validate_local_fields(self)
+                {
+                    self.#field_ident = previous;
+                    return Err(#crate_path::FieldWriteError::Violation(violation));
+                }
+                Ok(())
+            }
+        });
     }
     let post_validate = post_validate.map(|hook| quote! { #hook(self)?; });
     Ok(quote! {
         impl #impl_generics #crate_path::ValidateFields for #ident #type_generics #where_clause {
             fn validate_fields(&self) -> Result<(), #crate_path::ConfigViolation> {
-                #(#checks)*
+                <Self as #crate_path::ConfigSection>::validate_local_fields(self)?;
                 #post_validate
                 Ok(())
             }
@@ -41,6 +92,133 @@ pub(crate) fn expand(model: Model) -> Result<TokenStream> {
                 #(#descriptors),*
             ];
         }
+
+        impl #impl_generics #crate_path::ConfigSection for #ident #type_generics #where_clause {
+            const FIELD_COUNT: usize = Self::DESCRIPTORS.len();
+
+            fn default_section() -> Result<Self, #crate_path::ConfigViolation> {
+                let section = Self {
+                    #(#defaults),*
+                };
+                <Self as #crate_path::ValidateFields>::validate_fields(&section)?;
+                Ok(section)
+            }
+
+            fn field_value(&self, id: #crate_path::FieldId) -> Option<#crate_path::ConfigValue> {
+                match id.get() {
+                    #(#reads)*
+                    _ => None,
+                }
+            }
+
+            fn set_field(
+                &mut self,
+                id: #crate_path::FieldId,
+                value: #crate_path::ConfigValue,
+            ) -> Result<(), #crate_path::FieldWriteError> {
+                match id.get() {
+                    #(#writes,)*
+                    _ => Err(#crate_path::FieldWriteError::UnknownField(id)),
+                }
+            }
+
+            fn validate_local_fields(&self) -> Result<(), #crate_path::ConfigViolation> {
+                #(#checks)*
+                Ok(())
+            }
+        }
+    })
+}
+
+fn expand_sections(
+    ident: syn::Ident,
+    generics: syn::Generics,
+    crate_path: syn::Path,
+    post_validate: Option<syn::Path>,
+    fields: Vec<crate::parse::FieldModel>,
+) -> Result<TokenStream> {
+    let (impl_generics, type_generics, where_clause) = generics.split_for_impl();
+    let validations = fields.iter().map(|field| {
+        let field_ident = &field.ident;
+        let ty = &field.ty;
+        quote! {
+            <#ty as #crate_path::ValidateFields>::validate_fields(&self.#field_ident)?;
+        }
+    });
+    let defaults = fields.iter().map(|field| {
+        let field_ident = &field.ident;
+        let ty = &field.ty;
+        quote! {
+            #field_ident: <#ty as #crate_path::ConfigSection>::default_section()?
+        }
+    });
+    let reads = fields.iter().map(|field| {
+        let field_ident = &field.ident;
+        let ty = &field.ty;
+        quote! {
+            if let Some(value) = <#ty as #crate_path::ConfigSection>::field_value(
+                &self.#field_ident,
+                id,
+            ) {
+                return Some(value);
+            }
+        }
+    });
+    let writes = fields.iter().map(|field| {
+        let field_ident = &field.ident;
+        let ty = &field.ty;
+        quote! {
+            if <#ty as #crate_path::ConfigSection>::field_value(&self.#field_ident, id).is_some() {
+                return <#ty as #crate_path::ConfigSection>::set_field(
+                    &mut self.#field_ident,
+                    id,
+                    value,
+                );
+            }
+        }
+    });
+    let counts = fields.iter().map(|field| {
+        let ty = &field.ty;
+        quote! { <#ty as #crate_path::ConfigSection>::FIELD_COUNT }
+    });
+    let post_validate = post_validate.map(|hook| quote! { #hook(self)?; });
+    Ok(quote! {
+        impl #impl_generics #crate_path::ValidateFields for #ident #type_generics #where_clause {
+            fn validate_fields(&self) -> Result<(), #crate_path::ConfigViolation> {
+                #(#validations)*
+                #post_validate
+                Ok(())
+            }
+        }
+
+        impl #impl_generics #ident #type_generics #where_clause {
+            /// Number of fields aggregated from derived nested sections.
+            pub const FIELD_COUNT: usize = 0 #(+ #counts)*;
+        }
+
+        impl #impl_generics #crate_path::ConfigAggregate for #ident #type_generics #where_clause {
+            fn default_aggregate() -> Result<Self, #crate_path::ConfigViolation> {
+                let aggregate = Self {
+                    #(#defaults),*
+                };
+                <Self as #crate_path::ValidateFields>::validate_fields(&aggregate)?;
+                Ok(aggregate)
+            }
+
+            fn field_value(&self, id: #crate_path::FieldId) -> Option<#crate_path::ConfigValue> {
+                #(#reads)*
+                None
+            }
+
+            fn set_field(
+                &mut self,
+                id: #crate_path::FieldId,
+                value: #crate_path::ConfigValue,
+            ) -> Result<(), #crate_path::FieldWriteError> {
+                #(#writes)*
+                Err(#crate_path::FieldWriteError::UnknownField(id))
+            }
+        }
     })
 }