io.paradoxical.ResolvePomMojo Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of resolved-pom-maven-plugin Show documentation
A maven plugin to filter specific properties in a pom files and attach the resulting pom to the build output
The newest version!
package io.paradoxical;

import org.apache.maven.artifact.Artifact;
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.apache.maven.project.MavenProject;
import org.apache.maven.project.MavenProjectHelper;
import org.apache.maven.project.artifact.ProjectArtifactMetadata;
import org.apache.maven.shared.filtering.MavenFileFilter;
import org.apache.maven.shared.filtering.MavenFileFilterRequest;
import org.apache.maven.shared.filtering.MavenFilteringException;

import java.io.File;
import java.util.ArrayList;
import java.util.Map;
import java.util.Properties;

@Mojo(name = "resolve-pom", defaultPhase = LifecyclePhase.INITIALIZE)
public class ResolvePomMojo extends AbstractMojo {

    @Parameter(defaultValue = "${project.artifact}", readonly = true, required = true)
    private Artifact artifact;

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

    @Parameter(defaultValue = "${project.file}", required = true, readonly = true)
    private File pomFile;

    @Parameter(property = "encoding", defaultValue = "${project.build.sourceEncoding}")
    private String encoding;

    @Parameter(defaultValue = "${project.build.directory}/resolved-pom.xml", required = true)
    private File resolvedPomFile;

    @Parameter(required = true)
    private Map properties;

    @Parameter(property = "resolve-pom.overwrite", defaultValue = "true", required = false)
    private boolean overwriteExisting;

    @Component(role = MavenFileFilter.class, hint = "default")
    private MavenFileFilter fileFilter;

    @Component
    private MavenProjectHelper projectHelper;

    public void execute() throws MojoExecutionException {

        if(resolvedPomFile.equals(pomFile)) {
            getLog().info(String.format(
                    "Input pom file %s is the same as the output pom %s, " +
                    "this happens for multiple runs in the same build, and is probably safe to ignore",
                    pomFile,
                    resolvedPomFile));
            return;
        }

        final Properties additionalProperties = new Properties();

        for (Map.Entry entry : properties.entrySet()) {
            additionalProperties.put(entry.getKey(), entry.getValue() == null ? "" : entry.getValue());
        }

        getLog().info(String.format("Filtering pom at %s to %s", pomFile, resolvedPomFile));

        final File outputDirectory = resolvedPomFile.getParentFile();
        final boolean createdOutputDirectory = outputDirectory.mkdirs();

        getLog().debug(String.format("Ensure output directory %s : %s", outputDirectory.getName(), createdOutputDirectory));


        if (!resolvedPomFile.exists() || overwriteExisting) {
            resolvePom(additionalProperties);
        }
        else {
            getLog().info(String.format("output file already exists at %s if you wanted to overwrite it set resolve-pom.overwrite=true",
                                        resolvedPomFile));
        }

        artifact.addMetadata(new ResolvedProjectArtifactMetadata(artifact, resolvedPomFile));

        project.setFile(resolvedPomFile);

        // Not needed after the above method was found
        //        projectHelper.attachArtifact(project, "pom", resolvedPomFile);
    }

    private void resolvePom(final Properties additionalProperties) throws MojoExecutionException {
        final boolean enableFiltering = true;

        try {
            final boolean createdResolvedPomFile = resolvedPomFile.createNewFile();
            getLog().debug(String.format("Ensure output file %s : %s", resolvedPomFile.getName(), createdResolvedPomFile));
        }
        catch (Exception e) {
            throw new MojoExecutionException("Error creating output file", e);
        }

        final MavenFileFilterRequest mavenFileFilterRequest = new MavenFileFilterRequest(
                pomFile, // from
                resolvedPomFile, // to
                enableFiltering, // filtering
                null, // mavenProject - setting null means not to pull in project properties :)
                new ArrayList(), // filter .properties files to use
                false, // escapedBackslashesInFilePath? not sure...
                encoding, // encoding - Should probably set this to project.build.sourceEncoding
                null, // mavenSession - setting to null means no session properties :)
                additionalProperties // additionalProperties
        );

        try {
            fileFilter.copyFile(mavenFileFilterRequest);
        }
        catch (MavenFilteringException e) {
            getLog().error("Failed to create filtered pom");
            throw new MojoExecutionException("Failed to create a filtered pom", e);
        }

        getLog().info(String.format("Filtered pom to %s", resolvedPomFile));
    }

    private class ResolvedProjectArtifactMetadata extends ProjectArtifactMetadata {

        public ResolvedProjectArtifactMetadata(final Artifact artifact, final File file) {
            super(artifact, file);
        }

        @Override
        public void merge(final org.apache.maven.artifact.metadata.ArtifactMetadata metadata) {
            // don't do anything
            getLog().info("Got a request to merge metadata for: " + metadata.getKey() + " " + metadata.getRemoteFilename());
        }
    }
}