Move amended commit detection to background executor

Avoid UI hangs in large repos

Author: timxx

qgitc/amendcommitmodel.py

@@ -15,6 +15,7 @@ class AmendCommitInfo:
     author: str
     date: str
     willAmend: bool = True  # Whether this commit will be amended
+    body: Optional[str] = None
 
 
 class AmendCommitListModel(QAbstractListModel):

qgitc/commitwindow.py

@@ -151,6 +151,14 @@ def __init__(self, submodule: str, files: List[str], error: str = None):
         self.error = error
 
 
+class AmendCommitDetectedEvent(QEvent):
+    Type = QEvent.User + 9
+
+    def __init__(self, commitInfo: AmendCommitInfo):
+        super().__init__(QEvent.Type(AmendCommitDetectedEvent.Type))
+        self.commitInfo = commitInfo
+
+
 class CommitWindow(StateWindow):
 
     def __init__(self, parent=None):
@@ -281,6 +289,10 @@ def __init__(self, parent=None):
 
         self.ui.btnCommit.clicked.connect(self._onCommitClicked)
 
+        self._amendDetectExecutor = SubmoduleExecutor(self)
+        self._amendDetectExecutor.finished.connect(self._onAmendDetectFinished)
+        self._amendDetectionResults: List[AmendCommitInfo] = []
+
         # no UI tasks
         self._submoduleExecutor = SubmoduleExecutor(self)
         self._submoduleExecutor.finished.connect(
@@ -888,6 +900,32 @@ def _onNonUITaskFinished(self):
         self.ui.spinnerUnstaged.stop()
         self._updateAmendCommitsIfNeeded()
 
+    def _onAmendDetectFinished(self):
+        """Called when amend commit detection completes"""
+        commits = self._amendDetectionResults
+        mainCommit = None
+        if commits:
+            for commit in commits:
+                if not commit.repoDir or commit.repoDir == ".":
+                    mainCommit = commit
+                    break
+            if not mainCommit:
+                mainCommit = commits[0]
+
+            ApplicationBase.instance().postEvent(
+                self, TemplateReadyEvent(mainCommit.body, True))
+
+        hasStagedFiles = self._stagedModel.rowCount() > 0
+        if not hasStagedFiles and commits:
+            commits = [c for c in commits if c.subject == mainCommit.subject]
+
+        # Determine if unchecking is allowed
+        allowUncheck = not hasStagedFiles and len(commits) > 1
+
+        # Update model with commits
+        self._amendCommitsModel.setAllowUncheck(allowUncheck)
+        self._amendCommitsModel.setCommits(commits)
+
     def _blockUI(self, blocked=True):
         self.ui.tbUnstage.setEnabled(not blocked)
         self.ui.tbUnstageAll.setEnabled(not blocked)
@@ -945,6 +983,10 @@ def event(self, evt: QEvent):
                 evt.ntpDateTime, evt.localDateTime)
             return True
 
+        if evt.type() == AmendCommitDetectedEvent.Type:
+            self._handleAmendCommitDetectedEvent(evt.commitInfo)
+            return True
+
         return super().event(evt)
 
     def _addBlock(self, key: str, title: str):
