private void extractConfigurationImpl()

in buildSrc/src/main/java/com/uber/okbuck/core/model/base/Scope.java [417:527]
90 lines of code
12 McCabe index (conditional complexity)

  private void extractConfigurationImpl(
      Configuration configuration,
      Set<String> projectFirstLevel,
      Set<VersionlessDependency> externalFirstLevel) {
    DependencyFactory factory = ProjectUtil.getDependencyFactory(project);

    Set<ResolvedArtifactResult> jarArtifacts =
        getArtifacts(configuration, PROJECT_FILTER, ImmutableList.of("jar"));

    jarArtifacts.forEach(
        artifact -> {
          if (!DependencyUtils.isConsumable(artifact.getFile())) {
            return;
          }

          ProjectComponentIdentifier identifier =
              (ProjectComponentIdentifier) artifact.getId().getComponentIdentifier();
          VariantAttr variantAttr =
              artifact.getVariant().getAttributes().getAttribute(VariantAttr.ATTRIBUTE);
          String variant = variantAttr == null ? null : variantAttr.getName();

          Project identifierProject = project.project(identifier.getProjectPath());

          Target target =
              ProjectCache.getTargetCache(identifierProject).getTargetForVariant(variant);
          allTargetDeps.add(target);

          if (projectFirstLevel.contains(identifierProject.getPath())) {
            firstLevelTargetDeps.add(target);
          }
        });

    Set<ResolvedArtifactResult> aarOrJarArtifacts =
        getArtifacts(configuration, EXTERNAL_DEP_FILTER, ImmutableList.of("aar", "jar"));

    OkBuckExtension okBuckExtension = ProjectUtil.getOkBuckExtension(project);
    ExternalDependenciesExtension externalDependenciesExtension =
        okBuckExtension.getExternalDependenciesExtension();
    JetifierExtension jetifierExtension = okBuckExtension.getJetifierExtension();

    Set<ResolvedArtifactResult> consumableArtifacts =
        aarOrJarArtifacts
            .stream()
            .filter(artifact -> DependencyUtils.isConsumable(artifact.getFile()))
            .collect(Collectors.toSet());

    Map<ComponentIdentifier, ResolvedArtifactResult> componentIdToSourcesArtifactMap =
        ProjectUtil.downloadSources(project, consumableArtifacts);

    consumableArtifacts.forEach(
        artifact -> {
          ComponentIdentifier identifier = artifact.getId().getComponentIdentifier();
          ResolvedArtifactResult sourcesArtifact = componentIdToSourcesArtifactMap.get(identifier);

          if (identifier instanceof ModuleComponentIdentifier
              && ((ModuleComponentIdentifier) identifier).getVersion().length() > 0) {
            ModuleComponentIdentifier moduleIdentifier = (ModuleComponentIdentifier) identifier;

            @Var
            OExternalDependency externalDependency =
                factory.from(
                    moduleIdentifier.getGroup(),
                    moduleIdentifier.getModule(),
                    moduleIdentifier.getVersion(),
                    artifact.getFile(),
                    sourcesArtifact != null ? sourcesArtifact.getFile() : null,
                    externalDependenciesExtension,
                    jetifierExtension);

            externalDependency = depCache.get(externalDependency);
            allExternal.put(externalDependency.getVersionless(), externalDependency);

            if (externalFirstLevel.contains(externalDependency.getVersionless())) {
              firstLevelExternal.put(externalDependency.getVersionless(), externalDependency);
            }

          } else {
            String rootProjectPath = project.getRootProject().getProjectDir().getAbsolutePath();
            String artifactPath = artifact.getFile().getAbsolutePath();

            try {
              if (!FilenameUtils.directoryContains(rootProjectPath, artifactPath)
                  && !DependencyUtils.isWhiteListed(artifact.getFile())) {

                throw new IllegalStateException(
                    String.format(
                        "Local dependencies should be under project root. Dependencies "
                            + "outside the project can cause hard to reproduce builds"
                            + ". Please move dependency: %s inside %s",
                        artifact.getFile(), project.getRootProject().getProjectDir()));
              }
              @Var
              OExternalDependency localExternalDependency =
                  factory.fromLocal(
                      artifact.getFile(),
                      sourcesArtifact != null ? sourcesArtifact.getFile() : null,
                      externalDependenciesExtension,
                      jetifierExtension);

              localExternalDependency = depCache.get(localExternalDependency);
              allExternal.put(localExternalDependency.getVersionless(), localExternalDependency);

              // All all local deps to first level
              firstLevelExternal.put(
                  localExternalDependency.getVersionless(), localExternalDependency);
            } catch (IOException e) {
              throw new IllegalStateException(e);
            }
          }
        });
  }