private void resolveDependencies()

in tools/src/main/java/org/wildfly/swarm/tools/DependencyManager.java [147:217]
50 lines of code
5 McCabe index (conditional complexity)

    private void resolveDependencies(DeclaredDependencies declaredDependencies, boolean autodetect) throws Exception {
        this.dependencies.clear();

        // remove thorntail-runner dependencies, if some of them are needed, they should be re-added later
        Collection<ArtifactSpec> explicitDependencies = new ArrayList<>(declaredDependencies.getDirectDependencies());

        declaredDependencies.runnerDependency().ifPresent(runner -> {
            filterOutRunnerDependencies(runner, explicitDependencies);
        });

        // resolve the explicit deps to local files
        // expand to transitive if these are not pre-solved
        boolean resolveExplicitsTransitively = !declaredDependencies.isPresolved() || autodetect;
        Map<Boolean, List<ArtifactSpec>> partitioned = explicitDependencies.stream()
                .collect(Collectors.partitioningBy(declaredDependencies::isComplete));
        List<ArtifactSpec> complete = partitioned.get(true);
        List<ArtifactSpec> incomplete = partitioned.get(false);

        Collection<ArtifactSpec> resolvedIncompleteExplicitDependencies = resolveExplicitsTransitively ?
                resolver.resolveAllArtifactsTransitively(incomplete, false) :
                resolver.resolveAllArtifactsNonTransitively(incomplete);
        Collection<ArtifactSpec> resolvedCompleteExplicitDependencies = resolver.resolveAllArtifactsNonTransitively(complete);

        Collection<ArtifactSpec> resolvedExplicitDependencies = new LinkedHashSet<>();
        resolvedExplicitDependencies.addAll(resolvedCompleteExplicitDependencies);
        resolvedExplicitDependencies.addAll(resolvedIncompleteExplicitDependencies);

        this.dependencies.addAll(resolvedExplicitDependencies);

        Collection<ArtifactSpec> inputSet;
        Collection<ArtifactSpec> resolvedTransientDependencies;
        // resolve transitives if not pre-computed (i.e. from maven/gradle plugin)
        if (declaredDependencies.getTransientDependencies().isEmpty()) {
            inputSet = explicitDependencies;
            Collection<ArtifactSpec> filtered = inputSet
                    .stream()
                    .filter(dep -> dep.type().equals(JAR)) // filter out composite types, like ear, war, etc
                    .collect(Collectors.toList());

            resolvedTransientDependencies = resolver.resolveAllArtifactsTransitively(
                    filtered, false
            );

            this.dependencies.addAll(resolvedTransientDependencies);
        } else {
            // if transitive deps are pre-computed, resolve them to local files if needed
            inputSet = declaredDependencies.getTransientDependencies();
            Collection<ArtifactSpec> filtered = inputSet
                    .stream()
                    .filter(dep -> dep.type().equals(JAR))
                    .collect(Collectors.toList());

            resolvedTransientDependencies = Collections.emptySet();
            if (filtered.size() > 0) {

                resolvedTransientDependencies = resolver.resolveAllArtifactsNonTransitively(filtered);
                this.dependencies.addAll(resolvedTransientDependencies);
            }
        }

        // add the remaining transitive ones that have not been filtered
        Collection<ArtifactSpec> remainder = new ArrayList<>(inputSet);
        remainder.removeAll(resolvedTransientDependencies);

        this.dependencies.addAll(
                resolver.resolveAllArtifactsNonTransitively(remainder)
        );

        // populate the dependency map for faster lookups
        this.dependencies.forEach(s -> dependencyMap.put(s.mavenGav(), s));
    }