package org.apache.rat.mp;
/*
* 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.IOException;
import java.io.InputStream;
import java.io.Writer;
import java.lang.reflect.UndeclaredThrowableException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import javax.xml.transform.TransformerConfigurationException;
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.rat.Defaults;
import org.apache.rat.Report;
import org.apache.rat.ReportConfiguration;
import org.apache.rat.analysis.IHeaderMatcher;
import org.apache.rat.analysis.util.HeaderMatcherMultiplexer;
import org.apache.rat.api.RatException;
import org.apache.rat.license.ILicenseFamily;
import org.apache.rat.report.IReportable;
import org.apache.rat.report.claim.ClaimStatistic;
import org.codehaus.plexus.util.DirectoryScanner;
/**
* Abstract base class for Mojos, which are running Rat.
*/
public abstract class AbstractRatMojo extends AbstractMojo {
/**
* The Maven specific default excludes.
*/
static final List<String> MAVEN_DEFAULT_EXCLUDES = Collections
.unmodifiableList(Arrays.asList("target/**/*", //
"cobertura.ser", //
"release.properties", //
"pom.xml.releaseBackup"));
/**
* The Eclipse specific default excludes.
*/
static final List<String> ECLIPSE_DEFAULT_EXCLUDES = Collections
.unmodifiableList(Arrays.asList(".classpath",//
".project", //
".settings/**/*"));
/**
* The IDEA specific default excludes.
*/
static final List<String> IDEA_DEFAULT_EXCLUDES = Collections
.unmodifiableList(Arrays.asList(//
"*.iml", //
"*.ipr", //
"*.iws", //
".idea/**/*"));
/**
* The base directory, in which to search for files.
*
*/
@Parameter(property = "rat.basedir", defaultValue = "${basedir}", required = true)
private File basedir;
/**
* Specifies the licenses to accept. Deprecated, use {@link #licenses}
* instead.
*
* @deprecated Use {@link #licenses} instead.
*/
@Deprecated
@Parameter
private HeaderMatcherSpecification[] licenseMatchers;
/**
* Specifies the licenses to accept. By default, these are added to the
* default licenses, unless you set {@link #addDefaultLicenseMatchers} to
* true.
*
* @since 0.8
*/
@Parameter
private IHeaderMatcher[] licenses;
/**
* The set of approved license family names.
*
* @deprecated Use {@link #licenseFamilies} instead.
*/
@Deprecated
private LicenseFamilySpecification[] licenseFamilyNames;
/**
* Specifies the license families to accept.
*
* @since 0.8
*/
@Parameter
private ILicenseFamily[] licenseFamilies;
/**
* Whether to add the default list of license matchers.
*
*/
@Parameter(property = "rat.addDefaultLicenseMatchers", defaultValue = "true")
private boolean addDefaultLicenseMatchers;
/**
* Specifies files, which are included in the report. By default, all files
* are included.
*
*/
@Parameter
private String[] includes;
/**
* Specifies files, which are excluded in the report. By default, no files
* are excluded.
*
*/
@Parameter
private String[] excludes;
/**
* Whether to use the default excludes when scanning for files. The default
* excludes are:
* <ul>
* <li>meta data files for version control systems</li>
* <li>temporary files used by Maven, see <a
* href="#useMavenDefaultExcludes">useMavenDefaultExcludes</a></li>
* <li>configuration files for Eclipse, see <a
* href="#useEclipseDefaultExcludes">useEclipseDefaultExcludes</a></li>
* <li>configuration files for IDEA, see <a
* href="#useIdeaDefaultExcludes">useIdeaDefaultExcludes</a></li>
* </ul>
*/
@Parameter(property = "rat.useDefaultExcludes", defaultValue = "true")
private boolean useDefaultExcludes;
/**
* Whether to use the Maven specific default excludes when scanning for
* files. Maven specific default excludes are given by the constant
* MAVEN_DEFAULT_EXCLUDES: The <code>target</code> directory, the
* <code>cobertura.ser</code> file, and so on.
*/
@Parameter(property = "rat.useMavenDefaultExcludes", defaultValue = "true")
private boolean useMavenDefaultExcludes;
/**
* Whether to use the Eclipse specific default excludes when scanning for
* files. Eclipse specific default excludes are given by the constant
* ECLIPSE_DEFAULT_EXCLUDES: The <code>.classpath</code> and
* <code>.project</code> files, the <code>.settings</code> directory, and so
* on.
*/
@Parameter(property = "rat.useEclipseDefaultExcludes", defaultValue = "true")
private boolean useEclipseDefaultExcludes;
/**
* Whether to use the IDEA specific default excludes when scanning for
* files. IDEA specific default excludes are given by the constant
* IDEA_DEFAULT_EXCLUDES: The <code>*.iml</code>, <code>*.ipr</code> and
* <code>*.iws</code> files and the <code>.idea</code> directory.
*/
@Parameter(property = "rat.useIdeaDefaultExcludes", defaultValue = "true")
private boolean useIdeaDefaultExcludes;
/**
* Whether to exclude subprojects. This is recommended, if you want a
* separate apache-rat-plugin report for each subproject.
*
*/
@Parameter(property = "rat.excludeSubprojects", defaultValue = "true")
private boolean excludeSubProjects;
/**
* Holds the maven-internal project to allow resolution of artifact properties during mojo runs.
*/
@Parameter(defaultValue = "${project}", required = true, readonly = true)
private MavenProject project;
/**
* @return Returns the Maven project.
*/
protected MavenProject getProject() {
return project;
}
/**
* Returns the set of {@link IHeaderMatcher header matchers} to use.
*
* @throws MojoFailureException
* An error in the plugin configuration was detected.
* @throws MojoExecutionException
* An error occurred while calculating the result.
* @return Array of license matchers to use
*/
protected IHeaderMatcher[] getLicenseMatchers()
throws MojoFailureException, MojoExecutionException {
final List<IHeaderMatcher> list = new ArrayList<IHeaderMatcher>();
if (licenses != null) {
list.addAll(Arrays.asList(licenses));
}
if (licenseMatchers != null) {
for (final HeaderMatcherSpecification spec : licenseMatchers) {
final String className = spec.getClassName();
final IHeaderMatcher headerMatcher = newInstance(
IHeaderMatcher.class, className);
list.add(headerMatcher);
}
}
if (addDefaultLicenseMatchers) {
list.addAll(Arrays.asList(Defaults.DEFAULT_MATCHERS));
}
return list.toArray(new IHeaderMatcher[list.size()]);
}
private <T> T newInstance(final Class<T> clazz, final String className)
throws MojoExecutionException, MojoFailureException {
try {
final ClassLoader cl = Thread.currentThread()
.getContextClassLoader();
@SuppressWarnings("unchecked") // incorrect cast will be caught below
final T o = (T) cl.loadClass(className).newInstance();
if (!clazz.isAssignableFrom(o.getClass())) {
throw new MojoFailureException("The class "
+ o.getClass().getName() + " does not implement "
+ clazz.getName());
}
return o;
} catch (InstantiationException e) {
throw new MojoExecutionException("Failed to instantiate class "
+ className + ": " + e.getMessage(), e);
} catch (ClassCastException e) {
throw new MojoExecutionException("The class " + className
+ " is not implementing " + clazz.getName() + ": "
+ e.getMessage(), e);
} catch (IllegalAccessException e) {
throw new MojoExecutionException("Illegal access to class "
+ className + ": " + e.getMessage(), e);
} catch (ClassNotFoundException e) {
throw new MojoExecutionException("Class " + className
+ " not found: " + e.getMessage(), e);
}
}
/**
* Adds the given string array to the list.
*
* @param pList
* The list to which the array elements are being added.
* @param pArray
* The strings to add to the list.
*/
private static void add(List<String> pList, String[] pArray) {
if (pArray != null) {
Collections.addAll(pList, pArray);
}
}
/**
* Creates an iterator over the files to check.
*
* @return A container of files, which are being checked.
*/
protected IReportable getResources() {
final DirectoryScanner ds = new DirectoryScanner();
ds.setBasedir(basedir);
setExcludes(ds);
setIncludes(ds);
ds.scan();
whenDebuggingLogExcludedFiles(ds);
final String[] files = ds.getIncludedFiles();
logAboutIncludedFiles(files);
try {
return new FilesReportable(basedir, files);
} catch (IOException e) {
throw new UndeclaredThrowableException(e);
}
}
private void logAboutIncludedFiles(final String[] files) {
if (files.length == 0) {
getLog().warn("No resources included.");
} else {
getLog().info(
files.length
+ " resources included (use -debug for more details)");
if (getLog().isDebugEnabled()) {
for (String resource : files) {
getLog().debug(" - included " + resource);
}
}
}
}
private void whenDebuggingLogExcludedFiles(final DirectoryScanner ds) {
if (getLog().isDebugEnabled()) {
final String[] excludedFiles = ds.getExcludedFiles();
if (excludedFiles.length == 0) {
getLog().debug("No excluded resources.");
} else {
getLog().debug(
"Excluded " + excludedFiles.length + " resources:");
for (final String resource : excludedFiles) {
getLog().debug(" - excluded " + resource);
}
}
}
}
private void setIncludes(DirectoryScanner ds) {
if (includes != null) {
ds.setIncludes(includes);
}
}
private void setExcludes(DirectoryScanner ds) {
final List<String> excludeList = buildDefaultExclusions();
if (excludes == null || excludes.length == 0) {
getLog().info("No excludes explicitly specified.");
} else {
for (String exclude : excludes) {
getLog().info("Exclude: " + exclude);
}
}
add(excludeList, excludes);
if (!excludeList.isEmpty()) {
String[] allExcludes = excludeList.toArray(new String[excludeList
.size()]);
ds.setExcludes(allExcludes);
}
}
private List<String> buildDefaultExclusions() {
final List<String> results = new ArrayList<String>();
addPlexusDefaults(results);
addMavenDefaults(results);
addEclipseDefaults(results);
addIdeaDefaults(results);
if (excludeSubProjects && project != null
&& project.getModules() != null) {
for (Object o : project.getModules()) {
String moduleSubPath = (String) o;
results.add(moduleSubPath + "/**/*");
}
}
getLog().debug("Finished creating list of implicit excludes.");
if (results.isEmpty()) {
getLog().info("No excludes implicitly specified.");
} else {
getLog().info(
results.size()
+ " implicit excludes (use -debug for more details).");
for (final String exclude : results) {
getLog().debug("Implicit exclude: " + exclude);
}
}
return results;
}
private void addPlexusDefaults(final List<String> excludeList1) {
if (useDefaultExcludes) {
getLog().debug("Adding plexus default exclusions...");
Collections.addAll(excludeList1, DirectoryScanner.DEFAULTEXCLUDES);
} else {
getLog().debug(
"rat.useDefaultExcludes set to false. "
+ "Plexus default exclusions will not be added");
}
}
private void addMavenDefaults(final List<String> excludeList1) {
if (useMavenDefaultExcludes) {
getLog().debug(
"Adding exclusions often needed by Maven projects...");
excludeList1.addAll(MAVEN_DEFAULT_EXCLUDES);
} else {
getLog().debug(
"rat.useMavenDefaultExcludes set to false. "
+ "Exclusions often needed by Maven projects will not be added.");
}
}
private void addEclipseDefaults(final List<String> excludeList1) {
if (useEclipseDefaultExcludes) {
getLog().debug(
"Adding exclusions often needed by projects "
+ "developed in Eclipse...");
excludeList1.addAll(ECLIPSE_DEFAULT_EXCLUDES);
} else {
getLog().debug(
"rat.useEclipseDefaultExcludes set to false. "
+ "Exclusions often needed by projects developed in "
+ "Eclipse will not be added.");
}
}
private void addIdeaDefaults(final List<String> excludeList1) {
if (useIdeaDefaultExcludes) {
getLog().debug(
"Adding exclusions often needed by projects "
+ "developed in IDEA...");
excludeList1.addAll(IDEA_DEFAULT_EXCLUDES);
} else {
getLog().debug(
"rat.useIdeaDefaultExcludes set to false. "
+ "Exclusions often needed by projects developed in "
+ "IDEA will not be added.");
}
}
/**
* Writes the report to the given stream.
*
* @param out
* The target writer, to which the report is being written.
* @param style
* The stylesheet to use, or <code>null</code> for raw XML
*
* @return the current statistic.
*
* @throws MojoFailureException
* An error in the plugin configuration was detected.
* @throws MojoExecutionException
* Another error occurred while creating the report.
*/
protected ClaimStatistic createReport(Writer out, InputStream style)
throws MojoExecutionException, MojoFailureException {
final ReportConfiguration configuration = getConfiguration();
try {
if (style != null) {
return Report.report(out, getResources(), style, configuration);
} else {
return Report.report(getResources(), out, configuration);
}
} catch (TransformerConfigurationException e) {
throw new MojoExecutionException(e.getMessage(), e);
} catch (IOException e) {
throw new MojoExecutionException(e.getMessage(), e);
} catch (InterruptedException e) {
throw new MojoExecutionException(e.getMessage(), e);
} catch (RatException e) {
throw new MojoExecutionException(e.getMessage(), e);
}
}
protected ReportConfiguration getConfiguration()
throws MojoFailureException, MojoExecutionException {
final ReportConfiguration configuration = new ReportConfiguration();
configuration.setHeaderMatcher(new HeaderMatcherMultiplexer(
getLicenseMatchers()));
configuration.setApprovedLicenseNames(getApprovedLicenseNames());
return configuration;
}
private ILicenseFamily[] getApprovedLicenseNames()
throws MojoExecutionException, MojoFailureException {
final List<ILicenseFamily> list = new ArrayList<ILicenseFamily>();
if (licenseFamilies != null) {
list.addAll(Arrays.asList(licenseFamilies));
}
if (licenseFamilyNames != null) {
for (LicenseFamilySpecification spec : licenseFamilyNames) {
list.add(newInstance(ILicenseFamily.class, spec.getClassName()));
}
}
if (list.isEmpty()) {
return null;
}
return list.toArray(new ILicenseFamily[list.size()]);
}
}