@callstack/react-native-brownfield 5.0.2 → 5.1.1

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

@@ -0,0 +1,47 @@
+package com.callstack.react.brownfield.expo
+
+import com.callstack.react.brownfield.shared.VersionMediatingDependencySet
+import org.gradle.api.Project
+import org.gradle.testfixtures.ProjectBuilder
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class ExpoPublishingHelperGradleFallbackTest {
+    @Test
+    fun `Gradle-fallback discovery picks up runtimeOnly dependencies`() {
+        val root = ProjectBuilder.builder().build()
+        val expoPkgProject = ProjectBuilder.builder().withParent(root).withName("expo-fake-module").build()
+
+        expoPkgProject.configurations.create("implementation")
+        expoPkgProject.configurations.create("api")
+        expoPkgProject.configurations.create("runtimeOnly")
+        expoPkgProject.dependencies.add("runtimeOnly", "androidx.annotation:annotation:1.9.1")
+
+        val helper =
+            object : ExpoPublishingHelper(brownfieldAppProject = root) {
+                fun exposedAppend(
+                    pkgProject: Project,
+                    deps: VersionMediatingDependencySet,
+                ) {
+                    appendExpoTransitiveDependenciesFromGradle(pkgProject, deps)
+                }
+            }
+
+        val discovered = VersionMediatingDependencySet()
+        helper.exposedAppend(expoPkgProject, discovered)
+
+        // Coordinate-only check: VersionMediatingDependencySet keys on groupId/artifactId, so
+        // passing a scope here would be inert and would read as contradicting the scope
+        // assertion below.
+        assertTrue(
+            discovered.any { it.groupId == "androidx.annotation" && it.artifactId == "annotation" },
+            "expected the runtimeOnly dependency to be discovered via the Gradle fallback path",
+        )
+        assertEquals(
+            "runtime",
+            discovered.first { it.groupId == "androidx.annotation" }.scope,
+            "runtimeOnly dependencies should be published under Maven's runtime scope, not compile",
+        )
+    }
+}

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

