Expose supported types in ComparatorRegistry

base/src/main/kotlin/io/spine/compare/ComparatorRegistry.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2024, TeamDev. All rights reserved.
+ * Copyright 2026, TeamDev. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -78,6 +78,15 @@ public object ComparatorRegistry {
     @JvmStatic
     public fun contains(clazz: Class<*>): Boolean = map.containsKey(clazz)
 
+    /**
+     * Returns the types for which comparators are currently registered.
+     *
+     * The returned set is a snapshot; subsequent registrations do not
+     * affect it, and modifying it does not affect the registry.
+     */
+    @JvmStatic
+    public fun types(): Set<Class<*>> = map.keys.toSet()
+
     private fun loadServiceProviders() {
         ServiceLoader.load(ComparatorProvider::class.java)
             .forEach { it.registerIn(this) }

base/src/test/kotlin/io/spine/compare/ComparatorRegistrySpec.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2024, TeamDev. All rights reserved.
+ * Copyright 2026, TeamDev. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -29,7 +29,10 @@ package io.spine.compare
 import com.google.protobuf.Duration
 import com.google.protobuf.Timestamp
 import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.collections.shouldContain
+import io.kotest.matchers.collections.shouldNotContain
 import io.kotest.matchers.shouldBe
+import java.util.UUID
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Test
 
@@ -76,4 +79,26 @@ internal class ComparatorRegistrySpec {
         registry.register<StringBuilder>(comparator)
         registry.find<StringBuilder>() shouldBe comparator
     }
+
+    @Test
+    fun `expose the supported types`() {
+        registry.types() shouldContain Timestamp::class.java
+        registry.types() shouldContain Duration::class.java
+    }
+
+    @Test
+    fun `include a newly registered type among the supported types`() {
+        val comparator = compareBy<CharSequence> { it.length }
+        registry.types() shouldNotContain CharSequence::class.java
+        registry.register<CharSequence>(comparator)
+        registry.types() shouldContain CharSequence::class.java
+    }
+
+    @Test
+    fun `return a snapshot of the supported types`() {
+        val snapshot = registry.types()
+        snapshot shouldNotContain UUID::class.java
+        registry.register<UUID>(compareBy { it.toString() })
+        snapshot shouldNotContain UUID::class.java
+    }
 }

buildSrc/src/main/kotlin/io/spine/dependency/local/Compiler.kt

@@ -27,8 +27,6 @@
 package io.spine.dependency.local
 
 import io.spine.dependency.Dependency
-import io.spine.dependency.local.Compiler.DF_VERSION_ENV
-import io.spine.dependency.local.Compiler.VERSION_ENV
 
 /**
  * Dependencies on the Spine Compiler modules.
@@ -74,7 +72,7 @@ object Compiler : Dependency() {
      * The version of the Compiler dependencies.
      */
     override val version: String
-    private const val fallbackVersion = "2.0.0-SNAPSHOT.057"
+    private const val fallbackVersion = "2.0.0-SNAPSHOT.059"
 
     /**
      * The distinct version of the Compiler used by other build tools.
@@ -83,7 +81,7 @@ object Compiler : Dependency() {
      * transitive dependencies, this is the version used to build the project itself.
      */
     val dogfoodingVersion: String
-    private const val fallbackDfVersion = "2.0.0-SNAPSHOT.057"
+    private const val fallbackDfVersion = "2.0.0-SNAPSHOT.059"
 
     /**
      * The artifact for the Compiler Gradle plugin.

buildSrc/src/main/kotlin/io/spine/gradle/VersionGradleFile.kt

@@ -33,14 +33,20 @@ import org.gradle.api.GradleException
  * Reads a `version.gradle.kts` file and resolves the `extra` properties it declares.
  *
  * [contentUnder] and [contentInBase] read the file (from the working tree or a base branch);
- * [keyForValue] and [valueForKey] resolve its `extra` properties. The following declaration
- * shapes are handled (see the `bump-version` skill):
+ * [keyForValue] and [valueForKey] resolve its `extra` properties. Each property is registered
+ * either with the current `extra.set("name", …)` call or the legacy `by extra(…)` property
+ * delegate that Gradle deprecated (the `bump-version` skill migrates the latter to the former);
+ * both spellings are recognized, so a file is read correctly whether or not it has migrated.
+ * The following value shapes are handled:
  *
- *  1. a literal: `val versionToPublish: String by extra("2.0.0-SNAPSHOT.182")`;
- *  2. an alias to another `extra`: `val versionToPublish by extra(compilerVersion)` paired
- *     with `val compilerVersion: String by extra("2.0.0-SNAPSHOT.043")`;
- *  3. an alias to a plain `val`: `val versionToPublish by extra(base)` paired with
- *     `val base = "2.0.0-SNAPSHOT.043"`.
+ *  1. a literal:
+ *     `extra.set("versionToPublish", "2.0.0-SNAPSHOT.182")`, or the legacy
+ *     `val versionToPublish: String by extra("2.0.0-SNAPSHOT.182")`;
+ *  2. an alias to a plain `val` (or, in the legacy spelling, to another `extra`):
+ *     `extra.set("versionToPublish", compilerVersion)` paired with
+ *     `val compilerVersion = "2.0.0-SNAPSHOT.043"`, or the legacy
+ *     `val versionToPublish by extra(compilerVersion)` paired with
+ *     `val compilerVersion: String by extra("2.0.0-SNAPSHOT.043")`.
  *
  * The publishing-version property is identified by [keyForValue] using the already-resolved
  * project version as an oracle, so the specific property name (`versionToPublish`,
@@ -56,10 +62,19 @@ internal object VersionGradleFile {
      */
     const val NAME = "version.gradle.kts"
 
+    // Legacy `by extra(…)` property-delegate spellings (deprecated by Gradle).
     private val literalExtra =
         Regex("""val\s+(\w+)\s*(?::\s*String)?\s+by\s+extra\(\s*"([^"]+)"\s*\)""")
     private val aliasExtra =
         Regex("""val\s+(\w+)\s*(?::\s*String)?\s+by\s+extra\(\s*([A-Za-z_]\w*)\s*\)""")
+
+    // Current `extra.set("name", …)` spellings.
+    private val literalSet =
+        Regex("""extra\.set\(\s*"(\w+)"\s*,\s*"([^"]+)"\s*\)""")
+    private val aliasSet =
+        Regex("""extra\.set\(\s*"(\w+)"\s*,\s*([A-Za-z_]\w*)\s*\)""")
+
+    // A plain `val name = "value"` that an alias may reference.
     private val plainAssignment =
         Regex("""val\s+(\w+)\s*(?::\s*String)?\s*=\s*"([^"]+)"""")
 
@@ -68,12 +83,12 @@ internal object VersionGradleFile {
      * string value.
      */
     private fun parse(content: String): Map<String, String> {
-        val literals = literalExtra.findAll(content)
+        val literals = (literalExtra.findAll(content) + literalSet.findAll(content))
             .associate { it.groupValues[1] to it.groupValues[2] }
         val plains = plainAssignment.findAll(content)
             .associate { it.groupValues[1] to it.groupValues[2] }
         val resolved = literals.toMutableMap()
-        aliasExtra.findAll(content).forEach { match ->
+        (aliasExtra.findAll(content) + aliasSet.findAll(content)).forEach { match ->
             val name = match.groupValues[1]
             val source = match.groupValues[2]
             if (name !in resolved) {

buildSrc/src/main/kotlin/io/spine/gradle/fs/LazyTempPath.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2025, TeamDev. All rights reserved.
+ * Copyright 2026, TeamDev. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -41,11 +41,16 @@ import java.nio.file.WatchService
  *
  * After the first usage, the instances of this type delegate all calls to the internally
  * created instance of [Path] created with [createTempDirectory].
+ *
+ * The directory is created under the [shared base directory][SpineTempDir], which is removed
+ * when the JVM — the Gradle daemon — shuts down. Build tasks delete their own directories
+ * eagerly as the primary cleanup; this shutdown removal is a safety net, so a directory does
+ * not outlive the daemon even when a build fails before its eager cleanup runs.
  */
 @Suppress("TooManyFunctions")
 class LazyTempPath(private val prefix: String) : Path {
 
-    private val delegate: Path by lazy { createTempDirectory(prefix) }
+    private val delegate: Path by lazy { createTempDirectory(SpineTempDir.path, prefix) }
 
     override fun compareTo(other: Path): Int = delegate.compareTo(other)
 

buildSrc/src/main/kotlin/io/spine/gradle/fs/SpineTempDir.kt

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2026, TeamDev. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package io.spine.gradle.fs
+
+import java.nio.file.Files.createDirectories
+import java.nio.file.Files.createTempDirectory
+import java.nio.file.Path
+
+/**
+ * A per-JVM parent directory for the temporary directories created by the build.
+ *
+ * The directory is created [lazily][path] under a common, attributable namespace —
+ * `<java.io.tmpdir>/io.spine.gradle.fs`, named after the package of [LazyTempPath] — so
+ * that leftover files are easy to attribute. Within that namespace, each JVM gets its own
+ * subdirectory named after the process id, so concurrent Gradle daemons never delete one
+ * another's temporary files.
+ *
+ * Upon creation, the per-JVM directory is scheduled for recursive removal when the JVM
+ * shuts down. This is a safety net should the explicit cleanup performed by the build
+ * tasks not run — for example, when a build fails before reaching it. The shared namespace
+ * directory itself is intentionally left in place: deleting it on shutdown could wipe
+ * directories still in use by another JVM running on the same machine.
+ *
+ * @see LazyTempPath
+ */
+internal object SpineTempDir {
+
+    /**
+     * The per-JVM directory, created on the first access and removed on JVM shutdown.
+     */
+    val path: Path by lazy { createPerJvmDir() }
+
+    private fun createPerJvmDir(): Path {
+        val namespace = Path.of(systemTempDir(), LazyTempPath::class.java.packageName)
+        createDirectories(namespace)
+        // A per-JVM directory keeps concurrent Gradle daemons from deleting one another's
+        // files when their shutdown hooks fire. The PID makes a leftover directory easy
+        // to attribute; `createTempDirectory` adds a random suffix so that a reused PID
+        // still yields a unique directory.
+        val pid = ProcessHandle.current().pid()
+        val jvmDir = createTempDirectory(namespace, "$pid-")
+        deleteRecursivelyOnShutdown(jvmDir)
+        return jvmDir
+    }
+
+    /**
+     * Obtains the value of the system property pointing to the temporary directory.
+     */
+    private fun systemTempDir(): String =
+        checkNotNull(System.getProperty("java.io.tmpdir")) {
+            "The `java.io.tmpdir` system property is not set."
+        }
+
+    /**
+     * Requests the recursive removal of the given [directory] when the JVM shuts down.
+     *
+     * @see Runtime.addShutdownHook
+     */
+    private fun deleteRecursivelyOnShutdown(directory: Path) {
+        val runtime = Runtime.getRuntime()
+        runtime.addShutdownHook(Thread {
+            val deleted = directory.toFile().deleteRecursively()
+            if (!deleted) {
+                System.err.println("Unable to delete the temporary directory `$directory`.")
+            }
+        })
+    }
+}