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

Example 1 with ResolvedComponentResult

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

the class TDependencyManager method addDependency.

private void addDependency(@NonNull ResolvedComponentResult resolvedComponentResult, @NonNull VariantDependencies configDependencies, @NonNull Configuration configuration, @NonNull Collection<LibraryDependency> outLibraries, @NonNull List<JarDependency> outJars, @NonNull Map<ModuleVersionIdentifier, List<LibraryDependency>> alreadyFoundLibraries, @NonNull Map<ModuleVersionIdentifier, List<JarDependency>> alreadyFoundJars, @NonNull Map<ModuleVersionIdentifier, List<ResolvedArtifact>> artifacts, @NonNull Multimap<AndroidLibrary, Configuration> reverseLibMap, @NonNull Set<String> currentUnresolvedDependencies, @Nullable String testedProjectPath, @NonNull List<String> projectChain, @NonNull Set<String> artifactSet, @NonNull ScopeType scopeType, boolean forceProvided, int indent) {
    ModuleVersionIdentifier moduleVersion = resolvedComponentResult.getModuleVersion();
    if (configDependencies.getChecker().checkForExclusion(moduleVersion)) {
        return;
    }
    if (moduleVersion.getName().equals("support-annotations") && moduleVersion.getGroup().equals("com.android.support")) {
        configDependencies.setAnnotationsPresent(true);
    }
    List<LibraryDependency> libsForThisModule = alreadyFoundLibraries.get(moduleVersion);
    List<JarDependency> jarsForThisModule = alreadyFoundJars.get(moduleVersion);
    if (libsForThisModule != null) {
        if (DEBUG_DEPENDENCY) {
            printIndent(indent, "FOUND LIB: " + moduleVersion.getName());
        }
        outLibraries.addAll(libsForThisModule);
        for (AndroidLibrary lib : libsForThisModule) {
            reverseLibMap.put(lib, configuration);
        }
    } else if (jarsForThisModule != null) {
        if (DEBUG_DEPENDENCY) {
            printIndent(indent, "FOUND JAR: " + moduleVersion.getName());
        }
        outJars.addAll(jarsForThisModule);
    } else {
        if (DEBUG_DEPENDENCY) {
            printIndent(indent, "NOT FOUND: " + moduleVersion.getName());
        }
        // new module! Might be a jar or a library
        // get the associated gradlepath
        ComponentIdentifier id = resolvedComponentResult.getId();
        String gradlePath = (id instanceof ProjectComponentIdentifier) ? ((ProjectComponentIdentifier) id).getProjectPath() : null;
        // check if this is a tested app project (via a separate test module).
        // In which case, all the dependencies must become provided.
        boolean childForceProvided = forceProvided;
        if (scopeType == ScopeType.COMPILE && testedProjectPath != null && testedProjectPath.equals(gradlePath)) {
            childForceProvided = true;
        }
        // get the nested components first.
        List<LibraryDependency> nestedLibraries = Lists.newArrayList();
        List<JarDependency> nestedJars = Lists.newArrayList();
        Set<? extends DependencyResult> dependencies = resolvedComponentResult.getDependencies();
        for (DependencyResult dependencyResult : dependencies) {
            if (dependencyResult instanceof ResolvedDependencyResult) {
                ResolvedComponentResult selected = ((ResolvedDependencyResult) dependencyResult).getSelected();
                List<String> newProjectChain = projectChain;
                ComponentIdentifier identifier = selected.getId();
                if (identifier instanceof ProjectComponentIdentifier) {
                    String projectPath = ((ProjectComponentIdentifier) identifier).getProjectPath();
                    int index = projectChain.indexOf(projectPath);
                    if (index != -1) {
                        projectChain.add(projectPath);
                        String path = Joiner.on(" -> ").join(projectChain.subList(index, projectChain.size()));
                        throw new CircularReferenceException("Circular reference between projects: " + path);
                    }
                    newProjectChain = Lists.newArrayList();
                    newProjectChain.addAll(projectChain);
                    newProjectChain.add(projectPath);
                }
                addDependency(selected, configDependencies, configuration, nestedLibraries, nestedJars, alreadyFoundLibraries, alreadyFoundJars, artifacts, reverseLibMap, currentUnresolvedDependencies, testedProjectPath, newProjectChain, artifactSet, scopeType, childForceProvided, indent + 1);
            } else if (dependencyResult instanceof UnresolvedDependencyResult) {
                ComponentSelector attempted = ((UnresolvedDependencyResult) dependencyResult).getAttempted();
                if (attempted != null) {
                    currentUnresolvedDependencies.add(attempted.toString());
                }
            }
        }
        if (DEBUG_DEPENDENCY) {
            printIndent(indent, "BACK2: " + moduleVersion.getName());
            printIndent(indent, "NESTED LIBS: " + nestedLibraries.size());
            printIndent(indent, "NESTED JARS: " + nestedJars.size());
        }
        // now loop on all the artifact for this modules.
        List<ResolvedArtifact> moduleArtifacts = artifacts.get(moduleVersion);
        if (moduleArtifacts != null) {
            for (ResolvedArtifact artifact : moduleArtifacts) {
                MavenCoordinates mavenCoordinates = createMavenCoordinates(artifact);
                boolean provided = forceProvided;
                String coordKey = computeVersionLessCoordinateKey(mavenCoordinates);
                if (scopeType == ScopeType.PACKAGE) {
                    artifactSet.add(coordKey);
                } else if (scopeType == ScopeType.COMPILE) {
                    provided |= !artifactSet.contains(coordKey);
                }
                if (EXT_LIB_ARCHIVE.equals(artifact.getExtension())) {
                    if (DEBUG_DEPENDENCY) {
                        printIndent(indent, "TYPE: AAR");
                    }
                    if (libsForThisModule == null) {
                        libsForThisModule = Lists.newArrayList();
                        alreadyFoundLibraries.put(moduleVersion, libsForThisModule);
                    }
                    String path = computeArtifactPath(moduleVersion, artifact);
                    String name = computeArtifactName(moduleVersion, artifact);
                    if (DEBUG_DEPENDENCY) {
                        printIndent(indent, "NAME: " + name);
                        printIndent(indent, "PATH: " + path);
                    }
                    File explodedDir = project.file(project.getBuildDir() + "/" + FD_INTERMEDIATES + "/exploded-aar/" + path);
                    @SuppressWarnings("unchecked") LibraryDependency LibraryDependency = new LibraryDependency(artifact.getFile(), explodedDir, nestedLibraries, nestedJars, name, artifact.getClassifier(), gradlePath, null, /*requestedCoordinates*/
                    mavenCoordinates, provided);
                    libsForThisModule.add(LibraryDependency);
                    outLibraries.add(LibraryDependency);
                    reverseLibMap.put(LibraryDependency, configuration);
                } else if (EXT_JAR.equals(artifact.getExtension())) {
                    if (DEBUG_DEPENDENCY) {
                        printIndent(indent, "TYPE: JAR");
                    }
                    nestedLibraries.clear();
                    // check this jar does not have a dependency on an library, as this would not work.
                    if (!nestedLibraries.isEmpty()) {
                        // can detect this an accept it.
                        if (testedProjectPath != null && testedProjectPath.equals(gradlePath)) {
                            // if this is a package scope, then skip the dependencies.
                            if (scopeType == ScopeType.PACKAGE) {
                                recursiveLibSkip(nestedLibraries);
                            } else {
                                // if it's compile scope, make it optional.
                                provided = true;
                            }
                            outLibraries.addAll(nestedLibraries);
                        } else {
                            configDependencies.getChecker().handleIssue(createMavenCoordinates(artifact).toString(), SyncIssue.TYPE_JAR_DEPEND_ON_AAR, SyncIssue.SEVERITY_ERROR, String.format("Module '%s' depends on one or more Android Libraries but is a jar", moduleVersion));
                        }
                    }
                    if (jarsForThisModule == null) {
                        jarsForThisModule = Lists.newArrayList();
                        alreadyFoundJars.put(moduleVersion, jarsForThisModule);
                    }
                    JarDependency jarDependency = new JarDependency(artifact.getFile(), nestedJars, mavenCoordinates, gradlePath, provided);
                    // app module then skip it.
                    if (scopeType == ScopeType.PACKAGE && testedProjectPath != null && testedProjectPath.equals(gradlePath)) {
                        jarDependency.skip();
                        //noinspection unchecked
                        recursiveJavaSkip((List<JarDependency>) jarDependency.getDependencies());
                    }
                    if (DEBUG_DEPENDENCY) {
                        printIndent(indent, "JAR-INFO: " + jarDependency.toString());
                    }
                    jarsForThisModule.add(jarDependency);
                    outJars.add(jarDependency);
                } else if (EXT_ANDROID_PACKAGE.equals(artifact.getExtension())) {
                    String name = computeArtifactName(moduleVersion, artifact);
                    configDependencies.getChecker().handleIssue(name, SyncIssue.TYPE_DEPENDENCY_IS_APK, SyncIssue.SEVERITY_ERROR, String.format("Dependency %s on project %s resolves to an APK archive " + "which is not supported as a compilation dependency. File: %s", name, project.getName(), artifact.getFile()));
                } else if ("apklib".equals(artifact.getExtension())) {
                    String name = computeArtifactName(moduleVersion, artifact);
                    configDependencies.getChecker().handleIssue(name, SyncIssue.TYPE_DEPENDENCY_IS_APKLIB, SyncIssue.SEVERITY_ERROR, String.format("Packaging for dependency %s is 'apklib' and is not supported. " + "Only 'aar' libraries are supported.", name));
                } else if ("awb".equals(artifact.getExtension())) {
                    break;
                } else if ("solib".equals(artifact.getExtension())) {
                    break;
                } else {
                    String name = computeArtifactName(moduleVersion, artifact);
                    logger.warning(String.format("Unrecognized dependency: '%s' (type: '%s', extension: '%s')", name, artifact.getType(), artifact.getExtension()));
                }
            }
        }
        if (DEBUG_DEPENDENCY) {
            printIndent(indent, "DONE: " + moduleVersion.getName());
        }
    }
}