@@ -0,0 +1,110 @@
+package com.callstack.react.brownfield.plugin
+
+import com.callstack.react.brownfield.shared.Constants
+import org.gradle.testkit.runner.GradleRunner
+import org.junit.jupiter.api.Assumptions.assumeTrue
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.io.TempDir
+import java.io.File
+import kotlin.test.assertFalse
+
+/**
+ * Guards the pre-migration consumer shape no in-repo app has any more: one that still hand-registers
+ * `removeDependenciesFromModuleFile` as the setup docs instruct. If the plugin ever claims that name
+ * again, configuration fails outright for every consumer who hasn't migrated.
+ *
+ * Skipped without an Android SDK, since the plugin requires `com.android.library`.
+ */
+class LegacyConsumerConfigurationTest {
+    @Test
+    fun `a project still registering the documented legacy task configures successfully`(
+        @TempDir projectDir: File,
+    ) {
+        val androidSdk = System.getenv("ANDROID_HOME") ?: System.getenv("ANDROID_SDK_ROOT")
+        assumeTrue(
+            androidSdk != null && File(androidSdk).isDirectory,
+            "no Android SDK available (ANDROID_HOME/ANDROID_SDK_ROOT); skipping AGP-dependent test",
+        )
+
+        writeLegacyConsumerFixture(projectDir, androidSdk!!)
+
+        val result =
+            GradleRunner.create()
+                .withProjectDir(projectDir)
+                .withPluginClasspath()
+                .withArguments("tasks", "--stacktrace")
+                .forwardOutput()
+                .build()
+
+        // build() already failed above on any unrelated fixture breakage; this narrows a failure
+        // here to the duplicate-task-name case specifically.
+        assertFalse(
+            result.output.contains("as a task with that name already exists"),
+            "build output reports a duplicate task name; the plugin most likely claimed " +
+                "'${Constants.LEGACY_CONSUMER_MODULE_METADATA_TASK_NAME}', which the setup docs " +
+                "reserve for consumers",
+        )
+    }
+
+    private fun writeLegacyConsumerFixture(
+        projectDir: File,
+        androidSdk: String,
+    ) {
+        File(projectDir, "settings.gradle.kts").writeText(
+            """
+            dependencyResolutionManagement {
+                repositories {
+                    google()
+                    mavenCentral()
+                }
+            }
+            rootProject.name = "legacy-consumer"
+            include(":app")
+            include(":brownfieldlib")
+            """.trimIndent(),
+        )
+        File(projectDir, "local.properties").writeText("sdk.dir=$androidSdk\n")
+        // ArtifactsResolver looks for an `app` project; an empty stub is enough, this test is about
+        // the task container, not discovery.
+        File(projectDir, "app").mkdirs()
+        File(projectDir, "app/build.gradle.kts").writeText("")
+
+        // The `tasks.register("removeDependenciesFromModuleFile")` block below is verbatim from
+        // the published setup docs. Do not "modernize" it — its whole purpose is to reproduce
+        // what a not-yet-migrated consumer actually has in their build script.
+        File(projectDir, "brownfieldlib").mkdirs()
+        File(projectDir, "brownfieldlib/build.gradle.kts").writeText(
+            """
+            import groovy.json.JsonOutput
+            import groovy.json.JsonSlurper
+
+            plugins {
+                id("com.android.library")
+                id("com.callstack.react.brownfield")
+                `maven-publish`
+            }
+
+            android {
+                namespace = "com.example.legacyconsumer"
+                compileSdk = 34
+            }
+
+            val moduleBuildDir: Directory = layout.buildDirectory.get()
+
+            tasks.register("removeDependenciesFromModuleFile") {
+                doLast {
+                    file("${'$'}moduleBuildDir/publications/mavenAar/module.json").run {
+                        val json = inputStream().use { JsonSlurper().parse(it) as Map<String, Any> }
+                        (json["variants"] as? List<MutableMap<String, Any>>)?.forEach { variant ->
+                            (variant["dependencies"] as? MutableList<Map<String, Any>>)?.removeAll {
+                                it["group"] == rootProject.name
+                            }
+                        }
+                        writer().use { it.write(JsonOutput.prettyPrint(JsonOutput.toJson(json))) }
+                    }
+                }
+            }
+            """.trimIndent(),
+        )
+    }
+}

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

