use proc_macro2::TokenStream as TokenStream2;
use quote::{ToTokens, quote};
use syn::{Attribute, Field, Ident, Path, Type};
use crate::ValidateField;
#[derive(Debug, Clone)]
pub struct CrateName {
inner: Path,
}
impl ToTokens for CrateName {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
self.inner.to_tokens(tokens);
}
}
impl darling::FromMeta for CrateName {
fn from_string(value: &str) -> darling::Result<Self> {
Path::from_string(value).map(|inner| CrateName { inner })
}
fn from_value(value: &syn::Lit) -> darling::Result<Self> {
Path::from_value(value).map(|inner| CrateName { inner })
}
fn from_expr(value: &syn::Expr) -> darling::Result<Self> {
Path::from_expr(value).map(|inner| CrateName { inner })
}
}
impl Default for CrateName {
fn default() -> Self {
CrateName {
inner: syn::parse_str("::valid8r").expect("invalid valid crate name"),
}
}
}
pub fn quote_message(message: Option<String>) -> proc_macro2::TokenStream {
if let Some(m) = message {
quote!(
err.message = Some(::std::borrow::Cow::from(#m));
)
} else {
quote!()
}
}
pub fn quote_code(
crate_name: &CrateName,
code: Option<String>,
default: &str,
) -> proc_macro2::TokenStream {
if let Some(c) = code {
quote!(
let mut err = #crate_name::ValidationError::new(#c);
)
} else {
quote!(
let mut err = #crate_name::ValidationError::new(#default);
)
}
}
pub fn quote_use_statements(
crate_name: &CrateName,
fields: &[ValidateField],
) -> proc_macro2::TokenStream {
let mut length = quote!();
let mut email = quote!();
let mut card = quote!();
let mut url = quote!();
let mut ip = quote!();
let mut ncc = quote!();
let mut range = quote!();
let mut required = quote!();
let mut contains = quote!();
let mut does_not_contain = quote!();
let mut regex = quote!();
let mut phone_number = quote!();
let mut consent = quote!();
let mut prohibited = quote!();
for f in fields {
if f.length.is_some() {
length = quote!(
use #crate_name::ValidateLength;
);
}
if f.email.is_some() {
email = quote!(
use #crate_name::ValidateEmail;
);
}
if f.credit_card.is_some() {
card = quote!(
use #crate_name::ValidateCreditCard;
);
}
if f.url.is_some() {
url = quote!(
use #crate_name::ValidateUrl;
);
}
if f.ip.is_some() {
ip = quote!(
use #crate_name::ValidateIp;
);
}
if f.non_control_character.is_some() {
ncc = quote!(
use #crate_name::ValidateNonControlCharacter;
);
}
if f.range.is_some() {
range = quote!(
use #crate_name::ValidateRange;
);
}
if f.required.is_some()
|| f.required_if.is_some()
|| f.required_with.is_some()
|| f.required_with_all.is_some()
|| f.required_without.is_some()
|| f.required_without_all.is_some()
{
required = quote!(
use #crate_name::ValidateRequired;
);
}
if f.prohibited_if.is_some()
|| f.prohibited_with.is_some()
|| f.prohibited_with_all.is_some()
|| f.prohibited_without.is_some()
|| f.prohibited_without_all.is_some()
{
prohibited = quote!(
use #crate_name::ValidateProhibited;
);
}
if f.contains.is_some() {
contains = quote!(
use #crate_name::ValidateContains;
);
}
if f.does_not_contain.is_some() {
does_not_contain = quote!(
use #crate_name::ValidateDoesNotContain;
);
}
if f.regex.is_some() {
regex = quote!(
use #crate_name::ValidateRegex;
);
}
if f.phone_number.is_some() {
phone_number = quote!(
use #crate_name::ValidatePhoneNumber;
)
}
if f.accepted.is_some()
|| f.declined_if.is_some()
|| f.declined.is_some()
|| f.accepted_if.is_some()
{
consent = quote!(
use #crate_name::ValidateConsent;
);
}
}
quote!(
#length
#email
#card
#url
#ip
#ncc
#range
#required
#prohibited
#contains
#does_not_contain
#regex
#phone_number
#consent
)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FieldOptionality {
NotOptional,
Option,
OptionOption,
Delta,
}
pub fn type_optionality(ty: &Type) -> FieldOptionality {
if let Type::Path(type_path) = ty
&& let Some(segment) = type_path.path.segments.last()
{
if segment.ident == "Delta" {
return FieldOptionality::Delta;
}
if segment.ident == "Option" {
if let syn::PathArguments::AngleBracketed(args) = &segment.arguments
&& let Some(syn::GenericArgument::Type(inner)) = args.args.first()
&& matches!(
type_optionality(inner),
FieldOptionality::Option | FieldOptionality::OptionOption
)
{
return FieldOptionality::OptionOption;
}
return FieldOptionality::Option;
}
}
FieldOptionality::NotOptional
}
pub fn is_optionish_type(ty: &Type) -> bool {
type_optionality(ty) != FieldOptionality::NotOptional
}
pub fn field_optionality(field_name: &str, all_fields: &[&Field]) -> FieldOptionality {
all_fields
.iter()
.find(|f| f.ident.as_ref().is_some_and(|i| i == field_name))
.map(|f| type_optionality(&f.ty))
.unwrap_or(FieldOptionality::NotOptional)
}
pub fn generate_presence_check(
field_ident: &Ident,
optionality: FieldOptionality,
check_present: bool,
) -> TokenStream2 {
let present = match optionality {
FieldOptionality::NotOptional => quote! { true },
FieldOptionality::Option => quote! { self.#field_ident.is_some() },
FieldOptionality::OptionOption => quote! { matches!(self.#field_ident, Some(Some(_))) },
FieldOptionality::Delta => quote! { self.#field_ident.is_set() },
};
if check_present {
present
} else {
quote! { !(#present) }
}
}
pub fn generate_has_value_check(
field_ident: &Ident,
optionality: FieldOptionality,
) -> TokenStream2 {
match optionality {
FieldOptionality::OptionOption => quote! { matches!(self.#field_ident, Some(Some(_))) },
FieldOptionality::Delta => quote! { self.#field_ident.is_set() },
_ => quote! { self.#field_ident.validate_required() },
}
}
pub fn generate_is_prohibited_check(
field_ident: &Ident,
optionality: FieldOptionality,
) -> TokenStream2 {
match optionality {
FieldOptionality::OptionOption => quote! { !matches!(self.#field_ident, Some(Some(_))) },
FieldOptionality::Delta => quote! { !self.#field_ident.is_set() },
_ => quote! { self.#field_ident.validate_prohibited() },
}
}
pub fn is_field_sensitive(field_name: &str, all_fields: &[&Field]) -> bool {
use darling::FromField;
all_fields
.iter()
.find(|f| f.ident.as_ref().is_some_and(|i| i == field_name))
.and_then(|f| ValidateField::from_field(f).ok())
.is_some_and(|parsed| parsed.sensitive.unwrap_or(false))
}
pub fn get_attr<'a>(attrs: &'a [Attribute], name: &str) -> Option<&'a Attribute> {
attrs.iter().find(|a| match &a.meta {
syn::Meta::List(list) => list.tokens.clone().into_iter().any(|t| match t {
proc_macro2::TokenTree::Ident(i) => i == name,
_ => false,
}),
_ => false,
})
}