Apache
/
maven
mirror of https://github.com/apache/maven.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fixed errors reported by Checkstyle 

git-svn-id: https://svn.apache.org/repos/asf/maven/maven-3/trunk@813604 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Herve Boutemy 2009-09-10 21:49:53 +00:00
parent 4e37cb1a45
commit 388fcd100e
22 changed files with 1141 additions and 847 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
maven-compat/src/main/java/org/apache/maven/artifact/DefaultArtifact.java
View File

@ -263,7 +263,8 @@ public class DefaultArtifact
public Collection<ArtifactMetadata> getMetadataList()
{
if (metadataMap == null) {
if ( metadataMap == null )
{
return Collections.emptyList();
}
@ -528,7 +529,8 @@ public class DefaultArtifact
public boolean isSnapshot()
{
return getBaseVersion() != null && (getBaseVersion().endsWith(SNAPSHOT_VERSION) || getBaseVersion().equals(LATEST_VERSION));
return getBaseVersion() != null
&& ( getBaseVersion().endsWith( SNAPSHOT_VERSION ) || getBaseVersion().equals( LATEST_VERSION ) );
}
public void setResolved( boolean resolved )

14
maven-compat/src/main/java/org/apache/maven/artifact/repository/ArtifactRepositoryPolicy.java
View File

@ -82,16 +82,18 @@ public class ArtifactRepositoryPolicy
public void setUpdatePolicy( String updatePolicy )
{
if(updatePolicy != null) {
this.updatePolicy = updatePolicy;
if ( updatePolicy != null )
{
this.updatePolicy = updatePolicy;
}
}
public void setChecksumPolicy( String checksumPolicy )
{
if(checksumPolicy != null) {
this.checksumPolicy = checksumPolicy;
}
if ( checksumPolicy != null )
{
this.checksumPolicy = checksumPolicy;
}
}
public boolean isEnabled()
@ -135,7 +137,7 @@ public class ArtifactRepositoryPolicy
else if ( updatePolicy.startsWith( UPDATE_POLICY_INTERVAL ) )
{
String s = updatePolicy.substring( UPDATE_POLICY_INTERVAL.length() + 1 );
int minutes = Integer.valueOf(s);
int minutes = Integer.valueOf( s );
Calendar cal = Calendar.getInstance();
cal.add( Calendar.MINUTE, -minutes );
if ( cal.getTime().after( lastModified ) )

18
maven-compat/src/main/java/org/apache/maven/artifact/resolver/DebugResolutionListener.java
View File

@ -86,15 +86,15 @@ public class DebugResolutionListener
String ignoredScope )
{
logger.debug(
indent + artifact + " (not setting artifactScope to: " + ignoredScope + "; local artifactScope " + artifact.getScope() +
" wins)" );
indent + artifact + " (not setting artifactScope to: " + ignoredScope + "; local artifactScope " + artifact.getScope()
+ " wins)" );
// TODO: better way than static? this might hide messages in a reactor
if ( !ignoredArtifacts.contains( artifact ) )
{
logger.warn( "\n\tArtifact " + artifact + " retains local artifactScope '" + artifact.getScope() +
"' overriding broader artifactScope '" + ignoredScope + "'\n" +
"\tgiven by a dependency. If this is not intended, modify or remove the local artifactScope.\n" );
logger.warn( "\n\tArtifact " + artifact + " retains local artifactScope '" + artifact.getScope()
+ "' overriding broader artifactScope '" + ignoredScope + "'\n"
+ "\tgiven by a dependency. If this is not intended, modify or remove the local artifactScope.\n" );
ignoredArtifacts.add( artifact );
}
}
@ -107,16 +107,16 @@ public class DebugResolutionListener
public void selectVersionFromRange( Artifact artifact )
{
logger.debug( indent + artifact + " (setting version to: " + artifact.getVersion() + " from range: " +
artifact.getVersionRange() + ")" );
logger.debug( indent + artifact + " (setting version to: " + artifact.getVersion() + " from range: "
+ artifact.getVersionRange() + ")" );
}
public void restrictRange( Artifact artifact,
Artifact replacement,
VersionRange newRange )
{
logger.debug( indent + artifact + " (range restricted from: " + artifact.getVersionRange() + " and: " +
replacement.getVersionRange() + " to: " + newRange + " )" );
logger.debug( indent + artifact + " (range restricted from: " + artifact.getVersionRange() + " and: "
+ replacement.getVersionRange() + " to: " + newRange + " )" );
}
/**

12
maven-compat/src/main/java/org/apache/maven/artifact/resolver/MultipleArtifactsNotFoundException.java
View File

@ -90,13 +90,13 @@ public class MultipleArtifactsNotFoundException
int counter = 0;
for (Artifact artifact : artifacts) {
String message = (++counter) + ") " + artifact.getId();
for ( Artifact artifact : artifacts )
{
String message = ( ++counter ) + ") " + artifact.getId();
buffer.append(constructMissingArtifactMessage(message, " ", artifact.getGroupId(), artifact
.getArtifactId(), artifact.getVersion(), artifact.getType(), artifact.getClassifier(),
artifact.getDownloadUrl(), artifact
.getDependencyTrail()));
buffer.append( constructMissingArtifactMessage( message, " ", artifact.getGroupId(),
artifact.getArtifactId(), artifact.getVersion(), artifact.getType(), artifact.getClassifier(),
artifact.getDownloadUrl(), artifact.getDependencyTrail() ) );
}
buffer.append( "----------\n" );

40
maven-compat/src/main/java/org/apache/maven/artifact/versioning/VersionRange.java
View File

@ -279,8 +279,8 @@ public class VersionRange
version = recommendedVersion;
found = true;
}
else if ( version == null && restriction.getRecommendedVersion() != null &&
r.containsVersion( restriction.getRecommendedVersion() ) )
else if ( version == null && restriction.getRecommendedVersion() != null
&& r.containsVersion( restriction.getRecommendedVersion() ) )
{
// use this if we can, but prefer the original if possible
version = restriction.getRecommendedVersion();
@ -320,11 +320,11 @@ public class VersionRange
boolean done = false;
while ( !done )
{
if ( res1.getLowerBound() == null || res2.getUpperBound() == null ||
res1.getLowerBound().compareTo( res2.getUpperBound() ) <= 0 )
if ( res1.getLowerBound() == null || res2.getUpperBound() == null
|| res1.getLowerBound().compareTo( res2.getUpperBound() ) <= 0 )
{
if ( res1.getUpperBound() == null || res2.getLowerBound() == null ||
res1.getUpperBound().compareTo( res2.getLowerBound() ) >= 0 )
if ( res1.getUpperBound() == null || res2.getLowerBound() == null
|| res1.getUpperBound().compareTo( res2.getLowerBound() ) >= 0 )
{
ArtifactVersion lower;
ArtifactVersion upper;
@ -525,10 +525,13 @@ public class VersionRange
// TODO: could be more efficient by sorting the list and then moving along the restrictions in order?
ArtifactVersion matched = null;
for (ArtifactVersion version : versions) {
if (containsVersion(version)) {
for ( ArtifactVersion version : versions )
{
if ( containsVersion( version ) )
{
// valid - check if it is greater than the currently matched version
if (matched == null || version.compareTo(matched) > 0) {
if ( matched == null || version.compareTo( matched ) > 0 )
{
matched = version;
}
}
@ -538,8 +541,10 @@ public class VersionRange
public boolean containsVersion( ArtifactVersion version )
{
for (Restriction restriction : restrictions) {
if (restriction.containsVersion(version)) {
for ( Restriction restriction : restrictions )
{
if ( restriction.containsVersion( version ) )
{
return true;
}
}
@ -553,21 +558,22 @@ public class VersionRange
public boolean equals( Object obj )
{
if (this == obj){
if ( this == obj )
{
return true;
}
if (!(obj instanceof VersionRange ))
if ( !( obj instanceof VersionRange ) )
{
return false;
}
VersionRange other = (VersionRange) obj;
boolean equals =
recommendedVersion == other.recommendedVersion ||
( ( recommendedVersion != null ) && recommendedVersion.equals( other.recommendedVersion ) );
recommendedVersion == other.recommendedVersion
|| ( ( recommendedVersion != null ) && recommendedVersion.equals( other.recommendedVersion ) );
equals &=
restrictions == other.restrictions ||
( ( restrictions != null ) && restrictions.equals( other.restrictions ) );
restrictions == other.restrictions
|| ( ( restrictions != null ) && restrictions.equals( other.restrictions ) );
return equals;
}

10
maven-compat/src/main/java/org/apache/maven/profiles/DefaultProfileManager.java
View File

@ -28,7 +28,6 @@ import org.apache.maven.model.profile.ProfileSelector;
import org.apache.maven.profiles.activation.ProfileActivationException;
import org.codehaus.plexus.MutablePlexusContainer;
import org.codehaus.plexus.PlexusContainer;
import org.codehaus.plexus.component.annotations.Component;
import org.codehaus.plexus.component.annotations.Requirement;
import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
import org.codehaus.plexus.logging.Logger;
@ -67,7 +66,7 @@ public class DefaultProfileManager
*/
public DefaultProfileManager( PlexusContainer container )
{
this( container, null);
this( container, null );
}
/**
@ -89,7 +88,8 @@ public class DefaultProfileManager
this.requestProperties = props;
}
public Properties getRequestProperties() {
public Properties getRequestProperties()
{
return requestProperties;
}
@ -108,8 +108,8 @@ public class DefaultProfileManager
Profile existing = (Profile) profilesById.get( profileId );
if ( existing != null )
{
logger.warn( "Overriding profile: \'" + profileId + "\' (source: " + existing.getSource() +
") with new instance from source: " + profile.getSource() );
logger.warn( "Overriding profile: \'" + profileId + "\' (source: " + existing.getSource()
+ ") with new instance from source: " + profile.getSource() );
}
profilesById.put( profile.getId(), profile );

4
maven-compat/src/main/java/org/apache/maven/project/ModelUtils.java
View File

@ -97,8 +97,8 @@ public final class ModelUtils
// 1. we're not processing the plugins in an inheritance-based merge
// 2. the parent's <inherited/> flag is not set
// 3. the parent's <inherited/> flag is set to true
if ( !handleAsInheritance || ( parentInherited == null ) ||
Boolean.valueOf( parentInherited ).booleanValue() )
if ( !handleAsInheritance || ( parentInherited == null )
|| Boolean.valueOf( parentInherited ).booleanValue() )
{
Plugin childPlugin = (Plugin) childPlugins.get( parentPlugin.getKey() );

17
maven-compat/src/main/java/org/apache/maven/project/inheritance/DefaultModelInheritanceAssembler.java
View File

@ -155,8 +155,8 @@ public class DefaultModelInheritanceAssembler
appendPath( parentScm.getConnection(), child.getArtifactId(), childPathAdjustment, appendPaths ) );
}
if ( StringUtils.isEmpty( childScm.getDeveloperConnection() ) &&
!StringUtils.isEmpty( parentScm.getDeveloperConnection() ) )
if ( StringUtils.isEmpty( childScm.getDeveloperConnection() )
&& !StringUtils.isEmpty( parentScm.getDeveloperConnection() ) )
{
childScm
.setDeveloperConnection( appendPath( parentScm.getDeveloperConnection(), child.getArtifactId(),
@ -388,8 +388,8 @@ public class DefaultModelInheritanceAssembler
String parentInherited = parentPlugin.getInherited();
if ( !handleAsInheritance || ( parentInherited == null ) ||
Boolean.valueOf( parentInherited ).booleanValue() )
if ( !handleAsInheritance || ( parentInherited == null )
|| Boolean.valueOf( parentInherited ).booleanValue() )
{
ReportPlugin assembledPlugin = parentPlugin;
@ -545,9 +545,8 @@ public class DefaultModelInheritanceAssembler
if ( deps != null )
{
for ( Iterator<Dependency> it = deps.iterator(); it.hasNext(); )
for ( Dependency dependency : deps )
{
Dependency dependency = it.next();
depsMap.put( dependency.getManagementKey(), dependency );
}
}
@ -556,9 +555,8 @@ public class DefaultModelInheritanceAssembler
if ( deps != null )
{
for ( Iterator<Dependency> it = deps.iterator(); it.hasNext(); )
for ( Dependency dependency : deps )
{
Dependency dependency = it.next();
depsMap.put( dependency.getManagementKey(), dependency );
}
}
@ -753,9 +751,8 @@ public class DefaultModelInheritanceAssembler
private static void mergeExtensionLists( Build childBuild, Build parentBuild )
{
for ( Iterator i = parentBuild.getExtensions().iterator(); i.hasNext(); )
for ( Extension e : parentBuild.getExtensions() )
{
Extension e = (Extension) i.next();
if ( !childBuild.getExtensions().contains( e ) )
{
childBuild.addExtension( e );

28
maven-compat/src/main/java/org/apache/maven/repository/legacy/DefaultUpdateCheckManager.java
View File

@ -194,8 +194,8 @@ public class DefaultUpdateCheckManager
{
if ( !touchfile.getParentFile().exists() && !touchfile.getParentFile().mkdirs() )
{
getLogger().debug( "Failed to create directory: " + touchfile.getParent() +
" for tracking artifact metadata resolution." );
getLogger().debug( "Failed to create directory: " + touchfile.getParent()
+ " for tracking artifact metadata resolution." );
return;
}
@ -237,8 +237,8 @@ public class DefaultUpdateCheckManager
}
catch ( IOException e )
{
getLogger().debug( "Failed to record lastUpdated information for resolution.\nFile: " +
touchfile.toString() + "; key: " + key, e );
getLogger().debug( "Failed to record lastUpdated information for resolution.\nFile: "
+ touchfile.toString() + "; key: " + key, e );
}
finally
{
@ -250,8 +250,8 @@ public class DefaultUpdateCheckManager
}
catch ( IOException e )
{
getLogger().debug( "Error releasing exclusive lock for resolution tracking file: " +
touchfile, e );
getLogger().debug( "Error releasing exclusive lock for resolution tracking file: "
+ touchfile, e );
}
}
@ -263,8 +263,8 @@ public class DefaultUpdateCheckManager
}
catch ( IOException e )
{
getLogger().debug( "Error closing FileChannel for resolution tracking file: " +
touchfile, e );
getLogger().debug( "Error closing FileChannel for resolution tracking file: "
+ touchfile, e );
}
}
}
@ -314,8 +314,8 @@ public class DefaultUpdateCheckManager
}
catch ( IOException e )
{
getLogger().debug( "Failed to read lastUpdated information.\nFile: " +
touchfile.toString() + "; key: " + key, e );
getLogger().debug( "Failed to read lastUpdated information.\nFile: "
+ touchfile.toString() + "; key: " + key, e );
}
finally
{
@ -327,8 +327,8 @@ public class DefaultUpdateCheckManager
}
catch ( IOException e )
{
getLogger().debug( "Error releasing shared lock for resolution tracking file: " +
touchfile, e );
getLogger().debug( "Error releasing shared lock for resolution tracking file: "
+ touchfile, e );
}
}
@ -340,8 +340,8 @@ public class DefaultUpdateCheckManager
}
catch ( IOException e )
{
getLogger().debug( "Error closing FileChannel for resolution tracking file: " +
touchfile, e );
getLogger().debug( "Error closing FileChannel for resolution tracking file: "
+ touchfile, e );
}
}
}

11
maven-compat/src/main/java/org/apache/maven/repository/legacy/UpdateCheckManager.java
View File

@ -25,17 +25,18 @@ import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.repository.metadata.RepositoryMetadata;
public interface UpdateCheckManager {
public interface UpdateCheckManager
{
String ROLE = UpdateCheckManager.class.getName();
String ROLE = UpdateCheckManager.class.getName();
boolean isUpdateRequired( Artifact artifact, ArtifactRepository repository );
boolean isUpdateRequired( Artifact artifact, ArtifactRepository repository );
void touch( Artifact artifact, ArtifactRepository repository );
void touch( Artifact artifact, ArtifactRepository repository );
boolean isUpdateRequired( RepositoryMetadata metadata, ArtifactRepository repository, File file );
void touch( RepositoryMetadata metadata, ArtifactRepository repository, File file );
void touch( RepositoryMetadata metadata, ArtifactRepository repository, File file );
boolean isPomUpdateRequired( Artifact artifact, ArtifactRepository repository );

9
maven-compat/src/main/java/org/apache/maven/repository/legacy/resolver/transform/DefaultArtifactTransformationManager.java
View File

@ -55,7 +55,8 @@ public class DefaultArtifactTransformationManager
ArtifactRepository localRepository )
throws ArtifactResolutionException, ArtifactNotFoundException
{
for (ArtifactTransformation transform : artifactTransformations) {
for ( ArtifactTransformation transform : artifactTransformations )
{
transform.transformForResolve( artifact, remoteRepositories, localRepository );
}
}
@ -64,7 +65,8 @@ public class DefaultArtifactTransformationManager
ArtifactRepository localRepository )
throws ArtifactInstallationException
{
for (ArtifactTransformation transform : artifactTransformations) {
for ( ArtifactTransformation transform : artifactTransformations )
{
transform.transformForInstall( artifact, localRepository );
}
}
@ -74,7 +76,8 @@ public class DefaultArtifactTransformationManager
ArtifactRepository localRepository )
throws ArtifactDeploymentException
{
for (ArtifactTransformation transform : artifactTransformations) {
for ( ArtifactTransformation transform : artifactTransformations )
{
transform.transformForDeployment( artifact, remoteRepository, localRepository );
}
}

4
maven-compat/src/main/java/org/apache/maven/repository/legacy/resolver/transform/SnapshotTransformation.java
View File

@ -117,8 +117,8 @@ public class SnapshotTransformation
}
catch ( RepositoryMetadataResolutionException e )
{
throw new ArtifactDeploymentException( "Error retrieving previous build number for artifact '" +
artifact.getDependencyConflictId() + "': " + e.getMessage(), e );
throw new ArtifactDeploymentException( "Error retrieving previous build number for artifact '"
+ artifact.getDependencyConflictId() + "': " + e.getMessage(), e );
}
RepositoryMetadata metadata = new SnapshotArtifactRepositoryMetadata( artifact, snapshot );

197
maven-compat/src/main/java/org/apache/maven/repository/metadata/ClasspathContainer.java
View File

@ -1,5 +1,24 @@
package org.apache.maven.repository.metadata;
/*
* 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.util.ArrayList;
import java.util.Iterator;
import java.util.List;
@ -16,97 +35,111 @@ public class ClasspathContainer
implements Iterable<ArtifactMetadata>
{
private List<ArtifactMetadata> classpath;
private ArtifactScopeEnum scope;
//-------------------------------------------------------------------------------------------
public ClasspathContainer(ArtifactScopeEnum scope)
{
this.scope = ArtifactScopeEnum.checkScope(scope);
}
//-------------------------------------------------------------------------------------------
public ClasspathContainer(
List<ArtifactMetadata> classpath
, ArtifactScopeEnum scope
)
{
this(scope);
this.classpath = classpath;
}
//-------------------------------------------------------------------------------------------
public Iterator<ArtifactMetadata> iterator()
{
return classpath == null ? null : classpath.iterator() ;
}
//-------------------------------------------------------------------------------------------
public ClasspathContainer add( ArtifactMetadata md )
{
if( classpath == null )
classpath = new ArrayList<ArtifactMetadata>(16);
private ArtifactScopeEnum scope;
classpath.add(md);
// -------------------------------------------------------------------------------------------
public ClasspathContainer( ArtifactScopeEnum scope )
{
this.scope = ArtifactScopeEnum.checkScope( scope );
}
return this;
}
//-------------------------------------------------------------------------------------------
public List<ArtifactMetadata> getClasspath()
{
return classpath;
}
//-------------------------------------------------------------------------------------------
public MetadataTreeNode getClasspathAsTree()
throws MetadataResolutionException
{
if( classpath == null || classpath.size() < 1 )
return null;
// -------------------------------------------------------------------------------------------
public ClasspathContainer( List<ArtifactMetadata> classpath, ArtifactScopeEnum scope )
{
this( scope );
this.classpath = classpath;
}
MetadataTreeNode tree = null;
MetadataTreeNode parent = null;
MetadataTreeNode node = null;
// -------------------------------------------------------------------------------------------
public Iterator<ArtifactMetadata> iterator()
{
return classpath == null ? null : classpath.iterator();
}
for( ArtifactMetadata md : classpath ) {
node = new MetadataTreeNode( md, parent, md.isResolved(), md.getArtifactScope() );
if( tree == null ) {
tree = node;
}
// -------------------------------------------------------------------------------------------
public ClasspathContainer add( ArtifactMetadata md )
{
if ( classpath == null )
{
classpath = new ArrayList<ArtifactMetadata>( 16 );
}
if( parent != null ) {
parent.setNChildren(1);
parent.addChild(0, node);
}
classpath.add( md );
parent = node;
return this;
}
}
return tree;
}
// -------------------------------------------------------------------------------------------
public List<ArtifactMetadata> getClasspath()
{
return classpath;
}
public void setClasspath(List<ArtifactMetadata> classpath)
{
this.classpath = classpath;
}
// -------------------------------------------------------------------------------------------
public MetadataTreeNode getClasspathAsTree()
throws MetadataResolutionException
{
if ( classpath == null || classpath.size() < 1 )
{
return null;
}
public ArtifactScopeEnum getScope()
{
return scope;
}
MetadataTreeNode tree = null;
MetadataTreeNode parent = null;
MetadataTreeNode node = null;
public void setScope(ArtifactScopeEnum scope)
{
this.scope = scope;
}
//-------------------------------------------------------------------------------------------
@Override
public String toString()
{
StringBuilder sb = new StringBuilder(256);
sb.append("[scope="+scope.getScope() );
if(classpath != null)
for( ArtifactMetadata md : classpath ) {
sb.append(": "+md.toString()+'{'+md.getArtifactUri()+'}');
}
sb.append(']');
return sb.toString();
}
//-------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------
for ( ArtifactMetadata md : classpath )
{
node = new MetadataTreeNode( md, parent, md.isResolved(), md.getArtifactScope() );
if ( tree == null )
{
tree = node;
}
if ( parent != null )
{
parent.setNChildren( 1 );
parent.addChild( 0, node );
}
parent = node;
}
return tree;
}
public void setClasspath( List<ArtifactMetadata> classpath )
{
this.classpath = classpath;
}
public ArtifactScopeEnum getScope()
{
return scope;
}
public void setScope( ArtifactScopeEnum scope )
{
this.scope = scope;
}
// -------------------------------------------------------------------------------------------
@Override
public String toString()
{
StringBuilder sb = new StringBuilder( 256 );
sb.append( "[scope=" + scope.getScope() );
if ( classpath != null )
{
for ( ArtifactMetadata md : classpath )
{
sb.append( ": " + md.toString() + '{' + md.getArtifactUri() + '}' );
}
}
sb.append( ']' );
return sb.toString();
}
// -------------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------
}

231
maven-compat/src/main/java/org/apache/maven/repository/metadata/DefaultClasspathTransformation.java
View File

@ -1,5 +1,24 @@
package org.apache.maven.repository.metadata;
/*
* 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.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
@ -23,44 +42,47 @@ implements ClasspathTransformation
GraphConflictResolver conflictResolver;
//----------------------------------------------------------------------------------------------------
public ClasspathContainer transform(
MetadataGraph dirtyGraph
, ArtifactScopeEnum scope
, boolean resolve
)
throws MetadataGraphTransformationException
{
try {
if( dirtyGraph == null
|| dirtyGraph.isEmpty()
)
return null;
public ClasspathContainer transform( MetadataGraph dirtyGraph, ArtifactScopeEnum scope, boolean resolve )
throws MetadataGraphTransformationException
{
try
{
if ( dirtyGraph == null || dirtyGraph.isEmpty() )
{
return null;
}
MetadataGraph cleanGraph = conflictResolver.resolveConflicts( dirtyGraph, scope );
MetadataGraph cleanGraph = conflictResolver.resolveConflicts( dirtyGraph, scope );
if( cleanGraph == null
|| cleanGraph.isEmpty()
)
return null;
if ( cleanGraph == null || cleanGraph.isEmpty() )
{
return null;
}
ClasspathContainer cpc = new ClasspathContainer( scope );
if( cleanGraph.isEmptyEdges() ) {
// single entry in the classpath, populated from itself
ArtifactMetadata amd = cleanGraph.getEntry().getMd();
cpc.add( amd );
} else {
ClasspathGraphVisitor v = new ClasspathGraphVisitor( cleanGraph, cpc );
MetadataGraphVertex entry = cleanGraph.getEntry();
ArtifactMetadata md = entry.getMd();
// entry point
v.visit( entry ); //, md.getVersion(), md.getArtifactUri() );
}
ClasspathContainer cpc = new ClasspathContainer( scope );
if ( cleanGraph.isEmptyEdges() )
{
// single entry in the classpath, populated from itself
ArtifactMetadata amd = cleanGraph.getEntry().getMd();
cpc.add( amd );
}
else
{
ClasspathGraphVisitor v = new ClasspathGraphVisitor( cleanGraph, cpc );
MetadataGraphVertex entry = cleanGraph.getEntry();
ArtifactMetadata md = entry.getMd();
// entry point
v.visit( entry ); // , md.getVersion(), md.getArtifactUri() );
}
return cpc;
}
catch ( GraphConflictResolutionException e )
{
throw new MetadataGraphTransformationException( e );
}
}
return cpc;
} catch (GraphConflictResolutionException e) {
throw new MetadataGraphTransformationException(e);
}
}
//===================================================================================================
/**
* Helper class to traverse graph. Required to make the containing method thread-safe
@ -68,82 +90,91 @@ implements ClasspathTransformation
*/
private class ClasspathGraphVisitor
{
MetadataGraph graph;
ClasspathContainer cpc;
List<MetadataGraphVertex> visited;
//-----------------------------------------------------------------------
protected ClasspathGraphVisitor( MetadataGraph cleanGraph, ClasspathContainer cpc )
{
this.cpc = cpc;
this.graph = cleanGraph;
MetadataGraph graph;
visited = new ArrayList<MetadataGraphVertex>( cleanGraph.getVertices().size() );
}
//-----------------------------------------------------------------------
protected void visit( MetadataGraphVertex node ) //, String version, String artifactUri )
{
ArtifactMetadata md = node.getMd();
if( visited.contains(node) )
return;
ClasspathContainer cpc;
cpc.add( md );
List<MetadataGraphVertex> visited;
// -----------------------------------------------------------------------
protected ClasspathGraphVisitor( MetadataGraph cleanGraph, ClasspathContainer cpc )
{
this.cpc = cpc;
this.graph = cleanGraph;
visited = new ArrayList<MetadataGraphVertex>( cleanGraph.getVertices().size() );
}
// -----------------------------------------------------------------------
protected void visit( MetadataGraphVertex node ) // , String version, String artifactUri )
{
ArtifactMetadata md = node.getMd();
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() );
// 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.getPomOrder() - e1.getPomOrder();
// }
//
// return e2.getDepth() - e1.getDepth();
// }
// }
// );
// return e2.getDepth() - e1.getDepth();
// }
// }
// );
List<MetadataGraphEdge> exits = graph.getExcidentEdges(node);
List<MetadataGraphEdge> exits = graph.getExcidentEdges(node);
if( exits != null && exits.size() > 0)
{
MetadataGraphEdge[] sortedExits = exits.toArray( new MetadataGraphEdge[exits.size()] );
Arrays.sort( sortedExits
,
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();
}
if ( exits != null && exits.size() > 0 )
{
MetadataGraphEdge[] sortedExits = exits.toArray( new MetadataGraphEdge[exits.size()] );
Arrays.sort( sortedExits
,
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();
}
}
);
return e2.getDepth() - e1.getDepth();
}
}
);
for( MetadataGraphEdge e : sortedExits ) {
MetadataGraphVertex targetNode = e.getTarget();
targetNode.getMd().setArtifactScope( e.getScope() );
targetNode.getMd().setWhy( e.getSource().getMd().toString() );
visit( targetNode );
}
}
for ( MetadataGraphEdge e : sortedExits )
{
MetadataGraphVertex targetNode = e.getTarget();
targetNode.getMd().setArtifactScope( e.getScope() );
targetNode.getMd().setWhy( e.getSource().getMd().toString() );
visit( targetNode );
}
}
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
}
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------

