uk.co.caprica.maven.proguard.ProguardMojo Maven / Gradle / Ivy
/*
* 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.
*/
package uk.co.caprica.maven.proguard;
import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
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.plugins.annotations.ResolutionScope;
import org.apache.maven.project.MavenProject;
import org.apache.tools.ant.DefaultLogger;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.taskdefs.Java;
/**
* Maven Plugin for ProGuard.
*
* This project is a fork of https://github.com/dingxin/proguard-maven-plugin.
*
* @author dingxin
*/
@Mojo(name = "proguard", defaultPhase = LifecyclePhase.PACKAGE, requiresProject = true, threadSafe = true, requiresDependencyResolution = ResolutionScope.COMPILE)
public class ProguardMojo extends AbstractMojo {
/**
* Disables the plugin execution
*/
@Parameter(property = "maven.proguard.skip", defaultValue = "false")
private boolean skip;
/**
* ProGuard options
*/
@Parameter
private String[] options;
/**
* ProGuard configuration file
*/
@Parameter(defaultValue = "src/main/proguard/proguard.conf")
private File configFile;
/**
* Directory containing the input and generated JAR.
*/
@Parameter(property = "project.build.directory")
private File targetDirectory;
/**
* Specifies the input jar name (or war, apk) of the application to be
* processed.
*
* You may specify a classes directory, e.g. 'classes'.
*/
@Parameter
private String injar;
/**
* Specifies the name of the output jar (or war, apk)
*/
@Parameter
private String outjar;
/**
* ProGuard Filters for the input jar
*
* e.g. !module-info.class,!META-INF/maven/**
*/
@Parameter(defaultValue = "!module-info.class,!META-INF/maven/**")
private String inFilter;
/**
* ProGuard Filters for the output jar
*
* e.g. !META-INF/maven/**
*/
@Parameter(defaultValue = "!META-INF/maven/**")
private String outFilter;
/**
* Add dependency jars to -libraryjars arguments
*/
@Parameter(defaultValue = "true")
private boolean includeDependency;
/**
* Add dependency jars to -injars arguments
*/
@Parameter(defaultValue = "false")
private boolean includeDependencyInjar;
/**
* ProGuard Filters for dependency jars
*
* e.g. !module-info.class
*/
@Parameter(defaultValue = "!module-info.class,!META-INF/**")
private String dependencyFilter;
/**
* Additional -libraryjars
*
* e.g. ${java.home}/jmods/java.base.jmod(!**.jar;!module-info.class)
*
* e.g. ${java.home}/lib/rt.jar
*/
@Parameter
private List libs;
/**
* The Maven project reference where the plugin is currently being executed.
*/
@Parameter(property = "project", readonly = true)
private MavenProject mavenProject;
/**
* The plugin dependencies.
*/
@Parameter(property = "plugin.artifacts", readonly = true)
private List pluginArtifacts;
@Override
public void execute() throws MojoExecutionException, MojoFailureException {
if (skip) {
getLog().info("Proguard is skipped.");
return;
}
setDefaultJarName();
List args = getArgs();
execProguard(args);
}
private void execProguard(List args) throws MojoExecutionException, MojoFailureException {
getLog().info("Execute ProGuard: " + args.toString());
File proguardJar = getProguardJar();
Project antProject = new Project();
antProject.setName(this.mavenProject.getName());
antProject.init();
DefaultLogger antLogger = new DefaultLogger();
antLogger.setOutputPrintStream(System.out);
antLogger.setErrorPrintStream(System.err);
antLogger.setMessageOutputLevel(Project.MSG_INFO);
antProject.addBuildListener(antLogger);
antProject.setBaseDir(this.mavenProject.getBasedir());
Java java = new Java();
java.setProject(antProject);
java.setTaskName("proguard");
java.createClasspath().setLocation(proguardJar);
java.setClassname("proguard.ProGuard");
java.setFailonerror(true);
java.setFork(true);
for (String arg : args) {
java.createArg().setValue(arg);
}
int result = java.executeJava();
if (result != 0) {
throw new MojoExecutionException("ProGuard failed (result=" + result + ")");
}
//remove classes/classes when injar and outjar are directory
File outjarFile = new File(targetDirectory, outjar);
if(outjarFile.isDirectory()) {
File classesDir = new File(targetDirectory, outjar + "/classes/classes");
File classesFile = classesDir.listFiles()[0];
classesFile.renameTo(new File(targetDirectory, outjar + "/" + classesFile.getName()));
classesDir.getParentFile().delete();
}
}
private void setDefaultJarName() {
String type = mavenProject.getPackaging();
getLog().debug("Package Type: " + type);
if ("jar".equals(type)) {
if (injar == null) {
injar = mavenProject.getBuild().getFinalName() + ".jar";
}
if (outjar == null) {
outjar = injar;
}
} else if ("war".equals(type)) {
if (injar == null) {
injar = "classes";
}
if (outjar == null) {
outjar = injar;
}
}
getLog().debug("injar " + injar);
getLog().debug("outjar " + outjar);
}
private File getInjarFile() throws MojoFailureException {
File injarFile = new File(targetDirectory, injar);
if (!injarFile.exists()) {
throw new MojoFailureException("Can't find file " + injarFile);
}
File tempInjarFile;
if (injarFile.isDirectory()) {
tempInjarFile = new File(targetDirectory, nameNoExt(injar) + "_proguard_base");
} else {
tempInjarFile = new File(targetDirectory, nameNoExt(injar) + "_proguard_base.jar");
}
if (tempInjarFile.exists() && !deleteFile(tempInjarFile)) {
throw new MojoFailureException("Can't delete " + tempInjarFile);
}
if (!injarFile.renameTo(tempInjarFile)) {
throw new MojoFailureException("Can't rename " + injarFile);
}
injarFile = tempInjarFile;
getLog().debug("injarFile " + injarFile);
return injarFile;
}
private File getOutjarFile() throws MojoFailureException {
File outjarFile = new File(targetDirectory, outjar);
if (outjarFile.exists() && !deleteFile(outjarFile)) {
throw new MojoFailureException("Can't delete " + outjarFile);
}
return outjarFile;
}
private File getProguardJar() throws MojoFailureException {
for (Artifact artifact : this.pluginArtifacts) {
getLog().debug("Plugin Artifact: " + artifact.getFile());
if (artifact.getArtifactId().equals("proguard-base")) {
getLog().debug("Proguard Artifact: " + artifact.getFile());
return artifact.getFile().getAbsoluteFile();
}
}
throw new MojoFailureException("ProGuard not found");
}
private List getArgs() throws MojoFailureException {
List args = new ArrayList();
argForConfigFile(args);
argForInjar(args);
argForOutjar(args);
argForLibs(args);
argForDependency(args);
argForOptions(args);
return args;
}
private void argForConfigFile(List args) {
if (configFile != null && configFile.exists()) {
args.add("-include");
args.add(configFile.getAbsolutePath());
getLog().debug("ProGuard Configuration File: " + configFile);
}
}
private void argForInjar(List args) throws MojoFailureException {
args.add("-injars");
String classpath = getInjarFile().getAbsolutePath();
String filter = "";
if (inFilter != null) {
filter = "(" + inFilter + ")";
}
args.add(classpath + filter);
}
private void argForOutjar(List args) throws MojoFailureException {
args.add("-outjars");
String classpath = getOutjarFile().getAbsolutePath();
String filter = "";
if (outFilter != null) {
filter = "(" + outFilter + ")";
}
args.add(classpath + filter);
}
private void argForLibs(List args) {
if (libs != null) {
for (String lib : libs) {
args.add("-libraryjars");
args.add(lib);
}
}
}
private void argForDependency(List args) {
if (!includeDependency) {
return;
}
String option = "-libraryjars";
if (includeDependencyInjar) {
option = "-injars";
}
String filter = "";
if (dependencyFilter != null) {
filter = "(" + dependencyFilter + ")";
}
Set artifacts = this.mavenProject.getArtifacts();
for (Artifact artifact : artifacts) {
String classpath = artifact.getFile().getAbsolutePath();
args.add(option);
args.add(classpath + filter);
}
}
private void argForOptions(List args) {
if (options != null) {
Collections.addAll(args, options);
}
}
private String nameNoExt(String fileName) {
int dotIndex = fileName.lastIndexOf('.');
if (dotIndex == -1) {
return fileName;
} else {
return fileName.substring(0, dotIndex);
}
}
private boolean deleteFile(File file) {
if (file.isDirectory()) {
for (File subFile : file.listFiles()) {
deleteFile(subFile);
}
}
return file.delete();
}
}