[git] IJPL-212686 Implement commit message cleanup for commit-tree

GitOrigin-RevId: 3caf0c1d9618d718658ee99fd792c21366f33bd7

Author: stanislaupalyn

plugins/git4idea/src/git4idea/config/GitConfigUtil.java

@@ -13,6 +13,7 @@
 import git4idea.commands.GitCommand;
 import git4idea.commands.GitCommandResult;
 import git4idea.commands.GitLineHandler;
+import git4idea.inMemory.GitCommitMessageFormatter;
 import git4idea.repo.GitProjectConfigurationCache;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
@@ -41,12 +42,15 @@ public final class GitConfigUtil {
   public static final @NlsSafe String CORE_SSH_COMMAND = "core.sshCommand";
   public static final @NlsSafe String CORE_COMMENT_CHAR = "core.commentChar";
   public static final @NlsSafe String LOG_OUTPUT_ENCODING = "i18n.logoutputencoding";
+  public static final @NlsSafe String COMMIT_CLEANUP = "commit.cleanup";
   public static final @NlsSafe String COMMIT_ENCODING = "i18n.commitencoding";
   public static final @NlsSafe String COMMIT_TEMPLATE = "commit.template";
   public static final @NlsSafe String GPG_PROGRAM = "gpg.program";
   public static final @NlsSafe String GPG_COMMIT_SIGN = "commit.gpgSign";
   public static final @NlsSafe String GPG_COMMIT_SIGN_KEY = "user.signingkey";
 
+  public static final String DEFAULT_COMMENT_CHAR = "#";
+
   private GitConfigUtil() {
   }
 
@@ -163,6 +167,25 @@ public static boolean isRebaseUpdateRefsEnabledCached(@NotNull Project project,
                                                  .readRepositoryConfig(root, UPDATE_REFS)));
   }
 
+  @RequiresBackgroundThread
+  public static @NotNull GitCommitMessageFormatter.CleanupMode getCommitMessageCleanupModeCached(@NotNull Project project,
+                                                                                                 @NotNull VirtualFile root) {
+    String mode = GitProjectConfigurationCache.getInstance(project).readRepositoryConfig(root, COMMIT_CLEANUP);
+    return GitCommitMessageFormatter.CleanupMode.parse(mode);
+  }
+
+  @RequiresBackgroundThread
+  public static @NotNull String getCommitMessageCommentCharCached(@NotNull Project project,
+                                                                  @NotNull VirtualFile root) {
+    String commentString = GitProjectConfigurationCache.getInstance(project).readRepositoryConfig(root, CORE_COMMENT_CHAR);
+    if (commentString == null) {
+      return DEFAULT_COMMENT_CHAR;
+    }
+    else {
+      return commentString;
+    }
+  }
+
   /**
    * Get log output encoding for the specified root, or UTF-8 if the encoding is note explicitly specified
    */

plugins/git4idea/src/git4idea/inMemory/GitCommitMessageFormatter.kt

