/**
* This method attempts to find a matching dependency quickly, by bypassing full resolution of the
* classpath path group for a plugin. It assumes the following: 1. The dependendency is directly
* defined by the plugin artifact (this should always be true when a plugin implements an abstract
* method of another) 2. The plugin artifact defines no overrides that effect the dependency (this
* should be true as the plugin should just define the version it wants directly). If the
* performance of resolvePathGroup is improved this method could be replaced by the version below.
*/
private RepoArtifactId fastFindMatchingDependency(Target target, RepoArtifactId id) {
// Find the matching id that belongs to the classpath
PathGroup pathGroup = target.getPathGroup("classpath");
RepoArtifactId match = null;
String matchingPath = null;
for (Iterator i = target.getPlugin().getArtifact().getDependencies().iterator();
i.hasNext(); ) {
RepoDependency dependency = (RepoDependency) i.next();
if (dependency.getId().matches(id)) {
for (Iterator j = dependency.getPathSpecs().iterator(); j.hasNext(); ) {
RepoPathSpec pathSpec = (RepoPathSpec) j.next();
if (pathGroup.getPaths().contains("plugin." + pathSpec.getTo())) {
match = dependency.getId();
matchingPath = pathSpec.getTo();
break;
}
}
}
}
Assert.isTrue(
match != null,
target.getPlugin().getArtifact().getId().toShortString()
+ " does not declare a dependency that matches "
+ id);
// Apply any project overrides
for (Iterator i = overrides.iterator(); i.hasNext(); ) {
ws.quokka.core.model.Override override = (ws.quokka.core.model.Override) i.next();
if (override.getWithVersion() != null && override.matches(match)) {
Set paths = override.matchingPluginPaths(target.getPlugin().getArtifact().getId());
if (paths.contains(matchingPath) || ((paths.size() == 1) && paths.contains("*"))) {
log.verbose("Overriding " + match.toShortString() + " to " + override.getWithVersion());
if (log.isDebugEnabled()) {
log.debug(
"Applied "
+ override
+ (override.getLocator() == null ? "" : " from " + override.getLocator()));
}
return new RepoArtifactId(
id.getGroup(), id.getName(), id.getType(), override.getWithVersion());
}
}
}
return match;
// Slow code
// List artifacts = resolvePathGroup(target, "classpath");
// for (Iterator i = artifacts.iterator(); i.hasNext();) {
// RepoArtifact artifact = (RepoArtifact) i.next();
// if (artifact.getId().matches(id)) {
// return artifact.getId();
// }
// }
}
/**
* 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;
}
/**
* Returns a set of properties for the project. The precedence is: quokka.properties
* quokka.properties of inherited projects plugin.properties No expansion or ordering of
* properties is done
*/
public AnnotatedProperties getProperties() {
AnnotatedProperties resolvedProperties = new AnnotatedProperties();
// Add the global defaults
resolvedProperties.put("quokka.project.targetDir", "${basedir}/target");
resolvedProperties.put("quokka.project.sourceDir", "${basedir}/src");
resolvedProperties.put("quokka.project.resourcesDir", "${basedir}/resources");
// Add artifact related properties
if (project.getArtifacts().size() > 0) {
// Add properties common to all (group & version)
RepoArtifactId artifactId =
((Artifact) getProject().getArtifacts().iterator().next()).getId();
resolvedProperties.put("quokka.project.artifact.group", artifactId.getGroup());
resolvedProperties.put("quokka.project.artifact.version", artifactId.getVersion().toString());
// Build up a list of names by type
Map namesByType = new HashMap();
for (Iterator i = project.getArtifacts().iterator(); i.hasNext(); ) {
Artifact artifact = (Artifact) i.next();
artifactId = artifact.getId();
List names = (List) namesByType.get(artifactId.getType());
if (names == null) {
names = new ArrayList();
namesByType.put(artifactId.getType(), names);
}
names.add(artifactId.getName());
}
// Output the names
for (Iterator i = namesByType.entrySet().iterator(); i.hasNext(); ) {
Map.Entry entry = (Map.Entry) i.next();
List names = (List) entry.getValue();
resolvedProperties.put(
"quokka.project.artifact.name[" + entry.getKey() + "]",
Strings.join(names.iterator(), ","));
}
}
// Put the plugin properties in first. Order is not important as plugin properties should be
// unique to their plugin
for (Iterator i = resolvedTargets.values().iterator(); i.hasNext(); ) {
Target target = (Target) i.next();
AnnotatedProperties targetProperties = target.getDefaultProperties();
resolvedProperties.putAll(
applyProfiles(targetProperties, project.getActiveProfiles().getElements()));
}
// Put in any properties defined in dependency sets (processed in reverse to ensure high levels
// override low levels)
resolveProperties(resolvedProperties, project.getDependencySet());
resolvedProperties.putAll(
applyProfiles(project.getProperties(), project.getActiveProfiles().getElements()));
// Put the project paths as properties
for (Iterator i = resolvedPaths.entrySet().iterator(); i.hasNext(); ) {
Map.Entry entry = (Map.Entry) i.next();
resolvedProperties.put(
"quokka.project.path." + entry.getKey(),
toAntPath(getProjectPath((String) entry.getKey(), false, true)).toString());
}
return resolvedProperties;
}
