Examples with DependencyResult org.gradle.api.artifacts.result.DependencyResult used on opensource projects

Example 16 with DependencyResult

use of org.gradle.api.artifacts.result.DependencyResult in project gradle by gradle.

the class DependencyInsightReportTask method report.

@TaskAction
public void report() {
    assertValidTaskConfiguration();
    ResolvedComponentResult rootComponent = getRootComponentProperty().get();
    StyledTextOutput output = getTextOutputFactory().create(getClass());
    Set<DependencyResult> selectedDependencies = selectDependencies(rootComponent);
    if (selectedDependencies.isEmpty()) {
        output.println("No dependencies matching given input were found in " + configurationDescription);
        return;
    }
    errorHandler.renderErrors(output);
    renderSelectedDependencies(output, selectedDependencies);
    renderBuildScanHint(output);
}

Example 17 with DependencyResult

use of org.gradle.api.artifacts.result.DependencyResult in project atlas by alibaba.

the class AtlasDepTreeParser method parseDependencyTree.

public AtlasDependencyTree parseDependencyTree(@NonNull VariantDependencies variantDeps) {
    // 
    String name = variantDeps.getName().toLowerCase();
    if (!name.endsWith("debug") && !name.endsWith("release")) {
        return new AtlasDependencyTree(new ArrayList<>());
    }
    if (!name.equals("debug") && name.endsWith("debug")) {
        flavorName = variantDeps.getName().substring(0, name.length() - 5);
    }
    if (!name.equals("release") && name.endsWith("release")) {
        flavorName = variantDeps.getName().substring(0, name.length() - 6);
    }
    Configuration compileClasspath = variantDeps.getCompileClasspath();
    Configuration runtimeClasspath = variantDeps.getRuntimeClasspath();
    Configuration apiClasspath = variantDeps.getApiElements();
    Configuration configuration = variantDeps.getAnnotationProcessorConfiguration();
    Configuration bundleClasspath = project.getConfigurations().maybeCreate(AtlasPlugin.BUNDLE_COMPILE);
    ensureConfigured(compileClasspath, project);
    ensureConfigured(runtimeClasspath, project);
    ensureConfigured(bundleClasspath, project);
    ensureConfigured(apiClasspath, project);
    ensureConfigured(configuration, project);
    Map<ModuleVersionIdentifier, List<ResolvedArtifact>> artifacts = Maps.newHashMap();
    collectArtifacts(compileClasspath, artifacts);
    collectArtifacts(runtimeClasspath, artifacts);
    collectArtifacts(apiClasspath, artifacts);
    collectArtifacts(bundleClasspath, artifacts);
    collectArtifacts(configuration, artifacts);
    unEnsureConfigured(compileClasspath);
    unEnsureConfigured(runtimeClasspath);
    unEnsureConfigured(bundleClasspath);
    unEnsureConfigured(apiClasspath);
    unEnsureConfigured(configuration);
    // Rely on the group
    DependencyGroup dependencyGroup = new DependencyGroup(compileClasspath, bundleClasspath, artifacts, awbs);
    DependencyResolver dependencyResolver = new DependencyResolver(project, variantDeps, artifacts, dependencyGroup.bundleProvidedMap, dependencyGroup.bundleCompileMap);
    mResolvedDependencies.addAll(dependencyResolver.resolve(dependencyGroup.compileDependencies, true));
    for (DependencyResult dependencyResult : dependencyGroup.bundleDependencies) {
        mResolvedDependencies.addAll(dependencyResolver.resolve(Arrays.asList(dependencyResult), false));
    }
    AtlasDependencyTree atlasDependencyTree = toAtlasDependencyTree();
    check(atlasDependencyTree);
    return atlasDependencyTree;
}

Example 18 with DependencyResult

use of org.gradle.api.artifacts.result.DependencyResult in project atlas by alibaba.

the class DependencyResolver method resolve.

public List<ResolvedDependencyInfo> resolve(List<DependencyResult> dependencyResults, boolean mainBundle) {
    Multimap<String, ResolvedDependencyInfo> dependenciesMap = LinkedHashMultimap.create();
    // Instead of using the official flat dependency treatment, you can use your own tree dependence; For application dependencies, we only take compile dependencies
    Set<ModuleVersionIdentifier> directDependencies = new HashSet<ModuleVersionIdentifier>();
    Set<String> resolveSets = new HashSet<>();
    for (DependencyResult dependencyResult : dependencyResults) {
        if (dependencyResult instanceof ResolvedDependencyResult) {
            ModuleVersionIdentifier moduleVersion = ((ResolvedDependencyResult) dependencyResult).getSelected().getModuleVersion();
            CircleDependencyCheck circleDependencyCheck = new CircleDependencyCheck(moduleVersion);
            if (!directDependencies.contains(moduleVersion)) {
                directDependencies.add(moduleVersion);
                resolveDependency(null, ((ResolvedDependencyResult) dependencyResult).getSelected(), artifacts, variantDeps, 0, circleDependencyCheck, circleDependencyCheck.getRootDependencyNode(), dependenciesMap, resolveSets, mainBundle);
            }
        }
    }
    List<ResolvedDependencyInfo> mainResolvdInfo = resolveAllDependencies(dependenciesMap);
    if (mainBundle) {
        for (ResolvedDependencyInfo resolvedDependencyInfo : mainResolvdInfo) {
            addMainDependencyInfo(resolvedDependencyInfo);
        }
    }
    return mainResolvdInfo;
}

