org.gradle.api.artifacts.result.ResolvedDependencyResult Java Examples

/**
 * Traverses the dependency tree post-order and collects dependencies.
 * <p>
 * The recursive post-order traversal returns the root of the (sub)tree.
 * This allows the post-order adding into the set of dependencies as we
 * return from the recursive calls. The set of seen dependencies ensures
 * ensures that the cycles in Ivy metadata do not cause cycles in our
 * recursive calls.
 *
 * @param root         the root of the dependency (sub)tree
 * @param seen         the input set of already seen dependencies
 * @param dependencies the output set of dependencies in post-order
 * @return the root itself
 */
public static ResolvedComponentResult postOrderDependencies(
    ResolvedComponentResult root,
    Set<ComponentIdentifier> seen,
    Set<ResolvedComponentResult> dependencies) {
    for (DependencyResult d : root.getDependencies()) {
        if (!(d instanceof ResolvedDependencyResult)) {
            throw new GradleException("Unresolved dependency found for " + d.toString());
        }

        ResolvedComponentResult component = ((ResolvedDependencyResult) d).getSelected();
        ComponentIdentifier id = component.getId();

        if (!seen.contains(id)) {
            seen.add(id);
            dependencies.add(postOrderDependencies(component, seen, dependencies));
        }
    }

    return root;
}
 

public Set<RenderableDependency> getChildren() {
    Set<RenderableDependency> out = new LinkedHashSet<RenderableDependency>();
    for (DependencyResult d : dependency.getSelected().getDependencies()) {
        if (d instanceof UnresolvedDependencyResult) {
            out.add(new RenderableUnresolvedDependencyResult((UnresolvedDependencyResult) d));
        } else {
            out.add(new RenderableDependencyResult((ResolvedDependencyResult) d));
        }
    }
    return out;
}
 

private void eachElement(ResolvedComponentResult node,
                         Action<? super ResolvedComponentResult> moduleAction, Action<? super DependencyResult> dependencyAction,
                         Set<ResolvedComponentResult> visited) {
    if (!visited.add(node)) {
        return;
    }
    moduleAction.execute(node);
    for (DependencyResult d : node.getDependencies()) {
        dependencyAction.execute(d);
        if (d instanceof ResolvedDependencyResult) {
            eachElement(((ResolvedDependencyResult) d).getSelected(), moduleAction, dependencyAction, visited);
        }
    }
}
 

private void recordDependencyPaths(
    ImmutableListMultimap.Builder<String, String> output,
    ArrayDeque<ResolvedComponentResult> stack,
    ImmutableSet<String> targetCoordinates) {
  ResolvedComponentResult item = stack.getLast();
  ModuleVersionIdentifier identifier = item.getModuleVersion();
  String coordinates =
      String.format(
          "%s:%s:%s", identifier.getGroup(), identifier.getName(), identifier.getVersion());
  if (targetCoordinates.contains(coordinates)) {
    String dependencyPath =
        stack.stream().map(this::formatComponentResult).collect(Collectors.joining(" / "));
    output.put(coordinates, dependencyPath);
  }

  for (DependencyResult dependencyResult : item.getDependencies()) {
    if (dependencyResult instanceof ResolvedDependencyResult) {
      ResolvedDependencyResult resolvedDependencyResult =
          (ResolvedDependencyResult) dependencyResult;
      ResolvedComponentResult child = resolvedDependencyResult.getSelected();
      stack.add(child);
      recordDependencyPaths(output, stack, targetCoordinates);
    } else if (dependencyResult instanceof UnresolvedDependencyResult) {
      UnresolvedDependencyResult unresolvedResult = (UnresolvedDependencyResult) dependencyResult;
      getLogger()
          .error(
              "Could not resolve dependency: "
                  + unresolvedResult.getAttempted().getDisplayName());
    } else {
      throw new IllegalStateException("Unexpected dependency result type: " + dependencyResult);
    }
  }

  stack.removeLast();
}
 

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;

}
 