Example 2 with ResolvedComponentResult

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

the class DependencyManager method resolveDependency.

/**
     * 解析依赖
     *
     * @param resolvedDependencyContainer
     * @param parent
     * @param resolvedComponentResult
     * @param artifacts
     * @param configDependencies
     * @param indent
     */
private void resolveDependency(ResolvedDependencyContainer resolvedDependencyContainer, ResolvedDependencyInfo parent, ResolvedComponentResult resolvedComponentResult, Map<ModuleVersionIdentifier, List<ResolvedArtifact>> artifacts, VariantDependencies configDependencies, int indent, CircleDependencyCheck circleDependencyCheck, CircleDependencyCheck.DependencyNode node) {
    ModuleVersionIdentifier moduleVersion = resolvedComponentResult.getModuleVersion();
    if (configDependencies.getChecker().checkForExclusion(moduleVersion)) {
        return;
    }
    if (moduleVersion.getName().equals("support-annotations") && moduleVersion.getGroup().equals("com.android.support")) {
        configDependencies.setAnnotationsPresent(true);
    }
    // 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;
    // 如果同时找到多个依赖，暂时没法判断是那个真正有用
    for (ResolvedArtifact resolvedArtifact : moduleArtifacts) {
        ResolvedDependencyInfo resolvedDependencyInfo = new ResolvedDependencyInfo(moduleVersion.getVersion(), moduleVersion.getGroup(), moduleVersion.getName(), resolvedArtifact.getType(), resolvedArtifact.getClassifier());
        resolvedDependencyInfo.setIndent(indent);
        resolvedDependencyInfo.setGradlePath(gradlePath);
        resolvedDependencyInfo.setResolvedArtifact(resolvedArtifact);
        String path = computeArtifactPath(moduleVersion, resolvedArtifact);
        String name = computeArtifactName(moduleVersion, resolvedArtifact);
        File explodedDir = project.file(project.getBuildDir().getAbsolutePath() + "/" + FD_INTERMEDIATES + "/exploded-" + resolvedArtifact.getType().toLowerCase() + "/" + path);
        resolvedDependencyInfo.setExplodedDir(explodedDir);
        resolvedDependencyInfo.setDependencyName(name);
        if (null == parent) {
            parent = resolvedDependencyInfo;
        } else {
            resolvedDependencyInfo.setParent(parent);
            parent.getChildren().add(resolvedDependencyInfo);
        }
        Set<? extends DependencyResult> dependencies = resolvedComponentResult.getDependencies();
        for (DependencyResult dep : dependencies) {
            if (dep instanceof ResolvedDependencyResult) {
                ResolvedComponentResult childResolvedComponentResult = ((ResolvedDependencyResult) dep).getSelected();
                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(resolvedDependencyContainer, parent, ((ResolvedDependencyResult) dep).getSelected(), artifacts, configDependencies, indent + 1, circleDependencyCheck, childNode);
                }
            }
        }
        resolvedDependencyContainer.addDependency(resolvedDependencyInfo);
    }
}

