mod described_rules;
mod deserialize_enum_expansion;
mod deserialize_expansion;
mod deserialized_enum;
mod deserialized_struct;
mod expansion;
mod pattern;
mod serde_names;
mod validated_enum;
mod validated_struct;
mod written_rule;
use proc_macro::TokenStream;
use syn::{Data, DeriveInput, Error, parse_macro_input};
use deserialized_enum::DeserializedEnum;
use deserialized_struct::DeserializedStruct;
use validated_enum::ValidatedEnum;
use validated_struct::ValidatedStruct;
#[proc_macro_derive(Validate, attributes(validate, serde))]
pub fn derive_validate(input: TokenStream) -> TokenStream {
let input = parse_macro_input!(input as DeriveInput);
let validate_impl = match &input.data {
Data::Enum(data) => {
ValidatedEnum::from_input(&input, data).map(|validated_enum| expansion::validate_enum_impl(&validated_enum))
}
Data::Struct(_) | Data::Union(_) => ValidatedStruct::from_input(
&input,
"`Validate` can only be derived for a struct with named fields or an enum",
)
.map(|validated_struct| expansion::validate_impl(&validated_struct)),
};
validate_impl.unwrap_or_else(Error::into_compile_error).into()
}
#[proc_macro_derive(Deserialize, attributes(validate, serde, annotated))]
pub fn derive_deserialize(input: TokenStream) -> TokenStream {
let input = parse_macro_input!(input as DeriveInput);
let deserialize_impl = match &input.data {
Data::Enum(data) => DeserializedEnum::from_input(&input, data)
.map(|deserialized_enum| deserialize_enum_expansion::deserialize_enum_impl(&deserialized_enum)),
Data::Struct(_) | Data::Union(_) => DeserializedStruct::from_input(&input)
.map(|deserialized_struct| deserialize_expansion::deserialize_impl(&deserialized_struct)),
};
deserialize_impl.unwrap_or_else(Error::into_compile_error).into()
}