feat(ci): ⚡ add build-logic

apps/androidApp/build.gradle.kts

@@ -4,12 +4,12 @@ plugins {
 }
 
 android {
-    namespace = "com.multiplatformkickstarter.app.android"
-    compileSdk = properties["multiplatformkickstarter.android.compileSdk"].toString().toInt()
+    namespace = "io.astrum.mindsync.app.android"
+    compileSdk = properties["mindsync.android.compileSdk"].toString().toInt()
     defaultConfig {
-        applicationId = "com.multiplatformkickstarter.app.android"
-        minSdk = properties["multiplatformkickstarter.android.minSdk"].toString().toInt()
-        targetSdk = properties["multiplatformkickstarter.android.targetSdk"].toString().toInt()
+        applicationId = "io.astrum.mindsync.app.android"
+        minSdk = properties["mindsync.android.minSdk"].toString().toInt()
+        targetSdk = properties["mindsync.android.targetSdk"].toString().toInt()
         versionName = "1.0"
     }
     buildFeatures {

apps/backend/build.gradle.kts

@@ -6,7 +6,7 @@ plugins {
 }
 
 application {
-    mainClass.set("com.multiplatformkickstarter.ApplicationKt")
+    mainClass.set("io.astrum.mindsync.server.ApplicationKt")
 
     val isDevelopment: Boolean = project.ext.has("development")
     applicationDefaultJvmArgs = listOf("-Dio.ktor.development=$isDevelopment")

build-logic/analysis-convention/build.gradle.kts

@@ -0,0 +1,12 @@
+plugins {
+    `kotlin-dsl`
+}
+
+group = "io.astrum.mindsync.buildlogic.analysis"
+version = extra["app.plugins.version"].toString()
+
+dependencies {
+    implementation(libs.gradle.detekt)
+    implementation(libs.gradle.owasp.depcheck)
+    implementation(project(":common"))
+}

build-logic/analysis-convention/src/main/kotlin/detekt-convention.gradle.kts

@@ -0,0 +1,37 @@
+import io.astrum.mindsync.buildlogic.common.AppConfiguration
+import io.astrum.mindsync.buildlogic.common.extensions.catalogLib
+import io.gitlab.arturbosch.detekt.Detekt
+
+plugins {
+    id("io.gitlab.arturbosch.detekt")
+}
+
+detekt {
+    toolVersion = "1.23.3"
+    parallel = true
+    ignoreFailures = false
+    autoCorrect = true
+    buildUponDefaultConfig = true
+    config.setFrom(files("$rootDir/config/detekt.yml"))
+}
+
+tasks.withType<Detekt>().configureEach {
+    jvmTarget = AppConfiguration.jvmTargetStr
+    setSource(files(projectDir))
+    include("**/*.kt", "**/*.kts")
+    exclude("**/resources/**", "**/build/**")
+    reports {
+        xml.required.set(true)
+        html.required.set(true)
+        txt.required.set(true)
+        sarif.required.set(true)
+        md.required.set(true)
+    }
+}
+
+
+dependencies {
+    detektPlugins(catalogLib("detekt-compose"))
+    detektPlugins(catalogLib("detekt-compose2"))
+    detektPlugins(catalogLib("detekt-formatting"))
+}

build-logic/analysis-convention/src/main/kotlin/security-owasp-convention.gradle.kts

@@ -0,0 +1,26 @@
+import org.gradle.kotlin.dsl.configure
+import org.owasp.dependencycheck.gradle.extension.DependencyCheckExtension
+import org.owasp.dependencycheck.reporting.ReportGenerator
+
+plugins{
+    id("org.owasp.dependencycheck")
+}
+
+configure<DependencyCheckExtension> {
+    failBuildOnCVSS = 9F
+    formats = listOf(
+        ReportGenerator.Format.HTML.toString(),
+        ReportGenerator.Format.JUNIT.toString(),
+        ReportGenerator.Format.XML.toString(),
+        ReportGenerator.Format.SARIF.toString()
+    )
+    suppressionFile = "${rootProject.rootDir}/config/owasp/owasp-supression.xml"
+
+    // remove plugin dependencies, for configs see
+    // https://docs.gradle.org/current/userguide/java_plugin.html#sec:java_plugin_and_dependency_management
+    val validConfigurations = listOf("compileClasspath", "runtimeClasspath", "default")
+    scanConfigurations = configurations.names
+        .filter { validConfigurations.contains(it) }
+        .toList()
+    outputDirectory = layout.buildDirectory.dir("reports/owasp").get().asFile.absolutePath
+}

build-logic/common/build.gradle.kts

@@ -0,0 +1,16 @@
+plugins {
+    `kotlin-dsl`
+}
+
+group = "io.astrum.mindsync.buildlogic.common"
+version = extra["app.plugins.version"].toString()
+
+
+dependencies {
+//    implementation(libs.gradle.compose)
+//    implementation(libs.gradle.android)
+//    implementation(libs.gradle.sentry)
+    implementation(libs.gradle.kotlin)
+//    implementation(libs.gradle.kotlin.serialization)
+//    implementation(libs.gradle.devtools.ksp)
+}

build-logic/common/src/main/kotlin/io/astrum/mindsync/buildlogic/common/AppConfiguration.kt

@@ -0,0 +1,15 @@
+package io.astrum.mindsync.buildlogic.common
+
+import org.gradle.api.JavaVersion
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget as KtJvmTarget
+import org.jetbrains.kotlin.gradle.dsl.KotlinVersion as KtVersion
+
+object AppConfiguration {
+    const val appName = "Mindsync"
+    const val packageName = "io.astrum.mindsync"
+
+    val useJavaVersion = JavaVersion.VERSION_17
+    val jvmTarget = KtJvmTarget.fromTarget(useJavaVersion.toString())
+    val jvmTargetStr = jvmTarget.target
+    val kotlinVersion = KtVersion.KOTLIN_1_9
+}

build-logic/common/src/main/kotlin/io/astrum/mindsync/buildlogic/common/extensions/CommonExtension.kt

@@ -0,0 +1,64 @@
+@file:Suppress("UNUSED")
+package io.astrum.mindsync.buildlogic.common.extensions
+
+import io.astrum.mindsync.buildlogic.common.AppConfiguration
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.artifacts.ExternalModuleDependency
+import org.gradle.api.artifacts.VersionCatalog
+import org.gradle.api.artifacts.VersionCatalogsExtension
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.TaskContainer
+import org.gradle.api.tasks.compile.JavaCompile
+import org.gradle.kotlin.dsl.DependencyHandlerScope
+import org.gradle.kotlin.dsl.getByType
+import org.gradle.kotlin.dsl.withType
+import org.jetbrains.kotlin.gradle.plugin.KotlinDependencyHandler
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+val Project.libs: VersionCatalog get() = extensions.getByType<VersionCatalogsExtension>().named("libs")
+
+val Project.fullPackageName get() = AppConfiguration.packageName + path.replace(':', '.')
+
+fun Project.catalogVersion(alias: String) = libs.findVersion(alias).get().toString()
+fun Project.catalogLib(alias: String) = libs.findLibrary(alias).get()
+fun Project.catalogBundle(alias: String) = libs.findBundle(alias).get()
+
+fun KotlinDependencyHandler.catalogVersion(alias: String) = project.catalogVersion(alias)
+fun KotlinDependencyHandler.catalogLib(alias: String) = project.catalogLib(alias)
+fun KotlinDependencyHandler.catalogBundle(alias: String) = project.catalogBundle(alias)
+
+fun KotlinDependencyHandler.implementation(
+    dependencyNotation: Provider<*>,
+    configure: ExternalModuleDependency.() -> Unit
+) {
+    implementation(dependencyNotation.get().toString(), configure)
+}
+
+fun DependencyHandlerScope.implementation(
+    provider: Provider<*>,
+    dependencyConfiguration: ExternalModuleDependency.() -> Unit = {},
+) {
+    "implementation"(provider, dependencyConfiguration)
+}
+
+
+fun Project.coerceComposeVersion(configuration: Configuration) {
+    val independentGroups = setOf("compiler", "material3")
+    configuration.resolutionStrategy.eachDependency {
+        if (requested.group.startsWith("androidx.compose") && independentGroups.none(requested.group::contains)) {
+            useVersion(libs.findVersion("compose").get().requiredVersion)
+            because("I need the changes in lazyGrid")
+        }
+    }
+}
+
+fun TaskContainer.commonTasks() {
+    withType<JavaCompile>().configureEach {
+        sourceCompatibility = AppConfiguration.jvmTargetStr
+        targetCompatibility = AppConfiguration.jvmTargetStr
+    }
+    withType<KotlinCompile>().configureEach {
+        project.configureKotlinJvm()
+    }
+}

build-logic/common/src/main/kotlin/io/astrum/mindsync/buildlogic/common/extensions/KotlinJvmExtension.kt

@@ -0,0 +1,53 @@
+package io.astrum.mindsync.buildlogic.common.extensions
+
+import org.gradle.api.Action
+import org.gradle.api.JavaVersion
+import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.withType
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmOptions
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import org.gradle.api.Project
+
+/**
+* Configure base Kotlin options for JVM (non-Android)
+*/
+ fun Project.configureKotlinJvm() {
+    extensions.configure<JavaPluginExtension> {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+    configureKotlin()
+}
+
+/**
+ * Configure base Kotlin options
+ */
+private fun Project.configureKotlin() {
+    // Use withType to workaround https://youtrack.jetbrains.com/issue/KT-55947
+    tasks.withType<KotlinCompile>().configureEach {
+        kotlinOptions {
+            jvmTarget = JavaVersion.VERSION_17.toString()
+            freeCompilerArgs = freeCompilerArgs + listOf(
+                "-opt-in=androidx.compose.animation.ExperimentalAnimationApi",
+                "-opt-in=androidx.compose.material.ExperimentalMaterialApi",
+                "-opt-in=kotlinx.serialization.ExperimentalSerializationApi",
+                "-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
+                "-opt-in=kotlinx.coroutines.FlowPreview"
+            )
+        }
+    }
+    val kotlinOptions = "kotlinOptions"
+    if (extensions.findByName(kotlinOptions) != null) {
+        extensions.configure(kotlinOptions, Action<KotlinJvmOptions> {
+            jvmTarget = JavaVersion.VERSION_17.toString()
+            freeCompilerArgs = freeCompilerArgs + listOf(
+                "-opt-in=androidx.compose.animation.ExperimentalAnimationApi",
+                "-opt-in=androidx.compose.material.ExperimentalMaterialApi",
+                "-opt-in=kotlinx.serialization.ExperimentalSerializationApi",
+                "-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
+                "-opt-in=kotlinx.coroutines.FlowPreview"
+            )
+        })
+    }
+}

build-logic/gradle.properties

@@ -0,0 +1,7 @@
+org.gradle.parallel=true
+org.gradle.caching=true
+org.gradle.configureondemand=true
+org.gradle.configuration-cache=true
+
+
+app.plugins.version=0.0.1

build-logic/settings.gradle.kts

@@ -0,0 +1,28 @@
+rootProject.name = "build-logic"
+
+dependencyResolutionManagement {
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+    versionCatalogs {
+        register("libs") {
+            from(files("../gradle/libs.versions.toml"))
+        }
+    }
+}
+
+// Keep in sync with ../settings.gradle.kts
+buildCache {
+    local {
+        directory = rootDir.parentFile.resolve(".gradle/build-cache")
+    }
+}
+
+
+include(":common")
+//include(":android-convention")
+//include(":multiplatform-convention")
+include("analysis-convention")
+//include("documentation-convention")

build.gradle.kts

@@ -5,24 +5,6 @@ plugins {
     kotlin("multiplatform").version(libs.versions.kotlin).apply(false)
     kotlin("plugin.serialization").version(libs.versions.kotlin).apply(false)
     alias(libs.plugins.compose.multiplatform).apply(false)
-    alias(libs.plugins.ktlint).apply(false)
-    alias(libs.plugins.detekt).apply(false)
+    id("detekt-convention")
+    id("security-owasp-convention")
 }
-
-subprojects {
-    if (name != "desktopApp") {
-        apply(plugin = "org.jlleitschuh.gradle.ktlint")
-        apply(plugin = "io.gitlab.arturbosch.detekt")
-
-        configure<org.jlleitschuh.gradle.ktlint.KtlintExtension> {
-            debug.set(true)
-        }
-
-        configure<io.gitlab.arturbosch.detekt.extensions.DetektExtension> {
-            parallel = false
-            config.setFrom("../config/detekt-config.yml")
-            buildUponDefaultConfig = false
-        }
-
-    }
-}

config/owasp/owasp-supression.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<suppressions xmlns="https://jeremylong.github.io/DependencyCheck/dependency-suppression.1.3.xsd">
+</suppressions>

gradle.properties

@@ -23,6 +23,6 @@ org.jetbrains.compose.experimental.uikit.enabled=true
 kotlin.native.cachekind=none
 
 #MindSync config
-multiplatformkickstarter.android.compileSdk = 34
-multiplatformkickstarter.android.minSdk = 26
-multiplatformkickstarter.android.targetSdk = 34
+mindsync.android.compileSdk = 34
+mindsync.android.minSdk = 26
+mindsync.android.targetSdk = 34

gradle/libs.versions.toml

@@ -20,8 +20,20 @@ espressoCore = "3.5.1"
 accompanistSystemuicontroller = "0.32.0"
 activityCompose = "1.8.0"
 firebase = "32.5.0"
+owasp = "8.4.2"
 
 [libraries]
+# Gradle Plugins
+gradle-kotlin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
+# Utils
+gradle-owasp-depcheck = { module = "org.owasp:dependency-check-gradle", version.ref = "owasp" }
+# Detekt
+gradle-detekt = { module = "io.gitlab.arturbosch.detekt:detekt-gradle-plugin", version.ref = "detekt" }
+detekt-compose = { module = "io.nlopez.compose.rules:detekt", version = "0.3.0" }
+detekt-compose2 = { module = "ru.kode:detekt-rules-compose", version = "1.3.0" }
+detekt-formatting = { module = "io.gitlab.arturbosch.detekt:detekt-formatting", version.ref = "detekt" }
+
+
 # Common
 ktor-client-darwin = { module = "io.ktor:ktor-client-darwin", version.ref = "ktor-client" }
 ktor-client-android = { module = "io.ktor:ktor-client-android", version.ref = "ktor-client" }
@@ -115,7 +127,7 @@ android-application = { id = "com.android.application", version.ref = "androidGr
 android-library = { id = "com.android.library", version.ref = "androidGradlePlugin" }
 compose-multiplatform = { id = "org.jetbrains.compose", version.ref = "composeMultiplatform" }
 ktlint = { id = "org.jlleitschuh.gradle.ktlint", version.ref = "ktlint" }
-detekt = { id = "io.gitlab.arturbosch.detekt", version.ref = "detekt" }
+#detekt = { id = "io.gitlab.arturbosch.detekt", version.ref = "detekt" }
 
 #Backend
 kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version = "1.6.10" }

settings.gradle.kts

@@ -16,7 +16,7 @@ dependencyResolutionManagement {
 }
 
 pluginManagement {
-//    includeBuild("build-logic")
+    includeBuild("build-logic")
     repositories {
         mavenCentral()
         google()

shared/build.gradle.kts

@@ -102,10 +102,10 @@ kotlin {
 }
 
 android {
-    namespace = "com.multiplatformkickstarter.app"
-    compileSdk = properties["multiplatformkickstarter.android.compileSdk"].toString().toInt()
+    namespace = "io.astrum.mindsync.app"
+    compileSdk = properties["mindsync.android.compileSdk"].toString().toInt()
     defaultConfig {
-        minSdk = properties["multiplatformkickstarter.android.minSdk"].toString().toInt()
+        minSdk = properties["mindsync.android.minSdk"].toString().toInt()
     }
     compileOptions {
         sourceCompatibility = JavaVersion.VERSION_17

shared/src/androidMain/kotlin/io/astrum/mindsync/app/localization/Localization.android.kt

@@ -3,7 +3,7 @@ package io.astrum.mindsync.app.localization
 import android.content.res.Configuration
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.platform.LocalContext
-import java.util.Locale
+import java.util.*
 
 actual fun getCurrentLanguage(): AvailableLanguages {
     return when (Locale.getDefault().language) {