package cbt
package proguard
import java.io.File
import java.nio.file.Files.deleteIfExists
sealed class KeepOptionModifier( val string: String )
object KeepOptionModifier {
/* AUTO GENERATED SECTION BEGIN: keepModifiers */
/** Also keep any classes in the descriptors of specified fields and methods. */
object includedescriptorclasses extends KeepOptionModifier( "includedescriptorclasses" )
/** Allow the specified entry points to be removed in the shrinking step. */
object allowshrinking extends KeepOptionModifier( "allowshrinking" )
/** Allow the specified entry points to be modified in the optimization step. */
object allowoptimization extends KeepOptionModifier( "allowoptimization" )
/** Allow the specified entry points to be renamed in the obfuscation step. */
object allowobfuscation extends KeepOptionModifier( "allowobfuscation" )
/* AUTO GENERATED SECTION END: keepModifiers */
}
object ProGuard {
val artifactId = "proguard-base"
val groupId = "net.sf.proguard"
val version = "5.3.2"
val mainClass = "proguard.ProGuard"
val `rt.jar` = Seq( new File( System.getProperty( "java.home" ), "lib/rt.jar" ) )
}
case class ProGuard[T](
main: Seq[String] => Int,
T: Seq[File] => T,
log: String => Unit = _ => ()
) {
/**
Typed interface on top of the proguard command line tool.
Check the official ProGuard docs for usage.
Use `Some( None )` to call an option without arguments.
Use `true` to set a flag.
@see https://www.guardsquare.com/en/proguard/manual/refcard
@see https://www.guardsquare.com/en/proguard/manual/usage
/* AUTO GENERATED SECTION BEGIN: docs */
@param include Read configuration options from the given file.
@param basedirectory Specifies the base directory for subsequent relative file names.
@param injars Specifies the program jars ( or wars, ears, zips, or directories ).
@param outjars Specifies the names of the output jars ( or wars, ears, zips, or directories ).
@param libraryjars Specifies the library jars ( or wars, ears, zips, or directories ).
@param skipnonpubliclibraryclasses Ignore non-public library classes.
@param dontskipnonpubliclibraryclasses Don't ignore non-public library classes ( the default ).
@param dontskipnonpubliclibraryclassmembers Don't ignore package visible library class members.
@param keepdirectories Keep the specified directories in the output jars ( or wars, ears, zips, or directories ).
@param target Set the given version number in the processed classes.
@param forceprocessing Process the input, even if the output seems up to date.
@param keep Preserve the specified classes and class members.
@param keepclassmembers Preserve the specified class members, if their classes are preserved as well.
@param keepclasseswithmembers Preserve the specified classes and class members, if all of the specified class members are present.
@param keepnames Preserve the names of the specified classes and class members ( if they aren't removed in the shrinking step ).
@param keepclassmembernames Preserve the names of the specified class members ( if they aren't removed in the shrinking step ).
@param keepclasseswithmembernames Preserve the names of the specified classes and class members, if all of the specified class members are present ( after the shrinking step ).
@param printseeds List classes and class members matched by the various -keep options, to the standard output or to the given file.
@param dontshrink Don't shrink the input class files.
@param printusage List dead code of the input class files, to the standard output or to the given file.
@param whyareyoukeeping Print details on why the given classes and class members are being kept in the shrinking step.
@param dontoptimize Don't optimize the input class files.
@param optimizations The optimizations to be enabled and disabled.
@param optimizationpasses The number of optimization passes to be performed.
@param assumenosideeffects Assume that the specified methods don't have any side effects, while optimizing.
@param allowaccessmodification Allow the access modifiers of classes and class members to be modified, while optimizing.
@param mergeinterfacesaggressively Allow any interfaces to be merged, while optimizing.
@param dontobfuscate Don't obfuscate the input class files.
@param printmapping Print the mapping from old names to new names for classes and class members that have been renamed, to the standard output or to the given file.
@param applymapping Reuse the given mapping, for incremental obfuscation.
@param obfuscationdictionary Use the words in the given text file as obfuscated field names and method names.
@param classobfuscationdictionary Use the words in the given text file as obfuscated class names.
@param packageobfuscationdictionary Use the words in the given text file as obfuscated package names.
@param overloadaggressively Apply aggressive overloading while obfuscating.
@param useuniqueclassmembernames Ensure uniform obfuscated class member names for subsequent incremental obfuscation.
@param dontusemixedcaseclassnames Don't generate mixed-case class names while obfuscating.
@param keeppackagenames Keep the specified package names from being obfuscated.
@param flattenpackagehierarchy Repackage all packages that are renamed into the single given parent package.
@param repackageclasses Repackage all class files that are renamed into the single given package.
@param keepattributes Preserve the given optional attributes; typically Exceptions, InnerClasses, Signature, Deprecated, SourceFile, SourceDir, LineNumberTable, LocalVariableTable, LocalVariableTypeTable, Synthetic, EnclosingMethod, and *Annotation*.
@param keepparameternames Keep the parameter names and types of methods that are kept.
@param renamesourcefileattribute Put the given constant string in the SourceFile attributes.
@param adaptclassstrings Adapt string constants in the specified classes, based on the obfuscated names of any corresponding classes.
@param adaptresourcefilenames Rename the specified resource files, based on the obfuscated names of the corresponding class files.
@param adaptresourcefilecontents Update the contents of the specified resource files, based on the obfuscated names of the processed classes.
@param dontpreverify Don't preverify the processed class files.
@param microedition Target the processed class files at Java Micro Edition.
@param verbose Write out some more information during processing.
@param dontnote Don't print notes about potential mistakes or omissions in the configuration.
@param dontwarn Don't warn about unresolved references at all.
@param ignorewarnings Print warnings about unresolved references, but continue processing anyhow.
@param printconfiguration Write out the entire configuration in traditional ProGuard style, to the standard output or to the given file.
@param dump Write out the internal structure of the processed class files, to the standard output or to the given file.
/* AUTO GENERATED SECTION END: docs */
*/
case class proguard(
/* AUTO GENERATED SECTION BEGIN: params */
include: Option[File] = None,
basedirectory: Option[File] = None,
injars: Option[Seq[File]] = None,
outjars: Option[Seq[File]] = None,
libraryjars: Option[Seq[File]] = None,
skipnonpubliclibraryclasses: Boolean = false,
dontskipnonpubliclibraryclasses: Boolean = false,
dontskipnonpubliclibraryclassmembers: Boolean = false,
keepdirectories: Option[Option[String]] = None,
target: Option[String] = None,
forceprocessing: Boolean = false,
keep: Option[( Seq[KeepOptionModifier], String )] = None,
keepclassmembers: Option[( Seq[KeepOptionModifier], String )] = None,
keepclasseswithmembers: Option[( Seq[KeepOptionModifier], String )] = None,
keepnames: Option[String] = None,
keepclassmembernames: Option[String] = None,
keepclasseswithmembernames: Option[String] = None,
printseeds: Option[Option[File]] = None,
dontshrink: Boolean = false,
printusage: Option[Option[File]] = None,
whyareyoukeeping: Option[String] = None,
dontoptimize: Boolean = false,
optimizations: Option[String] = None,
optimizationpasses: Option[Int] = None,
assumenosideeffects: Option[String] = None,
allowaccessmodification: Boolean = false,
mergeinterfacesaggressively: Boolean = false,
dontobfuscate: Boolean = false,
printmapping: Option[Option[File]] = None,
applymapping: Option[File] = None,
obfuscationdictionary: Option[File] = None,
classobfuscationdictionary: Option[File] = None,
packageobfuscationdictionary: Option[File] = None,
overloadaggressively: Boolean = false,
useuniqueclassmembernames: Boolean = false,
dontusemixedcaseclassnames: Boolean = false,
keeppackagenames: Option[Option[String]] = None,
flattenpackagehierarchy: Option[Option[String]] = None,
repackageclasses: Option[Option[String]] = None,
keepattributes: Option[Option[String]] = None,
keepparameternames: Boolean = false,
renamesourcefileattribute: Option[Option[String]] = None,
adaptclassstrings: Option[Option[String]] = None,
adaptresourcefilenames: Option[Option[String]] = None,
adaptresourcefilecontents: Option[Option[String]] = None,
dontpreverify: Boolean = false,
microedition: Boolean = false,
verbose: Boolean = false,
dontnote: Option[Option[String]] = None,
dontwarn: Option[Option[String]] = None,
ignorewarnings: Boolean = false,
printconfiguration: Option[Option[File]] = None,
dump: Option[Option[File]] = None
/* AUTO GENERATED SECTION END: params */
) extends ( () => T ) {
// type class rendering scala values into string arguments
private class argsFor[T]( val apply: T => Option[Seq[String]] )
private object argsFor {
def apply[T: argsFor]( value: T ) = implicitly[argsFor[T]].apply( value )
implicit object SeqFile extends argsFor[Seq[File]]( v => Some( Seq( v.map( _.getPath ).mkString( ":" ) ) ) )
implicit object File extends argsFor[File]( v => Some( Seq( v.getPath ) ) )
implicit object String extends argsFor[String]( v => Some( Seq( v ) ) )
implicit object Int extends argsFor[Int]( i => Some( Seq( i.toString ) ) )
implicit object Boolean
extends argsFor[Boolean]( {
case false => None
case true => Some( Nil )
} )
implicit def Option2[T: argsFor]: argsFor[Option[T]] = new argsFor(
_.map( implicitly[argsFor[T]].apply( _ ).toSeq.flatten )
)
implicit def Option3[T: argsFor]: argsFor[Option[Option[String]]] =
new argsFor( _.map( _.toSeq ) )
implicit def SpecWithModifiers: argsFor[( Seq[KeepOptionModifier], String )] =
new argsFor( {
case ( modifiers, spec ) =>
Some( Seq( modifiers.map( _.string ).map( "," ++ _ ).mkString ).filterNot( _ == "" ) :+ spec )
} )
}
// capture string argument values and names
val args = (
/* AUTO GENERATED SECTION BEGIN: args */
argsFor( include ).map( "-include" +: _ )
++ argsFor( basedirectory ).map( "-basedirectory" +: _ )
++ argsFor( injars ).map( "-injars" +: _ )
++ argsFor( outjars ).map( "-outjars" +: _ )
++ argsFor( libraryjars ).map( "-libraryjars" +: _ )
++ argsFor( skipnonpubliclibraryclasses ).map( "-skipnonpubliclibraryclasses" +: _ )
++ argsFor( dontskipnonpubliclibraryclasses ).map( "-dontskipnonpubliclibraryclasses" +: _ )
++ argsFor( dontskipnonpubliclibraryclassmembers ).map( "-dontskipnonpubliclibraryclassmembers" +: _ )
++ argsFor( keepdirectories ).map( "-keepdirectories" +: _ )
++ argsFor( target ).map( "-target" +: _ )
++ argsFor( forceprocessing ).map( "-forceprocessing" +: _ )
++ argsFor( keep ).map( "-keep" +: _ )
++ argsFor( keepclassmembers ).map( "-keepclassmembers" +: _ )
++ argsFor( keepclasseswithmembers ).map( "-keepclasseswithmembers" +: _ )
++ argsFor( keepnames ).map( "-keepnames" +: _ )
++ argsFor( keepclassmembernames ).map( "-keepclassmembernames" +: _ )
++ argsFor( keepclasseswithmembernames ).map( "-keepclasseswithmembernames" +: _ )
++ argsFor( printseeds ).map( "-printseeds" +: _ )
++ argsFor( dontshrink ).map( "-dontshrink" +: _ )
++ argsFor( printusage ).map( "-printusage" +: _ )
++ argsFor( whyareyoukeeping ).map( "-whyareyoukeeping" +: _ )
++ argsFor( dontoptimize ).map( "-dontoptimize" +: _ )
++ argsFor( optimizations ).map( "-optimizations" +: _ )
++ argsFor( optimizationpasses ).map( "-optimizationpasses" +: _ )
++ argsFor( assumenosideeffects ).map( "-assumenosideeffects" +: _ )
++ argsFor( allowaccessmodification ).map( "-allowaccessmodification" +: _ )
++ argsFor( mergeinterfacesaggressively ).map( "-mergeinterfacesaggressively" +: _ )
++ argsFor( dontobfuscate ).map( "-dontobfuscate" +: _ )
++ argsFor( printmapping ).map( "-printmapping" +: _ )
++ argsFor( applymapping ).map( "-applymapping" +: _ )
++ argsFor( obfuscationdictionary ).map( "-obfuscationdictionary" +: _ )
++ argsFor( classobfuscationdictionary ).map( "-classobfuscationdictionary" +: _ )
++ argsFor( packageobfuscationdictionary ).map( "-packageobfuscationdictionary" +: _ )
++ argsFor( overloadaggressively ).map( "-overloadaggressively" +: _ )
++ argsFor( useuniqueclassmembernames ).map( "-useuniqueclassmembernames" +: _ )
++ argsFor( dontusemixedcaseclassnames ).map( "-dontusemixedcaseclassnames" +: _ )
++ argsFor( keeppackagenames ).map( "-keeppackagenames" +: _ )
++ argsFor( flattenpackagehierarchy ).map( "-flattenpackagehierarchy" +: _ )
++ argsFor( repackageclasses ).map( "-repackageclasses" +: _ )
++ argsFor( keepattributes ).map( "-keepattributes" +: _ )
++ argsFor( keepparameternames ).map( "-keepparameternames" +: _ )
++ argsFor( renamesourcefileattribute ).map( "-renamesourcefileattribute" +: _ )
++ argsFor( adaptclassstrings ).map( "-adaptclassstrings" +: _ )
++ argsFor( adaptresourcefilenames ).map( "-adaptresourcefilenames" +: _ )
++ argsFor( adaptresourcefilecontents ).map( "-adaptresourcefilecontents" +: _ )
++ argsFor( dontpreverify ).map( "-dontpreverify" +: _ )
++ argsFor( microedition ).map( "-microedition" +: _ )
++ argsFor( verbose ).map( "-verbose" +: _ )
++ argsFor( dontnote ).map( "-dontnote" +: _ )
++ argsFor( dontwarn ).map( "-dontwarn" +: _ )
++ argsFor( ignorewarnings ).map( "-ignorewarnings" +: _ )
++ argsFor( printconfiguration ).map( "-printconfiguration" +: _ )
++ argsFor( dump ).map( "-dump" +: _ )
/* AUTO GENERATED SECTION END: args */
).flatten.toSeq
def apply: T = {
outjars.foreach( _.map( _.toPath ).map( deleteIfExists ) )
val c = main( args )
if ( c != 0 ) throw new Exception
T( outjars.toSeq.flatten )
}
}
}
