com.github.bohnman.PackageInfoMojo Maven / Gradle / Ivy

package com.github.bohnman;

import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugins.annotations.Component;
import org.apache.maven.plugins.annotations.LifecyclePhase;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.SelectorUtils;
import org.codehaus.plexus.util.StringUtils;
import org.sonatype.plexus.build.incremental.BuildContext;
import org.sonatype.plexus.build.incremental.DefaultBuildContext;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static java.lang.String.format;

/**
 * Mojo that generates package-info.java files
 */
@Mojo(
        name = "generate",
        defaultPhase = LifecyclePhase.GENERATE_SOURCES
)
public class PackageInfoMojo extends AbstractMojo {

    private static final String PACKAGE_INFO_JAVA = "package-info.java";
    private static final Pattern PACKAGE_STATEMENT_PATTERN = Pattern.compile("^\\s*package\\s[\\S]+?\\s*;$", Pattern.MULTILINE);

    @Parameter(defaultValue = "${project.basedir}/src/main/java")
    private File sourceDirectory;

    @Parameter(defaultValue = "${project.basedir}/generated/src/main/java")
    private File outputDirectory;

    @Parameter
    private List packages;

    @Parameter(defaultValue = "(\\s*//\\s*\\s*)(.*?)(\\s*//\\s*\\s*)")
    private Pattern inlineReplacePattern;

    @Parameter(defaultValue = "true")
    private boolean generate;

    @Parameter(defaultValue = "true")
    private boolean inline;

    @Component
    private BuildContext buildContext;

    private Map templateCache = new HashMap<>();


    public PackageInfoMojo() {
    }

    public void setSourceDirectory(File sourceDirectory) {
        this.sourceDirectory = sourceDirectory;
    }

    public void setOutputDirectory(File outputDirectory) {
        this.outputDirectory = outputDirectory;
    }

    public void setPackages(List packages) {
        this.packages = packages;
    }

    public void setInlineReplacePattern(String inlineReplacePattern) {
        this.inlineReplacePattern = Pattern.compile(inlineReplacePattern, Pattern.MULTILINE);
    }

    public void setGenerate(boolean generate) {
        this.generate = generate;
    }

    public void setInline(boolean inline) {
        this.inline = inline;
    }

    public void execute() throws MojoExecutionException {
        try {
            getLog().info(format("Generating package-info.java: %s", this));
            generate();
            getLog().debug("Done.");
        } catch (MojoExecutionException e) {
            throw e;
        } catch (RuntimeException | Error e) {
            throw new MojoExecutionException("Error generating package info files", e);
        }
    }

    private void generate() throws MojoExecutionException {
        if (packages == null || packages.isEmpty()) {
            getLog().warn("Skipping generate. No  declaration found.");
            return;
        }

        validate();
        loadTemplates();
        if (buildContext == null) {
            getLog().info(format("Using defaultBuildContext"));
            buildContext = new DefaultBuildContext();
        }
        walk(sourceDirectory, outputDirectory, "");
    }

    private void validate() throws MojoExecutionException {
        getLog().debug("Validating parameters");

        if (sourceDirectory.getAbsolutePath().equals(outputDirectory.getAbsolutePath())) {
            throw new MojoExecutionException(format("Source and Output directories cannot be the same: [%s].", sourceDirectory.getAbsolutePath()));
        }

        if (!sourceDirectory.exists()) {
            throw new MojoExecutionException(format("Source Directory [%s] does not exist.", sourceDirectory.getAbsolutePath()));
        }

        if (!sourceDirectory.isDirectory()) {
            throw new MojoExecutionException(format("Source Directory [%s] is not a directory.", sourceDirectory.getAbsolutePath()));
        }

        if (generate) {
            if (outputDirectory.exists() && !outputDirectory.isDirectory()) {
                throw new MojoExecutionException(format("Output Directory [%s] is not a directory.", outputDirectory.getAbsolutePath()));
            }

            if (!outputDirectory.exists() && !outputDirectory.mkdirs()) {
                throw new MojoExecutionException(format("Failed to create Output Directory [%s].", outputDirectory.getAbsolutePath()));
            }

        }

        for (int i = 0; i < packages.size(); i++) {
            Package pkg = packages.get(i);

            if (StringUtils.isEmpty(pkg.getPattern())) {
                throw new MojoExecutionException(format("[%s]:  is required.", i));
            }

            if (pkg.getTemplate() == null) {
                throw new MojoExecutionException(format("[%s]: