Enable configuration cache

Enable the configuration cache feature in Gradle, and adjust
various pieces of build logic that aren't configuration cache compatible.

Author: bioball

build-logic/src/main/kotlin/BuildInfo.kt

@@ -372,35 +372,33 @@ open class BuildInfo(private val project: Project) {
     org.gradle.internal.os.OperatingSystem.current()
   }
 
-  // could be `commitId: Provider<String> = project.provider { ... }`
-  val commitId: String by lazy {
-    // allow -DcommitId=abc123 for build environments that don't have git.
-    System.getProperty("commitId").let { if (it != null) return@lazy it }
+  private val computedCommitId: Provider<String> =
     // only run command once per build invocation
     if (project.path == project.rootProject.path) {
-      val process =
-        ProcessBuilder()
-          .command("git", "rev-parse", "--short", "HEAD")
-          .directory(project.rootDir)
-          .start()
-      process.waitFor().also { exitCode ->
-        if (exitCode == -1) throw RuntimeException(process.errorStream.reader().readText())
-      }
-      process.inputStream.reader().readText().trim()
+      project.providers
+        .exec { commandLine("git", "rev-parse", "--short", "HEAD") }
+        .standardOutput
+        .asText
+        .map { it.trim() }
     } else {
       project.rootProject.extensions.getByType(BuildInfo::class.java).commitId
     }
-  }
 
-  val commitish: String by lazy { if (isReleaseBuild) project.version.toString() else commitId }
+  val commitId: Provider<String> =
+    // allow -DcommitId=abc123 for build environments that don't have git.
+    System.getProperty("commitId")?.let { project.providers.provider { it } } ?: computedCommitId
 
-  val pklVersion: String by lazy {
+  val commitish: Provider<String> =
+    if (isReleaseBuild) project.providers.provider { project.version.toString() } else commitId
+
+  val pklVersion: Provider<String> =
     if (isReleaseBuild) {
-      project.version.toString()
+      project.providers.provider { project.version.toString() }
     } else {
-      project.version.toString().replace("-SNAPSHOT", "-dev+$commitId")
+      project.providers
+        .provider { project.version.toString() }
+        .zip(commitId) { version, id -> version.replace("-SNAPSHOT", "-dev+$id") }
     }
-  }
 
   val pklVersionNonUnique: String by lazy {
     if (isReleaseBuild) {

build-logic/src/main/kotlin/PklFormatterSpotless.kt

@@ -15,6 +15,7 @@
  */
 import com.diffplug.spotless.FormatterFunc
 import com.diffplug.spotless.FormatterStep
+import java.io.File
 import java.io.Serial
 import java.io.Serializable
 import java.net.URLClassLoader
@@ -26,33 +27,36 @@ class PklFormatterStep(@Transient private val configuration: Configuration) : Se
   }
 
   fun create(): FormatterStep {
+    val files = configuration.files.toList()
     return FormatterStep.createLazy(
       "pkl",
-      { PklFormatterStep(configuration) },
-      { PklFormatterFunc(configuration) },
+      { PklFormatterState(files) },
+      { PklFormatterFunc(it.files) },
     )
   }
 }
 
