fn resolve()

in focus/internals/src/lib/target_resolver/mod.rs [147:208]
58 lines of code
2 McCabe index (conditional complexity)

    fn resolve(
        &self,
        request: &ResolutionRequest,
        cache_options: &CacheOptions,
        app: Arc<App>,
    ) -> Result<ResolutionResult> {
        use rayon::prelude::*;

        let subrequests = {
            let mut bazel_targets = HashSet::new();
            let mut directory_targets = HashSet::new();
            for target in request.targets.iter().cloned() {
                match target {
                    target @ Target::Bazel(_) => {
                        bazel_targets.insert(target);
                    }
                    target @ Target::Directory(_) => {
                        directory_targets.insert(target);
                    }
                }
            }

            let bazel_subrequest = ResolutionRequest {
                targets: bazel_targets,
                ..request.clone()
            };
            let directory_subrequest = ResolutionRequest {
                targets: directory_targets,
                ..request.clone()
            };
            vec![bazel_subrequest, directory_subrequest]
        };

        subrequests
            .par_iter()
            .map(|subrequest| {
                let app_clone = app.clone();

                match subrequest.targets.iter().next() {
                    Some(Target::Bazel(_)) => {
                        match subrequest.options.bazel_resolution_strategy {
                            BazelResolutionStrategy::Incremental => self
                                .incremental_bazel_resolver
                                .resolve(subrequest, cache_options, app_clone),
                            BazelResolutionStrategy::OneShot => self
                                .oneshot_bazel_resolver
                                .resolve(subrequest, cache_options, app_clone),
                        }
                    }
                    Some(Target::Directory(_)) => {
                        self.directory_resolver
                            .resolve(subrequest, cache_options, app_clone)
                    }
                    None => Ok(Default::default()),
                }
            })
            .try_reduce(ResolutionResult::new, |mut acc, result| {
                acc.merge(result);
                Ok(acc)
            })
            .context("Resolving targets failed")
    }