fn create_body_fn()

in api_generator/src/generator/code_gen/request/request_builder.rs [243:320]

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

    fn create_body_fn(
        builder_name: &str,
        builder_ident: &syn::Ident,
        default_fields: &[&syn::Ident],
        accepts_nd_body: bool,
    ) -> syn::ImplItem {
        let fields = default_fields
            .iter()
            .filter(|&&part| part != &ident("body"))
            .map(|&part| syn::FieldValue {
                attrs: vec![],
                ident: ident(part),
                expr: syn::ExprKind::Path(
                    None,
                    path_none(ident(format!("self.{}", part.as_ref())).as_ref()),
                )
                .into(),
                is_shorthand: false,
            });

        let (fn_arg, field_arg, ret_ty) = if accepts_nd_body {
            (
                syn::parse_type("Vec<T>").unwrap(),
                quote!(Some(NdBody::new(body))),
                syn::FunctionRetTy::Ty(code_gen::ty(
                    format!("{}<'a, 'b, NdBody<T>> where T: Body", &builder_name).as_ref(),
                )),
            )
        } else {
            (
                syn::parse_type("T").unwrap(),
                quote!(Some(body.into())),
                syn::FunctionRetTy::Ty(code_gen::ty(
                    format!("{}<'a, 'b, JsonBody<T>> where T: Serialize", &builder_name).as_ref(),
                )),
            )
        };

        syn::ImplItem {
            ident: ident("body<T>"),
            vis: syn::Visibility::Public,
            defaultness: syn::Defaultness::Final,
            attrs: vec![doc("The body for the API call")],
            node: syn::ImplItemKind::Method(
                syn::MethodSig {
                    unsafety: syn::Unsafety::Normal,
                    constness: syn::Constness::NotConst,
                    abi: None,
                    decl: syn::FnDecl {
                        inputs: vec![
                            syn::FnArg::SelfValue(syn::Mutability::Immutable),
                            syn::FnArg::Captured(syn::Pat::Path(None, path_none("body")), fn_arg),
                        ],
                        output: ret_ty,
                        variadic: false,
                    },
                    generics: generics_none(),
                },
                // generates a fn body of the form
                // --------
                // <builder_name> {
                //     body: body,
                //     ... assign rest of fields
                // }
                // ---------
                syn::Block {
                    stmts: vec![syn::Stmt::Expr(Box::new(parse_expr(quote!(
                            #builder_ident {
                                transport: self.transport,
                                parts: self.parts,
                                body: #field_arg,
                                #(#fields),*,
                            }
                    ))))],
                },
            ),
        }
    }