chore(release): 3.3.1 [skip ci]

## [3.3.1](https://github.com/revanced/revanced-patcher/compare/v3.3.0...v3.3.1) (2022-08-03)

### Bug Fixes

* revert soft dependencies ([7b2d058](7b2d058144))

CHANGELOG.md

@@ -1,3 +1,38 @@
+## [3.3.1](https://github.com/revanced/revanced-patcher/compare/v3.3.0...v3.3.1) (2022-08-03)
+
+
+### Bug Fixes
+
+* revert soft dependencies ([7b2d058](https://github.com/revanced/revanced-patcher/commit/7b2d058144b0718992d329731e2af7cc704e4370))
+
+# [3.3.0](https://github.com/revanced/revanced-patcher/compare/v3.2.1...v3.3.0) (2022-08-02)
+
+
+### Features
+
+* add getValue & setValue for PatchOption ([2572cd0](https://github.com/revanced/revanced-patcher/commit/2572cd04b5da4eeae738c8dde31493177edf0bf8))
+
+## [3.2.1](https://github.com/revanced/revanced-patcher/compare/v3.2.0...v3.2.1) (2022-08-02)
+
+
+### Bug Fixes
+
+* check if patch option requirement is met ([14a73bf](https://github.com/revanced/revanced-patcher/commit/14a73bfcafac36bce2b8466788d460edde7a14fd))
+
+# [3.2.0](https://github.com/revanced/revanced-patcher/compare/v3.1.0...v3.2.0) (2022-08-02)
+
+
+### Features
+
+* PatchOptions#nullify to nullify an option ([371f0c4](https://github.com/revanced/revanced-patcher/commit/371f0c4d0bf96e7f6db35085efccaed3000a096c))
+
+# [3.1.0](https://github.com/revanced/revanced-patcher/compare/v3.0.0...v3.1.0) (2022-08-02)
+
+
+### Features
+
+* validator for patch options ([4e2e772](https://github.com/revanced/revanced-patcher/commit/4e2e77238957d7732326cfe5e05145bf7dab5bfb))
+
 # [3.0.0](https://github.com/revanced/revanced-patcher/compare/v2.9.0...v3.0.0) (2022-08-02)
 
 

gradle.properties

@@ -1,2 +1,2 @@
 kotlin.code.style = official
-version = 3.0.0
+version = 3.3.1

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

@@ -262,16 +262,15 @@ class Patcher(private val options: PatcherOptions) {
         }
 
         // recursively apply all dependency patches
-        patch.dependencies.forEach {
-            val dependency = it.patch.java
+        patch.dependencies?.forEach {
+            val patchDependency = it.java
+
+            val result = applyPatch(patchDependency, appliedPatches)
 
-            val result = applyPatch(dependency, appliedPatches)
             if (result.isSuccess()) return@forEach
 
-            val error = result.error()!!
-            val errorMessage = error.cause ?: error.message
-
-            return PatchResultError("'$patchName' depends on '${dependency.patchName}' but the following error was raised: $errorMessage")
+            val errorMessage = result.error()!!.cause
+            return PatchResultError("'$patchName' depends on '${patchDependency.patchName}' but the following error was raised: $errorMessage")
         }
 
         val patchInstance = patch.getDeclaredConstructor().newInstance()

src/main/kotlin/app/revanced/patcher/extensions/AnnotationExtensions.kt

@@ -7,9 +7,6 @@ import app.revanced.patcher.annotation.Version
 import app.revanced.patcher.data.Data
 import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
 import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.patch.annotations.Dependencies
-import app.revanced.patcher.patch.annotations.DependencyType
-import app.revanced.patcher.patch.annotations.DependsOn
 import kotlin.reflect.KClass
 
 /**
@@ -38,26 +35,20 @@ private fun <T : Annotation> Class<*>.findAnnotationRecursively(
     return null
 }
 
-private typealias PatchClass = Class<out Patch<Data>>
-
 object PatchExtensions {
-    val PatchClass.patchName: String get() = recursiveAnnotation(Name::class)?.name ?: this.javaClass.simpleName
-    val PatchClass.version get() = recursiveAnnotation(Version::class)?.version
-    val PatchClass.include get() = recursiveAnnotation(app.revanced.patcher.patch.annotations.Patch::class)!!.include
-    val PatchClass.description get() = recursiveAnnotation(Description::class)?.description
-    val PatchClass.dependencies get() = buildList {
-        recursiveAnnotation(DependsOn::class)?.let { add(PatchDependency(it.value, it.type)) }
-        recursiveAnnotation(Dependencies::class)?.dependencies?.forEach { add(PatchDependency(it, DependencyType.HARD)) }
-    }.toTypedArray()
-    val PatchClass.compatiblePackages get() = recursiveAnnotation(Compatibility::class)?.compatiblePackages
+    val Class<out Patch<Data>>.patchName: String
+        get() = recursiveAnnotation(Name::class)?.name ?: this.javaClass.simpleName
+    val Class<out Patch<Data>>.version get() = recursiveAnnotation(Version::class)?.version
+    val Class<out Patch<Data>>.include get() = recursiveAnnotation(app.revanced.patcher.patch.annotations.Patch::class)!!.include
+    val Class<out Patch<Data>>.description get() = recursiveAnnotation(Description::class)?.description
+    val Class<out Patch<Data>>.dependencies get() = recursiveAnnotation(app.revanced.patcher.patch.annotations.DependsOn::class)?.dependencies
+    val Class<out Patch<Data>>.compatiblePackages get() = recursiveAnnotation(Compatibility::class)?.compatiblePackages
 
     @JvmStatic
-    fun PatchClass.dependsOn(patch: PatchClass): Boolean {
+    fun Class<out Patch<Data>>.dependsOn(patch: Class<out Patch<Data>>): Boolean {
         if (this.patchName == patch.patchName) throw IllegalArgumentException("thisval and patch may not be the same")
-        return this.dependencies.any { it.patch.java.patchName == this@dependsOn.patchName }
+        return this.dependencies?.any { it.java.patchName == this@dependsOn.patchName } == true
     }
-
-    class PatchDependency internal constructor(val patch: KClass<out Patch<Data>>, val type: DependencyType = DependencyType.HARD)
 }
 
 object MethodFingerprintExtensions {

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

@@ -1,13 +1,20 @@
+@file:Suppress("CanBeParameter", "MemberVisibilityCanBePrivate", "UNCHECKED_CAST")
+
 package app.revanced.patcher.patch
 
-@Suppress("CanBeParameter", "MemberVisibilityCanBePrivate")
+import kotlin.reflect.KProperty
+
 class NoSuchOptionException(val option: String) : Exception("No such option: $option")
+class IllegalValueException(val value: Any?) : Exception("Illegal value: $value")
+class InvalidTypeException(val got: String, val expected: String) :
+    Exception("Invalid option value type: $got, expected $expected")
+
+class RequirementNotMetException : Exception("null was passed into an option that requires a value")
 
 /**
  * A registry for an array of [PatchOption]s.
  * @param options An array of [PatchOption]s.
  */
-@Suppress("MemberVisibilityCanBePrivate")
 class PatchOptions(vararg val options: PatchOption<*>) : Iterable<PatchOption<*>> {
     private val register = buildMap {
         for (option in options) {
@@ -31,13 +38,22 @@ class PatchOptions(vararg val options: PatchOption<*>) : Iterable<PatchOption<*>
      * Please note that using the wrong value type results in a runtime error.
      */
     inline operator fun <reified T> set(key: String, value: T) {
-        @Suppress("UNCHECKED_CAST") val opt = get(key) as? PatchOption<T>
-        if (opt == null || opt.value !is T) throw IllegalArgumentException(
-            "The type of the option value is not the same as the type value provided"
+        @Suppress("UNCHECKED_CAST") val opt = get(key) as PatchOption<T>
+        if (opt.value !is T) throw InvalidTypeException(
+            T::class.java.canonicalName,
+            opt.value?.let { it::class.java.canonicalName } ?: "null"
         )
         opt.value = value
     }
 
+    /**
+     * Sets the value of a [PatchOption] to `null`.
+     * @param key The key of the [PatchOption].
+     */
+    fun nullify(key: String) {
+        get(key).value = null
+    }
+
     override fun iterator() = options.iterator()
 }
 
@@ -55,9 +71,37 @@ sealed class PatchOption<T>(
     default: T?,
     val title: String,
     val description: String,
-    val required: Boolean
+    val required: Boolean,
+    val validator: (T?) -> Boolean
 ) {
     var value: T? = default
+        set(value) {
+            if (value == null && required) {
+                throw RequirementNotMetException()
+            }
+            if (!validator(value)) {
+                throw IllegalValueException(value)
+            }
+            field = value
+        }
+
+    /**
+     * Gets the value of the option.
+     * Please note that using the wrong value type results in a runtime error.
+     */
+    operator fun <T> getValue(thisRef: Nothing?, property: KProperty<*>) = value as T
+
+    /**
+     * Gets the value of the option.
+     * Please note that using the wrong value type results in a runtime error.
+     */
+    inline operator fun <reified V> setValue(thisRef: Any?, property: KProperty<*>, new: V) {
+        if (value !is V) throw InvalidTypeException(
+            V::class.java.canonicalName,
+            value?.let { it::class.java.canonicalName } ?: "null"
+        )
+        value = new as T
+    }
 
     /**
      * A [PatchOption] representing a [String].
@@ -68,9 +112,10 @@ sealed class PatchOption<T>(
         default: String?,
         title: String,
         description: String,
-        required: Boolean = false
+        required: Boolean = false,
+        validator: (String?) -> Boolean = { true }
     ) : PatchOption<String>(
-        key, default, title, description, required
+        key, default, title, description, required, validator
     )
 
     /**
@@ -82,9 +127,10 @@ sealed class PatchOption<T>(
         default: Boolean?,
         title: String,
         description: String,
-        required: Boolean = false
+        required: Boolean = false,
+        validator: (Boolean?) -> Boolean = { true }
     ) : PatchOption<Boolean>(
-        key, default, title, description, required
+        key, default, title, description, required, validator
     )
 
     /**
@@ -98,9 +144,12 @@ sealed class PatchOption<T>(
         val options: Iterable<E>,
         title: String,
         description: String,
-        required: Boolean = false
+        required: Boolean = false,
+        validator: (E?) -> Boolean = { true }
     ) : PatchOption<E>(
-        key, default, title, description, required
+        key, default, title, description, required, {
+            (it?.let { it in options } ?: true) && validator(it)
+        }
     ) {
         init {
             if (default !in options) {
@@ -119,9 +168,10 @@ sealed class PatchOption<T>(
         options: Iterable<String>,
         title: String,
         description: String,
-        required: Boolean = false
+        required: Boolean = false,
+        validator: (String?) -> Boolean = { true }
     ) : ListOption<String>(
-        key, default, options, title, description, required
+        key, default, options, title, description, required, validator
     )
 
     /**
@@ -134,8 +184,9 @@ sealed class PatchOption<T>(
         options: Iterable<Int>,
         title: String,
         description: String,
-        required: Boolean = false
+        required: Boolean = false,
+        validator: (Int?) -> Boolean = { true }
     ) : ListOption<Int>(
-        key, default, options, title, description, required
+        key, default, options, title, description, required, validator
     )
 }

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

@@ -19,29 +19,6 @@ annotation class Patch(val include: Boolean = true)
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.RUNTIME)
 @MustBeDocumented
-@Deprecated(
-    "Does not support new parameter 'type'",
-    ReplaceWith("DependsOn")
-)
-annotation class Dependencies(
-    val dependencies: Array<KClass<out Patch<Data>>> = []
-)
-
-/**
- * Annotation for dependencies of [Patch]es .
- */
-@Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
-@MustBeDocumented
-@Repeatable
 annotation class DependsOn(
-    val value: KClass<out Patch<Data>>,
-    val type: DependencyType = DependencyType.HARD
-)
-
-enum class DependencyType {
-    /**
-     * Enforces that the dependency is applied, even if it was not selected.
-     */
-    HARD
-}
+    val dependencies: Array<KClass<out Patch<Data>>> = []
+)

src/test/kotlin/app/revanced/patcher/patch/PatchOptionsTest.kt

@@ -0,0 +1,85 @@
+package app.revanced.patcher.patch
+
+import app.revanced.patcher.usage.bytecode.ExampleBytecodePatch
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import kotlin.test.assertNotEquals
+
+internal class PatchOptionsTest {
+    private val options = ExampleBytecodePatch().options
+
+    @Test
+    fun `should not throw an exception`() {
+        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)
+                    }
+                }
+            }
+        }
+        val option = options["key1"]
+        println(option.value)
+        options["key1"] = "Hello, world!"
+        println(option.value)
+    }
+
+    @Test
+    fun `should return a different value when changed`() {
+        var value: String by options["key1"]
+        val current = value + "" // force a copy
+        value = "Hello, world!"
+        assertNotEquals(current, value)
+    }
+
+    @Test
+    fun `should be able to set value to null`() {
+        // Sadly, doing:
+        // > options["key2"] = null
+        // is not possible because Kotlin
+        // cannot reify the type "Nothing?".
+        options.nullify("key2")
+    }
+
+    @Test
+    fun `should fail because the option does not exist`() {
+        assertThrows<NoSuchOptionException> {
+            options["this option does not exist"] = 123
+        }
+    }
+
+    @Test
+    fun `should fail because of invalid value type`() {
+        assertThrows<InvalidTypeException> {
+            options["key1"] = 123
+        }
+    }
+
+    @Test
+    fun `should fail because of an illegal value`() {
+        assertThrows<IllegalValueException> {
+            options["key3"] = "this value is not an allowed option"
+        }
+    }
+
+    @Test
+    fun `should fail because of the requirement is not met`() {
+        assertThrows<RequirementNotMetException> {
+            options.nullify("key1")
+        }
+    }
+}

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

@@ -1,37 +0,0 @@
-package app.revanced.patcher.usage
-
-import app.revanced.patcher.patch.PatchOption
-import app.revanced.patcher.usage.bytecode.ExampleBytecodePatch
-import kotlin.test.Test
-
-internal class PatchOptionsUsage {
-    @Test
-    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)
-                    }
-                }
-            }
-        }
-        println(options["key1"].value)
-        options["key1"] = "Hello, world!"
-        println(options["key1"].value)
-    }
-}

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

@@ -11,7 +11,6 @@ import app.revanced.patcher.patch.PatchOption
 import app.revanced.patcher.patch.PatchOptions
 import app.revanced.patcher.patch.PatchResult
 import app.revanced.patcher.patch.PatchResultSuccess
-import app.revanced.patcher.patch.annotations.DependencyType
 import app.revanced.patcher.patch.annotations.DependsOn
 import app.revanced.patcher.patch.annotations.Patch
 import app.revanced.patcher.patch.impl.BytecodePatch
@@ -39,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.HARD)
+@DependsOn([ExampleBytecodePatch::class])
 class ExampleBytecodePatch : BytecodePatch(listOf(ExampleFingerprint)) {
     // This function will be executed by the patcher.
     // You can treat it as a constructor