eric: eric6/Plugins/VcsPlugins/vcsMercurial/hg.py@9978016560ec (annotated)

 # -*- coding: utf-8 -*-
 # Copyright (c) 2010 - 2020 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing the version control systems interface to Mercurial.
 """
 import os
 import shutil
 from PyQt5.QtCore import (
     pyqtSignal, QFileInfo, QFileSystemWatcher, QCoreApplication
 )
 from PyQt5.QtWidgets import QApplication, QDialog, QInputDialog
 from E5Gui.E5Application import e5App
 from E5Gui import E5MessageBox, E5FileDialog
 from QScintilla.MiniEditor import MiniEditor
 from VCS.VersionControl import VersionControl
 from VCS.RepositoryInfoDialog import VcsRepositoryInfoDialog
 from .HgDialog import HgDialog
 from .HgClient import HgClient
 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:
             E5MessageBox.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)
         # init is not possible with the command server
         dia = HgDialog(self.tr('Creating Mercurial repository'), self)
         res = dia.startProcess(args)
         if res:
             dia.exec()
         status = dia.normalExit()
         if status:
             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, 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 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
         @keyparam closeBranch flag indicating a close branch commit (boolean)
         @keyparam mq flag indicating a queue commit (boolean)
         @keyparam 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 = e5App().getObject("Project")
                     if nam == project.getProjectPath():
                         ok &= (
                             project.checkAllScriptsDirty(
                                 reportSyntaxErrors=True) and
                             project.checkDirty()
                         )
                         continue
                 elif os.path.isfile(nam):
                     editor = (
                         e5App().getObject("ViewManager").getOpenEditor(nam)
                     )
                     if editor:
                         ok &= editor.checkDirty()
                 if not ok:
                     break
             if not ok:
                 res = E5MessageBox.yesNo(
                     self.__ui,
                     self.tr("Commit Changes"),
                     self.tr(
                         """The commit affects files, that have unsaved"""
                         """ changes. Shall the commit be continued?"""),
                     icon=E5MessageBox.Warning)
                 if not res:
                     return
         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 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(repodir)
         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:
             if dname != repodir or fname != ".":
                 args.append(name)
         dia = HgDialog(
             self.tr('Committing changes to Mercurial repository'),
             self)
         res = dia.startProcess(args, dname)
         if res:
             dia.exec()
         self.committed.emit()
         if self.__forgotNames:
             model = e5App().getObject("Project").getModel()
             for name in self.__forgotNames:
                 model.updateVCSStatus(name)
             self.__forgotNames = []
         self.checkVCSStatus()
     def __getMostRecentCommitMessage(self, repodir):
         """
         Private method to get the most recent commit message.
         Note: This message is extracted from the parent commit of the
         working directory.
         @param repodir path containing the repository
         @type str
         @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, noDialog=False, revision=None):
         """
         Public method used to update a file/directory with the Mercurial
         repository.
         @param name file/directory name to be updated (string or list of
             strings)
         @param noDialog flag indicating quiet operations (boolean)
         @keyparam 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 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
         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, 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 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):
             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:
             out, err = self.__client.runcommand(args)
         else:
             dia = HgDialog(
                 self.tr(
                     'Adding files/directories to the Mercurial 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
         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):
             dname, fnames = self.splitPathList(name)
             self.addArguments(args, name)
         else:
             dname, fname = self.splitPath(name)
             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:
             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, repodir)
             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.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)
             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:
                 out, err = self.__client.runcommand(args)
                 res = err == ""
             else:
                 dia = HgDialog(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 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)
         """
         if isinstance(name, list):
             names = name[:]
         else:
             names = [name]
         for nam in names:
             if os.path.isfile(nam):
                 editor = e5App().getObject("ViewManager").getOpenEditor(nam)
                 if editor and not editor.checkDirty():
                     return
             else:
                 project = e5App().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(self.__projectHelper.getProject().getProjectPath(),
                            mq=mq, largefiles=largefiles)
     def vcsTag(self, name, 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)
         """
         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 .HgTagDialog import HgTagDialog
         dlg = HgTagDialog(self.hgGetTagsList(repodir, withType=True),
                           revision, tagName)
         if dlg.exec() == QDialog.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]:
             if 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, repodir)
         if res:
             dia.exec()
         return True
     def hgRevert(self, name):
         """
         Public method used to revert changes made to a file/directory.
         @param name file/directory name to be reverted (string)
         @return flag indicating, that the update contained an add
             or delete (boolean)
         """
         args = self.initCommand("revert")
         if not self.getPlugin().getPreferences("CreateBackup"):
             args.append("--no-backup")
         args.append("-v")
         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 = e5App().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.Accepted
         else:
             yes = E5MessageBox.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, repodir)
             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
         @keyparam rev revision to merge with
         @type str
         """
         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 not rev:
             from .HgMergeDialog import HgMergeDialog
             dlg = HgMergeDialog(self.hgGetTagsList(repodir),
                                 self.hgGetBranchesList(repodir),
                                 self.hgGetBookmarksList(repodir))
             if dlg.exec() == QDialog.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').format(name), self)
         res = dia.startProcess(args, repodir)
         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")
 e3a6c5b58bf
Added support for various Mercurial 'resolve' subcommands.

Detlev Offenbach <detlev@die

Mercurial Repositories > eric / annotate

eric6/Plugins/VcsPlugins/vcsMercurial/hg.py@9978016560ec (annotated)

eric6/Plugins/VcsPlugins/vcsMercurial/hg.py