Index: src/test/java/org/apache/maven/plugin/dependency/TestSortMojo.java
===================================================================
--- src/test/java/org/apache/maven/plugin/dependency/TestSortMojo.java (revision 0)
+++ src/test/java/org/apache/maven/plugin/dependency/TestSortMojo.java (revision 0)
@@ -0,0 +1,170 @@
+package org.apache.maven.plugin.dependency;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import java.io.File;
+import java.io.FileReader;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.maven.model.Dependency;
+import org.apache.maven.project.MavenProject;
+import org.codehaus.plexus.util.xml.Xpp3Dom;
+import org.codehaus.plexus.util.xml.Xpp3DomBuilder;
+
+/**
+ * Tests TreeMojo.
+ *
+ */
+public class TestSortMojo extends AbstractDependencyMojoTestCase
+{
+ // TestCase methods -------------------------------------------------------
+
+ /*
+ * @see org.apache.maven.plugin.testing.AbstractMojoTestCase#setUp()
+ */
+ protected void setUp() throws Exception
+ {
+ // required for mojo lookups to work
+ super.setUp( "sort", false );
+ }
+
+ // tests ------------------------------------------------------------------
+
+ /**
+ * Tests the proper sorting of dependencies.
+ *
+ * @throws Exception
+ */
+ public void testSortDependencies()
+ throws Exception
+ {
+
+ File testPom = new File( getBasedir(), "target/test-classes/unit/sort-test/pom.xml" );
+ Xpp3Dom testPomDom = Xpp3DomBuilder.build( new FileReader( testPom ) );
+ SortMojo mojo = new SortMojo();
+ MavenProject testProject = new MavenProject();
+ List dependencies = this.extractDependencyConfiguration(testPomDom);
+ testProject.setDependencies(dependencies);
+ mojo.setProject(testProject);
+
+ File outputFile = new File(testDir.getAbsolutePath() + "/sortOutput.txt");
+ setVariableValueToObject( mojo, "outputFile", outputFile );
+ setVariableValueToObject( mojo, "ascending", Boolean.TRUE );
+
+ // Test basic sorting functionality
+ mojo.execute();
+
+ assertDependencyEquals((Dependency)dependencies.get(0), "group a", "artifact b", "5");
+ assertDependencyEquals((Dependency)dependencies.get(1), "group b", "artifact a", "2");
+ assertDependencyEquals((Dependency)dependencies.get(2), "group b", "artifact b", "2");
+ assertDependencyEquals((Dependency)dependencies.get(3), "group c", "artifact a", "1");
+ assertDependencyEquals((Dependency)dependencies.get(4), "group c", "artifact a", "2");
+ assertDependencyEquals((Dependency)dependencies.get(5), "group c", "artifact c", "4");
+
+ // Test groupByScope
+ setVariableValueToObject( mojo, "groupByScope", Boolean.TRUE );
+ mojo.execute();
+
+ //List dependencies = extractDependencies(children);
+ assertDependencyEquals((Dependency)dependencies.get(0), "group b", "artifact a", "2");
+ assertDependencyEquals((Dependency)dependencies.get(1), "group c", "artifact a", "1");
+ assertDependencyEquals((Dependency)dependencies.get(2), "group c", "artifact a", "2");
+ assertDependencyEquals((Dependency)dependencies.get(3), "group c", "artifact c", "4");
+ // provided scope
+ assertDependencyEquals((Dependency)dependencies.get(4), "group b", "artifact b", "2");
+ //test scope
+ assertDependencyEquals((Dependency)dependencies.get(5), "group a", "artifact b", "5");
+
+ }
+
+ // private methods --------------------------------------------------------
+
+ private void assertDependencyEquals( Dependency dependency, String groupId, String artifactId, String version )
+ {
+ assertEquals( dependency.getGroupId(), groupId );
+ assertEquals( dependency.getArtifactId(), artifactId );
+ assertEquals( dependency.getVersion(), version );
+ }
+
+ /**
+ * @param pomDom
+ * @return the List of dependencies
+ */
+ protected List extractDependencyConfiguration( Xpp3Dom pomDom )
+ throws Exception
+ {
+ List dependencies = null;
+
+ Xpp3Dom dependenciesElement = pomDom.getChild( "dependencies" );
+ if ( dependenciesElement != null )
+ {
+ Xpp3Dom[] dependencyElements = dependenciesElement.getChildren();
+
+ dependencies = extractDependencies(dependencyElements);
+ }
+
+ return dependencies;
+ }
+
+ protected List extractDependencies( Xpp3Dom [] dependencyElements )
+ {
+ List dependencies = new ArrayList();
+
+ for (int i = 0; i < dependencyElements.length; i++)
+ {
+ Xpp3Dom dependencyElement = dependencyElements[i];
+
+ Dependency dependency = new Dependency();
+
+ String dependencyElementArtifactId = dependencyElement
+ .getChild("artifactId").getValue();
+ dependency.setArtifactId(dependencyElementArtifactId);
+
+ String dependencyElementGrouptId = dependencyElement.getChild(
+ "groupId").getValue();
+ dependency.setGroupId(dependencyElementGrouptId);
+
+ Xpp3Dom dependencyElementVersion = dependencyElement
+ .getChild("version");
+ if (dependencyElementVersion != null) {
+ dependency.setVersion(dependencyElementVersion.getValue());
+ }
+
+ Xpp3Dom dependencyElementScope = dependencyElement.getChild("scope");
+ if (dependencyElementScope != null) {
+ dependency.setScope(dependencyElementScope.getValue());
+ }
+
+ Xpp3Dom dependencyElementClassifier = dependencyElement.getChild("classifier");
+ if (dependencyElementClassifier != null) {
+ dependency.setClassifier(dependencyElementClassifier.getValue());
+ }
+
+ Xpp3Dom dependencyElementType = dependencyElement.getChild("type");
+ if (dependencyElementType != null) {
+ dependency.setType(dependencyElementType.getValue());
+ }
+
+ dependencies.add(dependency);
+ }
+ return dependencies;
+ }
+}
Index: src/test/resources/unit/sort-test/pom.xml
===================================================================
--- src/test/resources/unit/sort-test/pom.xml (revision 0)
+++ src/test/resources/unit/sort-test/pom.xml (revision 0)
@@ -0,0 +1,67 @@
+
+
+
+
+ group c
+ artifact a
+ 2
+
+
+ group b
+ artifact a
+ 2
+
+
+ group a
+ artifact a
+
+
+ group c
+ artifact 1
+
+
+
+
+ group c
+ artifact c
+ 4
+
+
+ group a
+ artifact b
+ 5
+ test
+
+
+ group b
+ artifact b
+ 2
+ provided
+
+
+ group c
+ artifact a
+ 1
+
+
+
Index: src/main/java/org/apache/maven/plugin/dependency/SortMojo.java
===================================================================
--- src/main/java/org/apache/maven/plugin/dependency/SortMojo.java (revision 0)
+++ src/main/java/org/apache/maven/plugin/dependency/SortMojo.java (revision 0)
@@ -0,0 +1,495 @@
+package org.apache.maven.plugin.dependency;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.apache.maven.model.Dependency;
+import org.apache.maven.model.Exclusion;
+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.codehaus.plexus.util.xml.PrettyPrintXMLWriter;
+
+
+/**
+ * This goal sorts dependencies in alphabetical order. It can also remove
+ * duplicate dependency definitions.
+ *
+ * @goal sort
+ */
+public class SortMojo
+ extends AbstractMojo
+{
+ // fields -----------------------------------------------------------------
+
+ /**
+ * The current project
+ *
+ * @parameter expression="${project}"
+ * @required
+ * @readonly
+ */
+ private MavenProject project;
+
+
+ /**
+ * Output file to write the sorted dependencies. By default output is written to the
+ * command line.
+ * @parameter expression="${mdep.sort.outputFile}"
+ */
+ private File outputFile;
+
+ /**
+ * Sort the dependencies in the dependencyManagement section.
+ *
+ * @parameter expression="${mdep.sort.sortDepMng}" default-value="false"
+ */
+ private boolean sortDepMng;
+
+ /**
+ * Sort the dependencies in ascending or descending alphabetical order.
+ *
+ * @parameter expression="${mdep.sort.ascending}" default-value="true"
+ */
+ private boolean ascending;
+
+ /**
+ * Whether to group the dependencies by scope.
+ *
+ * @parameter expression="${mdep.sort.groupByScope}" default-value="false"
+ */
+ private boolean groupByScope;
+
+ /**
+ * Whether to remove duplicate dependency definitions.
+ *
+ * @parameter expression="${mdep.sort.removeDuplicates}" default-value="true"
+ */
+ private boolean removeDeplicates;
+
+
+ // Mojo methods -----------------------------------------------------------
+
+ /*
+ * @see org.apache.maven.plugin.Mojo#execute()
+ */
+ public void execute() throws MojoExecutionException, MojoFailureException
+ {
+ List dependencies = null;
+ if (sortDepMng)
+ {
+ dependencies = project.getDependencyManagement().getDependencies();
+ }
+ else
+ {
+ dependencies = project.getDependencies();
+ }
+
+ if (this.removeDeplicates)
+ {
+ removeDuplicates(dependencies);
+ }
+
+ StringBuffer depXml;
+ if (groupByScope)
+ {
+ List [] dependencyLists = groupByScope(dependencies);
+ for ( int i = 0; i < dependencyLists.length; ++i )
+ {
+ this.sortDependencies(dependencyLists[i]);
+ }
+
+ depXml = new StringBuffer();
+ dependencies.clear();
+ for ( int i = 0; i < dependencyLists.length; ++i )
+ {
+ for ( int j = 0; j < dependencyLists[i].size(); ++j )
+ {
+ dependencies.add(dependencyLists[i].get(j));
+ }
+ }
+ }
+ else
+ {
+ this.sortDependencies(dependencies);
+ }
+ depXml = this.writeDependencyXML(dependencies);
+
+ if ( outputFile != null )
+ {
+ if ( ! outputFile.getParentFile().exists() )
+ {
+ outputFile.getParentFile().mkdirs();
+ }
+ getLog().info( "Writing sorted dependencies to: " + this.outputFile );
+ try
+ {
+ FileOutputStream fos = new FileOutputStream( this.outputFile );
+ PrintStream ps = new PrintStream(fos);
+ ps.print( "\n" + depXml );
+ ps.close();
+ fos.close();
+ }
+ catch ( IOException ioe )
+ {
+ ioe.printStackTrace();
+ getLog().error( ioe );
+ }
+ }
+ else
+ {
+ getLog().info( "\n" + depXml );
+ }
+ }
+
+ // private methods --------------------------------------------------------
+
+ /**
+ * Sorts dependencies in place.
+ */
+ public void sortDependencies(List dependencies)
+ {
+ quicksort( dependencies, 0, dependencies.size() - 1 , ascending);
+ }
+
+ private List [] groupByScope(List dependencies)
+ {
+ List[] dependencyLists = { new ArrayList(), new ArrayList(),
+ new ArrayList(), new ArrayList(), new ArrayList() };
+ Iterator iter = dependencies.iterator();
+ while(iter.hasNext())
+ {
+ Dependency dependency = (Dependency)iter.next();
+ if ( dependency.getScope() == null || dependency.getScope().equals("compile") )
+ {
+ dependencyLists[0].add(dependency);
+ }
+ else if ( dependency.getScope().equals("provided") )
+ {
+ dependencyLists[1].add(dependency);
+ }
+ else if ( dependency.getScope().equals("runtime") )
+ {
+ dependencyLists[2].add(dependency);
+ }
+ else if ( dependency.getScope().equals("test") )
+ {
+ dependencyLists[3].add(dependency);
+ }
+ else if ( dependency.getScope().equals("system") )
+ {
+ dependencyLists[4].add(dependency);
+ }
+ }
+ return dependencyLists;
+ }
+
+ private void removeDuplicates(List dependencies)
+ {
+ int i = 0;
+ while( i < dependencies.size() )
+ {
+ if ( contains( dependencies, (Dependency)dependencies.get(i), i + 1 ) )
+ {
+ dependencies.remove( i );
+ }
+ else
+ {
+ ++i;
+ }
+ }
+ }
+
+ private boolean contains(List dependencies, Dependency dependency, int index)
+ {
+ for( int i = index; i < dependencies.size(); ++i)
+ {
+ Dependency dependency2 = (Dependency)dependencies.get(i);
+ if (compare(dependency, dependency2) == 0)
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private void swap( List list, int i, int j )
+ {
+ Object tmp = list.get(i);
+ list.set(i, list.get(j));
+ list.set(j, tmp);
+ }
+
+ /**
+ * Quicksort a list of dependencies.
+ * @param list - the list to sort
+ * @param left - left end of the list
+ * @param right - right end of the list
+ * @param ascending - Sort ascending or descending
+ */
+ private void quicksort(List list, int left, int right, boolean ascending)
+ {
+ int i, last;
+
+ if (left >= right) { // do nothing if array size < 2
+ return;
+ }
+ swap(list, left, (left + right) / 2);
+ last = left;
+ for (i = left + 1; i <= right; i++)
+ {
+ Dependency dep1 = (Dependency)list.get(i);
+ Dependency dep2 = (Dependency)list.get(left);
+ if (ascending && compare(dep1, dep2) < 0)
+ {
+ swap(list, ++last, i);
+ }
+ else if (!ascending && compare(dep1, dep2) > 0)
+ {
+ swap(list, ++last, i);
+ }
+ }
+ swap(list, left, last);
+ quicksort(list, left, last - 1, ascending);
+ quicksort(list, last + 1, right, ascending);
+ }
+
+
+ /**
+ * Compare two dependencies. Follows the conventions of java.lang.Comparable.
+ * Two dependencies are considered equal if the groupId, artifactId, version, scope,
+ * and type are all the same.
+ * @param dep1
+ * @param dep2
+ * @return
+ */
+ private int compare(Dependency dep1, Dependency dep2)
+ {
+ if (dep1.equals(dep2))
+ {
+ return 0;
+ }
+
+ int result = dep1.getGroupId().compareTo(dep2.getGroupId());
+
+ if (result != 0) return result;
+
+ result = dep1.getArtifactId().compareTo(dep2.getArtifactId());
+
+ if (result != 0) return result;
+
+ if (dep1.getVersion() == null)
+ {
+ if (dep2.getVersion() == null)
+ {
+ result = 0;
+ }
+ else
+ {
+ result = -1;
+ }
+ }
+ else
+ {
+ if (dep2.getVersion() == null)
+ {
+ result = 1;
+ }
+ else
+ {
+ result = dep1.getVersion().compareTo(dep2.getVersion());
+ }
+ }
+
+ if (result != 0) return result;
+
+ if (dep1.getScope() == null)
+ {
+ if (dep2.getScope() == null)
+ {
+ result = 0;
+ }
+ else
+ {
+ result = -1;
+ }
+ }
+ else
+ {
+ result = dep1.getScope().compareTo(dep2.getScope());
+ }
+
+ if (result != 0) return result;
+
+ if (dep1.getClassifier() == null)
+ {
+ if (dep2.getClassifier() == null)
+ {
+ result = 0;
+ }
+ else
+ {
+ result = -1;
+ }
+ }
+ else
+ {
+ if (dep2.getClassifier() == null)
+ {
+ result = 1;
+ }
+ else
+ {
+ result = dep1.getClassifier().compareTo(dep2.getClassifier());
+ }
+ }
+
+ if (result != 0) return result;
+
+ if (dep1.getType() == null) {
+ if (dep2.getType() == null)
+ {
+ result = 0;
+ }
+ else
+ {
+ result = -1;
+ }
+ }
+ else
+ {
+ if (dep2.getType() == null)
+ {
+ result = 1;
+ }
+ else
+ {
+ result = dep1.getType().compareTo(dep2.getType());
+ }
+ }
+
+ return result;
+ }
+
+ private StringBuffer writeDependencyXML( List dependencies )
+ {
+ if ( !dependencies.isEmpty() )
+ {
+ StringWriter out = new StringWriter();
+ PrettyPrintXMLWriter writer = new PrettyPrintXMLWriter( out );
+
+ writer.startElement( "dependencies" );
+
+ Iterator iter = dependencies.iterator();
+ while ( iter.hasNext() )
+ {
+ Dependency dependency = (Dependency) iter.next();
+
+ writer.startElement( "dependency" );
+ writer.startElement( "groupId" );
+ writer.writeText( dependency.getGroupId() );
+ writer.endElement();
+ writer.startElement( "artifactId" );
+ writer.writeText( dependency.getArtifactId() );
+ writer.endElement();
+ writer.startElement( "version" );
+ writer.writeText( dependency.getVersion());
+ writer.endElement();
+
+ if ( dependency.getScope() != null )
+ {
+ writer.startElement( "scope" );
+ writer.writeText( dependency.getScope() );
+ writer.endElement();
+ }
+
+ if ( dependency.getClassifier() != null )
+ {
+ writer.startElement( "classifier" );
+ writer.writeText( dependency.getClassifier() );
+ writer.endElement();
+ }
+
+ if ( dependency.getType() != null && (! dependency.getType().equals("jar")))
+ {
+ writer.startElement( "type" );
+ writer.writeText( dependency.getType() );
+ writer.endElement();
+ }
+
+ List exclusions = dependency.getExclusions();
+ if ( exclusions != null && (exclusions.size() > 0) )
+ {
+ writer.startElement( "exclusions" );
+ Iterator exclIter = exclusions.iterator();
+ while(exclIter.hasNext())
+ {
+ Exclusion exclusion = (Exclusion)exclIter.next();
+ writer.startElement( "exclusion" );
+ writer.startElement("groupId");
+ writer.writeText( exclusion.getGroupId() );
+ writer.endElement();
+ writer.startElement("artifactId");
+ writer.writeText( exclusion.getArtifactId() );
+ writer.endElement();
+ writer.endElement();
+ }
+ writer.endElement();
+ }
+ writer.endElement();
+
+ }
+ writer.endElement();
+
+ return out.getBuffer();
+ }
+ else
+ {
+ return new StringBuffer();
+ }
+ }
+
+ /**
+ * @return Returns the project.
+ */
+ public MavenProject getProject ()
+ {
+ return this.project;
+ }
+
+ /**
+ * @return Returns the project.
+ */
+ public void setProject (MavenProject project)
+ {
+ this.project = project;
+ }
+
+
+}
Index: src/site/apt/usage.apt
===================================================================
--- src/site/apt/usage.apt (revision 580489)
+++ src/site/apt/usage.apt (working copy)
@@ -560,11 +560,7 @@
+---+
mvn dependency:analyze
+---+
-<<<<<<< .mine
-
-=======
->>>>>>> .r579027
Sample output:
+---+
@@ -607,6 +603,29 @@
[WARNING] Potential problems found in Dependency Management
+---+
+* The <<>> Mojo
+
+ This mojo can be used to organize the dependencies of a pom. This can be helpful if there
+ are a large number of dependencies and you want them in alphabetical order and/or organized
+ by scope.
+
+ This mojo can be executed from the command line:
+
++-----+
+mvn dependency:sort
++-----+
+
+ Optionally, the <<