eric: Plugins/VcsPlugins/vcsPySvn/subversion.py@de9c2efb9d02 (annotated)

 # -*- coding: utf-8 -*-
 # Copyright (c) 2006 - 2009 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing the version control systems interface to Subversion.
 """
 import os
 import shutil
 import types
 import urllib
 import time
 from PyQt4.QtCore import *
 from PyQt4.QtGui import *
 from E4Gui.E4Application import e4App
 from VCS.VersionControl import VersionControl
 import pysvn
 from SvnDialog import SvnDialog
 from SvnCommitDialog import SvnCommitDialog
 from SvnLogDialog import SvnLogDialog
 from SvnLogBrowserDialog import SvnLogBrowserDialog
 from SvnDiffDialog import SvnDiffDialog
 from SvnRevisionSelectionDialog import SvnRevisionSelectionDialog
 from SvnStatusDialog import SvnStatusDialog
 from SvnTagDialog import SvnTagDialog
 from SvnTagBranchListDialog import SvnTagBranchListDialog
 from SvnCopyDialog import SvnCopyDialog
 from SvnCommandDialog import SvnCommandDialog
 from SvnSwitchDialog import SvnSwitchDialog
 from SvnMergeDialog import SvnMergeDialog
 from SvnPropListDialog import SvnPropListDialog
 from SvnPropSetDialog import SvnPropSetDialog
 from SvnPropDelDialog import SvnPropDelDialog
 from SvnOptionsDialog import SvnOptionsDialog
 from SvnNewProjectOptionsDialog import SvnNewProjectOptionsDialog
 from SvnBlameDialog import SvnBlameDialog
 from SvnInfoDialog import SvnInfoDialog
 from SvnRelocateDialog import SvnRelocateDialog
 from SvnUrlSelectionDialog import SvnUrlSelectionDialog
 from SvnRepoBrowserDialog import SvnRepoBrowserDialog
 from SvnStatusMonitorThread import SvnStatusMonitorThread
 from ProjectBrowserHelper import SvnProjectBrowserHelper
 from ProjectHelper import SvnProjectHelper
 from Plugins.VcsPlugins.vcsSubversion.SvnDialog import SvnDialog as SvnProcessDialog
 import Utilities
 class Subversion(VersionControl):
     """
     Class implementing the version control systems interface to Subversion.
     @signal committed() emitted after the commit action has completed
     """
     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.interestingDataKeys = [
             "standardLayout",
         ]
         self.__plugin = plugin
         self.__ui = parent
         self.options = self.defaultOptions
         self.otherData["standardLayout"] = True
         self.tagsList = []
         self.branchesList = []
         self.allTagsBranchesList = []
         self.mergeList = [[], [], []]
         self.showedTags = False
         self.showedBranches = False
         self.tagTypeList = [
             'tags',
             'branches'
         ]
         self.commandHistory = []
         self.wdHistory = []
         if pysvn.version >= (1, 4, 3, 0) and os.environ.has_key("SVN_ASP_DOT_NET_HACK"):
             self.adminDir = '_svn'
         else:
             self.adminDir = '.svn'
         self.log = None
         self.diff = None
         self.status = None
         self.propList = None
         self.tagbranchList = None
         self.blame = None
         self.repoBrowser = None
         self.logBrowser = None
         self.statusCache = {}
         self.__commitData = {}
         self.__commitDialog = None
     def getPlugin(self):
         """
         Public method to get a reference to the plugin object.
         @return reference to the plugin object (VcsPySvnPlugin)
         """
         return self.__plugin
     def getClient(self):
         """
         Public method to create and initialize the pysvn client object.
         @return the pysvn client object (pysvn.Client)
         """
         configDir = ""
         authCache = True
         for arg in self.options['global']:
             if arg.startswith("--config-dir"):
                 configDir = arg.split("=", 1)[1]
             if arg.startswith("--no-auth-cache"):
                 authCache = False
         client = pysvn.Client(configDir)
         client.exception_style = 1
         client.set_auth_cache(authCache)
         return client
     ############################################################################
     ## Methods of the VCS interface
     ############################################################################
     def vcsShutdown(self):
         """
         Public method used to shutdown the Subversion 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.propList is not None:
             self.propList.close()
         if self.tagbranchList is not None:
             self.tagbranchList.close()
         if self.blame is not None:
             self.blame.close()
         if self.repoBrowser is not None:
             self.repoBrowser.close()
         if self.logBrowser is not None:
             self.logBrowser.close()
     def vcsExists(self):
         """
         Public method used to test for the presence of the svn executable.
         @return flag indicating the existance (boolean) and an error message (string)
         """
         self.versionStr = ".".join([str(v) for v in pysvn.svn_version[:-1]])
         return True, ""
     def vcsInit(self, vcsDir, noDialog = False):
         """
         Public method used to initialize the subversion repository.
         The subversion repository has to be initialized from outside eric4
         because the respective command always works locally. 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:
             QMessageBox.critical(None,
                 self.trUtf8("Create project in repository"),
                 self.trUtf8("""The project could not be created in the repository."""
                             """ Maybe the given repository doesn't exist or the"""
                             """ repository server is down."""))
         else:
             cwdIsPpath = False
             if os.getcwd() == project.ppath:
                 os.chdir(os.path.dirname(project.ppath))
                 cwdIsPpath = True
             tmpProjectDir = "%s_tmp" % project.ppath
             shutil.rmtree(tmpProjectDir, True)
             os.rename(project.ppath, tmpProjectDir)
             os.makedirs(project.ppath)
             self.vcsCheckout(vcsDataDict, project.ppath)
             if cwdIsPpath:
                 os.chdir(project.ppath)
             self.vcsCommit(project.ppath, vcsDataDict["message"], True)
             pfn = project.pfile
             if not os.path.isfile(pfn):
                 pfn += "z"
             if not os.path.isfile(pfn):
                 QMessageBox.critical(None,
                     self.trUtf8("New project"),
                     self.trUtf8("""The project could not be checked out of the"""
                                 """ repository.<br />"""
                                 """Restoring the original contents."""))
                 if os.getcwd() == project.ppath:
                     os.chdir(os.path.dirname(project.ppath))
                     cwdIsPpath = True
                 else:
                     cwdIsPpath = False
                 shutil.rmtree(project.ppath, True)
                 os.rename(tmpProjectDir, project.ppath)
                 project.pdata["VCS"] = ['None']
                 project.vcs = None
                 project.setDirty(True)
                 project.saveProject()
                 project.closeProject()
                 return
             shutil.rmtree(tmpProjectDir, True)
             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)
         """
         noDialog = False
         msg = vcsDataDict["message"]
         if not msg:
             msg = '***'
         vcsDir = self.svnNormalizeURL(vcsDataDict["url"])
         if vcsDir.startswith('/'):
             vcsDir = 'file://%s' % vcsDir
         elif vcsDir[1] in ['|', ':']:
             vcsDir = 'file:///%s' % vcsDir
         project = vcsDir[vcsDir.rfind('/') + 1:]
         # create the dir structure to be imported into the repository
         tmpDir = '%s_tmp' % projectDir
         try:
             os.makedirs(tmpDir)
             if self.otherData["standardLayout"]:
                 os.mkdir(os.path.join(tmpDir, project))
                 os.mkdir(os.path.join(tmpDir, project, 'branches'))
                 os.mkdir(os.path.join(tmpDir, project, 'tags'))
                 shutil.copytree(projectDir, os.path.join(tmpDir, project, 'trunk'))
             else:
                 shutil.copytree(projectDir, os.path.join(tmpDir, project))
         except OSError, e:
             if os.path.isdir(tmpDir):
                 shutil.rmtree(tmpDir, True)
             return False, False
         locker = QMutexLocker(self.vcsExecutionMutex)
         cwd = os.getcwd()
         os.chdir(os.path.join(tmpDir, project))
         opts = self.options['global'] + self.options['update']
         recurse = "--non-recursive" not in opts
         ignore = "--ignore" in opts
         url = self.__svnURL(vcsDir)
         client = self.getClient()
         if not noDialog:
             dlg = \
                 SvnDialog(self.trUtf8('Importing project into Subversion repository'),
                           "import%s%s --message %s ." % \
                             ((not recurse) and " --non-recursive" or "",
                              ignore and " --ignore" or "",
                              msg),
                     client)
             QApplication.processEvents()
         try:
             rev = client.import_(".", url, msg, recurse, ignore)
             status = True
         except pysvn.ClientError, e:
             status = False
             rev = None
             if not noDialog:
                 dlg.showError(e.args[0])
         locker.unlock()
         if not noDialog:
             rev and dlg.showMessage(self.trUtf8("Imported revision {0}.\n")\
                                           .format(rev.number))
             dlg.finish()
             dlg.exec_()
         os.chdir(cwd)
         shutil.rmtree(tmpDir, True)
         return status, False
     def vcsCheckout(self, vcsDataDict, projectDir, noDialog = False):
         """
         Public method used to check the project out of the Subversion repository.
         @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:
             tag = vcsDataDict["tag"]
         except KeyError:
             tag = None
         vcsDir = self.svnNormalizeURL(vcsDataDict["url"])
         if vcsDir.startswith('/'):
             vcsDir = 'file://%s' % vcsDir
         elif vcsDir[1] in ['|', ':']:
             vcsDir = 'file:///%s' % vcsDir
         if self.otherData["standardLayout"]:
             if tag is None or tag == '':
                 svnUrl = '%s/trunk' % vcsDir
             else:
                 if not tag.startswith('tags') and not tag.startswith('branches'):
                     type_, ok = QInputDialog.getItem(\
                         None,
                         self.trUtf8("Subversion Checkout"),
                         self.trUtf8("The tag must be a normal tag (tags) or"
                             " a branch tag (branches)."
                             " Please select from the list."),
                         self.tagTypeList,
 , False)
                     if not ok:
                         return False
                     tag = '%s/%s' % (type_, tag)
                 svnUrl = '%s/%s' % (vcsDir, tag)
         else:
             svnUrl = vcsDir
         opts = self.options['global'] + self.options['checkout']
         recurse = "--non-recursive" not in opts
         url = self.__svnURL(svnUrl)
         client = self.getClient()
         if not noDialog:
             dlg = \
                 SvnDialog(self.trUtf8('Checking project out of Subversion repository'),
                           "checkout%s %s %s" % \
                             ((not recurse) and " --non-recursive" or "",
                              url, projectDir),
                     client)
             QApplication.processEvents()
         locker = QMutexLocker(self.vcsExecutionMutex)
         try:
             rev = client.checkout(url, projectDir, recurse)
             status = True
         except pysvn.ClientError, e:
             status = False
             if not noDialog:
                 dlg.showError(e.args[0])
         locker.unlock()
         if not noDialog:
             dlg.finish()
             dlg.exec_()
         return status
     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)
         """
         try:
             tag = vcsDataDict["tag"]
         except KeyError:
             tag = None
         vcsDir = self.svnNormalizeURL(vcsDataDict["url"])
         if vcsDir.startswith('/') or vcsDir[1] == '|':
             vcsDir = 'file://%s' % vcsDir
         if self.otherData["standardLayout"]:
             if tag is None or tag == '':
                 svnUrl = '%s/trunk' % vcsDir
             else:
                 if not tag.startswith('tags') and not tag.startswith('branches'):
                     type_, ok = QInputDialog.getItem(\
                         None,
                         self.trUtf8("Subversion Export"),
                         self.trUtf8("The tag must be a normal tag (tags) or"
                             " a branch tag (branches)."
                             " Please select from the list."),
                         self.tagTypeList,
 , False)
                     if not ok:
                         return False
                     tag = '%s/%s' % (type_, tag)
                 svnUrl = '%s/%s' % (vcsDir, tag)
         else:
             svnUrl = vcsDir
         opts = self.options['global']
         recurse = "--non-recursive" not in opts
         url = self.__svnURL(svnUrl)
         client = self.getClient()
         dlg = \
             SvnDialog(self.trUtf8('Exporting project from Subversion repository'),
                       "export --force%s %s %s" % \
                         ((not recurse) and " --non-recursive" or "",
                          url, projectDir),
                 client)
         QApplication.processEvents()
         locker = QMutexLocker(self.vcsExecutionMutex)
         try:
             rev = client.export(url, projectDir, force = True, recurse = recurse)
             status = True
         except pysvn.ClientError, e:
             status = False
             dlg.showError(e.args[0])
         locker.unlock()
         dlg.finish()
         dlg.exec_()
         return status
     def vcsCommit(self, name, message, noDialog = False):
         """
         Public method used to make the change of a file/directory permanent in the
         Subversion 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
         """
         if not noDialog and not message:
             # call CommitDialog and get message from there
             if self.__commitDialog is None:
                 self.__commitDialog = SvnCommitDialog(self.__ui)
                 self.connect(self.__commitDialog, SIGNAL("accepted()"),
                              self.__vcsCommit_Step2)
             self.__commitDialog.show()
             self.__commitDialog.raise_()
             self.__commitDialog.activateWindow()
         self.__commitData["name"] = name
         self.__commitData["msg"] = message
         self.__commitData["noDialog"] = noDialog
         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"]
         if self.__commitDialog is not None:
             msg = self.__commitDialog.logMessage()
             if self.__commitDialog.hasChangelists():
                 changelists, keepChangelists = self.__commitDialog.changelistsData()
             else:
                 changelists, keepChangelists = [], False
             self.disconnect(self.__commitDialog, SIGNAL("accepted()"),
                             self.__vcsCommit_Step2)
             self.__commitDialog = None
         else:
             changelists, keepChangelists = [], False
         if not msg:
             msg = '***'
         if type(name) is types.ListType:
             dname, fnames = self.splitPathList(name)
         else:
             dname, fname = self.splitPath(name)
             fnames = [fname]
         if self.svnGetReposName(dname).startswith('http') or \
            self.svnGetReposName(dname).startswith('svn'):
             noDialog = False
         locker = QMutexLocker(self.vcsExecutionMutex)
         cwd = os.getcwd()
         os.chdir(dname)
         opts = self.options['global'] + self.options['commit']
         recurse = "--non-recursive" not in opts
         keeplocks = "--keep-locks" in opts
         client = self.getClient()
         if not noDialog:
             dlg = \
                 SvnDialog(self.trUtf8('Commiting changes to Subversion repository'),
                           "commit%s%s%s%s --message %s %s" % \
                             ((not recurse) and " --non-recursive" or "",
                              keeplocks and " --keep-locks" or "",
                              keepChangelists and " --keep-changelists" or "",
                              changelists and \
                                 " --changelist ".join([""] + changelists) or "",
                              msg, " ".join(fnames)),
                     client)
             QApplication.processEvents()
         try:
             if changelists:
                 rev = client.checkin(fnames, msg,
                                      recurse = recurse, keep_locks = keeplocks,
                                      keep_changelist = keepChangelists,
                                      changelists = changelists)
             else:
                 rev = client.checkin(fnames, msg,
                                      recurse = recurse, keep_locks = keeplocks)
         except pysvn.ClientError, e:
             rev = None
             if not noDialog:
                 dlg.showError(e.args[0])
         locker.unlock()
         if not noDialog:
             rev and dlg.showMessage(self.trUtf8("Committed revision {0}.")\
                 .format(rev.number))
             dlg.finish()
             dlg.exec_()
         os.chdir(cwd)
         self.emit(SIGNAL("committed()"))
         self.checkVCSStatus()
     def vcsUpdate(self, name, noDialog = False):
         """
         Public method used to update a file/directory with the Subversion repository.
         @param name file/directory name to be updated (string or list of strings)
         @param noDialog flag indicating quiet operations (boolean)
         @return flag indicating, that the update contained an add
             or delete (boolean)
         """
         if type(name) is types.ListType:
             dname, fnames = self.splitPathList(name)
         else:
             dname, fname = self.splitPath(name)
             fnames = [fname]
         locker = QMutexLocker(self.vcsExecutionMutex)
         cwd = os.getcwd()
         os.chdir(dname)
         opts = self.options['global'] + self.options['update']
         recurse = "--non-recursive" not in opts
         client = self.getClient()
         if not noDialog:
             dlg = \
                 SvnDialog(self.trUtf8('Synchronizing with the Subversion repository'),
                           "update%s %s" % ((not recurse) and " --non-recursive" or "",
                             " ".join(fnames)),
                     client)
         QApplication.processEvents()
         try:
             revlist = client.update(fnames, recurse)
         except pysvn.ClientError, e:
             dlg.showError(e.args[0])
         locker.unlock()
         if not noDialog:
             dlg.finish()
             dlg.exec_()
             res = dlg.hasAddOrDelete()
         else:
             res = False
         os.chdir(cwd)
         self.checkVCSStatus()
         return res
     def vcsAdd(self, name, isDir = False, noDialog = False):
         """
         Public method used to add a file/directory to the Subversion 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 (boolean)
         """
         if type(name) is types.ListType:
             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)
         names = []
         tree = []
         wdir = dname
         while not os.path.exists(os.path.join(dname, self.adminDir)):
             # add directories recursively, if they aren't in the repository already
             tree.insert(-1, dname)
             dname = os.path.split(dname)[0]
             wdir = dname
         names.extend(tree)
         if type(name) is types.ListType:
             tree2 = []
             for n in name:
                 d = os.path.split(n)[0]
                 while not os.path.exists(os.path.join(d, self.adminDir)):
                     if d in tree2 + tree:
                         break
                     tree2.append(d)
                     d = os.path.split(d)[0]
             tree2.reverse()
             names.extend(tree2)
             names.extend(name)
         else:
             names.append(name)
         locker = QMutexLocker(self.vcsExecutionMutex)
         cwd = os.getcwd()
         os.chdir(wdir)
         opts = self.options['global'] + self.options['add']
         recurse = False
         force = "--force" in opts or noDialog
         ignore = "--ignore" in opts
         client = self.getClient()
         if not noDialog:
             dlg = \
                 SvnDialog(\
                     self.trUtf8('Adding files/directories to the Subversion repository'),
                         "add --non-recursive%s%s %s" % \
                             (force and " --force" or "",
                              ignore and " --ignore" or "",
                              " ".join(names)),
                     client)
             QApplication.processEvents()
         try:
             client.add(names, recurse = recurse, force = force, ignore = ignore)
         except pysvn.ClientError, e:
             if not noDialog:
                 dlg.showError(e.args[0])
         locker.unlock()
         if not noDialog:
             dlg.finish()
             dlg.exec_()
         os.chdir(cwd)
     def vcsAddBinary(self, name, isDir = False):
         """
         Public method used to add a file/directory in binary mode to the
         Subversion 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 Subversion repository.
         @param path root directory of the tree to be added (string or list of strings))
         """
         tree = []
         if type(path) is types.ListType:
             dname, fnames = self.splitPathList(path)
             for n in path:
                 d = os.path.split(n)[0]
                 while not os.path.exists(os.path.join(d, self.adminDir)):
                     # add directories recursively,
                     # if they aren't in the repository already
                     if d in tree:
                         break
                     tree.append(d)
                     d = os.path.split(d)[0]
             tree.reverse()
         else:
             dname, fname = os.path.split(path)
             while not os.path.exists(os.path.join(dname, self.adminDir)):
                 # add directories recursively,
                 # if they aren't in the repository already
                 tree.insert(-1, dname)
                 dname = os.path.split(dname)[0]
         if tree:
             self.vcsAdd(tree, True)
         names = []
         if type(path) is types.ListType:
             names.extend(path)
         else:
             names.append(path)
         locker = QMutexLocker(self.vcsExecutionMutex)
         cwd = os.getcwd()
         os.chdir(dname)
         opts = self.options['global'] + self.options['add']
         recurse = True
         force = "--force" in opts
         ignore = "--ignore" in opts
         client = self.getClient()
         dlg = \
             SvnDialog(\
                 self.trUtf8('Adding directory trees to the Subversion repository'),
                     "add%s%s %s" % \
                         (force and " --force" or "",
                          ignore and " --ignore" or "",
                          " ".join(names)),
                 client)
         QApplication.processEvents()
         try:
             client.add(names, recurse = recurse, force = force, ignore = ignore)
         except pysvn.ClientError, e:
             dlg.showError(e.args[0])
         locker.unlock()
         dlg.finish()
         dlg.exec_()
         os.chdir(cwd)
     def vcsRemove(self, name, project = False, noDialog = False):
         """
         Public method used to remove a file/directory from the Subversion 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)
         """
         if type(name) is not types.ListType:
             name = [name]
         opts = self.options['global'] + self.options['remove']
         force = "--force" in opts or noDialog
         client = self.getClient()
         if not noDialog:
             dlg = \
                 SvnDialog(\
                     self.trUtf8('Removing files/directories from the Subversion repository'),
                         "remove%s %s" % \
                             (force and " --force" or "",
                              " ".join(name)),
                     client)
             QApplication.processEvents()
         locker = QMutexLocker(self.vcsExecutionMutex)
         try:
             client.remove(name, force = force)
             res = True
         except pysvn.ClientError, e:
             res = False
             if not noDialog:
                 dlg.showError(e.args[0])
         locker.unlock()
         if not noDialog:
             dlg.finish()
             dlg.exec_()
         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)
         """
         rx_prot = QRegExp('(file:|svn:|svn+ssh:|http:|https:).+')
         opts = self.options['global']
         res = False
         if noDialog:
             if target is None:
                 return False
             force = True
             accepted = True
         else:
             dlg = SvnCopyDialog(name, None, True, "--force" in opts)
             accepted = (dlg.exec_() == QDialog.Accepted)
             if accepted:
                 target, force = dlg.getData()
         if accepted:
             client = self.getClient()
             if rx_prot.exactMatch(target):
                 target = self.__svnURL(target)
                 log = "Moving %s to %s" % (name, target)
             else:
                 log = ""
                 target = target
             if not noDialog:
                 dlg = \
                     SvnDialog(\
                         self.trUtf8('Moving {0}').format(name),
                             "move%s%s %s %s" % \
                                 (force and " --force" or "",
                                 log and (" --message %s" % log) or "",
                                 name, target),
                         client, log = log)
                 QApplication.processEvents()
             locker = QMutexLocker(self.vcsExecutionMutex)
             try:
                 client.move(name, target, force = force)
                 res = True
             except pysvn.ClientError, e:
                 res = False
                 if not noDialog:
                     dlg.showError(e.args[0])
             locker.unlock()
             if not noDialog:
                 dlg.finish()
                 dlg.exec_()
             if res and not rx_prot.exactMatch(target):
                 if target.startswith(project.getProjectPath()):
                     if os.path.isdir(name):
                         project.moveDirectory(name, target)
                     else:
                         project.renameFileInPdata(name, target)
                 else:
                     if os.path.isdir(name):
                         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
         Subversion repository.
         @param name file/directory name to show the log of (string)
         """
         self.log = SvnLogDialog(self)
         self.log.show()
         QApplication.processEvents()
         self.log.start(name)
     def vcsDiff(self, name):
         """
         Public method used to view the difference of a file/directory to the
         Subversion 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 type(name) is types.ListType:
             names = name[:]
         else:
             names = [name]
         for nam in names:
             if os.path.isfile(nam):
                 editor = e4App().getObject("ViewManager").getOpenEditor(nam)
                 if editor and not editor.checkDirty() :
                     return
             else:
                 project = e4App().getObject("Project")
                 if nam == project.ppath and not project.saveAllScripts():
                     return
         self.diff = SvnDiffDialog(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
         Subversion repository.
         @param name file/directory name(s) to show the status of
             (string or list of strings)
         """
         self.status = SvnStatusDialog(self)
         self.status.show()
         QApplication.processEvents()
         self.status.start(name)
     def vcsTag(self, name):
         """
         Public method used to set the tag of a file/directory in the
         Subversion repository.
         @param name file/directory name to be tagged (string)
         """
         dname, fname = self.splitPath(name)
         reposURL = self.svnGetReposName(dname)
         if reposURL is None:
             QMessageBox.critical(None,
                 self.trUtf8("Subversion Error"),
                 self.trUtf8("""The URL of the project repository could not be"""
                     """ retrieved from the working copy. The tag operation will"""
                     """ be aborted"""))
             return
         if self.otherData["standardLayout"]:
             url = None
         else:
             url = self.svnNormalizeURL(reposURL)
         dlg = SvnTagDialog(self.allTagsBranchesList, url,
                            self.otherData["standardLayout"])
         if dlg.exec_() == QDialog.Accepted:
             tag, tagOp = dlg.getParameters()
             if tag in self.allTagsBranchesList:
                 self.allTagsBranchesList.remove(tag)
             self.allTagsBranchesList.insert(0, tag)
         else:
             return
         if self.otherData["standardLayout"]:
             rx_base = QRegExp('(.+)/(trunk|tags|branches).*')
             if not rx_base.exactMatch(reposURL):
                 QMessageBox.critical(None,
                     self.trUtf8("Subversion Error"),
                     self.trUtf8("""The URL of the project repository has an"""
                         """ invalid format. The tag operation will"""
                         """ be aborted"""))
                 return
             reposRoot = rx_base.cap(1)
             if tagOp in [1, 4]:
                 url = '%s/tags/%s' % (reposRoot, urllib.quote(tag))
             elif tagOp in [2, 8]:
                 url = '%s/branches/%s' % (reposRoot, urllib.quote(tag))
         else:
             url = self.__svnURL(unicode(tag))
         self.tagName = tag
         client = self.getClient()
         rev = None
         if tagOp in [1, 2]:
             log = 'Created tag <%s>' % self.tagName
             dlg = \
                 SvnDialog(\
                     self.trUtf8('Tagging {0} in the Subversion repository').format(name),
                         "copy --message %s %s %s" % (log, reposURL, url),
                     client, log = log)
             QApplication.processEvents()
             locker = QMutexLocker(self.vcsExecutionMutex)
             try:
                 rev = client.copy(reposURL, url)
             except pysvn.ClientError, e:
                 dlg.showError(e.args[0])
             locker.unlock()
         else:
             log = 'Deleted tag <%s>' % self.tagName
             dlg = \
                 SvnDialog(\
                     self.trUtf8('Tagging {0} in the Subversion repository').format(name),
                         "remove --message %s %s" % (log, url),
                     client, log = log)
             QApplication.processEvents()
             locker = QMutexLocker(self.vcsExecutionMutex)
             try:
                 rev = client.remove(url)
             except pysvn.ClientError, e:
                 dlg.showError(e.args[0])
             locker.unlock()
         rev and dlg.showMessage(\
             self.trUtf8("Revision {0}.\n").format(rev.number))
         dlg.finish()
         dlg.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)
         """
         recurse = False
         if type(name) is not types.ListType:
             name = [name]
             if os.path.isdir(name[0]):
                 recurse = True
         client = self.getClient()
         dlg = \
             SvnDialog(self.trUtf8('Reverting changes'),
                       "revert %s %s" % ((not recurse) and " --non-recursive" or "",
                         " ".join(name)),
                 client)
         QApplication.processEvents()
         locker = QMutexLocker(self.vcsExecutionMutex)
         try:
             client.revert(name, recurse)
         except pysvn.ClientError, e:
             dlg.showError(e.args[0])
         locker.unlock()
         dlg.finish()
         dlg.exec_()
         self.checkVCSStatus()
     def vcsSwitch(self, name):
         """
         Public method used to switch a directory to a different tag/branch.
         @param name directory name to be switched (string)
         """
         dname, fname = self.splitPath(name)
         reposURL = self.svnGetReposName(dname)
         if reposURL is None:
             QMessageBox.critical(None,
                 self.trUtf8("Subversion Error"),
                 self.trUtf8("""The URL of the project repository could not be"""
                     """ retrieved from the working copy. The switch operation will"""
                     """ be aborted"""))
             return
         if self.otherData["standardLayout"]:
             url = None
         else:
             url = self.svnNormalizeURL(reposURL)
         dlg = SvnSwitchDialog(self.allTagsBranchesList, url,
                               self.otherData["standardLayout"])
         if dlg.exec_() == QDialog.Accepted:
             tag, tagType = dlg.getParameters()
             if tag in self.allTagsBranchesList:
                 self.allTagsBranchesList.remove(tag)
             self.allTagsBranchesList.insert(0, tag)
         else:
             return
         if self.otherData["standardLayout"]:
             rx_base = QRegExp('(.+)/(trunk|tags|branches).*')
             if not rx_base.exactMatch(reposURL):
                 QMessageBox.critical(None,
                     self.trUtf8("Subversion Error"),
                     self.trUtf8("""The URL of the project repository has an"""
                         """ invalid format. The switch operation will"""
                         """ be aborted"""))
                 return
             reposRoot = rx_base.cap(1)
             tn = tag
             if tagType == 1:
                 url = '%s/tags/%s' % (reposRoot, urllib.quote(tag))
             elif tagType == 2:
                 url = '%s/branches/%s' % (reposRoot, urllib.quote(tag))
             elif tagType == 4:
                 url = '%s/trunk' % (reposRoot)
                 tn = QString('HEAD')
         else:
             url = self.__svnURL(tag)
             tn = url
         client = self.getClient()
         dlg = \
             SvnDialog(self.trUtf8('Switching to {0}').format(tn),
                       "switch %s %s" % (url, name),
                 client)
         QApplication.processEvents()
         locker = QMutexLocker(self.vcsExecutionMutex)
         try:
             rev = client.switch(name, url)
             dlg.showMessage(self.trUtf8("Revision {0}.\n").format(rev.number))
         except pysvn.ClientError, e:
             dlg.showError(e.args[0])
         locker.unlock()
         dlg.finish()
         dlg.exec_()
     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']
         dlg = SvnMergeDialog(self.mergeList[0], self.mergeList[1], self.mergeList[2],
                              "--force" in opts)
         if dlg.exec_() == QDialog.Accepted:
             urlrev1, urlrev2, target, force = dlg.getParameters()
         else:
             return
         # remember URL or revision
         if urlrev1 in self.mergeList[0]:
             self.mergeList[0].remove(urlrev1)
         self.mergeList[0].insert(0, urlrev1)
         if urlrev2 in self.mergeList[1]:
             self.mergeList[1].remove(urlrev2)
         self.mergeList[1].insert(0, urlrev2)
         rx_rev = QRegExp('\\d+|HEAD|head')
         locker = QMutexLocker(self.vcsExecutionMutex)
         cwd = os.getcwd()
         os.chdir(dname)
         recurse = "--non-recursive" not in opts
         if rx_rev.exactMatch(urlrev1):
             if urlrev1 in ["HEAD", "head"]:
                 revision1 = pysvn.Revision(pysvn.opt_revision_kind.head)
                 rev1 = "HEAD"
             else:
                 revision1 = \
                     pysvn.Revision(pysvn.opt_revision_kind.number, int(urlrev1)[0])
                 rev1 = urlrev1
             if urlrev2 in ["HEAD", "head"]:
                 revision2 = pysvn.Revision(pysvn.opt_revision_kind.head)
                 rev2 = "HEAD"
             else:
                 revision2 = \
                     pysvn.Revision(pysvn.opt_revision_kind.number, int(urlrev2)[0])

Mercurial Repositories > eric / annotate

Plugins/VcsPlugins/vcsPySvn/subversion.py@de9c2efb9d02 (annotated)

Plugins/VcsPlugins/vcsPySvn/subversion.py