private void processDependencies()

in buildSrc/src/main/java/com/uber/okbuck/core/manager/DependencyManager.java [387:470]
71 lines of code
6 McCabe index (conditional complexity)

  private void processDependencies(
      Map<VersionlessDependency, Collection<OExternalDependency>> dependencyMap,
      OkBuckExtension okBuckExtension) {
    Path rootPath = project.getRootDir().toPath();
    File cacheDir = rootPath.resolve(externalDependenciesExtension.getCache()).toFile();
    FileUtil.deleteQuitelyAndCreate(
        cacheDir,
        externalDependenciesExtension.shouldCleanCacheDir(),
        okBuckExtension.buildFileName);

    Map<Path, List<OExternalDependency>> groupToDependencyMap =
        dependencyMap
            .values()
            .stream()
            .flatMap(Collection::stream)
            .collect(
                Collectors.groupingBy(dependency -> rootPath.resolve(dependency.getTargetPath())));

    AnnotationProcessorCache annotationProcessorCache =
        ProjectUtil.getAnnotationProcessorCache(project);
    Map<Path, List<Scope>> basePathToScopeMap =
        annotationProcessorCache.getBasePathToExternalDependencyScopeMap();

    ImmutableList.Builder<OExternalDependency> bazelDependencies = ImmutableList.builder();

    groupToDependencyMap.forEach(
        (basePath, dependencies) -> {
          ImmutableList.Builder<OExternalDependency> localPrebuiltDependencies =
              ImmutableList.builder();
          ImmutableList.Builder<OExternalDependency> prebuiltDependencies = ImmutableList.builder();
          ImmutableList.Builder<OExternalDependency> httpFileDependencies = ImmutableList.builder();

          if (externalDependenciesExtension.shouldDownloadInBuck()) {
            dependencies.forEach(
                dependency -> {
                  if (dependency instanceof LocalOExternalDependency) {
                    localPrebuiltDependencies.add(dependency);
                  } else if (isPrebuiltDependency(dependency)) {
                    prebuiltDependencies.add(dependency);
                    bazelDependencies.add(dependency);
                  } else {
                    httpFileDependencies.add(dependency);
                    bazelDependencies.add(dependency);
                  }
                });
          } else {
            localPrebuiltDependencies.addAll(dependencies);
          }

          preComputeSha256(prebuiltDependencies.build(), sha256Cache);
          preComputeSha256(httpFileDependencies.build(), sha256Cache);

          ImmutableList.Builder<Rule> rulesBuilder = ImmutableList.builder();
          rulesBuilder.addAll(LocalPrebuiltRuleComposer.compose(localPrebuiltDependencies.build()));
          rulesBuilder.addAll(
              PrebuiltRuleComposer.compose(prebuiltDependencies.build(), sha256Cache));
          rulesBuilder.addAll(
              HttpFileRuleComposer.compose(httpFileDependencies.build(), sha256Cache));

          // Add annotation processor rules
          List<Scope> scopeList = basePathToScopeMap.get(basePath);
          if (scopeList != null) {
            rulesBuilder.addAll(JavaAnnotationProcessorRuleComposer.compose(scopeList));
          }

          buckFileManager.writeToBuckFile(
              rulesBuilder.build(), basePath.resolve(okBuckExtension.buildFileName).toFile());

          createSymlinks(basePath, localPrebuiltDependencies.build());
        });

    if (okBuckExtension.getExternalDependenciesExtension().bazelDepsEnabled()) {
      ImmutableList.Builder<Rule> bazelRulesBuilder = ImmutableList.builder();
      bazelRulesBuilder.add(new BazelFunctionRule());
      bazelRulesBuilder.addAll(
          BazelHttpFileRuleComposer.compose(bazelDependencies.build(), sha256Cache));

      buckFileManager.writeToBuckFile(
          "", cacheDir.toPath().resolve(okBuckExtension.buildFileName).toFile(), false);
      File defsBzl = cacheDir.toPath().resolve("defs.bzl").toFile();
      buckFileManager.writeToBuckFile(bazelRulesBuilder.build(), defsBzl);
      buckFileManager.writeToBuckFile("\n", defsBzl, true);
    }
  }