You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by jv...@apache.org on 2008/01/19 23:14:17 UTC
svn commit: r613470 - in /maven/artifact/trunk: ./
src/main/java/org/apache/maven/artifact/
src/main/java/org/apache/maven/artifact/resolver/conflict/
src/main/java/org/apache/maven/artifact/resolver/metadata/
src/main/java/org/apache/maven/artifact/tr...
Author: jvanzyl
Date: Sat Jan 19 14:14:15 2008
New Revision: 613470
URL: http://svn.apache.org/viewvc?rev=613470&view=rev
Log:
o Patches from Oleg which aid in the visualization of the graph
Modified:
maven/artifact/trunk/pom.xml
maven/artifact/trunk/src/main/java/org/apache/maven/artifact/ArtifactScopeEnum.java
maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/conflict/DefaultGraphConflictResolver.java
maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/ArtifactMetadata.java
maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/DefaultMetadataResolver.java
maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataGraph.java
maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataGraphEdge.java
maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataGraphVertex.java
maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataResolutionRequest.java
maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataResolutionRequestTypeEnum.java
maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataResolutionResult.java
maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataResolver.java
maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataTreeNode.java
maven/artifact/trunk/src/main/java/org/apache/maven/artifact/transform/DefaultClasspathTransformation.java
maven/artifact/trunk/src/test/java/org/apache/maven/artifact/resolver/conflict/DefaultGraphConflictResolverTest.java
maven/artifact/trunk/src/test/java/org/apache/maven/artifact/transform/DefaultClasspathTransformationTest.java
Modified: maven/artifact/trunk/pom.xml
URL: http://svn.apache.org/viewvc/maven/artifact/trunk/pom.xml?rev=613470&r1=613469&r2=613470&view=diff
==============================================================================
--- maven/artifact/trunk/pom.xml (original)
+++ maven/artifact/trunk/pom.xml Sat Jan 19 14:14:15 2008
@@ -146,15 +146,14 @@
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>retrotranslator-maven-plugin</artifactId>
- <version>1.0-alpha-2</version>
+ <version>1.0-alpha-3</version>
<executions>
<execution>
<goals>
<goal>translate-project</goal>
</goals>
<configuration>
- <classifier>jdk14</classifier>
- <attach>true</attach>
+ <embed>true</embed>
</configuration>
</execution>
</executions>
Modified: maven/artifact/trunk/src/main/java/org/apache/maven/artifact/ArtifactScopeEnum.java
URL: http://svn.apache.org/viewvc/maven/artifact/trunk/src/main/java/org/apache/maven/artifact/ArtifactScopeEnum.java?rev=613470&r1=613469&r2=613470&view=diff
==============================================================================
--- maven/artifact/trunk/src/main/java/org/apache/maven/artifact/ArtifactScopeEnum.java (original)
+++ maven/artifact/trunk/src/main/java/org/apache/maven/artifact/ArtifactScopeEnum.java Sat Jan 19 14:14:15 2008
@@ -69,7 +69,7 @@
}
private static final ArtifactScopeEnum [][][] _compliancySets = {
- { { compile }, { compile, test, runtime, provided, system } }
+ { { compile }, { compile, provided, system } }
, { { test }, { compile, test, provided, system } }
, { { runtime }, { compile, runtime, system } }
, { { provided }, { compile, test, provided } }
@@ -89,10 +89,12 @@
if( id == system.id )
return scope.id == system.id;
-
- for( ArtifactScopeEnum[][] set : _compliancySets ) {
- if( id == set[0][0].id ) {
- for( ArtifactScopeEnum ase : set[1] ) {
+ for( ArtifactScopeEnum[][] set : _compliancySets )
+ {
+ if( id == set[0][0].id )
+ {
+ for( ArtifactScopeEnum ase : set[1] )
+ {
if( s.id == ase.id )
return true;
}
Modified: maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/conflict/DefaultGraphConflictResolver.java
URL: http://svn.apache.org/viewvc/maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/conflict/DefaultGraphConflictResolver.java?rev=613470&r1=613469&r2=613470&view=diff
==============================================================================
--- maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/conflict/DefaultGraphConflictResolver.java (original)
+++ maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/conflict/DefaultGraphConflictResolver.java Sat Jan 19 14:14:15 2008
@@ -23,6 +23,7 @@
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.TreeSet;
import org.apache.maven.artifact.ArtifactScopeEnum;
import org.apache.maven.artifact.resolver.metadata.ArtifactMetadata;
@@ -54,41 +55,6 @@
*/
protected GraphConflictResolutionPolicy policy;
//-------------------------------------------------------------------------------------
- private class EdgeHolder
- {
- String key;
- MetadataGraphEdge edge;
-
- public EdgeHolder(String key, MetadataGraphEdge edge )
- {
- set( key, edge );
- }
-
- public EdgeHolder()
- {
- }
-
- public void set( String key, MetadataGraphEdge edge )
- {
- this.key = key;
- this.edge = edge;
- }
-
- public void set( EdgeHolder eh )
- {
- set( eh.key, eh.edge );
- }
-
- public boolean eq(EdgeHolder eh)
- {
- return key != null
- && edge != null
- && key.equals(eh.key)
- && edge.equals(eh.edge)
- ;
- }
-
- }
//-------------------------------------------------------------------------------------
public MetadataGraph resolveConflicts( MetadataGraph graph, ArtifactScopeEnum scope )
throws GraphConflictResolutionException
@@ -103,62 +69,76 @@
if( entry == null )
return null;
- final Map<String, List<MetadataGraphEdge>> edges = graph.getEdges();
- if( edges == null || edges.size() < 1 )
- return null;
-
- final Map<String, MetadataGraphVertex> vertices = graph.getVertices();
- if( vertices == null || vertices.size() < 1 )
+ if( graph.isEmpty() )
throw new GraphConflictResolutionException("graph with an entry, but not vertices do not exist");
+
+ if( graph.isEmptyEdges() )
+ return null; // no edges - nothing to worry about
+
+ final TreeSet<MetadataGraphVertex> vertices = graph.getVertices();
try {
- // edge case - single vertice graph
+ // edge case - single vertex graph
if( vertices.size() == 1 )
return new MetadataGraph( entry );
final ArtifactScopeEnum requestedScope = ArtifactScopeEnum.checkScope(scope);
- MetadataGraph res = new MetadataGraph( vertices.size(), edges.size() );
- res.setEntry( graph.getEntry() );
- res.setScope(requestedScope);
+ MetadataGraph res = new MetadataGraph( vertices.size() );
+ res.setVersionedVertices( false );
+ res.setScopedVertices( false );
+
+ MetadataGraphVertex resEntry = res.addVertex( entry.getMd() );
+ res.setEntry( resEntry );
+
+ res.setScope( requestedScope );
- for( Map.Entry<String, MetadataGraphVertex> mv : vertices.entrySet() ) {
- final MetadataGraphVertex v = mv.getValue();
- final EdgeHolder eh = cleanEdges( v, edges, requestedScope );
+ for( MetadataGraphVertex v : vertices ) {
+ final List<MetadataGraphEdge> ins = graph.getIncidentEdges(v);
+ final MetadataGraphEdge edge = cleanEdges( v, ins, requestedScope );
- if( eh == null ) { // no edges - don't need this vertice any more
- if( entry.getMd().toDomainString().equals(v.getMd().toDomainString() ) ) {
- // currently processing the entry point - it should not have any dependents
- // so add it anyway
- entry.getMd().setWhy("This is a graph entry point. No links.");
- res.addVertice(v);
+ if( edge == null ) { // no edges - don't need this vertex any more
+ if( entry.equals(v) ) { // unless it's an entry point.
+ // currently processing the entry point - it should not have any entry incident edges
+ res.getEntry().getMd().setWhy("This is a graph entry point. No links.");
+ }
+ else
+ {
+//System.out.println("--->"+v.getMd().toDomainString()
+//+" has been terminated on this entry set\n-------------------\n"
+//+ins
+//+"\n-------------------\n"
+//);
}
}
else
{
+//System.out.println("+++>"+v.getMd().toDomainString()+" still has "+edge.toString() );
// fill in domain md with actual version data
ArtifactMetadata md = v.getMd();
ArtifactMetadata newMd = new ArtifactMetadata(
md.getGroupId()
, md.getArtifactId()
- , eh.edge.getVersion()
+ , edge.getVersion()
, md.getType()
, md.getScopeAsEnum()
, md.getClassifier()
- , eh.edge.getArtifactUri()
- , eh.edge.getSource() == null
- ? ""
- : eh.edge.getSource().toString()
- , eh.edge.isResolved()
- , eh.edge.getTarget() == null ? null : eh.edge.getTarget().getError()
+ , edge.getArtifactUri()
+ , edge.getSource() == null ? "" : edge.getSource().getMd().toString()
+ , edge.isResolved()
+ , edge.getTarget() == null ? null : edge.getTarget().getMd().getError()
);
- v.setMd(newMd);
- res.addVertice(v);
- res.addEdge( eh.key, eh.edge );
+ MetadataGraphVertex newV = res.addVertex( newMd );
+ MetadataGraphVertex sourceV = res.addVertex( edge.getSource().getMd() );
+
+ res.addEdge( sourceV, newV, edge );
}
}
-
- return findLinkedSubgraph( res );
+ MetadataGraph linkedRes = findLinkedSubgraph( res );
+//System.err.println("Original graph("+graph.getVertices().size()+"):\n"+graph.toString());
+//System.err.println("Cleaned("+requestedScope+") graph("+res.getVertices().size()+"):\n"+res.toString());
+//System.err.println("Linked("+requestedScope+") subgraph("+linkedRes.getVertices().size()+"):\n"+linkedRes.toString());
+ return linkedRes;
} catch (MetadataResolutionException e) {
throw new GraphConflictResolutionException(e);
}
@@ -169,119 +149,79 @@
if( g.getVertices().size() == 1 )
return g;
- List<String> visited = new ArrayList<String>( g.getVertices().size() );
- visit( g.getEntry().getMd().toDomainString(), visited, g.getEdges() );
+ List<MetadataGraphVertex> visited = new ArrayList<MetadataGraphVertex>( g.getVertices().size() );
+ visit( g.getEntry(), visited, g );
- List<String> dropList = new ArrayList<String>( g.getVertices().size() );
+ List<MetadataGraphVertex> dropList = new ArrayList<MetadataGraphVertex>( g.getVertices().size() );
// collect drop list
- for( Map.Entry<String, MetadataGraphVertex> mv : g.getVertices().entrySet() )
+ for( MetadataGraphVertex v : g.getVertices() )
{
- if( !visited.contains(mv.getKey()) )
- dropList.add( mv.getKey() );
+ if( !visited.contains(v) )
+ dropList.add( v );
}
if( dropList.size() < 1 )
return g;
// now - drop vertices
- Map<String, MetadataGraphVertex> vertices = g.getVertices();
- for( String v : dropList )
+ TreeSet<MetadataGraphVertex> vertices = g.getVertices();
+ for( MetadataGraphVertex v : dropList )
{
vertices.remove(v);
}
- // collect edgeDropList
- List<String> edgeDropList = new ArrayList<String>( g.getEdges().size() );
- for( Map.Entry<String, List<MetadataGraphEdge>> me : g.getEdges().entrySet() )
- {
- String eKey = me.getKey();
- int ind = eKey.indexOf( MetadataGraph.DEFAULT_DOMAIN_SEPARATOR );
- String v1 = eKey.substring(0,ind);
- String v2 = eKey.substring(ind+1);
-
- if( visited.contains(v1) && visited.contains(v2) )
- continue;
-
- edgeDropList.add(eKey);
- }
-
- if( edgeDropList.size() < 1 )
- return g;
-
- // now - drop edges
- Map<String, List<MetadataGraphEdge>> edges = g.getEdges();
- for( String v : edgeDropList )
- {
- edges.remove(v);
- }
-
return g;
}
//-------------------------------------------------------------------------------------
- private final void visit( String from, List<String> visited, Map<String, List<MetadataGraphEdge>> edges )
+ private final void visit( MetadataGraphVertex from
+ , List<MetadataGraphVertex> visited
+ , MetadataGraph graph
+ )
{
if( visited.contains( from ) )
return;
visited.add(from);
- for( Map.Entry<String, List<MetadataGraphEdge>> e : edges.entrySet() )
- {
- if( e.getKey().startsWith(from) ) {
- String to = e.getKey().substring( e.getKey().indexOf(MetadataGraph.DEFAULT_DOMAIN_SEPARATOR)+1 );
- visit( to, visited, edges );
+ List<MetadataGraphEdge> exitList = graph.getExcidentEdges(from);
+//String s = "|---> "+from.getMd().toString()+" - "+(exitList == null ? -1 : exitList.size()) + " exit links";
+ if( exitList != null && exitList.size() > 0 ) {
+ for( MetadataGraphEdge e : graph.getExcidentEdges(from) )
+ {
+ visit( e.getTarget(), visited, graph );
}
}
}
//-------------------------------------------------------------------------------------
- private final EdgeHolder cleanEdges( MetadataGraphVertex v
- , Map< String, List<MetadataGraphEdge> > edges
- , ArtifactScopeEnum scope
- )
+ private final MetadataGraphEdge cleanEdges( MetadataGraphVertex v
+ , List<MetadataGraphEdge> edges
+ , ArtifactScopeEnum scope
+ )
{
- List< EdgeHolder > dirtyEdges = new ArrayList< EdgeHolder >(32);
- String vKey = v.getMd().toDomainString();
- for( Map.Entry<String, List<MetadataGraphEdge>> el : edges.entrySet() ) {
- if( el.getKey().endsWith(vKey) ) {
- for( MetadataGraphEdge e : el.getValue() ) {
- dirtyEdges.add( new EdgeHolder(el.getKey(), e) );
- }
- }
- }
-
- if( dirtyEdges.size() < 1 )
+ if( edges == null || edges.isEmpty() )
return null;
-
- EdgeHolder res = new EdgeHolder();
-
- if( dirtyEdges.size() == 1 ) {
- if( scope.encloses( dirtyEdges.get(0).edge.getScope()) )
- return dirtyEdges.get(0);
-
+
+ if( edges.size() == 1 ) {
+ MetadataGraphEdge e = edges.get(0);
+ if( scope.encloses( e.getScope() ) )
+ return e;
+
return null;
}
-
- for( EdgeHolder eh : dirtyEdges )
+
+ MetadataGraphEdge res = null;
+
+ for( MetadataGraphEdge e : edges )
{
- if( !scope.encloses(eh.edge.getScope()) )
+ if( !scope.encloses( e.getScope()) )
continue;
-
- if( res.key == null )
- {
- res.set( eh );
- }
- else
- {
- MetadataGraphEdge winner = policy.apply( eh.edge, res.edge );
- if( ! res.edge.equals(winner) ) {
- res.set(eh);
- }
- }
- }
- if( res.key == null )
- return null;
+ if( res == null )
+ res = e;
+ else
+ res = policy.apply( e, res );
+ }
return res;
}
Modified: maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/ArtifactMetadata.java
URL: http://svn.apache.org/viewvc/maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/ArtifactMetadata.java?rev=613470&r1=613469&r2=613470&view=diff
==============================================================================
--- maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/ArtifactMetadata.java (original)
+++ maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/ArtifactMetadata.java Sat Jan 19 14:14:15 2008
@@ -40,7 +40,6 @@
/** does the actual artifact for this metadata exists */
protected boolean artifactExists = false;
-
/** artifact URI */
protected String artifactUri;
@@ -145,6 +144,31 @@
this.resolved = resolved;
this.error = error;
}
+ //------------------------------------------------------------------
+ public ArtifactMetadata( String groupId
+ , String name
+ , String version
+ , String type
+ , String scopeString
+ , String classifier
+ , String artifactUri
+ , String why
+ , boolean resolved
+ , String error
+ )
+ {
+ this( groupId
+ , name
+ , version
+ , type
+ , scopeString == null ? ArtifactScopeEnum.DEFAULT_SCOPE : ArtifactScopeEnum.valueOf(scopeString)
+ , classifier
+ , artifactUri
+ , why
+ , resolved
+ , error
+ );
+ }
//------------------------------------------------------------------
public ArtifactMetadata( Artifact af )
@@ -217,6 +241,11 @@
public String getType()
{
return type;
+ }
+
+ public String getCheckedType()
+ {
+ return type == null ? "jar" : type;
}
public void setType( String type )
Modified: maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/DefaultMetadataResolver.java
URL: http://svn.apache.org/viewvc/maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/DefaultMetadataResolver.java?rev=613470&r1=613469&r2=613470&view=diff
==============================================================================
--- maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/DefaultMetadataResolver.java (original)
+++ maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/DefaultMetadataResolver.java Sat Jan 19 14:14:15 2008
@@ -3,10 +3,8 @@
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
-import java.util.Set;
import org.apache.maven.artifact.Artifact;
-import org.apache.maven.artifact.ArtifactScopeEnum;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
@@ -55,12 +53,7 @@
{
getLogger().debug( "Received request for: " + req.getQuery() );
- MetadataResolutionResult res = new MetadataResolutionResult( conflictResolver, classpathTransformation);
-
- if ( req.type == null )
- {
- throw new MetadataResolutionException( "no type in the request" );
- }
+ MetadataResolutionResult res = new MetadataResolutionResult();
MetadataTreeNode tree = resolveMetadataTree( req.getQuery()
, null
@@ -96,8 +89,8 @@
query.getGroupId()
, query.getArtifactId()
, query.getVersion()
- , null
- , "pom"
+ , query.getScope()
+ , query.getType() == null ? "jar" : query.getType()
);
getLogger().debug( "resolveMetadata request:"
@@ -156,14 +149,8 @@
);
ArtifactMetadata found = metadataResolution.getArtifactMetadata();
- // TODO
- // Oleg: this is a shortcut to get AMd artifact location URI
- // it is only valid because artifact (A) resolution is done BEFORE
- // Md resolution.
- //
- // Should be done inside Md Source instead
- //
- found.setArtifactUri( pomArtifact.getFile().toURI().toString() );
+ if( pomArtifact.getFile() != null && pomArtifact.getFile().toURI() != null )
+ found.setArtifactUri( pomArtifact.getFile().toURI().toString() );
MetadataTreeNode node = new MetadataTreeNode( found
, parent
@@ -198,6 +185,42 @@
throw new MetadataResolutionException( anyEx );
}
}
+ //------------------------------------------------------------------------
+ public List<Artifact> resolveArtifact(
+ List<ArtifactMetadata> mdCollection
+ , ArtifactRepository localRepository
+ , List<ArtifactRepository> remoteRepositories
+ )
+ throws ArtifactResolutionException
+ {
+ if( mdCollection == null || mdCollection.isEmpty() )
+ return null;
+
+ ArrayList<Artifact> res = new ArrayList<Artifact>( mdCollection.size() );
+ Artifact artifact = null;
+ try {
+ // TODO: optimize retrieval by zipping returns from repo managers (nexus)
+ for( ArtifactMetadata md : mdCollection )
+ {
+ artifact = artifactFactory.createArtifact(
+ md.getGroupId()
+ , md.getArtifactId()
+ , md.getVersion()
+ , md.getScope()
+ , md.getType() == null ? "jar" : md.getType()
+ );
+ artifactResolver.resolve( artifact, remoteRepositories , localRepository );
+ res.add(artifact);
+ }
+ return res;
+ } catch (ArtifactNotFoundException e) {
+ e.printStackTrace();
+ throw new ArtifactResolutionException( e.getMessage()
+ , artifact
+ , remoteRepositories
+ );
+ }
+ }
//------------------------------------------------------------------------
//------------------------------------------------------------------------
}
Modified: maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataGraph.java
URL: http://svn.apache.org/viewvc/maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataGraph.java?rev=613470&r1=613469&r2=613470&view=diff
==============================================================================
--- maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataGraph.java (original)
+++ maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataGraph.java Sat Jan 19 14:14:15 2008
@@ -4,6 +4,7 @@
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.TreeSet;
import org.apache.maven.artifact.ArtifactScopeEnum;
@@ -16,42 +17,58 @@
public class MetadataGraph
{
- public static char DEFAULT_DOMAIN_SEPARATOR = '>';
+ public static int DEFAULT_VERTICES = 32;
+ public static int DEFAULT_EDGES = 64;
+
+ // flags to indicate the granularity of vertices
+ private boolean versionedVertices = false;
+ private boolean scopedVertices = false;
/**
* the entry point we started building the graph from
*/
MetadataGraphVertex entry;
- Map<String, MetadataGraphVertex> vertices;
- Map<String, List<MetadataGraphEdge>> edges;
+ // graph vertices
+ TreeSet< MetadataGraphVertex > vertices;
+
+ /**
+ * incident and excident edges per node
+ */
+ Map<MetadataGraphVertex, List<MetadataGraphEdge>> incidentEdges;
+ Map<MetadataGraphVertex, List<MetadataGraphEdge>> excidentEdges;
/**
- * null in dirty graph, actual scope for transformed graph
+ * null in dirty graph, actual
+ * scope for conflict-resolved graph
*/
ArtifactScopeEnum scope;
//------------------------------------------------------------------------
/**
- * construct graph from a "dirty" tree
+ * init graph
*/
+ public MetadataGraph( int nVertices )
+ {
+ init( nVertices, 2*nVertices );
+ }
public MetadataGraph( int nVertices, int nEdges )
- throws MetadataResolutionException
{
- edges = new HashMap<String, List<MetadataGraphEdge>>( nEdges );
- vertices = new HashMap<String, MetadataGraphVertex>( nVertices );
+ init( nVertices, nEdges );
}
//------------------------------------------------------------------------
/**
- * construct a single vertice
+ * construct a single vertex
*/
public MetadataGraph( MetadataGraphVertex entry )
throws MetadataResolutionException
{
- if( entry == null || entry.getMd() == null )
- throw new MetadataResolutionException("cannot create a MetadataGraph out of empty vertice");
- vertices = new HashMap<String, MetadataGraphVertex>( 1 );
- vertices.put( entry.getMd().toDomainString(), entry );
-
+ checkVertex(entry);
+ checkVertices(1);
+
+ entry.setCompareVersion( versionedVertices );
+ entry.setCompareScope( scopedVertices );
+
+ vertices.add( entry );
this.entry = entry;
}
//------------------------------------------------------------------------
@@ -61,20 +78,39 @@
public MetadataGraph( MetadataTreeNode tree )
throws MetadataResolutionException
{
+ this( tree, false, false );
+ }
+ //------------------------------------------------------------------------
+ /**
+ * construct graph from a "dirty" tree
+ *
+ * @param tree "dirty" tree root
+ * @param versionedVertices true if graph nodes should be versioned (different versions -> different nodes)
+ * @param scopedVertices true if graph nodes should be versioned and scoped (different versions and/or scopes -> different nodes)
+ *
+ */
+ public MetadataGraph( MetadataTreeNode tree, boolean versionedVertices, boolean scopedVertices )
+ throws MetadataResolutionException
+ {
if ( tree == null )
{
throw new MetadataResolutionException( "tree is null" );
}
+ setVersionedVertices(versionedVertices);
+ setScopedVertices(scopedVertices);
+
+ this.versionedVertices = scopedVertices ? true : versionedVertices;
+ this.scopedVertices = scopedVertices;
+
int count = countNodes( tree );
- vertices = new HashMap<String, MetadataGraphVertex>( count );
- edges = new HashMap<String, List<MetadataGraphEdge>>( count + ( count / 2 ) );
- processNodes( null, tree, 0, 0 );
- }
+ init( count, count + ( count / 2 ) );
+ processTreeNodes( null, tree, 0, 0 );
+ }
//------------------------------------------------------------------------
- private void processNodes( MetadataGraphVertex parentVertice
+ private void processTreeNodes( MetadataGraphVertex parentVertex
, MetadataTreeNode node
, int depth
, int pomOrder
@@ -86,40 +122,21 @@
return;
}
- String nodeHash = node.graphHash();
- MetadataGraphVertex vertice = vertices.get( nodeHash );
- if ( vertice == null )
- { // does not exist yet ?
- vertice = new MetadataGraphVertex( node.md );
- vertices.put( nodeHash, vertice );
- }
-
- if ( parentVertice != null )
- { // then create edges
- String edgeId = edgeHash( parentVertice, vertice );
- List<MetadataGraphEdge> edgeList = edges.get( edgeId );
- if ( edgeList == null )
- {
- edgeList = new ArrayList<MetadataGraphEdge>( 4 );
- edges.put( edgeId, edgeList );
- }
+ MetadataGraphVertex vertex = new MetadataGraphVertex( node.md, versionedVertices, scopedVertices );
+ if( ! vertices.contains(vertex) )
+ {
+ vertices.add(vertex);
+ }
+ if( parentVertex != null ) // then create the edge
+ {
ArtifactMetadata md = node.getMd();
MetadataGraphEdge e = new MetadataGraphEdge( md.version, md.resolved, md.artifactScope, md.artifactUri, depth, pomOrder );
- if ( !edgeList.contains( e ) )
- {
- e.setSource( parentVertice.getMd() );
- e.setTarget( md );
- edgeList.add( e );
- }
- else
- {
- e = null;
- }
+ addEdge( parentVertex, vertex, e);
}
else
{
- entry = vertice;
+ entry = vertex;
}
MetadataTreeNode[] kids = node.getChildren();
@@ -131,52 +148,183 @@
for( int i = 0; i< kids.length; i++ )
{
MetadataTreeNode n = kids[i];
- processNodes( vertice, n, depth + 1, i );
+ processTreeNodes( vertex, n, depth + 1, i );
}
}
-
//------------------------------------------------------------------------
- public static String edgeHash( MetadataGraphVertex v1,
- MetadataGraphVertex v2 )
+ public MetadataGraphVertex findVertex( ArtifactMetadata md )
{
- return v1.md.toDomainString() + DEFAULT_DOMAIN_SEPARATOR + v2.md.toDomainString();
-// return h1.compareTo(h2) > 0
-// ? h1.hashCode()+""+h2.hashCode()
-// : h2.hashCode()+""+h1.hashCode()
-// ;
+ if( md == null || vertices == null || vertices.size() < 1 )
+ return null;
+
+ MetadataGraphVertex v = new MetadataGraphVertex(md);
+ v.setCompareVersion(versionedVertices);
+ v.setCompareScope(scopedVertices);
+
+ for( MetadataGraphVertex gv : vertices )
+ {
+ if( gv.equals(v) )
+ return gv;
+ }
+
+ return null;
}
-
//------------------------------------------------------------------------
- public MetadataGraph addVertice( MetadataGraphVertex v )
+ public MetadataGraphVertex addVertex( ArtifactMetadata md )
{
- if( v == null || v.getMd() == null )
- return this;
+ if( md == null )
+ return null;
+ checkVertices();
+
+ MetadataGraphVertex v = findVertex(md);
+ if( v != null)
+ return v;
+
+ v = new MetadataGraphVertex(md);
+
+ v.setCompareVersion(versionedVertices);
+ v.setCompareScope(scopedVertices);
+
+ vertices.add( v );
+ return v;
+ }
+ //------------------------------------------------------------------------
+ /**
+ * init graph
+ */
+ private void init( int nVertices, int nEdges )
+ {
+ int nV = nVertices;
+ if( nVertices < 1 )
+ nV = 1;
+
+ checkVertices(nV);
+
+ int nE = nVertices;
+ if( nEdges <= nV )
+ nE = 2*nE;
+
+ checkEdges(nE);
+ }
+
+ private void checkVertices()
+ {
+ checkVertices(DEFAULT_VERTICES);
+ }
+
+ private void checkVertices( int nVertices )
+ {
if( vertices == null )
- vertices = new HashMap<String, MetadataGraphVertex>();
- vertices.put(v.getMd().toDomainString(), v );
+ vertices = new TreeSet<MetadataGraphVertex>();
+ }
+ private void checkEdges()
+ {
+ int count = DEFAULT_EDGES;
- return this;
+ if( vertices != null )
+ count = vertices.size() + vertices.size() / 2;
+
+ checkEdges( count );
+ }
+ private void checkEdges( int nEdges )
+ {
+ if( incidentEdges == null )
+ incidentEdges = new HashMap<MetadataGraphVertex, List<MetadataGraphEdge>>( nEdges );
+ if( excidentEdges == null )
+ excidentEdges = new HashMap<MetadataGraphVertex, List<MetadataGraphEdge>>( nEdges );
+ }
+ //------------------------------------------------------------------------
+ private static void checkVertex( MetadataGraphVertex v )
+ throws MetadataResolutionException
+ {
+ if( v == null )
+ throw new MetadataResolutionException( "null vertex" );
+ if( v.getMd() == null )
+ throw new MetadataResolutionException( "vertex without metadata" );
}
//------------------------------------------------------------------------
- public MetadataGraph addEdge( String key, MetadataGraphEdge e )
+ private static void checkEdge( MetadataGraphEdge e )
+ throws MetadataResolutionException
{
if( e == null )
- return this;
-
- if( edges == null )
- edges = new HashMap<String, List<MetadataGraphEdge>>();
+ throw new MetadataResolutionException( "badly formed edge" );
+ }
+ //------------------------------------------------------------------------
+ public List<MetadataGraphEdge> getEdgesBetween(
+ MetadataGraphVertex vFrom
+ , MetadataGraphVertex vTo
+ )
+ {
+ List<MetadataGraphEdge> edges = getIncidentEdges(vTo);
+ if( edges == null || edges.isEmpty() )
+ return null;
+
+ List<MetadataGraphEdge> res = new ArrayList<MetadataGraphEdge>( edges.size() );
+
+ for( MetadataGraphEdge e : edges )
+ {
+ if( e.getSource().equals(vFrom) )
+ res.add(e);
+ }
+
+ return res;
+ }
+ //------------------------------------------------------------------------
+ public MetadataGraph addEdge( MetadataGraphVertex vFrom
+ , MetadataGraphVertex vTo
+ , MetadataGraphEdge e
+ )
+ throws MetadataResolutionException
+ {
+ checkVertex(vFrom);
+ checkVertex(vTo);
+
+ checkVertices();
- List<MetadataGraphEdge> eList = edges.get(key);
- if( eList == null ) {
- eList = new ArrayList<MetadataGraphEdge>();
- edges.put( key, eList );
+ checkEdge(e);
+ checkEdges();
+
+ e.setSource(vFrom);
+ e.setTarget(vTo);
+
+ vFrom.setCompareVersion(versionedVertices);
+ vFrom.setCompareScope(scopedVertices);
+
+ List<MetadataGraphEdge> exList = excidentEdges.get(vFrom);
+ if( exList == null ) {
+ exList = new ArrayList<MetadataGraphEdge>();
+ excidentEdges.put( vFrom, exList );
}
- if( ! eList.contains(e) )
- eList.add(e);
+ if( !exList.contains(e) )
+ exList.add(e);
+ List<MetadataGraphEdge> inList = incidentEdges.get(vTo);
+ if( inList == null ) {
+ inList = new ArrayList<MetadataGraphEdge>();
+ incidentEdges.put( vTo, inList );
+ }
+
+ if( !inList.contains(e) )
+ inList.add(e);
+
+ return this;
+ }
+ //------------------------------------------------------------------------
+ public MetadataGraph removeVertex( MetadataGraphVertex v )
+ {
+ if( vertices!= null && v != null )
+ vertices.remove(v);
+
+ if( incidentEdges!= null )
+ incidentEdges.remove(v);
+
+ if( excidentEdges!= null )
+ excidentEdges.remove(v);
+
return this;
+
}
//------------------------------------------------------------------------
private static int countNodes( MetadataTreeNode tree )
@@ -211,25 +359,43 @@
this.entry = entry;
}
- public Map<String, MetadataGraphVertex> getVertices()
+ public TreeSet<MetadataGraphVertex> getVertices()
{
return vertices;
}
+
+ public List<MetadataGraphEdge> getIncidentEdges( MetadataGraphVertex vertex )
+ {
+ checkEdges();
+ return incidentEdges.get(vertex);
+ }
+
+ public List<MetadataGraphEdge> getExcidentEdges( MetadataGraphVertex vertex )
+ {
+ checkEdges();
+ return excidentEdges.get(vertex);
+ }
+
+ public boolean isVersionedVertices()
+ {
+ return versionedVertices;
+ }
+ public void setVersionedVertices(boolean versionedVertices)
+ {
+ this.versionedVertices = versionedVertices;
+ }
+ public boolean isScopedVertices()
+ {
+ return scopedVertices;
+ }
+ public void setScopedVertices(boolean scopedVertices)
+ {
+ this.scopedVertices = scopedVertices;
- public void setVertices( Map<String, MetadataGraphVertex> vertices )
- {
- this.vertices = vertices;
- }
-
- public Map<String, List<MetadataGraphEdge>> getEdges()
- {
- return edges;
- }
-
- public void setEdges( Map<String, List<MetadataGraphEdge>> edges )
- {
- this.edges = edges;
- }
+ // scoped graph is versioned by definition
+ if( scopedVertices )
+ versionedVertices = true;
+ }
public ArtifactScopeEnum getScope()
{
return scope;
@@ -252,10 +418,44 @@
{
return
isEmpty()
- || edges == null
- || edges.isEmpty()
+ || incidentEdges == null
+ || incidentEdges.isEmpty()
;
}
+ //------------------------------------------------------------------------
+ @Override
+ public String toString()
+ {
+ StringBuilder sb = new StringBuilder(512);
+ if( isEmpty() )
+ return "empty";
+ for( MetadataGraphVertex v : vertices )
+ {
+ sb.append("Vertex: "+v.getMd().toString()+ "\n");
+ List<MetadataGraphEdge> ins = getIncidentEdges(v);
+ if( ins != null )
+ for( MetadataGraphEdge e : ins )
+ {
+ sb.append(" from : "+e.toString()+"\n");
+ }
+ else
+ sb.append(" no entries\n");
+
+ List<MetadataGraphEdge> outs = getExcidentEdges(v);
+ if( outs != null )
+ for( MetadataGraphEdge e : outs )
+ {
+ sb.append(" to : "+e.toString()+ "\n");
+ }
+ else
+ sb.append(" no exit\n");
+
+ sb.append("-------------------------------------------------\n");
+ }
+ sb.append("=============================================================\n");
+ return sb.toString();
+ }
+
//------------------------------------------------------------------------
//------------------------------------------------------------------------
}
Modified: maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataGraphEdge.java
URL: http://svn.apache.org/viewvc/maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataGraphEdge.java?rev=613470&r1=613469&r2=613470&view=diff
==============================================================================
--- maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataGraphEdge.java (original)
+++ maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataGraphEdge.java Sat Jan 19 14:14:15 2008
@@ -26,8 +26,8 @@
*
* In the first implementation only source used for explanatory function
*/
- ArtifactMetadata source;
- ArtifactMetadata target;
+ MetadataGraphVertex source;
+ MetadataGraphVertex target;
//----------------------------------------------------------------------------
public MetadataGraphEdge( String version
@@ -76,6 +76,7 @@
if ( o instanceof MetadataGraphEdge )
{
MetadataGraphEdge e = (MetadataGraphEdge) o;
+
return
objectsEqual( version, e.version )
&& ArtifactScopeEnum.checkScope(scope).getScope().equals(
@@ -147,26 +148,32 @@
this.artifactUri = artifactUri;
}
- public ArtifactMetadata getSource()
+ public MetadataGraphVertex getSource()
{
return source;
}
- public void setSource(ArtifactMetadata source)
+ public void setSource(MetadataGraphVertex source)
{
this.source = source;
}
- public ArtifactMetadata getTarget()
+ public MetadataGraphVertex getTarget()
{
return target;
}
- public void setTarget(ArtifactMetadata target)
+ public void setTarget(MetadataGraphVertex target)
{
this.target = target;
}
@Override
public String toString()
{
- return "[version="+version+", scope="+(scope == null ? "null" : scope.getScope())+", depth="+depth+"]";
+ return "[ "
+ + "FROM:("+( source==null?"no source":(source.md==null?"no source MD":source.md.toString()) )+") "
+ + "TO:("+( target==null?"no target":(target.md==null?"no target MD":target.md.toString()) )+") "
+ +"version="+version
+ +", scope="+(scope == null ? "null" : scope.getScope())
+ +", depth="+depth+"]"
+ ;
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
Modified: maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataGraphVertex.java
URL: http://svn.apache.org/viewvc/maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataGraphVertex.java?rev=613470&r1=613469&r2=613470&view=diff
==============================================================================
--- maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataGraphVertex.java (original)
+++ maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataGraphVertex.java Sat Jan 19 14:14:15 2008
@@ -1,5 +1,9 @@
package org.apache.maven.artifact.resolver.metadata;
+import org.apache.maven.artifact.ArtifactScopeEnum;
+
+import sun.misc.BASE64Encoder;
+
/**
* metadata graph vertice - just a wrapper around artifact's metadata
@@ -9,14 +13,26 @@
*/
public class MetadataGraphVertex
+implements Comparable<MetadataGraphVertex>
{
ArtifactMetadata md;
- public MetadataGraphVertex( ArtifactMetadata md )
+ // indications to use these in comparrison
+ private boolean compareVersion = false;
+ private boolean compareScope = false;
+
+ public MetadataGraphVertex( ArtifactMetadata md )
{
super();
this.md = md;
}
+
+ public MetadataGraphVertex( ArtifactMetadata md, boolean compareVersion, boolean compareScope )
+ {
+ this(md);
+ this.compareVersion = compareVersion;
+ this.compareScope = compareScope;
+ }
public ArtifactMetadata getMd()
{
@@ -27,10 +43,125 @@
{
this.md = md;
}
+ //---------------------------------------------------------------------
+ public boolean isCompareVersion()
+ {
+ return compareVersion;
+ }
+
+ public void setCompareVersion(boolean compareVersion)
+ {
+ this.compareVersion = compareVersion;
+ }
+
+ public boolean isCompareScope()
+ {
+ return compareScope;
+ }
+
+ public void setCompareScope(boolean compareScope)
+ {
+ this.compareScope = compareScope;
+ }
+ //---------------------------------------------------------------------
@Override
public String toString()
{
return "["+ (md == null ? "no metadata" : md.toString()) + "]";
}
+ //---------------------------------------------------------------------
+ private static int compareStrings( String s1, String s2 )
+ {
+ if( s1 == null && s2 == null )
+ return 0;
+
+ if( s1 == null && s2 != null )
+ return -1;
+
+ if( s1 != null && s2 == null )
+ return 1;
+
+ return s1.compareTo(s2);
+ }
+ //---------------------------------------------------------------------
+ public int compareTo(MetadataGraphVertex vertex)
+ {
+ if( vertex == null || vertex.getMd() == null )
+ return 1;
+
+ ArtifactMetadata vmd = vertex.getMd();
+
+ if( vmd == null )
+ {
+ if( md == null )
+ return 0;
+ else
+ return 1;
+ }
+
+ int g = compareStrings( md.groupId, vmd.groupId );
+
+ if( g == 0 )
+ {
+ int a = compareStrings( md.artifactId, vmd.artifactId );
+ if( a == 0 )
+ {
+ if( compareVersion )
+ {
+ int v = compareStrings( md.version, vmd.version );
+ if( v == 0) {
+ if( compareScope ) {
+ String s1 = ArtifactScopeEnum.checkScope( md.artifactScope).getScope();
+ String s2 = ArtifactScopeEnum.checkScope(vmd.artifactScope).getScope();
+ return s1.compareTo(s2);
+ }
+ else
+ return 0;
+ }
+ else
+ return v;
+ }
+ else
+ return 0;
+ }
+ else
+ return a;
+ }
+
+ return g;
+ }
+ //---------------------------------------------------------------------
+ @Override
+ public boolean equals(Object vo)
+ {
+ if( vo == null || !(vo instanceof MetadataGraphVertex) )
+ return false;
+ return compareTo( (MetadataGraphVertex)vo ) == 0;
+ }
+ //---------------------------------------------------------------------
+
+ @Override
+ public int hashCode()
+ {
+ if( md == null )
+ return super.hashCode();
+ StringBuilder hashString = new StringBuilder(128);
+ hashString.append( md.groupId+"|" );
+ hashString.append( md.artifactId+"|" );
+
+ if( compareVersion )
+ hashString.append(md.version + "|");
+
+ if( compareScope )
+ hashString.append(md.getArtifactScope() + "|");
+
+ return hashString.toString().hashCode();
+
+// BASE64Encoder b64 = new BASE64Encoder();
+// return b64.encode( hashString.toString().getBytes() ).hashCode();
+ }
+
+ //---------------------------------------------------------------------
+ //---------------------------------------------------------------------
}
Modified: maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataResolutionRequest.java
URL: http://svn.apache.org/viewvc/maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataResolutionRequest.java?rev=613470&r1=613469&r2=613470&view=diff
==============================================================================
--- maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataResolutionRequest.java (original)
+++ maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataResolutionRequest.java Sat Jan 19 14:14:15 2008
@@ -9,8 +9,6 @@
public class MetadataResolutionRequest
{
protected ArtifactMetadata query;
- protected MetadataResolutionRequestTypeEnum type;
-
protected ArtifactRepository localRepository;
protected List<ArtifactRepository> remoteRepositories;
@@ -20,12 +18,10 @@
}
//--------------------------------------------------------------------
- public MetadataResolutionRequest( MetadataResolutionRequestTypeEnum type,
- ArtifactMetadata query,
+ public MetadataResolutionRequest( ArtifactMetadata query,
ArtifactRepository localRepository,
List<ArtifactRepository> remoteRepositories )
{
- this.type = type;
this.query = query;
this.localRepository = localRepository;
this.remoteRepositories = remoteRepositories;
Modified: maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataResolutionRequestTypeEnum.java
URL: http://svn.apache.org/viewvc/maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataResolutionRequestTypeEnum.java?rev=613470&r1=613469&r2=613470&view=diff
==============================================================================
--- maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataResolutionRequestTypeEnum.java (original)
+++ maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataResolutionRequestTypeEnum.java Sat Jan 19 14:14:15 2008
@@ -2,7 +2,14 @@
public enum MetadataResolutionRequestTypeEnum
{
- tree( 1 ), graph( 2 ), classpathCompile( 3 ), classpathTest( 4 ), classpathRuntime( 5 );
+ tree( 1 )
+ , graph( 2 )
+ , classpathCompile( 3 )
+ , classpathTest( 4 )
+ , classpathRuntime( 5 )
+ , versionedGraph( 6 )
+ , scopedGraph( 7 )
+ ;
private int id;
Modified: maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataResolutionResult.java
URL: http://svn.apache.org/viewvc/maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataResolutionResult.java?rev=613470&r1=613469&r2=613470&view=diff
==============================================================================
--- maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataResolutionResult.java (original)
+++ maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataResolutionResult.java Sat Jan 19 14:14:15 2008
@@ -6,6 +6,8 @@
import org.apache.maven.artifact.transform.ClasspathContainer;
import org.apache.maven.artifact.transform.ClasspathTransformation;
import org.apache.maven.artifact.transform.MetadataGraphTransformationException;
+import org.codehaus.plexus.PlexusContainer;
+import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
/**
* This object is tinted with ClasspathTransformation and GraphConflictResolver.
@@ -16,11 +18,16 @@
public class MetadataResolutionResult
{
MetadataTreeNode treeRoot;
+
+ /**
+ * these components are are initialized on demand by
+ * explicit call of the initTreeProcessing()
+ */
ClasspathTransformation classpathTransformation;
GraphConflictResolver conflictResolver;
//----------------------------------------------------------------------------
- public MetadataResolutionResult()
+ public MetadataResolutionResult( )
{
}
//----------------------------------------------------------------------------
@@ -29,22 +36,22 @@
this.treeRoot = root;
}
//----------------------------------------------------------------------------
- public MetadataResolutionResult( GraphConflictResolver conflictResolver, ClasspathTransformation cpt )
- {
- this.classpathTransformation = cpt;
- this.conflictResolver = conflictResolver;
- }
- //----------------------------------------------------------------------------
public MetadataTreeNode getTree()
{
return treeRoot;
}
-
+ //----------------------------------------------------------------------------
public void setTree( MetadataTreeNode root )
{
this.treeRoot = root;
}
-
+
+ public void initTreeProcessing( PlexusContainer plexus )
+ throws ComponentLookupException
+ {
+ classpathTransformation = (ClasspathTransformation)plexus.lookup(ClasspathTransformation.class);
+ conflictResolver = (GraphConflictResolver)plexus.lookup(GraphConflictResolver.class);
+ }
//----------------------------------------------------------------------------
public MetadataGraph getGraph()
throws MetadataResolutionException
@@ -64,6 +71,37 @@
return conflictResolver.resolveConflicts( getGraph(), scope );
}
//----------------------------------------------------------------------------
+ public MetadataGraph getGraph( MetadataResolutionRequestTypeEnum requestType )
+ throws MetadataResolutionException, GraphConflictResolutionException
+ {
+ if( requestType == null )
+ return null;
+
+ if( treeRoot == null )
+ return null;
+
+ if( conflictResolver == null )
+ return null;
+
+ if( requestType.equals(MetadataResolutionRequestTypeEnum.classpathCompile) )
+ return conflictResolver.resolveConflicts( getGraph(), ArtifactScopeEnum.compile );
+ else if( requestType.equals(MetadataResolutionRequestTypeEnum.classpathRuntime) )
+ return conflictResolver.resolveConflicts( getGraph(), ArtifactScopeEnum.runtime );
+ else if( requestType.equals(MetadataResolutionRequestTypeEnum.classpathRuntime) )
+ return conflictResolver.resolveConflicts( getGraph(), ArtifactScopeEnum.test );
+ else if( requestType.equals(MetadataResolutionRequestTypeEnum.classpathRuntime) )
+ return conflictResolver.resolveConflicts( getGraph(), ArtifactScopeEnum.test );
+ else if( requestType.equals(MetadataResolutionRequestTypeEnum.graph) )
+ return getGraph();
+ else if( requestType.equals(MetadataResolutionRequestTypeEnum.versionedGraph) ) {
+ return new MetadataGraph( getTree(), true, false );
+ }
+ else if( requestType.equals(MetadataResolutionRequestTypeEnum.scopedGraph) ) {
+ return new MetadataGraph( getTree(), true, true );
+ }
+ return null;
+ }
+ //----------------------------------------------------------------------------
public ClasspathContainer getClasspath( ArtifactScopeEnum scope )
throws MetadataGraphTransformationException, MetadataResolutionException
{
@@ -78,7 +116,7 @@
return cpc;
}
-
+ //----------------------------------------------------------------------------
public MetadataTreeNode getClasspathTree( ArtifactScopeEnum scope )
throws MetadataGraphTransformationException, MetadataResolutionException
{
Modified: maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataResolver.java
URL: http://svn.apache.org/viewvc/maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataResolver.java?rev=613470&r1=613469&r2=613470&view=diff
==============================================================================
--- maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataResolver.java (original)
+++ maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataResolver.java Sat Jan 19 14:14:15 2008
@@ -1,5 +1,12 @@
package org.apache.maven.artifact.resolver.metadata;
+import java.util.Collection;
+import java.util.List;
+
+import org.apache.maven.artifact.Artifact;
+import org.apache.maven.artifact.repository.ArtifactRepository;
+import org.apache.maven.artifact.resolver.ArtifactResolutionException;
+
/**
* entry point into metadata resolution component
@@ -12,7 +19,7 @@
String ROLE = MetadataResolver.class.getName();
/**
- * collect all dependency metadata into one "dirty" graph
+ * collect all dependency metadata into one "dirty" tree
*
* @param request
* @return
@@ -20,4 +27,20 @@
*/
MetadataResolutionResult resolveMetadata( MetadataResolutionRequest request )
throws MetadataResolutionException;
+
+ /**
+ * resolve artifact List, given metadata List (order matters!)
+ *
+ * @param mdCollection - collection of artifact metadata's
+ * @param localRepository
+ * @param remoteRepositories
+ * @return collection of resolved artifacts
+ * @throws ArtifactResolutionException
+ */
+ public List<Artifact> resolveArtifact(
+ List<ArtifactMetadata> mdCollection
+ , ArtifactRepository localRepository
+ , List<ArtifactRepository> remoteRepositories
+ )
+ throws ArtifactResolutionException;
}
Modified: maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataTreeNode.java
URL: http://svn.apache.org/viewvc/maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataTreeNode.java?rev=613470&r1=613469&r2=613470&view=diff
==============================================================================
--- maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataTreeNode.java (original)
+++ maven/artifact/trunk/src/main/java/org/apache/maven/artifact/resolver/metadata/MetadataTreeNode.java Sat Jan 19 14:14:15 2008
@@ -1,14 +1,19 @@
package org.apache.maven.artifact.resolver.metadata;
-import java.util.List;
-
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.ArtifactScopeEnum;
+/**
+ * metadata [dirty] Tree
+ *
+ * @author <a href="oleg@codehaus.org">Oleg Gusakov</a>
+ *
+ */
public class MetadataTreeNode
{
ArtifactMetadata md; // this node
- MetadataTreeNode parent; // papa of cause
+
+ MetadataTreeNode parent; // papa
/** default # of children. Used for tree creation optimization only */
int nChildren = 8;
@@ -37,7 +42,7 @@
{
if ( md != null )
{
- md.setArtifactScope( scope );
+ md.setArtifactScope( ArtifactScopeEnum.checkScope(scope) );
md.setResolved(resolved);
}
@@ -48,7 +53,8 @@
public MetadataTreeNode( Artifact af,
MetadataTreeNode parent,
boolean resolved,
- ArtifactScopeEnum scope )
+ ArtifactScopeEnum scope
+ )
{
this( new ArtifactMetadata( af ), parent, resolved, scope );
}
@@ -65,7 +71,6 @@
children[index % nChildren] = kid;
}
-
//------------------------------------------------------------------
@Override
public String toString()
@@ -91,7 +96,6 @@
{
return children != null;
}
-
//------------------------------------------------------------------------
public ArtifactMetadata getMd()
{
@@ -122,7 +126,6 @@
{
this.children = children;
}
-
//------------------------------------------------------------------------
//------------------------------------------------------------------------
Modified: maven/artifact/trunk/src/main/java/org/apache/maven/artifact/transform/DefaultClasspathTransformation.java
URL: http://svn.apache.org/viewvc/maven/artifact/trunk/src/main/java/org/apache/maven/artifact/transform/DefaultClasspathTransformation.java?rev=613470&r1=613469&r2=613470&view=diff
==============================================================================
--- maven/artifact/trunk/src/main/java/org/apache/maven/artifact/transform/DefaultClasspathTransformation.java (original)
+++ maven/artifact/trunk/src/main/java/org/apache/maven/artifact/transform/DefaultClasspathTransformation.java Sat Jan 19 14:14:15 2008
@@ -1,6 +1,7 @@
package org.apache.maven.artifact.transform;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
@@ -40,7 +41,7 @@
|| dirtyGraph.isEmpty()
)
return null;
-
+
MetadataGraph cleanGraph = conflictResolver.resolveConflicts( dirtyGraph, scope );
if( cleanGraph == null
@@ -49,7 +50,7 @@
return null;
ClasspathContainer cpc = new ClasspathContainer( scope );
- if( cleanGraph.getEdges() == null || cleanGraph.getEdges().isEmpty() ) {
+ if( cleanGraph.isEmptyEdges() ) {
// single entry in the classpath, populated from itself
ArtifactMetadata amd = cleanGraph.getEntry().getMd();
cpc.add( amd );
@@ -67,90 +68,85 @@
}
}
//===================================================================================================
- /**
- * helper class to store visitation data
- */
- private class MetadataGraphEdgeWithNodes
- {
- MetadataGraphEdge edge;
- String source;
- String target;
-
- public MetadataGraphEdgeWithNodes(MetadataGraphEdge edge, String source, String target)
- {
- super();
- this.edge = edge;
- this.target = target;
- }
- }
- //===================================================================================================
/**
* Helper class to traverse graph. Required to make the containing method thread-safe
* and yet use class level data to lessen stack usage in recursion
*/
private class ClasspathGraphVisitor
{
- Map<String, List<MetadataGraphEdge>> edges;
- Map< String, MetadataGraphVertex> vertices;
+ MetadataGraph graph;
ClasspathContainer cpc;
- List<String> visited;
+ List<MetadataGraphVertex> visited;
//-----------------------------------------------------------------------
protected ClasspathGraphVisitor( MetadataGraph cleanGraph, ClasspathContainer cpc )
{
this.cpc = cpc;
-
- edges = cleanGraph.getEdges();
- vertices = cleanGraph.getVertices();
- visited = new ArrayList<String>( cleanGraph.getVertices().size() );
+ this.graph = cleanGraph;
+
+ visited = new ArrayList<MetadataGraphVertex>( cleanGraph.getVertices().size() );
}
//-----------------------------------------------------------------------
protected void visit( MetadataGraphVertex node ) //, String version, String artifactUri )
{
ArtifactMetadata md = node.getMd();
- String nodeKey = md.toDomainString();
- if( visited.contains(nodeKey) )
+ if( visited.contains(node) )
return;
cpc.add( md );
+//
+// TreeSet<MetadataGraphEdge> deps = new TreeSet<MetadataGraphEdge>(
+// new Comparator<MetadataGraphEdge>()
+// {
+// public int compare( MetadataGraphEdge e1
+// , MetadataGraphEdge e2
+// )
+// {
+// if( e1.getDepth() == e2.getDepth() )
+// {
+// if( e2.getPomOrder() == e1.getPomOrder() )
+// return e1.getTarget().toString().compareTo(e2.getTarget().toString() );
+//
+// return e2.getPomOrder() - e1.getPomOrder();
+// }
+//
+// return e2.getDepth() - e1.getDepth();
+// }
+// }
+// );
+
+ List<MetadataGraphEdge> exits = graph.getExcidentEdges(node);
- TreeSet<MetadataGraphEdgeWithNodes> deps = new TreeSet<MetadataGraphEdgeWithNodes>(
- new Comparator<MetadataGraphEdgeWithNodes>()
+ if( exits != null && exits.size() > 0)
+ {
+ MetadataGraphEdge[] sortedExits = exits.toArray( new MetadataGraphEdge[exits.size()] );
+ Arrays.sort( sortedExits
+ ,
+ new Comparator<MetadataGraphEdge>()
{
- public int compare( MetadataGraphEdgeWithNodes e1
- , MetadataGraphEdgeWithNodes e2
+ public int compare( MetadataGraphEdge e1
+ , MetadataGraphEdge e2
)
{
- if( e1.edge.getDepth() == e2.edge.getDepth() )
- return e2.edge.getPomOrder() - e1.edge.getPomOrder();
+ if( e1.getDepth() == e2.getDepth() )
+ {
+ if( e2.getPomOrder() == e1.getPomOrder() )
+ return e1.getTarget().toString().compareTo(e2.getTarget().toString() );
+ return e2.getPomOrder() - e1.getPomOrder();
+ }
- return e2.edge.getDepth() - e1.edge.getDepth();
+ return e2.getDepth() - e1.getDepth();
}
}
- );
-
- for( Map.Entry<String, List<MetadataGraphEdge>> el : edges.entrySet() ) {
- if( el.getKey().startsWith(nodeKey) ) {
- String edgeKey = el.getKey();
- int ind = edgeKey.indexOf(MetadataGraph.DEFAULT_DOMAIN_SEPARATOR);
- String source = edgeKey.substring( 0, ind );
- String target = edgeKey.substring( ind+1 );
- for( MetadataGraphEdge e : el.getValue() )
- deps.add( new MetadataGraphEdgeWithNodes(e,source,target) );
+ );
+
+ for( MetadataGraphEdge e : sortedExits ) {
+ MetadataGraphVertex targetNode = e.getTarget();
+ targetNode.getMd().setArtifactScope( e.getScope() );
+ targetNode.getMd().setWhy( e.getSource().getMd().toString() );
+ visit( targetNode );
}
- }
+ }
- if( deps.size() > 0 )
- for( MetadataGraphEdgeWithNodes e : deps ) {
- MetadataGraphVertex targetNode = vertices.get(e.target);
-
- // explain where this link is from
- ArtifactMetadata tmd = targetNode.getMd();
- ArtifactMetadata smd = e.edge.getSource();
-// if( tmd != null && smd != null )
-// tmd.setWhy( "originated from "+smd.toString() );
-
- visit( targetNode );//, e.edge.getVersion(), e.edge.getArtifactUri() );
- }
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
Modified: maven/artifact/trunk/src/test/java/org/apache/maven/artifact/resolver/conflict/DefaultGraphConflictResolverTest.java
URL: http://svn.apache.org/viewvc/maven/artifact/trunk/src/test/java/org/apache/maven/artifact/resolver/conflict/DefaultGraphConflictResolverTest.java?rev=613470&r1=613469&r2=613470&view=diff
==============================================================================
--- maven/artifact/trunk/src/test/java/org/apache/maven/artifact/resolver/conflict/DefaultGraphConflictResolverTest.java (original)
+++ maven/artifact/trunk/src/test/java/org/apache/maven/artifact/resolver/conflict/DefaultGraphConflictResolverTest.java Sat Jan 19 14:14:15 2008
@@ -10,6 +10,7 @@
import org.apache.maven.artifact.resolver.metadata.MetadataGraphEdge;
import org.apache.maven.artifact.resolver.metadata.MetadataGraphVertex;
import org.codehaus.plexus.PlexusTestCase;
+import org.codehaus.plexus.logging.Logger;
/**
*
@@ -21,14 +22,12 @@
public class DefaultGraphConflictResolverTest
extends PlexusTestCase
{
+ Logger log;
+
GraphConflictResolver resolver;
MetadataGraph graph;
- MetadataGraphEdge e1;
- MetadataGraphEdge e2;
- MetadataGraphEdge e3;
-
MetadataGraphVertex v1;
MetadataGraphVertex v2;
MetadataGraphVertex v3;
@@ -39,54 +38,35 @@
{
super.setUp();
resolver = (GraphConflictResolver) lookup( GraphConflictResolver.ROLE, "default" );
+
+ // logging
+ getContainer().getLoggerManager().setThresholds( Logger.LEVEL_DEBUG );
+ log = getContainer().getLoggerManager().getLoggerForComponent( this.getClass().getName() );
- e1 = new MetadataGraphEdge( "1.1", true, null, null, 2, 1 );
- e2 = new MetadataGraphEdge( "1.2", true, null, null, 3, 2 );
- e3 = new MetadataGraphEdge( "1.2", true, null, null, 2, 3 );
-
- v1 = new MetadataGraphVertex(new ArtifactMetadata("g","a1","1.0"));
- v2 = new MetadataGraphVertex(new ArtifactMetadata("g","a2","1.0"));
- v3 = new MetadataGraphVertex(new ArtifactMetadata("g","a3","1.0"));
- v4 = new MetadataGraphVertex(new ArtifactMetadata("g","a4","1.0"));
-
- graph = new MetadataGraph( 4, 3 );
- graph.setEntry(v1);
- Map< String, MetadataGraphVertex> v = graph.getVertices();
- Map<String,List<MetadataGraphEdge>> e = graph.getEdges();
-
- v.put(v1.getMd().toDomainString(), v1);
- v.put(v2.getMd().toDomainString(), v2);
- v.put(v3.getMd().toDomainString(), v3);
- v.put(v4.getMd().toDomainString(), v4);
/*
* v2
* v1<
* v3-v4
*
*/
- String key;
- List<MetadataGraphEdge> le;
-
+ graph = new MetadataGraph( 4, 3 );
+ v1 = graph.addVertex(new ArtifactMetadata("g","a1","1.0"));
+ graph.setEntry(v1);
+ v2 = graph.addVertex(new ArtifactMetadata("g","a2","1.0"));
+ v3 = graph.addVertex(new ArtifactMetadata("g","a3","1.0"));
+ v4 = graph.addVertex(new ArtifactMetadata("g","a4","1.0"));
+
// v1-->v2
- key = MetadataGraph.edgeHash(v1, v2);
- le = new ArrayList<MetadataGraphEdge>(2);
- le.add( new MetadataGraphEdge( "1.1", true, null, null, 2, 1 ) );
- le.add( new MetadataGraphEdge( "1.2", true, null, null, 2, 2 ) );
- e.put( key, le );
+ graph.addEdge(v1, v2, new MetadataGraphEdge( "1.1", true, null, null, 2, 1 ) );
+ graph.addEdge(v1, v2, new MetadataGraphEdge( "1.2", true, null, null, 2, 2 ) );
// v1-->v3
- key = MetadataGraph.edgeHash(v1, v3);
- le = new ArrayList<MetadataGraphEdge>(2);
- le.add( new MetadataGraphEdge( "1.1", true, null, null, 2, 1 ) );
- le.add( new MetadataGraphEdge( "1.2", true, null, null, 4, 2 ) );
- e.put( key, le );
+ graph.addEdge(v1, v3, new MetadataGraphEdge( "1.1", true, null, null, 2, 1 ) );
+ graph.addEdge(v1, v3, new MetadataGraphEdge( "1.2", true, null, null, 4, 2 ) );
// v3-->v4
- key = MetadataGraph.edgeHash(v3, v4);
- le = new ArrayList<MetadataGraphEdge>(2);
- le.add( new MetadataGraphEdge( "1.1", true, ArtifactScopeEnum.runtime, null, 2, 1 ) );
- le.add( new MetadataGraphEdge( "1.2", true, ArtifactScopeEnum.provided, null, 2, 2 ) );
- e.put( key, le );
+ graph.addEdge(v3, v4, new MetadataGraphEdge( "1.1", true, ArtifactScopeEnum.runtime, null, 2, 1 ) );
+ graph.addEdge(v3, v4, new MetadataGraphEdge( "1.2", true, ArtifactScopeEnum.provided, null, 2, 2 ) );
}
//------------------------------------------------------------------------------------------
public void testCompileResolution()
@@ -98,22 +78,20 @@
assertNotNull("null graph after resolver", res );
assertNotNull("no vertices in the resulting graph after resolver", res.getVertices() );
- assertNotNull("no edges in the resulting graph after resolver", res.getEdges() );
+
+ assertNotNull("no edges in the resulting graph after resolver", res.getExcidentEdges(v1) );
assertEquals( "wrong # of vertices in the resulting graph after resolver", 4, res.getVertices().size() );
- assertEquals( "wrong # of edges in the resulting graph after resolver", 3, res.getEdges().size() );
+ assertEquals( "wrong # of excident edges in the resulting graph entry after resolver", 2, res.getExcidentEdges(v1).size() );
- String key = MetadataGraph.edgeHash( v1, v2 );
- assertEquals( "wrong # of edges v1-v2 in the resulting graph after resolver", 1, res.getEdges().get(key).size() );
- assertEquals( "wrong edge v1-v2 in the resulting graph after resolver", "1.2", res.getEdges().get(key).get(0).getVersion() );
-
- key = MetadataGraph.edgeHash( v1, v3 );
- assertEquals( "wrong # of edges v1-v3 in the resulting graph after resolver", 1, res.getEdges().get(key).size() );
- assertEquals( "wrong edge v1-v3 in the resulting graph after resolver", "1.1", res.getEdges().get(key).get(0).getVersion() );
-
- key = MetadataGraph.edgeHash( v3, v4 );
- assertEquals( "wrong # of edges v3-v4 in the resulting graph after resolver", 1, res.getEdges().get(key).size() );
- assertEquals( "wrong edge v3-v4 in the resulting graph after resolver", "1.2", res.getEdges().get(key).get(0).getVersion() );
+ assertEquals( "wrong # of v2 incident edges in the resulting graph after resolver", 1, res.getIncidentEdges(v2).size() );
+ assertEquals( "wrong edge v1-v2 in the resulting graph after resolver", "1.2", res.getIncidentEdges(v2).get(0).getVersion() );
+
+ assertEquals( "wrong # of edges v1-v3 in the resulting graph after resolver", 1, res.getIncidentEdges(v3).size() );
+ assertEquals( "wrong edge v1-v3 in the resulting graph after resolver", "1.1", res.getIncidentEdges(v3).get(0).getVersion() );
+
+ assertEquals( "wrong # of edges v3-v4 in the resulting graph after resolver", 1, res.getIncidentEdges(v4).size() );
+ assertEquals( "wrong edge v3-v4 in the resulting graph after resolver", "1.2", res.getIncidentEdges(v4).get(0).getVersion() );
}
//------------------------------------------------------------------------------------------
public void testRuntimeResolution()
@@ -125,22 +103,43 @@
assertNotNull("null graph after resolver", res );
assertNotNull("no vertices in the resulting graph after resolver", res.getVertices() );
- assertNotNull("no edges in the resulting graph after resolver", res.getEdges() );
+ assertNotNull("no edges in the resulting graph after resolver", res.getExcidentEdges(v1) );
+
+ assertEquals( "wrong # of vertices in the resulting graph after resolver", 4, res.getVertices().size() );
+ assertEquals( "wrong # of excident edges in the resulting graph entry after resolver", 2, res.getExcidentEdges(v1).size() );
+
+ assertEquals( "wrong # of v2 incident edges in the resulting graph after resolver", 1, res.getIncidentEdges(v2).size() );
+ assertEquals( "wrong edge v1-v2 in the resulting graph after resolver", "1.2", res.getIncidentEdges(v2).get(0).getVersion() );
+
+ assertEquals( "wrong # of edges v1-v3 in the resulting graph after resolver", 1, res.getIncidentEdges(v3).size() );
+ assertEquals( "wrong edge v1-v3 in the resulting graph after resolver", "1.1", res.getIncidentEdges(v3).get(0).getVersion() );
+
+ assertEquals( "wrong # of edges v3-v4 in the resulting graph after resolver", 1, res.getIncidentEdges(v4).size() );
+ assertEquals( "wrong edge v3-v4 in the resulting graph after resolver", "1.1", res.getIncidentEdges(v4).get(0).getVersion() );
+ }
+ //------------------------------------------------------------------------------------------
+ public void testTestResolution()
+ throws Exception
+ {
+ MetadataGraph res;
+
+ res = resolver.resolveConflicts( graph, ArtifactScopeEnum.test );
+
+ assertNotNull("null graph after resolver", res );
+ assertNotNull("no vertices in the resulting graph after resolver", res.getVertices() );
+ assertNotNull("no edges in the resulting graph after resolver", res.getExcidentEdges(v1) );
assertEquals( "wrong # of vertices in the resulting graph after resolver", 4, res.getVertices().size() );
- assertEquals( "wrong # of edges in the resulting graph after resolver", 3, res.getEdges().size() );
+ assertEquals( "wrong # of excident edges in the resulting graph entry after resolver", 2, res.getExcidentEdges(v1).size() );
+
+ assertEquals( "wrong # of v2 incident edges in the resulting graph after resolver", 1, res.getIncidentEdges(v2).size() );
+ assertEquals( "wrong edge v1-v2 in the resulting graph after resolver", "1.2", res.getIncidentEdges(v2).get(0).getVersion() );
+
+ assertEquals( "wrong # of edges v1-v3 in the resulting graph after resolver", 1, res.getIncidentEdges(v3).size() );
+ assertEquals( "wrong edge v1-v3 in the resulting graph after resolver", "1.1", res.getIncidentEdges(v3).get(0).getVersion() );
- String key = MetadataGraph.edgeHash( v1, v2 );
- assertEquals( "wrong # of edges v1-v2 in the resulting graph after resolver", 1, res.getEdges().get(key).size() );
- assertEquals( "wrong edge v1-v2 in the resulting graph after resolver", "1.2", res.getEdges().get(key).get(0).getVersion() );
-
- key = MetadataGraph.edgeHash( v1, v3 );
- assertEquals( "wrong # of edges v1-v3 in the resulting graph after resolver", 1, res.getEdges().get(key).size() );
- assertEquals( "wrong edge v1-v3 in the resulting graph after resolver", "1.1", res.getEdges().get(key).get(0).getVersion() );
-
- key = MetadataGraph.edgeHash( v3, v4 );
- assertEquals( "wrong # of edges v3-v4 in the resulting graph after resolver", 1, res.getEdges().get(key).size() );
- assertEquals( "wrong edge v3-v4 in the resulting graph after resolver", "1.1", res.getEdges().get(key).get(0).getVersion() );
+ assertEquals( "wrong # of edges v3-v4 in the resulting graph after resolver", 1, res.getIncidentEdges(v4).size() );
+ assertEquals( "wrong edge v3-v4 in the resulting graph after resolver", "1.2", res.getIncidentEdges(v4).get(0).getVersion() );
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
Modified: maven/artifact/trunk/src/test/java/org/apache/maven/artifact/transform/DefaultClasspathTransformationTest.java
URL: http://svn.apache.org/viewvc/maven/artifact/trunk/src/test/java/org/apache/maven/artifact/transform/DefaultClasspathTransformationTest.java?rev=613470&r1=613469&r2=613470&view=diff
==============================================================================
--- maven/artifact/trunk/src/test/java/org/apache/maven/artifact/transform/DefaultClasspathTransformationTest.java (original)
+++ maven/artifact/trunk/src/test/java/org/apache/maven/artifact/transform/DefaultClasspathTransformationTest.java Sat Jan 19 14:14:15 2008
@@ -27,10 +27,6 @@
MetadataGraph graph;
- MetadataGraphEdge e1;
- MetadataGraphEdge e2;
- MetadataGraphEdge e3;
-
MetadataGraphVertex v1;
MetadataGraphVertex v2;
MetadataGraphVertex v3;
@@ -42,53 +38,30 @@
super.setUp();
transform = (ClasspathTransformation) lookup( ClasspathTransformation.ROLE, "default" );
- e1 = new MetadataGraphEdge( "1.1", true, null, null, 2, 1 );
- e2 = new MetadataGraphEdge( "1.2", true, null, null, 3, 2 );
- e3 = new MetadataGraphEdge( "1.2", true, null, null, 2, 3 );
-
- v1 = new MetadataGraphVertex(new ArtifactMetadata("g","a1","1.0"));
- v2 = new MetadataGraphVertex(new ArtifactMetadata("g","a2","1.0"));
- v3 = new MetadataGraphVertex(new ArtifactMetadata("g","a3","1.0"));
- v4 = new MetadataGraphVertex(new ArtifactMetadata("g","a4","1.0"));
-
graph = new MetadataGraph( 4, 3 );
- graph.setEntry(v1);
- Map< String, MetadataGraphVertex> v = graph.getVertices();
- Map<String,List<MetadataGraphEdge>> e = graph.getEdges();
-
- v.put(v1.getMd().toDomainString(), v1);
- v.put(v2.getMd().toDomainString(), v2);
- v.put(v3.getMd().toDomainString(), v3);
- v.put(v4.getMd().toDomainString(), v4);
/*
* v2
* v1<
- * v3-v4
+ * v3-v4
*
*/
- String key;
- List<MetadataGraphEdge> le;
+ v1 = graph.addVertex(new ArtifactMetadata("g","a1","1.0"));
+ graph.setEntry(v1);
+ v2 = graph.addVertex(new ArtifactMetadata("g","a2","1.0"));
+ v3 = graph.addVertex(new ArtifactMetadata("g","a3","1.0"));
+ v4 = graph.addVertex(new ArtifactMetadata("g","a4","1.0"));
// v1-->v2
- key = MetadataGraph.edgeHash(v1, v2);
- le = new ArrayList<MetadataGraphEdge>(2);
- le.add( new MetadataGraphEdge( "1.1", true, null, null, 2, 1 ) );
- le.add( new MetadataGraphEdge( "1.2", true, null, null, 2, 2 ) );
- e.put( key, le );
+ graph.addEdge(v1, v2, new MetadataGraphEdge( "1.1", true, null, null, 2, 1 ) );
+ graph.addEdge(v1, v2, new MetadataGraphEdge( "1.2", true, null, null, 2, 2 ) );
// v1-->v3
- key = MetadataGraph.edgeHash(v1, v3);
- le = new ArrayList<MetadataGraphEdge>(2);
- le.add( new MetadataGraphEdge( "1.1", true, null, null, 2, 1 ) );
- le.add( new MetadataGraphEdge( "1.2", true, null, null, 4, 2 ) );
- e.put( key, le );
+ graph.addEdge(v1, v3, new MetadataGraphEdge( "1.1", true, null, null, 2, 1 ) );
+ graph.addEdge(v1, v3, new MetadataGraphEdge( "1.2", true, null, null, 4, 2 ) );
// v3-->v4
- key = MetadataGraph.edgeHash(v3, v4);
- le = new ArrayList<MetadataGraphEdge>(2);
-// le.add( new MetadataGraphEdge( "1.1", true, ArtifactScopeEnum.runtime, null, 2, 1 ) );
- le.add( new MetadataGraphEdge( "1.2", true, ArtifactScopeEnum.test, null, 2, 2 ) );
- e.put( key, le );
+ graph.addEdge(v3, v4, new MetadataGraphEdge( "1.1", true, ArtifactScopeEnum.runtime, null, 2, 2 ) );
+ graph.addEdge(v3, v4, new MetadataGraphEdge( "1.2", true, ArtifactScopeEnum.test, null, 2, 2 ) );
}
//------------------------------------------------------------------------------------------
public void testCompileClasspathTransform()
@@ -100,10 +73,10 @@
assertNotNull("null classpath container after compile transform", res );
assertNotNull("null classpath after compile transform", res.getClasspath() );
- assertEquals("compile classpath should have 4 entries", 4, res.getClasspath().size() );
+ assertEquals("compile classpath should have 3 entries", 3, res.getClasspath().size() );
}
//------------------------------------------------------------------------------------------
- public void testProvidedClasspathTransform()
+ public void testRuntimeClasspathTransform()
throws Exception
{
ClasspathContainer res;
@@ -112,7 +85,25 @@
assertNotNull("null classpath container after runtime transform", res );
assertNotNull("null classpath after runtime transform", res.getClasspath() );
- assertEquals("runtime classpath should have 3 entries", 3, res.getClasspath().size() );
+ assertEquals("runtime classpath should have 4 entries", 4, res.getClasspath().size() );
+
+ ArtifactMetadata md = res.getClasspath().get(3);
+ assertEquals("runtime artifact version should be 1.1", "1.1", md.getVersion() );
+ }
+ //------------------------------------------------------------------------------------------
+ public void testTestClasspathTransform()
+ throws Exception
+ {
+ ClasspathContainer res;
+
+ res = transform.transform( graph, ArtifactScopeEnum.test, false );
+
+ assertNotNull("null classpath container after runtime transform", res );
+ assertNotNull("null classpath after runtime transform", res.getClasspath() );
+ assertEquals("runtime classpath should have 4 entries", 4, res.getClasspath().size() );
+
+ ArtifactMetadata md = res.getClasspath().get(3);
+ assertEquals("test artifact version should be 1.2", "1.2", md.getVersion() );
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------