fn extract_immediate_dependencies()

in focus/internals/src/lib/target_resolver/incremental_bazel_resolver.rs [249:322]
59 lines of code
3 McCabe index (conditional complexity)

    fn extract_immediate_dependencies(
        &self,
        app: Arc<App>,
        request: &ResolutionRequest,
        targets: BTreeSet<Label>,
    ) -> Result<BTreeMap<DependencyKey, DependencyValue>> {
        let query = bazel_common::make_set(targets.iter());
        let bazel_de::Query { rules } =
            Self::run_bazel_query_xml(app, request, vec!["--noimplicit_deps"], &query)?;

        let mut immediate_deps: BTreeMap<DependencyKey, BTreeSet<DependencyKey>> = BTreeMap::new();
        for rule in rules {
            use bazel_de::{QueryElement, Rule, RuleElement};

            match rule {
                QueryElement::Rule(Rule {
                    name,
                    location: _,
                    elements,
                }) => {
                    let target_label: Label = name.parse()?;

                    let mut rule_inputs = BTreeSet::new();
                    for rule_element in elements {
                        match rule_element {
                            RuleElement::RuleInput { name } => {
                                let label: Label = name.parse()?;
                                rule_inputs.insert(DependencyKey::BazelPackage(label));
                            }

                            RuleElement::Boolean { .. }
                            | RuleElement::Int { .. }
                            | RuleElement::String { .. }
                            | RuleElement::List { .. }
                            | RuleElement::Dict { .. }
                            | RuleElement::Label(_)
                            | RuleElement::VisibilityLabel { .. }
                            | RuleElement::RuleDefaultSetting { .. }
                            | RuleElement::RuleOutput { .. }
                            | RuleElement::Output { .. }
                            | RuleElement::Tristate { .. } => {
                                // Do nothing.
                            }
                        }
                    }

                    let key = DependencyKey::BazelPackage(target_label);
                    immediate_deps.entry(key).or_default().extend(rule_inputs);
                }

                QueryElement::SourceFile { name, body: () }
                | QueryElement::GeneratedFile { name, body: () } => {
                    let target_label: Label = name.parse()?;
                    let key = DependencyKey::BazelPackage(target_label);

                    // Create an entry for this package if it doesn't exist. We
                    // don't need to add any dependencies, since source files
                    // inside the package will already be checked out as part of
                    // materializing the package itself, and generated files will be generated by whatever rule generates them.
                    immediate_deps.entry(key.clone()).or_default();
                }

                QueryElement::PackageGroup { body: () } => {
                    // TODO: do we need to do anything for these cases?
                }
            }
        }

        let result: BTreeMap<DependencyKey, DependencyValue> = immediate_deps
            .into_iter()
            .map(|(k, v)| (k, DependencyValue::PackageInfo { deps: v }))
            .collect();
        Ok(result)
    }