54
maven-compat/src/main/java/org/apache/maven/repository/metadata/DefaultGraphConflictResolutionPolicy.java
View File

@ -1,5 +1,24 @@
package org.apache.maven.repository.metadata;
/*
* 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 org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
import org.codehaus.plexus.component.annotations.Component;
@ -26,25 +45,30 @@ implements GraphConflictResolutionPolicy
@Configuration(name="newer-first", value="true")
private boolean newerFirst = true;
public MetadataGraphEdge apply(MetadataGraphEdge e1, MetadataGraphEdge e2)
{
int depth1 = e1.getDepth();
int depth2 = e2.getDepth();
public MetadataGraphEdge apply( MetadataGraphEdge e1, MetadataGraphEdge e2 )
{
int depth1 = e1.getDepth();
int depth2 = e2.getDepth();
if( depth1 == depth2 ) {
ArtifactVersion v1 = new DefaultArtifactVersion( e1.getVersion() );
ArtifactVersion v2 = new DefaultArtifactVersion( e2.getVersion() );
if ( depth1 == depth2 )
{
ArtifactVersion v1 = new DefaultArtifactVersion( e1.getVersion() );
ArtifactVersion v2 = new DefaultArtifactVersion( e2.getVersion() );
if( newerFirst )
return v1.compareTo(v2) > 0 ? e1 : e2;
if ( newerFirst )
{
return v1.compareTo( v2 ) > 0 ? e1 : e2;
}
return v1.compareTo(v2) > 0 ? e2 : e1;
}
return v1.compareTo( v2 ) > 0 ? e2 : e1;
}
if( closerFirst )
return depth1 < depth2 ? e1 : e2;
if ( closerFirst )
{
return depth1 < depth2 ? e1 : e2;
}
return depth1 < depth2 ? e2 : e1;
}
return depth1 < depth2 ? e2 : e1;
}
}

484
maven-compat/src/main/java/org/apache/maven/repository/metadata/MetadataGraph.java
View File

@ -1,5 +1,24 @@
package org.apache.maven.repository.metadata;
/*
* 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.util.ArrayList;
import java.util.HashMap;
import java.util.List;
@ -17,19 +36,19 @@ import org.apache.maven.artifact.ArtifactScopeEnum;
public class MetadataGraph
{
public static int DEFAULT_VERTICES = 32;
public static int DEFAULT_EDGES = 64;
public static final int DEFAULT_VERTICES = 32;
public static final 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
*/
// 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;
// graph vertices
TreeSet< MetadataGraphVertex > vertices;
TreeSet<MetadataGraphVertex> vertices;
/**
* incident and excident edges per node
@ -49,11 +68,11 @@ public class MetadataGraph
*/
public MetadataGraph( int nVertices )
{
init( nVertices, 2*nVertices );
init( nVertices, 2 * nVertices );
}
public MetadataGraph( int nVertices, int nEdges )
{
init( nVertices, nEdges );
init( nVertices, nEdges );
}
//------------------------------------------------------------------------
/**
@ -62,14 +81,14 @@ public class MetadataGraph
public MetadataGraph( MetadataGraphVertex entry )
throws MetadataResolutionException
{
checkVertex(entry);
checkVertices(1);
checkVertex( entry );
checkVertices( 1 );
entry.setCompareVersion( versionedVertices );
entry.setCompareScope( scopedVertices );
entry.setCompareVersion( versionedVertices );
entry.setCompareScope( scopedVertices );
vertices.add( entry );
this.entry = entry;
vertices.add( entry );
this.entry = entry;
}
//------------------------------------------------------------------------
/**
@ -78,7 +97,7 @@ public class MetadataGraph
public MetadataGraph( MetadataTreeNode tree )
throws MetadataResolutionException
{
this( tree, false, false );
this( tree, false, false );
}
//------------------------------------------------------------------------
/**
@ -97,8 +116,8 @@ public class MetadataGraph
throw new MetadataResolutionException( "tree is null" );
}
setVersionedVertices(versionedVertices);
setScopedVertices(scopedVertices);
setVersionedVertices( versionedVertices );
setScopedVertices( scopedVertices );
this.versionedVertices = scopedVertices || versionedVertices;
this.scopedVertices = scopedVertices;
@ -114,7 +133,7 @@ public class MetadataGraph
, MetadataTreeNode node
, int depth
, int pomOrder
)
)
throws MetadataResolutionException
{
if ( node == null )
@ -123,20 +142,20 @@ public class MetadataGraph
}
MetadataGraphVertex vertex = new MetadataGraphVertex( node.md, versionedVertices, scopedVertices );
if( ! vertices.contains(vertex) )
if ( !vertices.contains( vertex ) )
{
vertices.add(vertex);
vertices.add( vertex );
}
if( parentVertex != null ) // then create the edge
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 );
addEdge( parentVertex, vertex, e);
addEdge( parentVertex, vertex, e );
}
else
{
entry = vertex;
entry = vertex;
}
MetadataTreeNode[] kids = node.getChildren();
@ -145,49 +164,57 @@ public class MetadataGraph
return;
}
for( int i = 0; i< kids.length; i++ )
for ( int i = 0; i < kids.length; i++ )
{
MetadataTreeNode n = kids[i];
MetadataTreeNode n = kids[i];
processTreeNodes( vertex, n, depth + 1, i );
}
}
//------------------------------------------------------------------------
public MetadataGraphVertex findVertex( ArtifactMetadata md )
{
if( md == null || vertices == null || vertices.size() < 1 )
return null;
if ( md == null || vertices == null || vertices.size() < 1 )
{
return null;
}
MetadataGraphVertex v = new MetadataGraphVertex(md);
v.setCompareVersion(versionedVertices);
v.setCompareScope(scopedVertices);
MetadataGraphVertex v = new MetadataGraphVertex( md );
v.setCompareVersion( versionedVertices );
v.setCompareScope( scopedVertices );
for( MetadataGraphVertex gv : vertices )
{
if( gv.equals(v) )
return gv;
}
for ( MetadataGraphVertex gv : vertices )
{
if ( gv.equals( v ) )
{
return gv;
}
}
return null;
return null;
}
//------------------------------------------------------------------------
public MetadataGraphVertex addVertex( ArtifactMetadata md )
{
if( md == null )
return null;
if ( md == null )
{
return null;
}
checkVertices();
checkVertices();
MetadataGraphVertex v = findVertex(md);
if( v != null)
return v;
MetadataGraphVertex v = findVertex( md );
if ( v != null )
{
return v;
}
v = new MetadataGraphVertex(md);
v = new MetadataGraphVertex( md );
v.setCompareVersion(versionedVertices);
v.setCompareScope(scopedVertices);
v.setCompareVersion( versionedVertices );
v.setCompareScope( scopedVertices );
vertices.add( v );
return v;
vertices.add( v );
return v;
}
//------------------------------------------------------------------------
/**
@ -195,135 +222,163 @@ public class MetadataGraph
*/
private void init( int nVertices, int nEdges )
{
int nV = nVertices;
if( nVertices < 1 )
nV = 1;
int nV = nVertices;
if ( nVertices < 1 )
{
nV = 1;
}
checkVertices(nV);
checkVertices( nV );
int nE = nVertices;
if( nEdges <= nV )
nE = 2*nE;
int nE = nVertices;
if ( nEdges <= nV )
{
nE = 2 * nE;
}
checkEdges(nE);
checkEdges( nE );
}
private void checkVertices()
{
checkVertices(DEFAULT_VERTICES);
checkVertices( DEFAULT_VERTICES );
}
private void checkVertices( int nVertices )
{
if( vertices == null )
vertices = new TreeSet<MetadataGraphVertex>();
if ( vertices == null )
{
vertices = new TreeSet<MetadataGraphVertex>();
}
}
private void checkEdges()
{
int count = DEFAULT_EDGES;
int count = DEFAULT_EDGES;
if( vertices != null )
count = vertices.size() + vertices.size() / 2;
if ( vertices != null )
{
count = vertices.size() + vertices.size() / 2;
}
checkEdges( count );
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 );
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" );
if ( v == null )
{
throw new MetadataResolutionException( "null vertex" );
}
if ( v.getMd() == null )
{
throw new MetadataResolutionException( "vertex without metadata" );
}
}
//------------------------------------------------------------------------
private static void checkEdge( MetadataGraphEdge e )
throws MetadataResolutionException
{
if( e == null )
throw new MetadataResolutionException( "badly formed edge" );
if ( e == null )
{
throw new MetadataResolutionException( "badly formed edge" );
}
}
//------------------------------------------------------------------------
public List<MetadataGraphEdge> getEdgesBetween(
MetadataGraphVertex vFrom
, MetadataGraphVertex vTo
)
public List<MetadataGraphEdge> getEdgesBetween( MetadataGraphVertex vFrom, MetadataGraphVertex vTo )
{
List<MetadataGraphEdge> edges = getIncidentEdges(vTo);
if( edges == null || edges.isEmpty() )
return null;
List<MetadataGraphEdge> edges = getIncidentEdges(vTo);
if ( edges == null || edges.isEmpty() )
{
return null;
}
List<MetadataGraphEdge> res = new ArrayList<MetadataGraphEdge>( edges.size() );
List<MetadataGraphEdge> res = new ArrayList<MetadataGraphEdge>( edges.size() );
for( MetadataGraphEdge e : edges )
{
if( e.getSource().equals(vFrom) )
res.add(e);
}
for ( MetadataGraphEdge e : edges )
{
if ( e.getSource().equals( vFrom ) )
{
res.add( e );
}
}
return res;
return res;
}
//------------------------------------------------------------------------
public MetadataGraph addEdge( MetadataGraphVertex vFrom
, MetadataGraphVertex vTo
, MetadataGraphEdge e
)
public MetadataGraph addEdge( MetadataGraphVertex vFrom, MetadataGraphVertex vTo, MetadataGraphEdge e )
throws MetadataResolutionException
{
checkVertex(vFrom);
checkVertex(vTo);
checkVertex( vFrom );
checkVertex( vTo );
checkVertices();
checkVertices();
checkEdge(e);
checkEdges();
checkEdge( e );
checkEdges();
e.setSource(vFrom);
e.setTarget(vTo);
e.setSource( vFrom );
e.setTarget( vTo );
vFrom.setCompareVersion(versionedVertices);
vFrom.setCompareScope(scopedVertices);
vFrom.setCompareVersion( versionedVertices );
vFrom.setCompareScope( scopedVertices );
List<MetadataGraphEdge> exList = excidentEdges.get(vFrom);
if( exList == null ) {
exList = new ArrayList<MetadataGraphEdge>();
excidentEdges.put( vFrom, exList );
}
List<MetadataGraphEdge> exList = excidentEdges.get( vFrom );
if ( exList == null )
{
exList = new ArrayList<MetadataGraphEdge>();
excidentEdges.put( vFrom, exList );
}
if( !exList.contains(e) )
exList.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 );
}
List<MetadataGraphEdge> inList = incidentEdges.get( vTo );
if ( inList == null )
{
inList = new ArrayList<MetadataGraphEdge>();
incidentEdges.put( vTo, inList );
}
if( !inList.contains(e) )
inList.add(e);
if ( !inList.contains( e ) )
{
inList.add( e );
}
return this;
return this;
}
//------------------------------------------------------------------------
public MetadataGraph removeVertex( MetadataGraphVertex v )
{
if( vertices!= null && v != null )
vertices.remove(v);
if ( vertices != null && v != null )
{
vertices.remove( v );
}
if( incidentEdges!= null )
incidentEdges.remove(v);
if ( incidentEdges != null )
{
incidentEdges.remove( v );
}
if( excidentEdges!= null )
excidentEdges.remove(v);
if ( excidentEdges != null )
{
excidentEdges.remove( v );
}
return this;
return this;
}
//------------------------------------------------------------------------
@ -364,97 +419,108 @@ public class MetadataGraph
return vertices;
}
public List<MetadataGraphEdge> getIncidentEdges( MetadataGraphVertex vertex )
{
checkEdges();
return incidentEdges.get(vertex);
}
public List<MetadataGraphEdge> getIncidentEdges( MetadataGraphVertex vertex )
{
checkEdges();
return incidentEdges.get( vertex );
}
public List<MetadataGraphEdge> getExcidentEdges( MetadataGraphVertex vertex )
{
checkEdges();
return excidentEdges.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;
{
return versionedVertices;
}
// scoped graph is versioned by definition
if( scopedVertices )
versionedVertices = true;
}
public ArtifactScopeEnum getScope()
{
return scope;
}
public void setScope(ArtifactScopeEnum scope)
{
this.scope = scope;
}
//------------------------------------------------------------------------
public boolean isEmpty()
{
return
entry == null
|| vertices == null
|| vertices.isEmpty()
;
}
//------------------------------------------------------------------------
public boolean isEmptyEdges()
{
return
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");
public void setVersionedVertices( boolean versionedVertices )
{
this.versionedVertices = versionedVertices;
}
List<MetadataGraphEdge> outs = getExcidentEdges(v);
if( outs != null )
for( MetadataGraphEdge e : outs )
{
sb.append(" to : "+e.toString()+ "\n");
}
else
sb.append(" no exit\n");
public boolean isScopedVertices()
{
return scopedVertices;
}
sb.append("-------------------------------------------------\n");
}
sb.append("=============================================================\n");
return sb.toString();
}
public void setScopedVertices( boolean scopedVertices )
{
this.scopedVertices = scopedVertices;
// scoped graph is versioned by definition
if ( scopedVertices )
{
versionedVertices = true;
}
}
public ArtifactScopeEnum getScope()
{
return scope;
}
public void setScope( ArtifactScopeEnum scope )
{
this.scope = scope;
}
// ------------------------------------------------------------------------
public boolean isEmpty()
{
return entry == null || vertices == null || vertices.isEmpty();
}
//------------------------------------------------------------------------
public boolean isEmptyEdges()
{
return 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();
}
//------------------------------------------------------------------------
//------------------------------------------------------------------------

