eric: Plugins/VcsPlugins/vcsMercurial/hg.py@7a58aba00647 (annotated)

 # -*- coding: utf-8 -*-
 # Copyright (c) 2010 - 2011 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing the version control systems interface to Mercurial.
 """
 import os
 import shutil
 import urllib.request, urllib.parse, urllib.error
 from PyQt4.QtCore import QProcess, pyqtSignal, QFileInfo
 from PyQt4.QtGui 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 .HgCommitDialog import HgCommitDialog
 from .HgOptionsDialog import HgOptionsDialog
 from .HgNewProjectOptionsDialog import HgNewProjectOptionsDialog
 from .HgCopyDialog import HgCopyDialog
 from .HgLogDialog import HgLogDialog
 from .HgLogBrowserDialog import HgLogBrowserDialog
 from .HgDiffDialog import HgDiffDialog
 from .HgRevisionsSelectionDialog import HgRevisionsSelectionDialog
 from .HgRevisionSelectionDialog import HgRevisionSelectionDialog
 from .HgMergeDialog import HgMergeDialog
 from .HgStatusMonitorThread import HgStatusMonitorThread
 from .HgStatusDialog import HgStatusDialog
 from .HgAnnotateDialog import HgAnnotateDialog
 from .HgTagDialog import HgTagDialog
 from .HgTagBranchListDialog import HgTagBranchListDialog
 from .HgCommandDialog import HgCommandDialog
 from .HgBundleDialog import HgBundleDialog
 from .HgBackoutDialog import HgBackoutDialog
 from .HgServeDialog import HgServeDialog
 from .ProjectBrowserHelper import HgProjectBrowserHelper
 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
     """
     committed = pyqtSignal()
     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.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.log = None
         self.diff = None
         self.status = None
         self.tagbranchList = None
         self.annotate = None
         self.editor = None
         self.serveDlg = None
         self.bundleFile = None
         self.statusCache = {}
         self.__commitData = {}
         self.__commitDialog = None
         self.__forgotNames = []
     def getPlugin(self):
         """
         Public method to get a reference to the plugin object.
         @return reference to the plugin object (VcsMercurialPlugin)
         """
         return self.__plugin
     def vcsShutdown(self):
         """
         Public method used to shutdown the Mercurial interface.
         """
         if self.log is not None:
             self.log.close()
         if self.diff is not None:
             self.diff.close()
         if self.status is not None:
             self.status.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.bundleFile and os.path.exists(self.bundleFile):
             os.remove(self.bundleFile)
     def vcsExists(self):
         """
         Public method used to test for the presence of the hg executable.
         @return flag indicating the existance (boolean) and an error message (string)
         """
         self.versionStr = ''
         errMsg = ""
         ioEncoding = Preferences.getSystem("IOEncoding")
         process = QProcess()
         process.start('hg', ['version'])
         procStarted = process.waitForStarted()
         if procStarted:
             finished = process.waitForFinished(30000)
             if finished and process.exitCode() == 0:
                 output = \
                     str(process.readAllStandardOutput(), ioEncoding, 'replace')
                 self.versionStr = output.splitlines()[0].split()[-1][0:-1]
                 return True, errMsg
             else:
                 if finished:
                     errMsg = \
                         self.trUtf8("The hg process finished with the exit code {0}")\
                         .format(process.exitCode())
                 else:
                     errMsg = self.trUtf8("The hg process did not finish within 30s.")
         else:
             errMsg = self.trUtf8("Could not start the hg executable.")
         return False, 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):
         """
         Public method to convert an uncontrolled project to a version controlled project.
         @param vcsDataDict dictionary of data required for the conversion
         @param project reference to the project object
         """
         success = self.vcsImport(vcsDataDict, project.ppath)[0]
         if not success:
             E5MessageBox.critical(self.__ui,
                 self.trUtf8("Create project repository"),
                 self.trUtf8("""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):
         """
         Public method used to import the project into the Subversion repository.
         @param vcsDataDict dictionary of data required for the import
         @param projectDir project directory (string)
         @param noDialog flag indicating quiet operations
         @return flag indicating an execution without errors (boolean)
             and a flag indicating the version controll status (boolean)
         """
         msg = vcsDataDict["message"]
         if not msg:
             msg = '***'
         args = []
         args.append('init')
         args.append(projectDir)
         dia = HgDialog(self.trUtf8('Creating Mercurial repository'))
         res = dia.startProcess(args)
         if res:
             dia.exec_()
         status = dia.normalExit()
         if status:
             status = self.hgCreateIgnoreFile(projectDir)
             if status:
                 args = []
                 args.append('commit')
                 args.append('--addremove')
                 args.append('--message')
                 args.append(msg)
                 dia = HgDialog(self.trUtf8('Initial commit to Mercurial repository'))
                 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"])
         if vcsUrl.startswith('/'):
             vcsUrl = 'file://{0}'.format(vcsUrl)
         elif vcsUrl[1] in ['|', ':']:
             vcsUrl = 'file:///{0}'.format(vcsUrl)
         args = []
         args.append('clone')
         self.addArguments(args, self.options['global'])
         self.addArguments(args, self.options['checkout'])
         if rev:
             args.append("--rev")
             args.append(rev)
         args.append(self.__hgURL(vcsUrl))
         args.append(projectDir)
         if noDialog:
             return self.startSynchronizedProcess(QProcess(), 'hg', args)
         else:
             dia = HgDialog(self.trUtf8('Cloning project from a Mercurial repository'))
             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 Subversion 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, '.hgignore')):
             os.remove(os.path.join(projectDir, '.hgignore'))
         return status
     def vcsCommit(self, name, message, noDialog = False, closeBranch = 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)
         """
         msg = message
         if not noDialog and not msg:
             # call CommitDialog and get message from there
             if self.__commitDialog is None:
                 self.__commitDialog = HgCommitDialog(self, 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
         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"]
         if self.__commitDialog is not None:
             msg = self.__commitDialog.logMessage()
             self.__commitDialog.accepted.disconnect(self.__vcsCommit_Step2)
             self.__commitDialog = None
         if not msg:
             msg = '***'
         args = []
         args.append('commit')
         self.addArguments(args, self.options['global'])
         self.addArguments(args, self.options['commit'])
         args.append("-v")
         if closeBranch:
             args.append("--close-branch")
         args.append("--message")
         args.append(msg)
         if isinstance(name, list):
             dname, fnames = self.splitPathList(name)
         else:
             dname, fname = self.splitPath(name)
         # find the root of the repo
         repodir = dname
         while not os.path.isdir(os.path.join(repodir, self.adminDir)):
             repodir = os.path.dirname(repodir)
             if repodir == os.sep:
                 return
         if isinstance(name, list):
             self.addArguments(args, fnames)
         else:
             if dname != repodir or fname != ".":
                 args.append(fname)
         if noDialog:
             self.startSynchronizedProcess(QProcess(), "hg", args, dname)
         else:
             dia = HgDialog(self.trUtf8('Commiting changes to Mercurial repository'))
             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 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 = []
         args.append('update')
         self.addArguments(args, self.options['global'])
         self.addArguments(args, self.options['update'])
         if "-v" not in args and "--verbose" not in args:
             args.append("-v")
         if revision is not None:
             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 repodir == os.sep:
                 return False
         if noDialog:
             self.startSynchronizedProcess(QProcess(), "hg", args, repodir)
             res = False
         else:
             dia = HgDialog(self.trUtf8('Synchronizing with the Mercurial repository'))
             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 = []
         args.append('add')
         self.addArguments(args, self.options['global'])
         self.addArguments(args, self.options['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 repodir == os.sep:
                 return
         if isinstance(name, list):
             self.addArguments(args, name)
         else:
             args.append(name)
         if noDialog:
             self.startSynchronizedProcess(QProcess(), "hg", args, repodir)
         else:
             dia = HgDialog(
                 self.trUtf8('Adding files/directories to the Mercurial repository'))
             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 = []
         args.append('remove')
         self.addArguments(args, self.options['global'])
         self.addArguments(args, self.options['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 repodir == os.sep:
                 return False
         if noDialog:
             res = self.startSynchronizedProcess(QProcess(), "hg", args, repodir)
         else:
             dia = HgDialog(
                 self.trUtf8('Removing files/directories from the Mercurial repository'))
             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)
         opts = self.options['global'][:]
         force = '--force' in opts
         if force:
             opts.remove('--force')
         res = False
         if noDialog:
             if target is None:
                 return False
             force = True
             accepted = True
         else:
             dlg = HgCopyDialog(name, None, True, force)
             accepted = dlg.exec_() == QDialog.Accepted
             if accepted:
                 target, force = dlg.getData()
         if accepted:
             args = []
             args.append('rename')
             self.addArguments(args, opts)
             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 repodir == os.sep:
                     return False
             if noDialog:
                 res = self.startSynchronizedProcess(QProcess(), "hg", args, repodir)
             else:
                 dia = HgDialog(self.trUtf8('Renaming {0}').format(name))
                 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 vcsLog(self, name):
         """
         Public method used to view the log of a file/directory from the
         Mercurial repository.
         @param name file/directory name to show the log of (string)
         """
         self.log = HgLogDialog(self)
         self.log.show()
         self.log.start(name)
     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
         self.diff = HgDiffDialog(self)
         self.diff.show()
         QApplication.processEvents()
         self.diff.start(name)
     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)
         """
         self.status = HgStatusDialog(self)
         self.status.show()
         self.status.start(name)
     def vcsTag(self, name):
         """
         Public method used to set the tag in the Mercurial repository.
         @param name file/directory name to be tagged (string)
         """
         dname, fname = self.splitPath(name)
         # find the root of the repo
         repodir = str(dname)
         while not os.path.isdir(os.path.join(repodir, self.adminDir)):
             repodir = os.path.dirname(repodir)
             if repodir == os.sep:
                 return
         dlg = HgTagDialog(self.tagsList)
         if dlg.exec_() == QDialog.Accepted:
             tag, tagOp = dlg.getParameters()
             if tag in self.tagsList:
                 self.tagsList.remove(tag)
             self.tagsList.insert(0, tag)
         else:
             return
         args = []
         args.append('tag')
         if tagOp == HgTagDialog.CreateLocalTag:
             args.append('--local')
         elif tagOp == HgTagDialog.DeleteTag:
             args.append('--remove')
         args.append('--message')
         if tagOp != HgTagDialog.DeleteTag:
             tag = tag.strip().replace(" ", "_")
             args.append("Created tag <{0}>.".format(tag))
         else:
             args.append("Removed tag <{0}>.".format(tag))
         args.append(tag)
         dia = HgDialog(self.trUtf8('Taging in the Mercurial repository'))
         res = dia.startProcess(args, repodir)
         if res:
             dia.exec_()
     def vcsRevert(self, name):
         """
         Public method used to revert changes made to a file/directory.
         @param name file/directory name to be reverted (string)
         """
         args = []
         args.append('revert')
         self.addArguments(args, self.options['global'])
         args.append("--no-backup")
         args.append("-v")
         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 repodir == os.sep:
                 return
         dia = HgDialog(self.trUtf8('Reverting changes'))
         res = dia.startProcess(args, repodir)
         if res:
             dia.exec_()
         self.checkVCSStatus()
     def vcsMerge(self, name):
         """
         Public method used to merge a URL/revision into the local project.
         @param name file/directory name to be merged (string)
         """
         dname, fname = self.splitPath(name)
         opts = self.options['global'][:]
         force = '--force' in opts
         if force:
             del opts[opts.index('--force')]
         dlg = HgMergeDialog(force, self.tagsList, self.branchesList)
         if dlg.exec_() == QDialog.Accepted:
             rev, force = dlg.getParameters()
         else:
             return
         # find the root of the repo
         repodir = dname
         while not os.path.isdir(os.path.join(repodir, self.adminDir)):
             repodir = os.path.dirname(repodir)
             if repodir == os.sep:
                 return
         args = []
         args.append('merge')
         self.addArguments(args, opts)
         if force:
             args.append("--force")
         if rev:
             args.append("--rev")
             args.append(rev)
         dia = HgDialog(self.trUtf8('Merging').format(name))
         res = dia.startProcess(args, repodir)
         if res:
             dia.exec_()
         self.checkVCSStatus()
     def vcsSwitch(self, name):
         """
         Public method used to switch a working directory to a different revision.
         @param name directory name to be switched (string)
         """
         dlg = HgRevisionSelectionDialog(self.tagsList, self.branchesList)
         if dlg.exec_() == QDialog.Accepted:
             rev = dlg.getRevision()
             self.vcsUpdate(name, revision = rev)
     def vcsRegisteredState(self, name):
         """
         Public method used to get the registered state of a file in the vcs.
         @param name filename to check (string)
         @return a combination of canBeCommited and canBeAdded
         """
         if name.endswith(os.sep):
             name = name[:-1]
         name = os.path.normcase(name)
         dname, fname = self.splitPath(name)
         if fname == '.' and os.path.isdir(os.path.join(dname, self.adminDir)):
             return self.canBeCommitted
         if name in self.statusCache:
             return self.statusCache[name]
         # find the root of the repo
         repodir = dname
         while not os.path.isdir(os.path.join(repodir, self.adminDir)):
             repodir = os.path.dirname(repodir)
             if repodir == os.sep:
                 return 0
         ioEncoding = Preferences.getSystem("IOEncoding")
         process = QProcess()
         args = []
         args.append('status')
         args.append('--all')
         args.append('--noninteractive')
         process.setWorkingDirectory(repodir)
         process.start('hg', args)
         procStarted = process.waitForStarted()
         if procStarted:
             finished = process.waitForFinished(30000)
             if finished and process.exitCode() == 0:
                 output = \
                     str(process.readAllStandardOutput(), ioEncoding, 'replace')
                 for line in output.splitlines():
                     flag, path = line.split(" ", 1)
                     absname = os.path.join(repodir, os.path.normcase(path))
                     if flag not in "?I":
                         if fname == '.':
                             if absname.startswith(dname + os.path.sep):
                                 return self.canBeCommitted
                             if absname == dname:
                                 return self.canBeCommitted
                         else:
                             if absname == name:
                                 return self.canBeCommitted
         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:
             # 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 repodir == os.sep:
                     return names
             ioEncoding = Preferences.getSystem("IOEncoding")
             process = QProcess()
             args = []
             args.append('status')
             args.append('--all')
             args.append('--noninteractive')
             process.setWorkingDirectory(dname)
             process.start('hg', args)
             procStarted = process.waitForStarted()
             if procStarted:
                 finished = process.waitForFinished(30000)
                 if finished and process.exitCode() == 0:
                     dirs = [x for x in names.keys() if os.path.isdir(x)]
                     output = \
                         str(process.readAllStandardOutput(), ioEncoding, 'replace')
                     for line in output.splitlines():
                         flag, path = line.split(" ", 1)
                         name = os.path.normcase(os.path.join(repodir, path))
                         dirName = os.path.dirname(name)
                         if name.startswith(dname):
                             if 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 vcsCleanup(self, name):
         """
         Public method used to cleanup the working directory.
         @param name directory name to be cleaned up (string)
         """
         patterns = ['*.orig', '*.rej']
         entries = []
         for pat in patterns:
             entries.extend(Utilities.direntries(name, True, pat))
         for entry in entries:
             try:
                 os.remove(entry)
             except OSError:
                 pass
     def vcsCommandLine(self, name):
         """
         Public method used to execute arbitrary mercurial commands.
         @param name directory name of the working directory (string)
         """
         dlg = HgCommandDialog(self.commandHistory, name)
         if dlg.exec_() == QDialog.Accepted:
             command = dlg.getData()
             commandList = Utilities.parseOptionString(command)
             # This moves any previous occurrence of these arguments to the head
             # of the list.
             if command in self.commandHistory:
                 self.commandHistory.remove(command)
             self.commandHistory.insert(0, command)
             args = []
             self.addArguments(args, commandList)
             # find the root of the repo
             repodir = name
             while not os.path.isdir(os.path.join(repodir, self.adminDir)):
                 repodir = os.path.dirname(repodir)
                 if repodir == os.sep:
                     return
             dia = HgDialog(self.trUtf8('Mercurial command'))
             res = dia.startProcess(args, repodir)
             if res:
                 dia.exec_()
     def vcsOptionsDialog(self, project, archive, editable = False, parent = None):
         """
         Public method to get a dialog to enter repository info.
         @param project reference to the project object
         @param archive name of the project in the repository (string)
         @param editable flag indicating that the project name is editable (boolean)
         @param parent parent widget (QWidget)
         """
         return 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 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)
         """
         info = []
         process = QProcess()
         args = []
         args.append('parents')
         args.append('--template')
         args.append('{rev}:{node|short}@@@{tags}@@@{author|xmlescape}@@@'
                     '{date|isodate}@@@{branches}\n')
         process.setWorkingDirectory(ppath)
         process.start('hg', args)
         procStarted = process.waitForStarted()
         if procStarted:
             finished = process.waitForFinished(30000)
             if finished and process.exitCode() == 0:
                 output = str(process.readAllStandardOutput(),
                     Preferences.getSystem("IOEncoding"), 'replace')
                 index = 0
                 for line in output.splitlines():
                     index += 1
                     changeset, tags, author, date, branches = line.split("@@@")
                     cdate, ctime = date.split()[:2]
                     info.append("""<p><table>""")
                     info.append(QApplication.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(QApplication.translate("mercurial",
                             """<tr><td><b>Tags</b></td><td>{0}</td></tr>""")\
                             .format('<br/>'.join(tags.split())))
                     if branches:
                         info.append(QApplication.translate("mercurial",
                             """<tr><td><b>Branches</b></td><td>{0}</td></tr>""")\
                             .format('<br/>'.join(branches.split())))
                     info.append(QApplication.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))
                     info.append("""</table></p>""")
         url = ""
         args =  []
         args.append('showconfig')
         args.append('paths.default')
         process.setWorkingDirectory(ppath)
         process.start('hg', args)
         procStarted = process.waitForStarted()
         if procStarted:
             finished = process.waitForFinished(30000)
             if finished and process.exitCode() == 0:
                 output = str(process.readAllStandardOutput(),
                     Preferences.getSystem("IOEncoding"), 'replace')
                 if output:
                     url = output.splitlines()[0].strip()
                 else:
                     url = ""
         return QApplication.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"""
             """</table></p>\n"""
             """{2}"""
             ).format(self.versionStr, url, "\n".join(info))
     ############################################################################
     ## Private Subversion specific methods are below.
     ############################################################################
     def __hgURL(self, url):
         """
         Private method to format a url for Mercurial.
         @param url unformatted url string (string)
         @return properly formated url for subversion (string)
         """
         url = self.hgNormalizeURL(url)
         url = url.split(':', 2)
         if len(url) == 4:
             scheme = url[0]
             user = url[1]
             host = url[2]
             port, path = url[3].split("/",1)
             return "{0}:{1}:{2}:{3}/{4}".format(
                 scheme, user, host, port, urllib.parse.quote(path))
         elif len(url) == 3:
             scheme = url[0]
             host = url[1]
             port, path = url[2].split("/",1)
             return "{0}:{1}:{2}/{3}".format(scheme, host, port, urllib.parse.quote(path))
         else:
             scheme = url[0]
             if scheme == "file":
                 return "{0}:{1}".format(scheme, urllib.parse.quote(url[1]))
             else:
                 host, path = url[1][2:].split("/",1)
                 return "{0}://{1}/{2}".format(scheme, host, urllib.parse.quote(path))
     def hgNormalizeURL(self, url):
         """
         Public method to normalize a url for Mercurial.
         @param url url string (string)
         @return properly normalized url for subversion (string)
         """
         url = url.replace('\\', '/')
         if url.endswith('/'):
             url = url[:-1]
         urll = url.split('//')
         return "{0}//{1}".format(urll[0], '/'.join(urll[1:]))
 




dd9f0bca5e2f
Added plugin for Mercurial version control system.

Detlev O&

Mercurial Repositories > eric / annotate

Plugins/VcsPlugins/vcsMercurial/hg.py@7a58aba00647 (annotated)

Plugins/VcsPlugins/vcsMercurial/hg.py