feat(gradle): create build-logic

Agents.md

@@ -61,7 +61,7 @@ Both library modules target:
 
 - **Android** (`androidMain`)
 - **JVM** (`jvmMain`)
-- **iOS** (`iosX64`, `iosArm64`, `iosSimulatorArm64`)
+- **iOS** (`iosArm64`, `iosSimulatorArm64`)
 
 ## Workflow
 
@@ -313,8 +313,8 @@ targets. The compiler reports `Unresolved reference 'SYSTEM'` during iOS publica
 
 **Workaround:** Use the `expect`/`actual` pattern. Declare an `internal expect val` in `commonMain`
 and provide `actual` implementations in each platform source set (`androidMain`, `jvmMain`,
-`iosMain`) that return `FileSystem.SYSTEM`. The `iosMain` source set covers all three iOS targets
-(`iosX64`, `iosArm64`, `iosSimulatorArm64`) via `applyDefaultHierarchyTemplate()`.
+`iosMain`) that return `FileSystem.SYSTEM`. The `iosMain` source set covers all two iOS targets
+(`iosArm64`, `iosSimulatorArm64`) via `applyDefaultHierarchyTemplate()`.
 
 Files involved:
 

README.md

@@ -20,7 +20,7 @@ SharedPreferences.
 
 ### KMP Targets
 
-Both modules target **Android**, **Desktop (JVM)**, and **iOS** (`iosX64`, `iosArm64`,
+Both modules target **Android**, **Desktop (JVM)**, and **iOS** (`iosArm64`,
 `iosSimulatorArm64`).
 
 ## Installation

build-logic/convention/build.gradle.kts

@@ -0,0 +1,44 @@
+plugins {
+    `kotlin-dsl`
+}
+
+dependencies {
+    compileOnly(libs.android.gradle.plugin)
+    compileOnly(libs.kotlin.gradle.plugin)
+    implementation(libs.spotless.gradle.plugin)
+    compileOnly(libs.compose.gradle.plugin)
+    compileOnly(libs.vanniktech.maven.publish.plugin)
+}
+
+gradlePlugin {
+    plugins {
+        register("spotless") {
+            id = "gd.spotless"
+            implementationClass = "SpotlessConventionPlugin"
+        }
+        register("kmpLibrary") {
+            id = "gd.kmp.library"
+            implementationClass = "KmpLibraryConventionPlugin"
+        }
+        register("kmpLibraryTest") {
+            id = "gd.kmp.library.test"
+            implementationClass = "KmpLibraryTestConventionPlugin"
+        }
+        register("mavenPublish") {
+            id = "gd.maven.publish"
+            implementationClass = "MavenPublishConventionPlugin"
+        }
+        register("compose") {
+            id = "gd.compose"
+            implementationClass = "ComposeConventionPlugin"
+        }
+        register("kmpSample") {
+            id = "gd.kmp.sample"
+            implementationClass = "KmpSampleConventionPlugin"
+        }
+        register("androidSampleApp") {
+            id = "gd.android.sample"
+            implementationClass = "AndroidSampleAppConventionPlugin"
+        }
+    }
+}

build-logic/convention/src/main/kotlin/AndroidSampleAppConventionPlugin.kt

@@ -0,0 +1,39 @@
+import com.android.build.api.dsl.ApplicationExtension
+import gd.buildlogic.configureAndroid
+import gd.buildlogic.configureCommonKotlinCompileOptions
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+
+@Suppress("unused")
+class AndroidSampleAppConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply("com.android.application")
+                apply("gd.compose")
+                apply("gd.spotless")
+            }
+
+            extensions.configure<ApplicationExtension> {
+                configureAndroid(this)
+
+                defaultConfig {
+                    testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+                }
+
+                buildFeatures {
+                    compose = true
+                }
+
+                packaging {
+                    resources {
+                        excludes += "/META-INF/{AL2.0,LGPL2.1}"
+                    }
+                }
+            }
+
+            configureCommonKotlinCompileOptions()
+        }
+    }
+}

build-logic/convention/src/main/kotlin/ComposeConventionPlugin.kt