Example 3 with ResolvedComponentResult

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

the class DefaultIdeDependencyResolver method getIdeRepoFileDependencies.

/**
     * Gets IDE repository file dependencies.
     *
     * @param configuration Configuration
     * @return IDE repository file dependencies
     */
public List<IdeExtendedRepoFileDependency> getIdeRepoFileDependencies(Configuration configuration) {
    ResolutionResult result = getIncomingResolutionResult(configuration);
    final Set<ResolvedComponentResult> resolvedRepoFileComponents = CollectionUtils.filter(result.getAllComponents(), new Spec<ResolvedComponentResult>() {

        @Override
        public boolean isSatisfiedBy(ResolvedComponentResult element) {
            return element.getId() instanceof ModuleComponentIdentifier;
        }
    });
    Set<ModuleVersionIdentifier> mappedResolvedDependencies = mapResolvedDependencies(resolvedRepoFileComponents);
    Set<ResolvedArtifact> artifacts = getExternalArtifacts(configuration);
    List<IdeExtendedRepoFileDependency> externalDependencies = new ArrayList<IdeExtendedRepoFileDependency>();
    for (ResolvedArtifact artifact : artifacts) {
        if (mappedResolvedDependencies.contains(artifact.getModuleVersion().getId())) {
            IdeExtendedRepoFileDependency ideRepoFileDependency = new IdeExtendedRepoFileDependency(artifact.getFile());
            ideRepoFileDependency.setId(artifact.getModuleVersion().getId());
            externalDependencies.add(ideRepoFileDependency);
        }
    }
    return externalDependencies;
}