@@ -0,0 +1,96 @@
+// Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+package git4idea.inMemory
+
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.vfs.VirtualFile
+import git4idea.config.GitConfigUtil
+
+/**
+ * Formatting of the message, according to the --cleanup=<mode>
+ * git commit-tree doesn't respect it, so we have to do it ourselves.
+ */
+object GitCommitMessageFormatter {
+  fun format(project: Project, root: VirtualFile, message: String): String {
+    val mode = GitConfigUtil.getCommitMessageCleanupModeCached(project, root)
+    if (mode == CleanupMode.NONE) return message
+
+    if (mode == CleanupMode.ALL) {
+      val commentChar = GitConfigUtil.getCommitMessageCommentCharCached(project, root)
+      return cleanupMessage(message, commentChar)
+    }
+    return cleanupMessage(message, null)
+  }
+
+  /**
+   * Skips every line that starts with [commentChar]
+   * Removes blank lines at the beginning and end of the message
+   * as well as trailing blanks from every line
+   * Multiple consecutive blank lines between non-empty lines are replaced with one blank line
+   * Adds newline at the end of the last line if needed
+   */
+  private fun cleanupMessage(message: String, commentChar: String?): String {
+    val lines = message.lines()
+
+    val startIndex = lines.indexOfFirst { it.isNotBlank() && !it.isCommentLine(commentChar) }
+    if (startIndex == -1) return ""
+
+    val endIndex = lines.indexOfLast { it.isNotBlank() && !it.isCommentLine(commentChar) }
+
+    val result = StringBuilder()
+    var previousLineEmpty = false
+    for (i in startIndex..endIndex) {
+      val line = lines[i].trimEnd()
+      if (line.isCommentLine(commentChar)) {
+        continue
+      }
+      if (line.isEmpty()) {
+        if (!previousLineEmpty) {
+          result.append('\n')
+        }
+        previousLineEmpty = true
+        continue
+      }
+      if (result.isNotEmpty()) {
+        result.append('\n')
+      }
+      result.append(line)
+      previousLineEmpty = false
+    }
+    result.append('\n')
+    return result.toString()
+  }
+
+  private fun String.isCommentLine(commentChar: String?): Boolean {
+    return commentChar != null && this.startsWith(commentChar)
+  }
+
+  enum class CleanupMode {
+    SPACE,
+    NONE,
+    @Suppress("unused")
+    SCISSORS, // Not used, as we don't open a commit message in the editor.'
+    ALL;
+
+    companion object {
+      @JvmStatic
+      fun parse(value: String?): CleanupMode =
+        parseOrNull(value) ?: throw IllegalArgumentException("Invalid commit message cleanup mode '$value'")
+
+      /**
+       * Returns the cleanup mode that corresponds to the argument,
+       * assuming the message is not open in the editor
+       */
+      private fun parseOrNull(value: String?): CleanupMode? {
+        if (value == null) return SPACE
+
+        return when (value) {
+          "default" -> SPACE
+          "verbatim" -> NONE
+          "strip" -> ALL
+          "scissors" -> SPACE // scissors behave as SPACE when a message is not open in the editor
+          else -> null
+        }
+      }
+    }
+  }
+}

plugins/git4idea/src/git4idea/inMemory/GitObjectRepository.kt