@@ -0,0 +1,16 @@
+import gd.buildlogic.libs
+import gd.buildlogic.pluginId
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+
+@Suppress("unused")
+class ComposeConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply(libs.pluginId("compose-compiler"))
+                apply(libs.pluginId("jetbrains-compose"))
+            }
+        }
+    }
+}

build-logic/convention/src/main/kotlin/KmpLibraryConventionPlugin.kt

@@ -0,0 +1,50 @@
+import com.android.build.api.dsl.KotlinMultiplatformAndroidLibraryTarget
+import gd.buildlogic.AndroidConfig
+import gd.buildlogic.configureCommonKotlinCompileOptions
+import gd.buildlogic.configureKmpLibrary
+import gd.buildlogic.libs
+import gd.buildlogic.pluginId
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.withType
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+
+@Suppress("unused")
+class KmpLibraryConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            configureCommonKotlinCompileOptions()
+
+            with(pluginManager) {
+                apply(libs.pluginId("kotlin-multiplatform"))
+                apply(libs.pluginId("android-library"))
+                apply("gd.spotless")
+            }
+
+            extensions.configure<KotlinMultiplatformExtension> {
+                configureKmpLibrary()
+                explicitApi()
+
+                applyDefaultHierarchyTemplate()
+
+                targets.withType<KotlinMultiplatformAndroidLibraryTarget>().configureEach {
+                    compileSdk = AndroidConfig.COMPILE_SDK
+                    minSdk = AndroidConfig.MIN_SDK
+                }
+
+                iosArm64()
+                iosSimulatorArm64()
+
+                jvm()
+
+                compilerOptions {
+                    freeCompilerArgs.addAll(
+                        "-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
+                        "-Xexpect-actual-classes",
+                    )
+                }
+            }
+        }
+    }
+}

build-logic/convention/src/main/kotlin/KmpLibraryTestConventionPlugin.kt

@@ -0,0 +1,55 @@
+import com.android.build.api.dsl.KotlinMultiplatformAndroidLibraryTarget
+import gd.buildlogic.library
+import gd.buildlogic.libs
+import gd.buildlogic.pluginId
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.withType
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+
+class KmpLibraryTestConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply(libs.pluginId("kotlin-multiplatform"))
+                apply(libs.pluginId("android-library"))
+            }
+            extensions.configure<KotlinMultiplatformExtension> {
+                applyDefaultHierarchyTemplate()
+
+                targets.withType<KotlinMultiplatformAndroidLibraryTarget>().configureEach {
+                    withDeviceTestBuilder {
+                        sourceSetTreeName = "test"
+                    }.configure {
+                        instrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+                    }
+                }
+
+                jvm()
+
+                sourceSets.apply {
+                    commonTest.dependencies {
+                        implementation(libs.library("kotlin-test"))
+                        implementation(libs.library("coroutines-test"))
+                    }
+
+                    getByName("androidDeviceTest") {
+                        dependencies {
+                            implementation(libs.library("kotlin-test"))
+                            implementation(libs.library("coroutines-test"))
+                            implementation(libs.library("datastore-preferences"))
+                            implementation(libs.library("junit4"))
+                            implementation(libs.library("androidx-test-junit"))
+                            implementation(libs.library("androidx-test-espresso"))
+                        }
+                    }
+
+                    jvmTest.dependencies {
+                        implementation(libs.library("junit5"))
+                    }
+                }
+            }
+        }
+    }
+}

build-logic/convention/src/main/kotlin/KmpSampleConventionPlugin.kt