public static boolean isAwbDependency(DependencyResult dependencyResult,
                                      Map<ModuleVersionIdentifier, List<ResolvedArtifact>> artifacts, Set<String>awbs) {
    if (dependencyResult instanceof ResolvedDependencyResult) {
        ResolvedDependencyResult resolvedDependencyResult = (ResolvedDependencyResult)dependencyResult;
        ModuleVersionIdentifier moduleVersionIdentifier = resolvedDependencyResult.getSelected().getModuleVersion();
        List<ResolvedArtifact> resolvedArtifacts = artifacts.get(moduleVersionIdentifier);

        if (resolvedArtifacts != null && resolvedArtifacts.size() > 0) {
            ResolvedArtifact resolvedArtifact = resolvedArtifacts.get(0);
            return ("awb".equals(resolvedArtifact.getType()) || awbs.contains(resolvedArtifact.getModuleVersion().getId().getGroup()+":"+resolvedArtifact.getModuleVersion().getId().getName()));
        }
    }
    return false;
}
 

public ResolvedDependencyResult createResolvedDependency(ComponentSelector requested, ResolvedComponentResult from, DefaultResolvedComponentResult selected) {
    List<Object> key = asList(requested, from, selected);
    if (!resolvedDependencies.containsKey(key)) {
        resolvedDependencies.put(key, new DefaultResolvedDependencyResult(requested, selected, from));
    }
    return resolvedDependencies.get(key);
}
 

private void eachElement(ResolvedComponentResult node,
                         Action<? super ResolvedComponentResult> moduleAction, Action<? super DependencyResult> dependencyAction,
                         Set<ResolvedComponentResult> visited) {
    if (!visited.add(node)) {
        return;
    }
    moduleAction.execute(node);
    for (DependencyResult d : node.getDependencies()) {
        dependencyAction.execute(d);
        if (d instanceof ResolvedDependencyResult) {
            eachElement(((ResolvedDependencyResult) d).getSelected(), moduleAction, dependencyAction, visited);
        }
    }
}
 

public boolean isSatisfiedBy(DependencyResult candidate) {
    if (candidate instanceof ResolvedDependencyResult) {
        return matchesRequested(candidate) || matchesSelected((ResolvedDependencyResult) candidate);
    } else {
        return matchesRequested(candidate);
    }
}
 

private boolean matchesSelected(ResolvedDependencyResult candidate) {
    ComponentIdentifier selected = candidate.getSelected().getId();

    if (moduleIdentifier != null && selected instanceof ModuleComponentIdentifier) {
        ModuleComponentIdentifier selectedModule = (ModuleComponentIdentifier) selected;
        return selectedModule.getGroup().equals(moduleIdentifier.getGroup())
                && selectedModule.getModule().equals(moduleIdentifier.getName());
    }

    return false;
}
 

public boolean isSatisfiedBy(DependencyResult candidate) {
    //The matching is very simple at the moment but it should solve majority of cases.
    //It operates using String#contains and it tests either requested or selected module.
    if (candidate instanceof ResolvedDependencyResult) {
        return matchesRequested(candidate) || matchesSelected((ResolvedDependencyResult) candidate);
    } else {
        return matchesRequested(candidate);
    }
}
 

private void eachElement(ResolvedComponentResult node,
                         Action<? super ResolvedComponentResult> moduleAction, Action<? super DependencyResult> dependencyAction,
                         Set<ResolvedComponentResult> visited) {
    if (!visited.add(node)) {
        return;
    }
    moduleAction.execute(node);
    for (DependencyResult d : node.getDependencies()) {
        dependencyAction.execute(d);
        if (d instanceof ResolvedDependencyResult) {
            eachElement(((ResolvedDependencyResult) d).getSelected(), moduleAction, dependencyAction, visited);
        }
    }
}
 

public Set<RenderableDependency> getChildren() {
    Set<RenderableDependency> out = new LinkedHashSet<RenderableDependency>();
    for (DependencyResult d : module.getDependencies()) {
        if (d instanceof UnresolvedDependencyResult) {
            out.add(new RenderableUnresolvedDependencyResult((UnresolvedDependencyResult) d));
        } else {
            out.add(new RenderableDependencyResult((ResolvedDependencyResult) d));
        }
    }
    return out;
}
 

