feat: Add build-logic with Versioning and Publishing plugins

Author: bratta-dk

.gitignore

@@ -2,6 +2,6 @@
 .gradle
 /local.properties
 /.idea
-/build
+build/
 .DS_Store
 /.kotlin

build-logic/convention/build.gradle.kts

@@ -0,0 +1,28 @@
+plugins {
+    `kotlin-dsl`
+}
+
+repositories {
+    google()
+    mavenCentral()
+    gradlePluginPortal()
+}
+
+dependencies {
+    compileOnly("com.android.tools.build:gradle:8.2.2")
+    implementation("software.amazon.awssdk:codeartifact:2.20.68")
+    implementation("pl.allegro.tech.build:axion-release-plugin:1.15.4")
+}
+
+gradlePlugin {
+    plugins {
+        register("projectVersioning") {
+            id = "convention.project.versioning"
+            implementationClass = "plugins.VersioningConventionPlugin"
+        }
+        register("projectPublishing") {
+            id = "convention.publishing"
+            implementationClass = "plugins.PublishingConventionPlugin"
+        }
+    }
+}

build-logic/convention/src/main/kotlin/extensions/PublishingConfigExtension.kt

@@ -0,0 +1,30 @@
+package extensions
+
+open class PublishingConfigExtension(
+    var groupId: String = "",
+    var artifactId: String = "",
+    // CodeArtifact specific
+    var domain: String = "",
+    var domainOwner: String = "",
+    var repository: String = "",
+    var region: String = "us-east-1",
+) {
+    fun groupId(value: String) {
+        groupId = value
+    }
+    fun artifactId(value: String) {
+        artifactId = value
+    }
+    fun domain(value: String) {
+        domain = value
+    }
+    fun domainOwner(value: String) {
+        domainOwner = value
+    }
+    fun repository(value: String) {
+        repository = value
+    }
+    fun region(value: String) {
+        region = value
+    }
+}

build-logic/convention/src/main/kotlin/extensions/VersioningExtension.kt

@@ -0,0 +1,20 @@
+package extensions
+
+open class VersioningExtension(
+    var tagPrefix: String = "",
+    var useHighestVersion: Boolean = true,
+    var initialVersion: String = "0.1.0",
+) {
+
+    fun tagPrefix(value: String) {
+        tagPrefix = value
+    }
+
+    fun useHighestVersion(value: Boolean) {
+        useHighestVersion = value
+    }
+
+    fun initialVersion(value: String) {
+        initialVersion = value
+    }
+}

build-logic/convention/src/main/kotlin/plugins/PublishingConventionPlugin.kt

@@ -0,0 +1,75 @@
+package plugins
+
+import extensions.PublishingConfigExtension
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.publish.PublishingExtension
+import org.gradle.api.publish.maven.MavenPublication
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.create
+import org.gradle.kotlin.dsl.get
+import software.amazon.awssdk.regions.Region
+import software.amazon.awssdk.services.codeartifact.CodeartifactClient
+import software.amazon.awssdk.services.codeartifact.model.GetAuthorizationTokenRequest
+
+@Suppress("unused")
+class PublishingConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply("maven-publish")
+            }
+
+            val extension = extensions.create("publishingConfig", PublishingConfigExtension::class.java)
+
+            afterEvaluate {
+                configurePublishing(extension)
+            }
+        }
+    }
+
+    private fun Project.configurePublishing(extension: PublishingConfigExtension) {
+        extensions.configure<PublishingExtension> {
+            publications {
+                // Creates a Maven publication called "release".
+                create<MavenPublication>("release") {
+                    // Applies the component for the release build variant.
+                    from(components["release"])
+
+                    // You can then customize attributes of the publication as shown below.
+                    groupId = extension.groupId
+                    artifactId = extension.artifactId
+                }
+            }
+            repositories {
+                // CodeArtifact repository
+                maven {
+                    name = "CodeArtifact"
+                    url = project.uri(getCodeArtifactRepoUrl(extension))
+                    credentials {
+                        username = "aws"
+                        password = getCodeArtifactAuthToken(extension)
+                    }
+                }
+            }
+        }
+    }
+
+    @Suppress("ktlint:standard:max-line-length")
+    private fun getCodeArtifactRepoUrl(extension: PublishingConfigExtension): String {
+        return "https://${extension.domain}-${extension.domainOwner}.d.codeartifact.${extension.region}.amazonaws.com/maven/${extension.repository}/"
+    }
+
+    private fun getCodeArtifactAuthToken(extension: PublishingConfigExtension): String {
+        val client = CodeartifactClient.builder()
+            .region(Region.of(extension.region))
+            .build()
+
+        val request = GetAuthorizationTokenRequest.builder()
+            .domain(extension.domain)
+            .domainOwner(extension.domainOwner)
+            .build()
+
+        return client.getAuthorizationToken(request).authorizationToken()
+    }
+}

