MRepoApp · SanmerDev · May 22, 2024 · May 22, 2024
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
@@ -6,17 +6,22 @@ updates:
       interval: "daily"
       time: "21:00"
     labels: [ "github_actions" ]
+
   - package-ecosystem: gradle
     directory: "/"
     schedule:
       interval: daily
       time: "21:00"
     labels: [ "dependencies" ]
     registries: "*"
-    ignore:
-      - dependency-name: "org.jetbrains.kotlin:*"
-      - dependency-name: "com.google.devtools.ksp:*"
-      - dependency-name: "androidx.compose.compiler:*"
+    groups:
+      kotlin-ksp:
+        patterns:
+          - "org.jetbrains.kotlin:*"
+          - "org.jetbrains.kotlin.jvm"
+          - "com.google.devtools.ksp"
+          - "com.google.devtools.ksp.gradle.plugin"
+
 registries:
   maven-google:
     type: "maven-repository"

diff --git a/.gitignore b/.gitignore
@@ -1,12 +1,15 @@
-# Gradle files
+# Gradle
 .gradle/
 build/
 
-# Local configuration file (sdk path, etc)
+# Kotlin
+.kotlin
+
+# Local configuration
 local.properties
 signing.properties
 
-# Android Studio generated files and folders
+# Android Studio
 captures/
 release/
 .externalNativeBuild/
@@ -16,7 +19,7 @@ release/
 *.iml
 .idea/
 
-# Keystore files
+# Keystore
 *.jks
 *.keystore
 

diff --git a/app/build.gradle.kts b/app/build.gradle.kts
@@ -2,10 +2,10 @@ import com.android.build.gradle.internal.api.ApkVariantOutputImpl
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
-    alias(libs.plugins.pro.application)
-    alias(libs.plugins.pro.compose)
-    alias(libs.plugins.pro.hilt)
-    alias(libs.plugins.pro.room)
+    alias(libs.plugins.self.application)
+    alias(libs.plugins.self.compose)
+    alias(libs.plugins.self.hilt)
+    alias(libs.plugins.self.room)
     alias(libs.plugins.kotlin.parcelize)
     alias(libs.plugins.ksp)
     alias(libs.plugins.protobuf)

