fn parse()

in metrics/derive/src/metric.rs [46:110]
61 lines of code
3 McCabe index (conditional complexity)

    fn parse(input: ParseStream) -> syn::Result<Self> {
        let mut args = MetricArgs::default();
        let mut first = true;

        fn duplicate_arg_error(
            span: Span,
            arg: &impl std::fmt::Display,
        ) -> syn::Result<MetricArgs> {
            Err(Error::new(
                span,
                format!("Unexpected duplicate argument '{}'", arg),
            ))
        }

        while !input.is_empty() {
            if !first {
                let _: Token![,] = input.parse()?;
            }
            first = false;

            let arg: ArgName = input.fork().parse()?;
            match &*arg.to_string() {
                "name" => {
                    let name = input.parse()?;
                    match args.name {
                        None => args.name = Some(name),
                        Some(_) => return duplicate_arg_error(name.span(), &arg),
                    }
                }
                "namespace" => {
                    let namespace = input.parse()?;
                    match args.namespace {
                        None => args.namespace = Some(namespace),
                        Some(_) => return duplicate_arg_error(namespace.span(), &arg),
                    }
                }
                "description" => {
                    let description = input.parse()?;
                    match args.description {
                        None => args.description = Some(description),
                        Some(_) => return duplicate_arg_error(description.span(), &arg),
                    }
                }
                "crate" => {
                    let krate = SingleArg {
                        ident: input.parse()?,
                        eq: input.parse()?,
                        value: Path::parse_mod_style(input)?,
                    };
                    match args.krate {
                        None => args.krate = Some(krate),
                        Some(_) => return duplicate_arg_error(krate.span(), &arg),
                    }
                }
                x => {
                    return Err(Error::new(
                        arg.span(),
                        format!("Unrecognized argument '{}'", x),
                    ))
                }
            }
        }

        Ok(args)
    }