Function parse_length

validify_derive/src/validate/parser.rs:94–149

(meta: &ParseNestedMeta)

parser!(parse_required_full, Required);

pub fn parse_length(meta: &ParseNestedMeta) -> Result<Length, syn::Error> {
    let mut validation = Length::default();

    meta.parse_nested_meta(|meta| {
        if meta.path.is_ident("min") {
            let content = meta.value()?;
            match content.parse::<LitInt>() {
                Ok(lit) => validation.min = Some(ValueOrPath::Value(lit.base10_parse::<u64>()?)),
                Err(_) => match content.parse::<syn::Path>() {
                    Ok(path) => validation.min = Some(ValueOrPath::Path(path)),
                    Err(_) => {
                        return Err(meta.error("Length parameter must be an int literal or path"))
                    }
                },
            }
            return Ok(());
        }

        if meta.path.is_ident("max") {
            let content = meta.value()?;
            match content.parse::<LitInt>() {
                Ok(lit) => validation.max = Some(ValueOrPath::Value(lit.base10_parse::<u64>()?)),
                Err(_) => match content.parse::<syn::Path>() {
                    Ok(path) => validation.max = Some(ValueOrPath::Path(path)),
                    Err(_) => {
                        return Err(meta.error("Length parameter must be an int literal or path"))
                    }
                },
            }
            return Ok(());
        }

        if meta.path.is_ident("equal") {
            let content = meta.value()?;
            if validation.max.is_some() || validation.min.is_some() {
                return Err(meta.error("equal parameter cannot be set if max or min exist"));
            }
            match content.parse::<LitInt>() {
                Ok(lit) => validation.equal = Some(ValueOrPath::Value(lit.base10_parse::<u64>()?)),
                Err(_) => match content.parse::<syn::Path>() {
                    Ok(path) => validation.equal = Some(ValueOrPath::Path(path)),
                    Err(_) => {
                        return Err(meta.error("Length parameter must be an int literal or path"))
                    }
                },
            }
            return Ok(());
        }

        code_and_message!(validation, meta);

        Err(meta.error("Unrecognized length parameter"))
    })?;

    Ok(validation)
}

pub fn parse_range(meta: &ParseNestedMeta) -> Result<Range, syn::Error> {