eric: comparison src/eric7/Plugins/VcsPlugins/vcsMercurial/hg.py

-:3fc8dfeb6ebe
+:b99e7fd55fd3
+# -*- coding: utf-8 -*-
+# Copyright (c) 2010 - 2022 Detlev Offenbach <detlev@die-offenbachs.de>
+#
+"""
+Module implementing the version control systems interface to Mercurial.
+"""
+import os
+import shutil
+import contextlib
+import pathlib
+from PyQt6.QtCore import pyqtSignal, QFileSystemWatcher, QCoreApplication
+from PyQt6.QtWidgets import QApplication, QDialog, QInputDialog
+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 .HgDialog import HgDialog
+from .HgClient import HgClient
+import Preferences
+import Utilities
+class Hg(VersionControl):
+"""
+Class implementing the version control systems interface to Mercurial.
+@signal committed() emitted after the commit action has completed
+@signal activeExtensionsChanged() emitted when the list of active
+extensions has changed
+@signal iniFileChanged() emitted when a Mercurial/repo configuration file
+has changed
+"""
+committed = pyqtSignal()
+activeExtensionsChanged = pyqtSignal()
+iniFileChanged = pyqtSignal()
+IgnoreFileName = ".hgignore"
+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.tagsList = []
+self.branchesList = []
+self.allTagsBranchesList = []
+self.bookmarksList = []
+self.showedTags = False
+self.showedBranches = False
+self.tagTypeList = [
+'tags',
+'branches',
+]
+self.commandHistory = []
+if "HG_ASP_DOT_NET_HACK" in os.environ:
+self.adminDir = '_hg'
+else:
+self.adminDir = '.hg'
+self.logBrowser = None
+self.logBrowserIncoming = None
+self.logBrowserOutgoing = None
+self.diff = None
+self.sbsDiff = None
+self.status = None
+self.summary = None
+self.tagbranchList = None
+self.annotate = None
+self.repoEditor = None
+self.serveDlg = None
+self.bookmarksListDlg = None
+self.bookmarksInOutDlg = None
+self.conflictsDlg = None
+self.bundleFile = None
+self.__lastChangeGroupPath = None
+self.statusCache = {}
+self.__commitData = {}
+self.__commitDialog = None
+self.__forgotNames = []
+self.__activeExtensions = []
+from .HgUtilities import getConfigPath
+self.__iniWatcher = QFileSystemWatcher(self)
+self.__iniWatcher.fileChanged.connect(self.__iniFileChanged)
+cfgFile = getConfigPath()
+if os.path.exists(cfgFile):
+self.__iniWatcher.addPath(cfgFile)
+self.__client = None
+self.__createClient()
+self.__projectHelper = None
+self.__repoDir = ""
+self.__repoIniFile = ""
+self.__defaultConfigured = False
+self.__defaultPushConfigured = False
+# instantiate the extensions
+from .QueuesExtension.queues import Queues
+from .PurgeExtension.purge import Purge
+from .GpgExtension.gpg import Gpg
+from .RebaseExtension.rebase import Rebase
+from .ShelveExtension.shelve import Shelve
+from .LargefilesExtension.largefiles import Largefiles
+from .StripExtension.strip import Strip
+from .HisteditExtension.histedit import Histedit
+from .CloseheadExtension.closehead import Closehead
+self.__extensions = {
+"mq": Queues(self),
+"purge": Purge(self),
+"gpg": Gpg(self),
+"rebase": Rebase(self),
+"shelve": Shelve(self),
+"largefiles": Largefiles(self),
+"strip": Strip(self),
+"histedit": Histedit(self),
+"closehead": Closehead(self),
+}
+def getPlugin(self):
+"""
+Public method to get a reference to the plugin object.
+@return reference to the plugin object (VcsMercurialPlugin)
+"""
+return self.__plugin
+def getEncoding(self):
+"""
+Public method to get the encoding to be used by Mercurial.
+@return encoding (string)
+"""
+return self.__plugin.getPreferences("Encoding")
+def vcsShutdown(self):
+"""
+Public method used to shutdown the Mercurial interface.
+"""
+if self.logBrowser is not None:
+self.logBrowser.close()
+if self.logBrowserIncoming is not None:
+self.logBrowserIncoming.close()
+if self.logBrowserOutgoing is not None:
+self.logBrowserOutgoing.close()
+if self.diff is not None:
+self.diff.close()
+if self.sbsDiff is not None:
+self.sbsDiff.close()
+if self.status is not None:
+self.status.close()
+if self.summary is not None:
+self.summary.close()
+if self.tagbranchList is not None:
+self.tagbranchList.close()
+if self.annotate is not None:
+self.annotate.close()
+if self.serveDlg is not None:
+self.serveDlg.close()
+if self.bookmarksListDlg is not None:
+self.bookmarksListDlg.close()
+if self.bookmarksInOutDlg is not None:
+self.bookmarksInOutDlg.close()
+if self.conflictsDlg is not None:
+self.conflictsDlg.close()
+if self.bundleFile and os.path.exists(self.bundleFile):
+os.remove(self.bundleFile)
+# shut down the project helpers
+if self.__projectHelper is not None:
+self.__projectHelper.shutdown()
+# shut down the extensions
+for extension in self.__extensions.values():
+extension.shutdown()
+# shut down the client
+self.__client and self.__client.stopServer()
+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]
+self.addArguments(args, self.__plugin.getGlobalOptions())
+return args
+def vcsExists(self):
+"""
+Public method used to test for the presence of the hg executable.
+@return flag indicating the existence (boolean) and an error message
+(string)
+"""
+from .HgUtilities import hgVersion
+self.versionStr, self.version, errMsg = hgVersion(self.__plugin)
+hgExists = errMsg == ""
+if hgExists:
+self.__getExtensionsInfo()
+return hgExists, errMsg
+def vcsInit(self, vcsDir, noDialog=False):
+"""
+Public method used to initialize the mercurial repository.
+The initialization is done, when a project is converted into a
+Mercurial 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 Mercurial 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 = HgDialog(self.tr('Creating Mercurial repository'), self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+status = dia.normalExit()
+if status:
+self.stopClient()
+self.__repoDir = projectDir
+ignoreName = os.path.join(projectDir, Hg.IgnoreFileName)
+if not os.path.exists(ignoreName):
+status = self.hgCreateIgnoreFile(projectDir)
+if status and addAll:
+args = self.initCommand("commit")
+args.append('--addremove')
+args.append('--message')
+args.append(msg)
+dia = HgDialog(
+self.tr('Initial commit to Mercurial repository'),
+self)
+res = dia.startProcess(args)
+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 Mercurial 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
+try:
+rev = vcsDataDict["revision"]
+except KeyError:
+rev = None
+vcsUrl = self.hgNormalizeURL(vcsDataDict["url"])
+args = self.initCommand("clone")
+if rev:
+args.append("--rev")
+args.append(rev)
+if vcsDataDict["largefiles"]:
+args.append("--all-largefiles")
+args.append(vcsUrl)
+args.append(projectDir)
+if noDialog:
+out, err = self.__client.runcommand(args)
+return err == ""
+else:
+dia = HgDialog(
+self.tr('Cloning project from a Mercurial 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 Mercurial 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, Hg.IgnoreFileName)):
+os.remove(os.path.join(projectDir, Hg.IgnoreFileName))
+return status
+def vcsCommit(self, name, message, noDialog=False, closeBranch=False,
+mq=False, merge=False):
+"""
+Public method used to make the change of a file/directory permanent
+in the Mercurial 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
+@param closeBranch flag indicating a close branch commit (boolean)
+@param mq flag indicating a queue commit (boolean)
+@param merge flag indicating a merge commit (boolean)
+"""
+msg = message
+if mq or merge:
+# ensure dialog is shown for a queue commit
+noDialog = False
+if not noDialog:
+# call CommitDialog and get message from there
+if self.__commitDialog is None:
+from .HgCommitDialog import HgCommitDialog
+self.__commitDialog = HgCommitDialog(self, msg, mq, merge,
+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"] = msg
+self.__commitData["noDialog"] = noDialog
+self.__commitData["closeBranch"] = closeBranch
+self.__commitData["mq"] = mq
+self.__commitData["merge"] = merge
+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"]
+closeBranch = self.__commitData["closeBranch"]
+mq = self.__commitData["mq"]
+merge = self.__commitData["merge"]
+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, amend, commitSubrepositories, author,
+dateTime) = self.__commitDialog.getCommitData()
+self.__commitDialog.deleteLater()
+self.__commitDialog = None
+if amend and not msg:
+msg = self.__getMostRecentCommitMessage()
+else:
+amend = False
+commitSubrepositories = False
+author = ""
+dateTime = ""
+if not msg and not amend:
+msg = '***'
+args = self.initCommand("commit")
+args.append("-v")
+if mq:
+args.append("--mq")
+elif merge:
+if author:
+args.append("--user")
+args.append(author)
+if dateTime:
+args.append("--date")
+args.append(dateTime)
+else:
+if closeBranch:
+args.append("--close-branch")
+if amend:
+args.append("--amend")
+if commitSubrepositories:
+args.append("--subrepos")
+if author:
+args.append("--user")
+args.append(author)
+if dateTime:
+args.append("--date")
+args.append(dateTime)
+if msg:
+args.append("--message")
+args.append(msg)
+if isinstance(name, list):
+self.addArguments(args, name)
+else:
+args.append(name)
+dia = HgDialog(
+self.tr('Committing changes to Mercurial repository'),
+self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+self.committed.emit()
+if self.__forgotNames:
+model = ericApp().getObject("Project").getModel()
+for name in self.__forgotNames:
+model.updateVCSStatus(name)
+self.__forgotNames = []
+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 __getMostRecentCommitMessage(self):
+"""
+Private method to get the most recent commit message.
+Note: This message is extracted from the parent commit of the
+working directory.
+@return most recent commit message
+@rtype str
+"""
+args = self.initCommand("log")
+args.append("--rev")
+args.append(".")
+args.append('--template')
+args.append('{desc}')
+output, error = self.__client.runcommand(args)
+return output
+def vcsUpdate(self, name=None, noDialog=False, revision=None):
+"""
+Public method used to update a file/directory with the Mercurial
+repository.
+@param name file/directory name to be updated (not used)
+@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("update")
+if "-v" not in args and "--verbose" not in args:
+args.append("-v")
+if revision:
+args.append("-r")
+args.append(revision)
+if noDialog:
+out, err = self.__client.runcommand(args)
+res = False
+else:
+dia = HgDialog(self.tr(
+'Synchronizing with the Mercurial repository'),
+self)
+res = dia.startProcess(args)
+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 Mercurial 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):
+self.addArguments(args, name)
+else:
+args.append(name)
+if noDialog:
+out, err = self.__client.runcommand(args)
+else:
+dia = HgDialog(
+self.tr(
+'Adding files/directories to the Mercurial repository'),
+self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+def vcsAddBinary(self, name, isDir=False):
+"""
+Public method used to add a file/directory in binary mode to the
+Mercurial 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 Mercurial
+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):
+"""
+Public method used to remove a file/directory from the Mercurial
+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
+@return flag indicating successfull operation (boolean)
+"""
+args = self.initCommand("remove")
+args.append("-v")
+if noDialog and '--force' not in args:
+args.append('--force')
+if isinstance(name, list):
+self.addArguments(args, name)
+else:
+args.append(name)
+if noDialog:
+out, err = self.__client.runcommand(args)
+res = err == ""
+else:
+dia = HgDialog(
+self.tr(
+'Removing files/directories from the Mercurial'
+' repository'),
+self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+res = dia.normalExitWithoutErrors()
+return res
+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 successfull operation (boolean)
+"""
+isDir = os.path.isdir(name)
+res = False
+if noDialog:
+if target is None:
+return False
+force = True
+accepted = True
+else:
+from .HgCopyDialog import HgCopyDialog
+dlg = HgCopyDialog(name, None, True)
+accepted = dlg.exec() == QDialog.DialogCode.Accepted
+if accepted:
+target, force = dlg.getData()
+if accepted:
+args = self.initCommand("rename")
+args.append("-v")
+if force:
+args.append('--force')
+args.append(name)
+args.append(target)
+if noDialog:
+out, err = self.__client.runcommand(args)
+res = err == ""
+else:
+dia = HgDialog(self.tr('Renaming {0}').format(name), self)
+res = dia.startProcess(args)
+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 vcsDiff(self, name):
+"""
+Public method used to view the difference of a file/directory to the
+Mercurial 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 .HgDiffDialog import HgDiffDialog
+self.diff = HgDiffDialog(self)
+self.diff.show()
+self.diff.raise_()
+QApplication.processEvents()
+self.diff.start(name, refreshable=True)
+def vcsStatus(self, name):
+"""
+Public method used to view the status of files/directories in the
+Mercurial repository.
+@param name file/directory name(s) to show the status of
+(string or list of strings)
+"""
+if self.status is None:
+from .HgStatusDialog import HgStatusDialog
+self.status = HgStatusDialog(self)
+self.status.show()
+self.status.raise_()
+self.status.start(name)
+def hgSummary(self, mq=False, largefiles=False):
+"""
+Public method used to show some summary information of the
+working directory state.
+@param mq flag indicating to show the queue status as well (boolean)
+@param largefiles flag indicating to show the largefiles status as
+well (boolean)
+"""
+if self.summary is None:
+from .HgSummaryDialog import HgSummaryDialog
+self.summary = HgSummaryDialog(self)
+self.summary.show()
+self.summary.raise_()
+self.summary.start(mq=mq, largefiles=largefiles)
+def vcsTag(self, name=None, revision=None, tagName=None):
+"""
+Public method used to set/remove a tag in the Mercurial repository.
+@param name file/directory name to determine the repo root from
+(string)
+@param revision revision to set tag for (string)
+@param tagName name of the tag (string)
+@return flag indicating a performed tag action (boolean)
+"""
+from .HgTagDialog import HgTagDialog
+dlg = HgTagDialog(self.hgGetTagsList(withType=True),
+revision, tagName)
+if dlg.exec() == QDialog.DialogCode.Accepted:
+tag, revision, tagOp, force = dlg.getParameters()
+else:
+return False
+args = self.initCommand("tag")
+msgPart = ""
+if tagOp in [HgTagDialog.CreateLocalTag, HgTagDialog.DeleteLocalTag]:
+args.append('--local')
+msgPart = "local "
+else:
+msgPart = "global "
+if tagOp in [HgTagDialog.DeleteGlobalTag, HgTagDialog.DeleteLocalTag]:
+args.append('--remove')
+if (
+tagOp in [
+HgTagDialog.CreateGlobalTag, HgTagDialog.CreateLocalTag] and
+revision
+):
+args.append("--rev")
+args.append(revision)
+if force:
+args.append("--force")
+args.append('--message')
+if tagOp in [HgTagDialog.CreateGlobalTag, HgTagDialog.CreateLocalTag]:
+tag = tag.strip().replace(" ", "_")
+args.append("Created {1}tag <{0}>.".format(tag, msgPart))
+else:
+args.append("Removed {1}tag <{0}>.".format(tag, msgPart))
+args.append(tag)
+dia = HgDialog(self.tr('Tagging in the Mercurial repository'),
+self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+return True
+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("revert")
+if not self.getPlugin().getPreferences("CreateBackup"):
+args.append("--no-backup")
+args.append("-v")
+if isinstance(name, list):
+self.addArguments(args, name)
+names = name[:]
+else:
+args.append(name)
+names = [name]
+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 = HgDialog(self.tr('Reverting changes'), self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+res = dia.hasAddOrDelete()
+self.checkVCSStatus()
+else:
+res = False
+return res
+def vcsMerge(self, name, rev=""):
+"""
+Public method used to merge a URL/revision into the local project.
+@param name file/directory name to be merged
+@type str
+@param rev revision to merge with
+@type str
+"""
+if not rev:
+from .HgMergeDialog import HgMergeDialog
+dlg = HgMergeDialog(self.hgGetTagsList(),
+self.hgGetBranchesList(),
+self.hgGetBookmarksList())
+if dlg.exec() == QDialog.DialogCode.Accepted:
+rev, force = dlg.getParameters()
+else:
+return
+else:
+force = False
+args = self.initCommand("merge")
+if force:
+args.append("--force")
+if self.getPlugin().getPreferences("InternalMerge"):
+args.append("--tool")
+args.append("internal:merge")
+if rev:
+args.append("--rev")
+args.append(rev)
+dia = HgDialog(self.tr('Merging'), self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+self.checkVCSStatus()
+def hgReMerge(self, name):
+"""
+Public method used to merge a URL/revision into the local project.
+@param name file/directory name to be merged (string)
+"""
+args = self.initCommand("resolve")
+if self.getPlugin().getPreferences("InternalMerge"):
+args.append("--tool")
+args.append("internal:merge")
+if isinstance(name, list):
+self.addArguments(args, name)
+names = name[:]
+else:
+args.append(name)
+names = [name]
+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("Re-Merge"),
+self.tr(
+"Do you really want to re-merge these files"
+" or directories?"),
+names)
+yes = dlg.exec() == QDialog.DialogCode.Accepted
+else:
+yes = EricMessageBox.yesNo(
+None,
+self.tr("Re-Merge"),
+self.tr("""Do you really want to re-merge the project?"""))
+if yes:
+dia = HgDialog(self.tr('Re-Merging').format(name), self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+self.checkVCSStatus()
+def vcsSwitch(self, name):
+"""
+Public method used to switch a working directory to a different
+revision.
+@param name directory name to be switched (string)
+@return flag indicating, that the switch contained an add
+or delete (boolean)
+"""
+from .HgRevisionSelectionDialog import HgRevisionSelectionDialog
+dlg = HgRevisionSelectionDialog(
+self.hgGetTagsList(),
+self.hgGetBranchesList(),
+bookmarksList=self.hgGetBookmarksList(),
+noneLabel=self.tr("Current branch tip")
+)
+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 file or directory name to check
+@type str
+@return a combination of canBeCommited and canBeAdded
+@rtype int
+"""
+if name.endswith(os.sep):
+name = name[:-1]
+name = os.path.normcase(name)
+if (
+os.path.isdir(name) and
+os.path.isdir(os.path.join(name, self.adminDir))
+):
+return self.canBeCommitted
+if name in self.statusCache:
+return self.statusCache[name]
+args = self.initCommand("status")
+args.append('--all')
+args.append('--noninteractive')
+output, error = self.__client.runcommand(args)
+if output:
+repodir = self.getClient().getRepository()
+for line in output.splitlines():
+if len(line) > 2 and line[0] in "MARC!?I" and line[1] == " ":
+flag, path = line.split(" ", 1)
+absname = Utilities.normcasepath(
+os.path.join(repodir, path))
+if flag not in "?I" and absname == name:
+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)
+found = False
+for name in list(self.statusCache.keys()):
+if name in names:
+found = True
+names[name] = self.statusCache[name]
+if not found:
+args = self.initCommand("status")
+args.append('--all')
+args.append('--noninteractive')
+output, error = self.__client.runcommand(args)
+if output:
+repoPath = self.getClient().getRepository()
+dirs = [x for x in names.keys() if os.path.isdir(x)]
+for line in output.splitlines():
+if line and line[0] in "MARC!?I":
+flag, path = line.split(" ", 1)
+name = os.path.normcase(os.path.join(repoPath, path))
+dirName = os.path.dirname(name)
+if name.startswith(dname) and flag not in "?I":
+if name in names:
+names[name] = self.canBeCommitted
+if dirName in names:
+names[dirName] = self.canBeCommitted
+if dirs:
+for d in dirs:
+if name.startswith(d):
+names[d] = self.canBeCommitted
+dirs.remove(d)
+break
+if flag not in "?I":
+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 'Mercurial' (string)
+"""
+return "Mercurial"
+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, Hg.IgnoreFileName)
+if not os.path.exists(ignoreName):
+self.hgCreateIgnoreFile(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.getPlugin().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 mercurial commands.
+@param name directory name of the working directory (string)
+"""
+from .HgCommandDialog import HgCommandDialog
+dlg = HgCommandDialog(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)
+dia = HgDialog(self.tr('Mercurial command'), self)
+res = dia.startProcess(args)
+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 (HgOptionsDialog)
+"""
+from .HgOptionsDialog import HgOptionsDialog
+return HgOptionsDialog(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
+(HgNewProjectOptionsDialog)
+"""
+from .HgNewProjectOptionsDialog import HgNewProjectOptionsDialog
+return HgNewProjectOptionsDialog(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)
+"""
+args = self.initCommand("parents")
+args.append('--template')
+args.append('{rev}:{node|short}@@@{tags}@@@{author|xmlescape}@@@'
+'{date|isodate}@@@{branches}@@@{bookmarks}\n')
+output, error = self.__client.runcommand(args)
+infoBlock = []
+if output:
+for index, line in enumerate(output.splitlines(), start=1):
+(changeset, tags, author, date, branches,
+bookmarks) = line.split("@@@")
+cdate, ctime = date.split()[:2]
+info = []
+info.append(QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Parent #{0}</b></td><td></td></tr>\n"""
+"""<tr><td><b>Changeset</b></td><td>{1}</td></tr>""")
+.format(index, changeset))
+if tags:
+info.append(QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Tags</b></td><td>{0}</td></tr>""")
+.format('<br/>'.join(tags.split())))
+if bookmarks:
+info.append(QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Bookmarks</b></td><td>{0}</td></tr>""")
+.format('<br/>'.join(bookmarks.split())))
+if branches:
+info.append(QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Branches</b></td><td>{0}</td></tr>""")
+.format('<br/>'.join(branches.split())))
+info.append(QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Last author</b></td><td>{0}</td></tr>\n"""
+"""<tr><td><b>Committed date</b></td><td>{1}</td></tr>\n"""
+"""<tr><td><b>Committed time</b></td><td>{2}</td></tr>""")
+.format(author, cdate, ctime))
+infoBlock.append("\n".join(info))
+infoStr = (
+"""<tr></tr>{0}""".format("<tr></tr>".join(infoBlock))
+if infoBlock else
+""
+)
+url = ""
+args = self.initCommand("showconfig")
+args.append('paths.default')
+output, error = self.__client.runcommand(args)
+url = output.splitlines()[0].strip() if output else ""
+return QCoreApplication.translate(
+'mercurial',
+"""<h3>Repository information</h3>\n"""
+"""<p><table>\n"""
+"""<tr><td><b>Mercurial V.</b></td><td>{0}</td></tr>\n"""
+"""<tr></tr>\n"""
+"""<tr><td><b>URL</b></td><td>{1}</td></tr>\n"""
+"""{2}"""
+"""</table></p>\n"""
+).format(self.versionStr, url, 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
+###########################################################################
+## Private Mercurial specific methods are below.
+###########################################################################
+def hgNormalizeURL(self, url):
+"""
+Public method to normalize a url for Mercurial.
+@param url url string (string)
+@return properly normalized url for mercurial (string)
+"""
+url = url.replace('\\', '/')
+if url.endswith('/'):
+url = url[:-1]
+urll = url.split('//')
+return "{0}//{1}".format(urll[0], '/'.join(urll[1:]))
+def hgCopy(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 .HgCopyDialog import HgCopyDialog
+dlg = HgCopyDialog(name)
+res = False
+if dlg.exec() == QDialog.DialogCode.Accepted:
+target, force = dlg.getData()
+args = self.initCommand("copy")
+args.append("-v")
+args.append(name)
+args.append(target)
+dia = HgDialog(
+self.tr('Copying {0}').format(name), self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+res = dia.normalExit()
+if (
+res and
+target.startswith(project.getProjectPath())
+):
+if os.path.isdir(name):
+project.copyDirectory(name, target)
+else:
+project.appendFile(target)
+return res
+def hgGetTagsList(self, withType=False):
+"""
+Public method to get the list of tags.
+@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("tags")
+args.append('--verbose')
+output, error = self.__client.runcommand(args)
+tagsList = []
+if output:
+for line in output.splitlines():
+li = line.strip().split()
+if li[-1][0] in "1234567890":
+# last element is a rev:changeset
+del li[-1]
+isLocal = False
+else:
+del li[-2:]
+isLocal = True
+name = " ".join(li)
+if name not in ["tip", "default"]:
+if withType:
+tagsList.append((name, isLocal))
+else:
+tagsList.append(name)
+if withType:
+return tagsList
+else:
+if tagsList:
+self.tagsList = tagsList
+return self.tagsList[:]
+def hgGetBranchesList(self):
+"""
+Public method to get the list of branches.
+@return list of branches (list of string)
+"""
+args = self.initCommand("branches")
+args.append('--closed')
+output, error = self.__client.runcommand(args)
+if output:
+self.branchesList = []
+for line in output.splitlines():
+li = line.strip().split()
+if li[-1][0] in "1234567890":
+# last element is a rev:changeset
+del li[-1]
+else:
+del li[-2:]
+name = " ".join(li)
+if name not in ["tip", "default"]:
+self.branchesList.append(name)
+return self.branchesList[:]
+def hgListTagBranch(self, tags=True):
+"""
+Public method used to list the available tags or branches.
+@param tags flag indicating listing of branches or tags
+(False = branches, True = tags)
+"""
+from .HgTagBranchListDialog import HgTagBranchListDialog
+self.tagbranchList = HgTagBranchListDialog(self)
+self.tagbranchList.show()
+if tags:
+if not self.showedTags:
+self.showedTags = True
+allTagsBranchesList = self.allTagsBranchesList
+else:
+self.tagsList = []
+allTagsBranchesList = None
+self.tagbranchList.start(
+tags, self.tagsList, allTagsBranchesList)
+else:
+if not self.showedBranches:
+self.showedBranches = True
+allTagsBranchesList = self.allTagsBranchesList
+else:
+self.branchesList = []
+allTagsBranchesList = None
+self.tagbranchList.start(
+tags, self.branchesList, self.allTagsBranchesList)
+def hgAnnotate(self, name):
+"""
+Public method to show the output of the hg annotate command.
+@param name file name to show the annotations for (string)
+"""
+if self.annotate is None:
+from .HgAnnotateDialog import HgAnnotateDialog
+self.annotate = HgAnnotateDialog(self)
+self.annotate.show()
+self.annotate.raise_()
+self.annotate.start(name)
+def hgExtendedDiff(self, name):
+"""
+Public method used to view the difference of a file/directory to the
+Mercurial 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)
+"""
+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
+from .HgRevisionsSelectionDialog import HgRevisionsSelectionDialog
+dlg = HgRevisionsSelectionDialog(
+self.hgGetTagsList(),
+self.hgGetBranchesList(),
+bookmarksList=self.hgGetBookmarksList()
+)
+if dlg.exec() == QDialog.DialogCode.Accepted:
+revisions = dlg.getRevisions()
+if self.diff is None:
+from .HgDiffDialog import HgDiffDialog
+self.diff = HgDiffDialog(self)
+self.diff.show()
+self.diff.raise_()
+self.diff.start(name, revisions)
+def __hgGetFileForRevision(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)
+"""
+args = self.initCommand("cat")
+if rev:
+args.append("--rev")
+args.append(rev)
+args.append(name)
+output, error = self.__client.runcommand(args)
+# 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 Mercurial
+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:
+from .HgRevisionsSelectionDialog import HgRevisionsSelectionDialog
+dlg = HgRevisionsSelectionDialog(
+self.hgGetTagsList(),
+self.hgGetBranchesList(),
+bookmarksList=self.hgGetBookmarksList()
+)
+if dlg.exec() == QDialog.DialogCode.Accepted:
+rev1, rev2 = dlg.getRevisions()
+else:
+return
+elif revisions:
+rev1, rev2 = revisions[0], revisions[1]
+else:
+rev1, rev2 = "", ""
+output1, error = self.__hgGetFileForRevision(name, rev=rev1)
+if error:
+EricMessageBox.critical(
+self.__ui,
+self.tr("Mercurial Side-by-Side Difference"),
+error)
+return
+name1 = "{0} (rev. {1})".format(name, rev1 and rev1 or ".")
+if rev2:
+output2, error = self.__hgGetFileForRevision(name, rev=rev2)
+if error:
+EricMessageBox.critical(
+self.__ui,
+self.tr("Mercurial 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()
+name2 = "{0} (Work)".format(name)
+except OSError:
+EricMessageBox.critical(
+self.__ui,
+self.tr("Mercurial 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 vcsLogBrowser(self, name=None, isFile=False):
+"""
+Public method used to browse the log of a file/directory from the
+Mercurial 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 name == self.getClient().getRepository():
+name = None
+if self.logBrowser is None:
+from .HgLogBrowserDialog import HgLogBrowserDialog
+self.logBrowser = HgLogBrowserDialog(self)
+self.logBrowser.show()
+self.logBrowser.raise_()
+self.logBrowser.start(name=name, isFile=isFile)
+def hgIncoming(self):
+"""
+Public method used to view the log of incoming changes from the
+Mercurial repository.
+"""
+if self.logBrowserIncoming is None:
+from .HgLogBrowserDialog import HgLogBrowserDialog
+self.logBrowserIncoming = HgLogBrowserDialog(
+self, mode="incoming")
+self.logBrowserIncoming.show()
+self.logBrowserIncoming.raise_()
+self.logBrowserIncoming.start()
+def hgOutgoing(self):
+"""
+Public method used to view the log of outgoing changes from the
+Mercurial repository.
+"""
+if self.logBrowserOutgoing is None:
+from .HgLogBrowserDialog import HgLogBrowserDialog
+self.logBrowserOutgoing = HgLogBrowserDialog(
+self, mode="outgoing")
+self.logBrowserOutgoing.show()
+self.logBrowserOutgoing.raise_()
+self.logBrowserOutgoing.start()
+def hgPull(self, revisions=None):
+"""
+Public method used to pull changes from a remote Mercurial repository.
+@param revisions list of revisions to be pulled
+@type list of str
+@return flag indicating, that the update contained an add
+or delete
+@rtype bool
+"""
+if (
+self.getPlugin().getPreferences("PreferUnbundle") and
+self.bundleFile and
+os.path.exists(self.bundleFile) and
+revisions is None
+):
+command = "unbundle"
+title = self.tr('Apply changegroups')
+else:
+command = "pull"
+title = self.tr('Pulling from a remote Mercurial repository')
+args = self.initCommand(command)
+args.append('-v')
+if self.getPlugin().getPreferences("PullUpdate"):
+args.append('--update')
+if command == "unbundle":
+args.append(self.bundleFile)
+if revisions:
+for rev in revisions:
+args.append("--rev")
+args.append(rev)
+dia = HgDialog(title, self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+res = dia.hasAddOrDelete()
+if (
+self.bundleFile and
+os.path.exists(self.bundleFile)
+):
+os.remove(self.bundleFile)
+self.bundleFile = None
+self.checkVCSStatus()
+return res
+def hgPush(self, force=False, newBranch=False, rev=None):
+"""
+Public method used to push changes to a remote Mercurial repository.
+@param force flag indicating a forced push (boolean)
+@param newBranch flag indicating to push a new branch (boolean)
+@param rev revision to be pushed (including all ancestors) (string)
+"""
+args = self.initCommand("push")
+args.append('-v')
+if force:
+args.append('-f')
+if newBranch:
+args.append('--new-branch')
+if rev:
+args.append('--rev')
+args.append(rev)
+dia = HgDialog(
+self.tr('Pushing to a remote Mercurial repository'), self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+self.checkVCSStatus()
+def hgInfo(self, mode="heads"):
+"""
+Public method to show information about the heads of the repository.
+@param mode mode of the operation (string, one of heads, parents,
+tip)
+"""
+if mode not in ("heads", "parents", "tip"):
+mode = "heads"
+info = []
+args = self.initCommand(mode)
+args.append('--template')
+args.append('{rev}:{node|short}@@@{tags}@@@{author|xmlescape}@@@'
+'{date|isodate}@@@{branches}@@@{parents}@@@{bookmarks}\n')
+output, error = self.__client.runcommand(args)
+if output:
+for index, line in enumerate(output.splitlines(), start=1):
+(changeset, tags, author, date, branches, parents,
+bookmarks) = line.split("@@@")
+cdate, ctime = date.split()[:2]
+info.append("""<p><table>""")
+if mode == "heads":
+info.append(QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Head #{0}</b></td><td></td></tr>\n""")
+.format(index))
+elif mode == "parents":
+info.append(QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Parent #{0}</b></td><td></td></tr>\n""")
+.format(index))
+elif mode == "tip":
+info.append(QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Tip</b></td><td></td></tr>\n"""))
+info.append(QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Changeset</b></td><td>{0}</td></tr>""")
+.format(changeset))
+if tags:
+info.append(QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Tags</b></td><td>{0}</td></tr>""")
+.format('<br/>'.join(tags.split())))
+if bookmarks:
+info.append(QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Bookmarks</b></td><td>{0}</td></tr>""")
+.format('<br/>'.join(bookmarks.split())))
+if branches:
+info.append(QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Branches</b></td><td>{0}</td></tr>""")
+.format('<br/>'.join(branches.split())))
+if parents:
+info.append(QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Parents</b></td><td>{0}</td></tr>""")
+.format('<br/>'.join(parents.split())))
+info.append(QCoreApplication.translate(
+"mercurial",
+"""<tr><td><b>Last author</b></td><td>{0}</td></tr>\n"""
+"""<tr><td><b>Committed date</b></td><td>{1}</td></tr>\n"""
+"""<tr><td><b>Committed time</b></td><td>{2}</td></tr>\n"""
+"""</table></p>""")
+.format(author, cdate, ctime))
+dlg = VcsRepositoryInfoDialog(None, "\n".join(info))
+dlg.exec()
+def hgConflicts(self):
+"""
+Public method used to show a list of files containing conflicts.
+"""
+if self.conflictsDlg is None:
+from .HgConflictsListDialog import HgConflictsListDialog
+self.conflictsDlg = HgConflictsListDialog(self)
+self.conflictsDlg.show()
+self.conflictsDlg.raise_()
+self.conflictsDlg.start()
+def vcsResolved(self, name, unresolve=False):
+"""
+Public method used to resolve conflicts of a file/directory.
+@param name file/directory name to be resolved (string)
+@param unresolve flag indicating to mark the file/directory as
+unresolved (boolean)
+"""
+args = self.initCommand("resolve")
+if unresolve:
+args.append("--unmark")
+else:
+args.append("--mark")
+if isinstance(name, list):
+self.addArguments(args, name)
+else:
+args.append(name)
+title = (
+self.tr("Marking as 'unresolved'")
+if unresolve else
+self.tr("Marking as 'resolved'")
+)
+dia = HgDialog(title, self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+self.checkVCSStatus()
+def hgAbortMerge(self):
+"""
+Public method to abort an uncommitted merge.
+@return flag indicating, that the abortion contained an add
+or delete (boolean)
+"""
+if self.version >= (4, 5, 0):
+args = self.initCommand("merge")
+args.append("--abort")
+else:
+args = self.initCommand("update")
+args.append("--clean")
+dia = HgDialog(
+self.tr('Aborting uncommitted merge'),
+self)
+res = dia.startProcess(args, showArgs=False)
+if res:
+dia.exec()
+res = dia.hasAddOrDelete()
+self.checkVCSStatus()
+return res
+def hgBranch(self):
+"""
+Public method used to create a branch in the Mercurial repository.
+"""
+from .HgBranchInputDialog import HgBranchInputDialog
+dlg = HgBranchInputDialog(self.hgGetBranchesList())
+if dlg.exec() == QDialog.DialogCode.Accepted:
+name, commit, force = dlg.getData()
+name = name.strip().replace(" ", "_")
+args = self.initCommand("branch")
+if force:
+args.append("--force")
+args.append(name)
+dia = HgDialog(
+self.tr('Creating branch in the Mercurial repository'),
+self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+if commit:
+project = ericApp().getObject("Project")
+self.vcsCommit(
+project.getProjectPath(),
+self.tr("Created new branch <{0}>.").format(
+name))
+def hgShowBranch(self):
+"""
+Public method used to show the current branch of the working directory.
+"""
+args = self.initCommand("branch")
+dia = HgDialog(self.tr('Showing current branch'), self)
+res = dia.startProcess(args, showArgs=False)
+if res:
+dia.exec()
+def hgGetCurrentBranch(self):
+"""
+Public method to get the current branch of the working directory.
+@return name of the current branch
+@rtype str
+"""
+args = self.initCommand("branch")
+output, error = self.__client.runcommand(args)
+return output.strip()
+def hgEditUserConfig(self):
+"""
+Public method used to edit the user configuration file.
+"""
+from .HgUserConfigDialog import HgUserConfigDialog
+dlg = HgUserConfigDialog(version=self.version)
+dlg.exec()
+def hgEditConfig(self, repoName=None,
+withLargefiles=True, largefilesData=None):
+"""
+Public method used to edit the repository configuration file.
+@param repoName directory name containing the repository
+@type str
+@param withLargefiles flag indicating to configure the largefiles
+section
+@type bool
+@param largefilesData dictionary with data for the largefiles
+section of the data dialog
+@type dict
+"""
+if repoName is None:
+repoName = self.getClient().getRepository()
+cfgFile = os.path.join(repoName, self.adminDir, "hgrc")
+if not os.path.exists(cfgFile):
+# open dialog to enter the initial data
+withLargefiles = (self.isExtensionActive("largefiles") and
+withLargefiles)
+from .HgRepoConfigDataDialog import HgRepoConfigDataDialog
+dlg = HgRepoConfigDataDialog(withLargefiles=withLargefiles,
+largefilesData=largefilesData)
+if dlg.exec() == QDialog.DialogCode.Accepted:
+createContents = True
+defaultUrl, defaultPushUrl = dlg.getData()
+if withLargefiles:
+lfMinSize, lfPattern = dlg.getLargefilesData()
+else:
+createContents = False
+with contextlib.suppress(OSError):
+with open(cfgFile, "w") as cfg:
+if createContents:
+# write the data entered
+cfg.write("[paths]\n")
+if defaultUrl:
+cfg.write("default = {0}\n".format(defaultUrl))
+if defaultPushUrl:
+cfg.write("default-push = {0}\n".format(
+defaultPushUrl))
+if (
+withLargefiles and
+(lfMinSize, lfPattern) != (None, None)
+):
+cfg.write("\n[largefiles]\n")
+if lfMinSize is not None:
+cfg.write("minsize = {0}\n".format(lfMinSize))
+if lfPattern is not None:
+cfg.write("patterns =\n")
+cfg.write("  {0}\n".format(
+"\n  ".join(lfPattern)))
+self.__monitorRepoIniFile(repoName)
+self.__iniFileChanged(cfgFile)
+self.repoEditor = MiniEditor(cfgFile, "Properties")
+self.repoEditor.show()
+def hgVerify(self):
+"""
+Public method to verify the integrity of the repository.
+"""
+args = self.initCommand("verify")
+dia = HgDialog(
+self.tr('Verifying the integrity of the Mercurial repository'),
+self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+def hgShowConfig(self):
+"""
+Public method to show the combined configuration.
+"""
+args = self.initCommand("showconfig")
+args.append("--untrusted")
+dia = HgDialog(
+self.tr('Showing the combined configuration settings'),
+self)
+res = dia.startProcess(args, showArgs=False)
+if res:
+dia.exec()
+def hgShowPaths(self):
+"""
+Public method to show the path aliases for remote repositories.
+"""
+args = self.initCommand("paths")
+dia = HgDialog(
+self.tr('Showing aliases for remote repositories'),
+self)
+res = dia.startProcess(args, showArgs=False)
+if res:
+dia.exec()
+def hgRecover(self):
+"""
+Public method to recover an interrupted transaction.
+"""
+args = self.initCommand("recover")
+dia = HgDialog(
+self.tr('Recovering from interrupted transaction'),
+self)
+res = dia.startProcess(args, showArgs=False)
+if res:
+dia.exec()
+def hgIdentify(self):
+"""
+Public method to identify the current working directory.
+"""
+args = self.initCommand("identify")
+dia = HgDialog(self.tr('Identifying project directory'), self)
+res = dia.startProcess(args, showArgs=False)
+if res:
+dia.exec()
+def hgCreateIgnoreFile(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 = [
+"glob:.eric6project",
+"glob:.eric7project",
+"glob:.ropeproject",
+"glob:.jedi",
+"glob:.directory",
+"glob:**.pyc",
+"glob:**.pyo",
+"glob:**.orig",
+"glob:**.bak",
+"glob:**.rej",
+"glob:**~",
+"glob:cur",
+"glob:tmp",
+"glob:__pycache__",
+"glob:**.DS_Store",
+]
+ignoreName = os.path.join(name, Hg.IgnoreFileName)
+res = (
+EricMessageBox.yesNo(
+self.__ui,
+self.tr("Create .hgignore file"),
+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 .hgignore 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 hgBundle(self, bundleData=None):
+"""
+Public method to create a changegroup file.
+@param bundleData dictionary containing the bundle creation information
+@type dict
+"""
+if bundleData is None:
+from .HgBundleDialog import HgBundleDialog
+dlg = HgBundleDialog(self.hgGetTagsList(),
+self.hgGetBranchesList(),
+self.hgGetBookmarksList(),
+version=self.version)
+if dlg.exec() != QDialog.DialogCode.Accepted:
+return
+revs, baseRevs, compression, bundleAll = dlg.getParameters()
+else:
+revs = bundleData["revs"]
+if bundleData["base"]:
+baseRevs = [bundleData["base"]]
+else:
+baseRevs = []
+compression = ""
+bundleAll = bundleData["all"]
+fname, selectedFilter = EricFileDialog.getSaveFileNameAndFilter(
+None,
+self.tr("Create changegroup"),
+self.__lastChangeGroupPath,
+self.tr("Mercurial Changegroup Files (*.hg)"),
+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 changegroup"),
+self.tr("<p>The Mercurial changegroup file <b>{0}</b> "
+"already exists. Overwrite it?</p>")
+.format(fpath),
+icon=EricMessageBox.Warning)
+if not res:
+return
+self.__lastChangeGroupPath = str(fpath.parent)
+args = self.initCommand("bundle")
+if bundleAll:
+args.append("--all")
+for rev in revs:
+args.append("--rev")
+args.append(rev)
+for baseRev in baseRevs:
+args.append("--base")
+args.append(baseRev)
+if compression:
+args.append("--type")
+args.append(compression)
+args.append(str(fpath))
+dia = HgDialog(self.tr('Create changegroup'), self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+def hgPreviewBundle(self):
+"""
+Public method used to view the log of incoming changes from a
+changegroup file.
+"""
+file = EricFileDialog.getOpenFileName(
+None,
+self.tr("Preview changegroup"),
+self.__lastChangeGroupPath,
+self.tr("Mercurial Changegroup Files (*.hg);;All Files (*)"))
+if file:
+self.__lastChangeGroupPath = os.path.dirname(file)
+if self.logBrowserIncoming is None:
+from .HgLogBrowserDialog import HgLogBrowserDialog
+self.logBrowserIncoming = HgLogBrowserDialog(
+self, mode="incoming")
+self.logBrowserIncoming.show()
+self.logBrowserIncoming.raise_()
+self.logBrowserIncoming.start(bundle=file)
+def hgUnbundle(self, files=None):
+"""
+Public method to apply changegroup files.
+@param files list of bundle files to be applied
+@type list of str
+@return flag indicating, that the update contained an add
+or delete
+@rtype bool
+"""
+res = False
+if not files:
+files = EricFileDialog.getOpenFileNames(
+None,
+self.tr("Apply changegroups"),
+self.__lastChangeGroupPath,
+self.tr("Mercurial Changegroup Files (*.hg);;All Files (*)"))
+if files:
+self.__lastChangeGroupPath = os.path.dirname(files[0])
+update = EricMessageBox.yesNo(
+self.__ui,
+self.tr("Apply changegroups"),
+self.tr("""Shall the working directory be updated?"""),
+yesDefault=True)
+args = self.initCommand("unbundle")
+if update:
+args.append("--update")
+args.append("--verbose")
+args.extend(files)
+dia = HgDialog(self.tr('Apply changegroups'), self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+res = dia.hasAddOrDelete()
+self.checkVCSStatus()
+return res
+def hgBisect(self, subcommand):
+"""
+Public method to perform bisect commands.
+@param subcommand name of the subcommand (one of 'good', 'bad',
+'skip' or 'reset')
+@type str
+@exception ValueError raised to indicate an invalid bisect subcommand
+"""
+if subcommand not in ("good", "bad", "skip", "reset"):
+raise ValueError(
+self.tr("Bisect subcommand ({0}) invalid.")
+.format(subcommand))
+rev = ""
+if subcommand in ("good", "bad", "skip"):
+from .HgRevisionSelectionDialog import HgRevisionSelectionDialog
+dlg = HgRevisionSelectionDialog(
+self.hgGetTagsList(),
+self.hgGetBranchesList(),
+bookmarksList=self.hgGetBookmarksList()
+)
+if dlg.exec() == QDialog.DialogCode.Accepted:
+rev = dlg.getRevision()
+else:
+return
+args = self.initCommand("bisect")
+args.append("--{0}".format(subcommand))
+if rev:
+args.append(rev)
+dia = HgDialog(
+self.tr('Mercurial Bisect ({0})').format(subcommand), self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+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
+"""
+args = self.initCommand("forget")
+args.append('-v')
+if isinstance(name, list):
+self.addArguments(args, name)
+else:
+args.append(name)
+dia = HgDialog(
+self.tr('Removing files from the Mercurial repository only'),
+self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+if isinstance(name, list):
+self.__forgotNames.extend(name)
+else:
+self.__forgotNames.append(name)
+def hgBackout(self):
+"""
+Public method used to backout an earlier changeset from the Mercurial
+repository.
+"""
+from .HgBackoutDialog import HgBackoutDialog
+dlg = HgBackoutDialog(self.hgGetTagsList(),
+self.hgGetBranchesList(),
+self.hgGetBookmarksList())
+if dlg.exec() == QDialog.DialogCode.Accepted:
+rev, merge, date, user, message = dlg.getParameters()
+if not rev:
+EricMessageBox.warning(
+self.__ui,
+self.tr("Backing out changeset"),
+self.tr("""No revision given. Aborting..."""))
+return
+args = self.initCommand("backout")
+args.append('-v')
+if merge:
+args.append('--merge')
+if date:
+args.append('--date')
+args.append(date)
+if user:
+args.append('--user')
+args.append(user)
+args.append('--message')
+args.append(message)
+args.append(rev)
+dia = HgDialog(self.tr('Backing out changeset'), self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+def hgRollback(self):
+"""
+Public method used to rollback the last transaction.
+"""
+res = EricMessageBox.yesNo(
+None,
+self.tr("Rollback last transaction"),
+self.tr("""Are you sure you want to rollback the last"""
+""" transaction?"""),
+icon=EricMessageBox.Warning)
+if res:
+dia = HgDialog(self.tr('Rollback last transaction'), self)
+res = dia.startProcess(["rollback"])
+if res:
+dia.exec()
+def hgServe(self, repoPath):
+"""
+Public method used to serve the project.
+@param repoPath directory containing the repository
+@type str
+"""
+from .HgServeDialog import HgServeDialog
+self.serveDlg = HgServeDialog(self, repoPath)
+self.serveDlg.show()
+def hgImport(self):
+"""
+Public method to import a patch file.
+@return flag indicating, that the import contained an add, a delete
+or a change to the project file (boolean)
+"""
+from .HgImportDialog import HgImportDialog
+dlg = HgImportDialog(self)
+if dlg.exec() == QDialog.DialogCode.Accepted:
+(patchFile, noCommit, message, date, user, withSecret, stripCount,
+force) = dlg.getParameters()
+args = self.initCommand("import")
+args.append("--verbose")
+if noCommit:
+args.append("--no-commit")
+else:
+if message:
+args.append('--message')
+args.append(message)
+if date:
+args.append('--date')
+args.append(date)
+if user:
+args.append('--user')
+args.append(user)
+if stripCount != 1:
+args.append("--strip")
+args.append(str(stripCount))
+if force:
+args.append("--force")
+if withSecret:
+args.append("--secret")
+args.append(patchFile)
+dia = HgDialog(self.tr("Import Patch"), self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+res = dia.hasAddOrDelete()
+self.checkVCSStatus()
+else:
+res = False
+return res
+def hgExport(self):
+"""
+Public method to export patches to files.
+"""
+from .HgExportDialog import HgExportDialog
+dlg = HgExportDialog(self.hgGetBookmarksList(),
+self.version >= (4, 7, 0))
+if dlg.exec() == QDialog.DialogCode.Accepted:
+(filePattern, revisions, bookmark, switchParent, allText,
+noDates, git) = dlg.getParameters()
+args = self.initCommand("export")
+args.append("--output")
+args.append(filePattern)
+args.append("--verbose")
+if switchParent:
+args.append("--switch-parent")
+if allText:
+args.append("--text")
+if noDates:
+args.append("--nodates")
+if git:
+args.append("--git")
+if bookmark:
+args.append("--bookmark")
+args.append(bookmark)
+else:
+for rev in revisions:
+args.append(rev)
+dia = HgDialog(self.tr("Export Patches"), self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+def hgPhase(self, data=None):
+"""
+Public method to change the phase of revisions.
+@param data tuple giving phase data (list of revisions, phase, flag
+indicating a forced operation) (list of strings, string, boolean)
+@return flag indicating success (boolean)
+@exception ValueError raised to indicate an invalid phase
+"""
+if data is None:
+from .HgPhaseDialog import HgPhaseDialog
+dlg = HgPhaseDialog()
+if dlg.exec() == QDialog.DialogCode.Accepted:
+data = dlg.getData()
+if data:
+revs, phase, force = data
+if phase not in ("p", "d", "s"):
+raise ValueError("Invalid phase given.")
+args = self.initCommand("phase")
+if phase == "p":
+args.append("--public")
+elif phase == "d":
+args.append("--draft")
+else:
+args.append("--secret")
+if force:
+args.append("--force")
+for rev in revs:
+args.append(rev)
+dia = HgDialog(self.tr("Change Phase"), self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+res = dia.normalExitWithoutErrors()
+else:
+res = False
+return res
+def hgGraft(self, revs=None):
+"""
+Public method to copy changesets from another branch.
+@param revs list of revisions to show in the revisions pane (list of
+strings)
+@return flag indicating that the project should be reread (boolean)
+"""
+from .HgGraftDialog import HgGraftDialog
+res = False
+dlg = HgGraftDialog(self, revs)
+if dlg.exec() == QDialog.DialogCode.Accepted:
+(revs,
+(userData, currentUser, userName),
+(dateData, currentDate, dateStr),
+log, dryrun, noCommit) = dlg.getData()
+args = self.initCommand("graft")
+args.append("--verbose")
+if userData:
+if currentUser:
+args.append("--currentuser")
+else:
+args.append("--user")
+args.append(userName)
+if dateData:
+if currentDate:
+args.append("--currentdate")
+else:
+args.append("--date")
+args.append(dateStr)
+if log:
+args.append("--log")
+if dryrun:
+args.append("--dry-run")
+if noCommit:
+args.append("--no-commit")
+args.extend(revs)
+dia = HgDialog(self.tr('Copy Changesets'), self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+res = dia.hasAddOrDelete()
+self.checkVCSStatus()
+return res
+def __hgGraftSubCommand(self, subcommand, title):
+"""
+Private method to perform a Mercurial graft subcommand.
+@param subcommand subcommand flag
+@type str
+@param title tirle of the dialog
+@type str
+@return flag indicating that the project should be reread
+@rtype bool
+"""
+args = self.initCommand("graft")
+args.append(subcommand)
+args.append("--verbose")
+dia = HgDialog(title, self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+res = dia.hasAddOrDelete()
+self.checkVCSStatus()
+return res
+def hgGraftContinue(self, path):
+"""
+Public method to continue copying changesets from another branch.
+@param path directory name of the project
+@type str
+@return flag indicating that the project should be reread
+@rtype bool
+"""
+return self.__hgGraftSubCommand(
+"--continue", self.tr('Copy Changesets (Continue)'))
+def hgGraftStop(self, path):
+"""
+Public method to stop an interrupted copying session.
+@param path directory name of the project
+@type str
+@return flag indicating that the project should be reread
+@rtype bool
+"""
+return self.__hgGraftSubCommand(
+"--stop", self.tr('Copy Changesets (Stop)'))
+def hgGraftAbort(self, path):
+"""
+Public method to abort an interrupted copying session and perform
+a rollback.
+@param path directory name of the project
+@type str
+@return flag indicating that the project should be reread
+@rtype bool
+"""
+return self.__hgGraftSubCommand(
+"--abort", self.tr('Copy Changesets (Abort)'))
+def hgArchive(self):
+"""
+Public method to create an unversioned archive from the repository.
+"""
+from .HgArchiveDialog import HgArchiveDialog
+dlg = HgArchiveDialog(self)
+if dlg.exec() == QDialog.DialogCode.Accepted:
+archive, type_, prefix, subrepos = dlg.getData()
+args = self.initCommand("archive")
+if type_:
+args.append("--type")
+args.append(type_)
+if prefix:
+args.append("--prefix")
+args.append(prefix)
+if subrepos:
+args.append("--subrepos")
+args.append(archive)
+dia = HgDialog(self.tr("Create Unversioned Archive"), self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+def hgDeleteBackups(self):
+"""
+Public method to delete all backup bundles in the backup area.
+"""
+backupdir = os.path.join(self.getClient().getRepository(),
+self.adminDir, "strip-backup")
+yes = EricMessageBox.yesNo(
+self.__ui,
+self.tr("Delete All Backups"),
+self.tr(
+"""<p>Do you really want to delete all backup bundles"""
+""" stored in the backup area?<br/><b>{0}</b></p>"""
+).format(backupdir)
+)
+if yes:
+shutil.rmtree(backupdir, True)
+###########################################################################
+## Methods to deal with sub-repositories are below.
+###########################################################################
+def getHgSubPath(self):
+"""
+Public method to get the path to the .hgsub file containing the
+definitions of sub-repositories.
+@return full path of the .hgsub file (string)
+"""
+ppath = self.__projectHelper.getProject().getProjectPath()
+return os.path.join(ppath, ".hgsub")
+def hasSubrepositories(self):
+"""
+Public method to check, if the project might have sub-repositories.
+@return flag indicating the existence of sub-repositories (boolean)
+"""
+hgsub = self.getHgSubPath()
+return os.path.isfile(hgsub) and os.stat(hgsub).st_size > 0
+def hgAddSubrepository(self):
+"""
+Public method to add a sub-repository.
+"""
+from .HgAddSubrepositoryDialog import HgAddSubrepositoryDialog
+ppath = self.__projectHelper.getProject().getProjectPath()
+hgsub = self.getHgSubPath()
+dlg = HgAddSubrepositoryDialog(ppath)
+if dlg.exec() == QDialog.DialogCode.Accepted:
+relPath, subrepoType, subrepoUrl = dlg.getData()
+if subrepoType == "hg":
+url = subrepoUrl
+else:
+url = "[{0}]{1}".format(subrepoType, subrepoUrl)
+entry = "{0} = {1}\n".format(relPath, url)
+contents = []
+if os.path.isfile(hgsub):
+# file exists; check, if such an entry exists already
+needsAdd = False
+try:
+with open(hgsub, "r") as f:
+contents = f.readlines()
+except OSError as err:
+EricMessageBox.critical(
+self.__ui,
+self.tr("Add Sub-repository"),
+self.tr(
+"""<p>The sub-repositories file .hgsub could not"""
+""" be read.</p><p>Reason: {0}</p>""")
+.format(str(err)))
+return
+if entry in contents:
+EricMessageBox.critical(
+self.__ui,
+self.tr("Add Sub-repository"),
+self.tr(
+"""<p>The sub-repositories file .hgsub already"""
+""" contains an entry <b>{0}</b>."""
+""" Aborting...</p>""").format(entry))
+return
+else:
+needsAdd = True
+if contents and not contents[-1].endswith("\n"):
+contents[-1] = contents[-1] + "\n"
+contents.append(entry)
+try:
+with open(hgsub, "w") as f:
+f.writelines(contents)
+except OSError as err:
+EricMessageBox.critical(
+self.__ui,
+self.tr("Add Sub-repository"),
+self.tr(
+"""<p>The sub-repositories file .hgsub could not"""
+""" be written to.</p><p>Reason: {0}</p>""")
+.format(str(err)))
+return
+if needsAdd:
+self.vcsAdd(hgsub)
+self.__projectHelper.getProject().appendFile(hgsub)
+def hgRemoveSubrepositories(self):
+"""
+Public method to remove sub-repositories.
+"""
+hgsub = self.getHgSubPath()
+subrepositories = []
+if not os.path.isfile(hgsub):
+EricMessageBox.critical(
+self.__ui,
+self.tr("Remove Sub-repositories"),
+self.tr("""<p>The sub-repositories file .hgsub does not"""
+""" exist. Aborting...</p>"""))
+return
+try:
+with open(hgsub, "r") as f:
+subrepositories = [line.strip() for line in f.readlines()]
+except OSError as err:
+EricMessageBox.critical(
+self.__ui,
+self.tr("Remove Sub-repositories"),
+self.tr("""<p>The sub-repositories file .hgsub could not"""
+""" be read.</p><p>Reason: {0}</p>""")
+.format(str(err)))
+return
+from .HgRemoveSubrepositoriesDialog import (
+HgRemoveSubrepositoriesDialog
+)
+dlg = HgRemoveSubrepositoriesDialog(subrepositories)
+if dlg.exec() == QDialog.DialogCode.Accepted:
+subrepositories, removedSubrepos, deleteSubrepos = dlg.getData()
+contents = "\n".join(subrepositories) + "\n"
+try:
+with open(hgsub, "w") as f:
+f.write(contents)
+except OSError as err:
+EricMessageBox.critical(
+self.__ui,
+self.tr("Remove Sub-repositories"),
+self.tr(
+"""<p>The sub-repositories file .hgsub could not"""
+""" be written to.</p><p>Reason: {0}</p>""")
+.format(str(err)))
+return
+if deleteSubrepos:
+ppath = self.__projectHelper.getProject().getProjectPath()
+for removedSubrepo in removedSubrepos:
+subrepoPath = removedSubrepo.split("=", 1)[0].strip()
+subrepoAbsPath = os.path.join(ppath, subrepoPath)
+shutil.rmtree(subrepoAbsPath, True)
+###########################################################################
+## Methods to handle configuration dependent stuff are below.
+###########################################################################
+def __checkDefaults(self):
+"""
+Private method to check, if the default and default-push URLs
+have been configured.
+"""
+args = self.initCommand("showconfig")
+args.append('paths')
+output, error = self.__client.runcommand(args)
+self.__defaultConfigured = False
+self.__defaultPushConfigured = False
+if output:
+for line in output.splitlines():
+line = line.strip()
+if (
+line.startswith("paths.default=") and
+not line.endswith("=")
+):
+self.__defaultConfigured = True
+if (
+line.startswith("paths.default-push=") and
+not line.endswith("=")
+):
+self.__defaultPushConfigured = True
+def canCommitMerge(self):
+"""
+Public method to check, if the working directory is an uncommitted
+merge.
+@return flag indicating commit merge capability
+@rtype bool
+"""
+args = self.initCommand("identify")
+output, error = self.__client.runcommand(args)
+return output.count('+') == 2
+def canPull(self):
+"""
+Public method to check, if pull is possible.
+@return flag indicating pull capability (boolean)
+"""
+return self.__defaultConfigured
+def canPush(self):
+"""
+Public method to check, if push is possible.
+@return flag indicating push capability (boolean)
+"""
+return self.__defaultPushConfigured or self.__defaultConfigured
+def __iniFileChanged(self, path):
+"""
+Private slot to handle a change of the Mercurial configuration file.
+@param path name of the changed file (string)
+"""
+if self.__client:
+ok, err = self.__client.restartServer()
+if not ok:
+EricMessageBox.warning(
+None,
+self.tr("Mercurial Command Server"),
+self.tr(
+"""<p>The Mercurial Command Server could not be"""
+""" restarted.</p><p>Reason: {0}</p>""").format(err))
+self.__getExtensionsInfo()
+if self.__repoIniFile and path == self.__repoIniFile:
+self.__checkDefaults()
+self.iniFileChanged.emit()
+def __monitorRepoIniFile(self, repodir):
+"""
+Private slot to add a repository configuration file to the list of
+monitored files.
+@param repodir directory name of the repository
+@type str
+"""
+cfgFile = os.path.join(repodir, self.adminDir, "hgrc")
+if os.path.exists(cfgFile):
+self.__iniWatcher.addPath(cfgFile)
+self.__repoIniFile = cfgFile
+self.__checkDefaults()
+###########################################################################
+## Methods to handle extensions are below.
+###########################################################################
+def __getExtensionsInfo(self):
+"""
+Private method to get the active extensions from Mercurial.
+"""
+activeExtensions = sorted(self.__activeExtensions)
+self.__activeExtensions = []
+args = self.initCommand("showconfig")
+args.append('extensions')
+output, error = self.__client.runcommand(args)
+if output:
+for line in output.splitlines():
+extensionName = (
+line.split("=", 1)[0].strip().split(".")[-1].strip()
+)
+self.__activeExtensions.append(extensionName)
+if self.version < (4, 8, 0) and "closehead" in self.__activeExtensions:
+self.__activeExtensions.remove["closehead"]
+if activeExtensions != sorted(self.__activeExtensions):
+self.activeExtensionsChanged.emit()
+def isExtensionActive(self, extensionName):
+"""
+Public method to check, if an extension is active.
+@param extensionName name of the extension to check for (string)
+@return flag indicating an active extension (boolean)
+"""
+extensionName = extensionName.strip()
+isActive = extensionName in self.__activeExtensions
+return isActive
+def getExtensionObject(self, extensionName):
+"""
+Public method to get a reference to an extension object.
+@param extensionName name of the extension (string)
+@return reference to the extension object (boolean)
+"""
+return self.__extensions[extensionName]
+###########################################################################
+## 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 HgProjectBrowserHelper
+return HgProjectBrowserHelper(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
+"""
+# find the root of the repo
+repodir = project.getProjectPath()
+while not os.path.isdir(os.path.join(repodir, self.adminDir)):
+repodir = os.path.dirname(repodir)
+if not repodir or os.path.splitdrive(repodir)[1] == os.sep:
+repodir = ""
+break
+self.__projectHelper = self.__plugin.getProjectHelper()
+self.__projectHelper.setObjects(self, project)
+if repodir:
+self.__repoDir = repodir
+self.__createClient(repodir)
+self.__monitorRepoIniFile(repodir)
+return self.__projectHelper
+###########################################################################
+## Methods to handle the Mercurial command server are below.
+###########################################################################
+def __createClient(self, repodir=""):
+"""
+Private method to create a Mercurial command server client.
+@param repodir path of the local repository
+@type str
+"""
+self.stopClient()
+self.__client = HgClient(repodir, "utf-8", self)
+ok, err = self.__client.startServer()
+if not ok:
+EricMessageBox.warning(
+None,
+self.tr("Mercurial Command Server"),
+self.tr(
+"""<p>The Mercurial Command Server could not be"""
+""" started.</p><p>Reason: {0}</p>""").format(err))
+def getClient(self):
+"""
+Public method to get a reference to the command server interface.
+@return reference to the client (HgClient)
+"""
+if self.__client is None:
+self.__createClient(self.__repoDir)
+return self.__client
+def stopClient(self):
+"""
+Public method to stop the command server client.
+"""
+if self.__client is not None:
+self.__client.stopServer()
+self.__client = None
+###########################################################################
+## 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 .HgStatusMonitorThread import HgStatusMonitorThread
+return HgStatusMonitorThread(interval, project, self)
+###########################################################################
+## Bookmarks methods
+###########################################################################
+def hgListBookmarks(self):
+"""
+Public method used to list the available bookmarks.
+"""
+self.bookmarksList = []
+if self.bookmarksListDlg is None:
+from .HgBookmarksListDialog import HgBookmarksListDialog
+self.bookmarksListDlg = HgBookmarksListDialog(self)
+self.bookmarksListDlg.show()
+self.bookmarksListDlg.raise_()
+self.bookmarksListDlg.start(self.bookmarksList)
+def hgGetBookmarksList(self):
+"""
+Public method to get the list of bookmarks.
+@return list of bookmarks (list of string)
+"""
+args = self.initCommand("bookmarks")
+client = self.getClient()
+output = client.runcommand(args)[0]
+self.bookmarksList = []
+for line in output.splitlines():
+li = line.strip().split()
+if li[-1][0] in "1234567890":
+# last element is a rev:changeset
+del li[-1]
+if li[0] == "*":
+del li[0]
+name = " ".join(li)
+self.bookmarksList.append(name)
+return self.bookmarksList[:]
+def hgBookmarkDefine(self, revision=None, bookmark=None):
+"""
+Public method to define a bookmark.
+@param revision revision to set bookmark for (string)
+@param bookmark name of the bookmark (string)
+"""
+if bool(revision) and bool(bookmark):
+ok = True
+else:
+from .HgBookmarkDialog import HgBookmarkDialog
+dlg = HgBookmarkDialog(HgBookmarkDialog.DEFINE_MODE,
+self.hgGetTagsList(),
+self.hgGetBranchesList(),
+self.hgGetBookmarksList())
+if dlg.exec() == QDialog.DialogCode.Accepted:
+revision, bookmark = dlg.getData()
+ok = True
+else:
+ok = False
+if ok:
+args = self.initCommand("bookmarks")
+if revision:
+args.append("--rev")
+args.append(revision)
+args.append(bookmark)
+dia = HgDialog(self.tr('Mercurial Bookmark'), self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+def hgBookmarkDelete(self, bookmark=None):
+"""
+Public method to delete a bookmark.
+@param bookmark name of the bookmark (string)
+"""
+if bookmark:
+ok = True
+else:
+bookmark, ok = QInputDialog.getItem(
+None,
+self.tr("Delete Bookmark"),
+self.tr("Select the bookmark to be deleted:"),
+[""] + sorted(self.hgGetBookmarksList()),
+0, True)
+if ok and bookmark:
+args = self.initCommand("bookmarks")
+args.append("--delete")
+args.append(bookmark)
+dia = HgDialog(self.tr('Delete Mercurial Bookmark'), self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+def hgBookmarkRename(self, renameInfo=None):
+"""
+Public method to rename a bookmark.
+@param renameInfo old and new names of the bookmark
+@type tuple of str and str
+"""
+if not renameInfo:
+from .HgBookmarkRenameDialog import HgBookmarkRenameDialog
+dlg = HgBookmarkRenameDialog(self.hgGetBookmarksList())
+if dlg.exec() == QDialog.DialogCode.Accepted:
+renameInfo = dlg.getData()
+if renameInfo:
+args = self.initCommand("bookmarks")
+args.append("--rename")
+args.append(renameInfo[0])
+args.append(renameInfo[1])
+dia = HgDialog(self.tr('Rename Mercurial Bookmark'), self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+def hgBookmarkMove(self, revision=None, bookmark=None):
+"""
+Public method to move a bookmark.
+@param revision revision to set bookmark for (string)
+@param bookmark name of the bookmark (string)
+"""
+if bool(revision) and bool(bookmark):
+ok = True
+else:
+from .HgBookmarkDialog import HgBookmarkDialog
+dlg = HgBookmarkDialog(HgBookmarkDialog.MOVE_MODE,
+self.hgGetTagsList(),
+self.hgGetBranchesList(),
+self.hgGetBookmarksList())
+if dlg.exec() == QDialog.DialogCode.Accepted:
+revision, bookmark = dlg.getData()
+ok = True
+else:
+ok = False
+if ok:
+args = self.initCommand("bookmarks")
+args.append("--force")
+if revision:
+args.append("--rev")
+args.append(revision)
+args.append(bookmark)
+dia = HgDialog(self.tr('Move Mercurial Bookmark'), self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+def hgBookmarkIncoming(self):
+"""
+Public method to show a list of incoming bookmarks.
+"""
+from .HgBookmarksInOutDialog import HgBookmarksInOutDialog
+self.bookmarksInOutDlg = HgBookmarksInOutDialog(
+self, HgBookmarksInOutDialog.INCOMING)
+self.bookmarksInOutDlg.show()
+self.bookmarksInOutDlg.start()
+def hgBookmarkOutgoing(self):
+"""
+Public method to show a list of outgoing bookmarks.
+"""
+from .HgBookmarksInOutDialog import HgBookmarksInOutDialog
+self.bookmarksInOutDlg = HgBookmarksInOutDialog(
+self, HgBookmarksInOutDialog.OUTGOING)
+self.bookmarksInOutDlg.show()
+self.bookmarksInOutDlg.start()
+def __getInOutBookmarks(self, incoming):
+"""
+Private method to get the list of incoming or outgoing bookmarks.
+@param incoming flag indicating to get incoming bookmarks (boolean)
+@return list of bookmarks (list of string)
+"""
+bookmarksList = []
+args = (
+self.initCommand("incoming")
+if incoming else
+self.initCommand("outgoing")
+)
+args.append('--bookmarks')
+client = self.getClient()
+output = client.runcommand(args)[0]
+for line in output.splitlines():
+if line.startswith(" "):
+li = line.strip().split()
+del li[-1]
+name = " ".join(li)
+bookmarksList.append(name)
+return bookmarksList
+def hgBookmarkPull(self, current=False, bookmark=None):
+"""
+Public method to pull a bookmark from a remote repository.
+@param current flag indicating to pull the current bookmark
+@type bool
+@param bookmark name of the bookmark
+@type str
+"""
+if current:
+bookmark = "."
+ok = True
+elif bookmark:
+ok = True
+else:
+bookmarks = self.__getInOutBookmarks(True)
+bookmark, ok = QInputDialog.getItem(
+None,
+self.tr("Pull Bookmark"),
+self.tr("Select the bookmark to be pulled:"),
+[""] + sorted(bookmarks),
+0, True)
+if ok and bookmark:
+args = self.initCommand("pull")
+args.append('--bookmark')
+args.append(bookmark)
+dia = HgDialog(self.tr(
+'Pulling bookmark from a remote Mercurial repository'),
+self)
+res = dia.startProcess(args)
+if res:
+dia.exec()
+def hgBookmarkPush(self, current=False, bookmark=None, allBookmarks=False):
+"""
+Public method to push a bookmark to a remote repository.
+@param current flag indicating to push the current bookmark
+@type bool
+@param bookmark name of the bookmark
+@type str
+@param allBookmarks flag indicating to push all bookmarks
+@type bool
+"""
+if current:
+bookmark = "."
+ok = True
+elif bookmark or allBookmarks:
+ok = True
+else:
+bookmarks = self.__getInOutBookmarks(False)
+bookmark, ok = QInputDialog.getItem(
+None,
+self.tr("Push Bookmark"),
+self.tr("Select the bookmark to be push:"),
+[""] + sorted(bookmarks),
+0, True)
+if ok and (bool(bookmark) or all):
+args = self.initCommand("push")
+if allBookmarks:
+args.append('--all-bookmarks')
+else:
+args.append('--bookmark')
+args.append(bookmark)
+dia = HgDialog(self.tr(
+'Pushing bookmark to a remote Mercurial repository'),
+self)
+res = dia.startProcess(args)
+if res:
+dia.exec()

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Plugins/VcsPlugins/vcsMercurial/hg.py

src/eric7/Plugins/VcsPlugins/vcsMercurial/hg.py