eric: comparison Project/Project.py

-:b3da30a52337
+:f4561c24989a
 import glob
 import fnmatch
 import copy
 import zipfile
 import io
+import re
 from PyQt4.QtCore import *
 from PyQt4.QtGui import *
 from E5Gui.E5Application import e5App
 """
 self.loaded = False     # flag for the loaded status
 self.dirty = False      # dirty flag
 self.pfile = ""         # name of the project file
 self.ppath = ""         # name of the project directory
+self.ppathRe = None
 self.translationsRoot = ""  # the translations prefix
 self.name = ""
 self.opened = False
 self.subdirs = [""] # record the project dir as a relative path (i.e. empty path)
 self.otherssubdirs = []
 .format(fn))
 return False
 self.pfile = os.path.abspath(fn)
 self.ppath = os.path.abspath(os.path.dirname(fn))
+if Utilities.isWindowsPlatform():
+self.ppathRe = re.compile(re.escape(self.ppath + os.sep), re.IGNORECASE )
+else:
+self.ppathRe = re.compile(re.escape(self.ppath + os.sep))
 # insert filename into list of recently opened projects
 self.__syncRecent()
 # now read the file
 res = self.__writeXMLProject(fn)
 if res:
 self.pfile = os.path.abspath(fn)
 self.ppath = os.path.abspath(os.path.dirname(fn))
+if Utilities.isWindowsPlatform():
+self.ppathRe = re.compile(re.escape(self.ppath + os.sep), re.IGNORECASE )
+else:
+self.ppathRe = re.compile(re.escape(self.ppath + os.sep))
 self.name = os.path.splitext(os.path.basename(fn))[0]
 self.setDirty(False)
 # insert filename into list of recently opened projects
 self.__syncRecent()
 The translation file is not deleted from the project directory.
 @param langFile the translation file to be removed (string)
 """
-langFile = langFile.replace(self.ppath + os.sep, '')
+langFile = self.getRelativePath(langFile)
 qmFile = self.__binaryTranslationFile(langFile)
 self.pdata["TRANSLATIONS"].remove(langFile)
 self.__model.removeItem(langFile)
 if qmFile:
 try:
 if self.pdata["TRANSLATIONSBINPATH"]:
-qmFile = os.path.join(self.pdata["TRANSLATIONSBINPATH"][0],
+qmFile = self.getRelativePath(
-os.path.basename(qmFile)).replace(self.ppath + os.sep, '')
+os.path.join(self.pdata["TRANSLATIONSBINPATH"][0],
+os.path.basename(qmFile)))
 self.pdata["TRANSLATIONS"].remove(qmFile)
 self.__model.removeItem(qmFile)
 except ValueError:
 pass
 self.setDirty(True)
 """
 Public slot to delete a translation from the project directory.
 @param langFile the translation file to be removed (string)
 """
-langFile = langFile.replace(self.ppath + os.sep, '')
+langFile = self.getRelativePath(langFile)
 qmFile = self.__binaryTranslationFile(langFile)
 try:
 fn = os.path.join(self.ppath, langFile)
 if os.path.exists(fn):
 # now get rid of the .qm file
 if qmFile:
 try:
 if self.pdata["TRANSLATIONSBINPATH"]:
-qmFile = os.path.join(self.pdata["TRANSLATIONSBINPATH"][0],
+qmFile = self.getRelativePath(
-os.path.basename(qmFile)).replace(self.ppath + os.sep, '')
+os.path.join(self.pdata["TRANSLATIONSBINPATH"][0],
+os.path.basename(qmFile)))
 fn = os.path.join(self.ppath, qmFile)
 if os.path.exists(fn):
 os.remove(fn)
 except IOError:
 QMessageBox.critical(None,
 """
 dirty = False
 if os.path.isabs(fn):
 # make it relative to the project root, if it starts with that path
-newfn = fn.replace(self.ppath + os.sep, '')
+newfn = self.getRelativePath(fn)
 else:
 # assume relative paths are relative to the project root
 newfn = fn
 newdir = os.path.dirname(newfn)
 @param fn file name or directory name to add (string)
 """
 if fn:
 # if it is below the project directory, make it relative to that
-fn = fn.replace(self.ppath + os.sep, '')
+fn = self.getRelativePath(fn)
 # if it ends with the directory separator character, remove it
 if fn.endswith(os.sep):
 fn = fn[:-1]
 @param oldfn old filename (string)
 @param newfn new filename of the main script (string)
 """
 if self.pdata["MAINSCRIPT"]:
-ofn = oldfn.replace(self.ppath + os.sep, '')
+ofn = self.getRelativePath(oldfn)
 if ofn != self.pdata["MAINSCRIPT"][0]:
 return
-fn = newfn.replace(self.ppath + os.sep, '')
+fn = self.getRelativePath(newfn)
 self.pdata["MAINSCRIPT"] = [fn]
 self.setDirty(True)
 def renameFile(self, oldfn, newfn = None):
 """
 @param oldfn old filename of the file (string)
 @param newfn new filename of the file (string)
 @return flag indicating success
 """
-fn = oldfn.replace(self.ppath + os.sep, '')
+fn = self.getRelativePath(oldfn)
 isSourceFile = fn in self.pdata["SOURCES"]
 if newfn is None:
 newfn = QFileDialog.getSaveFileName(\
 None,
 @param oldname old filename (string)
 @param newname new filename (string)
 @param isSourceFile flag indicating that this is a source file
 even if it doesn't have the source extension (boolean)
 """
-fn = oldname.replace(self.ppath + os.sep, '')
+fn = self.getRelativePath(oldname)
 if os.path.dirname(oldname) == os.path.dirname(newname):
 self.removeFile(oldname, False)
 self.appendFile(newname, isSourceFile, False)
 self.__model.renameItem(fn, newname)
 else:
 Public method to get all files starting with a common prefix.
 @param start prefix (string)
 """
 filelist = []
-start = start.replace(self.ppath + os.sep, '')
+start = self.getRelativePath(start)
 for key in ["SOURCES", "FORMS", "INTERFACES", "RESOURCES", "OTHERS"]:
 for entry in self.pdata[key][:]:
 if entry.startswith(start):
 filelist.append(os.path.join(self.ppath, entry))
 return filelist
 Public slot to copy a directory.
 @param olddn original directory name (string)
 @param newdn new directory name (string)
 """
-olddn = olddn.replace(self.ppath + os.sep, '')
+olddn = self.getRelativePath(olddn)
-newdn = newdn.replace(self.ppath + os.sep, '')
+newdn = self.getRelativePath(newdn)
 for key in ["SOURCES", "FORMS", "INTERFACES", "RESOURCES", "OTHERS"]:
 for entry in self.pdata[key][:]:
 if entry.startswith(olddn):
 entry = entry.replace(olddn, newdn)
 self.appendFile(os.path.join(self.ppath, entry), key == "SOURCES")
 Public slot to move a directory.
 @param olddn old directory name (string)
 @param newdn new directory name (string)
 """
-olddn = olddn.replace(self.ppath + os.sep, '')
+olddn = self.getRelativePath(olddn)
-newdn = newdn.replace(self.ppath + os.sep, '')
+newdn = self.getRelativePath(newdn)
 typeStrings = []
 for key in ["SOURCES", "FORMS", "INTERFACES", "RESOURCES", "OTHERS"]:
 for entry in self.pdata[key][:]:
 if entry.startswith(olddn):
 if key not in typeStrings:
 The file is not deleted from the project directory.
 @param fn filename to be removed from the project
 @param updateModel flag indicating an update of the model is requested (boolean)
 """
-fn = fn.replace(self.ppath + os.sep, '')
+fn = self.getRelativePath(fn)
 dirty = True
 if fn in self.pdata["SOURCES"]:
 self.pdata["SOURCES"].remove(fn)
 elif fn in self.pdata["FORMS"]:
 self.pdata["FORMS"].remove(fn)
 The directory is not deleted from the project directory.
 @param dn directory name to be removed from the project
 """
 dirty = False
-dn = dn.replace(self.ppath + os.sep, '')
+dn = self.getRelativePath(dn)
 for entry in self.pdata["OTHERS"][:]:
 if entry.startswith(dn):
 self.pdata["OTHERS"].remove(entry)
 dirty = True
 if not dn.endswith(os.sep):
 Public method to check the project for a file.
 @param fn filename to be checked (string)
 @return flag indicating, if the project contains the file (boolean)
 """
-fn = fn.replace(self.ppath + os.sep, '')
+fn = self.getRelativePath(fn)
 if fn in self.pdata["SOURCES"] or \
 fn in self.pdata["FORMS"] or \
 fn in self.pdata["INTERFACES"] or \
 fn in self.pdata["RESOURCES"] or \
 fn in self.pdata["OTHERS"]:
 QLineEdit.Normal,
 tslist[0])
 if not pattern.isEmpty:
 self.pdata["TRANSLATIONPATTERN"] = [pattern]
 self.pdata["TRANSLATIONPATTERN"][0] = \
-self.pdata["TRANSLATIONPATTERN"][0].replace(self.ppath + os.sep, "")
+self.getRelativePath(self.pdata["TRANSLATIONPATTERN"][0])
 pattern = self.pdata["TRANSLATIONPATTERN"][0].replace("%language%", "*")
 for ts in tslist:
 if fnmatch.fnmatch(ts, pattern):
 self.pdata["TRANSLATIONS"].append(ts)
 self.emit(SIGNAL('projectLanguageAdded'), ts)
 """
 vm = e5App().getObject("ViewManager")
 success = True
 filesWithSyntaxErrors = 0
 for fn in vm.getOpenFilenames():
-rfn = fn.replace(self.ppath + os.sep, '') # make relativ to project
+rfn = self.getRelativePath(fn)
 if rfn in self.pdata["SOURCES"] or rfn in self.pdata["OTHERS"]:
 editor = vm.getOpenEditor(fn)
 success &= vm.saveEditorEd(editor)
 if reportSyntaxErrors and editor.hasSyntaxErrors():
 filesWithSyntaxErrors += 1
 @return project path (string)
 """
 return self.ppath