public Set<RenderableDependency> getChildren() {
    Map<ComponentIdentifier, RenderableDependency> children = new LinkedHashMap<ComponentIdentifier, RenderableDependency>();
    for (ResolvedDependencyResult dependent : module.getDependents()) {
        InvertedRenderableModuleResult child = new InvertedRenderableModuleResult(dependent.getFrom());
        if (!children.containsKey(child.getId())) {
            children.put(child.getId(), child);
        }
    }
    return new LinkedHashSet<RenderableDependency>(children.values());
}
 

public boolean isSatisfiedBy(DependencyResult candidate) {
    if (candidate instanceof ResolvedDependencyResult) {
        return matchesRequested(candidate) || matchesSelected((ResolvedDependencyResult) candidate);
    } else {
        return matchesRequested(candidate);
    }
}
 

private boolean matchesSelected(ResolvedDependencyResult candidate) {
    ComponentIdentifier selected = candidate.getSelected().getId();

    if (moduleIdentifier != null && selected instanceof ModuleComponentIdentifier) {
        ModuleComponentIdentifier selectedModule = (ModuleComponentIdentifier) selected;
        return selectedModule.getGroup().equals(moduleIdentifier.getGroup())
                && selectedModule.getModule().equals(moduleIdentifier.getName());
    }

    return false;
}
 

public boolean isSatisfiedBy(DependencyResult candidate) {
    //The matching is very simple at the moment but it should solve majority of cases.
    //It operates using String#contains and it tests either requested or selected module.
    if (candidate instanceof ResolvedDependencyResult) {
        return matchesRequested(candidate) || matchesSelected((ResolvedDependencyResult) candidate);
    } else {
        return matchesRequested(candidate);
    }
}
 

public Set<RenderableDependency> getChildren() {
    Set<RenderableDependency> out = new LinkedHashSet<RenderableDependency>();
    for (DependencyResult d : dependency.getSelected().getDependencies()) {
        if (d instanceof UnresolvedDependencyResult) {
            out.add(new RenderableUnresolvedDependencyResult((UnresolvedDependencyResult) d));
        } else {
            out.add(new RenderableDependencyResult((ResolvedDependencyResult) d));
        }
    }
    return out;
}
 

public Set<RenderableDependency> getChildren() {
    Set<RenderableDependency> out = new LinkedHashSet<RenderableDependency>();
    for (DependencyResult d : module.getDependencies()) {
        if (d instanceof UnresolvedDependencyResult) {
            out.add(new RenderableUnresolvedDependencyResult((UnresolvedDependencyResult) d));
        } else {
            out.add(new RenderableDependencyResult((ResolvedDependencyResult) d));
        }
    }
    return out;
}
 

public Set<RenderableDependency> getChildren() {
    Map<ComponentIdentifier, RenderableDependency> children = new LinkedHashMap<ComponentIdentifier, RenderableDependency>();
    for (ResolvedDependencyResult dependent : module.getDependents()) {
        InvertedRenderableModuleResult child = new InvertedRenderableModuleResult(dependent.getFrom());
        if (!children.containsKey(child.getId())) {
            children.put(child.getId(), child);
        }
    }
    return new LinkedHashSet<RenderableDependency>(children.values());
}
 

public ResolvedDependencyResult createResolvedDependency(ComponentSelector requested, ResolvedComponentResult from, DefaultResolvedComponentResult selected) {
    List<Object> key = asList(requested, from, selected);
    if (!resolvedDependencies.containsKey(key)) {
        resolvedDependencies.put(key, new DefaultResolvedDependencyResult(requested, selected, from));
    }
    return resolvedDependencies.get(key);
}
 

