@callstack/react-native-brownfield 6.0.1 → 6.1.1

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/processors/VariantTaskProvider.kt

@@ -66,6 +66,10 @@ class VariantTaskProvider(val project: Project) {
             it.dependsOn(VariantHelper.getJavaCompileTask(project, capitalizedVariantName))
             it.variantName.set(variantName)
             it.inputClassesJars.from(aarLibraries.map { aarLibrary -> aarLibrary.getClassesJarFile() })
+            // libs/*.jar of each library (#489)
+            it.inputClassesJars.from(
+                aarLibraries.map { aarLibrary -> project.fileTree(aarLibrary.getLibsDir()) { tree -> tree.include("*.jar") } },
+            )
             it.outputDir.set(DirectoryManager.getMergeClassDirectory(variantName))
         }
     }

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/shared/GradleExclude.kt

@@ -0,0 +1,31 @@
+package com.callstack.react.brownfield.shared
+
+import org.gradle.api.Project
+
+/**
+ * The variant-independent configurations that feed what the host app gets. A variant's own
+ * (`debugRuntimeClasspath`) would leak into every variant, since the published list is shared, and a
+ * tool's (lint, detekt) may exclude things the app still needs.
+ */
+private val PUBLISHED_CONFIG_NAMES = TRANSITIVE_DEPENDENCY_CONFIG_NAMES + "embed"
+
+/**
+ * The configuration-level excludes that keep a dependency out of the brownfield module's build.
+ * The plugin reads what embedded libraries declare, not what Gradle resolves, so without these an
+ * excluded dependency would still be published and the host app would resolve it. `:app`'s rules
+ * are not read: they describe the standalone RN app, which may drop things the host needs.
+ */
+internal fun gradleExcludes(project: Project): List<GradleExclude> =
+    project.configurations
+        .filter { it.name in PUBLISHED_CONFIG_NAMES }
+        .flatMap { it.excludeRules }
+        .map { GradleExclude(it.group, it.module) }
+        .distinct()
+
+/** One exclude rule. Gradle types both parts as non-null, but a rule without one leaves it null. */
+internal data class GradleExclude(val group: String?, val module: String?) {
+    fun matches(
+        groupId: String,
+        artifactId: String,
+    ) = (group == null || group == groupId) && (module == null || module == artifactId)
+}

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/shared/MergeClassesTask.kt

@@ -54,6 +54,8 @@ abstract class MergeClassesTask : DefaultTask() {
             copyTask.from(mergedOutputDir)
             copyTask.into(javacDir)
             copyTask.exclude("META-INF/")
+            // Root module descriptor of a library's local jar, not a class of the AAR.
+            copyTask.exclude("module-info.class")
         }
 
         project.copy { copyTask ->

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/shared/PublishingMetadataInjector.kt

@@ -19,6 +19,7 @@ import org.gradle.api.publish.tasks.GenerateModuleMetadata
 internal fun mutatePomDependenciesNode(
     dependenciesNode: Node,
     dependencies: VersionMediatingDependencySet,
+    excludes: List<GradleExclude> = emptyList(),
     shouldExclude: (groupId: String, artifactId: String) -> Boolean,
 ) {
     dependenciesNode.children()
@@ -49,6 +50,21 @@ internal fun mutatePomDependenciesNode(
             childTags.forEach { (tagName, tagValue) ->
                 newDepNode.appendNode(tagName, tagValue)
             }
+            appendExclusions(newDepNode, excludes)
+        }
+    }
+}
+
+private fun appendExclusions(
+    dependencyNode: Node,
+    excludes: List<GradleExclude>,
+) {
+    if (excludes.isEmpty()) return
+    val exclusionsNode = dependencyNode.appendNode("exclusions")
+    excludes.forEach { exclude ->
+        exclusionsNode.appendNode("exclusion").apply {
+            appendNode("groupId", exclude.group ?: "*")
+            appendNode("artifactId", exclude.module ?: "*")
         }
     }
 }
@@ -69,6 +85,7 @@ internal fun resolveOrCreateDependenciesNode(root: Node): Node =
 internal fun mutateModuleJsonVariants(
     json: Map<*, *>,
     dependencies: VersionMediatingDependencySet,
+    excludes: List<GradleExclude> = emptyList(),
     shouldExclude: (groupId: String, artifactId: String) -> Boolean,
 ) {
     @Suppress("UNCHECKED_CAST")
@@ -98,6 +115,9 @@ internal fun mutateModuleJsonVariants(
                     dependencyToAdd.version?.let { version ->
                         put("version", mapOf("requires" to version))
                     }
+                    if (excludes.isNotEmpty()) {
+                        put("excludes", excludes.map { mapOf("group" to (it.group ?: "*"), "module" to (it.module ?: "*")) })
+                    }
                 },
             )
         }