+def startswithProjectPath(self, path):
+"""
+Public method to check, if a path starts with the project path.
+@param path path to be checked (string)
+"""
+if self.ppathRe:
+return self.ppathRe.match(path) is not None
+else:
+return False
 def getProjectFile(self):
 """
 Public method to get the path of the project file.
 @return path of the project file (string)
 @return project hash as a hex string (string)
 """
 return self.pdata["HASH"][0]
-def getRelativePath(self, fn):
+def getRelativePath(self, path):
 """
 Public method to convert a file path to a project relative
 file path.
-@param fn file or directory name to convert (string)
+@param path file or directory name to convert (string)
-@return project relative path or unchanged path, if fn doesn't
+@return project relative path or unchanged path, if path doesn't
 belong to the project (string)
 """
-return fn.replace(self.ppath + os.sep, "")
+if self.startswithProjectPath(path):
+return self.ppathRe.sub("", path, 1)
-def getRelativeUniversalPath(self, fn):
+else:
+return path
+def getRelativeUniversalPath(self, path):
 """
 Public method to convert a file path to a project relative
 file path with universal separators.
-@param fn file or directory name to convert (string)
+@param path file or directory name to convert (string)
-@return project relative path or unchanged path, if fn doesn't
+@return project relative path or unchanged path, if path doesn't
 belong to the project (string)
 """
-return Utilities.fromNativeSeparators(fn.replace(self.ppath + os.sep, ""))
+return Utilities.fromNativeSeparators(self.getRelativePath(path))
 def getAbsoluteUniversalPath(self, fn):
 """
 Public method to convert a project relative file path with universal
 separators to an absolute file path.
 @param fn filename to be checked (string)
 @return flag indicating membership (boolean)
 """
 newfn = os.path.abspath(fn)
-newfn = newfn.replace(self.ppath + os.sep, '')
+newfn = self.getRelativePath(newfn)
 if newfn in self.pdata["SOURCES"] or \
 newfn in self.pdata["FORMS"] or \
 newfn in self.pdata["INTERFACES"] or \
 newfn in self.pdata["RESOURCES"] or \
 newfn in self.pdata["TRANSLATIONS"] or \
 @param fn filename to be checked (string)
 @return flag indicating membership (boolean)
 """
 newfn = os.path.abspath(fn)
-newfn = newfn.replace(self.ppath + os.sep, '')
+newfn = self.getRelativePath(newfn)
 return newfn in self.pdata["SOURCES"]
 def isProjectForm(self, fn):
 """
 Public method used to check, if the passed in filename belongs to the project
 @param fn filename to be checked (string)
 @return flag indicating membership (boolean)
 """
 newfn = os.path.abspath(fn)
-newfn = newfn.replace(self.ppath + os.sep, '')
+newfn = self.getRelativePath(newfn)
 return newfn in self.pdata["FORMS"]
 def isProjectInterface(self, fn):
 """
 Public method used to check, if the passed in filename belongs to the project
 @param fn filename to be checked (string)
 @return flag indicating membership (boolean)
 """
 newfn = os.path.abspath(fn)
-newfn = newfn.replace(self.ppath + os.sep, '')
+newfn = self.getRelativePath(newfn)
 return newfn in self.pdata["INTERFACES"]
 def isProjectResource(self, fn):
 """
 Public method used to check, if the passed in filename belongs to the project
 @param fn filename to be checked (string)
 @return flag indicating membership (boolean)
 """
 newfn = os.path.abspath(fn)
-newfn = newfn.replace(self.ppath + os.sep, '')
+newfn = self.getRelativePath(newfn)
 return newfn in self.pdata["RESOURCES"]
 def initActions(self):
 """
 Public slot to initialize the project related actions.
 ns = os.path.abspath(os.path.join(curpath, ns))
 # do not bother with dirs here...
 if os.path.isdir(ns):
 if recursiveSearch:
-d = ns.replace(self.ppath + os.sep, '')
+d = self.getRelativePath(ns)
 if d not in dirs:
 dirs.append(d)
 continue
 filetype = ""
 @param fullname full name of the item to repopulate (string)
 """
 if not self.isOpen():
 return
-name = fullname.replace(self.ppath + os.sep, "")
+name = self.getRelativePath(fullname)
 self.emit(SIGNAL("prepareRepopulateItem"), name)
 self.__model.repopulateItem(name)
 self.emit(SIGNAL("completeRepopulateItem"), name)
 ##############################################################

Mercurial Repositories > eric / file comparison

comparison: Project/Project.py

Project/Project.py