Update GitCheckoutTask, so it re-runs if the repo is dirty (#3712)

Update GitCheckoutTask, so it re-runs if the repo is dirty

Currently, GitCheckoutTask might not re-run if the checked-out repository is dirty. This can cause invalid test results.
So, update GitCheckoutTask to re-run if the repo does not exist, is invalid, or contains any modifications.

- return a result with a more detailed message
- add more logging
- when checking if a repo is valid, use the `.git` directory
- set `parameters.expectedCommitId = commitId`

Author: adam-enko

build-logic/src/main/kotlin/dokkabuild/tasks/GitCheckoutTask.kt

@@ -13,11 +13,15 @@ import org.eclipse.jgit.util.FS
 import org.gradle.api.DefaultTask
 import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.file.FileSystemOperations
-import org.gradle.api.provider.Property
+import org.gradle.api.logging.Logger
+import org.gradle.api.logging.Logging
+import org.gradle.api.provider.*
 import org.gradle.api.tasks.CacheableTask
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.OutputDirectory
 import org.gradle.api.tasks.TaskAction
+import org.gradle.kotlin.dsl.assign
+import org.gradle.kotlin.dsl.of
 import java.io.File
 import javax.inject.Inject
 
@@ -26,7 +30,8 @@ import javax.inject.Inject
  */
 @CacheableTask
 abstract class GitCheckoutTask @Inject constructor(
-    private val fs: FileSystemOperations
+    private val fs: FileSystemOperations,
+    private val providers: ProviderFactory,
 ) : DefaultTask() {
 
     @get:OutputDirectory
@@ -40,16 +45,20 @@ abstract class GitCheckoutTask @Inject constructor(
     @get:Input
     abstract val commitId: Property<String>
 
+    init {
+        outputs.upToDateWhen { task ->
+            require(task is GitCheckoutTask)
+            val result = task.gitRepoStatus().get()
+            if (!result.isUpToDate) {
+                task.logger.lifecycle("[${task.path}] git repo ${task.localRepoDir} is not up to date. ${result.message}")
+            }
+            result.isUpToDate
+        }
+    }
+
     private val localRepoDir: File
         get() = temporaryDir.resolve("repo")
 
-    private val gitOperationsPrinter: ProgressMonitor =
-        if (logger.isInfoEnabled) {
-            TextProgressMonitor()
-        } else {
-            NullProgressMonitor.INSTANCE
-        }
-
     init {
         group = "git checkout"
     }
@@ -67,7 +76,7 @@ abstract class GitCheckoutTask @Inject constructor(
             exclude(".git/")
         }
 
-        logger.lifecycle("initialized git repo ${uri.get()} in ${destination.asFile.get()}")
+        logger.lifecycle("[$path] Initialized project ${uri.get()} in ${destination.asFile.get()}")
     }
 
     /**
@@ -82,17 +91,16 @@ abstract class GitCheckoutTask @Inject constructor(
         val commitId = commitId.get()
 
         // Check if the repo is already cloned. If yes, then we can re-use it to save time.
-        val gitRepoInitialized = RepositoryCache.FileKey.isGitRepository(localRepoDir, FS.DETECTED)
-
-        val repo = if (gitRepoInitialized) {
-            // re-use existing cloned repo
+        val repo = if (dirContainsGitRepo(localRepoDir)) {
+            logger.info("[$path] re-using existing cloned repo $localRepoDir")
             Git.open(localRepoDir)
         } else {
-            // repo is either not cloned or is not recognizable, so delete it and make a fresh clone
+            logger.info("[$path] repo $localRepoDir is either not cloned or is not recognizable")
+            // delete the invalid repo and make a fresh clone
             fs.delete { delete(localRepoDir) }
 
             Git.cloneRepository()
-                .setProgressMonitor(gitOperationsPrinter)
+                .setProgressMonitor(logger.asProgressMonitor())
                 .setNoCheckout(true)
                 .setURI(uri)
                 .setDirectory(localRepoDir)
@@ -102,14 +110,14 @@ abstract class GitCheckoutTask @Inject constructor(
         repo.use { git ->
             // checkout the specific commitId specified in the task input
             git.checkout()
-                .setProgressMonitor(gitOperationsPrinter)
+                .setProgressMonitor(logger.asProgressMonitor())
                 .setForced(true)
                 .setName(commitId)
                 .call()
 
             // git reset --hard (wipe changes to tracked files, if any)
             git.reset()
-                .setProgressMonitor(gitOperationsPrinter)
+                .setProgressMonitor(logger.asProgressMonitor())
                 .setMode(HARD)
                 .call()
 
@@ -121,4 +129,76 @@ abstract class GitCheckoutTask @Inject constructor(
                 .call()
         }
     }
+
+    private fun gitRepoStatus(): Provider<GitRepoStatusCheck.Result> =
+        providers.of(GitRepoStatusCheck::class) {
+            parameters.repoDir = localRepoDir
+            parameters.expectedCommitId = commitId
+        }
+
+    /**
+     * Determine if [repoDir][GitRepoStatusCheck.Params.repoDir] is a valid Git repo,
+     * and it does not contain any changes.
+     */
+    internal abstract class GitRepoStatusCheck : ValueSource<GitRepoStatusCheck.Result, GitRepoStatusCheck.Params> {
+
+        data class Result(
+            val isUpToDate: Boolean,
+            val message: String,
+        )
+
+        interface Params : ValueSourceParameters {
+            val repoDir: DirectoryProperty
+            val expectedCommitId: Property<String>
+        }
+
+        private val repoDir: File get() = parameters.repoDir.get().asFile
+        private val expectedCommitId: String get() = parameters.expectedCommitId.get()
+
+        private val logger = Logging.getLogger(GitRepoStatusCheck::class.java)
+
+        override fun obtain(): Result {
+            if (!dirContainsGitRepo(repoDir)) {
+                return Result(
+                    isUpToDate = false,
+                    message = "Repo is either not cloned or is not recognizable as a git repo."
+                )
+            }
+
+            // Open repository and get the current commit hash
+            Git.open(repoDir).use { git ->
+                val currentCommitId = git.repository.findRef("HEAD")?.objectId?.name()
+                if (currentCommitId != expectedCommitId) {
+                    return Result(
+                        isUpToDate = false,
+                        message = "Repo is not up-to-date. Expected commit-id $expectedCommitId, but was $currentCommitId."
+                    )
+                }
+
+                val status = git.status()
+                    .setProgressMonitor(logger.asProgressMonitor())
+                    .call()
+                if (!status.isClean) {
+                    return Result(
+                        isUpToDate = false,
+                        message = "Repo is not up-to-date. Found ${status.uncommittedChanges.size} uncommited, ${status.untracked.size} untracked changes."
+                    )
+                }
+                return Result(isUpToDate = true, message = "Repo is valid and up-to-date.")
+            }
+        }
+    }
+
+    companion object {
+
+        private fun dirContainsGitRepo(repoDir: File): Boolean =
+            RepositoryCache.FileKey.isGitRepository(repoDir.resolve(".git"), FS.DETECTED)
+
+        private fun Logger.asProgressMonitor(): ProgressMonitor =
+            if (isInfoEnabled) {
+                TextProgressMonitor()
+            } else {
+                NullProgressMonitor.INSTANCE
+            }
+    }
 }