chore(release): 2.13.0 [skip ci]

# [2.13.0](https://github.com/revanced/revanced-cli/compare/v2.12.0...v2.13.0) (2022-10-01)

### Features

* check, if input file exists ([b6dff6d](b6dff6d832))

.github/ISSUE_TEMPLATE/bug-issue.yml

@@ -59,3 +59,15 @@ body:
       description: Add additional context here.
     validations:
       required: false
+  - type: checkboxes
+    id: acknowledgements
+    attributes:
+      label: Acknowledgements
+      description: Your issue will be closed if you haven't done these steps.
+      options:
+        - label: I have searched the existing issues and this is a new and no duplicate or related to another open issue.
+          required: true
+        - label: I have written a short but informative title.
+          required: true
+        - label: I filled out all of the requested information in this issue properly.
+          required: true

.github/ISSUE_TEMPLATE/feature-issue.yml

@@ -43,4 +43,16 @@ body:
       label: Additional context
       description: Add additional context here.
     validations:
-      required: false
+      required: false
+  - type: checkboxes
+    id: acknowledgements
+    attributes:
+      label: Acknowledgements
+      description: Your issue will be closed if you haven't done these steps.
+      options:
+        - label: I have searched the existing issues and this is a new and no duplicate or related to another open issue.
+          required: true
+        - label: I have written a short but informative title.
+          required: true
+        - label: I filled out all of the requested information in this issue properly.
+          required: true

.gitignore

@@ -111,4 +111,5 @@ gradle-app.setting
 .gradletasknamecache
 
 # # Work around https://youtrack.jetbrains.com/issue/IDEA-116898
-# gradle/wrapper/gradle-wrapper.properties
+# gradle/wrapper/gradle-wrapper.properties
+revanced-cache/

.idea/vcs.xml

@@ -8,7 +8,5 @@
   </component>
   <component name="VcsDirectoryMappings">
     <mapping directory="$PROJECT_DIR$" vcs="Git" />
-    <mapping directory="$PROJECT_DIR$/../revanced-patcher" vcs="Git" />
-    <mapping directory="$PROJECT_DIR$/../revanced-patches" vcs="Git" />
   </component>
 </project>

CHANGELOG.md

