chore(release): 1.1.6-dev.1 [skip ci]

## [1.1.6-dev.1](https://github.com/revanced/revanced-cli/compare/v1.1.5...v1.1.6-dev.1) (2022-05-31)

### Bug Fixes

* migrate to latest patcher api changes ([ace70e4](ace70e417f))

.github/workflows/release.yml

@@ -1,5 +1,6 @@
 name: Release
 on:
+  workflow_dispatch:
   push:
     branches:
       - main

CHANGELOG.md

@@ -1,3 +1,24 @@
+## [1.1.6-dev.1](https://github.com/revanced/revanced-cli/compare/v1.1.5...v1.1.6-dev.1) (2022-05-31)
+
+
+### Bug Fixes
+
+* migrate to latest patcher api changes ([ace70e4](https://github.com/revanced/revanced-cli/commit/ace70e417fdf280c7630a5a89a773879fd240e96))
+
+## [1.1.5](https://github.com/revanced/revanced-cli/compare/v1.1.4...v1.1.5) (2022-05-27)
+
+
+### Bug Fixes
+
+* invalid code flow when adding patches ([206f202](https://github.com/revanced/revanced-cli/commit/206f2029d7498b6474c16a47cbe451c170fdd31f))
+
+## [1.1.4](https://github.com/revanced/revanced-cli/compare/v1.1.3...v1.1.4) (2022-05-26)
+
+
+### Bug Fixes
+
+* migrate from `PatchLoader.load(...)` to `JarPatchBundle(...).loadPatches()` ([cabd32f](https://github.com/revanced/revanced-cli/commit/cabd32fda41d32616a61ae450c60e1ee7c35bc59))
+
 ## [1.1.3](https://github.com/revanced/revanced-cli/compare/v1.1.2...v1.1.3) (2022-05-25)
 
 

build.gradle.kts

@@ -24,8 +24,7 @@ repositories {
 
 dependencies {
     implementation("org.jetbrains.kotlin:kotlin-stdlib:1.6.21")
-    implementation("app.revanced:revanced-patcher:+")
+    implementation("app.revanced:revanced-patcher:1.0.0-dev.17")
-    implementation("app.revanced:revanced-patches:+")
 
     implementation("info.picocli:picocli:4.6.3")
 
@@ -68,4 +67,4 @@ publishing {
             from(components["java"])
         }
     }
-}
+}

gradle.properties

@@ -1,2 +1,2 @@
 kotlin.code.style = official
-version = 1.1.3
+version = 1.1.6-dev.1

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.1.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

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

@@ -1,8 +1,8 @@
 package app.revanced.cli
 
+import app.revanced.patcher.PatcherOptions
 import app.revanced.patcher.annotation.Name
-import app.revanced.patcher.extensions.findAnnotationRecursively
+import app.revanced.patcher.util.patch.implementation.JarPatchBundle
-import app.revanced.patcher.util.patch.PatchLoader
 import app.revanced.utils.adb.Adb
 import app.revanced.utils.patcher.addPatchesFiltered
 import app.revanced.utils.signature.Signature
@@ -20,7 +20,7 @@ internal object MainCommand : Runnable {
     internal var includedPatches = arrayOf<String>()
 
     @Option(names = ["-p", "--patches"], description = ["One or more bundles of patches"])
-    internal var patchBundles = arrayOf<File>()
+    internal var patchBundles = arrayOf<String>()
 
     @Option(names = ["-t", "--temp-dir"], description = ["Temporal resource cache directory"], required = true)
     internal lateinit var cacheDirectory: String
@@ -54,21 +54,18 @@ internal object MainCommand : Runnable {
 
     override fun run() {
         if (listOnly) {
-            for (patchBundle in patchBundles)
+            for (patchBundlePath in patchBundles) for (it in JarPatchBundle(patchBundlePath).loadPatches()) {
-                for (it in PatchLoader.loadFromFile(patchBundle))
+
-                    println(
+                // TODO: adjust extension methods to be able to do this
-                        "[available] ${
+                val name = (it.annotations.find { it is Name } as? Name)?.name ?: it.simpleName
-                            it.javaClass.findAnnotationRecursively(
+                println(
-                                Name::class.java
+                    "[available] $name"
-                            )?.name ?: Name::class.java.name
+                )
-                        }"
+            }
-                    )
             return
         }
 
-        val patcher = app.revanced.patcher.Patcher(
+        val patcher = app.revanced.patcher.Patcher(PatcherOptions(inputFile, cacheDirectory, patchResources))
-            inputFile, cacheDirectory, patchResources
-        )
 
         if (signatureCheck) {
             patcher.addPatchesFiltered()
@@ -90,7 +87,7 @@ internal object MainCommand : Runnable {
         if (clean) File(cacheDirectory).deleteRecursively()
 
         adb?.deploy()
-      
+
         if (clean) outputFile.delete()
     }
 }

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

@@ -31,7 +31,8 @@ internal class Patcher {
             }
 
             if (MainCommand.patchResources) {
-                for (file in File(MainCommand.cacheDirectory).resolve("build/").listFiles(FileFilter { it.isDirectory })?.first()?.listFiles()!!) {
+                for (file in File(MainCommand.cacheDirectory).resolve("build/").listFiles(FileFilter { it.isDirectory })
+                    ?.first()?.listFiles()!!) {
                     if (!file.isDirectory) {
                         zipFileSystem.replaceFile(file.name, file.readBytes())
                         continue

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

@@ -2,29 +2,23 @@ package app.revanced.utils.patcher
 
 import app.revanced.cli.MainCommand
 import app.revanced.patcher.Patcher
-import app.revanced.patcher.annotation.Compatibility
-import app.revanced.patcher.annotation.Name
 import app.revanced.patcher.data.base.Data
-import app.revanced.patcher.extensions.findAnnotationRecursively
+import app.revanced.patcher.extensions.PatchExtensions.compatiblePackages
+import app.revanced.patcher.extensions.PatchExtensions.patchName
 import app.revanced.patcher.patch.base.Patch
-import app.revanced.patcher.util.patch.PatchLoader
+import app.revanced.patcher.util.patch.implementation.JarPatchBundle
 
 fun Patcher.addPatchesFiltered(
-    packageCompatibilityFilter: Boolean = true,
-    packageVersionCompatibilityFilter: Boolean = true,
     includeFilter: Boolean = false
 ) {
     val packageName = this.packageName
     val packageVersion = this.packageVersion
 
     MainCommand.patchBundles.forEach { bundle ->
-        val includedPatches = mutableListOf<Patch<Data>>()
+        val includedPatches = mutableListOf<Class<out Patch<Data>>>()
-        PatchLoader.loadFromFile(bundle).forEach patch@{ p ->
+        JarPatchBundle(bundle).loadPatches().forEach patch@{ patch ->
-            val patch = p.getDeclaredConstructor().newInstance()
+            val compatiblePackages = patch.compatiblePackages
-
+            val patchName = patch.patchName
-            val compatibilityAnnotation = patch.javaClass.findAnnotationRecursively(Compatibility::class.java)
-
-            val patchName = patch.javaClass.findAnnotationRecursively(Name::class.java)?.name ?: Name::class.java.name
 
             val prefix = "[skipped] $patchName"
 
@@ -33,21 +27,14 @@ fun Patcher.addPatchesFiltered(
                 return@patch
             }
 
-            if (packageVersionCompatibilityFilter || packageCompatibilityFilter) {
+            if (compatiblePackages == null) println("$prefix: Missing compatibility annotation. Continuing.")
-
+            else compatiblePackages.forEach { compatiblePackage ->
-                if (compatibilityAnnotation == null) {
+                if (compatiblePackage.name != packageName) {
-                    println("$prefix: Missing compatibility annotation.")
+                    println("$prefix: Package name not matching ${compatiblePackage.name}.")
                     return@patch
                 }
 
-
+                if (!compatiblePackage.versions.any { it == packageVersion }) {
-                for (compatiblePackage in compatibilityAnnotation.compatiblePackages) {
-                    if (packageCompatibilityFilter && compatiblePackage.name != packageName) {
-                        println("$prefix: Package name not matching ${compatiblePackage.name}.")
-                        return@patch
-                    }
-
-                    if (!packageVersionCompatibilityFilter || compatiblePackage.versions.any { it == packageVersion }) continue
                     println("$prefix: Unsupported version.")
                     return@patch
                 }
@@ -61,8 +48,13 @@ fun Patcher.addPatchesFiltered(
 }
 
 fun Patcher.applyPatchesPrint() {
-    for ((patch, result) in this.applyPatches()) {
+    this.applyPatches().forEach { (patch, result) ->
-        println("[${if (result.isFailure) "error" else "success"}] $patch")
+        if (result.isSuccess) {
+            println("[success] $patch")
+            return@forEach
+        }
+        println("[error] $patch:")
+        result.exceptionOrNull()!!.printStackTrace()
     }
 }
 

src/main/kotlin/app/revanced/utils/signature/Signature.kt

@@ -1,55 +1,52 @@
 package app.revanced.utils.signature
 
 import app.revanced.patcher.Patcher
-import app.revanced.patcher.extensions.findAnnotationRecursively
-import app.revanced.patcher.signature.implementation.method.annotation.FuzzyPatternScanMethod
-import app.revanced.patcher.signature.implementation.method.annotation.MatchingMethod
 import org.jf.dexlib2.iface.Method
 
 object Signature {
 
     fun checkSignatures(patcher: Patcher) {
+        TODO()
+        /**
         val failed = mutableListOf<String>()
         for (signature in patcher.resolveSignatures()) {
-            val signatureClass = signature::class.java
+        val signatureClass = signature::class.java
-            val signatureName =
+        val signatureName = signature.name ?: signatureClass.simpleName
-                signatureClass.findAnnotationRecursively(app.revanced.patcher.annotation.Name::class.java)?.name
+        if (!signature.resolved) {
-                    ?: signatureClass.name
+        failed.add(signatureName)
-            if (!signature.resolved) {
+        continue
-                failed.add(signatureName)
+        }
-                continue
-            }
 
-            val method = signature.result!!.method
+        val method = signature.result!!.method
-            val matchingMethod =
+        val matchingMethod = signature.matchingMethod ?: MatchingMethod()
-                signatureClass.findAnnotationRecursively(MatchingMethod::class.java) ?: MatchingMethod()
 
-            println(
+        println(
-                """
+        """
-                    [Signature] $signatureName
+        [Signature] $signatureName
-                    [Method] ${matchingMethod.definingClass}->${matchingMethod.name}
+        [Method] ${matchingMethod.definingClass}->${matchingMethod.name}
-                    [Match] ${method.definingClass}->${method.toStr()}
+        [Match] ${method.definingClass}->${method.toStr()}
-                """.trimIndent()
+        """.trimIndent()
-            )
+        )
 
-            signatureClass.findAnnotationRecursively(FuzzyPatternScanMethod::class.java)?.let {
+        signature.fuzzyThreshold.let {
-                val warnings = signature.result!!.scanResult.warnings!!
+        val warnings = signature.result!!.scanResult.warnings!!
-                println(
+        println(
-                    """
+        """
-                        [Warnings: ${warnings.count()}]
+        [Warnings: ${warnings.count()}]
-                        ${warnings.joinToString(separator = "\n") { warning -> "${warning.instructionIndex} / ${warning.patternIndex}: ${warning.wrongOpcode} (expected: ${warning.correctOpcode})" }}
+        ${warnings.joinToString(separator = "\n") { warning -> "${warning.instructionIndex} / ${warning.patternIndex}: ${warning.wrongOpcode} (expected: ${warning.correctOpcode})" }}
-                    """.trimIndent()
+        """.trimIndent()
-                )
+        )
-            }
+        }
         }
 
         println(
-            """
+        """
-                ${"=".repeat(50)}
+        ${"=".repeat(50)}
-                [Failed signatures: ${failed.size}]
+        [Failed signatures: ${failed.size}]
-                ${failed.joinToString(separator = "\n") { it }}
+        ${failed.joinToString(separator = "\n") { it }}
         """.trimIndent()
         )
+         */
     }
 
     private fun Method.toStr(): String {