public ResolvedPath getReslovedProjectPath(
String id,
boolean mergeWithCore,
boolean overrideCore,
boolean flatten,
List appliedOverrides) {
log.debug(
"Getting project path: id="
+ id
+ ", mergeWithCore="
+ mergeWithCore
+ ", overrideCore="
+ overrideCore
+ ", flatten="
+ flatten);
RepoArtifact artifact = new RepoArtifact();
for (Iterator i = depthFirst(project.getDependencySet()).iterator(); i.hasNext(); ) {
DependencySet set = (DependencySet) i.next();
// Add dependencies
for (Iterator j = set.getDependencies().iterator(); j.hasNext(); ) {
RepoDependency dependency = (RepoDependency) j.next();
artifact.addDependency(dependency);
}
// Add core overrides first if applicable
if (overrideCore) {
for (Iterator j = coreOverrides.iterator(); j.hasNext(); ) {
RepoOverride override = (RepoOverride) j.next();
artifact.addOverride(override);
}
}
// Add overrides
for (Iterator j = set.getOverrides().iterator(); j.hasNext(); ) {
RepoOverride override = (RepoOverride) j.next();
artifact.addOverride(override);
}
}
// Copy the project paths to the artifact
for (Iterator i = resolvedPaths.values().iterator(); i.hasNext(); ) {
RepoPath path = (RepoPath) i.next();
artifact.addPath(path);
}
ResolvedPath path = pathResolver.resolvePath(id, artifact, appliedOverrides, false, true);
path.setId("Project path '" + id + "'");
path = handleMergeAndFlatten(mergeWithCore, flatten, path);
return path;
}
public org.apache.tools.ant.types.Path toAntPath(List artifacts) {
org.apache.tools.ant.types.Path path = new org.apache.tools.ant.types.Path(antProject);
for (Iterator i = artifacts.iterator(); i.hasNext(); ) {
RepoArtifact artifact = (RepoArtifact) i.next();
if (artifact.getLocalCopy() != null) { // Possible for "paths" type
path.add(
new org.apache.tools.ant.types.Path(
antProject, artifact.getLocalCopy().getAbsolutePath()));
}
}
return path;
}
private ResolvedPath mergeWithCore(ResolvedPath path) {
// Will throw a detailed exception on conflict
pathResolver.merge(Arrays.asList(new ResolvedPath[] {corePath, path}));
// Now strip any artifacts that are found in the core
List artifacts = new ArrayList();
for (Iterator i = path.getArtifacts().iterator(); i.hasNext(); ) {
RepoArtifact artifact = (RepoArtifact) i.next();
if (!corePath.contains(artifact.getId())) {
artifacts.add(artifact);
}
}
return new ResolvedPath(path.getId(), artifacts);
}
/**
* Overrides anything that conflicts with the core to the core version This will allow old plugins
* to potentially work without overriding them
*/
private List getCoreOverrides() {
List overrides = new ArrayList();
for (Iterator i = corePath.getArtifacts().iterator(); i.hasNext(); ) {
RepoArtifact artifact = (RepoArtifact) i.next();
RepoArtifactId id = artifact.getId();
overrides.add(
new RepoOverride(
Collections.singleton("*"),
id.getGroup(),
id.getName(),
id.getType(),
null,
id.getVersion()));
}
return overrides;
}
public ResolvedPath _getResolvedPluginPath(
Plugin plugin, String pathId, boolean mergeWithCore, boolean overrideCore, boolean flatten) {
// Create a mock artifact for the resolver as a way to add user specified path specs and
// overrides
RepoArtifact artifact = new RepoArtifact();
RepoDependency dependency = new RepoDependency();
RepoArtifactId pluginId = plugin.getArtifact().getId();
dependency.setId(pluginId);
artifact.addDependency(dependency);
String id = "plugin";
artifact.addPath(new RepoPath(id, "Plugin path", true, true));
// Add dependencies
if (plugin.getDependency() != null) {
for (Iterator j = plugin.getDependency().getPathSpecs().iterator(); j.hasNext(); ) {
RepoPathSpec pluginPathSpec = (RepoPathSpec) j.next();
if (pluginPathSpec.getFrom().equals(pathId)) {
// Add user specifications. Ignore the mandatory flag and to paths as they
// are not relevant. However, allow descend to be false in case the writer of the
// plugin added bogus dependencies.
dependency.addPathSpec(
new RepoPathSpec(
pathId,
id,
pluginPathSpec.getOptions(),
(pluginPathSpec.isDescend() == null) ? Boolean.TRUE : pluginPathSpec.isDescend(),
Boolean.TRUE));
}
}
}
if (dependency.getPathSpecs().size() == 0) {
// Add default ... user hasn't specified anything
dependency.addPathSpec(new RepoPathSpec(pathId, id, null, Boolean.TRUE, Boolean.TRUE));
}
// Add core overrides if applicable
if (overrideCore) {
for (Iterator j = coreOverrides.iterator(); j.hasNext(); ) {
RepoOverride override = (RepoOverride) j.next();
artifact.addOverride(override);
}
}
// Add overrides
for (Iterator i = overrides.iterator(); i.hasNext(); ) {
ws.quokka.core.model.Override override = (ws.quokka.core.model.Override) i.next();
Set paths = override.matchingPluginPaths(plugin.getArtifact().getId());
if (paths.contains(pathId) || ((paths.size() == 1) && paths.contains("*"))) {
// Create a copy of the override, moving matching plugin paths to be standard paths
RepoOverride copy =
new RepoOverride(
Collections.singleton("*"),
override.getGroup(),
override.getName(),
override.getType(),
override.getVersion(),
override.getWithVersion(),
override.getWithPathSpecs());
artifact.addOverride(copy);
}
}
// Remove the plugin itself from the path
// TODO: Look into a better way of doing this, perhaps modifying Resolver so it has the option
// of not adding the root in first place.
ResolvedPath path = pathResolver.resolvePath(id, artifact);
path.setId("Plugin path '" + pathId + "' from " + pluginId.toShortString());
List artifacts = new ArrayList();
for (Iterator i = path.getArtifacts().iterator(); i.hasNext(); ) {
artifact = (RepoArtifact) i.next();
if (!artifact.getId().equals(pluginId)) {
artifacts.add(artifact);
}
if (pluginId.equals(artifact.getId().getAnnotations().get("declaredBy"))) {
artifact.getId().getAnnotations().remove("declaredBy");
}
}
path = new ResolvedPath(path.getId(), artifacts);
path = handleMergeAndFlatten(mergeWithCore, flatten, path);
return path;
}
public List _resolvePathGroup(Target target, String pathGroupId) {
Plugin plugin = target.getPlugin();
PathGroup pathGroup = target.getPathGroup(pathGroupId);
if (pathGroup == null) {
if (plugin.getDeclaringPlugin() != null) {
String declaringTargetName =
plugin.getDeclaringPlugin().getNameSpace() + ":" + parseImplements(target)[2];
pathGroup =
plugin.getDeclaringPlugin().getTarget(declaringTargetName).getPathGroup(pathGroupId);
// TODO: Check the path group only refers to project paths?
}
Assert.isTrue(
pathGroup != null,
"Target '"
+ target.getName()
+ "' has requested path group '"
+ pathGroupId
+ "' that does not exist");
}
if (log.isDebugEnabled()) {
log.debug(
"Resolving path: target="
+ target.getName()
+ ", pathGroup="
+ pathGroupId
+ ", pathGroupElements="
+ pathGroup.getPaths());
}
List paths = new ArrayList();
// Note: merging with core is turned off here so that the proper path tree is maintained
// However, core overrides are still applied by separating that into a different flag
resolvePath(
pathGroup.getPaths(),
paths,
false,
pathGroup.getMergeWithCore().booleanValue(),
target,
false);
if (log.isDebugEnabled()) {
log.debug("Resolved the following paths for path group '" + pathGroup + "'");
for (Iterator i = paths.iterator(); i.hasNext(); ) {
ResolvedPath path = (ResolvedPath) i.next();
log.debug(pathResolver.formatPath(path, false));
}
}
ResolvedPath path = pathResolver.merge(paths);
if (pathGroup.getMergeWithCore().booleanValue()) {
path = mergeWithCore(path);
}
// System.out.println(pathResolver.formatPath(path, false));
StringBuffer sb = new StringBuffer();
for (Iterator i = path.getArtifacts().iterator(); i.hasNext(); ) {
RepoArtifact artifact = (RepoArtifact) i.next();
sb.append(artifact.getId().toShortString()).append(";");
}
if (log.isDebugEnabled()) {
log.debug(
"Resolved path: target="
+ target.getName()
+ ", pathGroup="
+ pathGroupId
+ ", path="
+ sb.toString());
}
return path.getArtifacts();
}