fn let_parameters_exprs()

in api_generator/src/generator/code_gen/url/url_builder.rs [270:336]

• 59 lines of code
• 3 McCabe index (conditional complexity)

    fn let_parameters_exprs(
        url: &[PathPart<'a>],
        parts: &BTreeMap<String, Type>,
    ) -> Vec<syn::Stmt> {
        url.iter()
            .filter_map(|p| match *p {
                PathPart::Param(p) => {
                    let name = valid_name(p);
                    let name_ident = ident(name);
                    let ty = &parts[p].ty;

                    // don't generate an assignment expression for strings
                    if ty == &TypeKind::String {
                        return None;
                    }

                    let tokens = quote!(#name_ident);
                    // build a different expression, depending on the type of parameter
                    let (ident, init) = match ty {
                        TypeKind::List => {
                            // Join list values together
                            let name_str = format!("{}_str", &name);
                            let name_str_ident = ident(&name_str);
                            let join_call = syn::ExprKind::MethodCall(
                                ident("join"),
                                vec![],
                                vec![
                                    parse_expr(tokens),
                                    syn::ExprKind::Lit(syn::Lit::Str(
                                        ",".into(),
                                        syn::StrStyle::Cooked,
                                    ))
                                    .into(),
                                ],
                            )
                            .into();

                            (name_str_ident, join_call)
                        }
                        _ => {
                            // Handle enums, long, int, etc. by calling to_string()
                            let to_string_call = syn::ExprKind::MethodCall(
                                ident("to_string"),
                                vec![],
                                vec![parse_expr(tokens)],
                            )
                            .into();

                            (ident(format!("{}_str", name)), to_string_call)
                        }
                    };

                    Some(syn::Stmt::Local(Box::new(syn::Local {
                        pat: Box::new(syn::Pat::Ident(
                            syn::BindingMode::ByValue(syn::Mutability::Immutable),
                            ident,
                            None,
                        )),
                        ty: None,
                        init: Some(Box::new(init)),
                        attrs: vec![],
                    })))
                }
                _ => None,
            })
            .collect()
    }