eric: Plugins/VcsPlugins/vcsSubversion/subversion.py@f08c20c91de7 (annotated)

 # -*- coding: utf-8 -*-
 # Copyright (c) 2003 - 2013 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing the version control systems interface to Subversion.
 """
 import os
 import re
 import shutil
 import urllib.parse
 from PyQt4.QtCore import pyqtSignal, QProcess, QRegExp
 from PyQt4.QtGui import QLineEdit, QDialog, QInputDialog, QApplication
 from E5Gui.E5Application import e5App
 from E5Gui import E5MessageBox
 from VCS.VersionControl import VersionControl
 from .SvnDialog import SvnDialog
 from .SvnUtilities import getConfigPath, amendConfig, createDefaultConfig
 import Preferences
 import Utilities
 class Subversion(VersionControl):
     """
     Class implementing the version control systems interface to Subversion.
     @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.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 "SVN_ASP_DOT_NET_HACK" in os.environ:
             self.adminDir = '_svn'
         else:
             self.adminDir = '.svn'
         self.log = None
         self.diff = None
         self.sbsDiff = None
         self.status = None
         self.propList = None
         self.tagbranchList = None
         self.blame = None
         self.repoBrowser = None
         # regular expression object for evaluation of the status output
         self.rx_status1 = QRegExp(
             '(.{8})\\s+([0-9-]+)\\s+([0-9?]+)\\s+(\\S+)\\s+(.+)')
         self.rx_status2 = QRegExp('(.{8})\\s+(.+)\\s*')
         self.statusCache = {}
         self.__commitData = {}
         self.__commitDialog = None
         self.__wcng = True      # assume new generation working copy
                                 # metadata format
     def getPlugin(self):
         """
         Public method to get a reference to the plugin object.
         @return reference to the plugin object (VcsSubversionPlugin)
         """
         return self.__plugin
     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.sbsDiff is not None:
             self.sbsDiff.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()
     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 = ''
         errMsg = ""
         ioEncoding = Preferences.getSystem("IOEncoding")
         process = QProcess()
         process.start('svn', ['--version'])
         procStarted = process.waitForStarted(5000)
         if procStarted:
             finished = process.waitForFinished(30000)
             if finished and process.exitCode() == 0:
                 output = \
                     str(process.readAllStandardOutput(), ioEncoding, 'replace')
                 self.versionStr = output.split()[2]
                 v = list(re.match(r'.*?(\d+)\.(\d+)\.?(\d+)?', self.versionStr)
                          .groups())
                 for i in range(3):
                     try:
                         v[i] = int(v[i])
                     except TypeError:
                         v[i] = 0
                     except IndexError:
                         v.append(0)
                 self.version = tuple(v)
                 return True, errMsg
             else:
                 if finished:
                     errMsg = self.trUtf8(
                         "The svn process finished with the exit code {0}")\
                         .format(process.exitCode())
                 else:
                     errMsg = self.trUtf8(
                         "The svn process did not finish within 30s.")
         else:
             errMsg = self.trUtf8("Could not start the svn executable.")
         return False, errMsg
     def vcsInit(self, vcsDir, noDialog=False):
         """
         Public method used to initialize the subversion repository.
         The subversion repository has to be initialized from outside eric5
         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:
             E5MessageBox.critical(
                 self.__ui,
                 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 = "{0}_tmp".format(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):
                 E5MessageBox.critical(
                     self.__ui,
                     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.closeProject(noSave=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 control status (boolean)
         """
         noDialog = False
         msg = vcsDataDict["message"]
         if not msg:
             msg = '***'
         vcsDir = self.svnNormalizeURL(vcsDataDict["url"])
         if vcsDir.startswith('/'):
             vcsDir = 'file://{0}'.format(vcsDir)
         elif vcsDir[1] in ['|', ':']:
             vcsDir = 'file:///{0}'.format(vcsDir)
         project = vcsDir[vcsDir.rfind('/') + 1:]
         # create the dir structure to be imported into the repository
         tmpDir = '{0}_tmp'.format(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:
             if os.path.isdir(tmpDir):
                 shutil.rmtree(tmpDir, True)
             return False, False
         args = []
         args.append('import')
         self.addArguments(args, self.options['global'])
         args.append('-m')
         args.append(msg)
         args.append(self.__svnURL(vcsDir))
         if noDialog:
             status = self.startSynchronizedProcess(
                 QProcess(), "svn", args, os.path.join(tmpDir, project))
         else:
             dia = SvnDialog(
                 self.trUtf8('Importing project into Subversion repository'))
             res = dia.startProcess(args, os.path.join(tmpDir, project))
             if res:
                 dia.exec_()
             status = dia.normalExit()
         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://{0}'.format(vcsDir)
         elif vcsDir[1] in ['|', ':']:
             vcsDir = 'file:///{0}'.format(vcsDir)
         if self.otherData["standardLayout"]:
             if tag is None or tag == '':
                 svnUrl = '{0}/trunk'.format(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 = '{0}/{1}'.format(type, tag)
                 svnUrl = '{0}/{1}'.format(vcsDir, tag)
         else:
             svnUrl = vcsDir
         args = []
         args.append('checkout')
         self.addArguments(args, self.options['global'])
         self.addArguments(args, self.options['checkout'])
         args.append(self.__svnURL(svnUrl))
         args.append(projectDir)
         if noDialog:
             return self.startSynchronizedProcess(QProcess(), 'svn', args)
         else:
             dia = SvnDialog(
                 self.trUtf8('Checking project out of Subversion 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)
         """
         try:
             tag = vcsDataDict["tag"]
         except KeyError:
             tag = None
         vcsDir = self.svnNormalizeURL(vcsDataDict["url"])
         if vcsDir.startswith('/') or vcsDir[1] == '|':
             vcsDir = 'file://{0}'.format(vcsDir)
         if self.otherData["standardLayout"]:
             if tag is None or tag == '':
                 svnUrl = '{0}/trunk'.format(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 = '{0}/{1}'.format(type, tag)
                 svnUrl = '{0}/{1}'.format(vcsDir, tag)
         else:
             svnUrl = vcsDir
         args = []
         args.append('export')
         self.addArguments(args, self.options['global'])
         args.append("--force")
         args.append(self.__svnURL(svnUrl))
         args.append(projectDir)
         dia = SvnDialog(
             self.trUtf8('Exporting project from Subversion repository'))
         res = dia.startProcess(args)
         if res:
             dia.exec_()
         return dia.normalExit()
     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
         """
         msg = message
         if not noDialog and not msg:
             # call CommitDialog and get message from there
             if self.__commitDialog is None:
                 from .SvnCommitDialog import SvnCommitDialog
                 self.__commitDialog = SvnCommitDialog(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
         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 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.trUtf8("Commit Changes"),
                     self.trUtf8(
                         """The commit affects files, that have unsaved"""
                         """ changes. Shall the commit be continued?"""),
                     icon=E5MessageBox.Warning)
                 if not res:
                     return
         if self.__commitDialog is not None:
             msg = self.__commitDialog.logMessage()
             if self.__commitDialog.hasChangelists():
                 changelists, keepChangelists = \
                     self.__commitDialog.changelistsData()
             else:
                 changelists, keepChangelists = [], False
             self.__commitDialog.deleteLater()
             self.__commitDialog = None
         else:
             changelists, keepChangelists = [], False
         if not msg:
             msg = '***'
         args = []
         args.append('commit')
         self.addArguments(args, self.options['global'])
         self.addArguments(args, self.options['commit'])
         if keepChangelists:
             args.append("--keep-changelists")
         for changelist in changelists:
             args.append("--changelist")
             args.append(changelist)
         args.append("-m")
         args.append(msg)
         if isinstance(name, list):
             dname, fnames = self.splitPathList(name)
             self.addArguments(args, fnames)
         else:
             dname, fname = self.splitPath(name)
             args.append(fname)
         if self.svnGetReposName(dname).startswith('http') or \
            self.svnGetReposName(dname).startswith('svn'):
             noDialog = False
         if noDialog:
             self.startSynchronizedProcess(QProcess(), "svn", args, dname)
         else:
             dia = SvnDialog(
                 self.trUtf8('Commiting changes to Subversion repository'))
             res = dia.startProcess(args, dname)
             if res:
                 dia.exec_()
         self.committed.emit()
         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)
         """
         args = []
         args.append('update')
         self.addArguments(args, self.options['global'])
         self.addArguments(args, self.options['update'])
         if self.version >= (1, 5, 0):
             args.append('--accept')
             args.append('postpone')
         if isinstance(name, list):
             dname, fnames = self.splitPathList(name)
             self.addArguments(args, fnames)
         else:
             dname, fname = self.splitPath(name)
             args.append(fname)
         if noDialog:
             self.startSynchronizedProcess(QProcess(), "svn", args, dname)
             res = False
         else:
             dia = SvnDialog(
                 self.trUtf8('Synchronizing with the Subversion repository'))
             res = dia.startProcess(args, dname, True)
             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 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
         """
         args = []
         args.append('add')
         self.addArguments(args, self.options['global'])
         self.addArguments(args, self.options['add'])
         args.append('--non-recursive')
         if noDialog and '--force' not in args:
             args.append('--force')
         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)
         tree = []
         wdir = dname
         if self.__wcng:
             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  # oops, project is not version controlled
             while os.path.normcase(dname) != os.path.normcase(repodir) and \
                     (os.path.normcase(dname) not in self.statusCache or
                      self.statusCache[os.path.normcase(dname)] ==
                         self.canBeAdded):
                 # add directories recursively, if they aren't in the
                 # repository already
                 tree.insert(-1, dname)
                 dname = os.path.dirname(dname)
                 wdir = dname
         else:
             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.dirname(dname)
                 wdir = dname
         self.addArguments(args, tree)
         if isinstance(name, list):
             tree2 = []
             for n in name:
                 d = os.path.dirname(n)
                 if self.__wcng:
                     repodir = d
                     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  # oops, project is not version controlled
                     while os.path.normcase(d) != \
                         os.path.normcase(repodir) and \
                             (d not in tree2 + tree) and \
                             (os.path.normcase(d) not in self.statusCache or
                              self.statusCache[os.path.normcase(d)] ==
                                 self.canBeAdded):
                         tree2.append(d)
                         d = os.path.dirname(d)
                 else:
                     while not os.path.exists(os.path.join(d, self.adminDir)):
                         if d in tree2 + tree:
                             break
                         tree2.append(d)
                         d = os.path.dirname(d)
             tree2.reverse()
             self.addArguments(args, tree2)
             self.addArguments(args, name)
         else:
             args.append(name)
         if noDialog:
             self.startSynchronizedProcess(QProcess(), "svn", args, wdir)
         else:
             dia = SvnDialog(
                 self.trUtf8('Adding files/directories to the Subversion'
                             ' repository'))
             res = dia.startProcess(args, wdir)
             if res:
                 dia.exec_()
     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))
         """
         args = []
         args.append('add')
         self.addArguments(args, self.options['global'])
         self.addArguments(args, self.options['add'])
         tree = []
         if isinstance(path, list):
             dname, fnames = self.splitPathList(path)
             for n in path:
                 d = os.path.dirname(n)
                 if self.__wcng:
                     repodir = d
                     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  # oops, project is not version controlled
                     while os.path.normcase(d) != \
                         os.path.normcase(repodir) and \
                             (d not in tree) and \
                             (os.path.normcase(d) not in self.statusCache or
                              self.statusCache[os.path.normcase(d)] ==
                                 self.canBeAdded):
                         tree.append(d)
                         d = os.path.dirname(d)
                 else:
                     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.dirname(d)
             tree.reverse()
         else:
             dname, fname = os.path.split(path)
             if self.__wcng:
                 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  # oops, project is not version controlled
                 while os.path.normcase(dname) != \
                     os.path.normcase(repodir) and \
                         (os.path.normcase(dname) not in self.statusCache or
                          self.statusCache[os.path.normcase(dname)] ==
                             self.canBeAdded):
                     # add directories recursively, if they aren't in the
                     # repository already
                     tree.insert(-1, dname)
                     dname = os.path.dirname(dname)
             else:
                 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.dirname(dname)
         if tree:
             self.vcsAdd(tree, True)
         if isinstance(path, list):
             self.addArguments(args, path)
         else:
             args.append(path)
         dia = SvnDialog(
             self.trUtf8('Adding directory trees to the Subversion repository'))
         res = dia.startProcess(args, dname)
         if res:
             dia.exec_()
     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)
         """
         args = []
         args.append('delete')
         self.addArguments(args, self.options['global'])
         self.addArguments(args, self.options['remove'])
         if noDialog and '--force' not in args:
             args.append('--force')
         if isinstance(name, list):
             self.addArguments(args, name)
         else:
             args.append(name)
         if noDialog:
             res = self.startSynchronizedProcess(QProcess(), "svn", args)
         else:
             dia = SvnDialog(
                 self.trUtf8('Removing files/directories from the Subversion'
                             ' repository'))
             res = dia.startProcess(args)
             if res:
                 dia.exec_()
                 res = dia.normalExit()
         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'][:]
         force = '--force' in opts
         if force:
             del opts[opts.index('--force')]
         res = False
         if noDialog:
             if target is None:
                 return False
             force = True
             accepted = True
         else:
             from .SvnCopyDialog import SvnCopyDialog
             dlg = SvnCopyDialog(name, None, True, force)
             accepted = (dlg.exec_() == QDialog.Accepted)
             if accepted:
                 target, force = dlg.getData()
         if not rx_prot.exactMatch(target):
             isDir = os.path.isdir(name)
         else:
             isDir = False
         if accepted:
             args = []
             args.append('move')
             self.addArguments(args, opts)
             if force:
                 args.append('--force')
             if rx_prot.exactMatch(target):
                 args.append('--message')
                 args.append('Moving {0} to {1}'.format(name, target))
                 target = self.__svnURL(target)
             args.append(name)
             args.append(target)
             if noDialog:
                 res = self.startSynchronizedProcess(QProcess(), "svn", args)
             else:
                 dia = SvnDialog(self.trUtf8('Moving {0}')
                                 .format(name))
                 res = dia.startProcess(args)
                 if res:
                     dia.exec_()
                     res = dia.normalExit()
             if res and not rx_prot.exactMatch(target):
                 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
         Subversion repository.
         @param name file/directory name to show the log of (string)
         """
         isFile = os.path.isfile(name)
         noEntries, ok = QInputDialog.getInt(
             None,
             self.trUtf8("Subversion Log"),
             self.trUtf8("Select number of entries to show."),
             self.getPlugin().getPreferences("LogLimit"), 1, 999999, 1)
         if ok:
             from .SvnLogDialog import SvnLogDialog
             self.log = SvnLogDialog(self, isFile=isFile)
             self.log.show()
             self.log.start(name, noEntries)
     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 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
         from .SvnDiffDialog import SvnDiffDialog
         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)
         """
         from .SvnStatusDialog import SvnStatusDialog
         self.status = SvnStatusDialog(self)
         self.status.show()
         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:
             E5MessageBox.critical(
                 self.__ui,
                 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)
         from .SvnTagDialog import SvnTagDialog
         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):
                 E5MessageBox.critical(
                     self.__ui,
                     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 = '{0}/tags/{1}'.format(reposRoot, urllib.parse.quote(tag))
             elif tagOp in [2, 8]:
                 url = '{0}/branches/{1}'.format(
                     reposRoot, urllib.parse.quote(tag))
         else:
             url = self.__svnURL(tag)
         args = []
         if tagOp in [1, 2]:
             args.append('copy')
             self.addArguments(args, self.options['global'])
             self.addArguments(args, self.options['tag'])
             args.append('--message')
             args.append('Created tag <{0}>'.format(tag))
             args.append(reposURL)
             args.append(url)
         else:
             args.append('delete')
             self.addArguments(args, self.options['global'])
             self.addArguments(args, self.options['tag'])
             args.append('--message')
             args.append('Deleted tag <{0}>'.format(tag))
             args.append(url)
         dia = SvnDialog(self.trUtf8('Tagging {0} in the Subversion repository')
                         .format(name))
         res = dia.startProcess(args)
         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'])
         if isinstance(name, list):
             self.addArguments(args, name)
             names = name[:]
         else:
             if os.path.isdir(name):
                 args.append('--recursive')
             args.append(name)
             names = [name]
         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

Mercurial Repositories > eric / annotate

Plugins/VcsPlugins/vcsSubversion/subversion.py@f08c20c91de7 (annotated)

Plugins/VcsPlugins/vcsSubversion/subversion.py