build-logic 추가

build-logic/convention/build.gradle.kts

@@ -0,0 +1,59 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    `kotlin-dsl`
+}
+
+group = "com.peto.droidmorning.buildlogic"
+
+val javaVersion = JavaVersion.toVersion(libs.versions.java.get())
+
+java {
+    sourceCompatibility = javaVersion
+    targetCompatibility = javaVersion
+}
+
+kotlin {
+    compilerOptions {
+        jvmTarget = JvmTarget.fromTarget(libs.versions.java.get())
+    }
+}
+
+dependencies {
+    compileOnly(libs.android.gradle.plugin)
+    compileOnly(libs.kotlin.gradle.plugin)
+    compileOnly(libs.compose.gradle.plugin)
+}
+
+gradlePlugin {
+    plugins {
+        register("kmpPrimitive") {
+            id = "droidmorning.kmp"
+            implementationClass = "com.peto.droidmorning.KotlinMultiPlatformPlugin"
+        }
+        register("kmpAndroid") {
+            id = "droidmorning.kmp.android"
+            implementationClass = "com.peto.droidmorning.KotlinMultiPlatformAndroidPlugin"
+        }
+        register("kmpIos") {
+            id = "droidmorning.kmp.ios"
+            implementationClass = "com.peto.droidmorning.KotlinMultiPlatformiOSPlugin"
+        }
+        register("androidLibrary") {
+            id = "droidmorning.android.library"
+            implementationClass = "com.peto.droidmorning.AndroidLibraryConventionPlugin"
+        }
+        register("kotlinMultiplatform") {
+            id = "droidmorning.kotlin.multiplatform"
+            implementationClass = "com.peto.droidmorning.KotlinMultiplatformConventionPlugin"
+        }
+        register("composeMultiplatform") {
+            id = "droidmorning.compose.multiplatform"
+            implementationClass = "com.peto.droidmorning.ComposeMultiplatformConventionPlugin"
+        }
+        register("droidmorningFeature") {
+            id = "droidmorning.feature"
+            implementationClass = "com.peto.droidmorning.DroidMorningFeaturePlugin"
+        }
+    }
+}

build-logic/convention/src/main/kotlin/com/peto/droidmorning/AndroidLibraryConventionPlugin.kt

@@ -0,0 +1,37 @@
+package com.peto.droidmorning
+
+import com.android.build.gradle.LibraryExtension
+import com.peto.droidmorning.extentions.javaVersion
+import com.peto.droidmorning.extentions.libs
+import com.peto.droidmorning.extentions.plugin
+import com.peto.droidmorning.extentions.version
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+
+class AndroidLibraryConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply(libs.plugin("android-library").pluginId)
+            }
+
+            extensions.configure<LibraryExtension> {
+                compileSdk = libs.version("compileSdk").toInt()
+
+                defaultConfig {
+                    minSdk = libs.version("minSdk").toInt()
+                }
+
+                compileOptions {
+                    sourceCompatibility = libs.javaVersion("java")
+                    targetCompatibility = libs.javaVersion("java")
+                }
+
+                buildFeatures {
+                    buildConfig = true
+                }
+            }
+        }
+    }
+}

build-logic/convention/src/main/kotlin/com/peto/droidmorning/ComposeMultiplatformConventionPlugin.kt

@@ -0,0 +1,18 @@
+package com.peto.droidmorning
+
+import com.peto.droidmorning.extentions.composeMultiplatformDependencies
+import com.peto.droidmorning.extentions.libs
+import com.peto.droidmorning.extentions.plugin
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+
+class ComposeMultiplatformConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) = with(target) {
+        with(pluginManager) {
+            apply(libs.plugin("compose-multiplatform").pluginId)
+            apply(libs.plugin("kotlin-compose").pluginId)
+        }
+
+        composeMultiplatformDependencies()
+    }
+}

build-logic/convention/src/main/kotlin/com/peto/droidmorning/DroidMorningFeaturePlugin.kt

