#![doc = include_str!("../README.md")]
mod types;
mod utils;
mod validators;
use darling::FromDeriveInput;
use proc_macro_error2::proc_macro_error;
use quote::quote;
use syn::{DeriveInput, GenericParam, parse_macro_input};
use types::{ValidateField, ValidationData};
use utils::{CrateName, quote_use_statements};
#[proc_macro_error]
#[proc_macro_derive(Validate, attributes(validate))]
pub fn derive_validation(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let input: DeriveInput = parse_macro_input!(input);
let validation_data = match ValidationData::from_derive_input(&input) {
Ok(data) => data,
Err(e) => return e.write_errors().into(),
};
let crate_name = validation_data.crate_name;
let custom_context = if let Some(context) = &validation_data.context {
if let Some(mutable) = validation_data.mutable {
if mutable {
quote!(&'v_a mut #context)
} else {
quote!(&'v_a #context)
}
} else {
quote!(&'v_a #context)
}
} else {
quote!(())
};
let struct_data = validation_data.data.take_struct().unwrap();
let original_fields: Vec<syn::Field> = struct_data
.fields
.iter()
.map(|f| f.original.clone())
.collect();
let all_fields: Vec<&syn::Field> = original_fields.iter().collect();
let mut validation_fields: Vec<ValidateField> = struct_data
.fields
.into_iter()
.map(|f| f.parsed)
.filter(|f| if let Some(s) = f.skip { !s } else { true })
.map(|f| ValidateField {
crate_name: crate_name.clone(),
..f
})
.collect();
if let Some(nest_all_fields) = validation_data.nest_all_fields
&& nest_all_fields
{
validation_fields = validation_fields
.iter_mut()
.map(|f| {
f.nested = Some(true);
f.to_owned()
})
.collect();
}
let use_statements = quote_use_statements(&crate_name, &validation_fields);
let schema = validation_data.schema.iter().fold(quote!(), |acc, s| {
let st = validators::schema::tokens(s.clone());
let acc = quote! {
#acc
#st
};
acc
});
let ident = validation_data.ident;
let (imp, ty, whr) = validation_data.generics.split_for_impl();
let struct_generics_quote =
validation_data
.generics
.params
.iter()
.fold(quote!(), |mut q, g| {
if let GenericParam::Type(t) = g {
if t.default.is_some() {
let mut t2 = t.clone();
t2.default = None;
let g2 = GenericParam::Type(t2);
q.extend(quote!(#g2, ));
} else {
q.extend(quote!(#g, ));
}
} else {
q.extend(quote!(#g, ));
}
q
});
let imp_args = if struct_generics_quote.is_empty() {
quote!(<'v_a>)
} else {
quote!(<'v_a, #struct_generics_quote>)
};
let argless_validation = if validation_data.context.is_none() {
quote! {
impl #imp #crate_name::Validate for #ident #ty #whr {
fn validate(&self) -> ::std::result::Result<(), #crate_name::ValidationErrors> {
use #crate_name::ValidateArgs;
self.validate_with_args(())
}
}
}
} else {
quote!()
};
let field_validation_tokens: Vec<proc_macro2::TokenStream> = validation_fields
.iter()
.map(|f| f.generate_tokens(&all_fields))
.collect();
quote!(
#argless_validation
impl #imp_args #crate_name::ValidateArgs<'v_a> for #ident #ty #whr {
type Args = #custom_context;
fn validate_with_args(&self, args: Self::Args)
-> ::std::result::Result<(), #crate_name::ValidationErrors>
{
#use_statements
let mut errors = #crate_name::ValidationErrors::new();
#(#field_validation_tokens)*
let __validator_has_field_errors = !errors.is_empty();
#schema
if errors.is_empty() {
::std::result::Result::Ok(())
} else {
::std::result::Result::Err(errors)
}
}
}
)
.into()
}