fn let_encoded_exprs()

in api_generator/src/generator/code_gen/url/url_builder.rs [228:267]

• 37 lines of code
• 1 McCabe index (conditional complexity)

    fn let_encoded_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 path_expr = match &parts[p].ty {
                        TypeKind::String => path_none(name).into_expr(),
                        _ => path_none(format!("{}_str", name).as_str()).into_expr(),
                    };

                    let encoded_ident = ident(format!("encoded_{}", name));
                    let percent_encode_call: syn::Expr = syn::ExprKind::Call(
                        Box::new(path_none("percent_encode").into_expr()),
                        vec![
                            syn::ExprKind::MethodCall(ident("as_bytes"), vec![], vec![path_expr])
                                .into(),
                            path_none("PARTS_ENCODED").into_expr(),
                        ],
                    )
                    .into();

                    let into_call: syn::Expr =
                        syn::ExprKind::MethodCall(ident("into"), vec![], vec![percent_encode_call])
                            .into();

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