Example 4 with ResolvedComponentResult

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

the class DefaultIdeDependencyResolver method getIdeProjectDependencies.

/**
     * Gets IDE project dependencies.
     *
     * @param configuration Configuration
     * @param project Project
     * @return IDE project dependencies
     */
public List<IdeProjectDependency> getIdeProjectDependencies(Configuration configuration, Project project) {
    ResolutionResult result = getIncomingResolutionResult(configuration);
    final Set<ResolvedComponentResult> projectComponents = CollectionUtils.filter(result.getAllComponents(), new Spec<ResolvedComponentResult>() {

        @Override
        public boolean isSatisfiedBy(ResolvedComponentResult element) {
            return element.getId() instanceof ProjectComponentIdentifier;
        }
    });
    List<IdeProjectDependency> ideProjectDependencies = new ArrayList<IdeProjectDependency>();
    ProjectComponentIdentifier thisProjectId = DefaultProjectComponentIdentifier.newProjectId(project);
    for (ResolvedComponentResult projectComponent : projectComponents) {
        ProjectComponentIdentifier projectId = (ProjectComponentIdentifier) projectComponent.getId();
        if (thisProjectId.equals(projectId)) {
            continue;
        }
        if (!projectId.getBuild().isCurrentBuild()) {
            // Don't have access to the ProjectInstance: we can't use it to determine the name.
            ideProjectDependencies.add(new IdeProjectDependency(projectId));
        } else {
            Project resolvedProject = project.project(projectId.getProjectPath());
            ideProjectDependencies.add(new IdeProjectDependency(projectId, resolvedProject.getName()));
        }
    }
    return ideProjectDependencies;
}