@@ -118,9 +118,12 @@ internal class GitObjectRepository(val repository: GitRepository) {
     author: GitObject.Commit.Author? = null,
   ): Oid {
     LOG.debug("Starting commitTree operation: treeOid=$treeOid, parents=${parentsOids}")
+    val project = repository.project
+    val root = repository.root
 
+    val formattedMessage = GitCommitMessageFormatter.format(project, root, message.toString(Charsets.UTF_8))
     val messageFile = try {
-      GitCheckinEnvironment.createCommitMessageFile(repository.project, repository.root, message.toString(Charsets.UTF_8))
+      GitCheckinEnvironment.createCommitMessageFile(project, root, formattedMessage)
     }
     catch (e: ProcessCanceledException) {
       throw e
@@ -130,7 +133,7 @@ internal class GitObjectRepository(val repository: GitRepository) {
       throw e
     }
 
-    val handler = GitLineHandler(repository.project, repository.root, GitCommand.COMMIT_TREE).apply {
+    val handler = GitLineHandler(project, root, GitCommand.COMMIT_TREE).apply {
       setSilent(true)
       parentsOids.forEach { addParameters("-p", it.hex()) }
       if (author != null) {
@@ -145,7 +148,7 @@ internal class GitObjectRepository(val repository: GitRepository) {
       addAbsoluteFile(messageFile)
       addParameters(treeOid.hex())
 
-      if (message.isEmpty()) { // in this case git will ignore -F and read message from stdin
+      if (formattedMessage.isEmpty()) { // in this case git will ignore -F and read message from stdin
         setInputProcessor(GitHandlerInputProcessorUtil.redirectStream(byteArrayOf().inputStream()))
       }
     }

plugins/git4idea/tests/git4idea/inMemory/GitObjectRepositoryTest.kt

@@ -7,6 +7,7 @@ import git4idea.config.GitConfigUtil
 import git4idea.inMemory.objects.GitObject
 import git4idea.inMemory.objects.Oid
 import git4idea.test.GitSingleRepoTest
+import git4idea.test.assertMessage
 import git4idea.test.gitAsBytes
 import git4idea.test.tac
 import kotlin.jvm.java
@@ -67,7 +68,7 @@ class GitObjectRepositoryTest : GitSingleRepoTest() {
 
     assertEquals("Commit should have correct tree OID", tree.oid, commit.treeOid)
     assertEquals("Commit should have correct author", SAMPLE_AUTHOR, commit.author)
-    assertEquals("Commit should have correct message", "Test commit message", commit.message.toString(Charsets.UTF_8))
+    assertMessage(commit.message.toString(Charsets.UTF_8), "Test commit message", "Commit should have correct message")
     assertEquals("Commit should have no parents", 0, commit.parentsOids.size)
   }
 
@@ -205,7 +206,7 @@ class GitObjectRepositoryTest : GitSingleRepoTest() {
     val commitOid = repository.commitTree(tree.oid, emptyList(), emptyMessage, SAMPLE_AUTHOR)
     val commit = repository.findCommit(commitOid)
 
-    assertEquals("Commit should have empty message", "", commit.message.toString(Charsets.UTF_8))
+    assertMessage(commit.message.toString(Charsets.UTF_8), "", "Commit should have empty message")
   }
 
   private fun createTreeEntries(blob: GitObject.Blob): Map<GitObject.Tree.FileName, GitObject.Tree.Entry> {

plugins/git4idea/tests/git4idea/inMemory/rebase/log/reword/GitInMemoryRewordOperationTest.kt

@@ -6,6 +6,8 @@ import git4idea.rebase.log.GitCommitEditingOperationResult
 import git4idea.test.assertLastMessage
 import git4idea.test.message
 import org.junit.jupiter.api.Assertions.assertNotEquals
+import git4idea.config.GitConfigUtil
+import git4idea.test.lastMessage
 
 internal class GitInMemoryRewordOperationTest : GitInMemoryOperationTest() {
   fun `test reword last commit`() {
@@ -32,7 +34,7 @@ internal class GitInMemoryRewordOperationTest : GitInMemoryOperationTest() {
     val commit = file("a").append("content").addCommit("Old message").details()
     file("b").create().addCommit("Latest commit")
 
-    val newMessage = "New message"
+    val newMessage = "New message\n"
 
     refresh()
     updateChangeListManager()
@@ -87,4 +89,75 @@ internal class GitInMemoryRewordOperationTest : GitInMemoryOperationTest() {
 
     assertLastMessage(newMessage)
   }
+
+  fun `test compare messages should add newline at the end`() {
+    val (inMemMessage, nativeMessage) = rewordInMemoryAndNativeAndGetMessages("Implement feature")
+
+    assertEquals(nativeMessage, inMemMessage)
+  }
+
+  fun `test compare messages with default cleanup and default comment char`() {
+    val (inMemMessage, nativeMessage) = rewordInMemoryAndNativeAndGetMessages(COMPLEX_MESSAGE)
+
+    assertEquals(nativeMessage, inMemMessage)
+  }
+
+  fun `test compare messages with verbatim cleanup`() {
+    GitConfigUtil.setValue(project, repo.root, GitConfigUtil.COMMIT_CLEANUP, "verbatim")
+
+    val (inMemMessage, nativeMessage) = rewordInMemoryAndNativeAndGetMessages(COMPLEX_MESSAGE)
+
+    assertEquals(nativeMessage, inMemMessage)
+  }
+
+  fun `test compare messages with strip cleanup and custom comment char`() {
+    GitConfigUtil.setValue(project, repo.root, GitConfigUtil.COMMIT_CLEANUP, "strip")
+    GitConfigUtil.setValue(project, repo.root, GitConfigUtil.CORE_COMMENT_CHAR, ";")
+
+    val (inMemMessage, nativeMessage) = rewordInMemoryAndNativeAndGetMessages(COMPLEX_MESSAGE)
+
+    assertEquals(nativeMessage, inMemMessage)
+  }
+
+  // IJPL-212686
+  private fun rewordInMemoryAndNativeAndGetMessages(message: String): Pair<String, String> {
+    file("a").create().addCommit("Add a")
+    val commit = file("a").append("new content").addCommit("Modify a").details()
+    refresh()
+    updateChangeListManager()
+
+    val inBranch = "in-memory"
+    val nativeBranch = "native"
+
+    git("checkout -B $inBranch")
+    GitInMemoryRewordOperation(objectRepo, commit, message).run() as GitCommitEditingOperationResult.Complete
+    val inMemMessage = lastMessage()
+
+    git("checkout master")
+
+    git("checkout -B $nativeBranch")
+    git("commit --amend -m '$message'")
+    val nativeMessage = lastMessage()
+
+    return inMemMessage to nativeMessage
+  }
+
+  private val COMPLEX_MESSAGE = """
+      
+      # This is a comment with default char
+      
+      Subject with trailing spaces    
+         
+      # Another default comment
+      ; Comment with different char
+          
+      Body line with trailing spaces       
+      
+      
+      
+      Another body line
+      
+      ; comment at the end
+      
+    """.trimIndent()
 }