chore(release): 4.4.1 [skip ci]

## [4.4.1](https://github.com/revanced/revanced-patcher/compare/v4.4.0...v4.4.1) (2022-09-14)

### Bug Fixes

* compare any methods parameters ([#101](https://github.com/revanced/revanced-patcher/issues/101)) ([085a3a4](085a3a479d))

CHANGELOG.md

@@ -1,3 +1,64 @@
+## [4.4.1](https://github.com/revanced/revanced-patcher/compare/v4.4.0...v4.4.1) (2022-09-14)
+
+
+### Bug Fixes
+
+* compare any methods parameters ([#101](https://github.com/revanced/revanced-patcher/issues/101)) ([085a3a4](https://github.com/revanced/revanced-patcher/commit/085a3a479d7bd411dcb0492b283daca538c824a1))
+
+# [4.4.0](https://github.com/revanced/revanced-patcher/compare/v4.3.0...v4.4.0) (2022-09-09)
+
+
+### Features
+
+* add PathOption back ([172655b](https://github.com/revanced/revanced-patcher/commit/172655bde06efdb0955431b44d269e6a64fe317a))
+
+# [4.3.0](https://github.com/revanced/revanced-patcher/compare/v4.2.3...v4.3.0) (2022-09-09)
+
+
+### Features
+
+* improved Patch Options ([e722e3f](https://github.com/revanced/revanced-patcher/commit/e722e3f4f9dc64acf53595802a0a83cf46ee96b8))
+
+## [4.2.3](https://github.com/revanced/revanced-patcher/compare/v4.2.2...v4.2.3) (2022-09-08)
+
+
+### Bug Fixes
+
+* wrong value for iterator in PatchOptions ([e31ac1f](https://github.com/revanced/revanced-patcher/commit/e31ac1f132df56ba7d2f8446d289ae03ef28f67d))
+
+## [4.2.2](https://github.com/revanced/revanced-patcher/compare/v4.2.1...v4.2.2) (2022-09-08)
+
+
+### Bug Fixes
+
+* invalid type propagation in options ([b873228](https://github.com/revanced/revanced-patcher/commit/b873228ef0a9e6e431a4278c979caa5fcc508e0d)), closes [#98](https://github.com/revanced/revanced-patcher/issues/98)
+
+## [4.2.1](https://github.com/revanced/revanced-patcher/compare/v4.2.0...v4.2.1) (2022-09-08)
+
+
+### Bug Fixes
+
+* make patcher version public ([76c45dd](https://github.com/revanced/revanced-patcher/commit/76c45dd7c1ffdca57e30ae7109c9fe0e5768f877))
+
+# [4.2.0](https://github.com/revanced/revanced-patcher/compare/v4.1.5...v4.2.0) (2022-09-08)
+
+
+### Bug Fixes
+
+* remove repeatable from PatchDeprecated ([6e73631](https://github.com/revanced/revanced-patcher/commit/6e73631d4d21e5e862f07ed7517244f36394e5ca))
+
+
+### Features
+
+* SincePatcher annotation ([25f74dc](https://github.com/revanced/revanced-patcher/commit/25f74dc5e9ed1a09258345b920d4f5a0dd7da527))
+
+## [4.1.5](https://github.com/revanced/revanced-patcher/compare/v4.1.4...v4.1.5) (2022-09-08)
+
+
+### Bug Fixes
+
+* broken deprecation message ([62aa295](https://github.com/revanced/revanced-patcher/commit/62aa295e7372014238415af36d902a4e88e2acbc))
+
 ## [4.1.4](https://github.com/revanced/revanced-patcher/compare/v4.1.3...v4.1.4) (2022-09-08)
 
 

build.gradle.kts

@@ -37,6 +37,9 @@ tasks {
             events("PASSED", "SKIPPED", "FAILED")
         }
     }
+    processResources {
+        expand("projectVersion" to project.version)
+    }
 }
 
 java {

gradle.properties

@@ -1,2 +1,2 @@
 kotlin.code.style = official
-version = 4.1.4
+version = 4.4.1

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

@@ -6,6 +6,7 @@ import app.revanced.patcher.data.impl.findIndexed
 import app.revanced.patcher.extensions.PatchExtensions.dependencies
 import app.revanced.patcher.extensions.PatchExtensions.deprecated
 import app.revanced.patcher.extensions.PatchExtensions.patchName
+import app.revanced.patcher.extensions.PatchExtensions.sincePatcherVersion
 import app.revanced.patcher.extensions.nullOutputStream
 import app.revanced.patcher.fingerprint.method.utils.MethodFingerprintUtils.resolve
 import app.revanced.patcher.patch.Patch
@@ -15,6 +16,7 @@ import app.revanced.patcher.patch.PatchResultSuccess
 import app.revanced.patcher.patch.impl.BytecodePatch
 import app.revanced.patcher.patch.impl.ResourcePatch
 import app.revanced.patcher.util.ListBackedSet
+import app.revanced.patcher.util.VersionReader
 import brut.androlib.Androlib
 import brut.androlib.meta.UsesFramework
 import brut.androlib.options.BuildOptions
@@ -36,7 +38,7 @@ import java.io.Closeable
 import java.io.File
 import java.nio.file.Files
 
-val NAMER = BasicDexFileNamer()
+private val NAMER = BasicDexFileNamer()
 
 /**
  * The ReVanced Patcher.
@@ -48,6 +50,11 @@ class Patcher(private val options: PatcherOptions) {
 
     val data: PatcherData
 
+    companion object {
+        @JvmStatic
+        val version = VersionReader.read()
+    }
+
     init {
         val extInputFile = ExtFile(options.inputFile)
         try {
@@ -244,6 +251,15 @@ class Patcher(private val options: PatcherOptions) {
      * @param patches [Patch]es The patches to add.
      */
     fun addPatches(patches: Iterable<Class<out Patch<Data>>>) {
+        for (patch in patches) {
+            val needsVersion = patch.sincePatcherVersion
+            if (needsVersion != null && needsVersion > version) {
+                logger.error("Patch '${patch.patchName}' requires Patcher version $needsVersion or higher")
+                logger.error("Current Patcher version is $version")
+                logger.warn("Skipping '${patch.patchName}'!")
+                continue // TODO: continue or halt/throw?
+            }
+        }
         data.patches.addAll(patches)
     }
 
@@ -291,7 +307,8 @@ class Patcher(private val options: PatcherOptions) {
         }
 
         patch.deprecated?.let { (reason, replacement) ->
-            logger.warn("'$patchName' is deprecated: '$reason'" + if (replacement != null) ". Use '$replacement' instead." else "")
+            logger.warn("'$patchName' is deprecated: $reason")
+            if (replacement != null) logger.warn("Use '${replacement.java.patchName}' instead")
         }
 
         // TODO: find a solution for this

src/main/kotlin/app/revanced/patcher/annotation/Deprecated.kt

@@ -12,7 +12,6 @@ import kotlin.reflect.KClass
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.RUNTIME)
 @MustBeDocumented
-@Repeatable
 annotation class PatchDeprecated(
     val reason: String,
     val replacement: KClass<out Patch<Data>> = Patch::class

src/main/kotlin/app/revanced/patcher/annotation/SincePatcher.kt

@@ -0,0 +1,13 @@
+package app.revanced.patcher.annotation
+
+import app.revanced.patcher.patch.Patch
+import app.revanced.patcher.Patcher
+
+/**
+ * Declares a [Patch] deprecated for removal.
+ * @param version The minimum version of the [Patcher] this [Patch] supports.
+ */
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.RUNTIME)
+@MustBeDocumented
+annotation class SincePatcher(val version: String)

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

@@ -38,7 +38,7 @@ private fun <T : Annotation> Class<*>.findAnnotationRecursively(
 }
 
 object PatchExtensions {
-    val Class<out Patch<Data>>.patchName: String
+    val Class<*>.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
@@ -58,6 +58,7 @@ object PatchExtensions {
                 if (cl == Patch::class) null else cl
             }
         }
+    val Class<out Patch<Data>>.sincePatcherVersion get() = recursiveAnnotation(SincePatcher::class)?.version
 
     @JvmStatic
     fun Class<out Patch<Data>>.dependsOn(patch: Class<out Patch<Data>>): Boolean {

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

@@ -16,7 +16,6 @@ import org.jf.dexlib2.iface.instruction.Instruction
 import org.jf.dexlib2.iface.reference.MethodReference
 import org.jf.dexlib2.immutable.ImmutableMethod
 import org.jf.dexlib2.immutable.ImmutableMethodImplementation
-import org.jf.dexlib2.util.MethodUtil
 import java.io.OutputStream
 
 infix fun AccessFlags.or(other: AccessFlags) = this.value or other.value
@@ -47,16 +46,14 @@ fun MutableMethodImplementation.removeInstructions(index: Int, count: Int) {
 }
 
 /**
- * Compare a method to another, considering constructors and parameters.
+ * Compare a method to another, considering name and parameters.
  * @param otherMethod The method to compare against.
  * @return True if the methods match given the conditions.
  */
 fun Method.softCompareTo(otherMethod: MethodReference): Boolean {
-    if (MethodUtil.isConstructor(this) && !parametersEqual(
-            this.parameterTypes, otherMethod.parameterTypes
-        )
-    ) return false
-    return this.name == otherMethod.name
+    return this.name == otherMethod.name && parametersEqual(
+        this.parameterTypes, otherMethod.parameterTypes
+    )
 }
 
 /**

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

@@ -27,7 +27,7 @@ abstract class OptionsContainer {
     @Suppress("MemberVisibilityCanBePrivate")
     val options = PatchOptions()
 
-    protected fun option(opt: PatchOption<*>): PatchOption<*> {
+    protected fun <T> option(opt: PatchOption<T>): PatchOption<T> {
         options.register(opt)
         return opt
     }

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

@@ -2,8 +2,8 @@
 
 package app.revanced.patcher.patch
 
-import java.io.File
 import java.nio.file.Path
+import kotlin.io.path.pathString
 import kotlin.reflect.KProperty
 
 class NoSuchOptionException(val option: String) : Exception("No such option: $option")
@@ -17,7 +17,7 @@ object RequirementNotMetException : Exception("null was passed into an option th
  * A registry for an array of [PatchOption]s.
  * @param options An array of [PatchOption]s.
  */
-class PatchOptions(vararg val options: PatchOption<*>) : Iterable<PatchOption<*>> {
+class PatchOptions(vararg options: PatchOption<*>) : Iterable<PatchOption<*>> {
     private val register = mutableMapOf<String, PatchOption<*>>()
 
     init {
@@ -35,8 +35,22 @@ class PatchOptions(vararg val options: PatchOption<*>) : Iterable<PatchOption<*>
      * Get a [PatchOption] by its key.
      * @param key The key of the [PatchOption].
      */
+    @JvmName("getUntyped")
     operator fun get(key: String) = register[key] ?: throw NoSuchOptionException(key)
 
+    /**
+     * Get a [PatchOption] by its key.
+     * @param key The key of the [PatchOption].
+     */
+    inline operator fun <reified T> get(key: String): PatchOption<T> {
+        val opt = get(key)
+        if (opt.value !is T) throw InvalidTypeException(
+            opt.value?.let { it::class.java.canonicalName } ?: "null",
+            T::class.java.canonicalName
+        )
+        return opt as PatchOption<T>
+    }
+
     /**
      * Set the value of a [PatchOption].
      * @param key The key of the [PatchOption].
@@ -44,7 +58,7 @@ 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>
+        val opt = get<T>(key)
         if (opt.value !is T) throw InvalidTypeException(
             T::class.java.canonicalName,
             opt.value?.let { it::class.java.canonicalName } ?: "null"
@@ -60,7 +74,7 @@ class PatchOptions(vararg val options: PatchOption<*>) : Iterable<PatchOption<*>
         get(key).value = null
     }
 
-    override fun iterator() = options.iterator()
+    override fun iterator() = register.values.iterator()
 }
 
 /**
@@ -101,17 +115,23 @@ sealed class PatchOption<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> getValue(thisRef: Any?, property: KProperty<*>) =
-        value as? V ?: throw InvalidTypeException(
+    @JvmName("getValueTyped")
+    inline operator fun <reified V> getValue(thisRef: Nothing?, property: KProperty<*>): V? {
+        if (value !is V?) throw InvalidTypeException(
             V::class.java.canonicalName,
             value?.let { it::class.java.canonicalName } ?: "null"
         )
+        return value as? V?
+    }
+
+    operator fun getValue(thisRef: Any?, property: KProperty<*>) = value
 
     /**
      * 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) {
+    @JvmName("setValueTyped")
+    inline operator fun <reified V> setValue(thisRef: Nothing?, property: KProperty<*>, new: V) {
         if (value !is V) throw InvalidTypeException(
             V::class.java.canonicalName,
             value?.let { it::class.java.canonicalName } ?: "null"
@@ -119,6 +139,10 @@ sealed class PatchOption<T>(
         value = new as T
     }
 
+    operator fun setValue(thisRef: Any?, property: KProperty<*>, new: T?) {
+        value = new
+    }
+
     /**
      * A [PatchOption] representing a [String].
      * @see PatchOption
@@ -207,34 +231,18 @@ sealed class PatchOption<T>(
     )
 
     /**
-     * A [PatchOption] representing a [Path].
+     * A [PatchOption] representing a [Path], backed by a [String].
+     * The validator passes a [String], if you need a [Path] you will have to convert it yourself.
      * @see PatchOption
      */
-    open class PathOption(
+    class PathOption(
         key: String,
         default: Path?,
         title: String,
         description: String,
         required: Boolean = false,
-        validator: (Path?) -> Boolean = { true }
-    ) : PatchOption<Path>(
-        key, default, title, description, required, validator
-    )
-
-    /**
-     * A [PathOption] of type [File].
-     * @see PathOption
-     */
-    class FileOption(
-        key: String,
-        default: File?,
-        title: String,
-        description: String,
-        required: Boolean = false,
-        validator: (File?) -> Boolean = { true }
-    ) : PathOption(
-        key, default?.toPath(), title, description, required, {
-            validator(it?.toFile())
-        }
+        validator: (String?) -> Boolean = { true }
+    ) : PatchOption<String>(
+        key, default?.pathString, title, description, required, validator
     )
 }

src/main/kotlin/app/revanced/patcher/util/VersionReader.kt

@@ -0,0 +1,18 @@
+package app.revanced.patcher.util
+
+import java.util.*
+
+internal object VersionReader {
+    @JvmStatic
+    private val props = Properties().apply {
+        load(
+            VersionReader::class.java.getResourceAsStream("/revanced-patcher/version.properties")
+                ?: throw IllegalStateException("Could not load version.properties")
+        )
+    }
+
+    @JvmStatic
+    fun read(): String {
+        return props.getProperty("version") ?: throw IllegalStateException("Version not found")
+    }
+}

src/main/resources/revanced-patcher/version.properties

@@ -0,0 +1 @@
+version=${projectVersion}

src/test/kotlin/app/revanced/patcher/issues/Issue98.kt

@@ -0,0 +1,18 @@
+package app.revanced.patcher.issues
+
+import app.revanced.patcher.patch.PatchOption
+import org.junit.jupiter.api.Test
+import kotlin.test.assertNull
+
+internal class Issue98 {
+    companion object {
+        var key1: String? by PatchOption.StringOption(
+            "key1", null, "title", "description"
+        )
+    }
+
+    @Test
+    fun `should infer nullable type correctly`() {
+        assertNull(key1)
+    }
+}

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

@@ -3,7 +3,8 @@ 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 java.io.File
+import kotlin.io.path.Path
+import kotlin.io.path.pathString
 import kotlin.test.assertNotEquals
 
 internal class PatchOptionsTest {
@@ -36,11 +37,13 @@ internal class PatchOptionsTest {
                 }
 
                 is PatchOption.PathOption -> {
-                    option.value = File("test.txt").toPath()
+                    option.value = Path("test.txt").pathString
                 }
             }
         }
-        val option = options["key1"]
+        val option = options.get<String>("key1")
+        // or: val option: String? by options["key1"]
+        // then you won't need `.value` every time
         println(option.value)
         options["key1"] = "Hello, world!"
         println(option.value)
@@ -48,7 +51,7 @@ internal class PatchOptionsTest {
 
     @Test
     fun `should return a different value when changed`() {
-        var value: String by options["key1"]
+        var value: String? by options["key1"]
         val current = value + "" // force a copy
         value = "Hello, world!"
         assertNotEquals(current, value)
@@ -60,6 +63,9 @@ internal class PatchOptionsTest {
         // > options["key2"] = null
         // is not possible because Kotlin
         // cannot reify the type "Nothing?".
+        // So we have to do this instead:
+        options["key2"] = null as Any?
+        // This is a cleaner replacement for the above:
         options.nullify("key2")
     }
 
@@ -71,12 +77,19 @@ internal class PatchOptionsTest {
     }
 
     @Test
-    fun `should fail because of invalid value type`() {
+    fun `should fail because of invalid value type when setting an option`() {
         assertThrows<InvalidTypeException> {
             options["key1"] = 123
         }
     }
 
+    @Test
+    fun `should fail because of invalid value type when getting an option`() {
+        assertThrows<InvalidTypeException> {
+            options.get<Int>("key1")
+        }
+    }
+
     @Test
     fun `should fail because of an illegal value`() {
         assertThrows<IllegalValueException> {
@@ -94,7 +107,7 @@ internal class PatchOptionsTest {
     @Test
     fun `should fail because getting a non-initialized option is illegal`() {
         assertThrows<RequirementNotMetException> {
-            println(options["key6"].value)
+            println(options["key5"].value)
         }
     }
 }

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

@@ -32,8 +32,7 @@ import org.jf.dexlib2.immutable.reference.ImmutableFieldReference
 import org.jf.dexlib2.immutable.reference.ImmutableStringReference
 import org.jf.dexlib2.immutable.value.ImmutableFieldEncodedValue
 import org.jf.dexlib2.util.Preconditions
-import java.io.File
-import java.nio.file.Path
+import kotlin.io.path.Path
 
 @Patch
 @Name("example-bytecode-patch")
@@ -171,34 +170,34 @@ class ExampleBytecodePatch : BytecodePatch(listOf(ExampleFingerprint)) {
     }
 
     companion object : OptionsContainer() {
-        private var key1: String by option(
+        private var key1 by option(
             PatchOption.StringOption(
                 "key1", "default", "title", "description", true
             )
         )
-        private var key2: Boolean by option(
+        private var key2 by option(
             PatchOption.BooleanOption(
                 "key2", true, "title", "description" // required defaults to false
             )
         )
-        private var key3: String by option(
+        private var key3 by option(
             PatchOption.StringListOption(
                 "key3", "TEST", listOf("TEST", "TEST1", "TEST2"), "title", "description"
             )
         )
-        private var key4: Int by option(
+        private var key4 by option(
             PatchOption.IntListOption(
                 "key4", 1, listOf(1, 2, 3), "title", "description"
             )
         )
-        private var key5: Path by option(
-            PatchOption.PathOption(
-                "key5", File("test.txt").toPath(), "title", "description"
+        private var key5 by option(
+            PatchOption.StringOption(
+                "key5", null, "title", "description", true
             )
         )
-        private var key6: String by option(
-            PatchOption.StringOption(
-                "key6", null, "title", "description", true
+        private var key6 by option(
+            PatchOption.PathOption(
+                "key6", Path("test.txt"), "title", "description", true
             )
         )
     }

src/test/kotlin/app/revanced/patcher/util/VersionReaderTest.kt

@@ -0,0 +1,20 @@
+package app.revanced.patcher.util
+
+import org.junit.jupiter.api.Test
+
+import org.junit.jupiter.api.Assertions.*
+
+internal class VersionReaderTest {
+    @Test
+    fun read() {
+        val version = VersionReader.read()
+        assertNotNull(version)
+        assertTrue(version.isNotEmpty())
+        val parts = version.split(".")
+        assertEquals(3, parts.size)
+        parts.forEach {
+            assertTrue(it.toInt() >= 0)
+        }
+        println(version)
+    }
+}