-class PklFormatterFunc(@Transient private val configuration: Configuration) :
-  FormatterFunc, Serializable {
+data class PklFormatterState(val files: List<File>) : Serializable
+
+class PklFormatterFunc(private val files: List<File>) : FormatterFunc, Serializable {
   companion object {
     @Serial private const val serialVersionUID: Long = 1L
   }
 
-  private val classLoader by lazy {
-    val urls = configuration.files.map { it.toURI().toURL() }
+  private fun getClassLoader(): ClassLoader {
+    val urls = files.map { it.toURI().toURL() }
     // Use the platform classloader as parent to isolate from Gradle's classloader
-    URLClassLoader(urls.toTypedArray(), ClassLoader.getPlatformClassLoader())
+    return URLClassLoader(urls.toTypedArray(), ClassLoader.getPlatformClassLoader())
   }
 
-  private val formatterClass by lazy { classLoader.loadClass("org.pkl.formatter.Formatter") }
-
-  private val formatMethod by lazy { formatterClass.getMethod("format", String::class.java) }
-
-  private val formatterInstance by lazy { formatterClass.getConstructor().newInstance() }
+  private fun loadFormatterClass(): Class<*> {
+    return getClassLoader().loadClass("org.pkl.formatter.Formatter")
+  }
 
   override fun apply(input: String): String {
+    val formatterClass = loadFormatterClass()
+    val formatMethod = formatterClass.getMethod("format", String::class.java)
+    val formatterInstance = formatterClass.getConstructor().newInstance()
     return formatMethod(formatterInstance, input) as String
   }
 }

build-logic/src/main/kotlin/pklFatJar.gradle.kts

@@ -15,10 +15,12 @@
  */
 import org.gradle.api.GradleException
 import org.gradle.api.artifacts.Configuration
+import org.gradle.api.file.ArchiveOperations
 import org.gradle.api.publish.maven.MavenPublication
 import org.gradle.api.tasks.bundling.Jar
 import org.gradle.api.tasks.testing.Test
 import org.gradle.kotlin.dsl.*
+import org.gradle.kotlin.dsl.support.serviceOf
 
 plugins {
   `java-library`
@@ -150,17 +152,19 @@ tasks.check { dependsOn(testFatJar) }
 
 val validateFatJar by tasks.registering {
   val outputFile = layout.buildDirectory.file("validateFatJar/result.txt")
-  inputs.files(tasks.shadowJar)
+  val shadowJarFile = tasks.shadowJar.flatMap { it.archiveFile }
+  val archiveOps = serviceOf<ArchiveOperations>()
+  inputs.file(shadowJarFile)
   inputs.property("nonRelocations", nonRelocations)
   outputs.file(outputFile)
+  val nonRelocations = nonRelocations
 
   doLast {
     val unshadowedFiles = mutableListOf<String>()
-    zipTree(tasks.shadowJar.get().outputs.files.singleFile).visit {
-      val fileDetails = this
-      val path = fileDetails.relativePath.pathString
+    archiveOps.zipTree(shadowJarFile.get().asFile).visit {
+      val path = relativePath.pathString
       if (
-        !(fileDetails.isDirectory ||
+        !(isDirectory ||
           path.startsWith("org/pkl/") ||
           path.startsWith("META-INF/") ||
           nonRelocations.any { path.startsWith(it) })

build-logic/src/main/kotlin/pklHtmlValidator.gradle.kts

@@ -68,7 +68,7 @@ val validateHtml by
     // write a basic result file s.t. gradle can consider task up-to-date
     // writing a result file in case validation fails is not easily possible with JavaExec, but also
     // not strictly necessary
-    doFirst { project.delete(resultFile) }
+    doFirst { resultFile.get().asFile.delete() }
     doLast { resultFile.get().asFile.writeText("Success.") }
   }
 

build-logic/src/main/kotlin/pklJavaExecutable.gradle.kts

@@ -47,8 +47,10 @@ fun Task.setupTestStartJavaExecutable(launcher: Provider<JavaLauncher>? = null)
   val outputFile = layout.buildDirectory.file("testStartJavaExecutable/$name")
   outputs.file(outputFile)
 
+  val executableFile = javaExecutable.flatMap { it.outJar }
+  val pklVersion = buildInfo.pklVersionNonUnique
   val execOutput = providers.exec {
-    val executablePath = javaExecutable.get().outputs.files.singleFile
+    val executablePath = executableFile.get().asFile
     if (launcher?.isPresent == true) {
       commandLine(
         launcher.get().executablePath.asFile.absolutePath,
@@ -63,9 +65,9 @@ fun Task.setupTestStartJavaExecutable(launcher: Provider<JavaLauncher>? = null)
 
   doLast {
     val outputText = execOutput.standardOutput.asText.get()
-    if (!outputText.contains(buildInfo.pklVersionNonUnique)) {
+    if (!outputText.contains(pklVersion)) {
       throw GradleException(
-        "Expected version output to contain current version (${buildInfo.pklVersionNonUnique}), but got '$outputText'"
+        "Expected version output to contain current version ($pklVersion), but got '$outputText'"
       )
     }
     outputFile.get().asFile.toPath().apply {

build.gradle.kts

@@ -53,27 +53,47 @@ idea {
   }
 }
 
-val clean by tasks.existing { delete(layout.buildDirectory) }
+val clean by tasks.existing {
+  val buildDirectory = layout.buildDirectory
+  doLast { delete(buildDirectory) }
+}
 
-val printVersion by tasks.registering { doFirst { println(buildInfo.pklVersion) } }
+val printVersion by tasks.registering {
+  val pklVersion = buildInfo.pklVersion
+  doFirst { println(pklVersion.get()) }
+}
 
-val message =
-  """
-====
-Gradle version : ${gradle.gradleVersion}
-Java version   : ${System.getProperty("java.version")}
-isParallel     : ${gradle.startParameter.isParallelProjectExecutionEnabled}
-maxWorkerCount : ${gradle.startParameter.maxWorkerCount}
-Architecture   : ${buildInfo.arch}
+val printInfo by tasks.registering {
+  val arch = buildInfo.arch
+  val pklVersion = buildInfo.pklVersion
+  val pklVersionNonUnique = buildInfo.pklVersionNonUnique
+  val commitId = buildInfo.commitId
+  val gradleVerison = gradle.gradleVersion
+  val javaVersion = System.getProperty("java.version")
+  val isParallel = gradle.startParameter.isParallelProjectExecutionEnabled
+  val maxWorkerCount = gradle.startParameter.maxWorkerCount
+  val projectVersion = project.version
+  doFirst {
+    val message =
+      """
+      ====
+      Gradle version : $gradleVerison
+      Java version   : $javaVersion
+      isParallel     : $isParallel
+      maxWorkerCount : $maxWorkerCount
+      Architecture   : $arch
 
-Project Version        : ${project.version}
-Pkl Version            : ${buildInfo.pklVersion}
-Pkl Non-Unique Version : ${buildInfo.pklVersionNonUnique}
-Git Commit ID          : ${buildInfo.commitId}
-====
-"""
+      Project Version        : $projectVersion
+      Pkl Version            : ${pklVersion.get()}
+      Pkl Non-Unique Version : $pklVersionNonUnique
+      Git Commit ID          : ${commitId.get()}
+      ====
+      """
+        .trimIndent()
 
-val formattedMessage =
-  message.replace("\n====", "\n" + "=".repeat(message.lines().maxByOrNull { it.length }!!.length))
+    val formattedMessage =
+      message.replace("====", "=".repeat(message.lines().maxByOrNull { it.length }!!.length))
 
-logger.info(formattedMessage)
+    println(formattedMessage)
+  }
+}

gradle.properties

@@ -15,6 +15,8 @@ org.gradle.jvmargs= \
 
 org.gradle.parallel=true
 org.gradle.caching=true
+org.gradle.configuration-cache=true
+
 kotlin.stdlib.default.dependency=false
 kotlin.daemon.jvmargs=-XX:+UseParallelGC
 #org.gradle.workers.max=1

pkl-cli/pkl-cli.gradle.kts

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import java.io.ByteArrayOutputStream
 import java.io.OutputStream
 import org.gradle.kotlin.dsl.support.serviceOf
 
@@ -118,7 +117,8 @@ private fun setupJavaExecutableRun(
         null -> "java"
         else -> launcher.get().executablePath.asFile.absolutePath
       }
-    standardOutput = OutputStream.nullOutputStream()
+
+    doFirst { standardOutput = OutputStream.nullOutputStream() }
 
     args("-jar", tasks.javaExecutable.get().outputs.files.singleFile.toString(), *args)
 
@@ -133,7 +133,10 @@ val evalTestFlags = arrayOf("eval", "-x", "1 + 1", "pkl:base")
 
 fun Exec.useRootDirAndSuppressOutput() {
   workingDir = rootProject.layout.projectDirectory.asFile
-  standardOutput = ByteArrayOutputStream() // we only care that this exec doesn't fail
+  doFirst {
+    // we only care that this exec doesn't fail
+    standardOutput = OutputStream.nullOutputStream()
+  }
 }
 
 // 0.28 Preparing for JDK21 toolchains revealed that `testStartJavaExecutable` may pass, even though

pkl-commons-test/pkl-commons-test.gradle.kts

@@ -70,17 +70,29 @@ for (packageDir in file("src/main/files/packages").listFiles()!!) {
       into(destinationDir)
       val shasumFile = destinationDir.map { it.file("${packageDir.name}.json.sha256") }
       outputs.file(shasumFile)
+      val hexDigits =
+        charArrayOf('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f')
+      val computeChecksum: (File) -> String = { file ->
+        val hash = MessageDigest.getInstance("SHA-256").digest(file.readBytes())
+        buildString(hash.size * 2) {
+          for (b in hash) {
+            append(hexDigits[b.toInt() shr 4 and 0xF])
+            append(hexDigits[b.toInt() and 0xF])
+          }
+        }
+      }
       filter { line ->
-        line.replaceFirst("\$computedChecksum", archiveFile.get().asFile.computeChecksum())
+        line.replaceFirst("\$computedChecksum", computeChecksum(archiveFile.get().asFile))
       }
+      val isWindows = buildInfo.os.isWindows
       doLast {
         val outputFile = destinationDir.get().asFile.resolve("${packageDir.name}.json")
-        if (buildInfo.os.isWindows) {
+        if (isWindows) {
           val contents = outputFile.readText()
           // workaround for https://github.com/gradle/gradle/issues/1151
           outputFile.writeText(contents.replace("\r\n", "\n"))
         }
-        shasumFile.get().asFile.writeText(outputFile.computeChecksum())
+        shasumFile.get().asFile.writeText(computeChecksum(outputFile))
       }
     }
 
@@ -111,6 +123,9 @@ val generateKeys by
         "CN=localhost",
       )
     workingDir(keystoreDir)
+    // capture keystoreFile inside closure so we don't reference `this$0`; which breaks Gradle
+    // configuration cache
+    val keystoreFile = keystoreFile
     doFirst {
       workingDir.mkdirs()
       keystoreFile.get().asFile.delete()
@@ -143,20 +158,3 @@ val exportCerts by
       outputFile.get().asFile.delete()
     }
   }
-
-fun toHex(hash: ByteArray): String {
-  val hexDigitTable =
-    charArrayOf('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f')
-  return buildString(hash.size * 2) {
-    for (b in hash) {
-      append(hexDigitTable[b.toInt() shr 4 and 0xF])
-      append(hexDigitTable[b.toInt() and 0xF])
-    }
-  }
-}
-
-fun File.computeChecksum(): String {
-  val md = MessageDigest.getInstance("SHA-256")
-  val hash = md.digest(readBytes())
-  return toHex(hash)
-}

pkl-config-java/pkl-config-java.gradle.kts

@@ -33,10 +33,11 @@ val generateTestConfigClasses by
 
     classpath = pklCodegenJava
     mainClass.set("org.pkl.codegen.java.Main")
+    val codegenSources = fileTree("src/test/resources/codegenPkl")
     argumentProviders.add(
       CommandLineArgumentProvider {
         listOf("--output-dir", outputDir.get().asFile.path, "--generate-javadoc") +
-          fileTree("src/test/resources/codegenPkl").map { it.path }
+          codegenSources.map { it.path }
       }
     )
   }