eric: comparison src/eric7/Project/Project.py

-:6156d9675f62
+:ea35c92a3c7c
 from PyQt6.Qsci import QsciScintilla
 from PyQt6.QtCore import (
 QByteArray,
 QCryptographicHash,
-QFile,
-QIODevice,
 QObject,
 QProcess,
 pyqtSignal,
 pyqtSlot,
 )
 from eric7.EricGui.EricOverrideCursor import EricOverrideCursor, EricOverridenCursor
 from eric7.EricWidgets import EricFileDialog, EricMessageBox
 from eric7.EricWidgets.EricApplication import ericApp
 from eric7.EricWidgets.EricListSelectionDialog import EricListSelectionDialog
 from eric7.EricWidgets.EricProgressDialog import EricProgressDialog
-from eric7.EricXML.DebuggerPropertiesReader import DebuggerPropertiesReader
-from eric7.EricXML.ProjectReader import ProjectReader
-from eric7.EricXML.SessionReader import SessionReader
-from eric7.EricXML.TasksReader import TasksReader
-from eric7.EricXML.UserProjectReader import UserProjectReader
 from eric7.Globals import recentNameProject
+from eric7.RemoteServerInterface import EricServerFileDialog
 from eric7.Sessions.SessionFile import SessionFile
 from eric7.SystemUtilities import (
 FileSystemUtilities,
 OSUtilities,
 PythonUtilities,
 eols = [os.linesep, "\n", "\r", "\r\n"]
 DefaultMake = "make"
 DefaultMakefile = "makefile"
-def __init__(self, parent=None, filename=None):
+def __init__(self, parent=None, filename=None, remoteServer=None):
 """
 Constructor
 @param parent parent widget (usually the ui object)
 @type QWidget
-@param filename optional filename of a project file to open
+@param filename optional filename of a project file to open (defaults to None)
-@type str
+@type str (optional)
+@param remoteServer reference to the 'eric-ide' server interface object
+@type EricServerInterface
 """
 super().__init__(parent)
 self.ui = parent
+self.__remotefsInterface = remoteServer.getServiceInterface("FileSystem")
 self.__progLanguages = [
 "Python3",
 "MicroPython",
 "Ruby",
 if filename is not None:
 self.openProject(filename)
 else:
 self.vcs = self.initVCS()
-self.__model = ProjectBrowserModel(self)
+self.__model = ProjectBrowserModel(self, fsInterface=self.__remotefsInterface)
 self.codemetrics = None
 self.codecoverage = None
 self.profiledata = None
 self.applicationDiagram = None
 @param index key of the list to be checked
 @type str
 """
 removed = False
 removelist = []
-for file in self.__pdata[index]:
+if FileSystemUtilities.isRemoteFileName(self.ppath):
-if not os.path.exists(os.path.join(self.ppath, file)):
+for file in self.__pdata[index]:
-removelist.append(file)
+if not self.__remotefsInterface.exists(
-removed = True
+self.__remotefsInterface.join(self.ppath, file)
+):
+removelist.append(file)
+removed = True
+else:
+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 (.epj or .e4p) file.
+Private method to read in a project file (.epj).
 @param fn filename of the project file to be read
 @type str
 @return flag indicating success
 @rtype bool
 """
-if os.path.splitext(fn)[1] == ".epj":
+with EricOverrideCursor():
-# new JSON based format
+res = self.__projectFile.readFile(fn)
-with EricOverrideCursor():
-res = self.__projectFile.readFile(fn)
+if res:
-else:
+if FileSystemUtilities.isRemoteFileName(fn):
-# old XML based format
+self.pfile = fn
-f = QFile(fn)
+self.ppath = self.__remotefsInterface.dirname(fn)
-if f.open(QIODevice.OpenModeFlag.ReadOnly):
+self.name = self.__remotefsInterface.splitext(
-reader = ProjectReader(f, self)
+self.__remotefsInterface.basename(fn)
-reader.readXML()
+)[0]
-res = not reader.hasError()
-f.close()
-# create hash value, if it doesn't have one
-if reader.version.startswith("5.") and not self.__pdata["HASH"]:
-hashStr = str(
-QCryptographicHash.hash(
-QByteArray(self.ppath.encode("utf-8")),
-QCryptographicHash.Algorithm.Sha1,
-).toHex(),
-encoding="utf-8",
-)
-self.__pdata["HASH"] = hashStr
-self.setDirty(True)
 else:
-EricMessageBox.critical(
+self.pfile = os.path.abspath(fn)
-self.ui,
+self.ppath = os.path.abspath(os.path.dirname(fn))
-self.tr("Read Project File"),
+self.name = os.path.splitext(os.path.basename(fn))[0]
-self.tr(
-"<p>The project file <b>{0}</b> could not be read.</p>"
-).format(fn),
-)
-res = False
-if res:
-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 self.__pdata["TRANSLATIONPATTERN"]:
 self.translationsRoot = self.__pdata["TRANSLATIONPATTERN"].split(
 "%language%"
 )[0]
 elif self.__pdata["MAINSCRIPT"]:
 self.translationsRoot = os.path.splitext(self.__pdata["MAINSCRIPT"])[0]
-if os.path.isdir(os.path.join(self.ppath, self.translationsRoot)):
-dn = self.translationsRoot
+if FileSystemUtilities.isRemoteFileName(self.ppath):
+if self.__remotefsInterface.isdir(
+self.__remotefsInterface.join(self.ppath, self.translationsRoot)
+):
+dn = self.translationsRoot
+else:
+dn = self.__remotefsInterface.dirname(self.translationsRoot)
 else:
-dn = os.path.dirname(self.translationsRoot)
+if os.path.isdir(os.path.join(self.ppath, self.translationsRoot)):
-if dn not in self.subdirs:
+dn = self.translationsRoot
+else:
+dn = os.path.dirname(self.translationsRoot)
+if dn and 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
 for fileCategory in self.getFileCategories():
 self.__checkFilesExist(fileCategory)
 # get the names of subdirectories the files are stored in
 for fileCategory in [c for c in self.getFileCategories() if c != "OTHERS"]:
 for fn in self.__pdata[fileCategory]:
-dn = os.path.dirname(fn)
+dn = (
-if dn not in self.subdirs:
+self.__remotefsInterface.dirname(fn)
+if FileSystemUtilities.isRemoteFileName(fn)
+else os.path.dirname(fn)
+)
+if dn and 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)
+dn = (
-if dn not in self.otherssubdirs:
+self.__remotefsInterface.dirname(fn)
+if FileSystemUtilities.isRemoteFileName(fn)
+else os.path.dirname(fn)
+)
+if dn and dn not in self.otherssubdirs:
 self.otherssubdirs.append(dn)
 return res
 def __writeProject(self, fn=None):
 with EricOverrideCursor():
 res = self.__projectFile.writeFile(fn)
 if res:
-self.pfile = os.path.abspath(fn)
+if FileSystemUtilities.isRemoteFileName(fn):
-self.ppath = os.path.abspath(os.path.dirname(fn))
+self.pfile = fn
-self.name = os.path.splitext(os.path.basename(fn))[0]
+self.ppath = self.__remotefsInterface.dirname(fn)
+self.name = self.__remotefsInterface.splitext(
+self.__remotefsInterface.basename(fn)
+)[0]
+else:
+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 (.eqj or
+Private method to read in the user specific project file (.eqj).
-.e4q).
 """
 if self.pfile is None:
 return
-fn1, ext = os.path.splitext(os.path.basename(self.pfile))
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-fn = os.path.join(self.getProjectManagementDir(), "{0}.eqj".format(fn1))
+fn1, _ext = self.__remotefsInterface.splitext(
-if os.path.exists(fn):
+self.__remotefsInterface.basename(self.pfile)
-# try the new JSON based format first
+)
-self.__userProjectFile.readFile(fn)
+fn = self.__remotefsInterface.join(
+self.getProjectManagementDir(), f"{fn1}.eqj"
+)
+if not self.__remotefsInterface.exists(fn):
+return
 else:
-# try the old XML based format second
+fn1, _ext = os.path.splitext(os.path.basename(self.pfile))
-fn = os.path.join(self.getProjectManagementDir(), "{0}.e4q".format(fn1))
+fn = os.path.join(self.getProjectManagementDir(), f"{fn1}.eqj")
-if os.path.exists(fn):
+if not os.path.exists(fn):
-f = QFile(fn)
+return
-if f.open(QIODevice.OpenModeFlag.ReadOnly):
-reader = UserProjectReader(f, self)
+self.__userProjectFile.readFile(fn)
-reader.readXML()
-f.close()
-else:
-EricMessageBox.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 user specific project data to a JSON file.
 """
 if self.pfile is None:
 return
-fn, ext = os.path.splitext(os.path.basename(self.pfile))
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-fn = os.path.join(self.getProjectManagementDir(), "{0}.eqj".format(fn))
+fn1, _ext = self.__remotefsInterface.splitext(
+self.__remotefsInterface.basename(self.pfile)
+)
+fn = self.__remotefsInterface.join(
+self.getProjectManagementDir(), f"{fn1}.eqj"
+)
+else:
+fn1, _ext = os.path.splitext(os.path.basename(self.pfile))
+fn = os.path.join(self.getProjectManagementDir(), f"{fn1}.eqj")
 with EricOverrideCursor():
 self.__userProjectFile.writeFile(fn)
 def __showContextMenuSession(self):
 """
 enable = True
 if self.pfile is None:
 enable = False
 else:
-fn, ext = os.path.splitext(os.path.basename(self.pfile))
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-fn_new = os.path.join(self.getProjectManagementDir(), "{0}.esj".format(fn))
+fn, _ext = self.__remotefsInterface.splitext(
-fn_old = os.path.join(self.getProjectManagementDir(), "{0}.e5s".format(fn))
+self.__remotefsInterface.basename(self.pfile)
-enable = os.path.exists(fn_new) or os.path.exists(fn_old)
+)
+fn_sess = self.__remotefsInterface.join(
+self.getProjectManagementDir(), f"{fn}.esj"
+)
+enable = self.__remotefsInterface.exists(fn)
+else:
+fn, _ext = os.path.splitext(os.path.basename(self.pfile))
+fn_sess = os.path.join(self.getProjectManagementDir(), f"{fn}.esj")
+enable = os.path.exists(fn_sess)
 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 (.esj or .e5s).
+Private method to read in the project session file (.esj).
 @param quiet flag indicating quiet operations.
 If this flag is true, no errors are reported.
 @type bool
 @param indicator indicator string
 self.tr("Read Project Session"),
 self.tr("Please save the project first."),
 )
 return
-fn1, ext = os.path.splitext(os.path.basename(self.pfile))
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-fn = os.path.join(
+fn1, _ext = self.__remotefsInterface.splitext(
-self.getProjectManagementDir(), "{0}{1}.esj".format(fn1, indicator)
+self.__remotefsInterface.basename(self.pfile)
 )
-if os.path.exists(fn):
+fn = self.__remotefsInterface.join(
-# try the new JSON based format first
+self.getProjectManagementDir(), f"{fn1}{indicator}.esj"
-self.__sessionFile.readFile(fn)
+)
+if not self.__remotefsInterface.exists(fn):
+return
 else:
-# try the old XML based format second
+fn1, _ext = os.path.splitext(os.path.basename(self.pfile))
 fn = os.path.join(
-self.getProjectManagementDir(), "{0}{1}.e5s".format(fn1, indicator)
+self.getProjectManagementDir(), f"{fn1}{indicator}.esj"
 )
-if os.path.exists(fn):
+if not os.path.exists(fn):
-f = QFile(fn)
+return
-if f.open(QIODevice.OpenModeFlag.ReadOnly):
-reader = SessionReader(f, False)
+self.__sessionFile.readFile(fn)
-reader.readXML(quiet=quiet)
-f.close()
-else:
-if not quiet:
-EricMessageBox.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 (.esj).
 self.tr("Save Project Session"),
 self.tr("Please save the project first."),
 )
 return
-fn, ext = os.path.splitext(os.path.basename(self.pfile))
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-fn = os.path.join(
+fn1, _ext = self.__remotefsInterface.splitext(
-self.getProjectManagementDir(), "{0}{1}.esj".format(fn, indicator)
+self.__remotefsInterface.basename(self.pfile)
 )
+fn = self.__remotefsInterface.join(
+self.getProjectManagementDir(), f"{fn1}{indicator}.esj"
+)
+else:
+fn1, _ext = os.path.splitext(os.path.basename(self.pfile))
+fn = os.path.join(
+self.getProjectManagementDir(), f"{fn1}{indicator}.esj"
+)
 self.__sessionFile.writeFile(fn)
 def __deleteSession(self):
 """
 self.tr("Delete Project Session"),
 self.tr("Please save the project first."),
 )
 return
