trunk/apache-rat-plugin/src/main/java/org/apache/rat/mp/RatReportMojo.java

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 org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
import org.apache.maven.artifact.resolver.ArtifactResolutionException;
import org.apache.maven.artifact.resolver.ArtifactResolver;
import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
import org.apache.maven.artifact.versioning.VersionRange;
import org.apache.maven.doxia.site.decoration.Body;
import org.apache.maven.doxia.site.decoration.DecorationModel;
import org.apache.maven.doxia.site.decoration.Skin;
import org.apache.maven.doxia.siterenderer.Renderer;
import org.apache.maven.doxia.siterenderer.RendererException;
import org.apache.maven.doxia.siterenderer.RenderingContext;
import org.apache.maven.doxia.siterenderer.SiteRenderingContext;
import org.apache.maven.doxia.siterenderer.sink.SiteRendererSink;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugins.annotations.Component;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.plugins.annotations.ResolutionScope;
import org.apache.maven.reporting.MavenReport;
import org.apache.maven.reporting.MavenReportException;
import org.apache.rat.Defaults;
import org.codehaus.doxia.sink.Sink;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Locale;
import java.util.Map;
import java.util.ResourceBundle;


/**
 * Generates a report with Rat's output.
 */
@SuppressWarnings("deprecation") // MavenReport invokes the deprecated Sink implementation
@Mojo(name = "rat", requiresDependencyResolution = ResolutionScope.TEST)
public class RatReportMojo extends AbstractRatMojo implements MavenReport {
    public static final String DOT_HTML = ".html";
    @Component
    private Renderer siteRenderer;

    @Component
    private ArtifactFactory factory;

    @Component
    private ArtifactResolver resolver;

    /**
     * Specifies the directory where the report will be generated
     */
    @Parameter(defaultValue = "${project.reporting.outputDirectory}", required = true)
    private File outputDirectory;

    @Parameter(defaultValue = "${localRepository}", required = true, readonly = true)
    private ArtifactRepository localRepository;

    /**
     * Returns the skins artifact file.
     *
     * @return Artifact file
     * @throws MojoFailureException   An error in the plugin configuration was detected.
     * @throws MojoExecutionException An error occurred while searching for the artifact file.
     */
    private File getSkinArtifactFile() throws MojoFailureException, MojoExecutionException {
        final Skin skin = Skin.getDefaultSkin();

        String version = skin.getVersion();
        final Artifact artifact;
        try {
            if (version == null) {
                version = Artifact.RELEASE_VERSION;
            }
            VersionRange versionSpec = VersionRange.createFromVersionSpec(version);
            artifact =
                    factory.createDependencyArtifact(skin.getGroupId(), skin.getArtifactId(), versionSpec, "jar", null,
                            null);

            resolver.resolve(artifact, getProject().getRemoteArtifactRepositories(), localRepository);
        } catch (InvalidVersionSpecificationException e) {
            throw new MojoFailureException("The skin version '" + version + "' is not valid: " + e.getMessage());
        } catch (ArtifactResolutionException e) {
            throw new MojoExecutionException("Unable to find skin", e);
        } catch (ArtifactNotFoundException e) {
            throw new MojoFailureException("The skin does not exist: " + e.getMessage());
        }

        return artifact.getFile();
    }

    /**
     * Called from Maven to invoke the plugin.
     *
     * @throws MojoFailureException   An error in the plugin configuration was detected.
     * @throws MojoExecutionException An error occurred while creating the report.
     */
    public void execute() throws MojoExecutionException, MojoFailureException {
        if (skip) {
            getLog().info("RAT will not execute since it is configured to be skipped via system property 'rat.skip'.");
            return;
        }

        final DecorationModel model = new DecorationModel();
        model.setBody(new Body());
        final Map<String, String> attributes = new HashMap<String, String>();
        attributes.put("outputEncoding", "UTF-8");
        final Locale locale = Locale.getDefault();
        try {
            final SiteRenderingContext siteContext =
                    siteRenderer.createContextForSkin(getSkinArtifactFile(), attributes, model, getName(locale),
                            locale);
            final RenderingContext context = new RenderingContext(outputDirectory, getOutputName() + DOT_HTML);

            final SiteRendererSink sink = new SiteRendererSink(context);
            generate(sink, locale);

            if (!outputDirectory.mkdirs() && !outputDirectory.isDirectory()) {
                throw new IOException("Could not create output directory " + outputDirectory);
            }


            final Writer writer = new FileWriter(new File(outputDirectory, getOutputName() + DOT_HTML));

            siteRenderer.generateDocument(writer, sink, siteContext);

            siteRenderer.copyResources(siteContext, new File(getProject().getBasedir(), "src/site/resources"),
                    outputDirectory);
        } catch (IOException e) {
            throw new MojoExecutionException(e.getMessage(), e);
        } catch (MavenReportException e) {
            throw new MojoExecutionException(e.getMessage(), e);
        } catch (RendererException e) {
            throw new MojoExecutionException(e.getMessage(), e);
        }
    }