@@ -0,0 +1,53 @@
+package com.peto.droidmorning
+
+import com.peto.droidmorning.extentions.bundle
+import com.peto.droidmorning.extentions.composeMultiplatformDependencies
+import com.peto.droidmorning.extentions.library
+import com.peto.droidmorning.extentions.libs
+import com.peto.droidmorning.extentions.plugin
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.configure
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+
+class DroidMorningFeaturePlugin : Plugin<Project> {
+    override fun apply(target: Project) = with(target) {
+        with(pluginManager) {
+            apply(libs.plugin("android-library").pluginId)
+            apply(libs.plugin("kotlin-serialization").pluginId)
+        }
+
+        apply<KotlinMultiPlatformPlugin>()
+        apply<KotlinMultiPlatformAndroidPlugin>()
+        apply<KotlinMultiPlatformiOSPlugin>()
+
+        apply<ComposeMultiplatformConventionPlugin>()
+
+        extensions.configure<KotlinMultiplatformExtension> {
+            sourceSets.apply {
+                commonMain {
+                    dependencies {
+                        implementation(libs.library("androidx-navigation-compose"))
+                        implementation(libs.library("androidx-lifecycle-viewmodel-compose"))
+                        implementation(libs.library("androidx-lifecycle-runtime-compose"))
+
+                        implementation(libs.bundle("koin"))
+
+                        implementation(libs.library("kotlinx-coroutines-core"))
+                        implementation(libs.library("kotlinx-serialization-json"))
+                        implementation(libs.library("kotlinx-collections-immutable"))
+                        implementation(libs.library("napier"))
+                    }
+                }
+                commonTest {
+                    dependencies {
+                        implementation(libs.library("kotlin-test"))
+                        implementation(libs.library("koin-test"))
+                        implementation(libs.library("kotlinx-coroutines-test"))
+                    }
+                }
+            }
+        }
+    }
+}

build-logic/convention/src/main/kotlin/com/peto/droidmorning/KotlinMultiPlatformAndroidPlugin.kt

@@ -0,0 +1,53 @@
+package com.peto.droidmorning
+
+import com.peto.droidmorning.extentions.androidExtension
+import com.peto.droidmorning.extentions.javaVersion
+import com.peto.droidmorning.extentions.jvmTarget
+import com.peto.droidmorning.extentions.libs
+import com.peto.droidmorning.extentions.version
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+
+class KotlinMultiPlatformAndroidPlugin : Plugin<Project> {
+    override fun apply(target: Project): Unit = with(target) {
+        androidExtension.apply {
+            compileSdk = libs.version("compileSdk").toInt()
+
+            extensions.configure<KotlinMultiplatformExtension> {
+                androidTarget {
+                    compilerOptions.jvmTarget.set(libs.jvmTarget("java"))
+                }
+            }
+
+            defaultConfig {
+                minSdk = libs.version("minSdk").toInt()
+            }
+
+            compileOptions {
+                sourceCompatibility = libs.javaVersion("java")
+                targetCompatibility = libs.javaVersion("java")
+            }
+
+            packaging {
+                resources {
+                    excludes += "/META-INF/{AL2.0,LGPL2.1}"
+                }
+            }
+
+            sourceSets {
+                getByName("main") {
+                    assets.srcDirs("src/androidMain/assets")
+                    java.srcDirs("src/androidMain/kotlin")
+                    res.srcDirs("src/androidMain/res")
+                }
+                getByName("test") {
+                    assets.srcDirs("src/androidUnitTest/assets")
+                    java.srcDirs("src/androidUnitTest/kotlin")
+                    res.srcDirs("src/androidUnitTest/res")
+                }
+            }
+        }
+    }
+}

build-logic/convention/src/main/kotlin/com/peto/droidmorning/KotlinMultiPlatformPlugin.kt

@@ -0,0 +1,33 @@
+package com.peto.droidmorning
+
+import com.peto.droidmorning.extentions.jvmTarget
+import com.peto.droidmorning.extentions.libs
+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
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import org.jetbrains.kotlin.gradle.tasks.KotlinNativeLink
+
+class KotlinMultiPlatformPlugin : Plugin<Project> {
+    override fun apply(target: Project) = with(target) {
+        extensions.configure<KotlinMultiplatformExtension> {
+            compilerOptions {
+                freeCompilerArgs.add("-Xexpect-actual-classes")
+            }
+
+            applyDefaultHierarchyTemplate()
+        }
+
+        tasks.withType<KotlinCompile>().configureEach {
+            compilerOptions {
+                jvmTarget.set(libs.jvmTarget("java"))
+            }
+        }
+
+        tasks.withType<KotlinNativeLink>().configureEach {
+            notCompatibleWithConfigurationCache("Configuration cache not supported for a system property read at configuration time")
+        }
+    }
+}

build-logic/convention/src/main/kotlin/com/peto/droidmorning/KotlinMultiPlatformiOSPlugin.kt