Example 5 with ResolvedComponentResult

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

the class DefaultConfigurationResolver method resolveGraph.

public void resolveGraph(ConfigurationInternal configuration, ResolverResults results) {
    List<ResolutionAwareRepository> resolutionAwareRepositories = CollectionUtils.collect(repositories, Transformers.cast(ResolutionAwareRepository.class));
    StoreSet stores = storeFactory.createStoreSet();
    BinaryStore oldModelStore = stores.nextBinaryStore();
    Store<TransientConfigurationResults> oldModelCache = stores.oldModelCache();
    TransientConfigurationResultsBuilder oldTransientModelBuilder = new TransientConfigurationResultsBuilder(oldModelStore, oldModelCache, moduleIdentifierFactory);
    DefaultResolvedConfigurationBuilder oldModelBuilder = new DefaultResolvedConfigurationBuilder(oldTransientModelBuilder);
    ResolvedConfigurationDependencyGraphVisitor oldModelVisitor = new ResolvedConfigurationDependencyGraphVisitor(oldModelBuilder);
    BinaryStore newModelStore = stores.nextBinaryStore();
    Store<ResolvedComponentResult> newModelCache = stores.newModelCache();
    StreamingResolutionResultBuilder newModelBuilder = new StreamingResolutionResultBuilder(newModelStore, newModelCache, moduleIdentifierFactory);
    ResolvedLocalComponentsResultGraphVisitor localComponentsVisitor = new ResolvedLocalComponentsResultGraphVisitor();
    DefaultResolvedArtifactsBuilder artifactsBuilder = new DefaultResolvedArtifactsBuilder(buildProjectDependencies, configuration.getResolutionStrategy().getSortOrder(), buildOperationProcessor);
    FileDependencyCollectingGraphVisitor fileDependencyVisitor = new FileDependencyCollectingGraphVisitor(attributesFactory, buildOperationProcessor);
    DependencyGraphVisitor graphVisitor = new CompositeDependencyGraphVisitor(oldModelVisitor, newModelBuilder, localComponentsVisitor, fileDependencyVisitor);
    DependencyArtifactsVisitor artifactsVisitor = new CompositeDependencyArtifactsVisitor(oldModelVisitor, artifactsBuilder);
    resolver.resolve(configuration, resolutionAwareRepositories, metadataHandler, Specs.<DependencyMetadata>satisfyAll(), graphVisitor, artifactsVisitor, attributesSchema, moduleIdentifierFactory, moduleExclusions);
    VisitedArtifactsResults artifactsResults = artifactsBuilder.complete();
    VisitedFileDependencyResults fileDependencyResults = fileDependencyVisitor.complete();
    results.graphResolved(newModelBuilder.complete(), localComponentsVisitor, new BuildDependenciesOnlyVisitedArtifactSet(artifactsResults, fileDependencyResults, artifactTransforms));
    results.retainState(new ArtifactResolveState(oldModelBuilder.complete(), artifactsResults, fileDependencyResults, oldTransientModelBuilder));
}