chore(release): 2.9.0 [skip ci]

# [2.9.0](https://github.com/revanced/revanced-patcher/compare/v2.8.0...v2.9.0) (2022-08-02)

### Bug Fixes

* show error message instead of `null` ([8d95b14](8d95b14f35))

### Features

* exclusive mutable access to files ([814ce0b](814ce0b9ae))

.github/ISSUE_TEMPLATE/bug-issue.yml

@@ -51,10 +51,10 @@ body:
       label: Solution
       description: If applicable, add a possible solution.
     validations:
-      required: true
+      required: false
   - type: textarea
     attributes:
       label: Additional context
       description: Add additional context here.
     validations:
-      required: false
+      required: false

CHANGELOG.md

@@ -1,3 +1,27 @@
+# [2.9.0](https://github.com/revanced/revanced-patcher/compare/v2.8.0...v2.9.0) (2022-08-02)
+
+
+### Bug Fixes
+
+* show error message instead of `null` ([8d95b14](https://github.com/revanced/revanced-patcher/commit/8d95b14f350b47ec029f35e776f6e627aaf5f607))
+
+
+### Features
+
+* exclusive mutable access to files ([814ce0b](https://github.com/revanced/revanced-patcher/commit/814ce0b9ae29725417c86b7d11b40d025724a426))
+
+# [2.8.0](https://github.com/revanced/revanced-patcher/compare/v2.7.0...v2.8.0) (2022-08-01)
+
+
+### Bug Fixes
+
+* remove requirement for solution [skip ci] ([#80](https://github.com/revanced/revanced-patcher/issues/80)) ([9a4d30e](https://github.com/revanced/revanced-patcher/commit/9a4d30e15234ef62844f035c58a1143674d4c12e))
+
+
+### Features
+
+* patch options ([#81](https://github.com/revanced/revanced-patcher/issues/81)) ([fbb09f3](https://github.com/revanced/revanced-patcher/commit/fbb09f38dce49adc7f63b71bdf2df2ef0b84db04))
+
 # [2.7.0](https://github.com/revanced/revanced-patcher/compare/v2.6.0...v2.7.0) (2022-08-01)
 
 

gradle.properties

@@ -1,2 +1,2 @@
 kotlin.code.style = official
-version = 2.7.0
+version = 2.9.0

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

@@ -11,7 +11,6 @@ import app.revanced.patcher.patch.Patch
 import app.revanced.patcher.patch.PatchResult
 import app.revanced.patcher.patch.PatchResultError
 import app.revanced.patcher.patch.PatchResultSuccess
-import app.revanced.patcher.patch.annotations.DependencyType
 import app.revanced.patcher.patch.impl.BytecodePatch
 import app.revanced.patcher.patch.impl.ResourcePatch
 import app.revanced.patcher.util.ListBackedSet
@@ -265,16 +264,13 @@ class Patcher(private val options: PatcherOptions) {
         // recursively apply all dependency patches
         patch.dependencies.forEach {
             val dependency = it.patch.java
-            if ( // soft dependencies must be included manually.
-                it.type == DependencyType.SOFT && !data.patches.any { p ->
-                    p.patchName == dependency.patchName
-                }
-            ) return@forEach
 
             val result = applyPatch(dependency, appliedPatches)
             if (result.isSuccess()) return@forEach
 
-            val errorMessage = result.error()!!.cause
+            val error = result.error()!!
+            val errorMessage = error.cause ?: error.message
+
             return PatchResultError("'$patchName' depends on '${dependency.patchName}' but the following error was raised: $errorMessage")
         }
 

src/main/kotlin/app/revanced/patcher/data/impl/ResourceData.kt

@@ -19,31 +19,66 @@ class ResourceData(private val resourceCacheDirectory: File) : Data, Iterable<Fi
     override fun iterator() = resourceCacheDirectory.walkTopDown().iterator()
 
     inner class XmlFileHolder {
-        operator fun get(inputStream: InputStream, outputStream: OutputStream) =
+        operator fun get(inputStream: InputStream) =
-            DomFileEditor(inputStream, lazyOf(outputStream))
+            DomFileEditor(inputStream)
+
+        operator fun get(path: String): DomFileEditor {
+            return DomFileEditor(this@ResourceData[path])
+        }
 
-        operator fun get(path: String) = DomFileEditor(this@ResourceData[path])
     }
 }
 
+/**
+ * DomFileEditor is a wrapper for a file that can be edited as a dom document.
+ *
+ * @param inputStream the input stream to read the xml file from.
+ * @param outputStream the output stream to write the xml file to. If null, the file will not be written.
+ */
 class DomFileEditor internal constructor(
     private val inputStream: InputStream,
-    private val outputStream: Lazy<OutputStream>,
+    private val outputStream: Lazy<OutputStream>? = null,
 ) : Closeable {
+    // path to the xml file to unlock the resource when closing the editor
+    private var filePath: String? = null
+
+    /**
+     * The document of the xml file
+     */
     val file: Document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(inputStream)
         .also(Document::normalize)
 
     // lazily open an output stream
     // this is required because when constructing a DomFileEditor the output stream is created along with the input stream, which is not allowed
     // the workaround is to lazily create the output stream. This way it would be used after the input stream is closed, which happens in the constructor
-    constructor(file: File) : this(file.inputStream(), lazy { file.outputStream() })
+    constructor(file: File) : this(file.inputStream(), lazy { file.outputStream() }) {
+        filePath = file.path
 
-    override fun close() {
+        // prevent sharing mutability of the same file between multiple instances of DomFileEditor
-        val result = StreamResult(outputStream.value)
+        if (locks.contains(filePath))
-        TransformerFactory.newInstance().newTransformer().transform(DOMSource(file), result)
+            throw IllegalStateException("Can not create a DomFileEditor for that file because it is already locked by another instance of DomFileEditor.")
-
+        locks.add(filePath!!)
-        inputStream.close()
-        outputStream.value.close()
     }
 
+    override fun close() {
+        inputStream.close()
+
+        // if the output stream is not null, do not close it
+        outputStream?.let {
+            val result = StreamResult(it.value)
+            TransformerFactory.newInstance().newTransformer().transform(DOMSource(file), result)
+
+            it.value.close()
+        }
+
+        // remove the lock, if it exists
+        filePath?.let {
+            locks.remove(it)
+        }
+    }
+
+    private companion object {
+        // list of locked file paths
+        val locks = mutableListOf<String>()
+    }
 }

src/main/kotlin/app/revanced/patcher/patch/Patch.kt

@@ -17,4 +17,9 @@ abstract class Patch<out T : Data> {
      * The main function of the [Patch] which the patcher will call.
      */
     abstract fun execute(data: @UnsafeVariance T): PatchResult
+
+    /**
+     * A list of [PatchOption]s.
+     */
+    open val options: Iterable<PatchOption<*>> = listOf()
 }

src/main/kotlin/app/revanced/patcher/patch/PatchOption.kt

@@ -0,0 +1,100 @@
+package app.revanced.patcher.patch
+
+/**
+ * A [Patch] option.
+ * @param key Unique identifier of the option. Example: _`settings.microg.enabled`_
+ * @param default The default value of the option.
+ * @param title A human-readable title of the option. Example: _MicroG Settings_
+ * @param description A human-readable description of the option. Example: _Settings integration for MicroG._
+ * @param required Whether the option is required.
+ */
+@Suppress("MemberVisibilityCanBePrivate")
+sealed class PatchOption<T>(
+    val key: String,
+    default: T?,
+    val title: String,
+    val description: String,
+    val required: Boolean
+) {
+    var value: T? = default
+
+    /**
+     * A [PatchOption] representing a [String].
+     * @see PatchOption
+     */
+    class StringOption(
+        key: String,
+        default: String?,
+        title: String,
+        description: String,
+        required: Boolean = false
+    ) : PatchOption<String>(
+        key, default, title, description, required
+    )
+
+    /**
+     * A [PatchOption] representing a [Boolean].
+     * @see PatchOption
+     */
+    class BooleanOption(
+        key: String,
+        default: Boolean?,
+        title: String,
+        description: String,
+        required: Boolean = false
+    ) : PatchOption<Boolean>(
+        key, default, title, description, required
+    )
+
+    /**
+     * A [PatchOption] with a list of allowed options.
+     * @param options A list of allowed options for the [ListOption].
+     * @see PatchOption
+     */
+    sealed class ListOption<E>(
+        key: String,
+        default: E?,
+        val options: Iterable<E>,
+        title: String,
+        description: String,
+        required: Boolean = false
+    ) : PatchOption<E>(
+        key, default, title, description, required
+    ) {
+        init {
+            if (default !in options) {
+                throw IllegalStateException("Default option must be an allowed options")
+            }
+        }
+    }
+
+    /**
+     * A [ListOption] of type [String].
+     * @see ListOption
+     */
+    class StringListOption(
+        key: String,
+        default: String?,
+        options: Iterable<String>,
+        title: String,
+        description: String,
+        required: Boolean = false
+    ) : ListOption<String>(
+        key, default, options, title, description, required
+    )
+
+    /**
+     * A [ListOption] of type [Int].
+     * @see ListOption
+     */
+    class IntListOption(
+        key: String,
+        default: Int?,
+        options: Iterable<Int>,
+        title: String,
+        description: String,
+        required: Boolean = false
+    ) : ListOption<Int>(
+        key, default, options, title, description, required
+    )
+}

src/main/kotlin/app/revanced/patcher/patch/annotations/PatchAnnotation.kt

@@ -43,11 +43,5 @@ enum class DependencyType {
     /**
      * Enforces that the dependency is applied, even if it was not selected.
      */
-    HARD,
+    HARD
-
-    /**
-     * Applies the dependency only if it was selected.
-     */
-    @Deprecated("Will be removed when Patch Options is implemented.")
-    SOFT
 }

src/test/kotlin/app/revanced/patcher/usage/PatchOptionsUsage.kt

@@ -0,0 +1,30 @@
+package app.revanced.patcher.usage
+
+import app.revanced.patcher.patch.PatchOption
+import app.revanced.patcher.usage.bytecode.ExampleBytecodePatch
+
+fun patchOptionsUsage() {
+    val options = ExampleBytecodePatch().options
+    for (option in options) {
+        when (option) {
+            is PatchOption.StringOption -> {
+                option.value = "Hello World"
+            }
+            is PatchOption.BooleanOption -> {
+                option.value = false
+            }
+            is PatchOption.StringListOption -> {
+                option.value = option.options.first()
+                for (choice in option.options) {
+                    println(choice)
+                }
+            }
+            is PatchOption.IntListOption -> {
+                option.value = option.options.first()
+                for (choice in option.options) {
+                    println(choice)
+                }
+            }
+        }
+    }
+}

src/test/kotlin/app/revanced/patcher/usage/bytecode/ExampleBytecodePatch.kt

@@ -7,6 +7,7 @@ import app.revanced.patcher.data.impl.BytecodeData
 import app.revanced.patcher.extensions.addInstructions
 import app.revanced.patcher.extensions.or
 import app.revanced.patcher.extensions.replaceInstruction
+import app.revanced.patcher.patch.PatchOption
 import app.revanced.patcher.patch.PatchResult
 import app.revanced.patcher.patch.PatchResultSuccess
 import app.revanced.patcher.patch.annotations.DependencyType
@@ -37,7 +38,7 @@ import org.jf.dexlib2.util.Preconditions
 @Description("Example demonstration of a bytecode patch.")
 @ExampleResourceCompatibility
 @Version("0.0.1")
-@DependsOn(ExampleBytecodePatch::class, DependencyType.SOFT)
+@DependsOn(ExampleBytecodePatch::class, DependencyType.HARD)
 class ExampleBytecodePatch : BytecodePatch(listOf(ExampleFingerprint)) {
     // This function will be executed by the patcher.
     // You can treat it as a constructor
@@ -162,4 +163,19 @@ class ExampleBytecodePatch : BytecodePatch(listOf(ExampleFingerprint)) {
             )
         )
     }
+
+    override val options = listOf(
+        PatchOption.StringOption(
+            "key", "default", "title", "description", true
+        ),
+        PatchOption.BooleanOption(
+            "key", true, "title", "description" // required defaults to false
+        ),
+        PatchOption.StringListOption(
+            "key", "TEST", listOf("TEST", "TEST1", "TEST2"), "title", "description"
+        ),
+        PatchOption.IntListOption(
+            "key", 1, listOf(1, 2, 3), "title", "description"
+        ),
+    )
 }