fn get_per_triple_metadata()

in crate_universe/src/renderer.rs [54:166]

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

fn get_per_triple_metadata(
    package: &CrateContext,
) -> BTreeMap<PlatformLabel, CrateTargetedDepContext> {
    let mut per_triple_metadata: BTreeMap<PlatformLabel, CrateTargetedDepContext> = BTreeMap::new();

    // Always add a catch-all to cover the non-targeted dep case.
    // We merge in the default_deps after the next loop.
    per_triple_metadata.insert(
        PlatformLabel::default(),
        CrateTargetedDepContext {
            target: "Default".to_owned(),
            deps: empty_deps_context(),
            platform_targets: vec!["//conditions:default".to_owned()],
        },
    );

    for dep_context in &package.targeted_deps {
        dep_context
            .platform_targets
            .iter()
            .for_each(|platform_bazel_triple| {
                let targeted_dep_ctx = per_triple_metadata
                    .entry(PlatformLabel::from_bazel_triple(platform_bazel_triple))
                    .or_insert(CrateTargetedDepContext {
                        target: "".to_owned(),
                        deps: empty_deps_context(),
                        platform_targets: vec![platform_bazel_triple.clone()],
                    });

                // Mention all the targets that translated into the current condition (ie. current triplet).
                targeted_dep_ctx
                    .target
                    .push_str(&format!(" {}", &dep_context.target));

                targeted_dep_ctx
                    .deps
                    .dependencies
                    .extend(dep_context.deps.dependencies.iter().cloned());
                targeted_dep_ctx
                    .deps
                    .proc_macro_dependencies
                    .extend(dep_context.deps.proc_macro_dependencies.iter().cloned());
                targeted_dep_ctx
                    .deps
                    .data_dependencies
                    .extend(dep_context.deps.data_dependencies.iter().cloned());
                targeted_dep_ctx
                    .deps
                    .build_dependencies
                    .extend(dep_context.deps.build_dependencies.iter().cloned());
                targeted_dep_ctx.deps.build_proc_macro_dependencies.extend(
                    dep_context
                        .deps
                        .build_proc_macro_dependencies
                        .iter()
                        .cloned(),
                );
                targeted_dep_ctx
                    .deps
                    .build_data_dependencies
                    .extend(dep_context.deps.build_data_dependencies.iter().cloned());
                targeted_dep_ctx
                    .deps
                    .dev_dependencies
                    .extend(dep_context.deps.dev_dependencies.iter().cloned());
                targeted_dep_ctx.deps.aliased_dependencies.extend(
                    dep_context
                        .deps
                        .aliased_dependencies
                        .iter()
                        .map(|(k, v)| (k.clone(), v.clone())),
                );
            });
    }

    // Now also add the non-targeted deps to each target.
    for ctx in per_triple_metadata.values_mut() {
        ctx.deps
            .dependencies
            .extend(package.default_deps.dependencies.iter().cloned());
        ctx.deps
            .proc_macro_dependencies
            .extend(package.default_deps.proc_macro_dependencies.iter().cloned());
        ctx.deps
            .data_dependencies
            .extend(package.default_deps.data_dependencies.iter().cloned());
        ctx.deps
            .build_dependencies
            .extend(package.default_deps.build_dependencies.iter().cloned());
        ctx.deps.build_proc_macro_dependencies.extend(
            package
                .default_deps
                .build_proc_macro_dependencies
                .iter()
                .cloned(),
        );
        ctx.deps
            .build_data_dependencies
            .extend(package.default_deps.build_data_dependencies.iter().cloned());
        ctx.deps
            .dev_dependencies
            .extend(package.default_deps.dev_dependencies.iter().cloned());
        ctx.deps.aliased_dependencies.extend(
            package
                .default_deps
                .aliased_dependencies
                .iter()
                .map(|(k, v)| (k.clone(), v.clone())),
        );
    }

    per_triple_metadata
}