eric: Project/Project.py@fd7d34bd1a88 (annotated)

 # -*- coding: utf-8 -*-
 # Copyright (c) 2002 - 2015 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing the project management functionality.
 """
 from __future__ import unicode_literals
 try:
     str = unicode
 except NameError:
     pass
 import os
 import time
 import shutil
 import glob
 import fnmatch
 import copy
 import zipfile
 from PyQt5.QtCore import pyqtSlot, QFile, QFileInfo, pyqtSignal, \
     QCryptographicHash, QIODevice, QByteArray, QObject, Qt
 from PyQt5.QtGui import QCursor
 from PyQt5.QtWidgets import QLineEdit, QToolBar, QDialog, QInputDialog, \
     QApplication, QMenu, QAction
 from PyQt5.Qsci import QsciScintilla
 from E5Gui.E5Application import e5App
 from E5Gui import E5FileDialog, E5MessageBox
 from Globals import recentNameProject
 import UI.PixmapCache
 from E5Gui.E5Action import E5Action, createActionGroup
 import Preferences
 import Utilities
 class Project(QObject):
     """
     Class implementing the project management functionality.
     @signal dirty(int) emitted when the dirty state changes
     @signal projectLanguageAdded(str) emitted after a new language was added
     @signal projectLanguageAddedByCode(str) emitted after a new language was
         added. The language code is sent by this signal.
     @signal projectLanguageRemoved(str) emitted after a language was removed
     @signal projectFormAdded(str) emitted after a new form was added
     @signal projectFormRemoved(str) emitted after a form was removed
     @signal projectFormCompiled(str) emitted after a form was compiled
     @signal projectSourceAdded(str) emitted after a new source file was added
     @signal projectSourceRemoved(str) emitted after a source was removed
     @signal projectInterfaceAdded(str) emitted after a new IDL file was added
     @signal projectInterfaceRemoved(str) emitted after a IDL file was removed
     @signal projectResourceAdded(str) emitted after a new resource file was
         added
     @signal projectResourceRemoved(str) emitted after a resource was removed
     @signal projectOthersAdded(str) emitted after a file or directory was added
         to the OTHERS project data area
     @signal projectOthersRemoved(str) emitted after a file was removed from the
         OTHERS project data area
     @signal projectAboutToBeCreated() emitted just before the project will be
         created
     @signal newProjectHooks() emitted after a new project was generated but
         before the newProject() signal is sent
     @signal newProject() emitted after a new project was generated
     @signal sourceFile(str) emitted after a project file was read to
         open the main script
     @signal projectOpenedHooks() emitted after a project file was read but
         before the projectOpened() signal is sent
     @signal projectOpened() emitted after a project file was read
     @signal projectClosedHooks() emitted after a project file was closed but
         before the projectClosed() signal is sent
     @signal projectClosed() emitted after a project was closed
     @signal projectFileRenamed(str, str) emitted after a file of the project
         has been renamed
     @signal projectPropertiesChanged() emitted after the project properties
         were changed
     @signal directoryRemoved(str) emitted after a directory has been removed
         from the project
     @signal prepareRepopulateItem(str) emitted before an item of the model is
         repopulated
     @signal completeRepopulateItem(str) emitted after an item of the model was
         repopulated
     @signal vcsStatusMonitorStatus(str, str) emitted to signal the status of
         the monitoring thread (ok, nok, op, off) and a status message
     @signal reinitVCS() emitted after the VCS has been reinitialized
     @signal showMenu(str, QMenu) emitted when a menu is about to be shown. The
         name of the menu and a reference to the menu are given.
     @signal lexerAssociationsChanged() emitted after the lexer associations
         have been changed
     @signal projectChanged() emitted to signal a change of the project
     """
     dirty = pyqtSignal(int)
     projectLanguageAdded = pyqtSignal(str)
     projectLanguageAddedByCode = pyqtSignal(str)
     projectLanguageRemoved = pyqtSignal(str)
     projectFormAdded = pyqtSignal(str)
     projectFormRemoved = pyqtSignal(str)
     projectFormCompiled = pyqtSignal(str)
     projectSourceAdded = pyqtSignal(str)
     projectSourceRemoved = pyqtSignal(str)
     projectInterfaceAdded = pyqtSignal(str)
     projectInterfaceRemoved = pyqtSignal(str)
     projectResourceAdded = pyqtSignal(str)
     projectResourceRemoved = pyqtSignal(str)
     projectOthersAdded = pyqtSignal(str)
     projectOthersRemoved = pyqtSignal(str)
     projectAboutToBeCreated = pyqtSignal()
     newProjectHooks = pyqtSignal()
     newProject = pyqtSignal()
     sourceFile = pyqtSignal(str)
     projectOpenedHooks = pyqtSignal()
     projectOpened = pyqtSignal()
     projectClosedHooks = pyqtSignal()
     projectClosed = pyqtSignal()
     projectFileRenamed = pyqtSignal(str, str)
     projectPropertiesChanged = pyqtSignal()
     directoryRemoved = pyqtSignal(str)
     prepareRepopulateItem = pyqtSignal(str)
     completeRepopulateItem = pyqtSignal(str)
     vcsStatusMonitorStatus = pyqtSignal(str, str)
     reinitVCS = pyqtSignal()
     showMenu = pyqtSignal(str, QMenu)
     lexerAssociationsChanged = pyqtSignal()
     projectChanged = pyqtSignal()
     keynames = [
         "PROGLANGUAGE", "MIXEDLANGUAGE", "PROJECTTYPE",
         "SPELLLANGUAGE", "SPELLWORDS", "SPELLEXCLUDES",
         "DESCRIPTION", "VERSION", "HASH",
         "AUTHOR", "EMAIL",
         "SOURCES", "FORMS", "RESOURCES",
         "TRANSLATIONS", "TRANSLATIONPATTERN", "TRANSLATIONSBINPATH",
         "TRANSLATIONEXCEPTIONS",
         "MAINSCRIPT", "EOL",
         "VCS", "VCSOPTIONS", "VCSOTHERDATA",
         "OTHERS", "INTERFACES",
         "FILETYPES", "LEXERASSOCS",
         "PROJECTTYPESPECIFICDATA",
         "DOCUMENTATIONPARMS",
         "PACKAGERSPARMS",
         "CHECKERSPARMS",
         "OTHERTOOLSPARMS",
     ]
     dbgKeynames = [
         "INTERPRETER", "DEBUGCLIENT",
         "ENVIRONMENTOVERRIDE", "ENVIRONMENTSTRING",
         "REMOTEDEBUGGER", "REMOTEHOST", "REMOTECOMMAND",
         "PATHTRANSLATION", "REMOTEPATH", "LOCALPATH",
         "CONSOLEDEBUGGER", "CONSOLECOMMAND",
         "REDIRECT", "NOENCODING",
     ]
     userKeynames = [
         "VCSOVERRIDE", "VCSSTATUSMONITORINTERVAL",
     ]
     eols = [os.linesep, "\n", "\r", "\r\n"]
     def __init__(self, parent=None, filename=None):
         """
         Constructor
         @param parent parent widget (usually the ui object) (QWidget)
         @param filename optional filename of a project file to open (string)
         """
         super(Project, self).__init__(parent)
         self.ui = parent
         self.__progLanguages = [
             "Python2",
             "Python3",
             "Ruby",
             "JavaScript",
         ]
         self.dbgFilters = {
             "Python2": self.tr(
                 "Python2 Files (*.py2);;"
                 "Python2 GUI Files (*.pyw2);;"),
             "Python3": self.tr(
                 "Python3 Files (*.py *.py3);;"
                 "Python3 GUI Files (*.pyw *.pyw3);;"),
             "Ruby": self.tr("Ruby Files (*.rb);;"),
         }
         self.vcsMenu = None
         self.__initProjectTypes()
         self.__initData()
         self.recent = []
         self.__loadRecent()
         if filename is not None:
             self.openProject(filename)
         else:
             self.vcs = self.initVCS()
         from .ProjectBrowserModel import ProjectBrowserModel
         self.__model = ProjectBrowserModel(self)
         self.codemetrics = None
         self.codecoverage = None
         self.profiledata = None
         self.applicationDiagram = None
         self.loadedDiagram = None
     def __sourceExtensions(self, language):
         """
         Private method to get the source extensions of a programming language.
         @param language programming language (string)
         @return source extensions (list of string)
         """
         if language == "Python2":
             extensions = Preferences.getPython("PythonExtensions")
             # *.py and *.pyw should always be associated with source files
             for ext in [".py", ".pyw"]:
                 if ext not in extensions:
                     extensions.append(ext)
             return extensions
         elif language == "Python3":
             extensions = Preferences.getPython("Python3Extensions")
             # *.py and *.pyw should always be associated with source files
             for ext in [".py", ".pyw"]:
                 if ext not in extensions:
                     extensions.append(ext)
             return extensions
         elif language == "Ruby":
             return ['.rb']
         elif language == "JavaScript":
             return ['.js']
         elif language == "Mixed":
             return (Preferences.getPython("Python3Extensions") +
                     Preferences.getPython("PythonExtensions") +
                     ['.rb', '.js'])
         else:
             return [""]
     def getProgrammingLanguages(self):
         """
         Public method to get the programming languages supported by project.
         @return list of supported programming languages (list of string)
         """
         return self.__progLanguages[:]
     def __initProjectTypes(self):
         """
         Private method to initialize the list of supported project types.
         """
         self.__projectTypes = {}
         self.__fileTypeCallbacks = {}
         self.__lexerAssociationCallbacks = {}
         self.__binaryTranslationsCallbacks = {}
         self.__projectTypes["Qt4"] = self.tr("PyQt4 GUI")
         self.__projectTypes["Qt4C"] = self.tr("PyQt4 Console")
         self.__projectTypes["PyQt5"] = self.tr("PyQt5 GUI")
         self.__projectTypes["PyQt5C"] = self.tr("PyQt5 Console")
         self.__projectTypes["E6Plugin"] = self.tr("Eric6 Plugin")
         self.__projectTypes["Console"] = self.tr("Console")
         self.__projectTypes["Other"] = self.tr("Other")
         self.__projectProgLanguages = {
             "Python2": ["Qt4", "Qt4C", "PyQt5", "PyQt5C",
                         "E6Plugin", "Console", "Other"],
             "Python3": ["Qt4", "Qt4C", "PyQt5", "PyQt5C",
                         "E6Plugin", "Console", "Other"],
             "Ruby": ["Qt4", "Qt4C", "Console", "Other"],
             "JavaScript": ["Other"],
         }
         pyside2, pyside3 = Utilities.checkPyside()
         if pyside2 or pyside3:
             self.__projectTypes["PySide"] = self.tr("PySide GUI")
             self.__projectTypes["PySideC"] = self.tr("PySide Console")
             if pyside2:
                 self.__projectProgLanguages["Python2"].extend(
                     ["PySide", "PySideC"])
             if pyside3:
                 self.__projectProgLanguages["Python3"].extend(
                     ["PySide", "PySideC"])
     def getProjectTypes(self, progLanguage=""):
         """
         Public method to get the list of supported project types.
         @param progLanguage programming language to get project types for
             (string)
         @return reference to the dictionary of project types.
         """
         if progLanguage and progLanguage in self.__projectProgLanguages:
             ptypes = {}
             for ptype in self.__projectProgLanguages[progLanguage]:
                 ptypes[ptype] = self.__projectTypes[ptype]
             return ptypes
         else:
             return self.__projectTypes
     def hasProjectType(self, type_, progLanguage=""):
         """
         Public method to check, if a project type is already registered.
         @param type_ internal type designator (string)
         @param progLanguage programming language of the project type (string)
         @return flag indicating presence of the project type (boolean)
         """
         if progLanguage:
             return progLanguage in self.__projectProgLanguages and \
                 type_ in self.__projectProgLanguages[progLanguage]
         else:
             return type_ in self.__projectTypes
     def registerProjectType(self, type_, description, fileTypeCallback=None,
                             binaryTranslationsCallback=None,
                             lexerAssociationCallback=None, progLanguages=None):
         """
         Public method to register a project type.
         @param type_ internal type designator to be registered (string)
         @param description more verbose type name (display string) (string)
         @keyparam fileTypeCallback reference to a method returning a dictionary
             of filetype associations.
         @keyparam binaryTranslationsCallback reference to a method returning
             the name of the binary translation file given the name of the raw
             translation file
         @keyparam lexerAssociationCallback reference to a method returning the
             lexer type to be used for syntax highlighting given the name of
             a file
         @keyparam progLanguages programming languages supported by the
             project type (list of string)
         """
         if progLanguages:
             for progLanguage in progLanguages:
                 if progLanguage not in self.__projectProgLanguages:
                     E5MessageBox.critical(
                         self.ui,
                         self.tr("Registering Project Type"),
                         self.tr(
                             """<p>The Programming Language <b>{0}</b> is not"""
                             """ supported.</p>""")
                         .format(progLanguage)
                     )
                     return
                 if type_ in self.__projectProgLanguages[progLanguage]:
                     E5MessageBox.critical(
                         self.ui,
                         self.tr("Registering Project Type"),
                         self.tr(
                             """<p>The Project type <b>{0}</b> is already"""
                             """ registered with Programming Language"""
                             """ <b>{1}</b>.</p>""")
                         .format(type_, progLanguage)
                     )
                     return
         if type_ in self.__projectTypes:
             E5MessageBox.critical(
                 self.ui,
                 self.tr("Registering Project Type"),
                 self.tr("""<p>The Project type <b>{0}</b> is already"""
                         """ registered.</p>""").format(type_)
             )
         else:
             self.__projectTypes[type_] = description
             self.__fileTypeCallbacks[type_] = fileTypeCallback
             self.__lexerAssociationCallbacks[type_] = lexerAssociationCallback
             self.__binaryTranslationsCallbacks[type_] = \
                 binaryTranslationsCallback
             if progLanguages:
                 for progLanguage in progLanguages:
                     self.__projectProgLanguages[progLanguage].append(type_)
             else:
                 # no specific programming languages given -> add to all
                 for progLanguage in self.__projectProgLanguages:
                     self.__projectProgLanguages[progLanguage].append(type_)
     def unregisterProjectType(self, type_):
         """
         Public method to unregister a project type.
         @param type_ internal type designator to be unregistered (string)
         """
         for progLanguage in self.__projectProgLanguages:
             if type_ in self.__projectProgLanguages[progLanguage]:
                 self.__projectProgLanguages[progLanguage].remove(type_)
         if type_ in self.__projectTypes:
             del self.__projectTypes[type_]
         if type_ in self.__fileTypeCallbacks:
             del self.__fileTypeCallbacks[type_]
         if type_ in self.__lexerAssociationCallbacks:
             del self.__lexerAssociationCallbacks[type_]
         if type_ in self.__binaryTranslationsCallbacks:
             del self.__binaryTranslationsCallbacks[type_]
     def __initData(self):
         """
         Private method to initialize the project data part.
         """
         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.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 = []
         self.vcs = None
         self.vcsRequested = False
         self.dbgCmdline = ''
         self.dbgWd = ''
         self.dbgEnv = ''
         self.dbgReportExceptions = True
         self.dbgExcList = []
         self.dbgExcIgnoreList = []
         self.dbgAutoClearShell = True
         self.dbgTracePython = False
         self.dbgAutoContinue = True
         self.pdata = {}
         for key in self.__class__.keynames:
             self.pdata[key] = []
         self.pdata["AUTHOR"] = ['']
         self.pdata["EMAIL"] = ['']
         self.pdata["HASH"] = ['']
         self.pdata["PROGLANGUAGE"] = ["Python3"]
         self.pdata["MIXEDLANGUAGE"] = [False]
         self.pdata["PROJECTTYPE"] = ["Qt4"]
         self.pdata["SPELLLANGUAGE"] = \
             [Preferences.getEditor("SpellCheckingDefaultLanguage")]
         self.pdata["SPELLWORDS"] = ['']
         self.pdata["SPELLEXCLUDES"] = ['']
         self.pdata["FILETYPES"] = {}
         self.pdata["LEXERASSOCS"] = {}
         self.pdata["PROJECTTYPESPECIFICDATA"] = {}
         self.pdata["CHECKERSPARMS"] = {}
         self.pdata["PACKAGERSPARMS"] = {}
         self.pdata["DOCUMENTATIONPARMS"] = {}
         self.pdata["OTHERTOOLSPARMS"] = {}
         self.pdata["EOL"] = [-1]
         self.__initDebugProperties()
         self.pudata = {}
         for key in self.__class__.userKeynames:
             self.pudata[key] = []
         self.vcs = self.initVCS()
     def getData(self, category, key):
         """
         Public method to get data out of the project data store.
         @param category category of the data to get (string, one of
             PROJECTTYPESPECIFICDATA, CHECKERSPARMS, PACKAGERSPARMS,
             DOCUMENTATIONPARMS or OTHERTOOLSPARMS)
         @param key key of the data entry to get (string).
         @return a copy of the requested data or None
         """
         if category in ["PROJECTTYPESPECIFICDATA", "CHECKERSPARMS",
                         "PACKAGERSPARMS", "DOCUMENTATIONPARMS",
                         "OTHERTOOLSPARMS"] and \
            key in self.pdata[category]:
             return copy.deepcopy(self.pdata[category][key])
         else:
             return None
     def setData(self, category, key, data):
         """
         Public method to store data in the project data store.
         @param category category of the data to get (string, one of
             PROJECTTYPESPECIFICDATA, CHECKERSPARMS, PACKAGERSPARMS,
             DOCUMENTATIONPARMS or OTHERTOOLSPARMS)
         @param key key of the data entry to get (string).
         @param data data to be stored
         @return flag indicating success (boolean)
         """
         if category not in ["PROJECTTYPESPECIFICDATA", "CHECKERSPARMS",
                             "PACKAGERSPARMS", "DOCUMENTATIONPARMS",
                             "OTHERTOOLSPARMS"]:
             return False
         # test for changes of data and save them in the project
         # 1. there were none, now there are
         if key not in self.pdata[category] and len(data) > 0:
             self.pdata[category][key] = copy.deepcopy(data)
             self.setDirty(True)
         # 2. there were some, now there aren't
         elif key in self.pdata[category] and len(data) == 0:
             del self.pdata[category][key]
             self.setDirty(True)
         # 3. there were some and still are
         elif key in self.pdata[category] and len(data) > 0:
             if data != self.pdata[category][key]:
                 self.pdata[category][key] = copy.deepcopy(data)
                 self.setDirty(True)
         # 4. there were none and none are given
         else:
             return False
         return True
     def initFileTypes(self):
         """
         Public method to initialize the filetype associations with default
         values.
         """
         self.pdata["FILETYPES"] = {}
         if self.pdata["MIXEDLANGUAGE"][0]:
             sourceKey = "Mixed"
         else:
             sourceKey = self.pdata["PROGLANGUAGE"][0]
         for ext in self.__sourceExtensions(sourceKey):
             self.pdata["FILETYPES"]["*{0}".format(ext)] = "SOURCES"
         self.pdata["FILETYPES"]["*.idl"] = "INTERFACES"
         if self.pdata["PROJECTTYPE"][0] in ["Qt4", "PyQt5",
                                             "E6Plugin", "PySide"]:
             self.pdata["FILETYPES"]["*.ui"] = "FORMS"
         if self.pdata["PROJECTTYPE"][0] in ["Qt4", "Qt4C",
                                             "E6Plugin",
                                             "PyQt5", "PyQt5C",
                                             "PySide", "PySideC"]:
             self.pdata["FILETYPES"]["*.qrc"] = "RESOURCES"
         if self.pdata["PROJECTTYPE"][0] in ["Qt4", "Qt4C",
                                             "E6Plugin",
                                             "PyQt5", "PyQt5C",
                                             "PySide", "PySideC"]:
             self.pdata["FILETYPES"]["*.ts"] = "TRANSLATIONS"
             self.pdata["FILETYPES"]["*.qm"] = "TRANSLATIONS"
         try:
             if self.__fileTypeCallbacks[
                     self.pdata["PROJECTTYPE"][0]] is not None:
                 ftypes = \
                     self.__fileTypeCallbacks[self.pdata["PROJECTTYPE"][0]]()
                 self.pdata["FILETYPES"].update(ftypes)
         except KeyError:
             pass
         self.setDirty(True)
     def updateFileTypes(self):
         """
         Public method to update the filetype associations with new default
         values.
         """
         if self.pdata["PROJECTTYPE"][0] in ["Qt4", "Qt4C",
                                             "E6Plugin",
                                             "PyQt5", "PyQt5C",
                                             "PySide", "PySideC"]:
             if "*.ts" not in self.pdata["FILETYPES"]:
                 self.pdata["FILETYPES"]["*.ts"] = "TRANSLATIONS"
             if "*.qm" not in self.pdata["FILETYPES"]:
                 self.pdata["FILETYPES"]["*.qm"] = "TRANSLATIONS"
         try:
             if self.__fileTypeCallbacks[
                     self.pdata["PROJECTTYPE"][0]] is not None:
                 ftypes = \
                     self.__fileTypeCallbacks[self.pdata["PROJECTTYPE"][0]]()
                 for pattern, ftype in list(ftypes.items()):
                     if pattern not in self.pdata["FILETYPES"]:
                         self.pdata["FILETYPES"][pattern] = ftype
                         self.setDirty(True)
         except KeyError:
             pass
     def __loadRecent(self):
         """
         Private method to load the recently opened project filenames.
         """
         self.recent = []
         Preferences.Prefs.rsettings.sync()
         rp = Preferences.Prefs.rsettings.value(recentNameProject)
         if rp is not None:
             for f in rp:
                 if QFileInfo(f).exists():
                     self.recent.append(f)
     def __saveRecent(self):
         """
         Private method to save the list of recently opened filenames.
         """
         Preferences.Prefs.rsettings.setValue(recentNameProject, self.recent)
         Preferences.Prefs.rsettings.sync()
     def getMostRecent(self):
         """
         Public method to get the most recently opened project.
         @return path of the most recently opened project (string)
         """
         if len(self.recent):
             return self.recent[0]
         else:
             return None
     def getModel(self):
         """
         Public method to get a reference to the project browser model.
         @return reference to the project browser model (ProjectBrowserModel)
         """
         return self.__model
     def getVcs(self):
         """
         Public method to get a reference to the VCS object.
         @return reference to the VCS object
         """
         return self.vcs
     def handlePreferencesChanged(self):
         """
         Public slot used to handle the preferencesChanged signal.
         """
         if self.pudata["VCSSTATUSMONITORINTERVAL"]:
             self.setStatusMonitorInterval(
                 self.pudata["VCSSTATUSMONITORINTERVAL"][0])
         else:
             self.setStatusMonitorInterval(
                 Preferences.getVCS("StatusMonitorInterval"))
         self.__model.preferencesChanged()
     def setDirty(self, b):
         """
         Public method to set the dirty state.
         It emits the signal dirty(int).
         @param b dirty state (boolean)
         """
         self.__dirty = b
         self.saveAct.setEnabled(b)
         self.dirty.emit(bool(b))
         if self.__dirty:
             self.projectChanged.emit()
     def isDirty(self):
         """
         Public method to return the dirty state.
         @return dirty state (boolean)
         """
         return self.__dirty
     def isOpen(self):
         """
         Public method to return the opened state.
         @return open state (boolean)
         """
         return self.opened
     def __checkFilesExist(self, index):
         """
         Private method to check, if the files in a list exist.
         The files in the indicated list are checked for existance in the
         filesystem. Non existant files are removed from the list and the
         dirty state of the project is changed accordingly.
         @param index key of the list to be checked (string)
         """
         removed = False
         removelist = []
         for file in self.pdata[index]:
             if not os.path.exists(os.path.join(self.ppath, file)):
                 removelist.append(file)
                 removed = True
         if removed:
             for file in removelist:
                 self.pdata[index].remove(file)
             self.setDirty(True)
     def __readProject(self, fn):
         """
         Private method to read in a project (.e4p) file.
         @param fn filename of the project file to be read (string)
         @return flag indicating success
         """
         f = QFile(fn)
         if f.open(QIODevice.ReadOnly):
             from E5XML.ProjectReader import ProjectReader
             reader = ProjectReader(f, self)
             reader.readXML()
             res = not reader.hasError()
             f.close()
         else:
             QApplication.restoreOverrideCursor()
             E5MessageBox.critical(
                 self.ui,
                 self.tr("Read project file"),
                 self.tr(
                     "<p>The project file <b>{0}</b> could not be read.</p>")
                 .format(fn))
             return False
         self.pfile = os.path.abspath(fn)
         self.ppath = os.path.abspath(os.path.dirname(fn))
         # insert filename into list of recently opened projects
         self.__syncRecent()
         if res:
             if len(self.pdata["TRANSLATIONPATTERN"]) == 1:
                 self.translationsRoot = \
                     self.pdata["TRANSLATIONPATTERN"][0].split("%language%")[0]
             elif len(self.pdata["MAINSCRIPT"]) == 1:
                 self.translationsRoot = os.path.splitext(
                     self.pdata["MAINSCRIPT"][0])[0]
             if os.path.isdir(os.path.join(self.ppath, self.translationsRoot)):
                 dn = self.translationsRoot
             else:
                 dn = os.path.dirname(self.translationsRoot)
             if dn not in self.subdirs:
                 self.subdirs.append(dn)
             self.name = os.path.splitext(os.path.basename(fn))[0]
             # check, if the files of the project still exist in the
             # project directory
             self.__checkFilesExist("SOURCES")
             self.__checkFilesExist("FORMS")
             self.__checkFilesExist("INTERFACES")
             self.__checkFilesExist("TRANSLATIONS")
             self.__checkFilesExist("RESOURCES")
             self.__checkFilesExist("OTHERS")
             # get the names of subdirectories the files are stored in
             for fn in self.pdata["SOURCES"] + \
                 self.pdata["FORMS"] + \
                 self.pdata["INTERFACES"] + \
                 self.pdata["RESOURCES"] + \
                     self.pdata["TRANSLATIONS"]:
                 dn = os.path.dirname(fn)
                 if dn not in self.subdirs:
                     self.subdirs.append(dn)
             # get the names of other subdirectories
             for fn in self.pdata["OTHERS"]:
                 dn = os.path.dirname(fn)
                 if dn not in self.otherssubdirs:
                     self.otherssubdirs.append(dn)
             # create hash value, if it doesn't have one
             if reader.version.startswith("5.") and not self.pdata["HASH"][0]:
                 hash = str(QCryptographicHash.hash(
                     QByteArray(self.ppath.encode("utf-8")),
                     QCryptographicHash.Sha1).toHex(),
                     encoding="utf-8")
                 self.pdata["HASH"] = [hash]
                 self.setDirty(True)
         return res
     def __writeProject(self, fn=None):
         """
         Private method to save the project infos to a project file.
         @param fn optional filename of the project file to be written (string).
             If fn is None, the filename stored in the project object
             is used. This is the 'save' action. If fn is given, this filename
             is used instead of the one in the project object. This is the
             'save as' action.
         @return flag indicating success
         """
         if self.vcs is not None:
             self.pdata["VCSOPTIONS"] = [
                 copy.deepcopy(self.vcs.vcsGetOptions())]
             self.pdata["VCSOTHERDATA"] = [
                 copy.deepcopy(self.vcs.vcsGetOtherData())]
         if not self.pdata["HASH"][0]:
             hash = str(QCryptographicHash.hash(
                 QByteArray(self.ppath.encode("utf-8")),
                 QCryptographicHash.Sha1).toHex(),
                 encoding="utf-8")
             self.pdata["HASH"] = [hash]
         if fn is None:
             fn = self.pfile
         f = QFile(fn)
         if f.open(QIODevice.WriteOnly):
             from E5XML.ProjectWriter import ProjectWriter
             ProjectWriter(f, os.path.splitext(
                 os.path.basename(fn))[0]).writeXML()
             res = True
         else:
             E5MessageBox.critical(
                 self.ui,
                 self.tr("Save project file"),
                 self.tr(
                     "<p>The project file <b>{0}</b> could not be"
                     " written.</p>").format(fn))
             res = False
         if res:
             self.pfile = os.path.abspath(fn)
             self.ppath = os.path.abspath(os.path.dirname(fn))
             self.name = os.path.splitext(os.path.basename(fn))[0]
             self.setDirty(False)
             # insert filename into list of recently opened projects
             self.__syncRecent()
         return res
     def __readUserProperties(self):
         """
         Private method to read in the user specific project file (.e4q).
         """
         if self.pfile is None:
             return
         fn, ext = os.path.splitext(os.path.basename(self.pfile))
         fn = os.path.join(self.getProjectManagementDir(), '{0}.e4q'.format(fn))
         if os.path.exists(fn):
             f = QFile(fn)
             if f.open(QIODevice.ReadOnly):
                 from E5XML.UserProjectReader import UserProjectReader
                 reader = UserProjectReader(f, self)
                 reader.readXML()
                 f.close()
             else:
                 E5MessageBox.critical(
                     self.ui,
                     self.tr("Read user project properties"),
                     self.tr(
                         "<p>The user specific project properties file"
                         " <b>{0}</b> could not be read.</p>").format(fn))
     def __writeUserProperties(self):
         """
         Private method to write the project data to an XML file.
         """
         if self.pfile is None:
             return
         fn, ext = os.path.splitext(os.path.basename(self.pfile))
         fn = os.path.join(self.getProjectManagementDir(), '{0}.e4q'.format(fn))
         f = QFile(fn)
         if f.open(QIODevice.WriteOnly):
             from E5XML.UserProjectWriter import UserProjectWriter
             UserProjectWriter(
                 f, os.path.splitext(os.path.basename(fn))[0]).writeXML()
             f.close()
         else:
             E5MessageBox.critical(
                 self.ui,
                 self.tr("Save user project properties"),
                 self.tr(
                     "<p>The user specific project properties file <b>{0}</b>"
                     " could not be written.</p>").format(fn))
     def __showContextMenuSession(self):
         """
         Private slot called before the Session menu is shown.
         """
         enable = True
         if self.pfile is None:
             enable = False
         else:
             fn, ext = os.path.splitext(os.path.basename(self.pfile))
             fn_new = os.path.join(self.getProjectManagementDir(),
                                   '{0}.e5s'.format(fn))
             fn_old = os.path.join(self.getProjectManagementDir(),
                                   '{0}.e4s'.format(fn))
             enable = os.path.exists(fn_new) or os.path.exists(fn_old)
         self.sessActGrp.findChild(
             QAction, "project_load_session").setEnabled(enable)
         self.sessActGrp.findChild(
             QAction, "project_delete_session").setEnabled(enable)
     @pyqtSlot()
     def __readSession(self, quiet=False, indicator=""):
         """
         Private method to read in the project session file (.e5s or .e4s).
         @param quiet flag indicating quiet operations.
                 If this flag is true, no errors are reported.
         @keyparam indicator indicator string (string)
         """
         if self.pfile is None:
             if not quiet:
                 E5MessageBox.critical(
                     self.ui,
                     self.tr("Read project session"),
                     self.tr("Please save the project first."))
             return
         fn1, ext = os.path.splitext(os.path.basename(self.pfile))
         fn = os.path.join(self.getProjectManagementDir(),
                           '{0}{1}.e5s'.format(fn1, indicator))
         if not os.path.exists(fn):
             fn = os.path.join(self.getProjectManagementDir(),
                               '{0}{1}.e4s'.format(fn1, indicator))
         f = QFile(fn)
         if f.open(QIODevice.ReadOnly):
             from E5XML.SessionReader import SessionReader
             reader = SessionReader(f, False)
             reader.readXML(quiet=quiet)
             f.close()
         else:
             if not quiet:
                 E5MessageBox.critical(
                     self.ui,
                     self.tr("Read project session"),
                     self.tr(
                         "<p>The project session file <b>{0}</b> could not be"
                         " read.</p>").format(fn))
     @pyqtSlot()
     def __writeSession(self, quiet=False, indicator=""):
         """
         Private method to write the session data to an XML file (.e5s).
         @param quiet flag indicating quiet operations.
                 If this flag is true, no errors are reported.
         @keyparam indicator indicator string (string)
         """
         if self.pfile is None:
             if not quiet:
                 E5MessageBox.critical(
                     self.ui,
                     self.tr("Save project session"),
                     self.tr("Please save the project first."))
             return
         fn, ext = os.path.splitext(os.path.basename(self.pfile))
         fn = os.path.join(self.getProjectManagementDir(),
                           '{0}{1}.e5s'.format(fn, indicator))
         f = QFile(fn)
         if f.open(QIODevice.WriteOnly):
             from E5XML.SessionWriter import SessionWriter
             SessionWriter(
                 f, os.path.splitext(os.path.basename(fn))[0]).writeXML()
             f.close()
         else:
             if not quiet:
                 E5MessageBox.critical(
                     self.ui,
                     self.tr("Save project session"),
                     self.tr(
                         "<p>The project session file <b>{0}</b> could not be"
                         " written.</p>").format(fn))
     def __deleteSession(self):
         """
         Private method to delete the session file.
         """
         if self.pfile is None:
             E5MessageBox.critical(
                 self.ui,
                 self.tr("Delete project session"),
                 self.tr("Please save the project first."))
             return
         fname, ext = os.path.splitext(os.path.basename(self.pfile))
         for fn in [
             os.path.join(
                 self.getProjectManagementDir(), "{0}.e5s".format(fname)),
             os.path.join(
                 self.getProjectManagementDir(), "{0}.e4s".format(fname))]:
             if os.path.exists(fn):
                 try:
                     os.remove(fn)
                 except OSError:
                     E5MessageBox.critical(
                         self.ui,
                         self.tr("Delete project session"),
                         self.tr(
                             "<p>The project session file <b>{0}</b> could"
                             " not be deleted.</p>").format(fn))
     def __readTasks(self):
         """
         Private method to read in the project tasks file (.e6t).
         """
         if self.pfile is None:
             E5MessageBox.critical(
                 self.ui,
                 self.tr("Read tasks"),
                 self.tr("Please save the project first."))
             return
         base, ext = os.path.splitext(os.path.basename(self.pfile))
         fn = os.path.join(self.getProjectManagementDir(),
                           '{0}.e6t'.format(base))
         if not os.path.exists(fn):
             # try again with the old extension
             fn = os.path.join(self.getProjectManagementDir(),
                               '{0}.e4t'.format(base))
             if not os.path.exists(fn):
                 return
         f = QFile(fn)
         if f.open(QIODevice.ReadOnly):
             from E5XML.TasksReader import TasksReader
             reader = TasksReader(f, True)
             reader.readXML()
             f.close()
         else:
             E5MessageBox.critical(
                 self.ui,
                 self.tr("Read tasks"),
                 self.tr(
                     "<p>The tasks file <b>{0}</b> could not be read.</p>")
                 .format(fn))
     def writeTasks(self):
         """
         Public method to write the tasks data to an XML file (.e6t).
         """
         if self.pfile is None:
             return
         fn, ext = os.path.splitext(os.path.basename(self.pfile))
         fn = os.path.join(self.getProjectManagementDir(), '{0}.e6t'.format(fn))
         f = QFile(fn)
         ok = f.open(QIODevice.WriteOnly)
         if not ok:
             E5MessageBox.critical(
                 self.ui,
                 self.tr("Save tasks"),
                 self.tr(
                     "<p>The tasks file <b>{0}</b> could not be written.</p>")
                 .format(fn))
             return
         from E5XML.TasksWriter import TasksWriter
         TasksWriter(
             f, True, os.path.splitext(os.path.basename(fn))[0]).writeXML()
         f.close()
     def __showContextMenuDebugger(self):
         """
         Private slot called before the Debugger menu is shown.
         """
         enable = True
         if self.pfile is None:
             enable = False
         else:
             fn, ext = os.path.splitext(os.path.basename(self.pfile))
             fn = os.path.join(self.getProjectManagementDir(),
                               '{0}.e4d'.format(fn))
             enable = os.path.exists(fn)
         self.dbgActGrp.findChild(
             QAction, "project_debugger_properties_load").setEnabled(enable)
         self.dbgActGrp.findChild(
             QAction, "project_debugger_properties_delete").setEnabled(enable)
     @pyqtSlot()
     def __readDebugProperties(self, quiet=False):
         """
         Private method to read in the project debugger properties file (.e4d).
         @param quiet flag indicating quiet operations.
                 If this flag is true, no errors are reported.
         """
         if self.pfile is None:
             if not quiet:
                 E5MessageBox.critical(
                     self.ui,
                     self.tr("Read debugger properties"),
                     self.tr("Please save the project first."))
             return
         fn, ext = os.path.splitext(os.path.basename(self.pfile))
         fn = os.path.join(self.getProjectManagementDir(), '{0}.e4d'.format(fn))
         f = QFile(fn)
         if f.open(QIODevice.ReadOnly):
             from E5XML.DebuggerPropertiesReader import DebuggerPropertiesReader
             reader = DebuggerPropertiesReader(f, self)
             reader.readXML(quiet=quiet)
             f.close()
         else:
             if not quiet:
                 E5MessageBox.critical(
                     self.ui,
                     self.tr("Read debugger properties"),
                     self.tr(
                         "<p>The project debugger properties file <b>{0}</b>"
                         " could not be read.</p>").format(fn))
     @pyqtSlot()
 




8cd4d08fa9f6
Made code mostly PEP 8 compliant (except all whitespace and line length).

Detlev Offenbach <detlev@die-offenbachs.de>
parents: 
882

Mercurial Repositories > eric / annotate

Project/Project.py@fd7d34bd1a88 (annotated)

Project/Project.py