Esempio n. 1
0
  public Set<ResolvedArtifact> getArtifacts() {
    Set<ComponentArtifactMetaData> componentArtifacts = resolveComponentArtifacts();
    Set<ResolvedArtifact> resolvedArtifacts =
        new LinkedHashSet<ResolvedArtifact>(componentArtifacts.size());
    for (ComponentArtifactMetaData artifact : componentArtifacts) {
      IvyArtifactName artifactName = artifact.getName();
      if (!selector.acceptArtifact(moduleVersionIdentifier.getModule(), artifactName)) {
        continue;
      }

      ResolvedArtifact resolvedArtifact = allResolvedArtifacts.get(artifact.getId());
      if (resolvedArtifact == null) {
        Factory<File> artifactSource =
            new LazyArtifactSource(artifact, moduleSource, artifactResolver);
        resolvedArtifact =
            new DefaultResolvedArtifact(
                new DefaultResolvedModuleVersion(moduleVersionIdentifier),
                artifactName,
                artifact.getId(),
                artifactSource);
        allResolvedArtifacts.put(artifact.getId(), resolvedArtifact);
      }
      resolvedArtifacts.add(resolvedArtifact);
    }
    return resolvedArtifacts;
  }
 private ModuleResolutionFilter getSelector(List<DependencyEdge> transitiveEdges) {
   ModuleResolutionFilter resolutionFilter;
   if (transitiveEdges.isEmpty()) {
     resolutionFilter = DefaultModuleResolutionFilter.all();
   } else {
     resolutionFilter = transitiveEdges.get(0).getSelector();
     for (int i = 1; i < transitiveEdges.size(); i++) {
       DependencyEdge dependencyEdge = transitiveEdges.get(i);
       resolutionFilter = resolutionFilter.union(dependencyEdge.getSelector());
     }
   }
   resolutionFilter =
       resolutionFilter.intersect(
           DefaultModuleResolutionFilter.excludeAny(metaData.getExcludeRules()));
   return resolutionFilter;
 }
    public void visitOutgoingDependencies(Collection<DependencyEdge> target) {
      // If this configuration's version is in conflict, don't do anything
      // If not traversed before, add all selected outgoing edges
      // If traversed before, and the selected modules have changed, remove previous outgoing edges
      // and add outgoing edges again with
      //    the new selections.
      // If traversed before, and the selected modules have not changed, ignore
      // If none of the incoming edges are transitive, then the node has no outgoing edges

      if (moduleRevision.state != ModuleState.Selected) {
        LOGGER.debug("version for {} is not selected. ignoring.", this);
        return;
      }

      List<DependencyEdge> transitiveIncoming = new ArrayList<DependencyEdge>();
      for (DependencyEdge edge : incomingEdges) {
        if (edge.isTransitive()) {
          transitiveIncoming.add(edge);
        }
      }

      if (transitiveIncoming.isEmpty() && this != resolveState.root) {
        if (previousTraversal != null) {
          removeOutgoingEdges();
        }
        if (incomingEdges.isEmpty()) {
          LOGGER.debug("{} has no incoming edges. ignoring.", this);
        } else {
          LOGGER.debug("{} has no transitive incoming edges. ignoring outgoing edges.", this);
        }
        return;
      }

      ModuleResolutionFilter resolutionFilter = getSelector(transitiveIncoming);
      if (previousTraversal != null) {
        if (previousTraversal.acceptsSameModulesAs(resolutionFilter)) {
          LOGGER.debug(
              "Changed edges for {} selects same versions as previous traversal. ignoring", this);
          // Don't need to traverse again, but hang on to the new filter as the set of artifact may
          // have changed
          previousTraversal = resolutionFilter;
          return;
        }
        removeOutgoingEdges();
      }

      for (DependencyMetaData dependency : metaData.getDependencies()) {
        ModuleIdentifier targetModuleId =
            DefaultModuleIdentifier.newId(
                dependency.getRequested().getGroup(), dependency.getRequested().getName());
        if (isExcluded(resolutionFilter, targetModuleId)) {
          continue;
        }
        DependencyEdge dependencyEdge =
            new DependencyEdge(this, dependency, resolutionFilter, resolveState);
        outgoingEdges.add(dependencyEdge);
        target.add(dependencyEdge);
      }
      previousTraversal = resolutionFilter;
    }
    private boolean isExcluded(ModuleResolutionFilter selector, ModuleIdentifier targetModuleId) {
      if (!selector.acceptModule(targetModuleId)) {
        LOGGER.debug("{} is excluded from {}.", targetModuleId, this);
        return true;
      }

      return false;
    }
 public ModuleResolutionFilter getSelector() {
   Set<String> hierarchy = from.metaData.getHierarchy();
   ModuleResolutionFilter selector =
       DefaultModuleResolutionFilter.excludeAny(dependencyMetaData.getExcludeRules(hierarchy));
   return selector.intersect(resolutionFilter);
 }