feat: add plugin support

.run/iosApp-spm.run.xml

@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="iosApp-spm" type="KmmRunConfiguration" factoryName="iOS Application" CONFIG_VERSION="1" EXEC_TARGET_ID="27607109-90E2-4A98-8165-C0FF206F6E6D" XCODE_PROJECT="$PROJECT_DIR$/sentry-samples/kmp-app-spm/iosApp.xcodeproj" XCODE_CONFIGURATION="Debug" XCODE_SCHEME="iosApp">
+  <configuration default="false" name="iosApp-spm" type="KmmRunConfiguration" factoryName="iOS Application" CONFIG_VERSION="1" XCODE_PROJECT="$PROJECT_DIR$/sentry-samples/kmp-app-spm/iosApp.xcodeproj" XCODE_CONFIGURATION="Debug" XCODE_SCHEME="iosApp">
     <method v="2">
       <option name="com.jetbrains.kmm.ios.BuildIOSAppTask" enabled="true" />
     </method>

buildSrc/src/main/java/Config.kt

@@ -1,7 +1,7 @@
 object Config {
     val agpVersion = "7.4.2"
-    val kotlinVersion = "1.9.21"
-    val composeVersion = "1.5.11"
+    val kotlinVersion = "1.9.23"
+    val composeVersion = "1.6.1"
     val gradleMavenPublishPluginVersion = "0.18.0"
 
     val multiplatform = "multiplatform"
@@ -36,7 +36,7 @@ object Config {
         val sentryAndroid = "io.sentry:sentry-android:$sentryJavaVersion"
         val sentryJava = "io.sentry:sentry:$sentryJavaVersion"
 
-        val sentryCocoaVersion = "8.20.0"
+        val sentryCocoaVersion = "8.25.0"
         val sentryCocoa = "Sentry"
 
         object Samples {

plugin-build/build.gradle.kts

@@ -0,0 +1,47 @@
+import io.gitlab.arturbosch.detekt.Detekt
+
+plugins {
+    alias(libs.plugins.kotlin) apply false
+    alias(libs.plugins.pluginPublish) apply false
+    alias(libs.plugins.detekt)
+    alias(libs.plugins.ktlint)
+    alias(libs.plugins.versionCheck)
+}
+
+allprojects {
+    group = property("GROUP").toString()
+    version = property("VERSION").toString()
+
+    apply {
+        plugin(rootProject.libs.plugins.detekt.get().pluginId)
+        plugin(rootProject.libs.plugins.ktlint.get().pluginId)
+    }
+
+    ktlint {
+        debug.set(false)
+        verbose.set(true)
+        android.set(false)
+        outputToConsole.set(true)
+        ignoreFailures.set(false)
+        enableExperimentalRules.set(true)
+        filter {
+            exclude("**/generated/**")
+            include("**/kotlin/**")
+        }
+    }
+
+    detekt {
+        config.setFrom(rootProject.files("../config/detekt/detekt.yml"))
+    }
+}
+
+tasks.withType<Detekt>().configureEach {
+    reports {
+        html.required.set(true)
+        html.outputLocation.set(file("build/reports/detekt.html"))
+    }
+}
+
+tasks.register("clean", Delete::class.java) {
+    delete(rootProject.layout.buildDirectory)
+}

plugin-build/gradle.properties

@@ -0,0 +1,8 @@
+ID=io.sentry.kotlin.multiplatform.gradle.plugin
+VERSION=1.0.0
+GROUP=io.sentry
+DISPLAY_NAME=An empty Gradle Plugin from a template
+DESCRIPTION=An empty Gradle plugin created from a template
+WEBSITE=https://github.com/cortinico/kotlin-gradle-plugin-template
+VCS_URL=https://github.com/cortinico/kotlin-gradle-plugin-template
+IMPLEMENTATION_CLASS=io.sentry.kotlin.multiplatform.gradle.plugin.SentryPlugin

plugin-build/gradle/libs.versions.toml

@@ -0,0 +1,17 @@
+[versions]
+detekt = "1.23.6"
+kotlin = "1.9.23"
+ktlintGradle = "12.1.0"
+pluginPublish = "1.2.1"
+versionCheck = "0.51.0"
+
+[plugins]
+detekt = { id = "io.gitlab.arturbosch.detekt", version.ref = "detekt"}
+kotlin = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin"}
+ktlint = { id = "org.jlleitschuh.gradle.ktlint", version.ref = "ktlintGradle"}
+pluginPublish = { id = "com.gradle.plugin-publish", version.ref = "pluginPublish"}
+versionCheck = { id = "com.github.ben-manes.versions", version.ref = "versionCheck"}
+vanniktech-publish = { id = "com.vanniktech.maven.publish", version = "0.18.0"}
+
+[libraries]
+junit = "junit:junit:4.13.2"

plugin-build/gradle/wrapper

@@ -0,0 +1 @@
+../../gradle/wrapper

plugin-build/gradlew

@@ -0,0 +1 @@
+../gradlew

plugin-build/gradlew.bat

@@ -0,0 +1 @@
+../gradlew.bat

plugin-build/plugin/build.gradle.kts

@@ -0,0 +1,68 @@
+import com.vanniktech.maven.publish.MavenPublishPluginExtension
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    kotlin("jvm")
+    `java-gradle-plugin`
+//    alias(libs.plugins.pluginPublish)
+    id("de.undercouch.download") version "5.6.0"
+    alias(libs.plugins.vanniktech.publish)
+    id("distribution")
+}
+
+dependencies {
+    implementation(kotlin("stdlib"))
+    implementation(gradleApi())
+    implementation(kotlin("gradle-plugin"))
+
+    testImplementation(libs.junit)
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+tasks.withType<KotlinCompile> {
+    kotlinOptions {
+        jvmTarget = JavaVersion.VERSION_1_8.toString()
+    }
+}
+
+gradlePlugin {
+    plugins {
+        create(property("ID").toString()) {
+            id = property("ID").toString()
+            implementationClass = property("IMPLEMENTATION_CLASS").toString()
+            version = property("VERSION").toString()
+            description = property("DESCRIPTION").toString()
+            displayName = property("DISPLAY_NAME").toString()
+            tags.set(listOf("plugin", "gradle", "sample", "template"))
+        }
+    }
+}
+
+gradlePlugin {
+    website.set(property("WEBSITE").toString())
+    vcsUrl.set(property("VCS_URL").toString())
+}
+
+val publish = extensions.getByType(MavenPublishPluginExtension::class.java)
+// signing is done when uploading files to MC
+// via gpg:sign-and-deploy-file (release.kts)
+publish.releaseSigningEnabled = false
+
+tasks.named("distZip").configure {
+    dependsOn("publishToMavenLocal")
+}
+
+val sep = File.separator
+
+distributions {
+    main {
+        contents {
+            from("build${sep}libs")
+            from("build${sep}publications${sep}maven")
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+package io.sentry.kotlin.multiplatform.gradle.plugin
+
+import org.gradle.api.Project
+import org.gradle.api.provider.Property
+import javax.inject.Inject
+
+
+@Suppress("UnnecessaryAbstractClass")
+abstract class LinkerExtension
+@Inject
+constructor(project: Project) {
+    private val objects = project.objects
+
+    val xcodeprojPath: Property<String> = objects.property(String::class.java)
+}

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

@@ -0,0 +1,25 @@
+package io.sentry.kotlin.multiplatform.gradle.plugin
+
+import org.gradle.api.Project
+import org.gradle.api.provider.Property
+import javax.inject.Inject
+
+@Suppress("UnnecessaryAbstractClass")
+abstract class SentryExtension
+@Inject
+constructor(project: Project) {
+    private val objects = project.objects
+
+    /**
+     * Auto-installs the Sentry-Cocoa SDK pod if the cocoapods plugin is enabled.
+     */
+    val autoInstallWithCocoapods: Property<Boolean> =
+        objects.property(Boolean::class.java).convention(true)
+
+    /**
+     * Linker configuration.
+     *
+     * If you use SPM this configuration is necessary for setting up linking the framework and test executable.
+     */
+    val linker: LinkerExtension = objects.newInstance(LinkerExtension::class.java, project)
+}

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

@@ -0,0 +1,170 @@
+package io.sentry.kotlin.multiplatform.gradle.plugin
+
+import org.gradle.api.GradleException
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.plugins.ExtensionAware
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.plugin.cocoapods.CocoapodsExtension
+import org.jetbrains.kotlin.gradle.plugin.mpp.Framework
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
+import org.jetbrains.kotlin.gradle.plugin.mpp.TestExecutable
+import java.io.ByteArrayOutputStream
+import java.io.File
+
+internal const val SENTRY_EXTENSION_NAME = "sentry"
+internal const val LINKER_EXTENSION_NAME = "linker"
+internal const val COCOAPODS_PLUGIN_NAME = "org.jetbrains.kotlin.plugin.cocoapods"
+internal const val KOTLIN_EXTENSION_NAME = "kotlin"
+
+@Suppress("unused")
+class SentryPlugin : Plugin<Project> {
+    override fun apply(project: Project): Unit = with(project) {
+        val extension =
+            project.extensions.create(SENTRY_EXTENSION_NAME, SentryExtension::class.java, project)
+        project.extensions.add(LINKER_EXTENSION_NAME, extension.linker)
+
+        afterEvaluate {
+            val hasCocoapodsPlugin = project.pluginManager.hasPlugin(COCOAPODS_PLUGIN_NAME)
+            if (hasCocoapodsPlugin && extension.autoInstallWithCocoapods.get()) {
+                installPod()
+            } else {
+                configureLinkingOptions(extension.linker)
+            }
+        }
+    }
+}
+
+private fun Project.configureLinkingOptions(linkerExtension: LinkerExtension) {
+    val kmpExtension = this.extensions.findByName(KOTLIN_EXTENSION_NAME)
+    if (kmpExtension !is KotlinMultiplatformExtension) {
+        // todo: log, not multiplatform found
+        return
+    }
+
+    val customXcodeprojPath = linkerExtension.xcodeprojPath.orNull
+    println("customXcodeprojPath: $customXcodeprojPath")
+
+    val derivedDataPath = findDerivedDataPath(customXcodeprojPath)
+
+    kmpExtension.appleTargets().all { target ->
+        val frameworkArchitecture = target.frameworkArchitecture()
+        val dynamicFrameworkPath =
+            "$derivedDataPath/SourcePackages/artifacts/sentry-cocoa/Sentry-Dynamic/Sentry-Dynamic.xcframework/$frameworkArchitecture"
+        val staticFrameworkPath =
+            "$derivedDataPath/SourcePackages/artifacts/sentry-cocoa/Sentry/Sentry.xcframework/$frameworkArchitecture"
+
+        target.binaries.all { binary ->
+            if (frameworkArchitecture == null) {
+                // todo: log, unsupported architecture
+                return@all
+            }
+
+            var path = dynamicFrameworkPath
+            if (!File(dynamicFrameworkPath).exists()) {
+                // if it doesn't exist still search for the static one since we need either one
+                // for test linking
+                // todo: log, dynamic framework not found, using static framework
+                path = staticFrameworkPath
+
+                if (!File(staticFrameworkPath).exists()) {
+                    // todo: log, static framework also not found, error
+                    return@all
+                }
+            }
+
+            val testExecutable = binary is TestExecutable
+            val dynamicFramework = binary is Framework && !binary.isStatic
+            if (testExecutable) {
+                binary.linkerOpts("-rpath", "$path/Sentry.framework")
+                binary.linkerOpts("-F$path")
+            } else if (dynamicFramework) {
+                binary.linkerOpts("-F$path")
+            }
+        }
+    }
+}
+
+private fun Project.findDerivedDataPath(customXcodeprojPath: String? = null): String {
+    val xcodeprojPath = customXcodeprojPath ?: findXcodeprojFile(rootDir)?.absolutePath
+    val buildDirOutput = ByteArrayOutputStream()
+    exec {
+        it.commandLine = listOf(
+            "xcodebuild", "-project", xcodeprojPath, "-showBuildSettings"
+        )
+        it.standardOutput = buildDirOutput
+    }
+    val buildSettings = buildDirOutput.toString("UTF-8")
+    val buildDirRegex = Regex("BUILD_DIR = (.+)")
+    val buildDirMatch = buildDirRegex.find(buildSettings)
+    val buildDir = buildDirMatch?.groupValues?.get(1)
+        ?: throw GradleException("BUILD_DIR not found in xcodebuild output")
+    val derivedDataPath = buildDir.replace("/Build/Products", "")
+    return derivedDataPath
+}
+
+private fun findXcodeprojFile(dir: File): File? {
+    val ignoredDirectories = listOf("build", "DerivedData")
+
+    fun searchDirectory(directory: File): File? {
+        val files = directory.listFiles() ?: return null
+
+        for (file in files) {
+            if (file.name in ignoredDirectories) {
+                continue
+            }
+
+            // Recursively search the subdirectory
+            val result = searchDirectory(file)
+            if (result != null) {
+                return result
+            }
+
+            if (file.extension == "xcodeproj") {
+                return file
+            }
+        }
+        return null
+    }
+
+    return searchDirectory(dir)
+}
+
+private fun KotlinMultiplatformExtension.appleTargets() =
+    targets.withType(KotlinNativeTarget::class.java)
+        .matching { it.konanTarget.family.isAppleFamily }
+
+/**
+ * Installs the Sentry pod if not yet installed and configures the compiler options
+ */
+private fun Project.installPod() {
+    val kmpExtension = this.extensions.findByName(KOTLIN_EXTENSION_NAME)
+    if (kmpExtension !is KotlinMultiplatformExtension) {
+        return
+    }
+
+    (kmpExtension as ExtensionAware).extensions.configure(CocoapodsExtension::class.java) { cocoapods ->
+        val sentryPod = cocoapods.pods.findByName("Sentry")
+        if (sentryPod == null) {
+            cocoapods.pod("Sentry") {
+                version = "~> 8.25" // todo: check if this constraint is good enough
+                linkOnly = true
+                extraOpts += listOf("-compiler-option", "-fmodules")
+            }
+        }
+    }
+}
+
+/**
+ * Transforms a Kotlin Multiplatform target name to the architecture name that is found inside
+ * Sentry's framework directory.
+ */
+private fun KotlinNativeTarget.frameworkArchitecture(): String? {
+    return when (name) {
+        "iosSimulatorArm64" -> "ios-arm64_x86_64-simulator"
+        "iosX64" -> "ios-arm64_x86_64-simulator"
+        "iosArm64" -> "ios-arm64"
+        // todo: add more targets
+        else -> null
+    }
+}