Fix: clean and composite builds

src/main/kotlin/DevPublishPlugin.kt

@@ -163,12 +163,12 @@ constructor(
     inputs
       // Must convert to FileTree, because the directory might not exist, and
       // Gradle won't accept directories that don't exist as inputs.
-      .files(checksumsStore.asFileTree.sortedElements())
+      .files(checksumsStore.sortedFiles())
       .withPropertyName("devPubChecksumsStoreFiles")
       .withPathSensitivity(RELATIVE)
 
     outputs
-      .files(publicationStore.map { it.asFileTree.sortedElements() })
+      .dir(publicationStore)
       .withPropertyName("devPubPublicationStore")
 
     val currentProjectDir = layout.projectDirectory
@@ -200,6 +200,10 @@ constructor(
       }
     }
 
+    outputs.cacheIf("do not cache - this task only performs simple file modifications") { _ ->
+      false
+    }
+
     doFirst_("clear staging repo") {
       if (repoIsDevPub.get()) {
         // clear the staging repo so that we can only sync this publication's files in the doLast {} below

src/main/kotlin/internal/checksums/CreatePublicationChecksum.kt

@@ -14,23 +14,27 @@ internal abstract class CreatePublicationChecksum : ValueSource<String, CreatePu
   }
 
   override fun obtain(): String? {
+    val identifier = parameters.identifier.get()
+    val artifactsChecksums = artifactsChecksums()
+
+    return buildString {
+      appendLine(identifier)
+      appendLine("---")
+      artifactsChecksums.forEach {
+        appendLine(it)
+      }
+    }.trim()
+  }
+
+  private fun artifactsChecksums(): List<String> {
     val projectDir = parameters.projectDir.get().asFile
 
-    val checksum = parameters.artifacts
+    return parameters.artifacts
       .map { artifact ->
         val artifactPath = artifact.relativeTo(projectDir).invariantSeparatorsPath
         "${artifactPath}$FileChecksumSeparator${artifact.checksum()}"
       }
       .sorted()
-      .joinToString("\n")
-
-    val identifier = parameters.identifier.get()
-
-    return /* language=TEXT */ """
-      |$identifier
-      |---
-      |$checksum
-    """.trimMargin()
   }
 
   internal companion object {

src/main/kotlin/internal/checksums/LoadPublicationChecksum.kt

@@ -21,6 +21,7 @@ internal abstract class LoadPublicationChecksum : ValueSource<String, LoadPublic
       .resolve(checksumFilename)
       .takeIf(File::exists)
       ?.readText()
+      ?.trim()
   }
 
   internal companion object {

src/main/kotlin/internal/checksums/checksums.kt

@@ -5,19 +5,19 @@ import java.io.InputStream
 import java.io.OutputStream.nullOutputStream
 import java.security.DigestOutputStream
 import java.security.MessageDigest
-import java.util.*
+import kotlin.io.encoding.Base64
 
 internal fun File.checksum(): String =
   if (exists()) inputStream().checksum() else "missing"
 
 private fun InputStream.checksum(): String {
-  val messageDigester = MessageDigest.getInstance("SHA-256")
+  val md = MessageDigest.getInstance("SHA-256")
 
   buffered().use { input ->
-    DigestOutputStream(nullOutputStream(), messageDigester).use { digestStream ->
+    DigestOutputStream(nullOutputStream(), md).use { digestStream ->
       input.copyTo(digestStream)
     }
   }
 
-  return Base64.getEncoder().encodeToString(messageDigester.digest())
+  return Base64.encode(md.digest())
 }

src/main/kotlin/tasks/DevPublishTasksContainer.kt

@@ -40,6 +40,9 @@ class DevPublishTasksContainer(
         // provider property, so checking via the task name will have to do:
         project.tasks.matching { it.name == "publishAllPublicationsTo${DEV_PUB__MAVEN_REPO_NAME}Repository" }
       )
+
+      // always auto-refresh stored checksums
+      finalizedBy(generatePublicationChecksum)
     }
 
   private fun TaskContainer.registerGeneratePublicationChecksumTask(): TaskProvider<GeneratePublicationDataChecksumTask> =

src/main/kotlin/tasks/GeneratePublicationDataChecksumTask.kt

@@ -4,6 +4,7 @@ import dev.adamko.gradle.dev_publish.data.PublicationData
 import dev.adamko.gradle.dev_publish.internal.DevPublishInternalApi
 import dev.adamko.gradle.dev_publish.internal.checksums.CreatePublicationChecksum.Companion.createPublicationChecksum
 import dev.adamko.gradle.dev_publish.utils.info
+import java.io.File
 import javax.inject.Inject
 import org.gradle.api.NamedDomainObjectContainer
 import org.gradle.api.file.DirectoryProperty
@@ -40,7 +41,7 @@ constructor(
   abstract val tempDir: DirectoryProperty
 
   /** Used for prettier log messages. */
-  private val rootDir = project.rootDir
+  private val rootDir: File = project.rootDir
 
   @TaskAction
   @DevPublishInternalApi

src/main/kotlin/tasks/UpdateDevRepoTask.kt

@@ -2,12 +2,11 @@ package dev.adamko.gradle.dev_publish.tasks
 
 import dev.adamko.gradle.dev_publish.internal.DevPublishInternalApi
 import dev.adamko.gradle.dev_publish.utils.dropDirectory
-import dev.adamko.gradle.dev_publish.utils.sortedElements
+import dev.adamko.gradle.dev_publish.utils.sortedFiles
 import java.io.File
 import javax.inject.Inject
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.DirectoryProperty
-import org.gradle.api.file.FileSystemLocation
 import org.gradle.api.file.FileSystemOperations
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.*
@@ -40,8 +39,8 @@ constructor(
   @get:InputFiles
   @get:PathSensitive(RELATIVE)
   @DevPublishInternalApi
-  protected val publicationsStoreFiles: Provider<out Collection<FileSystemLocation>>
-    get() = publicationsStore.asFileTree.sortedElements()
+  protected val publicationsStoreFiles: Provider<out Set<File>>
+    get() = publicationsStore.sortedFiles()
 
   /**
    * Additional files to include in [devRepo].

src/main/kotlin/utils/gradleUtils.kt

@@ -1,14 +1,14 @@
 package dev.adamko.gradle.dev_publish.utils
 
+import java.io.File
 import org.gradle.api.Action
 import org.gradle.api.DefaultTask
 import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.artifacts.Configuration
 import org.gradle.api.attributes.Attribute
 import org.gradle.api.attributes.AttributeContainer
-import org.gradle.api.file.FileSystemLocation
-import org.gradle.api.file.FileTree
+import org.gradle.api.file.Directory
 import org.gradle.api.file.RelativePath
 import org.gradle.api.provider.Provider
 import org.gradle.kotlin.dsl.dependencies
@@ -116,19 +116,28 @@ internal fun RelativePath.dropDirectory(): RelativePath =
 
 
 /** Instantiate a new [Attribute] of type [T] */
-internal inline fun <reified T: Any> Attribute(name: String): Attribute<T> =
+internal inline fun <reified T : Any> Attribute(name: String): Attribute<T> =
   Attribute.of(name, T::class.java)
 
 
-internal operator fun <T: Any> AttributeContainer.get(key: Attribute<T>): T? =
+internal operator fun <T : Any> AttributeContainer.get(key: Attribute<T>): T? =
   getAttribute(key)
 
-
-/** Sorted [FileTree] elements. */
-// Sorting is important because FileTrees have unstable sorting, even on the same machine
-internal fun FileTree.sortedElements(): Provider<out Collection<FileSystemLocation>> =
-  elements.map { it.sortedBy(FileSystemLocation::getAsFile) }
-
+/**
+ * Get all files within the given directory, and in any subdirectories.
+ * All files are sorted alphabetically.
+ *
+ * This is useful for registering task inputs,
+ * since Gradle does not support input directories that do not yet exist.
+ */
+internal fun Provider<Directory>.sortedFiles(): Provider<out Set<File>> =
+  map { dir ->
+    dir.asFile
+      .walk()
+      .filter { it.isFile }
+      .sorted()
+      .toSet()
+  }
 
 /** Calls [DefaultTask.onlyIf], but smart-casts the task. */
 @Suppress("FunctionName")

src/test/kotlin/BuildCacheTest.kt

@@ -41,10 +41,9 @@ class BuildCacheTest : FunSpec({
         }
 
         val initialBuildCacheSize =
-          expectedBuildCacheDir.walk().filter { it.isRegularFile() }.map { it.fileSize() }.sum()
+          expectedBuildCacheDir.walk().filter { it.isRegularFile() }.sumOf { it.fileSize() }
 
         project.runner
-          //.forwardOutput()
           .withArguments(
             ":updateDevRepo",
             "--stacktrace",
@@ -75,7 +74,7 @@ class BuildCacheTest : FunSpec({
 
   companion object {
     private fun Path.recursiveFileSize(): Long =
-      walk().filter { it.isRegularFile() }.map { it.fileSize() }.sum()
+      walk().filter { it.isRegularFile() }.sumOf { it.fileSize() }
 
     private fun TestScope.project(): GradleProjectTest =
       gradleKtsProjectTest(
@@ -84,32 +83,32 @@ class BuildCacheTest : FunSpec({
       ) {
 
         buildGradleKts = """
-            plugins {
-              kotlin("jvm") version embeddedKotlinVersion
-              id("dev.adamko.dev-publish") version "+"
-              `maven-publish`
-            }
-            
-            group = "foo.project"
-            version = "0.0.1"
-            
-            publishing {
-              publications {
-                create<MavenPublication>("mavenJava") {
-                  from(components["java"])
-                }
-              }
-            }
-        """.trimIndent()
+          |plugins {
+          |  kotlin("jvm") version embeddedKotlinVersion
+          |  id("dev.adamko.dev-publish") version "+"
+          |  `maven-publish`
+          |}
+          |
+          |group = "foo.project"
+          |version = "0.0.1"
+          |
+          |publishing {
+          |  publications {
+          |    create<MavenPublication>("mavenJava") {
+          |      from(components["java"])
+          |    }
+          |  }
+          |}
+          |""".trimMargin()
 
         settingsGradleKts += """
-
-        buildCache {
-            local {
-                directory = file("local-cache").toURI()
-            }
-        }
-        """.trimIndent()
+          |  
+          |buildCache {
+          |    local {
+          |        directory = file("local-cache").toURI()
+          |    }
+          |}
+          |""".trimMargin()
 
         createKotlinFile(
           "src/main/kotlin/FooClass.kt", """