org.apache.maven.plugins.dependency.analyze.AbstractAnalyzeMojo Maven / Gradle / Ivy
package org.apache.maven.plugins.dependency.analyze;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import java.io.File;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import org.apache.commons.lang3.StringUtils;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.project.MavenProject;
import org.apache.maven.shared.artifact.filter.StrictPatternExcludesArtifactFilter;
import org.apache.maven.shared.dependency.analyzer.ProjectDependencyAnalysis;
import org.apache.maven.shared.dependency.analyzer.ProjectDependencyAnalyzer;
import org.apache.maven.shared.dependency.analyzer.ProjectDependencyAnalyzerException;
import org.codehaus.plexus.PlexusConstants;
import org.codehaus.plexus.PlexusContainer;
import org.codehaus.plexus.context.Context;
import org.codehaus.plexus.context.ContextException;
import org.codehaus.plexus.personality.plexus.lifecycle.phase.Contextualizable;
import org.codehaus.plexus.util.xml.PrettyPrintXMLWriter;
/**
* Analyzes the dependencies of this project and determines which are: used and declared; used and undeclared; unused
* and declared; compile scoped but only used in tests.
*
* @author Mark Hobson
* @since 2.0-alpha-5
*/
public abstract class AbstractAnalyzeMojo
extends AbstractMojo
implements Contextualizable
{
// fields -----------------------------------------------------------------
/**
* The plexus context to look-up the right {@link ProjectDependencyAnalyzer} implementation depending on the mojo
* configuration.
*/
private Context context;
/**
* The Maven project to analyze.
*/
@Parameter( defaultValue = "${project}", readonly = true, required = true )
private MavenProject project;
/**
* Specify the project dependency analyzer to use (plexus component role-hint). By default,
* maven-dependency-analyzer is used. To use this, you must declare
* a dependency for this plugin that contains the code for the analyzer. The analyzer must have a declared Plexus
* role name, and you specify the role name here.
*
* @since 2.2
*/
@Parameter( property = "analyzer", defaultValue = "default" )
private String analyzer;
/**
* Whether to fail the build if a dependency warning is found.
*/
@Parameter( property = "failOnWarning", defaultValue = "false" )
private boolean failOnWarning;
/**
* Output used dependencies.
*/
@Parameter( property = "verbose", defaultValue = "false" )
private boolean verbose;
/**
* Ignore Runtime/Provided/Test/System scopes for unused dependency analysis.
*/
@Parameter( property = "ignoreNonCompile", defaultValue = "false" )
private boolean ignoreNonCompile;
/**
* Ignore Runtime scope for unused dependency analysis.
*/
@Parameter( property = "ignoreUnusedRuntime", defaultValue = "false" )
private boolean ignoreUnusedRuntime;
/**
* Output the xml for the missing dependencies (used but not declared).
*
* @since 2.0-alpha-5
*/
@Parameter( property = "outputXML", defaultValue = "false" )
private boolean outputXML;
/**
* Output scriptable values for the missing dependencies (used but not declared).
*
* @since 2.0-alpha-5
*/
@Parameter( property = "scriptableOutput", defaultValue = "false" )
private boolean scriptableOutput;
/**
* Flag to use for scriptable output.
*
* @since 2.0-alpha-5
*/
@Parameter( property = "scriptableFlag", defaultValue = "$$$%%%" )
private String scriptableFlag;
/**
* Flag to use for scriptable output
*
* @since 2.0-alpha-5
*/
@Parameter( defaultValue = "${basedir}", readonly = true )
private File baseDir;
/**
* Target folder
*
* @since 2.0-alpha-5
*/
@Parameter( defaultValue = "${project.build.directory}", readonly = true )
private File outputDirectory;
/**
* Force dependencies as used, to override incomplete result caused by bytecode-level analysis. Dependency format is
* groupId:artifactId.
*
* @since 2.6
*/
@Parameter
private String[] usedDependencies;
/**
* Skip plugin execution completely.
*
* @since 2.7
*/
@Parameter( property = "mdep.analyze.skip", defaultValue = "false" )
private boolean skip;
/**
* List of dependencies that will be ignored. Any dependency on this list will be excluded from the "declared but
* unused" and the "used but undeclared" list. The filter syntax is:
*
*
* [groupId]:[artifactId]:[type]:[version]
*
*
* where each pattern segment is optional and supports full and partial * wildcards. An empty pattern
* segment is treated as an implicit wildcard. *
*
* For example, org.apache.* will match all artifacts whose group id starts with
* org.apache., and :::*-SNAPSHOT will match all snapshot artifacts.
*
*
* @since 2.10
*/
@Parameter
private String[] ignoredDependencies = new String[0];
/**
* List of dependencies that will be ignored if they are used but undeclared. The filter syntax is:
*
*
* [groupId]:[artifactId]:[type]:[version]
*
*
* where each pattern segment is optional and supports full and partial * wildcards. An empty pattern
* segment is treated as an implicit wildcard. *
*
* For example, org.apache.* will match all artifacts whose group id starts with
* org.apache., and :::*-SNAPSHOT will match all snapshot artifacts.
*
*
* @since 2.10
*/
@Parameter
private String[] ignoredUsedUndeclaredDependencies = new String[0];
/**
* List of dependencies that will be ignored if they are declared but unused. The filter syntax is:
*
*
* [groupId]:[artifactId]:[type]:[version]
*
*
* where each pattern segment is optional and supports full and partial * wildcards. An empty pattern
* segment is treated as an implicit wildcard. *
*
* For example, org.apache.* will match all artifacts whose group id starts with
* org.apache., and :::*-SNAPSHOT will match all snapshot artifacts.
*
*
* @since 2.10
*/
@Parameter
private String[] ignoredUnusedDeclaredDependencies = new String[0];
// Mojo methods -----------------------------------------------------------
/*
* @see org.apache.maven.plugin.Mojo#execute()
*/
@Override
public void execute()
throws MojoExecutionException, MojoFailureException
{
if ( isSkip() )
{
getLog().info( "Skipping plugin execution" );
return;
}
if ( "pom".equals( project.getPackaging() ) )
{
getLog().info( "Skipping pom project" );
return;
}
if ( outputDirectory == null || !outputDirectory.exists() )
{
getLog().info( "Skipping project with no build directory" );
return;
}
boolean warning = checkDependencies();
if ( warning && failOnWarning )
{
throw new MojoExecutionException( "Dependency problems found" );
}
}
/**
* @return {@link ProjectDependencyAnalyzer}
* @throws MojoExecutionException in case of an error.
*/
protected ProjectDependencyAnalyzer createProjectDependencyAnalyzer()
throws MojoExecutionException
{
final String role = ProjectDependencyAnalyzer.ROLE;
final String roleHint = analyzer;
try
{
final PlexusContainer container = (PlexusContainer) context.get( PlexusConstants.PLEXUS_KEY );
return (ProjectDependencyAnalyzer) container.lookup( role, roleHint );
}
catch ( Exception exception )
{
throw new MojoExecutionException( "Failed to instantiate ProjectDependencyAnalyser with role " + role
+ " / role-hint " + roleHint, exception );
}
}
@Override
public void contextualize( Context theContext )
throws ContextException
{
this.context = theContext;
}
/**
* @return {@link #skip}
*/
protected final boolean isSkip()
{
return skip;
}
// private methods --------------------------------------------------------
private boolean checkDependencies()
throws MojoExecutionException
{
ProjectDependencyAnalysis analysis;
try
{
analysis = createProjectDependencyAnalyzer().analyze( project );
if ( usedDependencies != null )
{
analysis = analysis.forceDeclaredDependenciesUsage( usedDependencies );
}
}
catch ( ProjectDependencyAnalyzerException exception )
{
throw new MojoExecutionException( "Cannot analyze dependencies", exception );
}
if ( ignoreNonCompile )
{
analysis = analysis.ignoreNonCompile();
}
Set usedDeclared = new LinkedHashSet<>( analysis.getUsedDeclaredArtifacts() );
Set usedUndeclared = new LinkedHashSet<>( analysis.getUsedUndeclaredArtifacts() );
Set unusedDeclared = new LinkedHashSet<>( analysis.getUnusedDeclaredArtifacts() );
Set testArtifactsWithNonTestScope = new LinkedHashSet<>(
analysis.getTestArtifactsWithNonTestScope() );
Set ignoredUsedUndeclared = new LinkedHashSet<>();
Set ignoredUnusedDeclared = new LinkedHashSet<>();
if ( ignoreUnusedRuntime )
{
filterArtifactsByScope( unusedDeclared, Artifact.SCOPE_RUNTIME );
}
ignoredUsedUndeclared.addAll( filterDependencies( usedUndeclared, ignoredDependencies ) );
ignoredUsedUndeclared.addAll( filterDependencies( usedUndeclared, ignoredUsedUndeclaredDependencies ) );
ignoredUnusedDeclared.addAll( filterDependencies( unusedDeclared, ignoredDependencies ) );
ignoredUnusedDeclared.addAll( filterDependencies( unusedDeclared, ignoredUnusedDeclaredDependencies ) );
boolean reported = false;
boolean warning = false;
if ( verbose && !usedDeclared.isEmpty() )
{
getLog().info( "Used declared dependencies found:" );
logArtifacts( analysis.getUsedDeclaredArtifacts(), false );
reported = true;
}
if ( !usedUndeclared.isEmpty() )
{
getLog().warn( "Used undeclared dependencies found:" );
logArtifacts( usedUndeclared, true );
reported = true;
warning = true;
}
if ( !unusedDeclared.isEmpty() )
{
getLog().warn( "Unused declared dependencies found:" );
logArtifacts( unusedDeclared, true );
reported = true;
warning = true;
}
if ( !testArtifactsWithNonTestScope.isEmpty() )
{
getLog().warn( "Non-test scoped test only dependencies found:" );
logArtifacts( testArtifactsWithNonTestScope, true );
reported = true;
warning = true;
}
if ( verbose && !ignoredUsedUndeclared.isEmpty() )
{
getLog().info( "Ignored used undeclared dependencies:" );
logArtifacts( ignoredUsedUndeclared, false );
reported = true;
}
if ( verbose && !ignoredUnusedDeclared.isEmpty() )
{
getLog().info( "Ignored unused declared dependencies:" );
logArtifacts( ignoredUnusedDeclared, false );
reported = true;
}
if ( outputXML )
{
writeDependencyXML( usedUndeclared );
}
if ( scriptableOutput )
{
writeScriptableOutput( usedUndeclared );
}
if ( !reported )
{
getLog().info( "No dependency problems found" );
}
return warning;
}
private void filterArtifactsByScope( Set artifacts, String scope )
{
for ( Iterator iterator = artifacts.iterator(); iterator.hasNext(); )
{
Artifact artifact = iterator.next();
if ( artifact.getScope().equals( scope ) )
{
iterator.remove();
}
}
}
private void logArtifacts( Set artifacts, boolean warn )
{
if ( artifacts.isEmpty() )
{
getLog().info( " None" );
}
else
{
for ( Artifact artifact : artifacts )
{
// called because artifact will set the version to -SNAPSHOT only if I do this. MNG-2961
artifact.isSnapshot();
if ( warn )
{
getLog().warn( " " + artifact );
}
else
{
getLog().info( " " + artifact );
}
}
}
}
private void writeDependencyXML( Set artifacts )
{
if ( !artifacts.isEmpty() )
{
getLog().info( "Add the following to your pom to correct the missing dependencies: " );
StringWriter out = new StringWriter();
PrettyPrintXMLWriter writer = new PrettyPrintXMLWriter( out );
for ( Artifact artifact : artifacts )
{
// called because artifact will set the version to -SNAPSHOT only if I do this. MNG-2961
artifact.isSnapshot();
writer.startElement( "dependency" );
writer.startElement( "groupId" );
writer.writeText( artifact.getGroupId() );
writer.endElement();
writer.startElement( "artifactId" );
writer.writeText( artifact.getArtifactId() );
writer.endElement();
writer.startElement( "version" );
writer.writeText( artifact.getBaseVersion() );
if ( !StringUtils.isBlank( artifact.getClassifier() ) )
{
writer.startElement( "classifier" );
writer.writeText( artifact.getClassifier() );
writer.endElement();
}
writer.endElement();
if ( !Artifact.SCOPE_COMPILE.equals( artifact.getScope() ) )
{
writer.startElement( "scope" );
writer.writeText( artifact.getScope() );
writer.endElement();
}
writer.endElement();
}
getLog().info( System.lineSeparator() + out.getBuffer() );
}
}
private void writeScriptableOutput( Set artifacts )
{
if ( !artifacts.isEmpty() )
{
getLog().info( "Missing dependencies: " );
String pomFile = baseDir.getAbsolutePath() + File.separatorChar + "pom.xml";
StringBuilder buf = new StringBuilder();
for ( Artifact artifact : artifacts )
{
// called because artifact will set the version to -SNAPSHOT only if I do this. MNG-2961
artifact.isSnapshot();
//CHECKSTYLE_OFF: LineLength
buf.append( scriptableFlag )
.append( ":" )
.append( pomFile )
.append( ":" )
.append( artifact.getDependencyConflictId() )
.append( ":" )
.append( artifact.getClassifier() )
.append( ":" )
.append( artifact.getBaseVersion() )
.append( ":" )
.append( artifact.getScope() )
.append( System.lineSeparator() );
//CHECKSTYLE_ON: LineLength
}
getLog().info( System.lineSeparator() + buf );
}
}
private List filterDependencies( Set artifacts, String[] excludes )
throws MojoExecutionException
{
ArtifactFilter filter = new StrictPatternExcludesArtifactFilter( Arrays.asList( excludes ) );
List result = new ArrayList<>();
for ( Iterator it = artifacts.iterator(); it.hasNext(); )
{
Artifact artifact = it.next();
if ( !filter.include( artifact ) )
{
it.remove();
result.add( artifact );
}
}
return result;
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy