use proc_macro2::Span;
use syn::parse::{Parse, ParseStream};
use syn::punctuated::Punctuated;
use syn::spanned::Spanned;
use syn::{Attribute, Error, Expr, Ident, Path, Token, parenthesized, token};
pub enum WrittenRule {
Each {
span: Span,
element_rules: Vec<WrittenRule>,
},
Call(Box<RuleCall>),
}
pub struct RuleCall {
pub path: Path,
pub value: Option<Expr>,
pub builder_arguments: Vec<NamedArgument>,
pub message: Option<Expr>,
}
pub struct NamedArgument {
pub name: Ident,
pub value: Expr,
}
pub enum StructRule {
ReportAll,
Custom(Box<StructCustom>),
}
pub struct StructCustom {
pub check: Expr,
pub field: Option<Expr>,
pub message: Option<Expr>,
pub span: Span,
}
enum Argument {
Named(NamedArgument),
Value(Expr),
}
pub fn written_rules(attributes: &[Attribute]) -> syn::Result<Vec<WrittenRule>> {
let mut rules = Vec::new();
for attribute in validate_attributes(attributes) {
rules.extend(attribute.parse_args_with(Punctuated::<WrittenRule, Token![,]>::parse_terminated)?);
}
Ok(rules)
}
pub fn written_struct_rules(attributes: &[Attribute]) -> syn::Result<Vec<StructRule>> {
let mut rules = Vec::new();
for attribute in validate_attributes(attributes) {
rules.extend(attribute.parse_args_with(Punctuated::<StructRule, Token![,]>::parse_terminated)?);
}
Ok(rules)
}
fn validate_attributes(attributes: &[Attribute]) -> impl Iterator<Item = &Attribute> {
attributes
.iter()
.filter(|attribute| attribute.path().is_ident("validate"))
}
impl Parse for WrittenRule {
fn parse(input: ParseStream) -> syn::Result<Self> {
let path = input.call(Path::parse_mod_style)?;
if path.is_ident("each") {
return Ok(Self::Each {
span: path.span(),
element_rules: element_rules(&path, input)?,
});
}
Ok(Self::Call(Box::new(RuleCall::parse_after(path, input)?)))
}
}
fn element_rules(each: &Path, input: ParseStream) -> syn::Result<Vec<WrittenRule>> {
if !input.peek(token::Paren) {
return Err(Error::new_spanned(
each,
"`each` takes the rules for every element in parentheses: `each(...)`",
));
}
let element_rules;
parenthesized!(element_rules in input);
let element_rules = Punctuated::<WrittenRule, Token![,]>::parse_terminated(&element_rules)?;
for element_rule in &element_rules {
if let WrittenRule::Call(call) = element_rule
&& call.path.is_ident("message")
{
return Err(Error::new_spanned(
&call.path,
"`message` goes on the rules inside `each`, not on `each` itself",
));
}
}
Ok(element_rules.into_iter().collect())
}
impl Parse for StructRule {
fn parse(input: ParseStream) -> syn::Result<Self> {
let path = input.call(Path::parse_mod_style)?;
if path.is_ident("report_all") {
return Ok(Self::ReportAll);
}
if !path.is_ident("custom") {
return Err(Error::new_spanned(
path,
"a struct's `#[validate(...)]` takes `report_all` and `custom(...)`",
));
}
Ok(Self::Custom(Box::new(StructCustom::parse_after(&path, input)?)))
}
}
const STRUCT_CUSTOM_ARGUMENTS: &str = "`custom` on a struct takes one function checking the struct, then optionally \
`field = ...` and `message = ...`: `custom(check, field = name)`";
impl StructCustom {
fn parse_after(custom: &Path, input: ParseStream) -> syn::Result<Self> {
if !input.peek(token::Paren) {
return Err(Error::new_spanned(custom, STRUCT_CUSTOM_ARGUMENTS));
}
let arguments;
parenthesized!(arguments in input);
let mut check = None;
let mut field = None;
let mut message = None;
for argument in Punctuated::<Argument, Token![,]>::parse_terminated(&arguments)? {
match argument {
Argument::Value(value) if check.is_none() => check = Some(value),
Argument::Named(named) if named.name == "field" => field = Some(named.value),
Argument::Named(named) if named.name == "message" => message = Some(named.value),
Argument::Value(value) => return Err(Error::new_spanned(value, STRUCT_CUSTOM_ARGUMENTS)),
Argument::Named(named) => return Err(Error::new_spanned(named.name, STRUCT_CUSTOM_ARGUMENTS)),
}
}
let check = check.ok_or_else(|| Error::new_spanned(custom, STRUCT_CUSTOM_ARGUMENTS))?;
Ok(Self {
check,
field,
message,
span: custom.span(),
})
}
}
impl RuleCall {
fn parse_after(path: Path, input: ParseStream) -> syn::Result<Self> {
if input.peek(Token![=]) {
input.parse::<Token![=]>()?;
return Ok(Self {
value: Some(input.parse()?),
..Self::without_arguments(path)
});
}
if !input.peek(token::Paren) {
return Ok(Self::without_arguments(path));
}
let arguments;
parenthesized!(arguments in input);
let arguments = Punctuated::<Argument, Token![,]>::parse_terminated(&arguments)?;
Self::from_arguments(path, arguments)
}
fn without_arguments(path: Path) -> Self {
Self {
path,
value: None,
builder_arguments: Vec::new(),
message: None,
}
}
fn from_arguments(path: Path, arguments: impl IntoIterator<Item = Argument>) -> syn::Result<Self> {
let mut rule = Self::without_arguments(path);
for argument in arguments {
match argument {
Argument::Named(named) if named.name == "message" => rule.message = Some(named.value),
Argument::Named(named) => rule.builder_arguments.push(named),
Argument::Value(value) if rule.value.is_some() => {
return Err(Error::new_spanned(value, "a rule takes one value at most"));
}
Argument::Value(value) => rule.value = Some(value),
}
}
if let (Some(_), Some(builder_argument)) = (&rule.value, rule.builder_arguments.first()) {
return Err(Error::new_spanned(
&builder_argument.name,
"a rule takes either one value or named arguments, not both",
));
}
Ok(rule)
}
pub fn has_arguments(&self) -> bool {
self.value.is_some() || !self.builder_arguments.is_empty() || self.message.is_some()
}
}
impl Parse for Argument {
fn parse(input: ParseStream) -> syn::Result<Self> {
let is_named = input.peek(Ident) && input.peek2(Token![=]) && !input.peek2(Token![==]);
if !is_named {
return Ok(Self::Value(input.parse()?));
}
let name = input.parse()?;
input.parse::<Token![=]>()?;
let value = input.parse()?;
Ok(Self::Named(NamedArgument { name, value }))
}
}