@@ -1,3 +1,39 @@
+# [2.13.0](https://github.com/revanced/revanced-cli/compare/v2.12.0...v2.13.0) (2022-10-01)
+
+
+### Features
+
+* check, if input file exists ([b6dff6d](https://github.com/revanced/revanced-cli/commit/b6dff6d832de4a513a6d86b0a59b2458eddd23c2))
+
+# [2.12.0](https://github.com/revanced/revanced-cli/compare/v2.11.2...v2.12.0) (2022-09-26)
+
+
+### Features
+
+* remove unused option `-r` ([467d838](https://github.com/revanced/revanced-cli/commit/467d8387e646c88d24a30406a5b2e84065ef4d54))
+
+## [2.11.2](https://github.com/revanced/revanced-cli/compare/v2.11.1...v2.11.2) (2022-09-23)
+
+## [2.11.1](https://github.com/revanced/revanced-cli/compare/v2.11.0...v2.11.1) (2022-09-21)
+
+# [2.11.0](https://github.com/revanced/revanced-cli/compare/v2.10.2...v2.11.0) (2022-09-20)
+
+
+### Features
+
+* section `acknowledgements` for issue templates ([0e3ecc3](https://github.com/revanced/revanced-cli/commit/0e3ecc3a51540b71072ae0be0eb94d115a5b1f92))
+
+## [2.10.2](https://github.com/revanced/revanced-cli/compare/v2.10.1...v2.10.2) (2022-09-18)
+
+## [2.10.1](https://github.com/revanced/revanced-cli/compare/v2.10.0...v2.10.1) (2022-09-09)
+
+# [2.10.0](https://github.com/revanced/revanced-cli/compare/v2.9.10...v2.10.0) (2022-09-08)
+
+
+### Features
+
+* Patch Options CLI implementation ([#132](https://github.com/revanced/revanced-cli/issues/132)) ([3f5345a](https://github.com/revanced/revanced-cli/commit/3f5345af6e45bfb6c91d52fc089ab18d81fdc998))
+
 ## [2.9.10](https://github.com/revanced/revanced-cli/compare/v2.9.9...v2.9.10) (2022-09-08)
 
 

build.gradle.kts

@@ -25,11 +25,12 @@ repositories {
 dependencies {
     implementation(kotlin("reflect"))
 
-    implementation("app.revanced:revanced-patcher:4.2.2")
+    implementation("app.revanced:revanced-patcher:5.1.2")
     implementation("info.picocli:picocli:4.6.3")
     implementation("com.android.tools.build:apksig:7.2.1")
     implementation("com.github.revanced:jadb:master-SNAPSHOT") // updated fork
     implementation("org.bouncycastle:bcpkix-jdk15on:1.70")
+    implementation("cc.ekblad:4koma:1.1.0")
 }
 
 tasks {

gradle.properties

@@ -1,2 +1,2 @@
 kotlin.code.style = official
-version = 2.9.10
+version = 2.13.0

src/main/kotlin/app/revanced/cli/command/MainCommand.kt

@@ -11,6 +11,7 @@ import app.revanced.patcher.extensions.PatchExtensions.compatiblePackages
 import app.revanced.patcher.extensions.PatchExtensions.description
 import app.revanced.patcher.extensions.PatchExtensions.patchName
 import app.revanced.patcher.util.patch.impl.JarPatchBundle
+import app.revanced.utils.OptionsLoader
 import app.revanced.utils.adb.Adb
 import picocli.CommandLine.*
 import java.io.File
@@ -51,6 +52,9 @@ internal object MainCommand : Runnable {
         @Option(names = ["-b", "--bundles"], description = ["One or more bundles of patches"], required = true)
         var patchBundles = arrayOf<String>()
 
+        @Option(names = ["--options"], description = ["Configuration file for all patch options"])
+        var options: File = File("options.toml")
+
         @ArgGroup(exclusive = false)
         var listingArgs: ListingArgs? = null
 
@@ -88,9 +92,6 @@ internal object MainCommand : Runnable {
         @Option(names = ["-i", "--include"], description = ["Include patches"])
         var includedPatches = arrayOf<String>()
 
-        @Option(names = ["-r", "--resource-patcher"], description = ["Disable patching resources"])
-        var disableResourcePatching: Boolean = false
-
         @Option(names = ["--experimental"], description = ["Disable patch version compatibility patch"])
         var experimental: Boolean = false
 
@@ -123,26 +124,22 @@ internal object MainCommand : Runnable {
     }
 
     override fun run() {
-        if (args.patchArgs?.listingArgs?.listOnly == true) {
-            printListOfPatches()
-            return
-        }
-
-        if (args.uninstall) {
-            uninstall()
-            return
-        }
+        if (args.patchArgs?.listingArgs?.listOnly == true) return printListOfPatches()
+        if (args.uninstall) return uninstall()
 
         val pArgs = this.args.patchArgs?.patchingArgs ?: return
+        val outputFile = File(pArgs.outputPath) // the file to write to
 
-        // the file to write to
-        val outputFile = File(pArgs.outputPath)
+        val allPatches = args.patchArgs!!.patchBundles.flatMap { bundle ->
+            JarPatchBundle(bundle).loadPatches()
+        }
+
+        OptionsLoader.init(args.patchArgs!!.options, allPatches)
 
         val patcher = app.revanced.patcher.Patcher(
             PatcherOptions(
-                args.inputFile,
+                args.inputFile.also { if (!it.exists()) return logger.error("Input file ${args.inputFile} does not exist.") },
                 pArgs.cacheDirectory,
-                !pArgs.disableResourcePatching,
                 pArgs.aaptPath,
                 pArgs.cacheDirectory,
                 PatcherLogger
@@ -157,7 +154,7 @@ internal object MainCommand : Runnable {
         val patchedFile = File(pArgs.cacheDirectory).resolve("${outputFile.nameWithoutExtension}_raw.apk")
 
         // start the patcher
-        Patcher.start(patcher, patchedFile)
+        Patcher.start(patcher, patchedFile, allPatches)
 
         val cacheDirectory = File(pArgs.cacheDirectory)
 
@@ -209,19 +206,13 @@ internal object MainCommand : Runnable {
     }
 
     private fun uninstall() {
-        // temporarily get package name using Patcher method
-        // fix: abstract options in patcher
-        val patcher = app.revanced.patcher.Patcher(
-            PatcherOptions(
-                args.inputFile,
-                "uninstaller-cache",
+        val adb: Adb? = args.deploy?.let {
+            Adb(
+                File("placeholder_file"),
+                app.revanced.patcher.Patcher(PatcherOptions(args.inputFile, "")).data.packageMetadata.packageName,
+                args.deploy!!,
                 false
             )
-        )
-        File("uninstaller-cache").deleteRecursively()
-
-        val adb: Adb? = args.deploy?.let {
-            Adb(File("placeholder_file"), patcher.data.packageMetadata.packageName, args.deploy!!, false)
         }
         adb?.uninstall()
     }

src/main/kotlin/app/revanced/cli/patcher/Patcher.kt

@@ -2,6 +2,8 @@ package app.revanced.cli.patcher
 
 import app.revanced.cli.command.MainCommand.args
 import app.revanced.cli.command.MainCommand.logger
+import app.revanced.patcher.data.Data
+import app.revanced.patcher.patch.Patch
 import app.revanced.utils.filesystem.ZipFileSystemUtils
 import app.revanced.utils.patcher.addPatchesFiltered
 import app.revanced.utils.patcher.applyPatchesVerbose
@@ -10,14 +12,14 @@ import java.io.File
 import java.nio.file.Files
 
 internal object Patcher {
-    internal fun start(patcher: app.revanced.patcher.Patcher, output: File) {
+    internal fun start(patcher: app.revanced.patcher.Patcher, output: File, allPatches: List<Class<out Patch<Data>>>) {
         val inputFile = args.inputFile
         val args = args.patchArgs?.patchingArgs!!
 
         // merge files like necessary integrations
         patcher.mergeFiles()
         // add patches, but filter incompatible or excluded patches
-        patcher.addPatchesFiltered()
+        patcher.addPatchesFiltered(allPatches)
         // apply patches
         patcher.applyPatchesVerbose()
 
@@ -33,10 +35,10 @@ internal object Patcher {
                 outputFileSystem.write(it.name, it.stream.readAllBytes())
             }
 
-            if (!args.disableResourcePatching) {
+            result.resourceFile?.let {
                 logger.info("Writing resources...")
 
-                ZipFileSystemUtils(result.resourceFile!!).use { resourceFileSystem ->
+                ZipFileSystemUtils(it).use { resourceFileSystem ->
                     val resourceFiles = resourceFileSystem.getFile(File.separator)
                     outputFileSystem.writePathRecursively(resourceFiles)
                 }

src/main/kotlin/app/revanced/utils/OptionsLoader.kt

@@ -0,0 +1,77 @@
+package app.revanced.utils
+
+import app.revanced.cli.command.MainCommand.logger
+import app.revanced.patcher.Patcher
+import app.revanced.patcher.data.Data
+import app.revanced.patcher.extensions.PatchExtensions.options
+import app.revanced.patcher.extensions.PatchExtensions.patchName
+import app.revanced.patcher.patch.Patch
+import cc.ekblad.toml.encodeToString
+import cc.ekblad.toml.model.TomlValue
+import cc.ekblad.toml.serialization.from
+import cc.ekblad.toml.tomlMapper
+import java.io.File
+
+private typealias PatchList = List<Class<out Patch<Data>>>
+private typealias OptionsMap = MutableMap<String, MutableMap<String, Any>>
+
+object OptionsLoader {
+    @JvmStatic
+    private val mapper = tomlMapper {}
+
+    @JvmStatic
+    fun init(file: File, patches: PatchList) {
+        if (!file.exists()) file.createNewFile()
+        val map = mapper.decodeWithDefaults(generateDefaults(patches), TomlValue.from(file.toPath()))
+        readAndSet(map, patches)
+        save(map, file)
+    }
+
+    private fun readAndSet(map: OptionsMap, patches: PatchList) {
+        for ((patchName, options) in map) {
+            val patch = patches.find { it.patchName == patchName } ?: continue
+            val patchOptions = patch.options ?: continue
+            for ((key, value) in options) {
+                if (value == "null") { // backwards compatibility, subject to removal
+                    options.remove(key)
+                    continue
+                }
+                try {
+                    patchOptions[key] = value
+                } catch (e: Exception) {
+                    logger.error("Error while setting option $key for patch $patchName: ${e.message}")
+                    e.printStackTrace()
+                }
+            }
+        }
+    }
+
+    private fun save(map: OptionsMap, file: File) {
+        val toml = mapper.encodeToString(map)
+        file.writeText(
+            """
+                # A list of options for each patch.
+                # This file does not contain all options by default.
+                # Run the CLI with the "--list --with-options" flags to see all available options.
+                # You can also run the CLI with the aforementioned flags and a patch name to see all available options for that patch.
+                # To set an option, add a line with the format "option = value" or set the value if the option already exists.
+                # To reset an option to its default value, delete the line.
+                # To reset all options to their default values, delete this file.
+                # 
+                # This file was generated by ReVanced Patcher version ${Patcher.version}.
+            """.trimIndent() + "\n\n$toml"
+        )
+    }
+
+    private fun generateDefaults(patches: PatchList) = buildMap {
+        for (patch in patches) {
+            val options = patch.options ?: continue
+            if (!options.iterator().hasNext()) continue
+            put(patch.patchName, buildMap {
+                for (option in options) {
+                    put(option.key, option.value ?: continue)
+                }
+            } as MutableMap)
+        }
+    } as MutableMap
+}

src/main/kotlin/app/revanced/utils/patcher/Patcher.kt

@@ -10,61 +10,59 @@ import app.revanced.patcher.extensions.PatchExtensions.deprecated
 import app.revanced.patcher.extensions.PatchExtensions.include
 import app.revanced.patcher.extensions.PatchExtensions.patchName
 import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.util.patch.impl.JarPatchBundle
 
-fun Patcher.addPatchesFiltered() {
+fun Patcher.addPatchesFiltered(allPatches: List<Class<out Patch<Data>>>) {
     val packageName = this.data.packageMetadata.packageName
     val packageVersion = this.data.packageMetadata.packageVersion
 
-    args.patchArgs?.patchBundles!!.forEach { bundle ->
-        val includedPatches = mutableListOf<Class<out Patch<Data>>>()
-        JarPatchBundle(bundle).loadPatches().forEach patch@{ patch ->
-            val compatiblePackages = patch.compatiblePackages
-            val patchName = patch.patchName
+    val includedPatches = mutableListOf<Class<out Patch<Data>>>()
+    allPatches.forEach patchLoop@{ patch ->
+        val compatiblePackages = patch.compatiblePackages
+        val patchName = patch.patchName
 
-            val prefix = "Skipping $patchName, reason"
+        val prefix = "Skipping $patchName, reason"
 
-            val args = MainCommand.args.patchArgs?.patchingArgs!!
+        val args = MainCommand.args.patchArgs?.patchingArgs!!
 
-            if (args.excludedPatches.contains(patchName)) {
-                logger.info("$prefix: manually excluded")
-                return@patch
-            } else if ((!patch.include || args.defaultExclude) && !args.includedPatches.contains(patchName)) {
-                logger.info("$prefix: excluded by default")
-                return@patch
-            }
-
-            patch.deprecated?.let { (reason, replacement) ->
-                logger.warn("$prefix: deprecated: $reason")
-                if (replacement != null) logger.warn("Either use ${replacement.java.patchName} instead or include it manually")
-                return@patch
-            }
-
-            if (compatiblePackages == null) logger.warn("$prefix: Missing compatibility annotation. Continuing.")
-            else {
-                if (!compatiblePackages.any { it.name == packageName }) {
-                    logger.warn("$prefix: incompatible with $packageName. This patch is only compatible with ${
-                        compatiblePackages.joinToString(
-                            ", "
-                        ) { it.name }
-                    }")
-                    return@patch
-                }
-
-                if (!(args.experimental || compatiblePackages.any { it.versions.isEmpty() || it.versions.any { version -> version == packageVersion } })) {
-                    val compatibleWith = compatiblePackages.joinToString(";") { _package ->
-                        "${_package.name}: ${_package.versions.joinToString(", ")}"
-                    }
-                    logger.warn("$prefix: incompatible with version $packageVersion. This patch is only compatible with version $compatibleWith")
-                    return@patch
-                }
-            }
-
-            logger.trace("Adding $patchName")
-            includedPatches.add(patch)
+        if (args.excludedPatches.contains(patchName)) {
+            logger.info("$prefix: manually excluded")
+            return@patchLoop
+        } else if ((!patch.include || args.defaultExclude) && !args.includedPatches.contains(patchName)) {
+            logger.info("$prefix: excluded by default")
+            return@patchLoop
         }
-        this.addPatches(includedPatches)
+
+        patch.deprecated?.let { (reason, replacement) ->
+            logger.warn("$prefix: deprecated: $reason")
+            if (replacement != null) logger.warn("Either use ${replacement.java.patchName} instead or include it manually")
+            return@patchLoop
+        }
+
+        if (compatiblePackages == null) logger.warn("$prefix: Missing compatibility annotation. Continuing.")
+        else {
+            if (!compatiblePackages.any { it.name == packageName }) {
+                logger.warn("$prefix: incompatible with $packageName. This patch is only compatible with ${
+                    compatiblePackages.joinToString(
+                        ", "
+                    ) { it.name }
+                }")
+                return@patchLoop
+            }
+
+            if (!(args.experimental || compatiblePackages.any { it.versions.isEmpty() || it.versions.any { version -> version == packageVersion } })) {
+                val compatibleWith = compatiblePackages.joinToString(";") { _package ->
+                    "${_package.name}: ${_package.versions.joinToString(", ")}"
+                }
+                logger.warn("$prefix: incompatible with version $packageVersion. This patch is only compatible with version $compatibleWith")
+                return@patchLoop
+            }
+        }
+
+        logger.trace("Adding $patchName")
+        includedPatches.add(patch)
     }
+
+    this.addPatches(includedPatches)
 }
 
 fun Patcher.applyPatchesVerbose() {