Here it is, it sorts only the artifactId, I retrieved the versions through
other means.
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.project.MavenProject;
import org.sonatype.aether.RepositorySystem;
import org.sonatype.aether.RepositorySystemSession;
import org.sonatype.aether.collection.CollectRequest;
import org.sonatype.aether.collection.CollectResult;
import org.sonatype.aether.collection.DependencyCollectionException;
import org.sonatype.aether.graph.Dependency;
import org.sonatype.aether.graph.DependencyNode;
import org.sonatype.aether.repository.RemoteRepository;
import org.sonatype.aether.util.DefaultRepositorySystemSession;
import org.sonatype.aether.util.artifact.DefaultArtifact;
import org.sonatype.aether.util.graph.PostorderNodeListGenerator;
import
org.sonatype.aether.util.graph.transformer.NoopDependencyGraphTransformer;
/**
*
* @goal z
*
*/
public class MyMojo extends AbstractMojo {
/**
* The entry point to Aether, i.e. the component doing all the work.
*
* @component
*/
private RepositorySystem repoSystem;
/**
* The current repository/network configuration of Maven.
*
* @parameter default-value="${repositorySystemSession}"
* @readonly
*/
private RepositorySystemSession repoSession;
/**
* The project's remote repositories to use for the resolution.
*
* @parameter default-value="${project.remoteProjectRepositories}"
* @readonly
*/
private List<RemoteRepository> remoteRepos;
/**
* @parameter default-value="${project}"
* @readonly
*/
private MavenProject project;
public void execute() throws MojoFailureException, MojoExecutionException {
// Create the root node
Dependency dependency = new Dependency(new
DefaultArtifact(project.getArtifact().getId()), "compile");
// Collect the whole expanded dependency tree, where nodes can be
// duplicated and no conflicts have been resolved
CollectRequest collectRequest = new CollectRequest();
collectRequest.setRoot(dependency);
collectRequest.setRepositories(remoteRepos);
CollectResult collectResult = null;
try {
DefaultRepositorySystemSession myRepoSession = new
DefaultRepositorySystemSession(repoSession);
NoopDependencyGraphTransformer myVisitor = new
NoopDependencyGraphTransformer();
myRepoSession = myRepoSession.setDependencyGraphTransformer(myVisitor);
collectResult = repoSystem.collectDependencies(myRepoSession,
collectRequest);
} catch (DependencyCollectionException e) {
e.printStackTrace();
}
// Sorting the whole dependency tree using Postorder from Aether
PostorderNodeListGenerator nlg = new PostorderNodeListGenerator();
DependencyNode node = collectResult.getRoot();
node.accept(nlg);
// Excluding the duplicated nodes, we start from the top of the list and
// exclude any node which has already been seen
List<DependencyNode> nodesList = nlg.getNodes();
List<DependencyNode> seenList = new ArrayList<DependencyNode>();
for (Iterator<DependencyNode> it = nodesList.iterator(); it.hasNext();) {
DependencyNode dep = it.next();
if (contains(seenList, dep)) {
it.remove();
} else {
seenList.add(dep);
}
}
// Topological sort is a revert postorder sort
Collections.reverse(nodesList);
// Finally, only the artifactIds are extracted. The versions don't match
// Maven's resolver.
// We can resolve versions by using Aether's
// NearestVersionConflictResolver graph transformer, but in our case the
// artifactIds were sufficient.
List<String> sortedDependencies = new LinkedList<String>();
for (DependencyNode dependencyNode : nodesList) {
sortedDependencies.add(dependencyNode.getDependency().getArtifact().getArtifactId());
}
System.out.println("Sorted dependencies:");
for (String artifactId : sortedDependencies) {
System.out.println(artifactId);
}
}
private boolean contains(List<DependencyNode> seenList, DependencyNode dep)
{
for (DependencyNode node : seenList) {
if (dep.getDependency().getArtifact().getArtifactId()
.equals(node.getDependency().getArtifact().getArtifactId())) {
return true;
}
}
return false;
}
}
On Sat, Nov 26, 2011 at 8:56 PM, Barrie Treloar <[email protected]> wrote:
> On Fri, Nov 25, 2011 at 11:41 PM, Jérémy <[email protected]> wrote:
> > Hi guys,
> >
> > I've finally succeeded!
> >
> > The trick was to play with the DependencyGraphTransformers in order to
> get
> > a non-reducted dependency tree. Then I used Aether's
> PostorderNodeListGenerator
> > to sort the nodes, and finally I removed the duplicated nodes.
>
> Any code snippets?
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: [email protected]
> For additional commands, e-mail: [email protected]
>
>