@@ -0,0 +1,29 @@
+package com.peto.droidmorning
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.get
+import org.gradle.kotlin.dsl.withType
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
+
+class KotlinMultiPlatformiOSPlugin : Plugin<Project> {
+    override fun apply(target: Project) = with(target) {
+        extensions.configure<KotlinMultiplatformExtension> {
+            iosArm64()
+            iosX64()
+            iosSimulatorArm64()
+
+            targets.withType<KotlinNativeTarget> {
+                compilations["main"].compilerOptions.configure {
+                    freeCompilerArgs.add("-Xexport-kdoc")
+                }
+                binaries.framework {
+                    baseName = project.name
+                    isStatic = true
+                }
+            }
+        }
+    }
+}

build-logic/convention/src/main/kotlin/com/peto/droidmorning/KotlinMultiplatformConventionPlugin.kt

@@ -0,0 +1,17 @@
+package com.peto.droidmorning
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.apply
+
+class KotlinMultiplatformConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) = with(target) {
+        with(pluginManager) {
+            apply("org.jetbrains.kotlin.multiplatform")
+        }
+
+        apply<KotlinMultiPlatformPlugin>()
+        apply<KotlinMultiPlatformAndroidPlugin>()
+        apply<KotlinMultiPlatformiOSPlugin>()
+    }
+}

build-logic/convention/src/main/kotlin/com/peto/droidmorning/extentions/ProjectExtensions.kt

@@ -0,0 +1,35 @@
+package com.peto.droidmorning.extentions
+
+import com.android.build.api.dsl.ApplicationExtension
+import com.android.build.api.dsl.CommonExtension
+import com.android.build.api.dsl.LibraryExtension
+import org.gradle.api.Project
+import org.gradle.api.artifacts.VersionCatalog
+import org.gradle.api.artifacts.VersionCatalogsExtension
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.getByType
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+
+internal val Project.libs: VersionCatalog
+    get() = extensions.getByType<VersionCatalogsExtension>().named("libs")
+
+internal val Project.androidExtension: CommonExtension<*, *, *, *, *, *>
+    get() = extensions.findByType(LibraryExtension::class.java)
+        ?: extensions.findByType(ApplicationExtension::class.java)
+        ?: error("Could not find Library or Application extension from this project")
+
+internal fun Project.composeMultiplatformDependencies() {
+    extensions.configure<KotlinMultiplatformExtension> {
+        sourceSets.apply {
+            commonMain {
+                dependencies {
+                    implementation(libs.bundle("compose-multiplatform"))
+                }
+            }
+        }
+    }
+
+    configurations.findByName("debugImplementation")?.let { cfg ->
+        dependencies.add(cfg.name, libs.library("compose-ui-tooling"))
+    }
+}

build-logic/convention/src/main/kotlin/com/peto/droidmorning/extentions/VersionCatalogExtensions.kt

@@ -0,0 +1,32 @@
+package com.peto.droidmorning.extentions
+
+import org.gradle.api.JavaVersion
+import org.gradle.api.artifacts.ExternalModuleDependencyBundle
+import org.gradle.api.artifacts.MinimalExternalModuleDependency
+import org.gradle.api.artifacts.VersionCatalog
+import org.gradle.plugin.use.PluginDependency
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+internal fun VersionCatalog.version(name: String): String {
+    return findVersion(name).get().requiredVersion
+}
+
+internal fun VersionCatalog.library(name: String): MinimalExternalModuleDependency {
+    return findLibrary(name).get().get()
+}
+
+internal fun VersionCatalog.plugin(name: String): PluginDependency {
+    return findPlugin(name).get().get()
+}
+
+internal fun VersionCatalog.bundle(name: String): ExternalModuleDependencyBundle {
+    return findBundle(name).get().get()
+}
+
+internal fun VersionCatalog.javaVersion(name: String): JavaVersion {
+    return JavaVersion.toVersion(version(name))
+}
+
+internal fun VersionCatalog.jvmTarget(name: String): JvmTarget {
+    return JvmTarget.fromTarget(version(name))
+}

build-logic/settings.gradle.kts

@@ -0,0 +1,16 @@
+dependencyResolutionManagement {
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+    versionCatalogs {
+        create("libs") {
+            from(files("../gradle/libs.versions.toml"))
+        }
+    }
+}
+
+rootProject.name = "build-logic"
+
+include(":convention")