    /**
     * Returns, whether the report may be generated.
     *
     * @return Always true.
     */
    public boolean canGenerateReport() {
        return true;
    }

    /**
     * Searches for a Rat artifact in the dependency list and returns its version.
     *
     * @return Version number, if found, or null.
     */
    private String getRatVersion() {
        for (@SuppressWarnings("unchecked") // library is not yet generified
             Iterator<Artifact> iter = getProject().getDependencyArtifacts().iterator(); iter.hasNext(); ) {
            Artifact a = iter.next();
            if ("rat-lib".equals(a.getArtifactId())) {
                return a.getVersion();
            }
        }
        return null;
    }

    /**
     * Writes the report to the Doxia sink.
     *
     * @param sink   The doxia sink, kind of a SAX handler.
     * @param locale The locale to use for writing the report.
     * @throws MavenReportException Writing the report failed.
     */
    public void generate(Sink sink, Locale locale) throws MavenReportException {
        ResourceBundle bundle = getBundle(locale);
        final String title = bundle.getString("report.rat.title");
        sink.head();
        sink.title();
        sink.text(title);
        sink.title_();
        sink.head_();

        sink.body();

        sink.section1();
        sink.sectionTitle1();
        sink.text(title);
        sink.sectionTitle1_();

        sink.paragraph();
        sink.text(bundle.getString("report.rat.link") + " ");
        sink.link(bundle.getString("report.rat.url"));
        sink.text(bundle.getString("report.rat.fullName"));
        sink.link_();
        final String ratVersion = getRatVersion();
        if (ratVersion != null) {
            sink.text(" " + ratVersion);
        }
        sink.text(".");
        sink.paragraph_();

        sink.paragraph();
        sink.verbatim(true);
        try {
            sink.text(createReport(Defaults.getDefaultStyleSheet()));
        } catch (MojoExecutionException e) {
            throw new MavenReportException(e.getMessage(), e);
        } catch (MojoFailureException e) {
            throw new MavenReportException(e.getMessage(), e);
        }
        sink.verbatim_();
        sink.paragraph_();
        sink.section1_();
        sink.body_();
    }

    /**
     * Returns the reports category name.
     *
     * @return {@link MavenReport#CATEGORY_PROJECT_REPORTS}
     */
    public String getCategoryName() {
        return MavenReport.CATEGORY_PROJECT_REPORTS;
    }

    /**
     * Returns the reports bundle
     *
     * @param locale Requested locale of the bundle
     * @return The bundle, which is used to read localized strings.
     */
    private ResourceBundle getBundle(Locale locale) {
        return ResourceBundle.getBundle("org/apache/rat/mp/rat-report", locale, getClass().getClassLoader());
    }

    /**
     * Returns the reports description.
     *
     * @param locale Requested locale of the bundle
     * @return Report description, as given by the key "report.rat.description" in the bundle.
     */
    public String getDescription(Locale locale) {
        return getBundle(locale).getString("report.rat.description");
    }

    /**
     * Returns the reports name.
     *
     * @param locale Requested locale of the bundle
     * @return Report name, as given by the key "report.rat.name" in the bundle.
     */
    public String getName(Locale locale) {
        return getBundle(locale).getString("report.rat.name");
    }

    /**
     * Returns the reports file name.
     *
     * @return "rat-report"
     */
    public String getOutputName() {
        return "rat-report";
    }

    /**
     * Returns the reports output directory.
     *
     * @return Value of the "outputDirectory" parameter.
     */
    public File getReportOutputDirectory() {
        return outputDirectory;
    }

    /**
     * Returns, whether this is an external report.
     *
     * @return Always false.
     */
    public boolean isExternalReport() {
        return false;
    }

    /**
     * Sets the reports output directory.
     *
     * @param pOutputDirectory Reports target directory.
     */
    public void setReportOutputDirectory(File pOutputDirectory) {
        outputDirectory = pOutputDirectory;
    }
}