path: root/libraries/proguard/Proguard.scala

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)
    }
  }
}