eric: comparison src/eric7/Plugins/VcsPlugins/vcsGit/git.py

-:3fc8dfeb6ebe
+:b99e7fd55fd3
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014 - 2022 Detlev Offenbach <detlev@die-offenbachs.de>
+#
+"""
+Module implementing the version control systems interface to Git.
+"""
+import os
+import shutil
+import re
+import contextlib
+import pathlib
+from PyQt6.QtCore import QProcess, pyqtSignal
+from PyQt6.QtWidgets import QApplication, QDialog, QInputDialog, QLineEdit
+from EricWidgets.EricApplication import ericApp
+from EricWidgets import EricMessageBox, EricFileDialog
+from QScintilla.MiniEditor import MiniEditor
+from VCS.VersionControl import VersionControl
+from VCS.RepositoryInfoDialog import VcsRepositoryInfoDialog
+from .GitDialog import GitDialog
+import Globals
+import Utilities
+import Preferences
+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.adminDir = '.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.__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()
+# 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):
+"""
+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):
+"""
+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)
+shutil.rmtree(os.path.join(projectDir, self.adminDir), True)
+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)
+"""
+if not noDialog:
+# call CommitDialog and get message from there
+if self.__commitDialog is None:
+from .GitCommitDialog import GitCommitDialog
+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 = dname
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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 = dname
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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 = dname
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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):
+"""
+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 = dname
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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)
+"""
+isDir = os.path.isdir(name)
+res = False
+if noDialog:
+if target is None:
+return False
+force = True
+accepted = True
+else:
+from .GitCopyDialog import GitCopyDialog
+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 = dname
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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)
+"""
+if self.logBrowser is None:
+from .GitLogBrowserDialog import GitLogBrowserDialog
+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)
+"""
+if self.reflogBrowser is None:
+from .GitReflogBrowserDialog import GitReflogBrowserDialog
+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)
+"""
+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:
+from .GitDiffDialog import GitDiffDialog
+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)
+"""
+if self.status is None:
+from .GitStatusDialog import GitStatusDialog
+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 = dname
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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
+"""
+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 = dname
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return False
+project = ericApp().getObject("Project")
+names = [project.getRelativePath(nam) for nam in names]
+if names[0]:
+from UI.DeleteFilesConfirmationDialog import (
+DeleteFilesConfirmationDialog
+)
+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)
+"""
+dname, fname = self.splitPath(name)
+# find the root of the repo
+repodir = dname
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return
+from .GitMergeDialog import GitMergeDialog
+dlg = GitMergeDialog(self.gitGetTagsList(repodir),
+self.gitGetBranchesList(repodir, withMaster=True),
+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)
+"""
+dname, fname = self.splitPath(name)
+# find the root of the repo
+repodir = dname
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return False
+from .GitRevisionSelectionDialog import GitRevisionSelectionDialog
+dlg = GitRevisionSelectionDialog(
+self.gitGetTagsList(repodir),
+self.gitGetBranchesList(repodir),
+trackingBranchesList=self.gitGetBranchesList(
+repodir, remotes=True),
+noneLabel=self.tr("Master 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.isdir(os.path.join(dname, self.adminDir)):
+return self.canBeCommitted
+if name in self.statusCache:
+return self.statusCache[name]
+# find the root of the repo
+repodir = dname
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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):
+"""
+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 = dname
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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(Utilities.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 = name
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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):
+"""
+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__/",
+"*.DS_Store",
+]
+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):
+"""
+Public method to show the output of the git blame command.
+@param name file name to show the annotations for (string)
+"""
+if self.blame is None:
+from .GitBlameDialog import GitBlameDialog
+self.blame = GitBlameDialog(self)
+self.blame.show()
+self.blame.raise_()
+self.blame.start(name)
+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)
+"""
+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 = dname
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return
+from .GitRevisionsSelectionDialog import GitRevisionsSelectionDialog
+dlg = GitRevisionsSelectionDialog(self.gitGetTagsList(repodir),
+self.gitGetBranchesList(repodir))
+if dlg.exec() == QDialog.DialogCode.Accepted:
+revisions = dlg.getRevisions()
+if self.diff is None:
+from .GitDiffDialog import GitDiffDialog
+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.splitPath(name)[0]
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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
+"""
+if isinstance(name, list):
+raise ValueError("Wrong parameter type")
+if extended:
+# find the root of the repo
+repodir = self.splitPath(name)[0]
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return
+from .GitRevisionsSelectionDialog import (
+GitRevisionsSelectionDialog
+)
+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:
+from UI.CompareDialog import CompareDialog
+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)
+"""
+# find the root of the repo
+repodir = self.splitPath(name)[0]
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return
+from .GitFetchDialog import GitFetchDialog
+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)
+"""
+# find the root of the repo
+repodir = self.splitPath(name)[0]
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return False
+from .GitPullDialog import GitPullDialog
+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)
+"""
+# find the root of the repo
+repodir = self.splitPath(name)[0]
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return
+from .GitPushDialog import GitPushDialog
+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 = dname
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return
+import sys
+editor = sys.argv[0].replace(".py", "_editor.py")
+env = {"GIT_EDITOR": "{0} {1}".format(
+Globals.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 = dname
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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)
+"""
+# find the root of the repo
+repodir = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return
+from .GitPatchFilesDialog import GitPatchFilesDialog
+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)
+"""
+if self.patchStatisticsDialog is None:
+from .GitPatchStatisticsDialog import GitPatchStatisticsDialog
+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)
+"""
+dname, fname = self.splitPath(name)
+# find the root of the repo
+repodir = dname
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return False
+from .GitTagDialog import GitTagDialog
+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, withType=False):
+"""
+Public method to get the list of tags.
+@param repodir directory name of the repository (string)
+@param withType flag indicating to get the tag type as well (boolean)
+@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)
+"""
+if self.tagbranchList is None:
+from .GitTagBranchListDialog import GitTagBranchListDialog
+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, withMaster=False, allBranches=False,
+remotes=False):
+"""
+Public method to get the list of branches.
+@param repodir directory name of the repository (string)
+@param withMaster flag indicating to get 'master' 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 != "master" or withMaster) 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)
+"""
+dname, fname = self.splitPath(name)
+# find the root of the repo
+repodir = dname
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return False, False
+from .GitBranchDialog import GitBranchDialog
+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)
+"""
+dname, fname = self.splitPath(name)
+# find the root of the repo
+repodir = dname
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return
+from .GitBranchPushDialog import GitBranchPushDialog
+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 = dname
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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)
+"""
+# find the root of the repo
+repodir = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return
+from .GitBundleDialog import GitBundleDialog
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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)
+"""
+# find the root of the repo
+repodir = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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)
+from .GitApplyBundleDataDialog import GitApplyBundleDataDialog
+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)
+"""
+# find the root of the repo
+repodir = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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)
+from .GitApplyBundleDataDialog import GitApplyBundleDataDialog
+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
+"""
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return False
+res = False
+rev = ""
+if subcommand in ("good", "bad", "skip", "reset"):
+showBranches = subcommand == "reset"
+showHead = subcommand == "reset"
+from .GitRevisionSelectionDialog import GitRevisionSelectionDialog
+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":
+from .GitBisectStartDialog import GitBisectStartDialog
+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)
+"""
+if self.bisectlogBrowser is None:
+from .GitBisectLogBrowserDialog import GitBisectLogBrowserDialog
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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)
+"""
+if self.remotesDialog is None:
+from .GitRemoteRepositoriesDialog import (
+GitRemoteRepositoriesDialog
+)
+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)
+"""
+# find the root of the repo
+repodir = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return
+from .GitAddRemoteDialog import GitAddRemoteDialog
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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
+"""
+# find the root of the repo
+repodir = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return
+if not remoteUrl:
+remoteUrl = self.gitGetRemoteUrl(repodir, remoteName)
+from .GitChangeRemoteUrlDialog import GitChangeRemoteUrlDialog
+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
+"""
+# find the root of the repo
+repodir = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return
+if not remoteUrl:
+remoteUrl = self.gitGetRemoteUrl(repodir, remoteName)
+from .GitRemoteCredentialsDialog import GitRemoteCredentialsDialog
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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)
+"""
+if self.describeDialog is None:
+from .GitDescribeDialog import GitDescribeDialog
+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)
+"""
+# find the root of the repo
+repodir = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return False
+res = False
+from .GitCherryPickDialog import GitCherryPickDialog
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return False
+import sys
+editor = sys.argv[0].replace(".py", "_editor.py")
+env = {"GIT_EDITOR": "{0} {1}".format(
+Globals.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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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)
+"""
+# find the root of the repo
+repodir = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return False
+res = False
+from .GitStashDataDialog import GitStashDataDialog
+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)
+"""
+if self.stashBrowser is None:
+from .GitStashBrowserDialog import GitStashBrowserDialog
+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)
+"""
+# find the root of the repo
+repodir = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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:
+from .GitDiffDialog import GitDiffDialog
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return
+cfgFile = os.path.join(repodir, self.adminDir, "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 .GitUtilities import getConfigPath
+cfgFile = getConfigPath()
+if not os.path.exists(cfgFile):
+from .GitUserConfigDataDialog import GitUserConfigDataDialog
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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)
+"""
+# find the root of the repo
+repodir = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return
+from .GitArchiveDataDialog import GitArchiveDataDialog
+dlg = GitArchiveDataDialog(
+self.gitGetTagsList(repodir),
+self.gitGetBranchesList(repodir, withMaster=True),
+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 = Utilities.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
+"""
+# find the root of the repo
+repodir = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return
+from .GitSubmoduleAddDialog import GitSubmoduleAddDialog
+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
+"""
+# find the root of the repo
+repodir = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return
+submodulesList = self.__gitSubmodulesList(repodir)
+if submodulesList:
+from .GitSubmodulesListDialog import GitSubmodulesListDialog
+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)
+"""
+paths = [submodule["path"]
+for submodule in self.__gitSubmodulesList(repodir)]
+from .GitListDialog import GitListDialog
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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
+"""
+# find the root of the repo
+repodir = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return
+paths = [submodule["path"]
+for submodule in self.__gitSubmodulesList(repodir)]
+from .GitSubmodulesDeinitDialog import GitSubmodulesDeinitDialog
+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 = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+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
+"""
+# find the root of the repo
+repodir = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return
+paths = [submodule["path"]
+for submodule in self.__gitSubmodulesList(repodir)]
+from .GitSubmodulesUpdateOptionsDialog import (
+GitSubmodulesUpdateOptionsDialog
+)
+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
+"""
+# find the root of the repo
+repodir = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return
+paths = [submodule["path"]
+for submodule in self.__gitSubmodulesList(repodir)]
+from .GitSubmodulesSyncDialog import GitSubmodulesSyncDialog
+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
+"""
+if self.submoduleStatusDialog is None:
+from .GitSubmodulesStatusDialog import GitSubmodulesStatusDialog
+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
+"""
+# find the root of the repo
+repodir = projectDir
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if os.path.splitdrive(repodir)[1] == os.sep:
+return
+paths = [submodule["path"]
+for submodule in self.__gitSubmodulesList(repodir)]
+from .GitSubmodulesSummaryOptionsDialog import (
+GitSubmodulesSummaryOptionsDialog
+)
+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 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)

Mercurial Repositories > eric / file comparison

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

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