Implement conditional Cocoa linking for targets

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Enhancements
+
+- Gradle Plugin: implement conditional Cocoa linking for targets ([#421](https://github.com/getsentry/sentry-kotlin-multiplatform/pull/421))
+
 ## 0.14.0
 
 ### Dependencies

sentry-kotlin-multiplatform-gradle-plugin/build.gradle.kts

@@ -25,6 +25,7 @@ dependencies {
     testImplementation(libs.junit)
     testImplementation(libs.junit.params)
     testImplementation(libs.mockk)
+    testImplementation(libs.truth)
 }
 
 tasks.test {

sentry-kotlin-multiplatform-gradle-plugin/gradle/libs.versions.toml

@@ -18,3 +18,4 @@ kover = { id = "org.jetbrains.kotlinx.kover", version.ref = "kover"}
 junit = "org.junit.jupiter:junit-jupiter-api:5.10.3"
 junit-params = "org.junit.jupiter:junit-jupiter-params:5.10.3"
 mockk = "io.mockk:mockk:1.13.12"
+truth = { module = "com.google.truth:truth", version = "1.4.4" }

sentry-kotlin-multiplatform-gradle-plugin/src/main/java/io/sentry/kotlin/multiplatform/gradle/SentryPlugin.kt

@@ -43,9 +43,13 @@
             }
         }
 
-    internal fun executeConfiguration(project: Project, hostIsMac: Boolean = HostManager.hostIsMac) {
+    internal fun executeConfiguration(
+        project: Project,
+        hostIsMac: Boolean = HostManager.hostIsMac
+    ) {
         val sentryExtension = project.extensions.getByType(SentryExtension::class.java)
-        val hasCocoapodsPlugin = project.plugins.findPlugin(KotlinCocoapodsPlugin::class.java) != null
+        val hasCocoapodsPlugin =
+            project.plugins.findPlugin(KotlinCocoapodsPlugin::class.java) != null
 
         if (sentryExtension.autoInstall.enabled.get()) {
             val autoInstall = sentryExtension.autoInstall
@@ -60,17 +64,61 @@
         }
 
         if (hostIsMac && !hasCocoapodsPlugin) {
-            project.logger.info("Cocoapods plugin not found. Attempting to link Sentry Cocoa framework.")
+            // Register a task graph listener so that we only configure Cocoa framework linking
+            // if at least one Apple target task is part of the requested task graph. This avoids
+            // executing the (potentially expensive) path-resolution logic when the build is only
+            // concerned with non-Apple targets such as Android.
 
-            val kmpExtension = project.extensions.findByName(KOTLIN_EXTENSION_NAME) as? KotlinMultiplatformExtension
-            val appleTargets = kmpExtension?.appleTargets()?.toList()
-                ?: throw GradleException("Error fetching Apple targets from Kotlin Multiplatform plugin.")
+            val kmpExtension =
+                project.extensions.findByName(KOTLIN_EXTENSION_NAME) as? KotlinMultiplatformExtension
+                    ?: throw GradleException("Error fetching Kotlin Multiplatform extension.")
 
-            CocoaFrameworkLinker(
-                logger = project.logger,
-                pathResolver = FrameworkPathResolver(project),
-                binaryLinker = FrameworkLinker(project.logger)
-            ).configure(appleTargets)
+            val appleTargets = kmpExtension.appleTargets().toList()
+
+            if (appleTargets.isEmpty()) {
+                project.logger.info("No Apple targets detected – skipping Sentry Cocoa framework linking setup.")
+                return
+            }
+
+            project.gradle.taskGraph.whenReady { graph ->
+                // Check which of the Kotlin/Native targets are actually in the graph
+                val activeTargets = appleTargets.filter { target ->
+                    val targetName = target.name.replaceFirstChar {
+                        it.uppercase()
+                    }
+                    val path = if (project.path == ":") {
+                        ":compileKotlin$targetName"
+                    } else {
+                        "${project.path}:compileKotlin$targetName"
+                    }
+                    // Will throw if it doesn't exist
+                    graph.hasTask(path)
+                }
+
+                if (activeTargets.isEmpty()) {
+                    project.logger.lifecycle(
+                        "No Apple compile task scheduled for this build " +
+                            "- skipping Sentry Cocoa framework linking"
+                    )
+                    return@whenReady
+                }
+
+                if (activeTargets.size > 1) {
+                    project.logger.warn(
+                        "Cannot set up Sentry Cocoa linking: " +
+                            "expected exactly one Apple target but found ${activeTargets.size} ($activeTargets)."
+                    )
+                    return@whenReady
+                }
+
+                project.logger.lifecycle("Set up Sentry Cocoa linking for target: ${activeTargets.first().name}")
+
+                CocoaFrameworkLinker(
+                    logger = project.logger,
+                    pathResolver = FrameworkPathResolver(project),
+                    binaryLinker = FrameworkLinker(project.logger)
+                ).configure(appleTargets = activeTargets)
+            }
         }
     }
 

sentry-kotlin-multiplatform-gradle-plugin/src/test/java/io/sentry/kotlin/multiplatform/gradle/CocoaFrameworkLinkerIntegrationTest.kt

@@ -0,0 +1,130 @@
+package io.sentry.kotlin.multiplatform.gradle
+
+import com.google.common.truth.Truth.assertThat
+import org.gradle.testkit.runner.GradleRunner
+import org.gradle.testkit.runner.internal.PluginUnderTestMetadataReading
+import org.gradle.testkit.runner.internal.io.SynchronizedOutputStream
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.condition.EnabledOnOs
+import org.junit.jupiter.api.condition.OS
+import org.junit.jupiter.api.io.TempDir
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.io.OutputStreamWriter
+
+@EnabledOnOs(OS.MAC)
+class CocoaFrameworkLinkerIntegrationTest {
+    /**
+     * Verifies that the Cocoa linker is **not** configured when the task graph
+     * contains only non-Apple targets.
+     */
+    @Test
+    fun `linker is not configured when only non-Apple tasks are requested`(@TempDir projectDir: File) {
+        writeBuildFiles(projectDir)
+
+        val output = ByteArrayOutputStream()
+        defaultRunner(projectDir, output)
+            .withArguments("compileKotlinJvm", "--dry-run", "--info")
+            .build()
+
+        assertThat(output.toString())
+            .contains("No Apple compile task scheduled for this build - skipping Sentry Cocoa framework linking")
+    }
+
+    /**
+     * Verifies that the Cocoa linker **is** configured when at least one Apple
+     * task is present in the task graph.
+     */
+    @Test
+    fun `linker is configured when an Apple task is requested`(@TempDir projectDir: File) {
+        writeBuildFiles(projectDir)
+
+        val output = ByteArrayOutputStream()
+        defaultRunner(projectDir, output)
+            .withArguments("compileKotlinIosSimulatorArm64", "--dry-run", "--info")
+            .build()
+
+        assertThat(output.toString())
+            .contains("Set up Sentry Cocoa linking for target: iosSimulatorArm64")
+        assertThat(output.toString())
+            .contains("Start resolving Sentry Cocoa framework paths for target: iosSimulatorArm64")
+    }
+
+    // ---------------------------------------------------------------------
+    // test-fixture helpers
+    // ---------------------------------------------------------------------
+
+    private fun writeBuildFiles(dir: File) {
+        // -----------------------------------------------------------------
+        // Create a fake XCFramework on disk so that the CustomPathStrategy
+        // can resolve a valid framework path even on CI machines where SPM
+        // (and hence DerivedData) is not available.
+        // -----------------------------------------------------------------
+        val fakeFrameworkDir = File(dir, "Sentry-Dynamic.xcframework").apply {
+            // Create minimal structure that satisfies path validation logic
+            val archDirName = "ios-arm64_x86_64-simulator" // architecture used for iosSimulatorArm64
+            val archDir = File(this, archDirName)
+            archDir.mkdirs()
+        }
+
+        File(dir, "settings.gradle").writeText("""rootProject.name = "fixture"""")
+
+        val pluginClasspath = PluginUnderTestMetadataReading
+            .readImplementationClasspath()
+            .joinToString(", ") { "\"${it.absolutePath.replace('\\', '/')}\"" }
+
+        File(dir, "build.gradle").writeText(
+            """
+            buildscript {
+              repositories {
+                google()
+                mavenCentral()
+                gradlePluginPortal()
+              }
+              dependencies {
+                classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$KOTLIN_VERSION"
+                classpath files($pluginClasspath)
+              }
+            }
+
+            apply plugin: 'org.jetbrains.kotlin.multiplatform'
+            apply plugin: 'io.sentry.kotlin.multiplatform.gradle'
+
+            repositories {
+              google()
+              mavenCentral()
+            }
+
+            kotlin {
+              jvm()                // non-Apple target
+              iosSimulatorArm64()   // Apple target used in tests
+            }
+
+            // -----------------------------------------------------------------
+            // Configure the plugin to use the fake framework path created above.
+            // This makes the CustomPathStrategy succeed immediately, bypassing the
+            // DerivedData and manual search strategies that rely on an SPM setup.
+            // -----------------------------------------------------------------
+            sentryKmp {
+              linker {
+                frameworkPath.set("${fakeFrameworkDir.absolutePath.replace('\\', '/')}")
+              }
+            }
+            """.trimIndent()
+        )
+    }
+
+    /** Returns a pre-configured [GradleRunner] that logs into [out]. */
+    private fun defaultRunner(projectDir: File, out: ByteArrayOutputStream): GradleRunner =
+        GradleRunner.create()
+            .withProjectDir(projectDir)
+            .withPluginClasspath()
+            .withGradleVersion(org.gradle.util.GradleVersion.current().version)
+            .forwardStdOutput(OutputStreamWriter(SynchronizedOutputStream(out)))
+            .forwardStdError(OutputStreamWriter(SynchronizedOutputStream(out)))
+            .withArguments("--stacktrace")
+
+    private companion object {
+        private const val KOTLIN_VERSION = "2.1.21"
+    }
+}