-fname, ext = os.path.splitext(os.path.basename(self.pfile))
+try:
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-for ext in (".esj", ".e5s", ".e4s"):
+title = self.tr("Delete Remote Project Session")
-fn = os.path.join(
+fname, _ext = self.__remotefsInterface.splitext(
-self.getProjectManagementDir(), "{0}{1}".format(fname, ext)
+self.__remotefsInterface.basename(self.pfile)
 )
-if os.path.exists(fn):
+fn = self.__remotefsInterface.join(
-try:
+self.getProjectManagementDir(), f"{fname}.esj"
+)
+if self.__remotefsInterface.exists(fn):
+self.__remotefsInterface.remove(fn)
+else:
+title = self.tr("Delete Project Session")
+fname, _ext = os.path.splitext(os.path.basename(self.pfile))
+fn = os.path.join(self.getProjectManagementDir(), f"{fname}.esj")
+if os.path.exists(fn):
 os.remove(fn)
 except OSError:
 EricMessageBox.critical(
 self.ui,
-self.tr("Delete Project Session"),
+title,
 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 (.etj or .e6t).
+Private method to read in the project tasks file (.etj).
 """
 if self.pfile is None:
 EricMessageBox.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))
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-fn = os.path.join(self.getProjectManagementDir(), "{0}.etj".format(base))
+base, _ext = self.__remotefsInterface.splitext(
-if os.path.exists(fn):
+self.__remotefsInterface.basename(self.pfile)
-# try new style JSON file first
+)
-self.__tasksFile.readFile(fn)
+fn = self.__remotefsInterface.join(
+self.getProjectManagementDir(), f"{base}.etj"
+)
+if not self.__remotefsInterface.exists(fn):
+return
 else:
-# try old style XML file second
+base, ext = os.path.splitext(os.path.basename(self.pfile))
-fn = os.path.join(self.getProjectManagementDir(), "{0}.e6t".format(base))
+fn = os.path.join(self.getProjectManagementDir(), f"{base}.etj")
-if os.path.exists(fn):
+if not os.path.exists(fn):
-f = QFile(fn)
+return
-if f.open(QIODevice.OpenModeFlag.ReadOnly):
-reader = TasksReader(f, True)
+self.__tasksFile.readFile(fn)
-reader.readXML()
-f.close()
-else:
-EricMessageBox.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 a JSON file (.etj).
 """
 if self.pfile is None:
 return
-fn, ext = os.path.splitext(os.path.basename(self.pfile))
+if FileSystemUtilities.isRemoteFileName(self.pfile):
+base, _ext = self.__remotefsInterface.splitext(
-fn = os.path.join(self.getProjectManagementDir(), "{0}.etj".format(fn))
+self.__remotefsInterface.basename(self.pfile)
+)
+fn = self.__remotefsInterface.join(
+self.getProjectManagementDir(), f"{base}.etj"
+)
+else:
+base, ext = os.path.splitext(os.path.basename(self.pfile))
+fn = os.path.join(self.getProjectManagementDir(), f"{base}.etj")
 self.__tasksFile.writeFile(fn)
 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))
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-# try new style file first
+fn1, _ext = self.__remotefsInterface.splitext(
-fn = os.path.join(self.getProjectManagementDir(), "{0}.edj".format(fn))
+self.__remotefsInterface.basename(self.pfile)
-if not os.path.exists(fn):
+)
-# try old style file second
+fn = self.__remotefsInterface.join(
-fn = os.path.join(self.getProjectManagementDir(), "{0}.e4d".format(fn))
+self.getProjectManagementDir(), f"{fn1}.edj"
-enable = os.path.exists(fn)
+)
+enable = self.__remotefsInterface.exists(fn)
+else:
+fn1, _ext = os.path.splitext(os.path.basename(self.pfile))
+fn = os.path.join(self.getProjectManagementDir(), f"{fn1}.edj")
+enable = os.path.exists(fn)
 self.dbgActGrp.findChild(
 QAction, "project_debugger_properties_load"
 ).setEnabled(enable)
 self.dbgActGrp.findChild(
 QAction, "project_debugger_properties_delete"
 self.tr("Read Debugger Properties"),
 self.tr("Please save the project first."),
 )
 return