@@ -0,0 +1,67 @@
+package com.callstack.react.brownfield.shared
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class DependencyPublishabilityTest {
+    @Test
+    fun `rejects a fully dynamic version`() {
+        val dep = DependencyInfo("com.facebook.react", "react-native", "+", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects a partially dynamic version`() {
+        val dep = DependencyInfo("androidx.core", "core-ktx", "1.+", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects a null version`() {
+        val dep = DependencyInfo("com.facebook.react", "react-android", null, "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects a blank version`() {
+        val dep = DependencyInfo("com.facebook.react", "react-android", "  ", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `accepts a normal pinned version`() {
+        val dep = DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false)
+        assertTrue(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects latest_release`() {
+        val dep = DependencyInfo("androidx.core", "core-ktx", "latest.release", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects latest_integration`() {
+        val dep = DependencyInfo("androidx.core", "core-ktx", "latest.integration", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects a closed Maven version range`() {
+        val dep = DependencyInfo("androidx.core", "core-ktx", "[1.0,2.0]", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects a half-open Maven version range`() {
+        val dep = DependencyInfo("androidx.core", "core-ktx", "[1.0,2.0)", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects an unbounded Maven version range`() {
+        val dep = DependencyInfo("androidx.core", "core-ktx", "[1.0,)", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+}

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

@@ -0,0 +1,222 @@
+package com.callstack.react.brownfield.shared
+
+import groovy.util.NodeList
+import groovy.xml.XmlParser
+import org.gradle.testfixtures.ProjectBuilder
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class PublishingMetadataInjectorTaskRegistrationTest {
+    @Test
+    fun `does not claim the task name the setup docs tell consumers to register`() {
+        val project = ProjectBuilder.builder().build()
+
+        PublishingMetadataInjector(project)
+
+        assertNull(
+            project.tasks.findByName(Constants.LEGACY_CONSUMER_MODULE_METADATA_TASK_NAME),
+            "the plugin must leave this name free: the published setup docs tell every bare-RN " +
+                "consumer to register it themselves, and the plugin applies before their script body",
+        )
+        assertNotNull(
+            project.tasks.findByName(Constants.MODULE_METADATA_POST_PROCESS_TASK_NAME),
+        )
+    }
+
+    @Test
+    fun `a not-yet-migrated consumer can still register the legacy task after the plugin has run`() {
+        // The upgrade path at the task-container level: plugin registers during apply(), then the
+        // consumer's script body registers the task the docs told them to. Must not throw.
+        val project = ProjectBuilder.builder().build()
+
+        PublishingMetadataInjector(project)
+        project.tasks.register(Constants.LEGACY_CONSUMER_MODULE_METADATA_TASK_NAME)
+
+        assertNotNull(project.tasks.findByName(Constants.LEGACY_CONSUMER_MODULE_METADATA_TASK_NAME))
+        assertNotNull(project.tasks.findByName(Constants.MODULE_METADATA_POST_PROCESS_TASK_NAME))
+    }
+}
+
+class MutatePomDependenciesNodeTest {
+    private fun dependenciesNodeFrom(xml: String): groovy.util.Node {
+        val root = XmlParser().parseText(xml)
+        return (root.get("dependencies") as NodeList).first() as groovy.util.Node
+    }
+
+    private fun versionsFor(
+        dependenciesNode: groovy.util.Node,
+        groupId: String,
+        artifactId: String,
+    ): List<String> {
+        return dependenciesNode.children()
+            .filterIsInstance<groovy.util.Node>()
+            .filter {
+                (it["groupId"] as NodeList).text() == groupId && (it["artifactId"] as NodeList).text() == artifactId
+            }
+            .map { (it["version"] as NodeList).text() }
+    }
+
+    @Test
+    fun `appends new dependencies with no pre-existing entries`() {
+        val dependenciesNode = dependenciesNodeFrom("<project><dependencies/></project>")
+        val toInject = VersionMediatingDependencySet()
+        toInject.add(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false))
+
+        mutatePomDependenciesNode(dependenciesNode, toInject) { _, _ -> false }
+
+        assertEquals(listOf("1.17.0"), versionsFor(dependenciesNode, "androidx.core", "core-ktx"))
+    }
+
+    @Test
+    fun `injects into a POM that has no dependencies element at all`() {
+        // Must call resolveOrCreateDependenciesNode — inlining the fallback here would make this
+        // pass even with the production path reverted to first().
+        val root = XmlParser().parseText("<project/>")
+        val toInject = VersionMediatingDependencySet()
+        toInject.add(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false))
+
+        val dependenciesNode = resolveOrCreateDependenciesNode(root)
+        mutatePomDependenciesNode(dependenciesNode, toInject) { _, _ -> false }
+
+        assertEquals(listOf("1.17.0"), versionsFor(dependenciesNode, "androidx.core", "core-ktx"))
+    }
+
+    @Test
+    fun `reuses the existing dependencies element instead of appending a second one`() {
+        val root =
+            XmlParser().parseText(
+                """
+                <project>
+                  <dependencies>
+                    <dependency>
+                      <groupId>androidx.core</groupId>
+                      <artifactId>core-ktx</artifactId>
+                      <version>1.17.0</version>
+                    </dependency>
+                  </dependencies>
+                </project>
+                """.trimIndent(),
+            )
+
+        val dependenciesNode = resolveOrCreateDependenciesNode(root)
+
+        assertEquals(
+            1,
+            (root.get("dependencies") as NodeList).size,
+            "a POM that already has <dependencies> must not gain a second one",
+        )
+        assertEquals(listOf("1.17.0"), versionsFor(dependenciesNode, "androidx.core", "core-ktx"))
+    }
+
+    @Test
+    fun `removes an unrelated excluded entry that is not being re-injected`() {
+        val dependenciesNode =
+            dependenciesNodeFrom(
+                """
+                <project>
+                  <dependencies>
+                    <dependency>
+                      <groupId>com.rnapp</groupId>
+                      <artifactId>brownfieldlib</artifactId>
+                      <version>unspecified</version>
+                    </dependency>
+                  </dependencies>
+                </project>
+                """.trimIndent(),
+            )
+
+        mutatePomDependenciesNode(dependenciesNode, VersionMediatingDependencySet()) { groupId, _ ->
+            groupId == "com.rnapp"
+        }
+
+        assertTrue(versionsFor(dependenciesNode, "com.rnapp", "brownfieldlib").isEmpty())
+    }
+
+    @Test
+    fun `a superseded stale entry is replaced by the mediated version, not left duplicated or missing`() {
+        // Consumer hand-declares 1.6.0, embedded module needs 1.7.1, so the coordinate is
+        // superseded and shouldExclude matches it. The mediated 1.7.1 must survive exactly once.
+        val dependenciesNode =
+            dependenciesNodeFrom(
+                """
+                <project>
+                  <dependencies>
+                    <dependency>
+                      <groupId>androidx.appcompat</groupId>
+                      <artifactId>appcompat</artifactId>
+                      <version>1.6.0</version>
+                      <scope>runtime</scope>
+                    </dependency>
+                  </dependencies>
+                </project>
+                """.trimIndent(),
+            )
+        val mediated = VersionMediatingDependencySet()
+        mediated.add(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false))
+
+        mutatePomDependenciesNode(dependenciesNode, mediated) { groupId, artifactId ->
+            groupId == "androidx.appcompat" && artifactId == "appcompat"
+        }
+
+        assertEquals(listOf("1.7.1"), versionsFor(dependenciesNode, "androidx.appcompat", "appcompat"))
+    }
+}
+
+class MutateModuleJsonVariantsTest {
+    private fun jsonWithVariant(dependencies: MutableList<MutableMap<String, Any>>): MutableMap<String, Any> {
+        return mutableMapOf(
+            "variants" to
+                mutableListOf(
+                    mutableMapOf<String, Any>(
+                        "name" to "runtimeElements",
+                        "dependencies" to dependencies,
+                    ),
+                ),
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun dependenciesOf(json: Map<*, *>): List<Map<String, Any>> {
+        val variants = json["variants"] as List<Map<String, Any>>
+        return variants.first()["dependencies"] as List<Map<String, Any>>
+    }
+
+    @Test
+    fun `appends new dependencies with no pre-existing entries`() {
+        val json = jsonWithVariant(mutableListOf())
+        val toInject = VersionMediatingDependencySet()
+        toInject.add(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false))
+
+        mutateModuleJsonVariants(json, toInject) { _, _ -> false }
+
+        val deps = dependenciesOf(json)
+        assertEquals(1, deps.size)
+        assertEquals("androidx.core", deps.first()["group"])
+        assertEquals("core-ktx", deps.first()["module"])
+    }
+
+    @Test
+    fun `a superseded stale entry is replaced by the mediated version, not left duplicated or missing`() {
+        val json =
+            jsonWithVariant(
+                mutableListOf(
+                    mutableMapOf("group" to "androidx.appcompat", "module" to "appcompat"),
+                ),
+            )
+        val mediated = VersionMediatingDependencySet()
+        mediated.add(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false))
+
+        mutateModuleJsonVariants(json, mediated) { group, module ->
+            group == "androidx.appcompat" && module == "appcompat"
+        }
+
+        val deps = dependenciesOf(json)
+        assertEquals(1, deps.size, "expected exactly one entry, not zero (deleted) or two (duplicated)")
+        @Suppress("UNCHECKED_CAST")
+        val version = (deps.first()["version"] as? Map<String, Any>)?.get("requires")
+        assertEquals("1.7.1", version)
+    }
+}

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

@@ -0,0 +1,37 @@
+package com.callstack.react.brownfield.shared
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class TransitiveDependencyFilteringTest {
+    @Test
+    fun `drops a hard-excluded coordinate the RNC discoverer found, even though it has no Expo awareness`() {
+        // The RNC discoverer has no Expo blacklist, so an embedded module depending on an Expo
+        // coordinate would otherwise be published as a Maven dependency that resolves nowhere.
+        val transitiveDeps = VersionMediatingDependencySet()
+        transitiveDeps.add(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false))
+        transitiveDeps.add(DependencyInfo("host.exp.exponent", "expo.modules.device", "56.0.4", "compile", false))
+
+        val hardExcludePredicate: (String, String) -> Boolean = { groupId, _ -> groupId == "host.exp.exponent" }
+        dropHardExcludedDependencies(transitiveDeps, hardExcludePredicate)
+
+        assertTrue(transitiveDeps.contains(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false)))
+        assertFalse(transitiveDeps.any { it.groupId == "host.exp.exponent" })
+        assertEquals(1, transitiveDeps.size)
+    }
+
+    @Test
+    fun `does not drop a superseded coordinate that is meant to still be injected`() {
+        // hardExcludePredicate must never include the supersede check, or a mediated
+        // replacement for a consumer's stale hand-declared dependency would be dropped too.
+        val transitiveDeps = VersionMediatingDependencySet()
+        transitiveDeps.add(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false))
+
+        dropHardExcludedDependencies(transitiveDeps) { _, _ -> false }
+
+        assertTrue(transitiveDeps.contains(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false)))
+        assertEquals(1, transitiveDeps.size)
+    }
+}

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

@@ -0,0 +1,42 @@
+package com.callstack.react.brownfield.shared
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class VersionMediatingDependencySetTest {
+    @Test
+    fun `keeps the higher version when the same coordinate is added twice`() {
+        val set = VersionMediatingDependencySet()
+
+        set.add(DependencyInfo("androidx.appcompat", "appcompat", "1.6.0", "compile", false))
+        set.add(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false))
+
+        assertEquals(1, set.size)
+        assertTrue(set.contains(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false)))
+    }
+
+    @Test
+    fun `does not downgrade when a lower version is added second`() {
+        val set = VersionMediatingDependencySet()
+
+        set.add(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false))
+        set.add(DependencyInfo("androidx.appcompat", "appcompat", "1.6.0", "compile", false))
+
+        val kept = set.first { it.groupId == "androidx.appcompat" }
+        assertEquals("1.7.1", kept.version)
+    }
+
+    @Test
+    fun `removeAll removes matching entries and returns them`() {
+        val set = VersionMediatingDependencySet()
+        set.add(DependencyInfo("host.exp.exponent", "expo", "1.0.0", "compile", false))
+        set.add(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false))
+
+        val removed = set.removeAll { it.groupId == "host.exp.exponent" }
+
+        assertEquals(1, removed.size)
+        assertEquals(1, set.size)
+        assertTrue(set.contains(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false)))
+    }
+}

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

@@ -0,0 +1,11 @@
+package com.callstack.react.brownfield.utils
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertTrue
+
+class ExtensionTest {
+    @Test
+    fun `experimentalIncludeTransitiveDependencies defaults to true`() {
+        assertTrue(Extension().experimentalIncludeTransitiveDependencies)
+    }
+}

package/ios/BrownfieldReactHostPreloader.h

@@ -0,0 +1,30 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Creates and starts the React Host, but does not create a view. React Native loads and evaluates
+ * the JavaScript bundle immediately, and not when it mounts the first React Native view.
+ * `viewWithModuleName:` makes the same call internally, thus a view that you create later uses the
+ * host that is ready.
+ *
+ * This class is in Objective-C, because Swift cannot make this call:
+ * `RCTReactNativeFactory.devMenuConfiguration` is nullable, but the related parameter is not
+ * nullable.
+ */
+@interface BrownfieldReactHostPreloader : NSObject
+
+/**
+ * Call this method on the main thread. If a host is already available, this method does nothing.
+ *
+ * @param reactNativeFactory An `RCTReactNativeFactory`, or a subclass, for example
+ *   `ExpoReactNativeFactory`. The type is `id`, because this header must stay free of the React
+ *   Native imports.
+ * @param launchOptions The launch options for the React Host.
+ */
++ (void)preloadWithReactNativeFactory:(id)reactNativeFactory
+                        launchOptions:(nullable NSDictionary *)launchOptions;
+
+@end
+
+NS_ASSUME_NONNULL_END