private Set<Artifact> processTransitiveDependencies(
Dependency dependency, boolean sharedLibraries) throws MojoExecutionException {
log.debug("Processing transitive dependencies for : " + dependency);
try {
final Set<Artifact> artifacts = new LinkedHashSet<Artifact>();
final List<String> exclusionPatterns = new ArrayList<String>();
if (dependency.getExclusions() != null && !dependency.getExclusions().isEmpty()) {
for (final Exclusion exclusion : dependency.getExclusions()) {
exclusionPatterns.add(exclusion.getGroupId() + ":" + exclusion.getArtifactId());
}
}
final ArtifactFilter optionalFilter =
new ArtifactFilter() {
@Override
public boolean include(Artifact artifact) {
return !artifact.isOptional();
}
};
final AndArtifactFilter filter = new AndArtifactFilter();
filter.add(new ExcludesArtifactFilter(exclusionPatterns));
filter.add(
new OrArtifactFilter(
Arrays.<ArtifactFilter>asList(
new ScopeArtifactFilter("compile"),
new ScopeArtifactFilter("runtime"),
new ScopeArtifactFilter("test"))));
filter.add(optionalFilter);
final DependencyNode node = dependencyGraphBuilder.buildDependencyGraph(project, filter);
final CollectingDependencyNodeVisitor collectingVisitor =
new CollectingDependencyNodeVisitor();
node.accept(collectingVisitor);
final List<DependencyNode> dependencies = collectingVisitor.getNodes();
for (final DependencyNode dep : dependencies) {
final boolean isNativeLibrary =
isNativeLibrary(sharedLibraries, dep.getArtifact().getType());
log.debug("Processing library : " + dep.getArtifact() + " isNative=" + isNativeLibrary);
if (isNativeLibrary) {
artifacts.add(dep.getArtifact());
}
}
return artifacts;
} catch (Exception e) {
throw new MojoExecutionException("Error while processing transitive dependencies", e);
}
}
public List<String> getDependencies() {
List<Dependency> deps = pom.getDependencies();
if (deps == null) return null;
final List<String> dependencies = new ArrayList<String>();
for (Dependency dep : deps) {
if (!dep.isOptional()) {
String coords =
dep.getGroupId()
+ ":"
+ dep.getArtifactId()
+ ":"
+ dep.getVersion()
+ (dep.getClassifier() != null && !dep.getClassifier().isEmpty()
? ":" + dep.getClassifier()
: "");
List<Exclusion> exclusions = dep.getExclusions();
if (exclusions != null && !exclusions.isEmpty()) {
StringBuilder sb = new StringBuilder();
sb.append('(');
for (Exclusion ex : exclusions)
sb.append(ex.getGroupId()).append(':').append(ex.getArtifactId()).append(',');
sb.delete(sb.length() - 1, sb.length());
sb.append(')');
coords += sb.toString();
}
dependencies.add(coords);
}
}
return dependencies;
}
private void handleExclusions(Artifact artifact, Dependency dependency) {
List<String> exclusions = new ArrayList<String>();
for (Exclusion exclusion : dependency.getExclusions()) {
exclusions.add(exclusion.getGroupId() + ":" + exclusion.getArtifactId());
}
ArtifactFilter filter = new ExcludesArtifactFilter(exclusions);
artifact.setDependencyFilter(filter);
}
/**
* Convert dependency to root artifact.
*
* @param dep Dependency
* @return Root artifact
*/
private RootArtifact root(final Dependency dep) {
return new RootArtifact(
this.aether,
new DefaultArtifact(
dep.getGroupId(),
dep.getArtifactId(),
dep.getClassifier(),
dep.getType(),
dep.getVersion()),
dep.getExclusions());
}
// generic method to retrieve all the transitive dependencies
private Collection<Artifact> getAllDependencies() throws MojoExecutionException {
List<Artifact> artifacts = new ArrayList<Artifact>();
for (Iterator<?> dependencies = project.getDependencies().iterator();
dependencies.hasNext(); ) {
Dependency dependency = (Dependency) dependencies.next();
String groupId = dependency.getGroupId();
String artifactId = dependency.getArtifactId();
VersionRange versionRange;
try {
versionRange = VersionRange.createFromVersionSpec(dependency.getVersion());
} catch (InvalidVersionSpecificationException e) {
throw new MojoExecutionException("unable to parse version", e);
}
String type = dependency.getType();
if (type == null) {
type = "jar";
}
String classifier = dependency.getClassifier();
boolean optional = dependency.isOptional();
String scope = dependency.getScope();
if (scope == null) {
scope = Artifact.SCOPE_COMPILE;
}
Artifact art =
this.artifactFactory.createDependencyArtifact(
groupId, artifactId, versionRange, type, classifier, scope, null, optional);
if (scope.equalsIgnoreCase(Artifact.SCOPE_SYSTEM)) {
art.setFile(new File(dependency.getSystemPath()));
}
List<String> exclusions = new ArrayList<String>();
for (Iterator<?> j = dependency.getExclusions().iterator(); j.hasNext(); ) {
Exclusion e = (Exclusion) j.next();
exclusions.add(e.getGroupId() + ":" + e.getArtifactId());
}
ArtifactFilter newFilter = new ExcludesArtifactFilter(exclusions);
art.setDependencyFilter(newFilter);
artifacts.add(art);
}
return artifacts;
}
// DefaultProjectBuilder
public Artifact createDependencyArtifact(Dependency d) {
if (d.getVersion() == null) {
return null;
}
VersionRange versionRange;
try {
versionRange = VersionRange.createFromVersionSpec(d.getVersion());
} catch (InvalidVersionSpecificationException e) {
return null;
}
Artifact artifact =
XcreateDependencyArtifact(
d.getGroupId(),
d.getArtifactId(),
versionRange,
d.getType(),
d.getClassifier(),
d.getScope(),
d.isOptional());
if (Artifact.SCOPE_SYSTEM.equals(d.getScope()) && d.getSystemPath() != null) {
artifact.setFile(new File(d.getSystemPath()));
}
if (!d.getExclusions().isEmpty()) {
List<String> exclusions = new ArrayList<>();
for (Exclusion exclusion : d.getExclusions()) {
exclusions.add(exclusion.getGroupId() + ':' + exclusion.getArtifactId());
}
artifact.setDependencyFilter(new ExcludesArtifactFilter(exclusions));
}
return artifact;
}
private Dependency toAetherDependency(org.apache.maven.model.Dependency dependency) {
Artifact artifact =
new DefaultArtifact(
dependency.getGroupId(),
dependency.getArtifactId(),
dependency.getClassifier(),
dependency.getType(),
dependency.getVersion());
ImmutableList.Builder<Exclusion> exclusions = ImmutableList.builder();
for (org.apache.maven.model.Exclusion exclusion : dependency.getExclusions()) {
exclusions.add(new Exclusion(exclusion.getGroupId(), exclusion.getArtifactId(), null, "*"));
}
return new Dependency(
artifact, dependency.getScope(), dependency.isOptional(), exclusions.build());
}
private DependencyInfo getDependencyInfo(Dependency dependency) {
DependencyInfo info = new DependencyInfo();
// dependency data
info.setGroupId(dependency.getGroupId());
info.setArtifactId(dependency.getArtifactId());
info.setVersion(dependency.getVersion());
info.setScope(dependency.getScope());
info.setClassifier(dependency.getClassifier());
info.setOptional(dependency.isOptional());
info.setType(dependency.getType());
info.setSystemPath(dependency.getSystemPath());
// exclusions
Collection<ExclusionInfo> exclusions = info.getExclusions();
final List<Exclusion> mavenExclusions = dependency.getExclusions();
for (Exclusion exclusion : mavenExclusions) {
exclusions.add(new ExclusionInfo(exclusion.getGroupId(), exclusion.getArtifactId()));
}
return info;
}
private File generateRubyStub(
final GemSpecification gemspec, final MavenArtifact artifact, final RubyDependencyType type)
throws IOException {
final VelocityContext context = new VelocityContext();
switch (type) {
case RUNTIME:
if (artifact.getArtifactFile() != null) {
context.put(
"jarfile",
createJarfileName(
artifact.getCoordinates().getGroupId(),
artifact.getCoordinates().getArtifactId(),
artifact.getCoordinates().getVersion()));
}
break;
case DEVELOPMENT:
context.put("filename", artifact.getCoordinates().getArtifactId() + ".rb");
break;
}
final List<MavenDependency> deps = new ArrayList<MavenDependency>();
for (final Dependency dependency : artifact.getPom().getDependencies()) {
if (RubyDependencyType.toRubyDependencyType(dependency.getScope()) == type
&& !dependency.isOptional()) {
final MavenDependency mavenDependency = new MavenDependency();
mavenDependency.name =
createRequireName(
dependency.getGroupId(), dependency.getArtifactId(), dependency.getVersion());
for (final Exclusion exclusion : dependency.getExclusions()) {
mavenDependency.exclusions.add(exclusion.getGroupId() + "/" + exclusion.getArtifactId());
}
deps.add(mavenDependency);
}
}
context.put("dependencies", deps);
return generateRubyFile("require" + type.name(), context, "rubyStub" + type.name());
}
/**
* Returns the list of project artifacts. Also artifacts generated from referenced projects will
* be added, but with the <code>resolved</code> property set to true.
*
* @return list of projects artifacts
* @throws MojoExecutionException if unable to parse dependency versions
*/
private Set getProjectArtifacts() throws MojoExecutionException {
// keep it sorted, this should avoid random classpath order in tests
Set artifacts = new TreeSet();
for (Iterator dependencies = getProject().getDependencies().iterator();
dependencies.hasNext(); ) {
Dependency dependency = (Dependency) dependencies.next();
String groupId = dependency.getGroupId();
String artifactId = dependency.getArtifactId();
VersionRange versionRange;
try {
versionRange = VersionRange.createFromVersionSpec(dependency.getVersion());
} catch (InvalidVersionSpecificationException e) {
throw new MojoExecutionException(
Messages.getString(
"unabletoparseversion",
new Object[] { // $NON-NLS-1$
dependency.getArtifactId(),
dependency.getVersion(),
dependency.getManagementKey(),
e.getMessage()
}),
e);
}
String type = dependency.getType();
if (type == null) {
type = "jar"; // $NON-NLS-1$
}
String classifier = dependency.getClassifier();
boolean optional = dependency.isOptional();
String scope = dependency.getScope();
if (scope == null) {
scope = Artifact.SCOPE_COMPILE;
}
Artifact art =
getArtifactFactory()
.createDependencyArtifact(
groupId, artifactId, versionRange, type, classifier, scope, optional);
if (scope.equalsIgnoreCase(Artifact.SCOPE_SYSTEM)) {
art.setFile(new File(dependency.getSystemPath()));
}
List exclusions = new ArrayList();
for (Iterator j = dependency.getExclusions().iterator(); j.hasNext(); ) {
Exclusion e = (Exclusion) j.next();
exclusions.add(e.getGroupId() + ":" + e.getArtifactId()); // $NON-NLS-1$
}
ArtifactFilter newFilter = new ExcludesArtifactFilter(exclusions);
art.setDependencyFilter(newFilter);
artifacts.add(art);
}
return artifacts;
}
public CollectResult collectDependencies(
Task task,
Dependencies dependencies,
LocalRepository localRepository,
RemoteRepositories remoteRepositories) {
RepositorySystemSession session = getSession(task, localRepository);
remoteRepositories =
remoteRepositories == null
? AetherUtils.getDefaultRepositories(project)
: remoteRepositories;
List<org.sonatype.aether.repository.RemoteRepository> repos =
ConverterUtils.toRepositories(project, session, remoteRepositories, getRemoteRepoMan());
CollectRequest collectRequest = new CollectRequest();
collectRequest.setRequestContext("project");
for (org.sonatype.aether.repository.RemoteRepository repo : repos) {
task.getProject().log("Using remote repository " + repo, Project.MSG_VERBOSE);
collectRequest.addRepository(repo);
}
if (dependencies != null) {
List<Exclusion> globalExclusions = dependencies.getExclusions();
Collection<String> ids = new HashSet<String>();
for (Dependency dep : dependencies.getDependencies()) {
ids.add(dep.getVersionlessKey());
collectRequest.addDependency(ConverterUtils.toDependency(dep, globalExclusions, session));
}
if (dependencies.getPom() != null) {
Model model = dependencies.getPom().getModel(task);
for (org.apache.maven.model.Dependency dep : model.getDependencies()) {
Dependency dependency = new Dependency();
dependency.setArtifactId(dep.getArtifactId());
dependency.setClassifier(dep.getClassifier());
dependency.setGroupId(dep.getGroupId());
dependency.setScope(dep.getScope());
dependency.setType(dep.getType());
dependency.setVersion(dep.getVersion());
if (ids.contains(dependency.getVersionlessKey())) {
continue;
}
if (dep.getSystemPath() != null && dep.getSystemPath().length() > 0) {
dependency.setSystemPath(task.getProject().resolveFile(dep.getSystemPath()));
}
for (org.apache.maven.model.Exclusion exc : dep.getExclusions()) {
Exclusion exclusion = new Exclusion();
exclusion.setGroupId(exc.getGroupId());
exclusion.setArtifactId(exc.getArtifactId());
exclusion.setClassifier("*");
exclusion.setExtension("*");
dependency.addExclusion(exclusion);
}
collectRequest.addDependency(
ConverterUtils.toDependency(dependency, globalExclusions, session));
}
}
}
task.getProject().log("Collecting dependencies", Project.MSG_VERBOSE);
CollectResult result;
try {
result = getSystem().collectDependencies(session, collectRequest);
} catch (DependencyCollectionException e) {
throw new BuildException("Could not collect dependencies: " + e.getMessage(), e);
}
return result;
}