package org.apache.maven.plugins.enforcer;
/*
* 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.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.ArtifactCollector;
import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
import org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
import org.apache.maven.artifact.versioning.OverConstrainedVersionException;
import org.apache.maven.enforcer.rule.api.EnforcerRuleException;
import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper;
import org.apache.maven.plugin.logging.Log;
import org.apache.maven.project.MavenProject;
import org.apache.maven.shared.dependency.tree.DependencyNode;
import org.apache.maven.shared.dependency.tree.DependencyTreeBuilder;
import org.apache.maven.shared.dependency.tree.DependencyTreeBuilderException;
import org.apache.maven.shared.dependency.tree.traversal.DependencyNodeVisitor;
import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
import org.codehaus.plexus.i18n.I18N;
/**
* Rule to enforce that the resolved dependency is also the most recent one of all transitive dependencies.
*
* @author Geoffrey De Smet
* @since 1.1
*/
public class RequireUpperBoundDeps
extends AbstractNonCacheableEnforcerRule
{
private static Log log;
private static I18N i18n;
/**
* Uses the {@link EnforcerRuleHelper} to populate the values of the
* {@link DependencyTreeBuilder#buildDependencyTree(MavenProject, ArtifactRepository, ArtifactFactory, ArtifactMetadataSource, ArtifactFilter, ArtifactCollector)}
* factory method. <br/>
* This method simply exists to hide all the ugly lookup that the {@link EnforcerRuleHelper} has to do.
*
* @param helper
* @return a Dependency Node which is the root of the project's dependency tree
* @throws EnforcerRuleException when the build should fail
*/
private DependencyNode getNode( EnforcerRuleHelper helper )
throws EnforcerRuleException
{
try
{
MavenProject project = (MavenProject) helper.evaluate( "${project}" );
DependencyTreeBuilder dependencyTreeBuilder =
(DependencyTreeBuilder) helper.getComponent( DependencyTreeBuilder.class );
ArtifactRepository repository = (ArtifactRepository) helper.evaluate( "${localRepository}" );
ArtifactFactory factory = (ArtifactFactory) helper.getComponent( ArtifactFactory.class );
ArtifactMetadataSource metadataSource =
(ArtifactMetadataSource) helper.getComponent( ArtifactMetadataSource.class );
ArtifactCollector collector = (ArtifactCollector) helper.getComponent( ArtifactCollector.class );
ArtifactFilter filter = null; // we need to evaluate all scopes
DependencyNode node =
dependencyTreeBuilder.buildDependencyTree( project, repository, factory, metadataSource, filter,
collector );
return node;
}
catch ( ExpressionEvaluationException e )
{
throw new EnforcerRuleException( "Unable to lookup an expression " + e.getLocalizedMessage(), e );
}
catch ( ComponentLookupException e )
{
throw new EnforcerRuleException( "Unable to lookup a component " + e.getLocalizedMessage(), e );
}
catch ( DependencyTreeBuilderException e )
{
throw new EnforcerRuleException( "Could not build dependency tree " + e.getLocalizedMessage(), e );
}
}
public void execute( EnforcerRuleHelper helper )
throws EnforcerRuleException
{
if ( log == null )
{
log = helper.getLog();
}
try
{
if ( i18n == null )
{
i18n = (I18N) helper.getComponent( I18N.class );
}
DependencyNode node = getNode( helper );
RequireUpperBoundDepsVisitor visitor = new RequireUpperBoundDepsVisitor();
node.accept( visitor );
List<String> errorMessages = buildErrorMessages( visitor.getConflicts() );
if ( errorMessages.size() > 0 )
{
throw new EnforcerRuleException( "Failed while enforcing RequireUpperBoundDeps. The error(s) are "
+ errorMessages );
}
}
catch ( ComponentLookupException e )
{
throw new EnforcerRuleException( "Unable to lookup a component " + e.getLocalizedMessage(), e );
}
catch ( Exception e )
{
throw new EnforcerRuleException( e.getLocalizedMessage(), e );
}
}
private List<String> buildErrorMessages( List<List<DependencyNode>> conflicts )
{
List<String> errorMessages = new ArrayList<String>( conflicts.size() );
for ( List<DependencyNode> conflict : conflicts )
{
errorMessages.add( buildErrorMessage( conflict ) );
}
return errorMessages;
}
private String buildErrorMessage( List<DependencyNode> conflict )
{
StringBuilder errorMessage = new StringBuilder();
errorMessage.append( "\nRequire upper bound dependencies error for "
+ getFullArtifactName( conflict.get( 0 ).getArtifact() ) + " paths to dependency are:\n" );
if ( conflict.size() > 0 )
{
errorMessage.append( buildTreeString( conflict.get( 0 ) ) );
}
for ( DependencyNode node : conflict.subList( 1, conflict.size() ) )
{
errorMessage.append( "and\n" );
errorMessage.append( buildTreeString( node ) );
}
return errorMessage.toString();
}
private StringBuilder buildTreeString( DependencyNode node )
{
List<String> loc = new ArrayList<String>();
DependencyNode currentNode = node;
while ( currentNode != null )
{
loc.add( getFullArtifactName( currentNode.getArtifact() ) );
currentNode = currentNode.getParent();
}
Collections.reverse( loc );
StringBuilder builder = new StringBuilder();
for ( int i = 0; i < loc.size(); i++ )
{
for ( int j = 0; j < i; j++ )
{
builder.append( " " );
}
builder.append( "+-" ).append( loc.get( i ) );
builder.append( "\n" );
}
return builder;
}
private String getFullArtifactName( Artifact artifact )
{
return artifact.getGroupId() + ":" + artifact.getArtifactId() + ":" + artifact.getVersion();
}
private static class RequireUpperBoundDepsVisitor
implements DependencyNodeVisitor
{
private Map<String, List<DependencyNodeHopCountPair>> keyToPairsMap =
new LinkedHashMap<String, List<DependencyNodeHopCountPair>>();
public boolean visit( DependencyNode node )
{
DependencyNodeHopCountPair pair = new DependencyNodeHopCountPair( node );
String key = pair.constructKey();
List<DependencyNodeHopCountPair> pairs = keyToPairsMap.get( key );
if ( pairs == null )
{
pairs = new ArrayList<DependencyNodeHopCountPair>();
keyToPairsMap.put( key, pairs );
}
pairs.add( pair );
Collections.sort( pairs );
return true;
}
public boolean endVisit( DependencyNode node )
{
return true;
}
public List<List<DependencyNode>> getConflicts()
{
List<List<DependencyNode>> output = new ArrayList<List<DependencyNode>>();
for ( List<DependencyNodeHopCountPair> pairs : keyToPairsMap.values() )
{
if ( containsConflicts( pairs ) )
{
List<DependencyNode> outputSubList = new ArrayList<DependencyNode>( pairs.size() );
for ( DependencyNodeHopCountPair pair : pairs )
{
outputSubList.add( pair.getNode() );
}
output.add( outputSubList );
}
}
return output;
}
@SuppressWarnings( "unchecked" )
private boolean containsConflicts( List<DependencyNodeHopCountPair> pairs )
{
ArtifactVersion resolvedVersion = pairs.get( 0 ).extractArtifactVersion();
for ( DependencyNodeHopCountPair pair : pairs )
{
ArtifactVersion version = pair.extractArtifactVersion();
if ( resolvedVersion.compareTo( version ) < 0 )
{
return true;
}
}
return false;
}
}
private static class DependencyNodeHopCountPair
implements Comparable<DependencyNodeHopCountPair>
{
private DependencyNode node;
private int hopCount;
private DependencyNodeHopCountPair( DependencyNode node )
{
this.node = node;
countHops();
}
private void countHops()
{
hopCount = 0;
DependencyNode parent = node.getParent();
while ( parent != null )
{
hopCount++;
parent = parent.getParent();
}
}
private String constructKey()
{
Artifact artifact = node.getArtifact();
return artifact.getGroupId() + ":" + artifact.getArtifactId();
}
public DependencyNode getNode()
{
return node;
}
private ArtifactVersion extractArtifactVersion()
{
Artifact artifact = node.getArtifact();
String version = artifact.getVersion();
if ( version != null )
{
return new DefaultArtifactVersion( version );
}
try
{
return artifact.getSelectedVersion();
}
catch ( OverConstrainedVersionException e )
{
throw new RuntimeException( "Version ranges problem with " + node.getArtifact(), e );
}
}
public int getHopCount()
{
return hopCount;
}
public int compareTo( DependencyNodeHopCountPair other )
{
return Integer.valueOf( hopCount ).compareTo( Integer.valueOf( other.getHopCount() ) );
}
}
}