private void eachElement(ResolvedComponentResult node,
                         Action<? super ResolvedComponentResult> moduleAction, Action<? super DependencyResult> dependencyAction,
                         Set<ResolvedComponentResult> visited) {
    if (!visited.add(node)) {
        return;
    }
    moduleAction.execute(node);
    for (DependencyResult d : node.getDependencies()) {
        dependencyAction.execute(d);
        if (d instanceof ResolvedDependencyResult) {
            eachElement(((ResolvedDependencyResult) d).getSelected(), moduleAction, dependencyAction, visited);
        }
    }
}
 

public ResolvedDependencyResult createResolvedDependency(ComponentSelector requested, ResolvedComponentResult from, DefaultResolvedComponentResult selected) {
    List<Object> key = asList(requested, from, selected);
    if (!resolvedDependencies.containsKey(key)) {
        resolvedDependencies.put(key, new DefaultResolvedDependencyResult(requested, selected, from));
    }
    return resolvedDependencies.get(key);
}
 

public boolean isSatisfiedBy(DependencyResult candidate) {
    //The matching is very simple at the moment but it should solve majority of cases.
    //It operates using String#contains and it tests either requested or selected module.
    if (candidate instanceof ResolvedDependencyResult) {
        return matchesRequested(candidate) || matchesSelected((ResolvedDependencyResult) candidate);
    } else {
        return matchesRequested(candidate);
    }
}
 

public Set<RenderableDependency> getChildren() {
    Set<RenderableDependency> out = new LinkedHashSet<RenderableDependency>();
    for (DependencyResult d : dependency.getSelected().getDependencies()) {
        if (d instanceof UnresolvedDependencyResult) {
            out.add(new RenderableUnresolvedDependencyResult((UnresolvedDependencyResult) d));
        } else {
            out.add(new RenderableDependencyResult((ResolvedDependencyResult) d));
        }
    }
    return out;
}
 

public Set<RenderableDependency> getChildren() {
    Set<RenderableDependency> out = new LinkedHashSet<RenderableDependency>();
    for (DependencyResult d : module.getDependencies()) {
        if (d instanceof UnresolvedDependencyResult) {
            out.add(new RenderableUnresolvedDependencyResult((UnresolvedDependencyResult) d));
        } else {
            out.add(new RenderableDependencyResult((ResolvedDependencyResult) d));
        }
    }
    return out;
}
 

public Set<RenderableDependency> getChildren() {
    Map<ComponentIdentifier, RenderableDependency> children = new LinkedHashMap<ComponentIdentifier, RenderableDependency>();
    for (ResolvedDependencyResult dependent : module.getDependents()) {
        InvertedRenderableModuleResult child = new InvertedRenderableModuleResult(dependent.getFrom());
        if (!children.containsKey(child.getId())) {
            children.put(child.getId(), child);
        }
    }
    return new LinkedHashSet<RenderableDependency>(children.values());
}
 

private boolean matchesSelected(ResolvedDependencyResult candidate) {
    ComponentIdentifier selected = candidate.getSelected().getId();

    if (moduleIdentifier != null && selected instanceof ModuleComponentIdentifier) {
        ModuleComponentIdentifier selectedModule = (ModuleComponentIdentifier) selected;
        return selectedModule.getGroup().equals(moduleIdentifier.getGroup())
                && selectedModule.getModule().equals(moduleIdentifier.getName());
    }

    return false;
}
 

public boolean isSatisfiedBy(DependencyResult candidate) {
    if (candidate instanceof ResolvedDependencyResult) {
        return matchesRequested(candidate) || matchesSelected((ResolvedDependencyResult) candidate);
    } else {
        return matchesRequested(candidate);
    }
}
 

private boolean matchesSelected(ResolvedDependencyResult candidate) {
    ComponentIdentifier selected = candidate.getSelected().getId();

    if (moduleIdentifier != null && selected instanceof ModuleComponentIdentifier) {
        ModuleComponentIdentifier selectedModule = (ModuleComponentIdentifier) selected;
        return selectedModule.getGroup().equals(moduleIdentifier.getGroup())
                && selectedModule.getModule().equals(moduleIdentifier.getName());
    }

    return false;
}