-fn1, ext = os.path.splitext(os.path.basename(self.pfile))
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-fn = os.path.join(self.getProjectManagementDir(), "{0}.edj".format(fn1))
+fn1, _ext = self.__remotefsInterface.splitext(
-if os.path.exists(fn):
+self.__remotefsInterface.basename(self.pfile)
-# try the new JSON based format first
+)
-if self.__debuggerPropertiesFile.readFile(fn):
+fn = self.__remotefsInterface.join(
-self.debugPropertiesLoaded = True
+self.getProjectManagementDir(), f"{fn1}.edj"
-self.debugPropertiesChanged = False
+)
+if not self.__remotefsInterface.exists(fn):
+return
 else:
-# try the old XML based format second
+fn1, _ext = os.path.splitext(os.path.basename(self.pfile))
-fn = os.path.join(self.getProjectManagementDir(), "{0}.e4d".format(fn1))
+fn = os.path.join(self.getProjectManagementDir(), f"{fn1}.edj")
+if not os.path.exists(fn):
-f = QFile(fn)
+return
-if f.open(QIODevice.OpenModeFlag.ReadOnly):
-reader = DebuggerPropertiesReader(f, self)
+if self.__debuggerPropertiesFile.readFile(fn):
-reader.readXML(quiet=quiet)
+self.debugPropertiesLoaded = True
-f.close()
+self.debugPropertiesChanged = False
-self.debugPropertiesLoaded = True
-self.debugPropertiesChanged = False
-else:
-if not quiet:
-EricMessageBox.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()
 def __writeDebugProperties(self, quiet=False):
 """
 Private method to write the project debugger properties file (.edj).
 self.tr("Save Debugger Properties"),
 self.tr("Please save the project first."),
 )
 return
-fn, ext = os.path.splitext(os.path.basename(self.pfile))
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-fn = os.path.join(self.getProjectManagementDir(), "{0}.edj".format(fn))
+fn1, _ext = self.__remotefsInterface.splitext(
+self.__remotefsInterface.basename(self.pfile)
+)
+fn = self.__remotefsInterface.join(
+self.getProjectManagementDir(), f"{fn1}.edj"
+)
+else:
+fn1, _ext = os.path.splitext(os.path.basename(self.pfile))
+fn = os.path.join(self.getProjectManagementDir(), f"{fn1}.edj")
 with EricOverrideCursor():
 self.__debuggerPropertiesFile.writeFile(fn)
 def __deleteDebugProperties(self):
 self.tr("Delete Debugger Properties"),
 self.tr("Please save the project first."),
 )
 return
-fname, ext = os.path.splitext(os.path.basename(self.pfile))
+try:
+if FileSystemUtilities.isRemoteFileName(self.pfile):
-for ext in (".edj", ".e4d"):
+title = self.tr("Delete Remote Debugger Properties")
-fn = os.path.join(
+fname, _ext = self.__remotefsInterface.splitext(
-self.getProjectManagementDir(), "{0}{1}".format(fname, ext)
+self.__remotefsInterface.basename(self.pfile)
 )
-if os.path.exists(fn):
+fn = self.__remotefsInterface.join(
-try:
+self.getProjectManagementDir(), f"{fname}.edj"
+)
+if self.__remotefsInterface.exists(fn):
+self.__remotefsInterface.remove(fn)
+else:
+title = self.tr("Delete Debugger Properties")
+fname, _ext = os.path.splitext(os.path.basename(self.pfile))
+fn = os.path.join(self.getProjectManagementDir(), f"{fname}.edj")
+if os.path.exists(fn):
 os.remove(fn)
 except OSError:
 EricMessageBox.critical(
 self.ui,
-self.tr("Delete Debugger Properties"),
+title,
 self.tr(
 "<p>The project debugger properties file"
 " <b>{0}</b> could not be deleted.</p>"
 ).format(fn),
 )
 def __initDebugProperties(self):
 """
 Private method to initialize the debug properties.
 """
 """
 tbPath = self.__pdata["TRANSLATIONSBINPATH"]
 for langFile in self.__pdata["TRANSLATIONS"][:]:
 qmFile = self.__binaryTranslationFile(langFile)
 if qmFile:
-if qmFile not in self.__pdata["TRANSLATIONS"] and os.path.exists(
+if FileSystemUtilities.isRemoteFileName(self.ppath):
-os.path.join(self.ppath, qmFile)
+if (
-):
+qmFile not in self.__pdata["TRANSLATIONS"]
-self.appendFile(qmFile)
+and self.__remotefsInterface.exists(
-if tbPath:
+self.__remotefsInterface.join(self.ppath, qmFile)
-qmFile = os.path.join(tbPath, os.path.basename(qmFile))
+)
+):
+self.appendFile(qmFile)
+if tbPath:
+qmFile = self.__remotefsInterface.join(
+tbPath, self.__remotefsInterface.basename(qmFile)
+)
+if (
+qmFile not in self.__pdata["TRANSLATIONS"]
+and self.__remotefsInterface.exists(
+self.__remotefsInterface.join(self.ppath, qmFile)
+)
+):
+self.appendFile(qmFile)
+else:
 if qmFile not in self.__pdata["TRANSLATIONS"] and os.path.exists(
 os.path.join(self.ppath, qmFile)
 ):
 self.appendFile(qmFile)
+if tbPath:
+qmFile = os.path.join(tbPath, os.path.basename(qmFile))
+if (
+qmFile not in self.__pdata["TRANSLATIONS"]
+and os.path.exists(os.path.join(self.ppath, qmFile))
+):
+self.appendFile(qmFile)
 def removeLanguageFile(self, langFile):
 """
 Public slot to remove a translation from the project.
 self.__model.removeItem(langFile)
 self.__pdata["TRANSLATIONS"].remove(langFile)
 if qmFile:
 with contextlib.suppress(ValueError):
 if self.__pdata["TRANSLATIONSBINPATH"]:
-qmFile = self.getRelativePath(
+if FileSystemUtilities.isRemoteFileName(self.ppath):
-os.path.join(
+qmFile = self.__remotefsInterface.join(
 self.__pdata["TRANSLATIONSBINPATH"],
-os.path.basename(qmFile),
+self.__remotefsInterface.basename(qmFile),
 )
-)
+else:
+qmFile = self.getRelativePath(
+os.path.join(
+self.__pdata["TRANSLATIONSBINPATH"],
+os.path.basename(qmFile),
+)
+)
 self.__model.removeItem(qmFile)
 self.__pdata["TRANSLATIONS"].remove(qmFile)
 self.setDirty(True)
 def deleteLanguageFile(self, langFile):
 """
 langFile = self.getRelativePath(langFile)
 qmFile = self.__binaryTranslationFile(langFile)
 try:
-fn = os.path.join(self.ppath, langFile)
+if FileSystemUtilities.isRemoteFileName(self.ppath):
-if os.path.exists(fn):
+fn = self.__remotefsInterface.join(self.ppath, langFile)
-os.remove(fn)
+if self.__remotefsInterface.exists(fn):
+self.__remotefsInterface.remove(fn)
+else:
+fn = os.path.join(self.ppath, langFile)
+if os.path.exists(fn):
+os.remove(fn)
 except OSError as err:
 EricMessageBox.critical(
 self.ui,
-self.tr("Delete translation"),
+self.tr("Delete Translation"),
 self.tr(
 "<p>The selected translation file <b>{0}</b> could not be"
 " deleted.</p><p>Reason: {1}</p>"
 ).format(langFile, str(err)),
 )
 """
 dirty = False
 # make it relative to the project root, if it starts with that path
 # assume relative paths are relative to the project root
-newfn = self.getRelativePath(fn) if os.path.isabs(fn) else fn
+if FileSystemUtilities.isRemoteFileName(self.ppath):
-newdir = os.path.dirname(newfn)
+newfn = self.getRelativePath(fn) if fn.startswith(self.ppath) else fn
+newdir = self.__remotefsInterface.dirname(newfn)
+else:
+newfn = self.getRelativePath(fn) if os.path.isabs(fn) else fn
+newdir = os.path.dirname(newfn)
 if isSourceFile:
 filetype = "SOURCES"
 else:
 filetype = "OTHERS"
-bfn = os.path.basename(newfn)
+bfn = (
+self.__remotefsInterface.basename(newfn)
+if FileSystemUtilities.isRemoteFileName(self.ppath)
+else os.path.basename(newfn)
+)
 if fnmatch.fnmatch(bfn, "*.ts") or fnmatch.fnmatch(bfn, "*.qm"):
 filetype = "TRANSLATIONS"
 else:
 for pattern in sorted(self.__pdata["FILETYPES"], reverse=True):
 if fnmatch.fnmatch(bfn, pattern):
 @param fileTypeFilter filter to be used by the add file dialog
 @type str
 @param startdir start directory for the selection dialog
 @type str
 """