@@ -1014,6 +1056,11 @@ def _handleUpdateCommitProgress(self, submodule: str, out: str, error: str, upda
             # add title only
             self._updateBlockOutput(repoName, "", False, action)
 
+    def _handleAmendCommitDetectedEvent(self, commitInfo: AmendCommitInfo):
+        """Handle single commit detected from worker thread"""
+        if commitInfo:
+            self._amendDetectionResults.append(commitInfo)
+
     def reloadLocalChanges(self):
         self._statusFetcher.cancel()
         self.clear()
@@ -1639,6 +1686,7 @@ def _onCodeReviewClicked(self):
 
     def cancel(self, force=False):
         self._aiMessage.cancel(force)
+        self._amendDetectExecutor.cancel(force)
         self._submoduleExecutor.cancel(force)
         self._commitExecutor.cancel(force)
         self._statusFetcher.cancel(force)
@@ -2018,56 +2066,35 @@ def _onAmendToggled(self, checked: bool):
 
     def _detectAmendCommits(self):
         """Detect which commits will be amended based on staged files or HEAD"""
-        commits = []
+        # Cancel any running detection
+        if self._amendDetectExecutor.isRunning():
+            self._amendDetectExecutor.cancel()
 
         # Collect repos that have staged files
         submoduleFiles = self._collectModelFiles(self._stagedModel)
-        hasStagedFiles = bool(submoduleFiles)
+
+        # Clear previous results
+        self._amendDetectionResults.clear()
 
         if submoduleFiles:
             # If there are staged files, detect commits from those repos
-            for repoDir in submoduleFiles.keys():
-                fullPath = fullRepoDir(repoDir)
-                commitInfo = self._getCommitInfo("HEAD", fullPath, repoDir)
-                if commitInfo:
-                    commits.append(commitInfo)
+            repoDirs = list(submoduleFiles.keys())
         else:
-            # No staged files - detect from HEAD of main repo
-            mainCommitInfo = self._getCommitInfo("HEAD", Git.REPO_DIR, None)
-            if not mainCommitInfo:
-                return
-
-            commits.append(mainCommitInfo)
-            repoDirs = {mainCommitInfo.repoDir}
-
-            # Check submodules for commits with the same message
+            # No staged files - detect from HEAD of main repo + matching submodules
             app = ApplicationBase.instance()
-            if app.submodules:
-                for submodule in app.submodules:
-                    if not submodule or submodule == ".":
-                        continue
-                    if submodule in repoDirs:
-                        continue
-                    subRepoDir = fullRepoDir(submodule)
-                    subCommitInfo = self._getCommitInfo(
-                        "HEAD", subRepoDir, submodule)
-
-                    # Include if commit message matches
-                    if subCommitInfo and subCommitInfo.subject == mainCommitInfo.subject:
-                        repoDirs.add(subCommitInfo.repoDir)
-                        commits.append(subCommitInfo)
+            repoDirs = app.submodules
 
-        allowUncheck = not hasStagedFiles and len(commits) > 1
-        self._amendCommitsModel.setAllowUncheck(allowUncheck)
-        self._amendCommitsModel.setCommits(commits)
+        self._amendDetectExecutor.submit(repoDirs, self._doDetectAmendCommits)
 
-        # Get the last commit message (from the first repo) when allowed
-        if (commits and self._canUpdateMessage() and self._submoduleExecutor
-                and not self._submoduleExecutor.isRunning()):
-            self._blockUI()
-            self.ui.spinnerUnstaged.start()
-            self._submoduleExecutor.submit(
-                [commits[0].repoDir], self._doGetMessage)
+    def _doDetectAmendCommits(self, submodule: str, userData: any, cancelEvent: CancelEvent):
+        if cancelEvent.isSet():
+            return
+
+        fullPath = fullRepoDir(submodule)
+        commitInfo = self._getCommitInfo("HEAD", fullPath, submodule)
+        if commitInfo and not cancelEvent.isSet():
+            ApplicationBase.instance().postEvent(
+                self, AmendCommitDetectedEvent(commitInfo))
 
     def _normalizeRepoDirDisplay(self, repoDir: str):
         if not repoDir or repoDir == ".":
@@ -2076,14 +2103,15 @@ def _normalizeRepoDirDisplay(self, repoDir: str):
 
     def _getCommitInfo(self, sha1: str, repoDir: str, repoDirDisplay: str) -> AmendCommitInfo:
         """Get commit information for a specific commit"""
-        summary = Git.commitSummary(sha1, repoDir)
+        summary = Git.commitSummary(sha1, repoDir, includeFullMessage=True)
         if not summary:
             return None
 
         return AmendCommitInfo(
             repoDir=self._normalizeRepoDirDisplay(repoDirDisplay),
             sha1=summary["sha1"],
             subject=summary["subject"],
+            body=summary["body"],
             author=summary["author"],
             date=summary["date"],
             willAmend=True
@@ -2102,16 +2130,6 @@ def _canUpdateMessage(self):
 
         return False
 
-    def _doGetMessage(self, submodule: str, userData, cancelEvent: CancelEvent):
-        if cancelEvent.isSet():
-            return
-
-        repoDir = fullRepoDir(submodule)
-        message = Git.commitMessage("HEAD", repoDir)
-        if cancelEvent.isSet():
-            return
-        ApplicationBase.instance().postEvent(self, TemplateReadyEvent(message, True))
-
     def _onExternalDiff(self):
         ApplicationBase.instance().trackFeatureUsage("commit.external_diff")
         listView: QListView = self._acRestoreFiles.data()

qgitc/gitutils.py

@@ -284,8 +284,10 @@ def branches():
         return data.decode("utf-8").split('\n')
 
     @staticmethod
-    def commitSummary(sha1, repoDir=None):
+    def commitSummary(sha1, repoDir=None, includeFullMessage=False):
         fmt = "%h%x01%s%x01%ad%x01%an%x01%ae"
+        if includeFullMessage:
+            fmt += "%x01%B"
         args = ["show", "-s",
                 "--pretty=format:{0}".format(fmt),
                 "--date=short", sha1]
@@ -296,11 +298,15 @@ def commitSummary(sha1, repoDir=None):
 
         parts = data.decode("utf-8").split("\x01")
 
-        return {"sha1": parts[0],
-                "subject": parts[1],
-                "date": parts[2],
-                "author": parts[3],
-                "email": parts[4]}
+        summary = {"sha1": parts[0],
+                   "subject": parts[1],
+                   "date": parts[2],
+                   "author": parts[3],
+                   "email": parts[4]}
+        if includeFullMessage:
+            summary["body"] = parts[5].rstrip()
+
+        return summary
 
     @staticmethod
     def abbrevCommit(sha1):