Function parse_range

validify_derive/src/validate/parser.rs:151–189

(meta: &ParseNestedMeta)

}

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

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

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

        code_and_message!(validation, meta);

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

    Ok(validation)
}

pub fn parse_contains_full(meta: &ParseNestedMeta, not: bool) -> Result<Contains, syn::Error> {
    let mut validation = Contains {