264
maven-compat/src/main/java/org/apache/maven/repository/metadata/MetadataGraphVertex.java
View File

@ -1,5 +1,24 @@
package org.apache.maven.repository.metadata;
/*
* 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 org.apache.maven.artifact.ArtifactScopeEnum;
/**
@ -16,15 +35,15 @@ public class MetadataGraphVertex
private boolean compareVersion = false;
private boolean compareScope = false;
public MetadataGraphVertex( ArtifactMetadata md )
public MetadataGraphVertex( ArtifactMetadata md )
{
super();
this.md = md;
}
public MetadataGraphVertex( ArtifactMetadata md, boolean compareVersion, boolean compareScope )
public MetadataGraphVertex( ArtifactMetadata md, boolean compareVersion, boolean compareScope )
{
this(md);
this( md );
this.compareVersion = compareVersion;
this.compareScope = compareScope;
}
@ -38,125 +57,160 @@ public class MetadataGraphVertex
{
this.md = md;
}
//---------------------------------------------------------------------
// ---------------------------------------------------------------------
public boolean isCompareVersion()
{
return compareVersion;
}
{
return compareVersion;
}
public void setCompareVersion(boolean compareVersion)
{
this.compareVersion = compareVersion;
}
public void setCompareVersion( boolean compareVersion )
{
this.compareVersion = compareVersion;
}
public boolean isCompareScope()
{
return compareScope;
}
public boolean isCompareScope()
{
return compareScope;
}
public void setCompareScope(boolean compareScope)
{
this.compareScope = 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;
// ---------------------------------------------------------------------
@Override
public String toString()
{
return "[" + ( md == null ? "no metadata" : md.toString() ) + "]";
}
if( s1 == null && s2 != null )
return -1;
// ---------------------------------------------------------------------
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;
if ( s1 != null && s2 == null )
{
return 1;
}
ArtifactMetadata vmd = vertex.getMd();
return s1.compareTo( s2 );
}
if( vmd == null )
{
if( md == null )
return 0;
else
return 1;
}
// ---------------------------------------------------------------------
public int compareTo( MetadataGraphVertex vertex )
{
if ( vertex == null || vertex.getMd() == null )
{
return 1;
}
int g = compareStrings( md.groupId, vmd.groupId );
ArtifactMetadata vmd = vertex.getMd();
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;
}
if ( vmd == null )
{
if ( md == null )
{
return 0;
}
else
{
return 1;
}
}
return g;
}
//---------------------------------------------------------------------
@Override
public boolean equals(Object vo)
{
if( vo == null || !(vo instanceof MetadataGraphVertex) )
return false;
return compareTo( (MetadataGraphVertex)vo ) == 0;
}
//---------------------------------------------------------------------
int g = compareStrings( md.groupId, vmd.groupId );
@Override
public int hashCode()
{
if( md == null )
return super.hashCode();
StringBuilder hashString = new StringBuilder(128);
hashString.append( md.groupId+"|" );
hashString.append( md.artifactId+"|" );
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;
}
}
if( compareVersion )
hashString.append(md.version + "|");
return g;
}
if( compareScope )
hashString.append(md.getArtifactScope() + "|");
// ---------------------------------------------------------------------
@Override
public boolean equals( Object vo )
{
if ( vo == null || !( vo instanceof MetadataGraphVertex ) )
{
return false;
}
return compareTo( (MetadataGraphVertex) vo ) == 0;
}
return hashString.toString().hashCode();
// ---------------------------------------------------------------------
// BASE64Encoder b64 = new BASE64Encoder();
// return b64.encode( hashString.toString().getBytes() ).hashCode();
}
@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();
}
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
}

121
maven-compat/src/main/java/org/apache/maven/repository/metadata/MetadataResolutionResult.java
View File

@ -1,5 +1,24 @@
package org.apache.maven.repository.metadata;
/*
* 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 org.apache.maven.artifact.ArtifactScopeEnum;
import org.codehaus.plexus.PlexusContainer;
import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
@ -44,24 +63,28 @@ public class MetadataResolutionResult
public void initTreeProcessing( PlexusContainer plexus )
throws ComponentLookupException
{
classpathTransformation = (ClasspathTransformation)plexus.lookup(ClasspathTransformation.class);
conflictResolver = (GraphConflictResolver)plexus.lookup(GraphConflictResolver.class);
classpathTransformation = (ClasspathTransformation) plexus.lookup( ClasspathTransformation.class );
conflictResolver = (GraphConflictResolver) plexus.lookup( GraphConflictResolver.class );
}
//----------------------------------------------------------------------------
public MetadataGraph getGraph()
throws MetadataResolutionException
{
return treeRoot == null ? null : new MetadataGraph(treeRoot);
return treeRoot == null ? null : new MetadataGraph( treeRoot );
}
//----------------------------------------------------------------------------
public MetadataGraph getGraph( ArtifactScopeEnum scope )
throws MetadataResolutionException, GraphConflictResolutionException
{
if( treeRoot == null )
return null;
if ( treeRoot == null )
{
return null;
}
if( conflictResolver == null )
return null;
if ( conflictResolver == null )
{
return null;
}
return conflictResolver.resolveConflicts( getGraph(), scope );
}
@ -69,43 +92,65 @@ public class MetadataResolutionResult
public MetadataGraph getGraph( MetadataResolutionRequestTypeEnum requestType )
throws MetadataResolutionException, GraphConflictResolutionException
{
if( requestType == null )
return null;
if ( requestType == null )
{
return null;
}
if( treeRoot == null )
return null;
if ( treeRoot == null )
{
return null;
}
if( conflictResolver == 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;
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
{
if( classpathTransformation == null )
return null;
if ( classpathTransformation == null )
{
return null;
}
MetadataGraph dirtyGraph = getGraph();
if( dirtyGraph == null )
return null;
if ( dirtyGraph == null )
{
return null;
}
return classpathTransformation.transform( dirtyGraph, scope, false );
}
@ -114,9 +159,11 @@ public class MetadataResolutionResult
public MetadataTreeNode getClasspathTree( ArtifactScopeEnum scope )
throws MetadataGraphTransformationException, MetadataResolutionException
{
ClasspathContainer cpc = getClasspath(scope);
if( cpc == null )
return null;
ClasspathContainer cpc = getClasspath( scope );
if ( cpc == null )
{
return null;
}
return cpc.getClasspathAsTree();
}

4
maven-compat/src/main/mdo/metadata.mdo
View File

@ -147,8 +147,8 @@ under the License.
versioning.setLastUpdated( v.getLastUpdated() );
}
if ( v.getLastUpdated() == null || v.getLastUpdated().length() == 0 ||
versioning.getLastUpdated().compareTo( v.getLastUpdated() ) >= 0 )
if ( v.getLastUpdated() == null || v.getLastUpdated().length() == 0
|| versioning.getLastUpdated().compareTo( v.getLastUpdated() ) >= 0 )
{
changed = true;
v.setLastUpdated( versioning.getLastUpdated() );

122
maven-compat/src/test/java/org/apache/maven/repository/MirrorProcessorTest.java
View File

@ -1,12 +1,30 @@
package org.apache.maven.repository;
/*
* 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.util.Arrays;
import java.util.List;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.repository.ArtifactRepositoryFactory;
import org.apache.maven.artifact.repository.DefaultArtifactRepository;
import org.apache.maven.artifact.repository.layout.DefaultRepositoryLayout;
import org.codehaus.plexus.PlexusTestCase;
@ -25,9 +43,11 @@ public class MirrorProcessorTest
}
@Override
protected void tearDown() throws Exception {
mirrorBuilder = null;
super.tearDown();
protected void tearDown()
throws Exception
{
mirrorBuilder = null;
super.tearDown();
}
public void testAddMirrorWithNullRepositoryId()
@ -37,24 +57,24 @@ public class MirrorProcessorTest
public void testExternalURL()
{
assertTrue( mirrorBuilder.isExternalRepo( getRepo( "foo", "http://somehost" ) ) );
assertTrue( mirrorBuilder.isExternalRepo( getRepo( "foo", "http://somehost:9090/somepath" ) ) );
assertTrue( mirrorBuilder.isExternalRepo( getRepo( "foo", "ftp://somehost" ) ) );
assertTrue( mirrorBuilder.isExternalRepo( getRepo( "foo", "http://192.168.101.1" ) ) );
assertTrue( mirrorBuilder.isExternalRepo( getRepo( "foo", "http://" ) ) );
assertTrue( DefaultMirrorBuilder.isExternalRepo( getRepo( "foo", "http://somehost" ) ) );
assertTrue( DefaultMirrorBuilder.isExternalRepo( getRepo( "foo", "http://somehost:9090/somepath" ) ) );
assertTrue( DefaultMirrorBuilder.isExternalRepo( getRepo( "foo", "ftp://somehost" ) ) );
assertTrue( DefaultMirrorBuilder.isExternalRepo( getRepo( "foo", "http://192.168.101.1" ) ) );
assertTrue( DefaultMirrorBuilder.isExternalRepo( getRepo( "foo", "http://" ) ) );
// these are local
assertFalse( mirrorBuilder.isExternalRepo( getRepo( "foo", "http://localhost:8080" ) ) );
assertFalse( mirrorBuilder.isExternalRepo( getRepo( "foo", "http://127.0.0.1:9090" ) ) );
assertFalse( mirrorBuilder.isExternalRepo( getRepo( "foo", "file://localhost/somepath" ) ) );
assertFalse( mirrorBuilder.isExternalRepo( getRepo( "foo", "file://localhost/D:/somepath" ) ) );
assertFalse( mirrorBuilder.isExternalRepo( getRepo( "foo", "http://localhost" ) ) );
assertFalse( mirrorBuilder.isExternalRepo( getRepo( "foo", "http://127.0.0.1" ) ) );
assertFalse( mirrorBuilder.isExternalRepo( getRepo( "foo", "file:///somepath" ) ) );
assertFalse( mirrorBuilder.isExternalRepo( getRepo( "foo", "file://D:/somepath" ) ) );
assertFalse( DefaultMirrorBuilder.isExternalRepo( getRepo( "foo", "http://localhost:8080" ) ) );
assertFalse( DefaultMirrorBuilder.isExternalRepo( getRepo( "foo", "http://127.0.0.1:9090" ) ) );
assertFalse( DefaultMirrorBuilder.isExternalRepo( getRepo( "foo", "file://localhost/somepath" ) ) );
assertFalse( DefaultMirrorBuilder.isExternalRepo( getRepo( "foo", "file://localhost/D:/somepath" ) ) );
assertFalse( DefaultMirrorBuilder.isExternalRepo( getRepo( "foo", "http://localhost" ) ) );
assertFalse( DefaultMirrorBuilder.isExternalRepo( getRepo( "foo", "http://127.0.0.1" ) ) );
assertFalse( DefaultMirrorBuilder.isExternalRepo( getRepo( "foo", "file:///somepath" ) ) );
assertFalse( DefaultMirrorBuilder.isExternalRepo( getRepo( "foo", "file://D:/somepath" ) ) );
// not a proper url so returns false;
assertFalse( mirrorBuilder.isExternalRepo( getRepo( "foo", "192.168.101.1" ) ) );
assertFalse( mirrorBuilder.isExternalRepo( getRepo( "foo", "" ) ) );
assertFalse( DefaultMirrorBuilder.isExternalRepo( getRepo( "foo", "192.168.101.1" ) ) );
assertFalse( DefaultMirrorBuilder.isExternalRepo( getRepo( "foo", "" ) ) );
}
public void testMirrorLookup()
@ -129,52 +149,52 @@ public class MirrorProcessorTest
public void testPatterns()
{
assertTrue( mirrorBuilder.matchPattern( getRepo( "a" ), "*" ) );
assertTrue( mirrorBuilder.matchPattern( getRepo( "a" ), "*," ) );
assertTrue( mirrorBuilder.matchPattern( getRepo( "a" ), ",*," ) );
assertTrue( mirrorBuilder.matchPattern( getRepo( "a" ), "*," ) );
assertTrue( DefaultMirrorBuilder.matchPattern( getRepo( "a" ), "*" ) );
assertTrue( DefaultMirrorBuilder.matchPattern( getRepo( "a" ), "*," ) );
assertTrue( DefaultMirrorBuilder.matchPattern( getRepo( "a" ), ",*," ) );
assertTrue( DefaultMirrorBuilder.matchPattern( getRepo( "a" ), "*," ) );
assertTrue( mirrorBuilder.matchPattern( getRepo( "a" ), "a" ) );
assertTrue( mirrorBuilder.matchPattern( getRepo( "a" ), "a," ) );
assertTrue( mirrorBuilder.matchPattern( getRepo( "a" ), ",a," ) );
assertTrue( mirrorBuilder.matchPattern( getRepo( "a" ), "a," ) );
assertTrue( DefaultMirrorBuilder.matchPattern( getRepo( "a" ), "a" ) );
assertTrue( DefaultMirrorBuilder.matchPattern( getRepo( "a" ), "a," ) );
assertTrue( DefaultMirrorBuilder.matchPattern( getRepo( "a" ), ",a," ) );
assertTrue( DefaultMirrorBuilder.matchPattern( getRepo( "a" ), "a," ) );
assertFalse( mirrorBuilder.matchPattern( getRepo( "b" ), "a" ) );
assertFalse( mirrorBuilder.matchPattern( getRepo( "b" ), "a," ) );
assertFalse( mirrorBuilder.matchPattern( getRepo( "b" ), ",a" ) );
assertFalse( mirrorBuilder.matchPattern( getRepo( "b" ), ",a," ) );
assertFalse( DefaultMirrorBuilder.matchPattern( getRepo( "b" ), "a" ) );
assertFalse( DefaultMirrorBuilder.matchPattern( getRepo( "b" ), "a," ) );
assertFalse( DefaultMirrorBuilder.matchPattern( getRepo( "b" ), ",a" ) );
assertFalse( DefaultMirrorBuilder.matchPattern( getRepo( "b" ), ",a," ) );
assertTrue( mirrorBuilder.matchPattern( getRepo( "a" ), "a,b" ) );
assertTrue( mirrorBuilder.matchPattern( getRepo( "b" ), "a,b" ) );
assertTrue( DefaultMirrorBuilder.matchPattern( getRepo( "a" ), "a,b" ) );
assertTrue( DefaultMirrorBuilder.matchPattern( getRepo( "b" ), "a,b" ) );
assertFalse( mirrorBuilder.matchPattern( getRepo( "c" ), "a,b" ) );
assertFalse( DefaultMirrorBuilder.matchPattern( getRepo( "c" ), "a,b" ) );
assertTrue( mirrorBuilder.matchPattern( getRepo( "a" ), "*" ) );
assertTrue( mirrorBuilder.matchPattern( getRepo( "a" ), "*,b" ) );
assertTrue( mirrorBuilder.matchPattern( getRepo( "a" ), "*,!b" ) );
assertTrue( DefaultMirrorBuilder.matchPattern( getRepo( "a" ), "*" ) );
assertTrue( DefaultMirrorBuilder.matchPattern( getRepo( "a" ), "*,b" ) );
assertTrue( DefaultMirrorBuilder.matchPattern( getRepo( "a" ), "*,!b" ) );
assertFalse( mirrorBuilder.matchPattern( getRepo( "a" ), "*,!a" ) );
assertFalse( mirrorBuilder.matchPattern( getRepo( "a" ), "!a,*" ) );
assertFalse( DefaultMirrorBuilder.matchPattern( getRepo( "a" ), "*,!a" ) );
assertFalse( DefaultMirrorBuilder.matchPattern( getRepo( "a" ), "!a,*" ) );
assertTrue( mirrorBuilder.matchPattern( getRepo( "c" ), "*,!a" ) );
assertTrue( mirrorBuilder.matchPattern( getRepo( "c" ), "!a,*" ) );
assertTrue( DefaultMirrorBuilder.matchPattern( getRepo( "c" ), "*,!a" ) );
assertTrue( DefaultMirrorBuilder.matchPattern( getRepo( "c" ), "!a,*" ) );
assertFalse( mirrorBuilder.matchPattern( getRepo( "c" ), "!a,!c" ) );
assertFalse( mirrorBuilder.matchPattern( getRepo( "d" ), "!a,!c*" ) );
assertFalse( DefaultMirrorBuilder.matchPattern( getRepo( "c" ), "!a,!c" ) );
assertFalse( DefaultMirrorBuilder.matchPattern( getRepo( "d" ), "!a,!c*" ) );
}
public void testPatternsWithExternal()
{
assertTrue( mirrorBuilder.matchPattern( getRepo( "a", "http://localhost" ), "*" ) );
assertFalse( mirrorBuilder.matchPattern( getRepo( "a", "http://localhost" ), "external:*" ) );
assertTrue( DefaultMirrorBuilder.matchPattern( getRepo( "a", "http://localhost" ), "*" ) );
assertFalse( DefaultMirrorBuilder.matchPattern( getRepo( "a", "http://localhost" ), "external:*" ) );
assertTrue( mirrorBuilder.matchPattern( getRepo( "a", "http://localhost" ), "external:*,a" ) );
assertFalse( mirrorBuilder.matchPattern( getRepo( "a", "http://localhost" ), "external:*,!a" ) );
assertTrue( mirrorBuilder.matchPattern( getRepo( "a", "http://localhost" ), "a,external:*" ) );
assertFalse( mirrorBuilder.matchPattern( getRepo( "a", "http://localhost" ), "!a,external:*" ) );
assertTrue( DefaultMirrorBuilder.matchPattern( getRepo( "a", "http://localhost" ), "external:*,a" ) );
assertFalse( DefaultMirrorBuilder.matchPattern( getRepo( "a", "http://localhost" ), "external:*,!a" ) );
assertTrue( DefaultMirrorBuilder.matchPattern( getRepo( "a", "http://localhost" ), "a,external:*" ) );
assertFalse( DefaultMirrorBuilder.matchPattern( getRepo( "a", "http://localhost" ), "!a,external:*" ) );
assertFalse( mirrorBuilder.matchPattern( getRepo( "c", "http://localhost" ), "!a,external:*" ) );
assertTrue( mirrorBuilder.matchPattern( getRepo( "c", "http://somehost" ), "!a,external:*" ) );
assertFalse( DefaultMirrorBuilder.matchPattern( getRepo( "c", "http://localhost" ), "!a,external:*" ) );
assertTrue( DefaultMirrorBuilder.matchPattern( getRepo( "c", "http://somehost" ), "!a,external:*" ) );
}
public void testMirrorProperUrlAndProtocolAndBasedir()

51
maven-compat/src/test/java/org/apache/maven/repository/legacy/DefaultWagonManagerTest.java
View File

@ -34,10 +34,6 @@ import org.apache.maven.artifact.repository.ArtifactRepositoryPolicy;
import org.apache.maven.artifact.repository.layout.ArtifactRepositoryLayout;
import org.apache.maven.artifact.repository.layout.DefaultRepositoryLayout;
import org.apache.maven.artifact.versioning.VersionRange;
import org.apache.maven.repository.legacy.ChecksumFailedException;
import org.apache.maven.repository.legacy.DefaultWagonManager;
import org.apache.maven.repository.legacy.UpdateCheckManager;
import org.apache.maven.repository.legacy.WagonManager;
import org.apache.maven.wagon.ResourceDoesNotExistException;
import org.apache.maven.wagon.TransferFailedException;
import org.apache.maven.wagon.UnsupportedProtocolException;
@ -76,33 +72,44 @@ public class DefaultWagonManagerTest
}
@Override
protected void tearDown() throws Exception {
wagonManager = null;
artifactFactory = null;
super.tearDown();
protected void tearDown()
throws Exception
{
wagonManager = null;
artifactFactory = null;
super.tearDown();
}
public void testUnnecessaryRepositoryLookup() throws Exception {
public void testUnnecessaryRepositoryLookup()
throws Exception
{
Artifact artifact = createTestPomArtifact( "target/test-data/get-missing-pom" );
List<ArtifactRepository> repos = new ArrayList<ArtifactRepository>();
repos.add(artifactRepositoryFactory.createArtifactRepository( "repo1", "string://url1", new ArtifactRepositoryLayoutStub(), null, null ));
repos.add(artifactRepositoryFactory.createArtifactRepository( "repo2", "string://url2", new ArtifactRepositoryLayoutStub(), null, null ));
repos.add( artifactRepositoryFactory.createArtifactRepository( "repo1", "string://url1",
new ArtifactRepositoryLayoutStub(), null, null ) );
repos.add( artifactRepositoryFactory.createArtifactRepository( "repo2", "string://url2",
new ArtifactRepositoryLayoutStub(), null, null ) );
StringWagon wagon = (StringWagon) wagonManager.getWagon( "string" );
wagon.addExpectedContent( repos.get(0).getLayout().pathOf( artifact ), "expected" );
wagon.addExpectedContent( repos.get(1).getLayout().pathOf( artifact ), "expected" );
wagon.addExpectedContent( repos.get( 0 ).getLayout().pathOf( artifact ), "expected" );
wagon.addExpectedContent( repos.get( 1 ).getLayout().pathOf( artifact ), "expected" );
class TransferListener
extends AbstractTransferListener
{
public List<TransferEvent> events = new ArrayList<TransferEvent>();
@Override
public void transferInitiated( TransferEvent transferEvent )
{
events.add( transferEvent );
}
}
class TransferListener extends AbstractTransferListener {
public List<TransferEvent> events = new ArrayList<TransferEvent>();
@Override
public void transferInitiated(TransferEvent transferEvent) {
events.add(transferEvent);
}
};
TransferListener listener = new TransferListener();
wagonManager.getArtifact( artifact, repos, listener );
assertEquals(1, listener.events.size());
assertEquals( 1, listener.events.size() );
}
public void testGetPomExistsLocallyForced()
@ -311,7 +318,7 @@ public class DefaultWagonManagerTest
/* getArtifact */
assertFalse( "Transfer listener is registered before test",
wagon.getTransferEventSupport().hasTransferListener( transferListener ) );
wagonManager.getArtifact( artifact, repo, transferListener);
wagonManager.getArtifact( artifact, repo, transferListener );
assertFalse( "Transfer listener still registered after getArtifact",
wagon.getTransferEventSupport().hasTransferListener( transferListener ) );

11
maven-compat/src/test/java/org/apache/maven/repository/legacy/resolver/DefaultArtifactCollectorTest.java
View File

@ -48,7 +48,6 @@ import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException
import org.apache.maven.artifact.versioning.OverConstrainedVersionException;
import org.apache.maven.artifact.versioning.VersionRange;
import org.apache.maven.repository.legacy.metadata.MetadataResolutionRequest;
import org.apache.maven.repository.legacy.resolver.LegacyArtifactCollector;
import org.codehaus.plexus.PlexusTestCase;
/**
@ -84,10 +83,12 @@ public class DefaultArtifactCollectorTest
}
@Override
protected void tearDown() throws Exception {
artifactCollector = null;
artifactFactory = null;
super.tearDown();
protected void tearDown()
throws Exception
{
artifactCollector = null;
artifactFactory = null;
super.tearDown();
}
// works, but we don't fail on cycles presently