Function parse_time

validify_derive/src/validate/parser.rs:391–543

(meta: &ParseNestedMeta)

}

pub fn parse_time(meta: &ParseNestedMeta) -> Result<Time, syn::Error> {
    const INTERVALS: [&str; 5] = ["seconds", "minutes", "hours", "days", "weeks"];

    let mut validation = Time::default();

    meta.parse_nested_meta(|meta| {
        if meta.path.is_ident("op") {
            let content = meta.value()?;
            match content.parse::<syn::Ident>() {
                Ok(id) => {
                    validation.op = id.to_string().into();
                    if matches!(validation.op, TimeOp::None) {
                        return Err(meta.error(
                            "op must be a path corresponding to one of the time validation functions"
                        ))
                    }
                },
                Err(_) => return Err(meta.error(
                    "op must be a path corresponding to one of the time validation functions"
                )),
            }
            return Ok(());
        }

        if meta.path.is_ident("target") {
            let content = meta.value()?;
            match content.parse::<LitStr>() {
                Ok(date) => {
                    if date.value().is_empty() {
                        return Err(meta.error("target cannot be empty"));
                    }
                    validation.target = Some(ValueOrPath::Value(date.value()))
                },
                Err(_) => match content.parse::<syn::Path>() {
                    Ok(path) => {
                        validation.target = Some(ValueOrPath::Path(path))
                    },
                    Err(e) => {
                        return Err(
                            meta.error(format!("target must be a path or a string literal: {e}"))
                        )
                    }
                },
            }
            return Ok(());
        }

        if meta.path.is_ident("format") {
            let content = meta.value()?;
            match content.parse::<LitStr>() {
                Ok(format) => {
                    if format.value().is_empty() {
                        return Err(meta.error("format cannot be empty"));
                    }
                    validation.format = Some(format.value())
                },
                Err(_) => return Err(meta.error("format must be a string literal"))
            }