+# TODO: adapt to remote server
 from .AddFileDialog import AddFileDialog
 if not startdir:
 startdir = self.ppath
 @param target target directory
 @type str
 @param quiet flag indicating quiet operations
 @type bool
 """
+# TODO: adapt to remote server
 # get all relevant filename patterns
 patterns = []
 ignorePatterns = []
 for pattern, patterntype in self.__pdata["FILETYPES"].items():
 if patterntype == filetype:
 @param source source directory
 @type str
 @param target target directory
 @type str
 """
+# TODO: adapt to remote server
 # first perform the addition of source
 self.__addSingleDirectory(filetype, source, target, True)
 ignore_patterns = [
 ".svn",
 @param fileTypeFilter filter to be used by the add directory dialog
 @type str
 @param startdir start directory for the selection dialog
 @type str
 """
+# TODO: adapt to remote server
 from .AddDirectoryDialog import AddDirectoryDialog
 if not startdir:
 startdir = self.ppath
 Public method to add a file/directory to the OTHERS project data.
 @param fn file name or directory name to add
 @type str
 """
+# TODO: adapt to remote server
 if fn:
 # if it is below the project directory, make it relative to that
 fn = self.getRelativePath(fn)
 # if it ends with the directory separator character, remove it
 @param newfn new filename of the file
 @type str
 @return flag indicating success
 @rtype bool
 """
+# TODO: adapt to remote server
 fn = self.getRelativePath(oldfn)
 isSourceFile = fn in self.__pdata["SOURCES"]
 if newfn is None:
 newfn = EricFileDialog.getSaveFileName(
 @type str
 @param isSourceFile flag indicating that this is a source file
 even if it doesn't have the source extension
 @type bool
 """
+# TODO: adapt to remote server
 fn = self.getRelativePath(oldname)
 if os.path.dirname(oldname) == os.path.dirname(newname):
 if self.__isInPdata(oldname):
 self.removeFile(oldname, False)
 self.appendFile(newname, isSourceFile, False)
 @param start prefix
 @type str
 @return list of files starting with a common prefix
 @rtype list of str
 """
+# TODO: adapt to remote server
 filelist = []
 start = self.getRelativePath(start)
 for fileCategory in [
 c for c in self.getFileCategories() if c != "TRANSLATIONS"
 ]:
 @return flag indicating success
 @rtype bool
 """
 if self.isDirty():
 if len(self.pfile) > 0:
-if self.pfile.endswith(".e4p"):
-self.pfile = self.pfile.replace(".e4p", ".epj")
-self.__syncRecent()
 ok = self.__writeProject()
 else:
 ok = self.saveProjectAs()
 else:
 ok = True
 @return name of the project
 @rtype str
 """
 if self.pfile:
-name = os.path.splitext(self.pfile)[0]
+return self.name
-return os.path.basename(name)
 else:
 return ""
 def getProjectManagementDir(self):
 """
 Public method to get the path of the management directory.
 @return path of the management directory
 @rtype str
 """
-return os.path.join(self.ppath, ".eric7project")
+if FileSystemUtilities.isRemoteFileName(self.ppath):
+return self.__remotefsInterface.join(self.ppath, ".eric7project")
+else:
+return os.path.join(self.ppath, ".eric7project")
 def createProjectManagementDir(self):
 """
 Public method to create the project management directory.
 It does nothing, if it already exists.
 """
 # create management directory if not present
 mgmtDir = self.getProjectManagementDir()
-if not os.path.exists(mgmtDir):
+if FileSystemUtilities.isRemoteFileName(mgmtDir):
-os.makedirs(mgmtDir)
+self.__remotefsInterface.makedirs(mgmtDir, exist_ok=True)
+else:
+os.makedirs(mgmtDir, exist_ok=True)
 def getHash(self):
 """
 Public method to get the project hash.
 """
 if path is None:
 return ""
 try:
-return str(pathlib.Path(path).relative_to(self.ppath))
+if FileSystemUtilities.isRemoteFileName(self.ppath):
+if self.__remotefsInterface.separator() == "\\":
+return str(pathlib.PureWindowsPath(path).relative_to(self.ppath))
+else:
+return str(pathlib.PurePosixPath(path).relative_to(self.ppath))
+else:
+return str(pathlib.PurePath(path).relative_to(self.ppath))
 except ValueError:
 return path
 def getRelativeUniversalPath(self, path):
 """
 @type str
 @return project relative path or unchanged path, if path doesn't
 belong to the project
 @rtype str
 """
-return FileSystemUtilities.fromNativeSeparators(self.getRelativePath(path))
+if FileSystemUtilities.isRemoteFileName(self.ppath):
+return self.__remotefsInterface.fromNativeSeparators(
+self.getRelativePath(path)
+)
+else:
+return FileSystemUtilities.fromNativeSeparators(self.getRelativePath(path))
 def getAbsolutePath(self, fn):
 """
 Public method to convert a project relative file path to an absolute
 file path.
 @param fn file or directory name to convert
 @type str
 @return absolute path
 @rtype str
 """
-if not os.path.isabs(fn):
+if not fn.startswith(self.ppath):
-fn = os.path.join(self.ppath, fn)
+if FileSystemUtilities.isRemoteFileName(self.ppath):
+fn = self.__remotefsInterface.join(self.ppath, fn)
+else:
+fn = os.path.join(self.ppath, fn)
 return fn
 def getAbsoluteUniversalPath(self, fn):
 """
 Public method to convert a project relative file path with universal
 @param fn file or directory name to convert
 @type str
 @return absolute path
 @rtype str
 """
-if not os.path.isabs(fn):
+if not fn.startswith(self.ppath):
-fn = os.path.join(self.ppath, FileSystemUtilities.toNativeSeparators(fn))
+if FileSystemUtilities.isRemoteFileName(self.ppath):
+fn = self.__remotefsInterface.join(
+self.ppath, self.__remotefsInterface.fromNativeSeparators(fn)
+)
+else:
+fn = os.path.join(
+self.ppath, FileSystemUtilities.fromNativeSeparators(fn)
+)
 return fn
 def getEolString(self):
 """
 Public method to get the EOL-string to be used by the project.
 @param group group to check
 @type str
 @return flag indicating membership
 @rtype bool
 """
-newfn = os.path.abspath(fn)
+newfn = (
+fn
+if FileSystemUtilities.isRemoteFileName(fn)
+else os.path.abspath(fn)
+)
 newfn = self.getRelativePath(newfn)
 if newfn in self.__pdata[group] or (
 group == "OTHERS"
 and any(newfn.startswith(entry) for entry in self.__pdata[group])
 ):
 act.setWhatsThis(
 self.tr("""<b>Open...</b><p>This opens an existing project.</p>""")
 )
 act.triggered.connect(self.openProject)
 self.actions.append(act)
+self.openRemoteAct = EricAction(
+self.tr("Open remote project"),
+EricPixmapCache.getIcon("projectOpen-remote"),
+self.tr("Open (Remote)..."),
+0,
+0,
+self.actGrp1,
+"project_open_remote",
+)
+self.openRemoteAct.setStatusTip(self.tr("Open an existing remote project"))
+self.openRemoteAct.setWhatsThis(
+self.tr(
+"<b>Open (Remote)...</b><p>This opens an existing remote project.</p>"
+)
+)
+self.openRemoteAct.triggered.connect(self.__openRemoteProject)
+self.actions.append(self.openRemoteAct)
+self.openRemoteAct.setEnabled(False)  # server is not connected initially
 self.reloadAct = EricAction(
 self.tr("Reload project"),
 EricPixmapCache.getIcon("projectReload"),
 self.tr("Re&load"),
 self.__createEmbeddedEnvironment(upgrade=True)
 except (OSError, json.JSONDecodeError):
 # the configuration file does not exist or is invalid JSON
 self.__initVenvConfiguration()
+#############################################################################
+## Below are methods implementing the support for 'eric-ide server projects
+#############################################################################
+@pyqtSlot(bool)
+def remoteConnectionChanged(self, connected):
+"""
+Public slot to handle a change of the 'eric-ide' server connection state.
+@param connected flag indicating the connection state
+@type bool
+"""
+self.openRemoteAct.setEnabled(connected)
+@pyqtSlot()
+def __openRemoteProject(self):
+"""
+Private slot to open a project of an 'eric-ide' server.
+"""
+# TODO: not implemented yet
+fn = EricServerFileDialog.getOpenFileName(
+self.parent(),
+self.tr("Open project"),
+"",
+self.tr("Project Files (*.epj)"),
+)
+if fn:
+self.openProject(fn=fn)
 #
 # eflag: noqa = M601

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Project/Project.py

src/eric7/Project/Project.py