fn parts()

in api_generator/src/generator/code_gen/url/enum_builder.rs [106:153]

• 44 lines of code
• 5 McCabe index (conditional complexity)

    fn parts(path: &Path) -> syn::Variant {
        let params = &path.path.params();

        let name = params
            .iter()
            .map(|k| k.to_pascal_case())
            .collect::<Vec<_>>()
            .join("");

        let doc = match params.len() {
            1 => doc(params[0].replace('_', " ").to_pascal_case()),
            n => {
                let mut d: String = params
                    .iter()
                    .enumerate()
                    .filter(|&(i, _)| i != n - 1)
                    .map(|(_, e)| e.replace('_', " ").to_pascal_case())
                    .collect::<Vec<_>>()
                    .join(", ");

                d.push_str(
                    format!(" and {}", params[n - 1].replace('_', " ").to_pascal_case()).as_str(),
                );
                doc(d)
            }
        };

        syn::Variant {
            ident: ident(name),
            attrs: vec![doc],
            discriminant: None,
            data: syn::VariantData::Tuple(
                path.path
                    .params()
                    .iter()
                    .map(|&p| {
                        let ty = &path.parts[p].ty;
                        syn::Field {
                            ident: None,
                            vis: syn::Visibility::Inherited,
                            attrs: vec![],
                            ty: typekind_to_ty(p, ty, true, false),
                        }
                    })
                    .collect(),
            ),
        }
    }