diff --git a/build-logic/build.gradle.kts b/build-logic/build.gradle.kts
@@ -4,34 +4,35 @@ plugins {
 
 dependencies {
     compileOnly(libs.android.gradle)
+    compileOnly(libs.compose.gradle)
     compileOnly(libs.kotlin.gradle)
     compileOnly(libs.ksp.gradle)
 }
 
 gradlePlugin {
     plugins {
-        register("proApplication") {
-            id = "pro.application"
+        register("self.application") {
+            id = "self.application"
             implementationClass = "ApplicationConventionPlugin"
         }
-
-        register("proLibrary") {
-            id = "pro.library"
+        
+        register("self.library") {
+            id = "self.library"
             implementationClass = "LibraryConventionPlugin"
         }
 
-        register("proCompose") {
-            id = "pro.compose"
+        register("self.compose") {
+            id = "self.compose"
             implementationClass = "ComposeConventionPlugin"
         }
 
-        register("proHilt") {
-            id = "pro.hilt"
+        register("self.hilt") {
+            id = "self.hilt"
             implementationClass = "HiltConventionPlugin"
         }
 
-        register("proRoom") {
-            id = "pro.room"
+        register("self.room") {
+            id = "self.room"
             implementationClass = "RoomConventionPlugin"
         }
     }

diff --git a/build-logic/src/main/kotlin/ApplicationConventionPlugin.kt b/build-logic/src/main/kotlin/ApplicationConventionPlugin.kt
@@ -4,49 +4,43 @@ import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.plugins.JavaPluginExtension
 import org.gradle.jvm.toolchain.JavaLanguageVersion
+import org.gradle.kotlin.dsl.apply
 import org.gradle.kotlin.dsl.configure
 import org.jetbrains.kotlin.gradle.dsl.KotlinAndroidProjectExtension
 
 class ApplicationConventionPlugin : Plugin<Project> {
-    override fun apply(target: Project) {
-        with(target) {
-            with(pluginManager) {
-                apply("com.android.application")
-                apply("org.jetbrains.kotlin.android")
-            }
+    override fun apply(target: Project) = with(target) {
+        apply(plugin = "com.android.application")
+        apply(plugin = "org.jetbrains.kotlin.android")
 
-            extensions.configure<ApplicationExtension> {
-                compileSdk = 34
-                buildToolsVersion = "34.0.0"
+        extensions.configure<ApplicationExtension> {
+            compileSdk = 34
+            buildToolsVersion = "34.0.0"
 
-                defaultConfig {
-                    minSdk = 26
-                    targetSdk = compileSdk
-                }
+            defaultConfig {
+                minSdk = 29
+                targetSdk = compileSdk
+            }
 
-                compileOptions {
-                    sourceCompatibility = JavaVersion.VERSION_21
-                    targetCompatibility = JavaVersion.VERSION_21
-                }
+            compileOptions {
+                sourceCompatibility = JavaVersion.VERSION_21
+                targetCompatibility = JavaVersion.VERSION_21
             }
+        }
 
-            extensions.configure<JavaPluginExtension> {
-                toolchain {
-                    languageVersion.set(JavaLanguageVersion.of(21))
-                }
+        extensions.configure<JavaPluginExtension> {
+            toolchain {
+                languageVersion.set(JavaLanguageVersion.of(21))
             }
+        }
 
-            extensions.configure<KotlinAndroidProjectExtension> {
-                jvmToolchain(21)
+        extensions.configure<KotlinAndroidProjectExtension> {
+            jvmToolchain(21)
 
-                sourceSets.all {
-                    languageSettings {
-                        optIn("androidx.compose.material3.ExperimentalMaterial3Api")
-                        optIn("androidx.compose.foundation.ExperimentalFoundationApi")
-                        optIn("androidx.compose.foundation.layout.ExperimentalLayoutApi")
-                        optIn("kotlin.ExperimentalStdlibApi")
-                        optIn("kotlinx.coroutines.FlowPreview")
-                    }
+            sourceSets.all {
+                languageSettings {
+                    optIn("kotlin.ExperimentalStdlibApi")
+                    optIn("kotlinx.coroutines.FlowPreview")
                 }
             }
         }

diff --git a/build-logic/src/main/kotlin/ComposeConventionPlugin.kt b/build-logic/src/main/kotlin/ComposeConventionPlugin.kt
@@ -2,34 +2,40 @@ import com.android.build.api.dsl.ApplicationExtension
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.artifacts.VersionCatalogsExtension
+import org.gradle.kotlin.dsl.apply
 import org.gradle.kotlin.dsl.configure
 import org.gradle.kotlin.dsl.dependencies
 import org.gradle.kotlin.dsl.getByType
+import org.jetbrains.kotlin.gradle.dsl.KotlinAndroidProjectExtension
 
 class ComposeConventionPlugin : Plugin<Project> {
-    override fun apply(target: Project) {
-        with(target) {
-            val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
+    override fun apply(target: Project) = with(target) {
+        apply(plugin = "com.android.application")
+        apply(plugin = "org.jetbrains.kotlin.android")
+        apply(plugin = "org.jetbrains.kotlin.plugin.compose")
 
-            pluginManager.apply("com.android.application")
-
-            extensions.configure<ApplicationExtension> {
-                buildFeatures {
-                    compose = true
-                }
-
-                composeOptions {
-                    kotlinCompilerExtensionVersion =
-                        libs.findVersion("androidxComposeCompiler").get().toString()
-                }
+        extensions.configure<ApplicationExtension> {
+            buildFeatures {
+                compose = true
+            }
+        }
 
-                dependencies {
-                    "implementation"(libs.findLibrary("androidx.compose.material3").get())
-                    "implementation"(libs.findLibrary("androidx.compose.ui").get())
-                    "implementation"(libs.findLibrary("androidx.compose.ui.tooling.preview").get())
-                    "debugImplementation"(libs.findLibrary("androidx.compose.ui.tooling").get())
+        extensions.configure<KotlinAndroidProjectExtension> {
+            sourceSets.all {
+                languageSettings {
+                    optIn("androidx.compose.material3.ExperimentalMaterial3Api")
+                    optIn("androidx.compose.foundation.ExperimentalFoundationApi")
+                    optIn("androidx.compose.foundation.layout.ExperimentalLayoutApi")
                 }
             }
         }
+
+        val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
+        dependencies {
+            "implementation"(libs.findLibrary("androidx.compose.material3").get())
+            "implementation"(libs.findLibrary("androidx.compose.ui").get())
+            "implementation"(libs.findLibrary("androidx.compose.ui.tooling.preview").get())
+            "debugImplementation"(libs.findLibrary("androidx.compose.ui.tooling").get())
+        }
     }
 }
diff --git a/build-logic/src/main/kotlin/HiltConventionPlugin.kt b/build-logic/src/main/kotlin/HiltConventionPlugin.kt
@@ -1,23 +1,19 @@
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.artifacts.VersionCatalogsExtension
+import org.gradle.kotlin.dsl.apply
 import org.gradle.kotlin.dsl.dependencies
 import org.gradle.kotlin.dsl.getByType
 
 class HiltConventionPlugin : Plugin<Project> {
-    override fun apply(target: Project) {
-        with(target) {
-            val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
+    override fun apply(target: Project) = with(target) {
+        apply(plugin = "dagger.hilt.android.plugin")
+        apply(plugin = "com.google.devtools.ksp")
 
-            with(pluginManager) {
-                apply("dagger.hilt.android.plugin")
-                apply("com.google.devtools.ksp")
-            }
-
-            dependencies {
-                "implementation"(libs.findLibrary("hilt.android").get())
-                "ksp"(libs.findLibrary("hilt.compiler").get())
-            }
+        val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
+        dependencies {
+            "implementation"(libs.findLibrary("hilt.android").get())
+            "ksp"(libs.findLibrary("hilt.compiler").get())
         }
     }
 }
diff --git a/build-logic/src/main/kotlin/LibraryConventionPlugin.kt b/build-logic/src/main/kotlin/LibraryConventionPlugin.kt
@@ -4,40 +4,37 @@ import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.plugins.JavaPluginExtension
 import org.gradle.jvm.toolchain.JavaLanguageVersion
+import org.gradle.kotlin.dsl.apply
 import org.gradle.kotlin.dsl.configure
 import org.jetbrains.kotlin.gradle.dsl.KotlinAndroidProjectExtension
 
 class LibraryConventionPlugin : Plugin<Project> {
-    override fun apply(target: Project) {
-        with(target) {
-            with(pluginManager) {
-                apply("com.android.library")
-                apply("org.jetbrains.kotlin.android")
-            }
+    override fun apply(target: Project) = with(target) {
+        apply(plugin = "com.android.library")
+        apply(plugin = "org.jetbrains.kotlin.android")
 
-            extensions.configure<LibraryExtension> {
-                compileSdk = 34
-                buildToolsVersion = "34.0.0"
-
-                defaultConfig {
-                    minSdk = 26
-                }
+        extensions.configure<LibraryExtension> {
+            compileSdk = 34
+            buildToolsVersion = "34.0.0"
 
-                compileOptions {
-                    sourceCompatibility = JavaVersion.VERSION_21
-                    targetCompatibility = JavaVersion.VERSION_21
-                }
+            defaultConfig {
+                minSdk = 29
             }
 
-            extensions.configure<JavaPluginExtension> {
-                toolchain {
-                    languageVersion.set(JavaLanguageVersion.of(21))
-                }
+            compileOptions {
+                sourceCompatibility = JavaVersion.VERSION_21
+                targetCompatibility = JavaVersion.VERSION_21
             }
+        }
 
-            extensions.configure<KotlinAndroidProjectExtension> {
-                jvmToolchain(21)
+        extensions.configure<JavaPluginExtension> {
+            toolchain {
+                languageVersion.set(JavaLanguageVersion.of(21))
             }
         }
+
+        extensions.configure<KotlinAndroidProjectExtension> {
+            jvmToolchain(21)
+        }
     }
 }
diff --git a/build-logic/src/main/kotlin/ProjectExt.kt b/build-logic/src/main/kotlin/ProjectExt.kt
@@ -1,6 +1,5 @@
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.extra
-import org.jetbrains.kotlin.konan.properties.hasProperty
 import java.io.File
 import java.io.FileInputStream
 import java.io.InputStreamReader
@@ -17,16 +16,14 @@ val Project.releaseKeyStore: File get() = File(project.properties["keyStore"] as
 val Project.releaseKeyStorePassword: String get() = project.properties["keyStorePassword"] as String
 val Project.releaseKeyAlias: String get() = project.properties["keyAlias"] as String
 val Project.releaseKeyPassword: String get() = project.properties["keyPassword"] as String
-val Project.hasReleaseKeyStore: Boolean get() = run {
+val Project.hasReleaseKeyStore: Boolean get() {
     gradleSigningProperties(rootDir).apply {
-        if (!hasProperty("keyStore")) return@apply
-
         stringPropertyNames().forEach {
             project.extra[it] = getProperty(it)
         }
     }
 
-    project.hasProperty("keyStore")
+    return project.hasProperty("keyStore")
 }
 
 private fun gradleSigningProperties(rootDir: File): Properties {