private void processDependency()

in maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/df/DfDependencyCollector.java [176:311]
119 lines of code
14 McCabe index (conditional complexity)

    private void processDependency(
            Args args,
            RequestTrace parent,
            Results results,
            List<RemoteRepository> repositories,
            DependencySelector depSelector,
            DependencyManager depManager,
            DependencyTraverser depTraverser,
            VersionFilter verFilter,
            Dependency dependency,
            List<Artifact> relocations,
            boolean disableVersionManagement) {
        if (depSelector != null && !depSelector.selectDependency(dependency)) {
            return;
        }

        RequestTrace trace = collectStepTrace(parent, args.request.getRequestContext(), args.nodes.nodes, dependency);
        PremanagedDependency preManaged =
                PremanagedDependency.create(depManager, dependency, disableVersionManagement, args.premanagedState);
        dependency = preManaged.getManagedDependency();

        boolean noDescriptor = isLackingDescriptor(args.session, dependency.getArtifact());

        boolean traverse = !noDescriptor && (depTraverser == null || depTraverser.traverseDependency(dependency));

        List<? extends Version> versions;
        VersionRangeResult rangeResult;
        try {
            VersionRangeRequest rangeRequest =
                    createVersionRangeRequest(args.request.getRequestContext(), trace, repositories, dependency);

            rangeResult = cachedResolveRangeResult(rangeRequest, args.pool, args.session);

            versions = filterVersions(dependency, rangeResult, verFilter, args.versionContext);
        } catch (VersionRangeResolutionException e) {
            results.addException(dependency, e, args.nodes.nodes);
            return;
        }

        for (Version version : versions) {
            Artifact originalArtifact = dependency.getArtifact().setVersion(version.toString());
            Dependency d = dependency.setArtifact(originalArtifact);

            ArtifactDescriptorRequest descriptorRequest =
                    createArtifactDescriptorRequest(args.request.getRequestContext(), trace, repositories, d);

            final ArtifactDescriptorResult descriptorResult =
                    getArtifactDescriptorResult(args, results, noDescriptor, d, descriptorRequest);
            if (descriptorResult != null) {
                d = d.setArtifact(descriptorResult.getArtifact());

                DependencyNode node = args.nodes.top();

                int cycleEntry = DefaultDependencyCycle.find(args.nodes.nodes, d.getArtifact());
                if (cycleEntry >= 0) {
                    results.addCycle(args.nodes.nodes, cycleEntry, d);
                    DependencyNode cycleNode = args.nodes.get(cycleEntry);
                    if (cycleNode.getDependency() != null) {
                        DefaultDependencyNode child = createDependencyNode(
                                relocations, preManaged, rangeResult, version, d, descriptorResult, cycleNode);
                        node.getChildren().add(child);
                        continue;
                    }
                }

                if (!descriptorResult.getRelocations().isEmpty()) {
                    boolean disableVersionManagementSubsequently =
                            originalArtifact.getGroupId().equals(d.getArtifact().getGroupId())
                                    && originalArtifact
                                            .getArtifactId()
                                            .equals(d.getArtifact().getArtifactId());

                    processDependency(
                            args,
                            parent,
                            results,
                            repositories,
                            depSelector,
                            depManager,
                            depTraverser,
                            verFilter,
                            d,
                            descriptorResult.getRelocations(),
                            disableVersionManagementSubsequently);
                    return;
                } else {
                    d = args.pool.intern(d.setArtifact(args.pool.intern(d.getArtifact())));

                    List<RemoteRepository> repos =
                            getRemoteRepositories(rangeResult.getRepository(version), repositories);

                    DefaultDependencyNode child = createDependencyNode(
                            relocations,
                            preManaged,
                            rangeResult,
                            version,
                            d,
                            descriptorResult.getAliases(),
                            repos,
                            args.request.getRequestContext());

                    node.getChildren().add(child);

                    boolean recurse =
                            traverse && !descriptorResult.getDependencies().isEmpty();
                    if (recurse) {
                        doRecurse(
                                args,
                                parent,
                                results,
                                repositories,
                                depSelector,
                                depManager,
                                depTraverser,
                                verFilter,
                                d,
                                descriptorResult,
                                child);
                    }
                }
            } else {
                DependencyNode node = args.nodes.top();
                List<RemoteRepository> repos = getRemoteRepositories(rangeResult.getRepository(version), repositories);
                DefaultDependencyNode child = createDependencyNode(
                        relocations,
                        preManaged,
                        rangeResult,
                        version,
                        d,
                        null,
                        repos,
                        args.request.getRequestContext());
                node.getChildren().add(child);
            }
        }
    }