build-logic/convention/src/main/kotlin/plugins/VersioningConventionPlugin.kt

@@ -0,0 +1,75 @@
+package plugins
+
+import com.android.build.gradle.AppExtension
+import com.android.build.gradle.BaseExtension
+import com.android.build.gradle.LibraryExtension
+import extensions.VersioningExtension
+import org.gradle.api.GradleException
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import pl.allegro.tech.build.axion.release.ReleasePlugin
+import pl.allegro.tech.build.axion.release.domain.VersionConfig
+
+@Suppress("unused")
+class VersioningConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            if (this != rootProject) {
+                throw GradleException(
+                    "Versioning plugin can be applied to the root project only",
+                )
+            }
+
+            with(pluginManager) {
+                apply(ReleasePlugin::class.java)
+            }
+
+            val extension = extensions.create("versioning", VersioningExtension::class.java)
+
+            afterEvaluate {
+                configureVersioning(extension)
+            }
+        }
+    }
+
+    private fun Project.configureVersioning(extension: VersioningExtension) {
+        val scmConfig = extensions.getByType(VersionConfig::class.java).apply {
+            useHighestVersion.set(extension.useHighestVersion)
+            versionCreator("versionWithBranch")            
+            tag {
+                prefix.set(extension.tagPrefix)
+                versionSeparator.set("")
+                initialVersion.set({ _, _ -> extension.initialVersion })
+            }
+        }
+        allprojects {
+            version = scmConfig.version
+            setupAndroidVersioning(scmConfig)
+        }
+    }
+
+    private fun Project.setupAndroidVersioning(scmConfig: VersionConfig) {
+        val configureVersion: BaseExtension.(String) -> Unit = { version ->
+            val minor = version.split(".")[0].toInt()
+            val major = version.split(".")[1].toInt()
+            val patch = version.split(".")[2].toInt()
+            defaultConfig.versionCode = minor * MINOR_MULTIPLIER + major * MAJOR_MULTIPLIER + patch
+            defaultConfig.versionName = "$minor.$major.$patch"
+        }
+        pluginManager.withPlugin("com.android.library") {
+            extensions.getByType(LibraryExtension::class.java).apply {
+                configureVersion(scmConfig.undecoratedVersion)
+            }
+        }
+        pluginManager.withPlugin("com.android.application") {
+            extensions.getByType(AppExtension::class.java).apply {
+                configureVersion(scmConfig.undecoratedVersion)
+            }
+        }
+    }
+
+    companion object {
+        private const val MINOR_MULTIPLIER = 1_000_000
+        private const val MAJOR_MULTIPLIER = 1_000
+    }
+}

build-logic/gradle.properties

@@ -0,0 +1,4 @@
+# Gradle properties are not passed to included builds https://github.com/gradle/gradle/issues/2534
+org.gradle.parallel=true
+org.gradle.caching=true
+org.gradle.configureondemand=true

build-logic/settings.gradle.kts

@@ -0,0 +1,19 @@
+pluginManagement {
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+
+dependencyResolutionManagement {
+    @Suppress("UnstableApiUsage")
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+
+rootProject.name = "build-logic"
+include(":convention")