eric: comparison Project/Project.py

-:175b36822cc9
+:2c193da9b94f
 "TRANSLATIONSBINPATH": "",
 "MAINSCRIPT": "",
 "VCS": "None",
 "VCSOPTIONS": {},
 "VCSOTHERDATA": {},
-# TODO: change these to use lists only where neccessary
+"AUTHOR": '',
-"AUTHOR": [''],
+"EMAIL": '',
-"EMAIL": [''],
+"HASH": '',
-"HASH": [''],
+"PROGLANGUAGE": "Python3",
-"PROGLANGUAGE": ["Python3"],
+"MIXEDLANGUAGE": False,
-"MIXEDLANGUAGE": [False],
+"PROJECTTYPE": "PyQt5",
-"PROJECTTYPE": ["PyQt5"],
 "SPELLLANGUAGE":
-[Preferences.getEditor("SpellCheckingDefaultLanguage")],
+Preferences.getEditor("SpellCheckingDefaultLanguage"),
 "SPELLWORDS": '',
 "SPELLEXCLUDES": '',
 "FILETYPES": {},
 "LEXERASSOCS": {},
 "PROJECTTYPESPECIFICDATA": {},
 """
 Public method to initialize the filetype associations with default
 values.
 """
 self.pdata["FILETYPES"] = {}
-if self.pdata["MIXEDLANGUAGE"][0]:
+if self.pdata["MIXEDLANGUAGE"]:
 sourceKey = "Mixed"
 else:
-sourceKey = self.pdata["PROGLANGUAGE"][0]
+sourceKey = self.pdata["PROGLANGUAGE"]
 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",
+if self.pdata["PROJECTTYPE"] in ["Qt4", "PyQt5",
 "E6Plugin", "PySide"]:
 self.pdata["FILETYPES"]["*.ui"] = "FORMS"
-if self.pdata["PROJECTTYPE"][0] in ["Qt4", "Qt4C",
+if self.pdata["PROJECTTYPE"] in ["Qt4", "Qt4C",
 "E6Plugin",
 "PyQt5", "PyQt5C",
 "PySide", "PySideC"]:
 self.pdata["FILETYPES"]["*.qrc"] = "RESOURCES"
-if self.pdata["PROJECTTYPE"][0] in ["Qt4", "Qt4C",
+if self.pdata["PROJECTTYPE"] 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:
+self.pdata["PROJECTTYPE"]] is not None:
 ftypes = \
-self.__fileTypeCallbacks[self.pdata["PROJECTTYPE"][0]]()
+self.__fileTypeCallbacks[self.pdata["PROJECTTYPE"]]()
 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",
+if self.pdata["PROJECTTYPE"] 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:
+self.pdata["PROJECTTYPE"]] is not None:
 ftypes = \
-self.__fileTypeCallbacks[self.pdata["PROJECTTYPE"][0]]()
+self.__fileTypeCallbacks[self.pdata["PROJECTTYPE"]]()
 for pattern, ftype in list(ftypes.items()):
 if pattern not in self.pdata["FILETYPES"]:
 self.pdata["FILETYPES"][pattern] = ftype
 self.setDirty(True)
 except KeyError:
 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]:
+if reader.version.startswith("5.") and not self.pdata["HASH"]:
 hash = str(QCryptographicHash.hash(
 QByteArray(self.ppath.encode("utf-8")),
 QCryptographicHash.Sha1).toHex(),
 encoding="utf-8")
-self.pdata["HASH"] = [hash]
+self.pdata["HASH"] = hash
 self.setDirty(True)
 return res
 def __writeProject(self, fn=None):
 self.pdata["VCSOPTIONS"] = \
 copy.deepcopy(self.vcs.vcsGetOptions())
 self.pdata["VCSOTHERDATA"] = \
 copy.deepcopy(self.vcs.vcsGetOtherData())
-if not self.pdata["HASH"][0]:
+if not self.pdata["HASH"]:
 hash = str(QCryptographicHash.hash(
 QByteArray(self.ppath.encode("utf-8")),
 QCryptographicHash.Sha1).toHex(),
 encoding="utf-8")
-self.pdata["HASH"] = [hash]
+self.pdata["HASH"] = hash
 if fn is None:
 fn = self.pfile
 f = QFile(fn)
 from .AddLanguageDialog import AddLanguageDialog
 dlg = AddLanguageDialog(self.parent())
 if dlg.exec_() == QDialog.Accepted:
 lang = dlg.getSelectedLanguage()