@@ -0,0 +1,95 @@
+import com.android.build.api.dsl.KotlinMultiplatformAndroidLibraryTarget
+import gd.buildlogic.AndroidConfig
+import gd.buildlogic.configureCommonKotlinCompileOptions
+import gd.buildlogic.configureKmpLibrary
+import gd.buildlogic.library
+import gd.buildlogic.libs
+import gd.buildlogic.pluginId
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.file.DuplicatesStrategy
+import org.gradle.api.tasks.testing.Test
+import org.gradle.jvm.tasks.Jar
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.withType
+import org.jetbrains.compose.ComposeExtension
+import org.jetbrains.compose.ComposePlugin
+import org.jetbrains.compose.desktop.DesktopExtension
+import org.jetbrains.compose.desktop.application.dsl.TargetFormat
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+
+@Suppress("unused")
+class KmpSampleConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            configureCommonKotlinCompileOptions()
+
+            with(pluginManager) {
+                apply(libs.pluginId("kotlin-multiplatform"))
+                apply(libs.pluginId("android-library"))
+                apply(libs.pluginId("kotlin-serialization"))
+                apply("gd.compose")
+                apply("gd.spotless")
+            }
+
+            extensions.configure<KotlinMultiplatformExtension> {
+                configureKmpLibrary()
+
+                applyDefaultHierarchyTemplate()
+
+                targets.withType<KotlinMultiplatformAndroidLibraryTarget>().configureEach {
+                    compileSdk = AndroidConfig.COMPILE_SDK
+                    minSdk = AndroidConfig.MIN_SDK
+                }
+
+                jvm("desktop")
+
+                compilerOptions {
+                    freeCompilerArgs.add("-Xexpect-actual-classes")
+                }
+
+                sourceSets.named("desktopMain") {
+                    dependencies {
+                        implementation(libs.library("coroutines-swing"))
+                        @Suppress("DEPRECATION")
+                        implementation(ComposePlugin.DesktopDependencies.currentOs)
+                    }
+                }
+            }
+
+            extensions.configure<ComposeExtension> {
+                extensions.configure<DesktopExtension> {
+                    application {
+                        buildTypes {
+                            release {
+                                proguard {
+                                    configurationFiles.from(project.file("proguard-rules.pro"))
+                                }
+                            }
+                        }
+
+                        nativeDistributions {
+                            modules("jdk.unsupported")
+                            targetFormats(TargetFormat.Dmg, TargetFormat.Msi, TargetFormat.Deb)
+                            packageVersion = "1.0.0"
+                        }
+                    }
+                }
+            }
+
+            configureCommonKotlinCompileOptions()
+
+            tasks.withType<Test>().configureEach {
+                useJUnitPlatform()
+            }
+
+            tasks.withType<Jar>().configureEach {
+                duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+
+                exclude("META-INF/AL2.0")
+                exclude("META-INF/LGPL2.1")
+                exclude("META-INF/MANIFEST.MF")
+            }
+        }
+    }
+}

build-logic/convention/src/main/kotlin/MavenPublishConventionPlugin.kt

@@ -0,0 +1,14 @@
+import gd.buildlogic.configureMavenPublish
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+
+@Suppress("unused")
+class MavenPublishConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            pluginManager.apply("com.vanniktech.maven.publish")
+
+            configureMavenPublish()
+        }
+    }
+}

build-logic/convention/src/main/kotlin/SpotlessConventionPlugin.kt

@@ -0,0 +1,33 @@
+import com.diffplug.gradle.spotless.SpotlessExtension
+import gd.buildlogic.libs
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+
+@Suppress("unused")
+class SpotlessConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            pluginManager.apply("com.diffplug.spotless")
+
+            extensions.configure<SpotlessExtension> {
+                kotlin {
+                    target("**/*.kt", "**/*.kts")
+                    targetExclude("**/build/**/*.kt")
+                    ktlint(
+                        libs.findLibrary("ktlint-core").get().get().version!!,
+                    ).editorConfigOverride(
+                        mapOf("ktlint_standard_annotation" to "disabled"),
+                    )
+                    trimTrailingWhitespace()
+                    endWithNewline()
+                }
+                format("xml") {
+                    target("**/*.xml")
+                    trimTrailingWhitespace()
+                    endWithNewline()
+                }
+            }
+        }
+    }
+}

build-logic/convention/src/main/kotlin/gd/buildlogic/AndroidConfig.kt

@@ -0,0 +1,14 @@
+package gd.buildlogic
+
+import org.gradle.api.JavaVersion as GradleJavaVersion
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget as KotlinJvmTarget
+
+object AndroidConfig {
+    const val COMPILE_SDK = 36
+    const val TARGET_SDK = 36
+    const val MIN_SDK = 24
+
+    // https://youtrack.jetbrains.com/issue/KT-66995/JvmTarget-and-JavaVersion-compatibility-for-easier-JVM-version-setup
+    val JavaVersion = GradleJavaVersion.VERSION_17
+    val JvmTarget = KotlinJvmTarget.JVM_17
+}