@@ -116,6 +136,7 @@ internal fun mutateModuleJsonVariants(
 class PublishingMetadataInjector(private val project: Project) {
     private var dependencies = VersionMediatingDependencySet()
     private var shouldExclude: (groupId: String, artifactId: String) -> Boolean = { _, _ -> false }
+    private var excludes: List<GradleExclude> = emptyList()
     private var enabled = false
 
     init {
@@ -124,12 +145,16 @@ class PublishingMetadataInjector(private val project: Project) {
     }
 
     /** Supplies the dependencies to inject and enables injection on the hooks registered in [init]. */
-    fun configure(
+    internal fun configure(
         dependencies: VersionMediatingDependencySet,
         shouldExclude: (groupId: String, artifactId: String) -> Boolean,
+        excludes: List<GradleExclude>,
     ) {
         this.dependencies = dependencies
         this.shouldExclude = shouldExclude
+        // Gradle writes the module's excludes onto the dependencies it declares; these are injected
+        // later, so they need them too, or an excluded library could still arrive through one.
+        this.excludes = excludes
         this.enabled = true
     }
 
@@ -148,7 +173,7 @@ class PublishingMetadataInjector(private val project: Project) {
                     if (!moduleFile.exists()) return@forEach
 
                     val json = moduleFile.inputStream().use { JsonSlurper().parse(it) as Map<*, *> }
-                    mutateModuleJsonVariants(json, dependencies, shouldExclude)
+                    mutateModuleJsonVariants(json, dependencies, excludes, shouldExclude)
                     moduleFile.writer().use {
                         it.write(JsonOutput.prettyPrint(JsonOutput.toJson(json)))
                     }
@@ -172,7 +197,7 @@ class PublishingMetadataInjector(private val project: Project) {
 
                             val root = it.asNode()
                             val dependenciesNode = resolveOrCreateDependenciesNode(root)
-                            mutatePomDependenciesNode(dependenciesNode, dependencies, shouldExclude)
+                            mutatePomDependenciesNode(dependenciesNode, dependencies, excludes, shouldExclude)
                         }
                     }
             }

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/utils/Extension.kt

@@ -14,7 +14,9 @@ open class Extension {
     var appProjectName = "app"
 
     /**
-     * Whether to use stripped .so files.
+     * Whether to take the .so files from the app module's stripped or unstripped native output. It
+     * does not change which .so files are embedded. AGP still strips the AAR's native libs when it
+     * packages the library.
      *
      * Default is `true`.
      */
@@ -54,6 +56,17 @@ open class Extension {
      */
     var ignoreEmbeddedLibs = listOf<String>()
 
+    /**
+     * Exact .so file names, taken from the app module's native output, to embed in the AAR on top
+     * of the app's own libs and the embedded libraries' libs. Use it for a .so the host app cannot
+     * get any other way: one the app module builds or ships itself, or one from a dependency the
+     * published AAR does not declare.
+     *
+     * Provide in this format:
+     * listOf("libmmkv.so")
+     */
+    var dynamicLibs = listOf<String>()
+
     /**
      * Whether to publish embedded native modules' third-party dependencies into the generated POM
      * and Gradle Module Metadata, so consuming apps resolve them instead of declaring them by hand.

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/utils/TaskOutputs.kt

@@ -0,0 +1,40 @@
+package com.callstack.react.brownfield.utils
+
+import org.gradle.api.GradleException
+import org.gradle.api.Project
+import org.gradle.api.file.DirectoryProperty
+import java.lang.reflect.Method
+
+/**
+ * Finds `taskName`'s `getterName()` that returns a `DirectoryProperty`. Resolving the task by name
+ * (rather than importing its class) keeps this plugin from depending on RNGP's/expo-updates'
+ * internal task types. If the task, or the property, isn't there, this fails the build with a
+ * clear message instead of silently producing an empty or stale directory.
+ */
+internal fun directoryGetter(
+    appProject: Project,
+    taskName: String,
+    getterName: String,
+): Method {
+    val task =
+        appProject.tasks.findByName(taskName)
+            ?: throw GradleException(
+                "brownfield: expected task '$taskName' was not found in project " +
+                    "'${appProject.path}'. Check that the plugin producing it is applied there.",
+            )
+
+    val getter =
+        runCatching { task.javaClass.getMethod(getterName) }.getOrElse {
+            throw GradleException(
+                "brownfield: task '$taskName' (${task.javaClass.name}) does not expose " +
+                    "'$getterName()'. The plugin that registers it most likely changed its " +
+                    "API; the brownfield Gradle plugin needs updating to match.",
+                it,
+            )
+        }
+
+    check(DirectoryProperty::class.java.isAssignableFrom(getter.returnType)) {
+        "brownfield: '$taskName.$getterName()' no longer returns a DirectoryProperty."
+    }
+    return getter
+}

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/plugin/AgpCompatibilityMatrixTest.kt

@@ -7,6 +7,7 @@ import org.junit.jupiter.api.io.TempDir
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.MethodSource
 import java.io.File
+import kotlin.test.assertFalse
 import kotlin.test.assertTrue
 
 /**
@@ -39,12 +40,19 @@ class AgpCompatibilityMatrixTest {
         // `--dry-run` still runs configuration in full — variant callbacks, source set wiring, task
         // graph construction — which is where every AGP API the plugin touches is exercised. It just
         // skips the task actions, which would need a real RN app to produce anything meaningful.
-        GradleRunner.create()
-            .withProjectDir(projectDir)
-            .withPluginClasspath(pluginClasspathFor(agpVersion))
-            .withArguments("assembleDebug", "--dry-run", "--stacktrace")
-            .forwardOutput()
-            .build()
+        val result =
+            GradleRunner.create()
+                .withProjectDir(projectDir)
+                .withPluginClasspath(pluginClasspathFor(agpVersion))
+                .withArguments("assembleDebug", "--dry-run", "--stacktrace")
+                .forwardOutput()
+                .build()
+
+        // AGP 9 turns resValues off by default and warns on every read of variant.resValues.
+        assertFalse(
+            result.output.contains("Accessing value resValues"),
+            "the plugin reads variant.resValues although the feature is disabled",
+        )
     }
 
     @Test

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/plugin/HardExcludePredicateTest.kt

@@ -0,0 +1,28 @@
+package com.callstack.react.brownfield.plugin
+
+import com.callstack.react.brownfield.shared.gradleExcludes
+import org.gradle.testfixtures.ProjectBuilder
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.io.TempDir
+import java.io.File
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class HardExcludePredicateTest {
+    @TempDir
+    lateinit var tempDir: File
+
+    @Test
+    fun `never publishes what the brownfield module excludes, or its own subprojects`() {
+        val root = ProjectBuilder.builder().withName("MyApp").withProjectDir(tempDir).build()
+        val lib = ProjectBuilder.builder().withName("brownfieldlib").withParent(root).build()
+        lib.configurations.create("implementation")
+        lib.configurations.all { it.exclude(mapOf("group" to "com.caverock", "module" to "androidsvg")) }
+
+        val excluded = hardExcludePredicate(lib, null, emptyList(), emptyList(), gradleExcludes(lib))
+
+        assertTrue(excluded("com.caverock", "androidsvg"))
+        assertTrue(excluded("MyApp", "react-native-screens"))
+        assertFalse(excluded("androidx.core", "core-ktx"))
+    }
+}

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/processors/ConfigureProcessJniTaskTest.kt

@@ -0,0 +1,60 @@
+package com.callstack.react.brownfield.processors
+
+import com.callstack.react.brownfield.utils.Extension
+import org.gradle.testfixtures.ProjectBuilder
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.io.TempDir
+import java.io.File
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class ConfigureProcessJniTaskTest {
+    @TempDir
+    lateinit var tempDir: File
+
+    private fun configure(useStripped: Boolean): Pair<ProcessAndCopyJniLibsTask, File> {
+        val root = ProjectBuilder.builder().withProjectDir(tempDir).build()
+        val app = ProjectBuilder.builder().withName("app").withParent(root).build()
+        val lib = ProjectBuilder.builder().withName("BrownfieldLib").withParent(root).build()
+        val ext =
+            Extension().apply {
+                useStrippedSoFiles = useStripped
+                ignoreEmbeddedLibs = listOf("libdatadog")
+                dynamicLibs = listOf("libmmkv.so")
+            }
+        val explode = lib.tasks.register("explodeDevReleaseAar")
+        val task = lib.tasks.register("processJni", ProcessAndCopyJniLibsTask::class.java).get()
+
+        configureProcessJniTask(task, lib, app, ext, "devRelease", listOf(File(tempDir, "jni")), explode)
+        return task to app.layout.buildDirectory.get().asFile
+    }
+
+    @Test
+    fun `wires the stripped source, settings and report path`() {
+        val (task, appBuild) = configure(useStripped = true)
+
+        assertEquals(
+            File(appBuild, "intermediates/stripped_native_libs/devRelease/stripDevReleaseDebugSymbols/out/lib"),
+            task.appNativeLibsDir.get().asFile,
+        )
+        assertTrue(":app:stripDevReleaseDebugSymbols" in task.dependsOn, task.dependsOn.toString())
+        assertTrue(":BrownfieldLib:generateCodegenSchemaFromJavaScript" in task.dependsOn, task.dependsOn.toString())
+        assertEquals(listOf("libdatadog"), task.extraIgnoredLibs.get())
+        assertEquals(listOf("libmmkv.so"), task.dynamicLibs.get())
+        assertTrue(
+            task.skippedReportFile.get().asFile.invariantSeparatorsPath
+                .endsWith("BrownfieldLib/build/reports/brownfield/devRelease/skipped-so.txt"),
+        )
+    }
+
+    @Test
+    fun `wires the unstripped source`() {
+        val (task, appBuild) = configure(useStripped = false)
+
+        assertEquals(
+            File(appBuild, "intermediates/merged_native_libs/devRelease/mergeDevReleaseNativeLibs/out/lib"),
+            task.appNativeLibsDir.get().asFile,
+        )
+        assertTrue(":app:mergeDevReleaseNativeLibs" in task.dependsOn, task.dependsOn.toString())
+    }
+}