-if self.pdata["PROJECTTYPE"][0] in \
+if self.pdata["PROJECTTYPE"] in \
 ["Qt4", "Qt4C", "PyQt5", "PyQt5C", "E6Plugin",
 "PySide", "PySideC"]:
 langFile = self.pdata["TRANSLATIONPATTERN"]\
 .replace("%language%", lang)
 self.appendFile(langFile)
 @return name of the binary translations file (string)
 """
 qmFile = ""
 try:
 if self.__binaryTranslationsCallbacks[
-self.pdata["PROJECTTYPE"][0]] is not None:
+self.pdata["PROJECTTYPE"]] is not None:
 qmFile = self.__binaryTranslationsCallbacks[
-self.pdata["PROJECTTYPE"][0]](langFile)
+self.pdata["PROJECTTYPE"]](langFile)
 except KeyError:
 qmFile = langFile.replace('.ts', '.qm')
 if qmFile == langFile:
 qmFile = ""
 return qmFile
 self.menuShowAct.setEnabled(True)
 self.menuDiagramAct.setEnabled(True)
 self.menuApidocAct.setEnabled(True)
 self.menuPackagersAct.setEnabled(True)
 self.pluginGrp.setEnabled(
-self.pdata["PROJECTTYPE"][0] in ["E6Plugin"])
+self.pdata["PROJECTTYPE"] in ["E6Plugin"])
 self.addLanguageAct.setEnabled(
 bool(self.pdata["TRANSLATIONPATTERN"]))
 self.projectAboutToBeCreated.emit()
 hash = str(QCryptographicHash.hash(
 QByteArray(self.ppath.encode("utf-8")),
 QCryptographicHash.Sha1).toHex(),
 encoding="utf-8")
-self.pdata["HASH"] = [hash]
+self.pdata["HASH"] = hash
 # create the project directory if it doesn't exist already
 if not os.path.isdir(self.ppath):
 try:
 os.makedirs(self.ppath)
 .format(self.ppath))
 self.vcs = self.initVCS()
 return
 # create an empty __init__.py file to make it a Python package
 # (only for Python and Python3)
-if self.pdata["PROGLANGUAGE"][0] in \
+if self.pdata["PROGLANGUAGE"] in \
 ["Python", "Python2", "Python3"]:
 fn = os.path.join(self.ppath, "__init__.py")
 f = open(fn, "w", encoding="utf-8")
 f.close()
 self.appendFile(fn, True)
 yesDefault=True)
 if res:
 self.newProjectAddFiles(ms)
 # create an empty __init__.py file to make it a Python package
 # if none exists (only for Python and Python3)
-if self.pdata["PROGLANGUAGE"][0] in \
+if self.pdata["PROGLANGUAGE"] in \
 ["Python", "Python2", "Python3"]:
 fn = os.path.join(self.ppath, "__init__.py")
 if not os.path.exists(fn):
 f = open(fn, "w", encoding="utf-8")
 f.close()
 qmlist = Utilities.direntries(tpd, True, pattern)
 for qm in qmlist:
 self.pdata["TRANSLATIONS"].append(qm)
 self.projectLanguageAdded.emit(qm)
 if not self.pdata["MAINSCRIPT"]:
-if self.pdata["PROGLANGUAGE"][0] in \
+if self.pdata["PROGLANGUAGE"] in \
 ["Python", "Python2", "Python3"]:
 self.pdata["MAINSCRIPT"] = '{0}.py'.format(mainscriptname)
-elif self.pdata["PROGLANGUAGE"][0] == "Ruby":
+elif self.pdata["PROGLANGUAGE"] == "Ruby":
 self.pdata["MAINSCRIPT"] = '{0}.rb'.format(mainscriptname)
 self.setDirty(True)
 QApplication.restoreOverrideCursor()
 def __showProperties(self):
 Private slot to display the properties dialog.
 """
 from .PropertiesDialog import PropertiesDialog
 dlg = PropertiesDialog(self, False)
 if dlg.exec_() == QDialog.Accepted:
-projectType = self.pdata["PROJECTTYPE"][0]
+projectType = self.pdata["PROJECTTYPE"]
 dlg.storeData()
 self.setDirty(True)
 try:
 ms = os.path.join(self.ppath, self.pdata["MAINSCRIPT"])
 if os.path.exists(ms):
 self.appendFile(ms)
 except IndexError:
 pass
-if self.pdata["PROJECTTYPE"][0] != projectType:
+if self.pdata["PROJECTTYPE"] != projectType:
 # reinitialize filetype associations
 self.initFileTypes()
 if self.translationsRoot:
 tp = os.path.join(self.ppath, self.translationsRoot)
 os.makedirs(tp)
 if tp != self.ppath and tp not in self.subdirs:
 self.subdirs.append(tp)
 self.pluginGrp.setEnabled(
-self.pdata["PROJECTTYPE"][0] in ["E6Plugin"])
+self.pdata["PROJECTTYPE"] in ["E6Plugin"])
 self.__model.projectPropertiesChanged()
 self.projectPropertiesChanged.emit()
