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;
}
ModuleVersionSpec selectorSpec = getSelector(transitiveIncoming);
if (previousTraversal != null) {
if (previousTraversal.acceptsSameModulesAs(selectorSpec)) {
LOGGER.debug(
"Changed edges for {} selects same versions as previous traversal. ignoring", this);
return;
}
removeOutgoingEdges();
}
for (DependencyMetaData dependency : metaData.getDependencies()) {
DependencyDescriptor dependencyDescriptor = dependency.getDescriptor();
ModuleId targetModuleId = dependencyDescriptor.getDependencyRevisionId().getModuleId();
if (!selectorSpec.isSatisfiedBy(targetModuleId)) {
LOGGER.debug("{} is excluded from {}.", targetModuleId, this);
continue;
}
DependencyEdge dependencyEdge =
new DependencyEdge(this, dependency, selectorSpec, resolveState);
outgoingEdges.add(dependencyEdge);
target.add(dependencyEdge);
}
previousTraversal = selectorSpec;
}
public DependencyEdge(
ConfigurationNode from,
DependencyMetaData dependencyMetaData,
ModuleVersionSpec selectorSpec,
ResolveState resolveState) {
this.from = from;
this.dependencyMetaData = dependencyMetaData;
this.dependencyDescriptor = dependencyMetaData.getDescriptor();
this.selectorSpec = selectorSpec;
this.resolveState = resolveState;
selector = resolveState.getSelector(dependencyMetaData);
}
public void resolve(DependencyMetaData dependency, BuildableModuleVersionResolveResult result) {
resolver.resolve(dependency, result);
DependencyDescriptor descriptor = dependency.getDescriptor();
if (result.getFailure() != null || !(descriptor instanceof ClientModuleDependencyDescriptor)) {
return;
}
ClientModuleDependencyDescriptor clientModuleDependencyDescriptor =
(ClientModuleDependencyDescriptor) descriptor;
ModuleDescriptor moduleDescriptor = clientModuleDependencyDescriptor.getTargetModule();
result.setMetaData(moduleDescriptor);
}
public void resolve(DependencyMetaData dependency, BuildableModuleVersionResolveResult result) {
DependencyDescriptor descriptor = dependency.getDescriptor();
if (descriptor instanceof ProjectDependencyDescriptor) {
ProjectDependencyDescriptor desc = (ProjectDependencyDescriptor) descriptor;
ModuleDescriptor moduleDescriptor = projectModuleRegistry.findProject(desc);
final ModuleRevisionId moduleRevisionId = moduleDescriptor.getModuleRevisionId();
final DefaultModuleVersionIdentifier moduleVersionIdentifier =
new DefaultModuleVersionIdentifier(
moduleRevisionId.getOrganisation(),
moduleRevisionId.getName(),
moduleRevisionId.getRevision());
result.resolved(moduleVersionIdentifier, moduleDescriptor, artifactResolver);
} else {
resolver.resolve(dependency, result);
}
}
// TODO - don't pass in 'from' configuration - the dependency should have whatever context it
// needs
public Set<ConfigurationMetaData> resolveTargetConfigurations(
DependencyMetaData dependencyMetaData,
ConfigurationMetaData fromConfiguration,
ModuleVersionMetaData targetModuleVersion) {
// TODO - resolve directly to config meta data
ModuleDescriptor targetDescriptor = targetModuleVersion.getDescriptor();
DependencyDescriptor dependencyDescriptor = dependencyMetaData.getDescriptor();
Set<String> targetConfigurationNames = new LinkedHashSet<String>();
for (String config : dependencyDescriptor.getModuleConfigurations()) {
if (config.equals("*") || config.equals("%")) {
collectTargetConfiguration(
dependencyDescriptor,
fromConfiguration,
fromConfiguration.getName(),
targetDescriptor,
targetConfigurationNames);
} else if (fromConfiguration.getHierarchy().contains(config)) {
collectTargetConfiguration(
dependencyDescriptor,
fromConfiguration,
config,
targetDescriptor,
targetConfigurationNames);
}
}
Set<ConfigurationMetaData> targets = new LinkedHashSet<ConfigurationMetaData>();
for (String targetConfigurationName : targetConfigurationNames) {
// TODO - move this down below
if (targetDescriptor.getConfiguration(targetConfigurationName) == null) {
throw new RuntimeException(
String.format(
"Module version %s, configuration '%s' declares a dependency on configuration '%s' which is not declared in the module descriptor for %s",
fromConfiguration.getModuleVersion().getId(),
fromConfiguration.getName(),
targetConfigurationName,
targetModuleVersion.getId()));
}
ConfigurationMetaData targetConfiguration =
targetModuleVersion.getConfiguration(targetConfigurationName);
targets.add(targetConfiguration);
}
return targets;
}
