Versioning for program modules added

build.gradle.kts

@@ -41,6 +41,10 @@ gradlePlugin {
     }
 }
 
+kotlin {
+    jvmToolchain(masterLibs.versions.javaVersion.get().toInt())
+}
+
 java {
     toolchain {
         languageVersion.set(JavaLanguageVersion.of(masterLibs.versions.javaVersion.get()))

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.4.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

settings.gradle.kts

@@ -7,7 +7,7 @@ dependencyResolutionManagement {
 
     versionCatalogs {
         create("masterLibs") {
-            from("net.keinekekse:version-catalog:104")
+            from("net.keinekekse:version-catalog:141")
         }
     }
 }

src/main/kotlin/net/keinekekse/version/AddVersionTask.kt

@@ -5,10 +5,12 @@ import io.github.z4kn4fein.semver.withoutSuffixes
 import org.gradle.api.DefaultTask
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.MapProperty
 import org.gradle.api.provider.Property
 import org.gradle.api.tasks.*
 import java.util.*
 
+@CacheableTask
 abstract class AddVersionTask : DefaultTask() {
 
     // 1. Define what triggers the task (Source Files)
@@ -41,46 +43,100 @@ abstract class AddVersionTask : DefaultTask() {
     @get:Input
     abstract val versionPackageName: Property<String>
 
+    @get:Input
+    abstract val modules: MapProperty<String, Map<String, String>>
+
     @TaskAction
     fun execute() {
-        println("execute task: incrementBuildNumber")
         val buildNumber = incrementAndGetBuildNumber()
         writeClassFile(buildNumber)
     }
 
     private fun writeClassFile(buildNumber: String) {
-        val ver = getVersionInfo(buildNumber)
-
-        val file = versionClassFile.get().asFile
-        file.parentFile.mkdirs()
-        file.writeText(
+        var fileContent =
             """
                 package ${versionPackageName.get()}
                 
-                object VERSION {
-                    const val version = "${ver.version}"
-                    const val fullVersion = "${ver.fullVersion}"
-                    const val major = ${ver.major}
-                    const val minor = ${ver.minor}
-                    const val patch = ${ver.patch}
-                    const val preRelease = "${ver.preRelease}"
-                    const val buildMetadata = "${ver.buildMetadata}"
-                    const val buildDate = "${ver.buildDate}"
-                    const val displayName = "${ver.displayName}"
-                    const val copyright = "${ver.copyright}"
-                    const val name = "${ver.name}"
-                    const val description = "${ver.description}"
+                import net.keinekekse.version.Version
+                
+            """.trimIndent() +
+                    buildVersionObject(
+                        "",
+                        projectVersion.get(),
+                        buildNumber,
+                        displayNameExtra.get(),
+                        copyrightExtra.get(),
+                        projectName.get(),
+                        projectDescription.get()
+                    )
+        if (modules.isPresent) {
+            modules.get().forEach { (moduleName, moduleInfo) ->
+                fileContent +=
+                    buildVersionObject(
+                        moduleName,
+                        moduleInfo["version"] ?: "",
+                        buildNumber,
+                        moduleInfo["displayName"] ?: moduleName,
+                        moduleInfo["copyright"] ?: copyrightExtra.get(),
+                        moduleName,
+                        moduleInfo["description"] ?: ""
+                    )
+            }
+        }
+
+        val file = versionClassFile.get().asFile
+        file.parentFile.mkdirs()
+        file.writeText(fileContent)
+    }
+
+    private fun buildVersionObject(
+        moduleName: String,
+        versionString: String,
+        buildNumber: String,
+        longName: String,
+        copy: String,
+        shortName: String,
+        desc: String,
+    ): String {
+        val ver = getVersionInfo(versionString, buildNumber, longName, copy, shortName, desc)
+        val module = if (moduleName.isBlank()) {
+            ""
+        } else {
+            "_$moduleName"
+        }
+
+        return """
+                
+                object VERSION$module: Version {
+                    override val version = "${ver.version}"
+                    override val fullVersion = "${ver.fullVersion}"
+                    override val major = ${ver.major}
+                    override val minor = ${ver.minor}
+                    override val patch = ${ver.patch}
+                    override val preRelease = "${ver.preRelease}"
+                    override val buildMetadata = "${ver.buildMetadata}"
+                    override val buildDate = "${ver.buildDate}"
+                    override val displayName = "${ver.displayName}"
+                    override val copyright = "${ver.copyright}"
+                    override val name = "${ver.name}"
+                    override val description = "${ver.description}"
                 }
             """.trimIndent()
-        )
 
     }
 
-    private fun getVersionInfo(buildNumber: String): VersionInfo {
+    private fun getVersionInfo(
+        versionString: String,
+        buildNumber: String,
+        longName: String,
+        copy: String,
+        shortName: String,
+        desc: String,
+    ): VersionInfo {
         val version =
-            if (Version.parse(projectVersion.get(), strict = false).buildMetadata.isNullOrEmpty())
-                Version.parse(projectVersion.get() + "+build.$buildNumber", strict = false)
-            else Version.parse(projectVersion.get(), strict = false)
+            if (Version.parse(versionString, strict = false).buildMetadata.isNullOrEmpty())
+                Version.parse("$versionString+build.$buildNumber", strict = false)
+            else Version.parse(versionString, strict = false)
 
         println("Source files changed. Setting version to $version")
 
@@ -91,13 +147,14 @@ abstract class AddVersionTask : DefaultTask() {
             preRelease = version.preRelease ?: "",
             buildMetadata = version.buildMetadata ?: "",
             fullVersion = version.toString(),
-            version = if (version.isPreRelease) version.toString() else
+            version = if (version.isPreRelease)
+                "${version.major}.${version.minor}.${version.patch}-${version.preRelease}" else
                 version.withoutSuffixes().toString(),
             buildDate = java.time.Instant.now().toString(),
-            displayName = displayNameExtra.get(),
-            copyright = copyrightExtra.get(),
-            name = projectName.get(),
-            description = projectDescription.get() ?: ""
+            displayName = longName,
+            copyright = copy,
+            name = shortName,
+            description = desc
         )
     }
 

src/main/kotlin/net/keinekekse/version/VersionPlugin.kt

@@ -36,25 +36,53 @@ import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
  *  versionConfig {
  *      versionClassFile.set(layout.projectDirectory.file("src/main/kotlin/Version.kt"))
  *      versionPackageName.set("net.keinekekse")
+ *
+ *      // Optional Versionen von Teilbereichen des Programms
+ *       modules.set(
+ *         mapOf(
+ *             "books" to mapOf(  // -> object VERSION_books
+ *                 "version" to libs.versions.books.get(),
+ *                 "displayName" to "Books-DB",
+ *                 "copyright" to "Copyright (c) 2026 Hartmut Bauer", // null => extra["copyright]
+ *                 "description" to "Books + Comics Database"  // null => ""
+ *             )
+ *         )
+ *     )
  *  }
  * ```
  *
  * VERSION-class:
  *
  * ```
- * object VERSION {
- *     const val version = "1.0.0-beta.1+build.13" // für Release-Ver: major.minor.patch
- *     const val fullVersion = "1.0.0-beta.1+build.13"
- *     const val major = 1
- *     const val minor = 0
- *     const val patch = 0
- *     const val preRelease = "beta.1"
- *     const val buildMetadata = "build.13"
- *     const val buildDate = "2026-01-10T18:54:42.227942Z"
- *     const val displayName = "Program"
- *     const val copyright = "Copyright (c) 2026 Hartmut Bauer"
- *     const val name = "program-name"
- *     const val description = "Program description"
+ * import net.keinekekse.version.Version // -> util-Lib
+ *
+ * object VERSION: Version {
+ *     override val version = "1.0.0-beta.1 // für Release-Ver: major.minor.patch
+ *     override val fullVersion = "1.0.0-beta.1+build.13"
+ *     override val major = 1
+ *     override val minor = 0
+ *     override val patch = 0
+ *     override val preRelease = "beta.1"
+ *     override val buildMetadata = "build.13"
+ *     override val buildDate = "2026-01-10T18:54:42.227942Z"
+ *     override val displayName = "Program"
+ *     override val copyright = "Copyright (c) 2026 Hartmut Bauer"
+ *     override val name = "program-name"
+ *     override val description = "Program description"
+ * }
+ * object VERSION_books: Version {
+ *     override val version = "0.1.0-alpha.1"
+ *     override val fullVersion = "0.1.0-alpha.1+build.11"
+ *     override val major = 0
+ *     override val minor = 1
+ *     override val patch = 0
+ *     override val preRelease = "alpha.1"
+ *     override val buildMetadata = "build.11"
+ *     override val buildDate = "2026-09-19T00:18:40.584742Z"
+ *     override val displayName = "Books-DB"
+ *     override val copyright = "Copyright (c) 2026 Hartmut Bauer"
+ *     override val name = "books"
+ *     override val description = "Books + Comics Database"
  * }
  * ```
  *
@@ -121,6 +149,15 @@ class VersionPlugin : Plugin<Project> {
                         if (it.has("copyright")) it.get("copyright")?.toString() else ""
                     }
                 })
+                if (extension.modules.isPresent) {
+                    modules.set(extension.modules)
+                    extension.modules.get().forEach { (moduleName, moduleInfo) ->
+//                        project.extensions.create("${moduleName}Version", VersionPluginExtension::class.java).apply {
+//                            versionClassFile.set(project.layout.buildDirectory.file("generated/sources/version/${moduleName}/kotlin/${project.name}-version.kt"))
+//                            modules.set(moduleInfo)
+//                        }
+                    }
+                }
             }
 
         // 1. Handle Kotlin/JVM (Standard Project)

src/main/kotlin/net/keinekekse/version/VersionPluginExtension.kt

@@ -1,10 +1,13 @@
 package net.keinekekse.version
 
 import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.MapProperty
 import org.gradle.api.provider.Property
 
 interface VersionPluginExtension {
     val versionPackageName: Property<String>
 
     val versionClassFile: RegularFileProperty
+
+    val modules: MapProperty<String, Map<String, String>>
 }