-if self.pdata["PROJECTTYPE"][0] != projectType:
+if self.pdata["PROJECTTYPE"] != projectType:
 self.__reorganizeFiles()
 def __showUserProperties(self):
 """
 Private slot to display the user specific properties dialog.
 for pattern, language in list(self.pdata["LEXERASSOCS"].items()):
 if fnmatch.fnmatch(filename, pattern):
 return language
 # try project type specific defaults next
-projectType = self.pdata["PROJECTTYPE"][0]
+projectType = self.pdata["PROJECTTYPE"]
 try:
 if self.__lexerAssociationCallbacks[projectType] is not None:
 return self.__lexerAssociationCallbacks[projectType](filename)
 except KeyError:
 pass
 self.menuShowAct.setEnabled(True)
 self.menuDiagramAct.setEnabled(True)
 self.menuApidocAct.setEnabled(True)
 self.menuPackagersAct.setEnabled(True)
 self.pluginGrp.setEnabled(
-self.pdata["PROJECTTYPE"][0] in [
+self.pdata["PROJECTTYPE"] in ["E6Plugin"])
-"E6Plugin"])
 self.addLanguageAct.setEnabled(
 bool(self.pdata["TRANSLATIONPATTERN"]))
 self.__model.projectOpened()
 self.projectOpenedHooks.emit()
 """
 Public method to get the type of the project.
 @return UI type of the project (string)
 """
-return self.pdata["PROJECTTYPE"][0]
+return self.pdata["PROJECTTYPE"]
 def getProjectLanguage(self):
 """
 Public method to get the project's programming language.
 @return programming language (string)
 """
-return self.pdata["PROGLANGUAGE"][0]
+return self.pdata["PROGLANGUAGE"]
+def isMixedLanguageProject(self):
+"""
+Public method to check, if this is a mixed language project.
+@return flag indicating a mixed language project
+@rtype bool
+"""
+return self.pdata("MIXEDLANGUAGE")
 def isPythonProject(self):
 """
 Public method to check, if this project is a Python2 or Python3
 project.
 @return flag indicating a Python project (boolean)
 """
-return self.pdata["PROGLANGUAGE"][0] in ["Python", "Python2",
+return self.pdata["PROGLANGUAGE"] in ["Python", "Python2",
 "Python3"]
 def isPy3Project(self):
 """
 Public method to check, if this project is a Python3 project.
 @return flag indicating a Python3 project (boolean)
 """
-return self.pdata["PROGLANGUAGE"][0] == "Python3"
+return self.pdata["PROGLANGUAGE"] == "Python3"
 def isPy2Project(self):
 """
 Public method to check, if this project is a Python2 project.
 @return flag indicating a Python2 project (boolean)
 """
-return self.pdata["PROGLANGUAGE"][0] in ["Python", "Python2"]
+return self.pdata["PROGLANGUAGE"] in ["Python", "Python2"]
 def isRubyProject(self):
 """
 Public method to check, if this project is a Ruby project.
 @return flag indicating a Ruby project (boolean)
 """
-return self.pdata["PROGLANGUAGE"][0] == "Ruby"
+return self.pdata["PROGLANGUAGE"] == "Ruby"
 def isJavaScriptProject(self):
 """
 Public method to check, if this project is a JavaScript project.
 @return flag indicating a JavaScript project (boolean)
 """
-return self.pdata["PROGLANGUAGE"][0] == "JavaScript"
+return self.pdata["PROGLANGUAGE"] == "JavaScript"
 def getProjectSpellLanguage(self):
 """
 Public method to get the project's programming language.
 @return programming language (string)
 """
-return self.pdata["SPELLLANGUAGE"][0]
+return self.pdata["SPELLLANGUAGE"]
 def getProjectDictionaries(self):
 """
 Public method to get the names of the project specific dictionaries.
 Public method to get the default extension for the project's
 programming language.
 @return default extension (including the dot) (string)
 """
-if self.pdata["PROGLANGUAGE"]:
+lang = self.pdata["PROGLANGUAGE"]
-lang = self.pdata["PROGLANGUAGE"][0]
+if lang == "":
-if lang == "":
+lang = "Python3"
-lang = "Python3"
+elif lang == "Python":
-elif lang == "Python":
+lang = "Python2"
-lang = "Python2"
+return self.__sourceExtensions(lang)[0]
-return self.__sourceExtensions(lang)[0]
-else:
-return ""
 def getProjectPath(self):
 """
 Public method to get the project path.
 """
 Public method to get the project hash.
 @return project hash as a hex string (string)
 """
-return self.pdata["HASH"][0]
+return self.pdata["HASH"]
 def getRelativePath(self, path):
 """
 Public method to convert a file path to a project relative
 file path.

Mercurial Repositories > eric / file comparison

comparison: Project/Project.py

Project/Project.py