src/eric7/Plugins/VcsPlugins/vcsGit/git.py

# -*- coding: utf-8 -*-

# Copyright (c) 2014 - 2023 Detlev Offenbach <detlev@die-offenbachs.de>
#

"""
Module implementing the version control systems interface to Git.
"""

import contextlib
import os
import pathlib
import re
import shutil
import sys

from PyQt6.QtCore import QProcess, pyqtSignal
from PyQt6.QtWidgets import QApplication, QDialog, QInputDialog, QLineEdit

from eric7 import Preferences, Utilities
from eric7.EricWidgets import EricFileDialog, EricMessageBox
from eric7.EricWidgets.EricApplication import ericApp
from eric7.QScintilla.MiniEditor import MiniEditor
from eric7.SystemUtilities import FileSystemUtilities, PythonUtilities
from eric7.VCS.RepositoryInfoDialog import VcsRepositoryInfoDialog
from eric7.VCS.VersionControl import VersionControl

from .GitDialog import GitDialog


class Git(VersionControl):
    """
    Class implementing the version control systems interface to Git.

    @signal committed() emitted after the commit action has completed
    """

    committed = pyqtSignal()

    IgnoreFileName = ".gitignore"

    def __init__(self, plugin, parent=None, name=None):
        """
        Constructor

        @param plugin reference to the plugin object
        @param parent parent widget (QWidget)
        @param name name of this object (string)
        """
        VersionControl.__init__(self, parent, name)
        self.defaultOptions = {
            "global": [""],
            "commit": [""],
            "checkout": [""],
            "update": [""],
            "add": [""],
            "remove": [""],
            "diff": [""],
            "log": [""],
            "history": [""],
            "status": [""],
            "tag": [""],
            "export": [""],
        }

        self.__plugin = plugin
        self.__ui = parent

        self.options = self.defaultOptions

        self.tagTypeList = [
            "tags",
            "branches",
        ]

        self.commandHistory = []

        self.adminDirOrFile = ".git"

        self.log = None
        self.logBrowser = None
        self.reflogBrowser = None
        self.diff = None
        self.sbsDiff = None
        self.tagbranchList = None
        self.status = None
        self.remotesDialog = None
        self.describeDialog = None
        self.blame = None
        self.stashBrowser = None
        self.repoEditor = None
        self.userEditor = None
        self.bisectlogBrowser = None
        self.bisectReplayEditor = None
        self.patchStatisticsDialog = None
        self.submoduleStatusDialog = None
        self.worktreeDialog = None

        self.__lastBundlePath = None
        self.__lastReplayPath = None

        self.statusCache = {}

        self.__commitData = {}
        self.__commitDialog = None

        self.__patchCheckData = None

        self.__projectHelper = None

    def getPlugin(self):
        """
        Public method to get a reference to the plugin object.

        @return reference to the plugin object (VcsGitPlugin)
        """
        return self.__plugin

    def vcsShutdown(self):
        """
        Public method used to shutdown the Git interface.
        """
        if self.log is not None:
            self.log.close()
        if self.logBrowser is not None:
            self.logBrowser.close()
        if self.reflogBrowser is not None:
            self.reflogBrowser.close()
        if self.diff is not None:
            self.diff.close()
        if self.sbsDiff is not None:
            self.sbsDiff.close()
        if self.tagbranchList is not None:
            self.tagbranchList.close()
        if self.status is not None:
            self.status.close()
        if self.remotesDialog is not None:
            self.remotesDialog.close()
        if self.describeDialog is not None:
            self.describeDialog.close()
        if self.blame is not None:
            self.blame.close()
        if self.stashBrowser is not None:
            self.stashBrowser.close()
        if self.bisectlogBrowser is not None:
            self.bisectlogBrowser.close()
        if self.bisectReplayEditor is not None:
            self.bisectReplayEditor.close()
        if self.repoEditor is not None:
            self.repoEditor.close()
        if self.userEditor is not None:
            self.userEditor.close()
        if self.patchStatisticsDialog is not None:
            self.patchStatisticsDialog.close()
        if self.submoduleStatusDialog is not None:
            self.submoduleStatusDialog.close()
        if self.worktreeDialog is not None:
            self.worktreeDialog.close()

        # shut down the project helpers
        if self.__projectHelper is not None:
            self.__projectHelper.shutdown()

    def initCommand(self, command):
        """
        Public method to initialize a command arguments list.

        @param command command name (string)
        @return list of command options (list of string)
        """
        args = [command]
        return args

    def vcsExists(self):
        """
        Public method used to test for the presence of the git executable.

        @return flag indicating the existance (boolean) and an error message
            (string)
        """
        self.versionStr = ""
        errMsg = ""
        ioEncoding = Preferences.getSystem("IOEncoding")

        args = self.initCommand("version")
        process = QProcess()
        process.start("git", args)
        procStarted = process.waitForStarted(5000)
        if procStarted:
            finished = process.waitForFinished(30000)
            if finished and process.exitCode() == 0:
                output = str(process.readAllStandardOutput(), ioEncoding, "replace")
                versionLine = output.splitlines()[0]
                v = list(
                    re.match(r".*?(\d+)\.(\d+)\.?(\d+)?\.?(\d+)?", versionLine).groups()
                )
                for i in range(4):
                    try:
                        v[i] = int(v[i])
                    except TypeError:
                        v[i] = 0
                    except IndexError:
                        v.append(0)
                self.version = tuple(v)
                self.versionStr = ".".join([str(v) for v in self.version])
                return True, errMsg
            else:
                if finished:
                    errMsg = self.tr(
                        "The git process finished with the exit code {0}"
                    ).format(process.exitCode())
                else:
                    errMsg = self.tr("The git process did not finish within 30s.")
        else:
            errMsg = self.tr("Could not start the git executable.")

        return False, errMsg

    def vcsInit(self, vcsDir, noDialog=False):  # noqa: U100
        """
        Public method used to initialize the Git repository.

        The initialization is done, when a project is converted into a
        Git controlled project. Therefore we always return TRUE without
        doing anything.

        @param vcsDir name of the VCS directory (string)
        @param noDialog flag indicating quiet operations (boolean)
        @return always TRUE
        """
        return True

    def vcsConvertProject(self, vcsDataDict, project, addAll=True):
        """
        Public method to convert an uncontrolled project to a version
        controlled project.

        @param vcsDataDict dictionary of data required for the conversion
        @type dict
        @param project reference to the project object
        @type Project
        @param addAll flag indicating to add all files to the repository
        @type bool
        """
        success = self.vcsImport(vcsDataDict, project.ppath, addAll=addAll)[0]
        if not success:
            EricMessageBox.critical(
                self.__ui,
                self.tr("Create project repository"),
                self.tr("""The project repository could not be created."""),
            )
        else:
            pfn = project.pfile
            if not os.path.isfile(pfn):
                pfn += "z"
            project.closeProject()
            project.openProject(pfn)

    def vcsImport(
        self, vcsDataDict, projectDir, noDialog=False, addAll=True  # noqa: U100
    ):
        """
        Public method used to import the project into the Git repository.

        @param vcsDataDict dictionary of data required for the import
        @type dict
        @param projectDir project directory (string)
        @type str
        @param noDialog flag indicating quiet operations
        @type bool
        @param addAll flag indicating to add all files to the repository
        @type bool
        @return tuple containing a flag indicating an execution without errors
            and a flag indicating the version controll status
        @rtype tuple of (bool, bool)
        """
        msg = vcsDataDict["message"]
        if not msg:
            msg = "***"

        args = self.initCommand("init")
        args.append(projectDir)
        dia = GitDialog(self.tr("Creating Git repository"), self)
        res = dia.startProcess(args)
        if res:
            dia.exec()
        status = dia.normalExit()

        if status:
            ignoreName = os.path.join(projectDir, Git.IgnoreFileName)
            if not os.path.exists(ignoreName):
                status = self.gitCreateIgnoreFile(projectDir)

            if status and addAll:
                args = self.initCommand("add")
                args.append("-v")
                args.append(".")
                dia = GitDialog(self.tr("Adding files to Git repository"), self)
                res = dia.startProcess(args, projectDir)
                if res:
                    dia.exec()
                status = dia.normalExit()

                if status:
                    args = self.initCommand("commit")
                    args.append("--message={0}".format(msg))
                    dia = GitDialog(self.tr("Initial commit to Git repository"), self)
                    res = dia.startProcess(args, projectDir)
                    if res:
                        dia.exec()
                    status = dia.normalExit()

        return status, False

    def vcsCheckout(self, vcsDataDict, projectDir, noDialog=False):
        """
        Public method used to check the project out of a Git repository
        (clone).

        @param vcsDataDict dictionary of data required for the checkout
        @param projectDir project directory to create (string)
        @param noDialog flag indicating quiet operations
        @return flag indicating an execution without errors (boolean)
        """
        noDialog = False
        vcsUrl = self.gitNormalizeURL(vcsDataDict["url"])

        args = self.initCommand("clone")
        args.append(vcsUrl)
        args.append(projectDir)

        if noDialog:
            return self.startSynchronizedProcess(QProcess(), "git", args)
        else:
            dia = GitDialog(self.tr("Cloning project from a Git repository"), self)
            res = dia.startProcess(args)
            if res:
                dia.exec()
            return dia.normalExit()

    def vcsExport(self, vcsDataDict, projectDir):
        """
        Public method used to export a directory from the Git repository.

        @param vcsDataDict dictionary of data required for the checkout
        @param projectDir project directory to create (string)
        @return flag indicating an execution without errors (boolean)
        """
        status = self.vcsCheckout(vcsDataDict, projectDir)
        adminPath = os.path.join(projectDir, self.adminDirOrFile)
        if os.path.isdir(adminPath):
            shutil.rmtree(adminPath, True)
        else:
            os.remove(adminPath)
        if os.path.exists(os.path.join(projectDir, Git.IgnoreFileName)):
            os.remove(os.path.join(projectDir, Git.IgnoreFileName))
        return status

    def vcsCommit(self, name, message="", noDialog=False, commitAll=True, amend=False):
        """
        Public method used to make the change of a file/directory permanent
        in the Git repository.

        @param name file/directory name to be committed (string or list of
            strings)
        @param message message for this operation (string)
        @param noDialog flag indicating quiet operations (boolean)
        @param commitAll flag indicating to commit all local changes (boolean)
        @param amend flag indicating to amend the HEAD commit (boolean)
        """
        from .GitCommitDialog import GitCommitDialog

        if not noDialog:
            # call CommitDialog and get message from there
            if self.__commitDialog is None:
                self.__commitDialog = GitCommitDialog(
                    self, message, amend, commitAll, self.__ui
                )
                self.__commitDialog.accepted.connect(self.__vcsCommit_Step2)
            self.__commitDialog.show()
            self.__commitDialog.raise_()
            self.__commitDialog.activateWindow()

        self.__commitData["name"] = name
        self.__commitData["msg"] = message
        self.__commitData["noDialog"] = noDialog
        self.__commitData["all"] = commitAll

        if noDialog:
            self.__vcsCommit_Step2()

    def __vcsCommit_Step2(self):
        """
        Private slot performing the second step of the commit action.
        """
        name = self.__commitData["name"]
        msg = self.__commitData["msg"]
        noDialog = self.__commitData["noDialog"]
        commitAll = self.__commitData["all"]

        if not noDialog:
            # check, if there are unsaved changes, that should be committed
            if isinstance(name, list):
                nameList = name
            else:
                nameList = [name]
            ok = True
            for nam in nameList:
                # check for commit of the project
                if os.path.isdir(nam):
                    project = ericApp().getObject("Project")
                    if nam == project.getProjectPath():
                        ok &= (
                            project.checkAllScriptsDirty(reportSyntaxErrors=True)
                            and project.checkDirty()
                        )
                        continue
                elif os.path.isfile(nam):
                    editor = ericApp().getObject("ViewManager").getOpenEditor(nam)
                    if editor:
                        ok &= editor.checkDirty()
                if not ok:
                    break

            if not ok:
                res = EricMessageBox.yesNo(
                    self.__ui,
                    self.tr("Commit Changes"),
                    self.tr(
                        """The commit affects files, that have unsaved"""
                        """ changes. Shall the commit be continued?"""
                    ),
                    icon=EricMessageBox.Warning,
                )
                if not res:
                    return

        if self.__commitDialog is not None:
            msg = self.__commitDialog.logMessage()
            amend = self.__commitDialog.amend()
            resetAuthor = self.__commitDialog.resetAuthor()
            commitAll = not self.__commitDialog.stagedOnly()
            self.__commitDialog.deleteLater()
            self.__commitDialog = None
        else:
            amend = False
            resetAuthor = False

        if not msg and not amend:
            msg = "***"

        args = self.initCommand("commit")
        if amend:
            args.append("--amend")
        if resetAuthor:
            args.append("--reset-author")
        if msg:
            args.append("--message")
            args.append(msg)

        if isinstance(name, list):
            dname, fnames = self.splitPathList(name)
        else:
            dname, fname = self.splitPath(name)

        # find the root of the repo
        repodir = self.findRepoRoot(dname)
        if not repodir:
            return

        if isinstance(name, list):
            args.append("--")
            self.addArguments(args, fnames)
        else:
            if dname != repodir or fname != ".":
                args.append("--")
                args.append(fname)
            else:
                if commitAll:
                    args.append("--all")

        if noDialog:
            self.startSynchronizedProcess(QProcess(), "git", args, dname)
        else:
            dia = GitDialog(self.tr("Committing changes to Git repository"), self)
            res = dia.startProcess(args, dname)
            if res:
                dia.exec()
        self.committed.emit()
        self.checkVCSStatus()

    def vcsCommitMessages(self):
        """
        Public method to get the list of saved commit messages.

        @return list of saved commit messages
        @rtype list of str
        """
        # try per project commit history first
        messages = self._vcsProjectCommitMessages()
        if not messages:
            # empty list returned, try the vcs specific one
            messages = self.getPlugin().getPreferences("Commits")

        return messages

    def vcsAddCommitMessage(self, message):
        """
        Public method to add a commit message to the list of saved messages.

        @param message message to be added
        @type str
        """
        if not self._vcsAddProjectCommitMessage(message):
            commitMessages = self.vcsCommitMessages()
            if message in commitMessages:
                commitMessages.remove(message)
            commitMessages.insert(0, message)
            no = Preferences.getVCS("CommitMessages")
            del commitMessages[no:]
            self.getPlugin().setPreferences("Commits", commitMessages)

    def vcsClearCommitMessages(self):
        """
        Public method to clear the list of saved messages.
        """
        if not self._vcsClearProjectCommitMessages():
            self.getPlugin().setPreferences("Commits", [])

    def vcsUpdate(self, name, noDialog=False, revision=None):
        """
        Public method used to update a file/directory with the Git
        repository.

        @param name file/directory name to be updated (string or list of
            strings)
        @param noDialog flag indicating quiet operations (boolean)
        @param revision revision to update to (string)
        @return flag indicating, that the update contained an add
            or delete (boolean)
        """
        args = self.initCommand("checkout")
        if revision:
            res = EricMessageBox.yesNo(
                None,
                self.tr("Switch"),
                self.tr(
                    """<p>Do you really want to switch to <b>{0}</b>?</p>"""
                ).format(revision),
                yesDefault=True,
            )
            if not res:
                return False
            args.append(revision)

        if isinstance(name, list):
            args.append("--")
            dname, fnames = self.splitPathList(name)
            self.addArguments(args, fnames)
        else:
            dname, fname = self.splitPath(name)
            if fname != ".":
                args.append("--")
                args.append(fname)

        # find the root of the repo
        repodir = self.findRepoRoot(dname)
        if not repodir:
            return False

        if noDialog:
            self.startSynchronizedProcess(QProcess(), "git", args, repodir)
            res = False
        else:
            dia = GitDialog(self.tr("Synchronizing with the Git repository"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()
                res = dia.hasAddOrDelete()
        self.checkVCSStatus()
        return res

    def vcsAdd(self, name, isDir=False, noDialog=False):
        """
        Public method used to add a file/directory to the Git repository.

        @param name file/directory name to be added (string)
        @param isDir flag indicating name is a directory (boolean)
        @param noDialog flag indicating quiet operations
        """
        args = self.initCommand("add")
        args.append("-v")

        if isinstance(name, list):
            if isDir:
                dname, fname = os.path.split(name[0])
            else:
                dname, fnames = self.splitPathList(name)
        else:
            if isDir:
                dname, fname = os.path.split(name)
            else:
                dname, fname = self.splitPath(name)

        # find the root of the repo
        repodir = self.findRepoRoot(dname)
        if not repodir:
            return

        if isinstance(name, list):
            self.addArguments(args, name)
        else:
            args.append(name)

        if noDialog:
            self.startSynchronizedProcess(QProcess(), "git", args, repodir)
        else:
            dia = GitDialog(
                self.tr("Adding files/directories to the Git repository"), self
            )
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()

    def vcsAddBinary(self, name, isDir=False):
        """
        Public method used to add a file/directory in binary mode to the
        Git repository.

        @param name file/directory name to be added (string)
        @param isDir flag indicating name is a directory (boolean)
        """
        self.vcsAdd(name, isDir)

    def vcsAddTree(self, path):
        """
        Public method to add a directory tree rooted at path to the Git
        repository.

        @param path root directory of the tree to be added (string or list of
            strings))
        """
        self.vcsAdd(path, isDir=False)

    def vcsRemove(
        self, name, project=False, noDialog=False, stageOnly=False  # noqa: U100
    ):
        """
        Public method used to remove a file/directory from the Git
        repository.

        The default operation is to remove the local copy as well.

        @param name file/directory name to be removed (string or list of
            strings))
        @param project flag indicating deletion of a project tree (boolean)
            (not needed)
        @param noDialog flag indicating quiet operations (boolean)
        @param stageOnly flag indicating to just remove the file from the
            staging area (boolean)
        @return flag indicating successful operation (boolean)
        """
        args = self.initCommand("rm")
        if noDialog and "--force" not in args:
            args.append("--force")
        if stageOnly:
            args.append("--cached")

        if isinstance(name, list):
            if os.path.isdir(name[0]):
                args.append("-r")
            dname, fnames = self.splitPathList(name)
            args.append("--")
            self.addArguments(args, name)
        else:
            if os.path.isdir(name):
                args.append("-r")
            dname, fname = self.splitPath(name)
            args.append("--")
            args.append(name)

        # find the root of the repo
        repodir = self.findRepoRoot(dname)
        if not repodir:
            return False

        if noDialog:
            res = self.startSynchronizedProcess(QProcess(), "git", args, repodir)
        else:
            dia = GitDialog(
                self.tr("Removing files/directories from the Git repository"), self
            )
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()
                res = dia.normalExitWithoutErrors()

        return res

    def vcsForget(self, name):
        """
        Public method used to remove a file from the Mercurial repository.

        This will not remove the file from the project directory.

        @param name file/directory name to be removed
        @type str or list of str
        """
        self.vcsRemove(name, stageOnly=True)

    def vcsMove(self, name, project, target=None, noDialog=False):
        """
        Public method used to move a file/directory.

        @param name file/directory name to be moved (string)
        @param project reference to the project object
        @param target new name of the file/directory (string)
        @param noDialog flag indicating quiet operations
        @return flag indicating successful operation (boolean)
        """
        from .GitCopyDialog import GitCopyDialog

        isDir = os.path.isdir(name)

        res = False
        if noDialog:
            if target is None:
                return False
            force = True
            accepted = True
        else:
            dlg = GitCopyDialog(name, None, True)
            accepted = dlg.exec() == QDialog.DialogCode.Accepted
            if accepted:
                target, force = dlg.getData()

        if accepted:
            args = self.initCommand("mv")
            args.append("-v")
            if force:
                args.append("--force")
            args.append(name)
            args.append(target)

            dname, fname = self.splitPath(name)
            # find the root of the repo
            repodir = self.findRepoRoot(dname)
            if not repodir:
                return False

            if noDialog:
                res = self.startSynchronizedProcess(QProcess(), "git", args, repodir)
            else:
                dia = GitDialog(self.tr("Renaming {0}").format(name), self)
                res = dia.startProcess(args, repodir)
                if res:
                    dia.exec()
                    res = dia.normalExit()
            if res:
                if target.startswith(project.getProjectPath()):
                    if isDir:
                        project.moveDirectory(name, target)
                    else:
                        project.renameFileInPdata(name, target)
                else:
                    if isDir:
                        project.removeDirectory(name)
                    else:
                        project.removeFile(name)
        return res

    def vcsLogBrowser(self, name, isFile=False):
        """
        Public method used to browse the log of a file/directory from the
        Git repository.

        @param name file/directory name to show the log of (string)
        @param isFile flag indicating log for a file is to be shown
            (boolean)
        """
        from .GitLogBrowserDialog import GitLogBrowserDialog

        if self.logBrowser is None:
            self.logBrowser = GitLogBrowserDialog(self)
        self.logBrowser.show()
        self.logBrowser.raise_()
        self.logBrowser.start(name, isFile=isFile)

    def gitReflogBrowser(self, projectDir):
        """
        Public method used to browse the reflog of the project.

        @param projectDir name of the project directory (string)
        """
        from .GitReflogBrowserDialog import GitReflogBrowserDialog

        if self.reflogBrowser is None:
            self.reflogBrowser = GitReflogBrowserDialog(self)
        self.reflogBrowser.show()
        self.reflogBrowser.raise_()
        self.reflogBrowser.start(projectDir)

    def vcsDiff(self, name):
        """
        Public method used to view the difference of a file/directory to the
        Git repository.

        If name is a directory and is the project directory, all project files
        are saved first. If name is a file (or list of files), which is/are
        being edited and has unsaved modification, they can be saved or the
        operation may be aborted.

        @param name file/directory name to be diffed (string)
        """
        from .GitDiffDialog import GitDiffDialog

        names = name[:] if isinstance(name, list) else [name]
        for nam in names:
            if os.path.isfile(nam):
                editor = ericApp().getObject("ViewManager").getOpenEditor(nam)
                if editor and not editor.checkDirty():
                    return
            else:
                project = ericApp().getObject("Project")
                if nam == project.ppath and not project.saveAllScripts():
                    return
        if self.diff is None:
            self.diff = GitDiffDialog(self)
        self.diff.show()
        self.diff.raise_()
        QApplication.processEvents()
        self.diff.start(name, diffMode="work2stage2repo", refreshable=True)

    def vcsStatus(self, name):
        """
        Public method used to view the status of files/directories in the
        Git repository.

        @param name file/directory name(s) to show the status of
            (string or list of strings)
        """
        from .GitStatusDialog import GitStatusDialog

        if self.status is None:
            self.status = GitStatusDialog(self)
        self.status.show()
        self.status.raise_()
        self.status.start(name)

    def gitUnstage(self, name):
        """
        Public method used to unstage a file/directory.

        @param name file/directory name to be reverted (string)
        @return flag indicating, that the update contained an add
            or delete (boolean)
        """
        if isinstance(name, list):
            dname, fnames = self.splitPathList(name)
        else:
            dname, fname = self.splitPath(name)

        # find the root of the repo
        repodir = self.findRepoRoot(dname)
        if not repodir:
            return False

        args = self.initCommand("reset")
        args.append("HEAD")
        args.append("--")
        if isinstance(name, list):
            self.addArguments(args, name)
        else:
            args.append(name)

        dia = GitDialog(self.tr("Unstage files/directories"), self)
        res = dia.startProcess(args, repodir)
        if res:
            dia.exec()
            res = dia.hasAddOrDelete()
        self.checkVCSStatus()

        return res

    def vcsRevert(self, name):
        """
        Public method used to revert changes made to a file/directory.

        @param name file/directory name to be reverted
        @type str
        @return flag indicating, that the update contained an add
            or delete
        @rtype bool
        """
        from eric7.UI.DeleteFilesConfirmationDialog import DeleteFilesConfirmationDialog

        args = self.initCommand("checkout")
        args.append("--")
        if isinstance(name, list):
            dname, fnames = self.splitPathList(name)
            self.addArguments(args, name)
            names = name[:]
        else:
            dname, fname = self.splitPath(name)
            args.append(name)
            names = [name]

        # find the root of the repo
        repodir = self.findRepoRoot(dname)
        if not repodir:
            return False

        project = ericApp().getObject("Project")
        names = [project.getRelativePath(nam) for nam in names]
        if names[0]:
            dlg = DeleteFilesConfirmationDialog(
                self.parent(),
                self.tr("Revert changes"),
                self.tr(
                    "Do you really want to revert all changes to these files"
                    " or directories?"
                ),
                names,
            )
            yes = dlg.exec() == QDialog.DialogCode.Accepted
        else:
            yes = EricMessageBox.yesNo(
                None,
                self.tr("Revert changes"),
                self.tr(
                    """Do you really want to revert all changes of"""
                    """ the project?"""
                ),
            )
        if yes:
            dia = GitDialog(self.tr("Reverting changes"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()
                res = dia.hasAddOrDelete()
            self.checkVCSStatus()
        else:
            res = False

        return res

    def vcsMerge(self, name):
        """
        Public method used to merge a URL/revision into the local project.

        @param name file/directory name to be merged (string)
        """
        from .GitMergeDialog import GitMergeDialog

        dname, fname = self.splitPath(name)

        # find the root of the repo
        repodir = self.findRepoRoot(dname)
        if not repodir:
            return

        dlg = GitMergeDialog(
            self.gitGetTagsList(repodir),
            self.gitGetBranchesList(repodir),
            self.gitGetCurrentBranch(repodir),
            self.gitGetBranchesList(repodir, remotes=True),
        )
        if dlg.exec() == QDialog.DialogCode.Accepted:
            commit, doCommit, commitMessage, addLog, diffStat = dlg.getParameters()
            args = self.initCommand("merge")
            if doCommit:
                args.append("--commit")
                args.append("-m")
                args.append(commitMessage)
                if addLog:
                    args.append("--log")
                else:
                    args.append("--no-log")
            else:
                args.append("--no-commit")
            if diffStat:
                args.append("--stat")
            else:
                args.append("--no-stat")
            if commit:
                args.append(commit)

            dia = GitDialog(self.tr("Merging").format(name), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()
            self.checkVCSStatus()

    def vcsSwitch(self, name):
        """
        Public method used to switch a working directory to a different
        revision.

        @param name directory name to be switched (string)
        @return flag indicating, that the switch contained an add
            or delete (boolean)
        """
        from .GitRevisionSelectionDialog import GitRevisionSelectionDialog

        dname, fname = self.splitPath(name)

        # find the root of the repo
        repodir = self.findRepoRoot(dname)
        if not repodir:
            return False

        dlg = GitRevisionSelectionDialog(
            self.gitGetTagsList(repodir),
            self.gitGetBranchesList(repodir),
            trackingBranchesList=self.gitGetBranchesList(repodir, remotes=True),
            noneLabel=self.tr("Main branch head"),
        )
        if dlg.exec() == QDialog.DialogCode.Accepted:
            rev = dlg.getRevision()
            return self.vcsUpdate(name, revision=rev)

        return False

    def vcsRegisteredState(self, name):
        """
        Public method used to get the registered state of a file in the vcs.

        @param name filename to check (string)
        @return a combination of canBeCommited and canBeAdded
        """
        if name.endswith(os.sep):
            name = name[:-1]
        name = os.path.normcase(name)
        dname, fname = self.splitPath(name)

        if fname == "." and os.path.exists(os.path.join(dname, self.adminDirOrFile)):
            return self.canBeCommitted

        if name in self.statusCache:
            return self.statusCache[name]

        # find the root of the repo
        repodir = self.findRepoRoot(dname)
        if not repodir:
            return 0

        args = self.initCommand("status")
        args.append("--porcelain")
        args.append(name)

        ioEncoding = Preferences.getSystem("IOEncoding")
        output = ""
        process = QProcess()
        process.setWorkingDirectory(repodir)
        process.start("git", args)
        procStarted = process.waitForStarted(5000)
        if procStarted:
            finished = process.waitForFinished(30000)
            if finished and process.exitCode() == 0:
                output = str(process.readAllStandardOutput(), ioEncoding, "replace")

        if output:
            for line in output.splitlines():
                if line and line[0] in " MADRCU!?":
                    flag = line[1]
                    path = line[3:].split(" -> ")[-1]
                    absname = os.path.join(repodir, os.path.normcase(path))
                    if absname.endswith(("/", "\\")):
                        absname = absname[:-1]
                    if flag not in "?!":
                        if fname == ".":
                            if absname.startswith(dname + os.path.sep):
                                return self.canBeCommitted
                            if absname == dname:
                                return self.canBeCommitted
                        else:
                            if absname == name:
                                return self.canBeCommitted
        else:
            return self.canBeCommitted

        return self.canBeAdded

    def vcsAllRegisteredStates(self, names, dname, shortcut=True):  # noqa: U100
        """
        Public method used to get the registered states of a number of files
        in the vcs.

        <b>Note:</b> If a shortcut is to be taken, the code will only check,
        if the named directory has been scanned already. If so, it is assumed,
        that the states for all files have been populated by the previous run.

        @param names dictionary with all filenames to be checked as keys
        @param dname directory to check in (string)
        @param shortcut flag indicating a shortcut should be taken (boolean)
        @return the received dictionary completed with a combination of
            canBeCommited and canBeAdded or None in order to signal an error
        """
        if dname.endswith(os.sep):
            dname = dname[:-1]
        dname = os.path.normcase(dname)

        # revert the logic because git status doesn't show unchanged files
        for name in names:
            names[name] = self.canBeCommitted

        found = False
        for name in self.statusCache:
            if name in names:
                found = True
                names[name] = self.statusCache[name]

        if not found:
            # find the root of the repo
            repodir = self.findRepoRoot(dname)
            if not repodir:
                return names

            args = self.initCommand("status")
            args.append("--porcelain")

            ioEncoding = Preferences.getSystem("IOEncoding")
            output = ""
            process = QProcess()
            process.setWorkingDirectory(dname)
            process.start("git", args)
            procStarted = process.waitForStarted(5000)
            if procStarted:
                finished = process.waitForFinished(30000)
                if finished and process.exitCode() == 0:
                    output = str(process.readAllStandardOutput(), ioEncoding, "replace")

            if output:
                for line in output.splitlines():
                    if line and line[0] in " MADRCU!?":
                        flag = line[1]
                        path = line[3:].split(" -> ")[-1]
                        name = os.path.normcase(os.path.join(repodir, path))
                        dirName = os.path.dirname(name)
                        if name.startswith(dname) and flag in "?!":
                            isDir = name.endswith(("/", "\\"))
                            if isDir:
                                name = name[:-1]
                            if name in names:
                                names[name] = self.canBeAdded
                            if isDir:
                                # it's a directory
                                for nname in names:
                                    if nname.startswith(name):
                                        names[nname] = self.canBeAdded
                        if flag not in "?!":
                            self.statusCache[name] = self.canBeCommitted
                            self.statusCache[dirName] = self.canBeCommitted
                        else:
                            self.statusCache[name] = self.canBeAdded
                            if dirName not in self.statusCache:
                                self.statusCache[dirName] = self.canBeAdded

        return names

    def clearStatusCache(self):
        """
        Public method to clear the status cache.
        """
        self.statusCache = {}

    def vcsName(self):
        """
        Public method returning the name of the vcs.

        @return always 'Git' (string)
        """
        return "Git"

    def vcsInitConfig(self, project):
        """
        Public method to initialize the VCS configuration.

        This method ensures, that an ignore file exists.

        @param project reference to the project (Project)
        """
        ppath = project.getProjectPath()
        if ppath:
            ignoreName = os.path.join(ppath, Git.IgnoreFileName)
            if not os.path.exists(ignoreName):
                self.gitCreateIgnoreFile(project.getProjectPath(), autoAdd=True)

    def vcsCleanup(self, name):
        """
        Public method used to cleanup the working directory.

        @param name directory name to be cleaned up (string)
        """
        patterns = self.__plugin.getPreferences("CleanupPatterns").split()

        entries = []
        for pat in patterns:
            entries.extend(FileSystemUtilities.direntries(name, True, pat))

        for entry in entries:
            with contextlib.suppress(OSError):
                os.remove(entry)

    def vcsCommandLine(self, name):
        """
        Public method used to execute arbitrary Git commands.

        @param name directory name of the working directory (string)
        """
        from .GitCommandDialog import GitCommandDialog

        dlg = GitCommandDialog(self.commandHistory, name)
        if dlg.exec() == QDialog.DialogCode.Accepted:
            command = dlg.getData()
            commandList = Utilities.parseOptionString(command)

            # This moves any previous occurrence of these arguments to the head
            # of the list.
            if command in self.commandHistory:
                self.commandHistory.remove(command)
            self.commandHistory.insert(0, command)

            args = []
            self.addArguments(args, commandList)

            # find the root of the repo
            repodir = self.findRepoRoot(name)
            if not repodir:
                return

            dia = GitDialog(self.tr("Git Command"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()

    def vcsOptionsDialog(
        self, project, archive, editable=False, parent=None  # noqa: U100
    ):
        """
        Public method to get a dialog to enter repository info.

        @param project reference to the project object
        @param archive name of the project in the repository (string)
        @param editable flag indicating that the project name is editable
            (boolean)
        @param parent parent widget (QWidget)
        @return reference to the instantiated options dialog (GitOptionsDialog)
        """
        from .GitOptionsDialog import GitOptionsDialog

        return GitOptionsDialog(self, project, parent)

    def vcsNewProjectOptionsDialog(self, parent=None):
        """
        Public method to get a dialog to enter repository info for getting a
        new project.

        @param parent parent widget (QWidget)
        @return reference to the instantiated options dialog
            (GitNewProjectOptionsDialog)
        """
        from .GitNewProjectOptionsDialog import GitNewProjectOptionsDialog

        return GitNewProjectOptionsDialog(self, parent)

    def vcsRepositoryInfos(self, ppath):
        """
        Public method to retrieve information about the repository.

        @param ppath local path to get the repository infos (string)
        @return string with ready formated info for display (string)
        """
        formatTemplate = (
            "format:"
            "%h%n"
            "%p%n"
            "%an%n"
            "%ae%n"
            "%ai%n"
            "%cn%n"
            "%ce%n"
            "%ci%n"
            "%d%n"
            "%s"
        )

        args = self.initCommand("show")
        args.append("--abbrev-commit")
        args.append(
            "--abbrev={0}".format(self.__plugin.getPreferences("CommitIdLength"))
        )
        args.append("--format={0}".format(formatTemplate))
        args.append("--no-patch")
        args.append("HEAD")

        output = ""
        process = QProcess()
        process.setWorkingDirectory(ppath)
        process.start("git", args)
        procStarted = process.waitForStarted(5000)
        if procStarted:
            finished = process.waitForFinished(30000)
            if finished and process.exitCode() == 0:
                output = str(
                    process.readAllStandardOutput(),
                    Preferences.getSystem("IOEncoding"),
                    "replace",
                )

        if output:
            info = []
            (
                commit,
                parents,
                author,
                authorMail,
                authorDate,
                committer,
                committerMail,
                committerDate,
                refs,
                subject,
            ) = output.splitlines()
            tags = []
            branches = []
            for name in refs.strip()[1:-1].split(","):
                name = name.strip()
                if name:
                    if name.startswith("tag: "):
                        tags.append(name.split()[1])
                    elif name != "HEAD":
                        branches.append(name)

            info.append(
                self.tr("<tr><td><b>Commit</b></td><td>{0}</td></tr>").format(commit)
            )
            if parents:
                info.append(
                    self.tr("<tr><td><b>Parents</b></td><td>{0}</td></tr>").format(
                        "<br/>".join(parents.strip().split())
                    )
                )
            if tags:
                info.append(
                    self.tr("<tr><td><b>Tags</b></td><td>{0}</td></tr>").format(
                        "<br/>".join(tags)
                    )
                )
            if branches:
                info.append(
                    self.tr("<tr><td><b>Branches</b></td><td>{0}</td></tr>").format(
                        "<br/>".join(branches)
                    )
                )
            info.append(
                self.tr(
                    "<tr><td><b>Author</b></td><td>{0} &lt;{1}&gt;</td></tr>"
                ).format(author, authorMail)
            )
            info.append(
                self.tr("<tr><td><b>Date</b></td><td>{0}</td></tr>").format(
                    authorDate.rsplit(":", 1)[0]
                )
            )
            info.append(
                self.tr(
                    "<tr><td><b>Committer</b></td><td>{0} &lt;{1}&gt;</td></tr>"
                ).format(committer, committerMail)
            )
            info.append(
                self.tr("<tr><td><b>Committed Date</b></td><td>{0}</td></tr>").format(
                    committerDate.rsplit(":", 1)[0]
                )
            )
            info.append(
                self.tr("<tr><td><b>Subject</b></td><td>{0}</td></tr>").format(subject)
            )
            infoStr = "\n".join(info)
        else:
            infoStr = ""

        return self.tr(
            """<h3>Repository information</h3>\n"""
            """<p><table>\n"""
            """<tr><td><b>Git V.</b></td><td>{0}</td></tr>\n"""
            """<tr></tr>\n"""
            """{1}"""
            """</table></p>\n"""
        ).format(self.versionStr, infoStr)

    def vcsSupportCommandOptions(self):
        """
        Public method to signal the support of user settable command options.

        @return flag indicating the support  of user settable command options
            (boolean)
        """
        return False

    ###########################################################################
    ## Git specific methods are below.
    ###########################################################################

    def gitNormalizeURL(self, url):
        """
        Public method to normalize a url for Git.

        @param url url string (string)
        @return properly normalized url for git (string)
        """
        url = url.replace("\\", "/")
        if url.endswith("/"):
            url = url[:-1]
        urll = url.split("//")
        if len(urll) > 1:
            url = "{0}//{1}".format(urll[0], "/".join(urll[1:]))

        return url

    def gitCreateIgnoreFile(self, name, autoAdd=False):
        """
        Public method to create the ignore file.

        @param name directory name to create the ignore file in (string)
        @param autoAdd flag indicating to add it automatically (boolean)
        @return flag indicating success
        """
        status = False
        ignorePatterns = [
            ".eric6project/",
            ".eric7project/",
            ".ropeproject/",
            ".jedi/",
            ".directory/",
            "*.pyc",
            "*.pyo",
            "*.orig",
            "*.bak",
            "*.rej",
            "*~",
            "cur/",
            "tmp/",
            "__pycache__/",
            "__pypackages__",
            "*.DS_Store",
            ".pytest_cache/",
            "venv/",
            ".venv/",
            "env/",
            ".env/",
        ]

        ignoreName = os.path.join(name, Git.IgnoreFileName)
        res = (
            EricMessageBox.yesNo(
                self.__ui,
                self.tr("Create {0} file").format(ignoreName),
                self.tr(
                    """<p>The file <b>{0}</b> exists already."""
                    """ Overwrite it?</p>"""
                ).format(ignoreName),
                icon=EricMessageBox.Warning,
            )
            if os.path.exists(ignoreName)
            else True
        )
        if res:
            try:
                # create a .gitignore file
                with open(ignoreName, "w") as ignore:
                    ignore.write("\n".join(ignorePatterns))
                    ignore.write("\n")
                status = True
            except OSError:
                status = False

            if status and autoAdd:
                self.vcsAdd(ignoreName, noDialog=True)
                project = ericApp().getObject("Project")
                project.appendFile(ignoreName)

        return status

    def gitCopy(self, name, project):
        """
        Public method used to copy a file/directory.

        @param name file/directory name to be copied (string)
        @param project reference to the project object
        @return flag indicating successful operation (boolean)
        """
        from .GitCopyDialog import GitCopyDialog

        dlg = GitCopyDialog(name)
        if dlg.exec() == QDialog.DialogCode.Accepted:
            target, force = dlg.getData()

            # step 1: copy the file/directory:
            if os.path.isdir(name):
                try:
                    shutil.copytree(name, target)
                except (OSError, shutil.Error) as why:
                    EricMessageBox.critical(
                        self,
                        self.tr("Git Copy"),
                        self.tr(
                            """<p>Copying the directory <b>{0}</b>"""
                            """ failed.</p><p>Reason: {1}</p>"""
                        ).format(name, str(why)),
                    )
                    return False
                self.vcsAdd(target, isDir=True)
                if target.startswith(project.getProjectPath()):
                    project.copyDirectory(name, target)

            else:
                try:
                    shutil.copy2(name, target)
                except (OSError, shutil.Error) as why:
                    EricMessageBox.critical(
                        self,
                        self.tr("Git Copy"),
                        self.tr(
                            """<p>Copying the file <b>{0}</b>"""
                            """ failed.</p><p>Reason: {1}</p>"""
                        ).format(name, str(why)),
                    )
                    return False
                self.vcsAdd(target, isDir=False)
                if target.startswith(project.getProjectPath()):
                    project.appendFile(target)
            self.checkVCSStatus()
        return True

    def gitBlame(self, name, skiplist=""):
        """
        Public method to show the output of the git blame command.

        @param name file name to show the annotations for
        @type str
        @param skiplist name of a skip list file
        @type str
        """
        from .GitBlameDialog import GitBlameDialog

        if self.blame is None:
            self.blame = GitBlameDialog(self)
        self.blame.show()
        self.blame.raise_()
        self.blame.start(name, skiplist=skiplist)

    def gitExtendedDiff(self, name):
        """
        Public method used to view the difference of a file/directory to the
        Git repository.

        If name is a directory and is the project directory, all project files
        are saved first. If name is a file (or list of files), which is/are
        being edited and has unsaved modification, they can be saved or the
        operation may be aborted.

        This method gives the chance to enter the revisions to be compared.

        @param name file/directory name to be diffed (string)
        """
        from .GitDiffDialog import GitDiffDialog
        from .GitRevisionsSelectionDialog import GitRevisionsSelectionDialog

        if isinstance(name, list):
            dname, fnames = self.splitPathList(name)
            names = name[:]
        else:
            dname, fname = self.splitPath(name)
            names = [name]
        for nam in names:
            if os.path.isfile(nam):
                editor = ericApp().getObject("ViewManager").getOpenEditor(nam)
                if editor and not editor.checkDirty():
                    return
            else:
                project = ericApp().getObject("Project")
                if nam == project.ppath and not project.saveAllScripts():
                    return

        # find the root of the repo
        repodir = self.findRepoRoot(dname)
        if not repodir:
            return

        dlg = GitRevisionsSelectionDialog(
            self.gitGetTagsList(repodir), self.gitGetBranchesList(repodir)
        )
        if dlg.exec() == QDialog.DialogCode.Accepted:
            revisions = dlg.getRevisions()
            if self.diff is None:
                self.diff = GitDiffDialog(self)
            self.diff.show()
            self.diff.raise_()
            self.diff.start(name, revisions)

    def __gitGetFileForRevision(self, name, rev=""):
        """
        Private method to get a file for a specific revision from the
        repository.

        @param name file name to get from the repository (string)
        @param rev revision to retrieve (string)
        @return contents of the file (string) and an error message (string)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(self.splitPath(name)[0])
        if not repodir:
            return False

        args = self.initCommand("cat-file")
        args.append("blob")
        args.append("{0}:{1}".format(rev, name.replace(repodir + os.sep, "")))

        output = ""
        error = ""

        process = QProcess()
        process.setWorkingDirectory(repodir)
        process.start("git", args)
        procStarted = process.waitForStarted(5000)
        if procStarted:
            finished = process.waitForFinished(30000)
            if finished:
                if process.exitCode() == 0:
                    output = str(
                        process.readAllStandardOutput(),
                        Preferences.getSystem("IOEncoding"),
                        "replace",
                    )
                else:
                    error = str(
                        process.readAllStandardError(),
                        Preferences.getSystem("IOEncoding"),
                        "replace",
                    )
            else:
                error = self.tr("The git process did not finish within 30s.")
        else:
            error = self.tr(
                "The process {0} could not be started. "
                "Ensure, that it is in the search path."
            ).format("git")

        # return file contents with 'universal newlines'
        return output.replace("\r\n", "\n").replace("\r", "\n"), error

    def vcsSbsDiff(self, name, extended=False, revisions=None):
        """
        Public method used to view the difference of a file to the Git
        repository side-by-side.

        @param name file name to be diffed (string)
        @param extended flag indicating the extended variant (boolean)
        @param revisions tuple of two revisions (tuple of strings)
        @exception ValueError raised to indicate an invalid name parameter
        """
        from eric7.UI.CompareDialog import CompareDialog

        from .GitRevisionsSelectionDialog import GitRevisionsSelectionDialog

        if isinstance(name, list):
            raise ValueError("Wrong parameter type")

        if extended:
            # find the root of the repo
            repodir = self.findRepoRoot(self.splitPath(name)[0])
            if not repodir:
                return

            dlg = GitRevisionsSelectionDialog(
                self.gitGetTagsList(repodir), self.gitGetBranchesList(repodir)
            )
            if dlg.exec() == QDialog.DialogCode.Accepted:
                rev1, rev2 = dlg.getRevisions()
        elif revisions:
            rev1, rev2 = revisions[0], revisions[1]
        else:
            rev1, rev2 = "", ""

        output1, error = self.__gitGetFileForRevision(name, rev=rev1)
        if error:
            EricMessageBox.critical(
                self.__ui, self.tr("Git Side-by-Side Difference"), error
            )
            return
        name1 = "{0} (rev. {1})".format(name, rev1 and rev1 or "Stage")

        if rev2:
            if rev2 == "Stage":
                rev2 = ""
            output2, error = self.__gitGetFileForRevision(name, rev=rev2)
            if error:
                EricMessageBox.critical(
                    self.__ui, self.tr("Git Side-by-Side Difference"), error
                )
                return
            name2 = "{0} (rev. {1})".format(name, rev2)
        else:
            try:
                with open(name, "r", encoding="utf-8") as f1:
                    output2 = f1.read()
                    f1.close()
                name2 = "{0} (Work)".format(name)
            except OSError:
                EricMessageBox.critical(
                    self.__ui,
                    self.tr("Git Side-by-Side Difference"),
                    self.tr("""<p>The file <b>{0}</b> could not be read.</p>""").format(
                        name
                    ),
                )
                return

        if self.sbsDiff is None:
            self.sbsDiff = CompareDialog()
        self.sbsDiff.show()
        self.sbsDiff.raise_()
        self.sbsDiff.compare(output1, output2, name1, name2)

    def gitFetch(self, name):
        """
        Public method to fetch changes from a remote repository.

        @param name directory name (string)
        """
        from .GitFetchDialog import GitFetchDialog

        # find the root of the repo
        repodir = self.findRepoRoot(self.splitPath(name)[0])
        if not repodir:
            return

        dlg = GitFetchDialog(self, repodir)
        if dlg.exec() == QDialog.DialogCode.Accepted:
            (
                remote,
                url,
                remoteBranches,
                localBranch,
                fetchAll,
                prune,
                includeTags,
            ) = dlg.getData()

            args = self.initCommand("fetch")
            args.append("--verbose")
            if prune:
                args.append("--prune")
            if includeTags:
                args.append("--tags")
            if fetchAll:
                args.append("--all")
            else:
                args.append(remote) if remote else args.append(url)
                if len(remoteBranches) == 1 and localBranch:
                    args.append(remoteBranches[0] + ":" + localBranch)
                else:
                    args.extend(remoteBranches)

            dia = GitDialog(self.tr("Fetching from a remote Git repository"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()
            self.checkVCSStatus()

    def gitPull(self, name):
        """
        Public method used to pull changes from a remote Git repository.

        @param name directory name of the project to be pulled to (string)
        @return flag indicating, that the update contained an add
            or delete (boolean)
        """
        from .GitPullDialog import GitPullDialog

        # find the root of the repo
        repodir = self.findRepoRoot(self.splitPath(name)[0])
        if not repodir:
            return False

        dlg = GitPullDialog(self, repodir)
        if dlg.exec() == QDialog.DialogCode.Accepted:
            remote, url, branches, pullAll, prune = dlg.getData()

            args = self.initCommand("pull")
            args.append("--no-commit")
            args.append("--verbose")
            if prune:
                args.append("--prune")
            if pullAll:
                args.append("--all")
            else:
                args.append(remote) if remote else args.append(url)
                args.extend(branches)

            dia = GitDialog(self.tr("Pulling from a remote Git repository"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()
                res = dia.hasAddOrDelete()
            self.checkVCSStatus()
            return res
        else:
            return False

    def gitPush(self, name):
        """
        Public method used to push changes to a remote Git repository.

        @param name directory name of the project to be pushed from (string)
        """
        from .GitPushDialog import GitPushDialog

        # find the root of the repo
        repodir = self.findRepoRoot(self.splitPath(name)[0])
        if not repodir:
            return

        dlg = GitPushDialog(self, repodir)
        if dlg.exec() == QDialog.DialogCode.Accepted:
            remote, refspecs, tags, tracking, submodule = dlg.getData()

            args = self.initCommand("push")
            args.append("--verbose")
            args.append("--porcelain")
            if tags:
                args.append("--tags")
            if tracking:
                args.append("--set-upstream")
            if submodule:
                args.append("--recurse-submodules={0}".format(submodule))
            args.append(remote)
            args.extend(refspecs)

            dia = GitDialog(self.tr("Pushing to a remote Git repository"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()
            self.checkVCSStatus()

    def gitCommitMerge(self, name):
        """
        Public method to commit a failed merge.

        @param name file/directory name (string)
        """
        dname, fname = self.splitPath(name)

        # find the root of the repo
        repodir = self.findRepoRoot(dname)
        if not repodir:
            return

        editor = sys.argv[0].replace(".py", "_editor.py")
        env = {
            "GIT_EDITOR": "{0} {1}".format(
                PythonUtilities.getPythonExecutable(), editor
            )
        }

        args = self.initCommand("commit")

        dia = GitDialog(self.tr("Committing failed merge"), self)
        res = dia.startProcess(args, repodir, environment=env)
        if res:
            dia.exec()
        self.committed.emit()
        self.checkVCSStatus()

    def gitCancelMerge(self, name):
        """
        Public method to cancel an uncommitted or failed merge.

        @param name file/directory name (string)
        @return flag indicating, that the cancellation contained an add
            or delete (boolean)
        """
        dname, fname = self.splitPath(name)

        # find the root of the repo
        repodir = self.findRepoRoot(dname)
        if not repodir:
            return False

        args = self.initCommand("merge")
        args.append("--abort")

        dia = GitDialog(self.tr("Aborting uncommitted/failed merge"), self)
        res = dia.startProcess(args, repodir, False)
        if res:
            dia.exec()
            res = dia.hasAddOrDelete()
        self.checkVCSStatus()
        return res

    def gitApply(self, repodir, patchFile, cached=False, reverse=False, noDialog=False):
        """
        Public method to apply a patch stored in a given file.

        @param repodir directory name of the repository (string)
        @param patchFile name of the patch file (string)
        @param cached flag indicating to apply the patch to the staging area
            (boolean)
        @param reverse flag indicating to apply the patch in reverse (boolean)
        @param noDialog flag indicating quiet operations (boolean)
        """
        args = self.initCommand("apply")
        if cached:
            args.append("--index")
            args.append("--cached")
        if reverse:
            args.append("--reverse")
        args.append(patchFile)

        if noDialog:
            self.startSynchronizedProcess(QProcess(), "git", args, repodir)
        else:
            dia = GitDialog(self.tr("Applying patch"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()

    def gitApplyCheckPatches(self, projectDir, check=False):
        """
        Public method to apply a list of patch files or check, if they would
        apply cleanly.

        @param projectDir directory name of the project (string)
        @param check flag indicating to perform a check operation (boolean)
        """
        from .GitPatchFilesDialog import GitPatchFilesDialog

        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        dlg = GitPatchFilesDialog(repodir, self.__patchCheckData)
        if dlg.exec() == QDialog.DialogCode.Accepted:
            patchFilesList, stripCount, inaccurateEof, recount = dlg.getData()
            if patchFilesList:
                args = self.initCommand("apply")
                if check:
                    args.append("--check")
                    self.__patchCheckData = (
                        patchFilesList,
                        stripCount,
                        inaccurateEof,
                        recount,
                    )
                    title = self.tr("Check patch files")
                else:
                    self.__patchCheckData = None
                    title = self.tr("Apply patch files")
                if inaccurateEof:
                    args.append("--inaccurate-eof")
                if recount:
                    args.append("--recount")
                args.append("-p{0}".format(stripCount))
                args.extend(patchFilesList)

                dia = GitDialog(title, self)
                res = dia.startProcess(args, repodir)
                if res:
                    dia.exec()
                    if not check:
                        self.checkVCSStatus()

    def gitShowPatchesStatistics(self, projectDir):
        """
        Public method to show statistics for a set of patch files.

        @param projectDir directory name of the project (string)
        """
        from .GitPatchStatisticsDialog import GitPatchStatisticsDialog

        if self.patchStatisticsDialog is None:
            self.patchStatisticsDialog = GitPatchStatisticsDialog(self)
        self.patchStatisticsDialog.show()
        self.patchStatisticsDialog.raise_()
        self.patchStatisticsDialog.start(projectDir, self.__patchCheckData)
        self.__patchCheckData = self.patchStatisticsDialog.getData()

    ###########################################################################
    ## Methods for tag handling.
    ###########################################################################

    def vcsTag(self, name, revision=None, tagName=None):
        """
        Public method used to set/remove a tag in the Git repository.

        @param name file/directory name to determine the repo root from
            (string)
        @param revision revision to set tag for (string)
        @param tagName name of the tag (string)
        @return flag indicating a performed tag action (boolean)
        """
        from .GitTagDialog import GitTagDialog

        dname, fname = self.splitPath(name)

        # find the root of the repo
        repodir = self.findRepoRoot(dname)
        if not repodir:
            return False

        dlg = GitTagDialog(self.gitGetTagsList(repodir), revision, tagName)
        if dlg.exec() == QDialog.DialogCode.Accepted:
            tag, revision, tagOp, tagType, force = dlg.getParameters()
        else:
            return False

        args = self.initCommand("tag")
        if tagOp == GitTagDialog.CreateTag:
            msg = "Created tag <{0}>.".format(tag)
            if tagType == GitTagDialog.AnnotatedTag:
                args.append("--annotate")
                args.append("--message={0}".format(msg))
            elif tagType == GitTagDialog.SignedTag:
                args.append("--sign")
                args.append("--message={0}".format(msg))
            if force:
                args.append("--force")
        elif tagOp == GitTagDialog.DeleteTag:
            args.append("--delete")
        elif tagOp == GitTagDialog.VerifyTag:
            args.append("--verify")
        else:
            return False
        args.append(tag)
        if tagOp == GitTagDialog.CreateTag and revision:
            args.append(revision)

        dia = GitDialog(self.tr("Tagging in the Git repository"), self)
        res = dia.startProcess(args, repodir)
        if res:
            dia.exec()

        return True

    def gitGetTagsList(self, repodir):
        """
        Public method to get the list of tags.

        @param repodir directory name of the repository (string)
        @return list of tags (list of string) or list of tuples of
            tag name and flag indicating a local tag (list of tuple of string
            and boolean), if withType is True
        """
        args = self.initCommand("tag")
        args.append("--list")

        output = ""
        process = QProcess()
        process.setWorkingDirectory(repodir)
        process.start("git", args)
        procStarted = process.waitForStarted(5000)
        if procStarted:
            finished = process.waitForFinished(30000)
            if finished and process.exitCode() == 0:
                output = str(
                    process.readAllStandardOutput(),
                    Preferences.getSystem("IOEncoding"),
                    "replace",
                )

        tagsList = []
        if output:
            for line in output.splitlines():
                name = line.strip()
                tagsList.append(name)

        return tagsList

    def gitListTagBranch(self, path, tags=True, listAll=True, merged=True):
        """
        Public method used to list the available tags or branches.

        @param path directory name of the project (string)
        @param tags flag indicating listing of branches or tags
            (False = branches, True = tags)
        @param listAll flag indicating to show all tags or branches (boolean)
        @param merged flag indicating to show only merged or non-merged
            branches (boolean)
        """
        from .GitTagBranchListDialog import GitTagBranchListDialog

        if self.tagbranchList is None:
            self.tagbranchList = GitTagBranchListDialog(self)
        self.tagbranchList.show()
        self.tagbranchList.raise_()
        if tags:
            self.tagbranchList.start(path, tags)
        else:
            self.tagbranchList.start(path, tags, listAll, merged)

    ###########################################################################
    ## Methods for branch handling.
    ###########################################################################

    def gitGetBranchesList(
        self, repodir, withMain=False, allBranches=False, remotes=False
    ):
        """
        Public method to get the list of branches.

        @param repodir directory name of the repository (string)
        @param withMain flag indicating to get 'main' as well (boolean)
        @param allBranches flag indicating to return all branches (boolean)
        @param remotes flag indicating to return remote branches only (boolean)
        @return list of branches (list of string)
        """
        args = self.initCommand("branch")
        args.append("--list")
        if allBranches:
            args.append("--all")
        elif remotes:
            args.append("--remotes")

        output = ""
        process = QProcess()
        process.setWorkingDirectory(repodir)
        process.start("git", args)
        procStarted = process.waitForStarted(5000)
        if procStarted:
            finished = process.waitForFinished(30000)
            if finished and process.exitCode() == 0:
                output = str(
                    process.readAllStandardOutput(),
                    Preferences.getSystem("IOEncoding"),
                    "replace",
                )

        branchesList = []
        if output:
            for line in output.splitlines():
                name = line[2:].strip()
                if (
                    (name not in ("main", "master") or withMain)
                    and "->" not in name
                    and not name.startswith("(")
                    and not name.endswith(")")
                ):
                    branchesList.append(name)

        return branchesList

    def gitGetCurrentBranch(self, repodir):
        """
        Public method used to show the current branch of the working directory.

        @param repodir directory name of the repository (string)
        @return name of the current branch (string)
        """
        args = self.initCommand("branch")
        args.append("--list")

        branchName = ""
        output = ""
        process = QProcess()
        process.setWorkingDirectory(repodir)
        process.start("git", args)
        procStarted = process.waitForStarted(5000)
        if procStarted:
            finished = process.waitForFinished(30000)
            if finished and process.exitCode() == 0:
                output = str(
                    process.readAllStandardOutput(),
                    Preferences.getSystem("IOEncoding"),
                    "replace",
                )

        if output:
            for line in output.splitlines():
                if line.startswith("* "):
                    branchName = line[2:].strip()
                    if branchName.startswith("(") and branchName.endswith(")"):
                        # not a valid branch name, probably detached head
                        branchName = ""
                    break

        return branchName

    def gitBranch(self, name, revision=None, branchName=None, branchOp=None):
        """
        Public method used to create, delete or move a branch in the Git
        repository.

        @param name file/directory name to be branched (string)
        @param revision revision to set tag for (string)
        @param branchName name of the branch (string)
        @param branchOp desired branch operation (integer)
        @return flag indicating a performed branch action (boolean) and
            a flag indicating, that the branch operation contained an add
            or delete (boolean)
        """
        from .GitBranchDialog import GitBranchDialog

        dname, fname = self.splitPath(name)

        # find the root of the repo
        repodir = self.findRepoRoot(dname)
        if not repodir:
            return False, False

        dlg = GitBranchDialog(
            self.gitGetBranchesList(repodir, allBranches=True),
            revision,
            branchName,
            branchOp,
        )
        if dlg.exec() == QDialog.DialogCode.Accepted:
            (
                branchOp,
                branch,
                revision,
                newBranch,
                remoteBranch,
                force,
            ) = dlg.getParameters()
        else:
            return False, False

        if branchOp in [
            GitBranchDialog.CreateBranch,
            GitBranchDialog.DeleteBranch,
            GitBranchDialog.RenameBranch,
            GitBranchDialog.SetTrackingBranch,
            GitBranchDialog.UnsetTrackingBranch,
        ]:
            args = self.initCommand("branch")
            if branchOp == GitBranchDialog.CreateBranch:
                if force:
                    args.append("--force")
                args.append(branch)
                if revision:
                    args.append(revision)
            elif branchOp == GitBranchDialog.DeleteBranch:
                if force:
                    args.append("-D")
                else:
                    args.append("-d")
                args.append(branch)
            elif branchOp == GitBranchDialog.RenameBranch:
                if force:
                    args.append("-M")
                else:
                    args.append("-m")
                args.append(branch)
                args.append(newBranch)
            elif branchOp == GitBranchDialog.SetTrackingBranch:
                args.append("--set-upstream-to={0}".format(remoteBranch))
                if branch:
                    args.append(branch)
            elif branchOp == GitBranchDialog.UnsetTrackingBranch:
                args.append("--unset-upstream")
                if branch:
                    args.append(branch)
        elif branchOp in [
            GitBranchDialog.CreateSwitchBranch,
            GitBranchDialog.CreateTrackingBranch,
        ]:
            args = self.initCommand("checkout")
            if branchOp == GitBranchDialog.CreateSwitchBranch:
                if force:
                    args.append("-B")
                else:
                    args.append("-b")
                args.append(branch)
                if revision:
                    args.append(revision)
            elif branchOp == GitBranchDialog.CreateTrackingBranch:
                args.append("--track")
                args.append(branch)
        else:
            return False, False

        dia = GitDialog(self.tr("Branching in the Git repository"), self)
        res = dia.startProcess(args, repodir)
        if res:
            dia.exec()
            if branchOp in [
                GitBranchDialog.CreateSwitchBranch,
                GitBranchDialog.CreateTrackingBranch,
            ]:
                update = dia.hasAddOrDelete()
                self.checkVCSStatus()
            else:
                update = False

        return True, update

    def gitDeleteRemoteBranch(self, name):
        """
        Public method to delete a branch from a remote repository.

        @param name file/directory name (string)
        """
        from .GitBranchPushDialog import GitBranchPushDialog

        dname, fname = self.splitPath(name)

        # find the root of the repo
        repodir = self.findRepoRoot(dname)
        if not repodir:
            return

        dlg = GitBranchPushDialog(
            self.gitGetBranchesList(repodir),
            self.gitGetRemotesList(repodir),
            delete=True,
        )
        if dlg.exec() == QDialog.DialogCode.Accepted:
            branchName, remoteName = dlg.getData()[:2]

            args = self.initCommand("push")
            args.append(remoteName)
            args.append(":{0}".format(branchName))

            dia = GitDialog(self.tr("Delete Remote Branch"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()

    def gitShowBranch(self, name):
        """
        Public method used to show the current branch of the working directory.

        @param name file/directory name (string)
        """
        dname, fname = self.splitPath(name)

        # find the root of the repo
        repodir = self.findRepoRoot(dname)
        if not repodir:
            return

        branchName = self.gitGetCurrentBranch(repodir)
        EricMessageBox.information(
            None,
            self.tr("Current Branch"),
            self.tr("""<p>The current branch is <b>{0}</b>.</p>""").format(branchName),
        )

    ###########################################################################
    ## Methods for bundles handling.
    ###########################################################################

    def gitBundle(self, projectDir):
        """
        Public method to create a bundle file.

        @param projectDir name of the project directory (string)
        """
        from .GitBundleDialog import GitBundleDialog

        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        dlg = GitBundleDialog(
            self.gitGetTagsList(repodir), self.gitGetBranchesList(repodir)
        )
        if dlg.exec() == QDialog.DialogCode.Accepted:
            revs = dlg.getData()

            fname, selectedFilter = EricFileDialog.getSaveFileNameAndFilter(
                None,
                self.tr("Create Bundle"),
                self.__lastBundlePath or repodir,
                self.tr("Git Bundle Files (*.bundle)"),
                None,
                EricFileDialog.DontConfirmOverwrite,
            )

            if not fname:
                return  # user aborted

            fpath = pathlib.Path(fname)
            if not fpath.suffix:
                ex = selectedFilter.split("(*")[1].split(")")[0]
                if ex:
                    fpath = fpath.with_suffix(ex)
            if fpath.exists():
                res = EricMessageBox.yesNo(
                    self.__ui,
                    self.tr("Create Bundle"),
                    self.tr(
                        "<p>The Git bundle file <b>{0}</b> "
                        "already exists. Overwrite it?</p>"
                    ).format(fpath),
                    icon=EricMessageBox.Warning,
                )
                if not res:
                    return

            self.__lastBundlePath = str(fpath.parent)

            args = self.initCommand("bundle")
            args.append("create")
            args.append(str(fpath))
            for rev in revs:
                args.append(rev)

            dia = GitDialog(self.tr("Create Bundle"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()

    def gitVerifyBundle(self, projectDir):
        """
        Public method to verify a bundle file.

        @param projectDir name of the project directory (string)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        fname = EricFileDialog.getOpenFileName(
            None,
            self.tr("Verify Bundle"),
            self.__lastBundlePath or repodir,
            self.tr("Git Bundle Files (*.bundle);;All Files (*)"),
        )
        if fname:
            self.__lastBundlePath = os.path.dirname(fname)

            args = self.initCommand("bundle")
            args.append("verify")
            args.append(fname)

            dia = GitDialog(self.tr("Verify Bundle"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()

    def gitBundleListHeads(self, projectDir):
        """
        Public method to list the heads contained in a bundle file.

        @param projectDir name of the project directory (string)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        fname = EricFileDialog.getOpenFileName(
            None,
            self.tr("List Bundle Heads"),
            self.__lastBundlePath or repodir,
            self.tr("Git Bundle Files (*.bundle);;All Files (*)"),
        )
        if fname:
            self.__lastBundlePath = os.path.dirname(fname)

            args = self.initCommand("bundle")
            args.append("list-heads")
            args.append(fname)

            dia = GitDialog(self.tr("List Bundle Heads"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()

    def gitGetBundleHeads(self, repodir, bundleFile):
        """
        Public method to get a list of heads contained in a bundle file.

        @param repodir directory name of the repository (string)
        @param bundleFile file name of a git bundle file (string)
        @return list of heads (list of strings)
        """
        args = self.initCommand("bundle")
        args.append("list-heads")
        args.append(bundleFile)

        output = ""
        process = QProcess()
        process.setWorkingDirectory(repodir)
        process.start("git", args)
        procStarted = process.waitForStarted(5000)
        if procStarted:
            finished = process.waitForFinished(30000)
            if finished and process.exitCode() == 0:
                output = str(
                    process.readAllStandardOutput(),
                    Preferences.getSystem("IOEncoding"),
                    "replace",
                )

        heads = []
        if output:
            for line in output.splitlines():
                head = line.strip().split(None, 1)[1]  # commit id, head
                heads.append(head.replace("refs/heads/", ""))

        return heads

    def gitBundleFetch(self, projectDir):
        """
        Public method to fetch a head of a bundle file into the local
        repository.

        @param projectDir name of the project directory (string)
        """
        from .GitApplyBundleDataDialog import GitApplyBundleDataDialog

        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        fname = EricFileDialog.getOpenFileName(
            None,
            self.tr("Apply Bundle"),
            self.__lastBundlePath or repodir,
            self.tr("Git Bundle Files (*.bundle);;All Files (*)"),
        )
        if fname:
            self.__lastBundlePath = os.path.dirname(fname)

            dlg = GitApplyBundleDataDialog(
                self.gitGetBundleHeads(repodir, fname), self.gitGetBranchesList(repodir)
            )
            if dlg.exec() == QDialog.DialogCode.Accepted:
                bundleHead, branch = dlg.getData()

                args = self.initCommand("fetch")
                args.append("--verbose")
                args.append(fname)
                if branch:
                    args.append(bundleHead + ":" + branch)
                else:
                    args.append(bundleHead)

                dia = GitDialog(self.tr("Applying a bundle file (fetch)"), self)
                res = dia.startProcess(args, repodir)
                if res:
                    dia.exec()
                    res = dia.hasAddOrDelete()
                self.checkVCSStatus()

    def gitBundlePull(self, projectDir):
        """
        Public method to pull a head of a bundle file into the local
        repository and working area.

        @param projectDir name of the project directory (string)
        @return flag indicating, that the update contained an add
            or delete (boolean)
        """
        from .GitApplyBundleDataDialog import GitApplyBundleDataDialog

        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return False

        res = False
        fname = EricFileDialog.getOpenFileName(
            None,
            self.tr("Apply Bundle"),
            self.__lastBundlePath or repodir,
            self.tr("Git Bundle Files (*.bundle);;All Files (*)"),
        )
        if fname:
            self.__lastBundlePath = os.path.dirname(fname)

            dlg = GitApplyBundleDataDialog(
                self.gitGetBundleHeads(repodir, fname), self.gitGetBranchesList(repodir)
            )
            if dlg.exec() == QDialog.DialogCode.Accepted:
                bundleHead, branch = dlg.getData()

                args = self.initCommand("pull")
                args.append("--verbose")
                args.append(fname)
                if branch:
                    args.append(bundleHead + ":" + branch)
                else:
                    args.append(bundleHead)

                dia = GitDialog(self.tr("Applying a bundle file (fetch)"), self)
                res = dia.startProcess(args, repodir)
                if res:
                    dia.exec()
                    res = dia.hasAddOrDelete()
                self.checkVCSStatus()

        return res

    ###########################################################################
    ## Methods for bisect handling.
    ###########################################################################

    def gitBisect(self, projectDir, subcommand):
        """
        Public method to perform bisect commands.

        @param projectDir name of the project directory (string)
        @param subcommand name of the subcommand (string, one of 'start',
            'start_extended', 'good', 'bad', 'skip' or 'reset')
        @return flag indicating, that the update contained an add
            or delete (boolean)
        @exception ValueError raised to indicate an invalid bisect subcommand
        """
        from .GitBisectStartDialog import GitBisectStartDialog
        from .GitRevisionSelectionDialog import GitRevisionSelectionDialog

        if subcommand not in (
            "start",
            "start_extended",
            "good",
            "bad",
            "skip",
            "reset",
        ):
            raise ValueError(
                self.tr("Bisect subcommand ({0}) invalid.").format(subcommand)
            )

        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return False

        res = False
        rev = ""
        if subcommand in ("good", "bad", "skip", "reset"):
            showBranches = subcommand == "reset"
            showHead = subcommand == "reset"
            dlg = GitRevisionSelectionDialog(
                self.gitGetTagsList(repodir),
                self.gitGetBranchesList(repodir),
                showBranches=showBranches,
                showHead=showHead,
            )
            if dlg.exec() == QDialog.DialogCode.Accepted:
                rev = dlg.getRevision()
            else:
                return False

        args = self.initCommand("bisect")
        if subcommand == "start_extended":
            dlg = GitBisectStartDialog()
            if dlg.exec() == QDialog.DialogCode.Accepted:
                bad, good, noCheckout = dlg.getData()
                args.append("start")
                if noCheckout:
                    args.append("--no-checkout")
                args.append(bad)
                args.extend(good)
                args.append("--")
            else:
                return False
        else:
            args.append(subcommand)
            if rev:
                args.extend(rev.split())
                # treat rev as a list separated by whitespace

        dia = GitDialog(self.tr("Git Bisect ({0})").format(subcommand), self)
        res = dia.startProcess(args, repodir)
        if res:
            dia.exec()
            res = dia.hasAddOrDelete()
            self.checkVCSStatus()

        return res

    def gitBisectLogBrowser(self, projectDir):
        """
        Public method used to browse the bisect log of the project.

        @param projectDir name of the project directory (string)
        """
        from .GitBisectLogBrowserDialog import GitBisectLogBrowserDialog

        if self.bisectlogBrowser is None:
            self.bisectlogBrowser = GitBisectLogBrowserDialog(self)
        self.bisectlogBrowser.show()
        self.bisectlogBrowser.raise_()
        self.bisectlogBrowser.start(projectDir)

    def gitBisectCreateReplayFile(self, projectDir):
        """
        Public method used to create a bisect replay file for the project.

        @param projectDir name of the project directory (string)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        args = self.initCommand("bisect")
        args.append("log")

        output = ""
        process = QProcess()
        process.setWorkingDirectory(repodir)
        process.start("git", args)
        procStarted = process.waitForStarted(5000)
        if procStarted:
            finished = process.waitForFinished(30000)
            if finished and process.exitCode() == 0:
                output = str(
                    process.readAllStandardOutput(),
                    Preferences.getSystem("IOEncoding"),
                    "replace",
                )
        else:
            EricMessageBox.critical(
                self,
                self.tr("Process Generation Error"),
                self.tr(
                    "The process {0} could not be started. "
                    "Ensure, that it is in the search path."
                ).format("git"),
            )
            return

        if output:
            fname, selectedFilter = EricFileDialog.getSaveFileNameAndFilter(
                None,
                self.tr("Create Bisect Replay File"),
                self.__lastBundlePath or repodir,
                self.tr("Git Bisect Replay Files (*.replay)"),
                None,
                EricFileDialog.DontConfirmOverwrite,
            )

            if not fname:
                return  # user aborted

            fpath = pathlib.Path(fname)
            if not fpath.suffix:
                ex = selectedFilter.split("(*")[1].split(")")[0]
                if ex:
                    fpath = fpath.with_suffix(ex)
            if fpath.exists():
                res = EricMessageBox.yesNo(
                    self.__ui,
                    self.tr("Create Bisect Replay File"),
                    self.tr(
                        "<p>The Git bisect replay file <b>{0}</b> "
                        "already exists. Overwrite it?</p>"
                    ).format(fpath),
                    icon=EricMessageBox.Warning,
                )
                if not res:
                    return
            self.__lastReplayPath = str(fpath.parent)

            try:
                with fpath.open("w") as f:
                    f.write(output)
            except OSError as err:
                EricMessageBox.critical(
                    self.__ui,
                    self.tr("Create Bisect Replay File"),
                    self.tr(
                        """<p>The file <b>{0}</b> could not be written.</p>"""
                        """<p>Reason: {1}</p>"""
                    ).format(fpath, str(err)),
                )

    def gitBisectEditReplayFile(self, projectDir):
        """
        Public method used to edit a bisect replay file.

        @param projectDir name of the project directory (string)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        fname = EricFileDialog.getOpenFileName(
            None,
            self.tr("Edit Bisect Replay File"),
            self.__lastReplayPath or repodir,
            self.tr("Git Bisect Replay Files (*.replay);;All Files (*)"),
        )
        if fname:
            self.__lastReplayPath = os.path.dirname(fname)

            self.bisectReplayEditor = MiniEditor(fname)
            self.bisectReplayEditor.show()

    def gitBisectReplay(self, projectDir):
        """
        Public method to replay a bisect session.

        @param projectDir name of the project directory (string)
        @return flag indicating, that the update contained an add
            or delete (boolean)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return False

        res = False
        fname = EricFileDialog.getOpenFileName(
            None,
            self.tr("Bisect Replay"),
            self.__lastReplayPath or repodir,
            self.tr("Git Bisect Replay Files (*.replay);;All Files (*)"),
        )
        if fname:
            self.__lastReplayPath = os.path.dirname(fname)

            args = self.initCommand("bisect")
            args.append("replay")
            args.append(fname)

            dia = GitDialog(self.tr("Git Bisect ({0})").format("replay"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()
                res = dia.hasAddOrDelete()
            self.checkVCSStatus()

        return res

    ###########################################################################
    ## Methods for remotes handling.
    ###########################################################################

    def gitGetRemotesList(self, repodir):
        """
        Public method to get the list of remote repos.

        @param repodir directory name of the repository (string)
        @return list of remote repos (list of string)
        """
        args = self.initCommand("remote")

        output = ""
        process = QProcess()
        process.setWorkingDirectory(repodir)
        process.start("git", args)
        procStarted = process.waitForStarted(5000)
        if procStarted:
            finished = process.waitForFinished(30000)
            if finished and process.exitCode() == 0:
                output = str(
                    process.readAllStandardOutput(),
                    Preferences.getSystem("IOEncoding"),
                    "replace",
                )

        remotesList = []
        if output:
            for line in output.splitlines():
                name = line.strip()
                remotesList.append(name)

        return remotesList

    def gitGetRemoteUrlsList(self, repodir, forFetch=True):
        """
        Public method to get the list of remote repos and their URLs.

        @param repodir directory name of the repository (string)
        @param forFetch flag indicating to get Fetch info (string)
        @return list of tuples of remote repo name and repo URL (list of
            tuple of two strings)
        """
        args = self.initCommand("remote")
        args.append("--verbose")

        output = ""
        process = QProcess()
        process.setWorkingDirectory(repodir)
        process.start("git", args)
        procStarted = process.waitForStarted(5000)
        if procStarted:
            finished = process.waitForFinished(30000)
            if finished and process.exitCode() == 0:
                output = str(
                    process.readAllStandardOutput(),
                    Preferences.getSystem("IOEncoding"),
                    "replace",
                )

        remotesList = []
        if output:
            for line in output.splitlines():
                name, urlmode = line.strip().split(None, 1)
                url, mode = urlmode.rsplit(None, 1)
                if (forFetch and mode == "(fetch)") or (
                    (not forFetch) and mode == "(push)"
                ):
                    remotesList.append((name, url))

        return remotesList

    def gitGetRemoteUrl(self, repodir, remoteName):
        """
        Public method to get the URL of a remote repository.

        @param repodir directory name of the repository
        @type str
        @param remoteName name of the remote repository
        @type str
        @return URL of the remote repository
        @rtype str
        """
        args = self.initCommand("remote")
        args.append("get-url")
        args.append(remoteName)

        output = ""
        process = QProcess()
        process.setWorkingDirectory(repodir)
        process.start("git", args)
        procStarted = process.waitForStarted(5000)
        if procStarted:
            finished = process.waitForFinished(30000)
            if finished and process.exitCode() == 0:
                output = str(
                    process.readAllStandardOutput(),
                    Preferences.getSystem("IOEncoding"),
                    "replace",
                ).strip()

        return output

    def gitGetRemoteBranchesList(self, repodir, remote):
        """
        Public method to get the list of a remote repository branches.

        @param repodir directory name of the repository (string)
        @param remote remote repository name (string)
        @return list of remote repository branches (list of string)
        """
        args = self.initCommand("ls-remote")
        args.append("--heads")
        args.append(remote)

        output = ""
        process = QProcess()
        process.setWorkingDirectory(repodir)
        process.start("git", args)
        procStarted = process.waitForStarted(5000)
        if procStarted:
            finished = process.waitForFinished(30000)
            if finished and process.exitCode() == 0:
                output = str(
                    process.readAllStandardOutput(),
                    Preferences.getSystem("IOEncoding"),
                    "replace",
                )

        remoteBranches = []
        if output:
            for line in output.splitlines():
                branch = line.strip().split()[-1].split("/")[-1]
                remoteBranches.append(branch)

        return remoteBranches

    def gitShowRemote(self, projectDir, remoteName):
        """
        Public method to show information about a remote repository.

        @param projectDir name of the project directory (string)
        @param remoteName name of the remote repository (string)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        args = self.initCommand("remote")
        args.append("show")
        args.append(remoteName)

        dia = GitDialog(self.tr("Show Remote Info"), self)
        res = dia.startProcess(args, repodir, showArgs=False)
        if res:
            dia.exec()

    def gitShowRemotes(self, projectDir):
        """
        Public method to show available remote repositories.

        @param projectDir name of the project directory (string)
        """
        from .GitRemoteRepositoriesDialog import GitRemoteRepositoriesDialog

        if self.remotesDialog is None:
            self.remotesDialog = GitRemoteRepositoriesDialog(self)
        self.remotesDialog.show()
        self.remotesDialog.raise_()
        self.remotesDialog.start(projectDir)

    def gitAddRemote(self, projectDir):
        """
        Public method to add a remote repository.

        @param projectDir name of the project directory (string)
        """
        from .GitAddRemoteDialog import GitAddRemoteDialog

        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        dlg = GitAddRemoteDialog()
        if dlg.exec() == QDialog.DialogCode.Accepted:
            name, url = dlg.getData()
            args = self.initCommand("remote")
            args.append("add")
            args.append(name)
            args.append(url)

            self.startSynchronizedProcess(QProcess(), "git", args, workingDir=repodir)

    def gitRenameRemote(self, projectDir, remoteName):
        """
        Public method to rename a remote repository.

        @param projectDir name of the project directory (string)
        @param remoteName name of the remote repository (string)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        newName, ok = QInputDialog.getText(
            None,
            self.tr("Rename Remote Repository"),
            self.tr("Enter new name for remote repository:"),
            QLineEdit.EchoMode.Normal,
        )
        if ok and newName and newName != remoteName:
            args = self.initCommand("remote")
            args.append("rename")
            args.append(remoteName)
            args.append(newName)

            self.startSynchronizedProcess(QProcess(), "git", args, workingDir=repodir)

    def gitChangeRemoteUrl(self, projectDir, remoteName, remoteUrl=""):
        """
        Public method to change the URL of a remote repository.

        @param projectDir name of the project directory
        @type str
        @param remoteName name of the remote repository
        @type str
        @param remoteUrl URL of the remote repository
        @type str
        """
        from .GitChangeRemoteUrlDialog import GitChangeRemoteUrlDialog

        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        if not remoteUrl:
            remoteUrl = self.gitGetRemoteUrl(repodir, remoteName)

        dlg = GitChangeRemoteUrlDialog(remoteName, remoteUrl)
        if dlg.exec() == QDialog.DialogCode.Accepted:
            name, url = dlg.getData()
            if url != remoteUrl:
                args = self.initCommand("remote")
                args.append("set-url")
                args.append(name)
                args.append(url)

                self.startSynchronizedProcess(
                    QProcess(), "git", args, workingDir=repodir
                )

    def gitChangeRemoteCredentials(self, projectDir, remoteName, remoteUrl=""):
        """
        Public method to change the user credentials of a remote repository.

        @param projectDir name of the project directory
        @type str
        @param remoteName name of the remote repository
        @type str
        @param remoteUrl URL of the remote repository
        @type str
        """
        from .GitRemoteCredentialsDialog import GitRemoteCredentialsDialog

        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        if not remoteUrl:
            remoteUrl = self.gitGetRemoteUrl(repodir, remoteName)

        dlg = GitRemoteCredentialsDialog(remoteName, remoteUrl)
        if dlg.exec() == QDialog.DialogCode.Accepted:
            name, url = dlg.getData()
            if url != remoteUrl:
                args = self.initCommand("remote")
                args.append("set-url")
                args.append(name)
                args.append(url)

                self.startSynchronizedProcess(
                    QProcess(), "git", args, workingDir=repodir
                )

    def gitRemoveRemote(self, projectDir, remoteName):
        """
        Public method to remove a remote repository.

        @param projectDir name of the project directory (string)
        @param remoteName name of the remote repository (string)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        args = self.initCommand("remote")
        args.append("remove")
        args.append(remoteName)

        self.startSynchronizedProcess(QProcess(), "git", args, workingDir=repodir)

    def gitPruneRemote(self, projectDir, remoteName):
        """
        Public method to prune stale remote-tracking branches.

        @param projectDir name of the project directory (string)
        @param remoteName name of the remote repository (string)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        args = self.initCommand("remote")
        args.append("prune")
        args.append(remoteName)

        dia = GitDialog(self.tr("Show Remote Info"), self)
        res = dia.startProcess(args, repodir)
        if res:
            dia.exec()

    def gitShortlog(self, projectDir, commit):
        """
        Public method to show a short log suitable for inclusion in release
        announcements.

        @param projectDir name of the project directory (string)
        @param commit commit to start the log at (strings)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        args = self.initCommand("shortlog")
        args.append("-w")
        args.append(commit)

        dia = GitDialog(self.tr("Show Shortlog"), self)
        res = dia.startProcess(args, repodir, showArgs=False)
        if res:
            dia.exec()

    def gitDescribe(self, projectDir, commits):
        """
        Public method to find the most recent tag reachable from each commit.

        @param projectDir name of the project directory (string)
        @param commits list of commits to start the search from
            (list of strings)
        """
        from .GitDescribeDialog import GitDescribeDialog

        if self.describeDialog is None:
            self.describeDialog = GitDescribeDialog(self)
        self.describeDialog.show()
        self.describeDialog.raise_()
        self.describeDialog.start(projectDir, commits)

    ###########################################################################
    ## Methods for cherry-pick handling.
    ###########################################################################

    def gitCherryPick(self, projectDir, commits=None):
        """
        Public method to cherry pick commits and apply them to the current
        branch.

        @param projectDir name of the project directory (string)
        @param commits list of commits to be applied (list of strings)
        @return flag indicating that the project should be reread (boolean)
        """
        from .GitCherryPickDialog import GitCherryPickDialog

        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return False

        res = False

        dlg = GitCherryPickDialog(commits)
        if dlg.exec() == QDialog.DialogCode.Accepted:
            commits, cherrypickInfo, signoff, nocommit = dlg.getData()

            args = self.initCommand("cherry-pick")
            args.append("-Xpatience")
            if cherrypickInfo:
                args.append("-x")
            if signoff:
                args.append("--signoff")
            if nocommit:
                args.append("--no-commit")
            args.extend(commits)

            dia = GitDialog(self.tr("Cherry-pick"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()
                res = dia.hasAddOrDelete()
                self.checkVCSStatus()
        return res

    def gitCherryPickContinue(self, projectDir):
        """
        Public method to continue the last copying session after conflicts
        were resolved.

        @param projectDir name of the project directory (string)
        @return flag indicating that the project should be reread (boolean)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return False

        editor = sys.argv[0].replace(".py", "_editor.py")
        env = {
            "GIT_EDITOR": "{0} {1}".format(
                PythonUtilities.getPythonExecutable(), editor
            )
        }

        args = self.initCommand("cherry-pick")
        args.append("--continue")

        dia = GitDialog(self.tr("Copy Changesets (Continue)"), self)
        res = dia.startProcess(args, repodir, environment=env)
        if res:
            dia.exec()
            res = dia.hasAddOrDelete()
            self.checkVCSStatus()
        return res

    def gitCherryPickQuit(self, projectDir):
        """
        Public method to quit the current copying operation.

        @param projectDir name of the project directory (string)
        @return flag indicating that the project should be reread (boolean)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return False

        args = self.initCommand("cherry-pick")
        args.append("--quit")

        dia = GitDialog(self.tr("Copy Changesets (Quit)"), self)
        res = dia.startProcess(args, repodir)
        if res:
            dia.exec()
            res = dia.hasAddOrDelete()
            self.checkVCSStatus()
        return res

    def gitCherryPickAbort(self, projectDir):
        """
        Public method to cancel the last copying session and return to
        the previous state.

        @param projectDir name of the project directory (string)
        @return flag indicating that the project should be reread (boolean)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return False

        args = self.initCommand("cherry-pick")
        args.append("--abort")

        dia = GitDialog(self.tr("Copy Changesets (Cancel)"), self)
        res = dia.startProcess(args, repodir)
        if res:
            dia.exec()
            res = dia.hasAddOrDelete()
            self.checkVCSStatus()
        return res

    ###########################################################################
    ## Methods for stash handling.
    ###########################################################################

    def __gitGetStashesList(self, projectDir):
        """
        Private method to get a list of stash names.

        @param projectDir name of the project directory (string)
        @return list of available stashes (list of string)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return []

        args = self.initCommand("stash")
        args.append("list")
        args.append("--format=format:%gd")

        stashesList = []
        output = ""
        process = QProcess()
        process.setWorkingDirectory(repodir)
        process.start("git", args)
        procStarted = process.waitForStarted(5000)
        if procStarted:
            finished = process.waitForFinished(30000)
            if finished and process.exitCode() == 0:
                output = str(
                    process.readAllStandardOutput(),
                    Preferences.getSystem("IOEncoding"),
                    "replace",
                )

        if output:
            stashesList = output.strip().splitlines()

        return stashesList

    def gitStashSave(self, projectDir):
        """
        Public method to save the current changes to a new stash.

        @param projectDir name of the project directory (string)
        @return flag indicating, that the save contained an add
            or delete (boolean)
        """
        from .GitStashDataDialog import GitStashDataDialog

        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return False

        res = False
        dlg = GitStashDataDialog()
        if dlg.exec() == QDialog.DialogCode.Accepted:
            message, keepIndex, untracked = dlg.getData()
            args = self.initCommand("stash")
            args.append("save")
            if keepIndex:
                args.append("--keep-index")
            if untracked == GitStashDataDialog.UntrackedOnly:
                args.append("--include-untracked")
            elif untracked == GitStashDataDialog.UntrackedAndIgnored:
                args.append("--all")
            if message:
                args.append(message)

            dia = GitDialog(self.tr("Saving stash"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()
                res = dia.hasAddOrDelete()
            self.checkVCSStatus()
        return res

    def gitStashBrowser(self, projectDir):
        """
        Public method used to browse the stashed changes.

        @param projectDir name of the project directory (string)
        """
        from .GitStashBrowserDialog import GitStashBrowserDialog

        if self.stashBrowser is None:
            self.stashBrowser = GitStashBrowserDialog(self)
        self.stashBrowser.show()
        self.stashBrowser.raise_()
        self.stashBrowser.start(projectDir)

    def gitStashShowPatch(self, projectDir, stashName=""):
        """
        Public method to show the contents of a stash.

        @param projectDir name of the project directory (string)
        @param stashName name of a stash (string)
        """
        from .GitDiffDialog import GitDiffDialog

        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        if not stashName:
            availableStashes = self.__gitGetStashesList(repodir)
            stashName, ok = QInputDialog.getItem(
                None,
                self.tr("Show Stash"),
                self.tr("Select a stash (empty for latest stash):"),
                [""] + availableStashes,
                0,
                False,
            )
            if not ok:
                return

        if self.diff is None:
            self.diff = GitDiffDialog(self)
        self.diff.show()
        self.diff.raise_()
        self.diff.start(repodir, diffMode="stash", stashName=stashName)

    def gitStashApply(self, projectDir, stashName=""):
        """
        Public method to apply a stash but keep it.

        @param projectDir name of the project directory (string)
        @param stashName name of a stash (string)
        @return flag indicating, that the restore contained an add
            or delete (boolean)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return False

        if not stashName:
            availableStashes = self.__gitGetStashesList(repodir)
            stashName, ok = QInputDialog.getItem(
                None,
                self.tr("Restore Stash"),
                self.tr("Select a stash (empty for latest stash):"),
                [""] + availableStashes,
                0,
                False,
            )
            if not ok:
                return False

        args = self.initCommand("stash")
        args.append("apply")
        if stashName:
            args.append(stashName)

        dia = GitDialog(self.tr("Restoring stash"), self)
        res = dia.startProcess(args, repodir)
        if res:
            dia.exec()
            res = dia.hasAddOrDelete()
        self.checkVCSStatus()
        return res

    def gitStashPop(self, projectDir, stashName=""):
        """
        Public method to apply a stash and delete it.

        @param projectDir name of the project directory (string)
        @param stashName name of a stash (string)
        @return flag indicating, that the restore contained an add
            or delete (boolean)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return False

        if not stashName:
            availableStashes = self.__gitGetStashesList(repodir)
            stashName, ok = QInputDialog.getItem(
                None,
                self.tr("Restore Stash"),
                self.tr("Select a stash (empty for latest stash):"),
                [""] + availableStashes,
                0,
                False,
            )
            if not ok:
                return False

        args = self.initCommand("stash")
        args.append("pop")
        if stashName:
            args.append(stashName)

        dia = GitDialog(self.tr("Restoring stash"), self)
        res = dia.startProcess(args, repodir)
        if res:
            dia.exec()
            res = dia.hasAddOrDelete()
        self.checkVCSStatus()
        return res

    def gitStashBranch(self, projectDir, stashName=""):
        """
        Public method to create a branch from a stash.

        @param projectDir name of the project directory (string)
        @param stashName name of a stash (string)
        @return flag indicating, that the restore contained an add
            or delete (boolean)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return False

        branchName, ok = QInputDialog.getText(
            None,
            self.tr("Create Branch"),
            self.tr("Enter a branch name to restore a stash to:"),
            QLineEdit.EchoMode.Normal,
        )
        if not ok or branchName == "":
            return False

        if not stashName:
            availableStashes = self.__gitGetStashesList(repodir)
            stashName, ok = QInputDialog.getItem(
                None,
                self.tr("Create Branch"),
                self.tr("Select a stash (empty for latest stash):"),
                [""] + availableStashes,
                0,
                False,
            )
            if not ok:
                return False

        args = self.initCommand("stash")
        args.append("branch")
        args.append(branchName)
        if stashName:
            args.append(stashName)

        dia = GitDialog(self.tr("Creating branch"), self)
        res = dia.startProcess(args, repodir)
        if res:
            dia.exec()
            res = dia.hasAddOrDelete()
        self.checkVCSStatus()
        return res

    def gitStashDrop(self, projectDir, stashName=""):
        """
        Public method to delete a stash.

        @param projectDir name of the project directory (string)
        @param stashName name of a stash (string)
        @return flag indicating a successful deletion (boolean)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return False

        if not stashName:
            availableStashes = self.__gitGetStashesList(repodir)
            stashName, ok = QInputDialog.getItem(
                None,
                self.tr("Show Stash"),
                self.tr("Select a stash (empty for latest stash):"),
                [""] + availableStashes,
                0,
                False,
            )
            if not ok:
                return False

        res = EricMessageBox.yesNo(
            None,
            self.tr("Delete Stash"),
            self.tr("""Do you really want to delete the stash <b>{0}</b>?""").format(
                stashName
            ),
        )
        if res:
            args = self.initCommand("stash")
            args.append("drop")
            if stashName:
                args.append(stashName)

            dia = GitDialog(self.tr("Deleting stash"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()
        return res

    def gitStashClear(self, projectDir):
        """
        Public method to delete all stashes.

        @param projectDir name of the project directory (string)
        @return flag indicating a successful deletion (boolean)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return False

        res = EricMessageBox.yesNo(
            None,
            self.tr("Delete All Stashes"),
            self.tr("""Do you really want to delete all stashes?"""),
        )
        if res:
            args = self.initCommand("stash")
            args.append("clear")

            dia = GitDialog(self.tr("Deleting all stashes"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()
        return res

    def gitEditConfig(self, projectDir):
        """
        Public method used to edit the repository configuration file.

        @param projectDir name of the project directory (string)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        cfgFile = os.path.join(repodir, self.adminDirOrFile, "config")
        if not os.path.exists(cfgFile):
            # create an empty one
            with contextlib.suppress(OSError), open(cfgFile, "w"):
                pass
        self.repoEditor = MiniEditor(cfgFile, "Properties")
        self.repoEditor.show()

    def gitEditUserConfig(self):
        """
        Public method used to edit the user configuration file.
        """
        from .GitUserConfigDataDialog import GitUserConfigDataDialog
        from .GitUtilities import getConfigPath

        cfgFile = getConfigPath()
        if not os.path.exists(cfgFile):
            dlg = GitUserConfigDataDialog()
            if dlg.exec() == QDialog.DialogCode.Accepted:
                firstName, lastName, email = dlg.getData()
            else:
                firstName, lastName, email = ("Firstname", "Lastname", "email_address")
            with contextlib.suppress(OSError), open(cfgFile, "w") as f:
                f.write("[user]\n")
                f.write("    name = {0} {1}\n".format(firstName, lastName))
                f.write("    email = {0}\n".format(email))
        self.userEditor = MiniEditor(cfgFile, "Properties")
        self.userEditor.show()

    def gitShowConfig(self, projectDir):
        """
        Public method to show the combined configuration.

        @param projectDir name of the project directory (string)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        args = self.initCommand("config")
        args.append("--list")

        dia = GitDialog(self.tr("Showing the combined configuration settings"), self)
        res = dia.startProcess(args, repodir, False)
        if res:
            dia.exec()

    def gitVerify(self, projectDir):
        """
        Public method to verify the connectivity and validity of objects
        of the database.

        @param projectDir name of the project directory (string)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        args = self.initCommand("fsck")
        args.append("--strict")
        args.append("--full")
        args.append("--cache")

        dia = GitDialog(self.tr("Verifying the integrity of the Git repository"), self)
        res = dia.startProcess(args, repodir, False)
        if res:
            dia.exec()

    def gitHouseKeeping(self, projectDir):
        """
        Public method to cleanup and optimize the local repository.

        @param projectDir name of the project directory (string)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        args = self.initCommand("gc")
        args.append("--prune")
        if self.__plugin.getPreferences("AggressiveGC"):
            args.append("--aggressive")

        dia = GitDialog(self.tr("Performing Repository Housekeeping"), self)
        res = dia.startProcess(args, repodir)
        if res:
            dia.exec()

    def gitStatistics(self, projectDir):
        """
        Public method to show some statistics of the local repository.

        @param projectDir name of the project directory (string)
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        args = self.initCommand("count-objects")
        args.append("-v")

        output = ""
        process = QProcess()
        process.setWorkingDirectory(repodir)
        process.start("git", args)
        procStarted = process.waitForStarted(5000)
        if procStarted:
            finished = process.waitForFinished(30000)
            if finished and process.exitCode() == 0:
                output = str(
                    process.readAllStandardOutput(),
                    Preferences.getSystem("IOEncoding"),
                    "replace",
                )

        info = []
        if output:
            statistics = {}
            for line in output.splitlines():
                key, value = line.strip().split(": ", 1)
                statistics[key] = value

            info.append("""<p><table>""")
            info.append(self.tr("""<tr><td><b>Statistics</b></td></tr>"""))
            info.append(
                self.tr(
                    """<tr><td>Number of loose objects: </td><td>{0}</td></tr>"""
                ).format(statistics["count"])
            )
            info.append(
                self.tr(
                    """<tr><td>Disk space used by loose objects: </td>"""
                    """<td>{0} KiB</td></tr>"""
                ).format(statistics["size"])
            )
            info.append(
                self.tr(
                    """<tr><td>Number of packed objects: </td>"""
                    """<td>{0}</td></tr>"""
                ).format(statistics["in-pack"])
            )
            info.append(
                self.tr("""<tr><td>Number of packs: </td><td>{0}</td></tr>""").format(
                    statistics["packs"]
                )
            )
            info.append(
                self.tr(
                    """<tr><td>Disk space used by packed objects: </td>"""
                    """<td>{0} KiB</td></tr>"""
                ).format(statistics["size-pack"])
            )
            info.append(
                self.tr(
                    """<tr><td>Packed objects waiting for pruning: </td>"""
                    """<td>{0}</td></tr>"""
                ).format(statistics["prune-packable"])
            )
            info.append(
                self.tr("""<tr><td>Garbage files: </td><td>{0}</td></tr>""").format(
                    statistics["garbage"]
                )
            )
            info.append(
                self.tr(
                    """<tr><td>Disk space used by garbage files: </td>"""
                    """<td>{0} KiB</td></tr>"""
                ).format(statistics["size-garbage"])
            )
            info.append("""</table></p>""")
        else:
            info.append(self.tr("<p><b>No statistics available.</b></p>"))
        dlg = VcsRepositoryInfoDialog(None, "\n".join(info))
        dlg.exec()

    def gitGetArchiveFormats(self, repodir):
        """
        Public method to get a list of supported archive formats.

        @param repodir directory name of the repository (string)
        @return list of supported archive formats (list of strings)
        """
        args = self.initCommand("archive")
        args.append("--list")

        output = ""
        process = QProcess()
        process.setWorkingDirectory(repodir)
        process.start("git", args)
        procStarted = process.waitForStarted(5000)
        if procStarted:
            finished = process.waitForFinished(30000)
            if finished and process.exitCode() == 0:
                output = str(
                    process.readAllStandardOutput(),
                    Preferences.getSystem("IOEncoding"),
                    "replace",
                )

        archiveFormats = []
        if output:
            for line in output.splitlines():
                archiveFormat = line.strip()
                archiveFormats.append(archiveFormat)

        return archiveFormats

    def gitCreateArchive(self, projectDir):
        """
        Public method to show some statistics of the local repository.

        @param projectDir name of the project directory (string)
        """
        from .GitArchiveDataDialog import GitArchiveDataDialog

        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        dlg = GitArchiveDataDialog(
            self.gitGetTagsList(repodir),
            self.gitGetBranchesList(repodir),
            self.gitGetArchiveFormats(repodir),
        )
        if dlg.exec() == QDialog.DialogCode.Accepted:
            commit, archiveFormat, fileName, prefix = dlg.getData()
            args = self.initCommand("archive")
            args.append("--format={0}".format(archiveFormat))
            args.append("--output={0}".format(fileName))
            if prefix:
                prefix = FileSystemUtilities.fromNativeSeparators(prefix)
                if not prefix.endswith("/"):
                    prefix += "/"
                args.append("--prefix={0}".format(prefix))
            args.append(commit)

            dia = GitDialog(self.tr("Creating Archive"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()

    ###########################################################################
    ## Methods related to submodules.
    ###########################################################################

    def gitSubmoduleAdd(self, projectDir):
        """
        Public method to add a submodule to the project.

        @param projectDir name of the project directory
        @type str
        """
        from .GitSubmoduleAddDialog import GitSubmoduleAddDialog

        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        dlg = GitSubmoduleAddDialog(self, repodir)
        if dlg.exec() == QDialog.DialogCode.Accepted:
            repo, branch, name, path, force = dlg.getData()
            args = self.initCommand("submodule")
            args.append("add")
            if branch:
                args.append("--branch")
                args.append(branch)
            if force:
                args.append("--force")
            if name:
                args.append("--name")
                args.append(name)
            args.append(repo)
            if path:
                args.append(path)

            dia = GitDialog(self.tr("Add Submodule"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()

    def __gitSubmodulesList(self, repodir):
        """
        Private method to get the data of defined submodules.

        @param repodir name of the directory containing the repo subdirectory
        @type str
        @return list of dictionaries with submodule name, path, URL and branch
        @rtype list of dict
        """
        submodulesFile = os.path.join(repodir, ".gitmodules")
        if not os.path.exists(submodulesFile):
            return []

        try:
            with open(submodulesFile, "r") as modulesFile:
                contents = modulesFile.readlines()
        except OSError:
            # silently ignore them
            return []

        submodules = []
        submoduleDict = None
        for line in contents:
            line = line.strip()
            if line.startswith("[submodule"):
                if submoduleDict:
                    if "branch" not in submoduleDict:
                        submoduleDict["branch"] = ""
                    submodules.append(submoduleDict)
                submoduleDict = {"name": line.split(None, 1)[1][1:-2]}
            elif "=" in line:
                option, value = line.split("=", 1)
                submoduleDict[option.strip()] = value.strip()
        if submoduleDict:
            if "branch" not in submoduleDict:
                submoduleDict["branch"] = ""
            submodules.append(submoduleDict)

        return submodules

    def gitSubmoduleList(self, projectDir):
        """
        Public method to show a list of all submodules of the project.

        @param projectDir name of the project directory
        @type str
        """
        from .GitSubmodulesListDialog import GitSubmodulesListDialog

        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        submodulesList = self.__gitSubmodulesList(repodir)
        if submodulesList:
            dlg = GitSubmodulesListDialog(submodulesList)
            dlg.exec()
        else:
            EricMessageBox.information(
                None,
                self.tr("List Submodules"),
                self.tr("""No submodules defined for the project."""),
            )

    def __selectSubmodulePath(self, repodir):
        """
        Private method to select a submodule path.

        @param repodir name of the directory containing the repo subdirectory
        @type str
        @return tuple of selected submodule path and flag indicating
            a cancellation
        @rtype tuple of (str, bool)
        """
        allEntry = self.tr("All")
        paths = [submodule["path"] for submodule in self.__gitSubmodulesList(repodir)]
        submodulePath, ok = QInputDialog.getItem(
            None,
            self.tr("Submodule Path"),
            self.tr("Select a submodule path:"),
            [allEntry] + sorted(paths),
            0,
            False,
        )
        if submodulePath == allEntry:
            submodulePath = ""

        return submodulePath, ok

    def __selectSubmodulePaths(self, repodir):
        """
        Private method to select a list of submodule paths.

        @param repodir name of the directory containing the repo subdirectory
        @type str
        @return tuple of selected submodule paths and flag indicating
            a cancellation
        @rtype tuple of (list of str, bool)
        """
        from .GitListDialog import GitListDialog

        paths = [submodule["path"] for submodule in self.__gitSubmodulesList(repodir)]

        dlg = GitListDialog(sorted(paths))
        if dlg.exec() == QDialog.DialogCode.Accepted:
            selectedPaths = dlg.getSelection()
            return selectedPaths, True
        else:
            return [], False

    def gitSubmoduleInit(self, projectDir):
        """
        Public method to initialize one or all submodules.

        @param projectDir name of the project directory
        @type str
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        submodulePaths, ok = self.__selectSubmodulePaths(repodir)
        if ok:
            args = self.initCommand("submodule")
            args.append("init")
            args.extend(submodulePaths)

            dia = GitDialog(self.tr("Initialize Submodules"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()

    def gitSubmoduleDeinit(self, projectDir):
        """
        Public method to unregister submodules.

        @param projectDir name of the project directory
        @type str
        """
        from .GitSubmodulesDeinitDialog import GitSubmodulesDeinitDialog

        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        paths = [submodule["path"] for submodule in self.__gitSubmodulesList(repodir)]

        dlg = GitSubmodulesDeinitDialog(paths)
        if dlg.exec() == QDialog.DialogCode.Accepted:
            deinitAll, submodulePaths, force = dlg.getData()
            args = self.initCommand("submodule")
            args.append("deinit")
            if deinitAll:
                args.append("--all")
            else:
                args.extend(submodulePaths)
            if force:
                args.append("--force")

            dia = GitDialog(self.tr("Unregister Submodules"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()

    def gitSubmoduleUpdate(self, projectDir, initialize=False, remote=False):
        """
        Public method to update submodules.

        @param projectDir name of the project directory
        @type str
        @param initialize flag indicating an initialize and update operation
        @type bool
        @param remote flag indicating a fetch and update operation
        @type bool
        """
        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        submodulePaths, ok = self.__selectSubmodulePaths(repodir)
        if ok:
            args = self.initCommand("submodule")
            args.append("update")
            if initialize:
                args.append("--init")
            if remote:
                args.append("--remote")
            args.extend(submodulePaths)

            dia = GitDialog(self.tr("Update Submodules"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()

    def gitSubmoduleUpdateWithOptions(self, projectDir):
        """
        Public method to update submodules offering a dialog to select the
        update options.

        @param projectDir name of the project directory
        @type str
        """
        from .GitSubmodulesUpdateOptionsDialog import GitSubmodulesUpdateOptionsDialog

        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        paths = [submodule["path"] for submodule in self.__gitSubmodulesList(repodir)]

        dlg = GitSubmodulesUpdateOptionsDialog(paths)
        if dlg.exec() == QDialog.DialogCode.Accepted:
            procedure, init, remote, noFetch, force, submodulePaths = dlg.getData()

            args = self.initCommand("submodule")
            args.append("update")
            args.append(procedure)
            if init:
                args.append("--init")
            if remote:
                args.append("--remote")
            if noFetch:
                args.append("--no-fetch")
            if force:
                args.append("--force")
            args.extend(submodulePaths)

            dia = GitDialog(self.tr("Update Submodules"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()

    def gitSubmoduleSync(self, projectDir):
        """
        Public method to synchronize submodules.

        @param projectDir name of the project directory
        @type str
        """
        from .GitSubmodulesSyncDialog import GitSubmodulesSyncDialog

        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        paths = [submodule["path"] for submodule in self.__gitSubmodulesList(repodir)]

        dlg = GitSubmodulesSyncDialog(paths)
        if dlg.exec() == QDialog.DialogCode.Accepted:
            submodulePaths, recursive = dlg.getData()
            args = self.initCommand("submodule")
            args.append("sync")
            if recursive:
                args.append("--recursive")
            args.extend(submodulePaths)

            dia = GitDialog(self.tr("Synchronize Submodules"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()

    def gitSubmoduleStatus(self, projectDir):
        """
        Public method to show the status of the submodules.

        @param projectDir name of the project directory
        @type str
        """
        from .GitSubmodulesStatusDialog import GitSubmodulesStatusDialog

        if self.submoduleStatusDialog is None:
            self.submoduleStatusDialog = GitSubmodulesStatusDialog(self)
        self.submoduleStatusDialog.show()
        self.submoduleStatusDialog.raise_()
        self.submoduleStatusDialog.start(projectDir)

    def gitSubmoduleSummary(self, projectDir):
        """
        Public method to show the status of the submodules.

        @param projectDir name of the project directory
        @type str
        """
        from .GitSubmodulesSummaryOptionsDialog import GitSubmodulesSummaryOptionsDialog

        # find the root of the repo
        repodir = self.findRepoRoot(projectDir)
        if not repodir:
            return

        paths = [submodule["path"] for submodule in self.__gitSubmodulesList(repodir)]

        dlg = GitSubmodulesSummaryOptionsDialog(paths)
        if dlg.exec() == QDialog.DialogCode.Accepted:
            submodulePaths, superProject, index, commit, limit = dlg.getData()
            args = self.initCommand("submodule")
            args.append("summary")
            if superProject:
                args.append("--files")
            if index:
                args.append("--cached")
            if limit > -1:
                args.append("--summary-limit")
                args.append(str(limit))
            if commit:
                args.append(commit)
                if submodulePaths:
                    args.append("--")
            args.extend(submodulePaths)

            dia = GitDialog(self.tr("Submodules Summary"), self)
            res = dia.startProcess(args, repodir)
            if res:
                dia.exec()

    ###########################################################################
    ## Methods for worktree management are below..
    ###########################################################################

    def gitWorktreeManagement(self, projectDir):
        """
        Public method to show the worktree list/management dialog.

        @param projectDir name of the project directory
        @type str
        """
        from .GitWorktreeDialog import GitWorktreeDialog

        if self.worktreeDialog is None:
            self.worktreeDialog = GitWorktreeDialog(self)
        self.worktreeDialog.show()
        self.worktreeDialog.raise_()
        self.worktreeDialog.start(projectDir)

    ###########################################################################
    ## Methods to get the helper objects are below.
    ###########################################################################

    def vcsGetProjectBrowserHelper(self, browser, project, isTranslationsBrowser=False):
        """
        Public method to instantiate a helper object for the different
        project browsers.

        @param browser reference to the project browser object
        @param project reference to the project object
        @param isTranslationsBrowser flag indicating, the helper is requested
            for the translations browser (this needs some special treatment)
        @return the project browser helper object
        """
        from .ProjectBrowserHelper import GitProjectBrowserHelper

        return GitProjectBrowserHelper(self, browser, project, isTranslationsBrowser)

    def vcsGetProjectHelper(self, project):
        """
        Public method to instantiate a helper object for the project.

        @param project reference to the project object
        @return the project helper object
        """
        self.__projectHelper = self.__plugin.getProjectHelper()
        self.__projectHelper.setObjects(self, project)
        return self.__projectHelper

    ###########################################################################
    ##  Status Monitor Thread methods
    ###########################################################################

    def _createStatusMonitorThread(self, interval, project):
        """
        Protected method to create an instance of the VCS status monitor
        thread.

        @param interval check interval for the monitor thread in seconds
            (integer)
        @param project reference to the project object (Project)
        @return reference to the monitor thread (QThread)
        """
        from .GitStatusMonitorThread import GitStatusMonitorThread

        return GitStatusMonitorThread(interval, project, self)

    ###########################################################################
    ##  Method to find the repository root
    ###########################################################################

    def findRepoRoot(self, start):
        """
        Public method to find the repository root directory given a start.

        @param start start directory name
        @type str
        @return directory name of the repository root or None, if it was not found
        @rtype str or None
        """
        repoRoot = start
        while repoRoot and not os.path.exists(
            os.path.join(repoRoot, self.adminDirOrFile)
        ):
            repoRoot = os.path.dirname(repoRoot)
            if os.path.splitdrive(repoRoot)[1] == os.sep:
                repoRoot = None
                break

        return repoRoot