Example 19 with DependencyResult

use of org.gradle.api.artifacts.result.DependencyResult in project atlas by alibaba.

the class DependencyResolver method resolveDependency.

/**
 * Analytical dependence
 *  @param parent
 * @param resolvedComponentResult
 * @param artifacts
 * @param configDependencies
 * @param indent
 * @param mainBundle
 */
private void resolveDependency(ResolvedDependencyInfo parent, ResolvedComponentResult resolvedComponentResult, Map<ModuleVersionIdentifier, List<ResolvedArtifact>> artifacts, VariantDependencies configDependencies, int indent, CircleDependencyCheck circleDependencyCheck, CircleDependencyCheck.DependencyNode node, Multimap<String, ResolvedDependencyInfo> dependenciesMap, Set<String> resolvedDependencies, boolean mainBundle) {
    ModuleVersionIdentifier moduleVersion = resolvedComponentResult.getModuleVersion();
    // }
    if (!ids.contains(moduleVersion.getGroup() + ":" + moduleVersion.getName())) {
        artifacts.put(moduleVersion, Lists.newArrayList((DependencyGroup.bundleCompileId.get(moduleVersion))));
    }
    // now loop on all the artifact for this modules.
    List<ResolvedArtifact> moduleArtifacts = artifacts.get(moduleVersion);
    ComponentIdentifier id = resolvedComponentResult.getId();
    String gradlePath = (id instanceof ProjectComponentIdentifier) ? ((ProjectComponentIdentifier) id).getProjectPath() : null;
    // If you can find multiple dependencies at the same time, you can't judge for the time being that it's really useful
    if (null != moduleArtifacts) {
        for (ResolvedArtifact resolvedArtifact : moduleArtifacts) {
            String key = moduleVersion.getGroup() + ":" + moduleVersion.getName();
            // remove android.jar
            if (key.equals("com.google.android:android")) {
                continue;
            }
            if (mainDependencies.contains(key)) {
                continue;
            }
            if (resolvedDependencies.contains(key)) {
                continue;
            }
            // 
            resolvedDependencies.add(key);
            boolean isAwbBundle = bundleProvidedMap.containsKey(key);
            Set<String> providedDirectDep = bundleProvidedMap.get(key);
            ResolvedDependencyInfo resolvedDependencyInfo = new ResolvedDependencyInfo(moduleVersion.getVersion(), moduleVersion.getGroup(), moduleVersion.getName(), !mainBundle ? "awb" : resolvedArtifact.getType(), resolvedArtifact.getClassifier());
            resolvedDependencyInfo.setIndent(indent);
            resolvedDependencyInfo.setGradlePath(gradlePath);
            resolvedDependencyInfo.setResolvedArtifact(resolvedArtifact);
            String path = AtlasDepHelper.computeArtifactPath(moduleVersion, resolvedArtifact);
            String name = AtlasDepHelper.computeArtifactName(moduleVersion, resolvedArtifact);
            MavenCoordinates mavenCoordinates = DependencyConvertUtils.convert(resolvedArtifact, !mainBundle ? DependencyConvertUtils.Type.AWB : DependencyConvertUtils.Type.AAR);
            File explodedDir = DependencyLocationManager.getExploreDir(project, mavenCoordinates, resolvedArtifact.getFile(), !mainBundle ? "awb" : resolvedArtifact.getType().toLowerCase(), path);
            resolvedDependencyInfo.setExplodedDir(explodedDir);
            resolvedDependencyInfo.setDependencyName(name);
            if (null == parent) {
                parent = resolvedDependencyInfo;
            } else {
                resolvedDependencyInfo.setParent(parent);
                parent.getChildren().add(resolvedDependencyInfo);
            }
            Set<DependencyResult> dependencyResults = null;
            Set<? extends DependencyResult> dependencies = (Set<DependencyResult>) resolvedComponentResult.getDependencies();
            if (bundleCompileMap.containsKey(resolvedDependencyInfo.getGroup() + ":" + resolvedDependencyInfo.getName())) {
                dependencyResults = bundleCompileMap.get(parent.getGroup() + ":" + parent.getName());
            }
            Set<DependencyResult> combineDependencies = combine(dependencyResults, dependencies);
            if (null != combineDependencies) {
                for (DependencyResult dep : combineDependencies) {
                    if (dep instanceof ResolvedDependencyResult) {
                        ResolvedComponentResult childResolvedComponentResult = ((ResolvedDependencyResult) dep).getSelected();
                        if (isAwbBundle && providedDirectDep.contains(childResolvedComponentResult.getModuleVersion().getGroup() + ":" + childResolvedComponentResult.getModuleVersion().getName())) {
                            continue;
                        }
                        CircleDependencyCheck.DependencyNode childNode = circleDependencyCheck.addDependency(childResolvedComponentResult.getModuleVersion(), node, indent + 1);
                        CircleDependencyCheck.CircleResult circleResult = circleDependencyCheck.checkCircle(logger);
                        if (circleResult.hasCircle) {
                            logger.warning("[CircleDependency]" + StringUtils.join(circleResult.detail, ";"));
                        } else {
                            resolveDependency(parent, ((ResolvedDependencyResult) dep).getSelected(), artifacts, configDependencies, indent + 1, circleDependencyCheck, childNode, dependenciesMap, resolvedDependencies, true);
                        }
                    }
                }
            }
            addDependencyInfo(resolvedDependencyInfo, null, dependenciesMap);
        }
    }
}