eric: comparison src/eric7/Plugins/PluginCodeStyleChecker.py

-:e9e7eca7efee
+:bf71ee032bb4
 class CodeStyleCheckerPlugin(QObject):
 """
 Class implementing the code style checker plug-in.
 @signal styleChecked(str, dict, int, list) emitted when the style check was
 done for a file.
 @signal batchFinished() emitted when a style check batch is done
 @signal error(str, str) emitted in case of an error
 """
 styleChecked = pyqtSignal(str, dict, int, list)
 batchFinished = pyqtSignal()
 error = pyqtSignal(str, str)
 def __init__(self, ui):
 """
 Constructor
 @param ui reference to the user interface object (UI.UserInterface)
 """
 super().__init__(ui)
 self.__ui = ui
 self.__initialize()
 self.backgroundService = ericApp().getObject("BackgroundService")
 path = os.path.join(
-os.path.dirname(__file__), 'CheckerPlugins', 'CodeStyleChecker')
+os.path.dirname(__file__), "CheckerPlugins", "CodeStyleChecker"
+)
 self.backgroundService.serviceConnect(
-'style', 'Python3', path, 'CodeStyleChecker',
+"style",
+"Python3",
+path,
+"CodeStyleChecker",
 self.__translateStyleCheck,
 onErrorCallback=self.serviceErrorPy3,
-onBatchDone=self.batchJobDone)
+onBatchDone=self.batchJobDone,
+)
 self.queuedBatches = []
 self.batchesFinished = True
 self.__wrapper = textwrap.TextWrapper(width=80)
 def __serviceError(self, fn, msg):
 """
 Private slot handling service errors.
 @param fn file name (string)
 @param msg message text (string)
 """
 self.error.emit(fn, msg)
 def serviceErrorPy3(self, fx, lang, fn, msg):
 """
 Public slot handling service errors for Python 3.
 @param fx service name (string)
 @param lang language (string)
 @param fn file name (string)
 @param msg message text (string)
 """
-if fx in ['style', 'batch_style'] and lang == 'Python3':
+if fx in ["style", "batch_style"] and lang == "Python3":
-if fx == 'style':
+if fx == "style":
 self.__serviceError(fn, msg)
 else:
 self.__serviceError(self.tr("Python 3 batch check"), msg)
 self.batchJobDone(fx, lang)
 def batchJobDone(self, fx, lang):
 """
 Public slot handling the completion of a batch job.
 @param fx service name (string)
 @param lang language (string)
 """
-if fx in ['style', 'batch_style']:
+if fx in ["style", "batch_style"]:
 if lang in self.queuedBatches:
 self.queuedBatches.remove(lang)
 # prevent sending the signal multiple times
 if len(self.queuedBatches) == 0 and not self.batchesFinished:
 self.batchFinished.emit()
 self.batchesFinished = True
 def __initialize(self):
 """
 Private slot to (re)initialize the plugin.
 """
 self.__projectAct = None
 self.__projectCodeStyleCheckerDialog = None
 self.__projectBrowserAct = None
 self.__projectBrowserMenu = None
 self.__projectBrowserCodeStyleCheckerDialog = None
 self.__editors = []
 self.__editorAct = None
 self.__editorCodeStyleCheckerDialog = None
 def styleCheck(self, lang, filename, source, args):
 encoding, backup)
 @type list of (str, str, bool, str, str, bool, int, list of (int, int),
 bool, str, dict, dict, list of str, str, str, bool)
 """
 if lang is None:
-lang = 'Python{0}'.format(determinePythonVersion(filename, source))
+lang = "Python{0}".format(determinePythonVersion(filename, source))
-if lang != 'Python3':
+if lang != "Python3":
 return
 data = [source, args]
-self.backgroundService.enqueueRequest('style', lang, filename, data)
+self.backgroundService.enqueueRequest("style", lang, filename, data)
 def styleBatchCheck(self, argumentsList):
 """
 Public method to prepare a style check on multiple Python source files.
 @param argumentsList list of arguments tuples with each tuple
 containing filename, source and args as given in styleCheck()
 method
 @type list of tuple of (str, str, list)
 """
 data = {
 "Python3": [],
 }
 for filename, source, args in argumentsList:
-lang = 'Python{0}'.format(determinePythonVersion(filename, source))
+lang = "Python{0}".format(determinePythonVersion(filename, source))
-if lang != 'Python3':
+if lang != "Python3":
 continue
 else:
 data[lang].append((filename, source, args))
 self.queuedBatches = []
-if data['Python3']:
+if data["Python3"]:
-self.queuedBatches.append('Python3')
+self.queuedBatches.append("Python3")
-self.backgroundService.enqueueRequest('batch_style', 'Python3', "",
+self.backgroundService.enqueueRequest(
-data['Python3'])
+"batch_style", "Python3", "", data["Python3"]
+)
 self.batchesFinished = False
 def cancelStyleBatchCheck(self):
 """
 Public method to cancel all batch jobs.
 """
-self.backgroundService.requestCancel('batch_style', 'Python3')
+self.backgroundService.requestCancel("batch_style", "Python3")
 def __translateStyleCheck(self, fn, codeStyleCheckerStats, results):
 """
 Private slot called after performing a style check on one file.
 @param fn filename of the just checked file
 @type str
 @param codeStyleCheckerStats stats of style and name check
 @type dict
 @param results dictionary containing the check result data
 (see CodesStyleChecker.__checkCodeStyle for details)
 @type dict
 """
-from CheckerPlugins.CodeStyleChecker.translations import (
+from CheckerPlugins.CodeStyleChecker.translations import getTranslatedMessage
-getTranslatedMessage
-)
 fixes = 0
 for result in results:
 msg = getTranslatedMessage(result["code"], result["args"])
 if result["fixcode"]:
 fixes += 1
-trFixedMsg = getTranslatedMessage(result["fixcode"],
+trFixedMsg = getTranslatedMessage(result["fixcode"], result["fixargs"])
-result["fixargs"])
 msg += "\n" + QCoreApplication.translate(
-'CodeStyleCheckerDialog', "Fix: {0}").format(trFixedMsg)
+"CodeStyleCheckerDialog", "Fix: {0}"
+).format(trFixedMsg)
 result["display"] = "\n".join(self.__wrapper.wrap(msg))
 self.styleChecked.emit(fn, codeStyleCheckerStats, fixes, results)
 def activate(self):
 """
 Public method to activate this plugin.
 @return tuple of None and activation status (boolean)
 """
 menu = ericApp().getObject("Project").getMenu("Checks")
 if menu:
 self.__projectAct = EricAction(
-self.tr('Check Code Style'),
+self.tr("Check Code Style"),
-self.tr('&Code Style...'), 0, 0,
+self.tr("&Code Style..."),
-self, 'project_check_pep8')
+0,
-self.__projectAct.setStatusTip(
+0,
-self.tr('Check code style.'))
+self,
-self.__projectAct.setWhatsThis(self.tr(
+"project_check_pep8",
+)
+self.__projectAct.setStatusTip(self.tr("Check code style."))
+self.__projectAct.setWhatsThis(
+self.tr(
+"""<b>Check Code Style...</b>"""
+"""<p>This checks Python files for compliance to the"""
+""" code style conventions given in various PEPs.</p>"""
+)
+)
+self.__projectAct.triggered.connect(self.__projectCodeStyleCheck)
+ericApp().getObject("Project").addEricActions([self.__projectAct])
+menu.addAction(self.__projectAct)
+self.__editorAct = EricAction(
+self.tr("Check Code Style"), self.tr("&Code Style..."), 0, 0, self, ""
+)
+self.__editorAct.setWhatsThis(
+self.tr(
 """<b>Check Code Style...</b>"""
 """<p>This checks Python files for compliance to the"""
 """ code style conventions given in various PEPs.</p>"""
-))
+)
-self.__projectAct.triggered.connect(
+)
-self.__projectCodeStyleCheck)
-ericApp().getObject("Project").addEricActions([self.__projectAct])
-menu.addAction(self.__projectAct)
-self.__editorAct = EricAction(
-self.tr('Check Code Style'),
-self.tr('&Code Style...'), 0, 0,
-self, "")
-self.__editorAct.setWhatsThis(self.tr(
-"""<b>Check Code Style...</b>"""
-"""<p>This checks Python files for compliance to the"""
-""" code style conventions given in various PEPs.</p>"""
-))
 self.__editorAct.triggered.connect(self.__editorCodeStyleCheck)
 ericApp().getObject("Project").showMenu.connect(self.__projectShowMenu)
 ericApp().getObject("ProjectBrowser").getProjectBrowser(
-"sources").showMenu.connect(self.__projectBrowserShowMenu)
+"sources"
-ericApp().getObject("ViewManager").editorOpenedEd.connect(
+).showMenu.connect(self.__projectBrowserShowMenu)
-self.__editorOpened)
+ericApp().getObject("ViewManager").editorOpenedEd.connect(self.__editorOpened)
-ericApp().getObject("ViewManager").editorClosedEd.connect(
+ericApp().getObject("ViewManager").editorClosedEd.connect(self.__editorClosed)
-self.__editorClosed)
 for editor in ericApp().getObject("ViewManager").getOpenEditors():
 self.__editorOpened(editor)
 return None, True
 def deactivate(self):
 """
 Public method to deactivate this plugin.
 """
-ericApp().getObject("Project").showMenu.disconnect(
+ericApp().getObject("Project").showMenu.disconnect(self.__projectShowMenu)
-self.__projectShowMenu)
 ericApp().getObject("ProjectBrowser").getProjectBrowser(
-"sources").showMenu.disconnect(self.__projectBrowserShowMenu)
+"sources"
+).showMenu.disconnect(self.__projectBrowserShowMenu)
 ericApp().getObject("ViewManager").editorOpenedEd.disconnect(
-self.__editorOpened)
+self.__editorOpened
+)
 ericApp().getObject("ViewManager").editorClosedEd.disconnect(
-self.__editorClosed)
+self.__editorClosed
+)
 menu = ericApp().getObject("Project").getMenu("Checks")
 if menu:
 menu.removeAction(self.__projectAct)
 if self.__projectBrowserMenu and self.__projectBrowserAct:
-self.__projectBrowserMenu.removeAction(
+self.__projectBrowserMenu.removeAction(self.__projectBrowserAct)
-self.__projectBrowserAct)
 for editor in self.__editors:
 editor.showMenu.disconnect(self.__editorShowMenu)
 menu = editor.getMenu("Checks")
 if menu is not None:
 menu.removeAction(self.__editorAct)
 self.__initialize()
 def __projectShowMenu(self, menuName, menu):
 """
 Private slot called, when the the project menu or a submenu is
 about to be shown.
 @param menuName name of the menu to be shown (string)
 @param menu reference to the menu (QMenu)
 """
 if menuName == "Checks" and self.__projectAct is not None:
 self.__projectAct.setEnabled(
-ericApp().getObject("Project").getProjectLanguage() in
+ericApp().getObject("Project").getProjectLanguage()
-["Python3", "MicroPython"])
+in ["Python3", "MicroPython"]
+)
 def __projectBrowserShowMenu(self, menuName, menu):
 """
 Private slot called, when the the project browser menu or a submenu is
 about to be shown.
 @param menuName name of the menu to be shown (string)
 @param menu reference to the menu (QMenu)
 """
-if (
+if menuName == "Checks" and ericApp().getObject(
-menuName == "Checks" and
+"Project"
-ericApp().getObject("Project").getProjectLanguage() in
+).getProjectLanguage() in ["Python3", "MicroPython"]:
-["Python3", "MicroPython"]
-):
 self.__projectBrowserMenu = menu
 if self.__projectBrowserAct is None:
 self.__projectBrowserAct = EricAction(
-self.tr('Check Code Style'),
+self.tr("Check Code Style"),
-self.tr('&Code Style...'), 0, 0,
+self.tr("&Code Style..."),
-self, "")
+0,
-self.__projectBrowserAct.setWhatsThis(self.tr(
+0,
-"""<b>Check Code Style...</b>"""
+self,
-"""<p>This checks Python files for compliance to the"""
+"",
-""" code style conventions given in various PEPs.</p>"""
+)
-))
+self.__projectBrowserAct.setWhatsThis(
+self.tr(
+"""<b>Check Code Style...</b>"""
+"""<p>This checks Python files for compliance to the"""
+""" code style conventions given in various PEPs.</p>"""
+)
+)
 self.__projectBrowserAct.triggered.connect(
-self.__projectBrowserCodeStyleCheck)
+self.__projectBrowserCodeStyleCheck
+)
 if self.__projectBrowserAct not in menu.actions():
 menu.addAction(self.__projectBrowserAct)
 def __projectCodeStyleCheck(self):
 """
 Private slot used to check the project files for code style.
 """
 project = ericApp().getObject("Project")
 project.saveAllScripts()
 ppath = project.getProjectPath()
-files = [os.path.join(ppath, file)
+files = [
-for file in project.pdata["SOURCES"]
+os.path.join(ppath, file)
-if file.endswith(
+for file in project.pdata["SOURCES"]
-tuple(Preferences.getPython("Python3Extensions")))]
+if file.endswith(tuple(Preferences.getPython("Python3Extensions")))
+]
 from CheckerPlugins.CodeStyleChecker import CodeStyleCheckerDialog
 self.__projectCodeStyleCheckerDialog = (
 CodeStyleCheckerDialog.CodeStyleCheckerDialog(self)
 )
 self.__projectCodeStyleCheckerDialog.show()
 self.__projectCodeStyleCheckerDialog.prepare(files, project)
 def __projectBrowserCodeStyleCheck(self):
 """
 Private method to handle the code style check context menu action of
 the project sources browser.
 """
-browser = (
+browser = ericApp().getObject("ProjectBrowser").getProjectBrowser("sources")
-ericApp().getObject("ProjectBrowser").getProjectBrowser("sources")
-)
 if browser.getSelectedItemsCount([ProjectBrowserFileItem]) > 1:
 fn = []
 for itm in browser.getSelectedItems([ProjectBrowserFileItem]):
 fn.append(itm.fileName())
 isDir = False
 fn = itm.fileName()
 isDir = False
 except AttributeError:
 fn = itm.dirName()
 isDir = True
 from CheckerPlugins.CodeStyleChecker import CodeStyleCheckerDialog
 self.__projectBrowserCodeStyleCheckerDialog = (
 CodeStyleCheckerDialog.CodeStyleCheckerDialog(self)
 )
 self.__projectBrowserCodeStyleCheckerDialog.show()
 if isDir:
-self.__projectBrowserCodeStyleCheckerDialog.start(
+self.__projectBrowserCodeStyleCheckerDialog.start(fn, save=True)
-fn, save=True)
 else:
 self.__projectBrowserCodeStyleCheckerDialog.start(
-fn, save=True, repeat=True)
+fn, save=True, repeat=True
+)
 def __editorOpened(self, editor):
 """
 Private slot called, when a new editor was opened.
 @param editor reference to the new editor (QScintilla.Editor)
 """
 menu = editor.getMenu("Checks")
 if menu is not None:
 menu.addAction(self.__editorAct)
 editor.showMenu.connect(self.__editorShowMenu)
 self.__editors.append(editor)
 def __editorClosed(self, editor):
 """
 Private slot called, when an editor was closed.
 @param editor reference to the editor (QScintilla.Editor)
 """
 with contextlib.suppress(ValueError):
 self.__editors.remove(editor)
 def __editorShowMenu(self, menuName, menu, editor):
 """
 Private slot called, when the the editor context menu or a submenu is
 about to be shown.
 @param menuName name of the menu to be shown (string)
 @param menu reference to the menu (QMenu)
 @param editor reference to the editor
 """
 if menuName == "Checks":
 if self.__editorAct not in menu.actions():
 menu.addAction(self.__editorAct)
 self.__editorAct.setEnabled(editor.isPyFile())
 def __editorCodeStyleCheck(self):
 """
 Private slot to handle the code style check context menu action
 of the editors.
 """
 editor = ericApp().getObject("ViewManager").activeWindow()
 if (
-editor is not None and
+editor is not None
-editor.checkDirty() and
+and editor.checkDirty()
-editor.getFileName() is not None
+and editor.getFileName() is not None
 ):
-from CheckerPlugins.CodeStyleChecker import (
+from CheckerPlugins.CodeStyleChecker import CodeStyleCheckerDialog
-CodeStyleCheckerDialog
-)
 self.__editorCodeStyleCheckerDialog = (
 CodeStyleCheckerDialog.CodeStyleCheckerDialog(self)
 )
 self.__editorCodeStyleCheckerDialog.show()
 self.__editorCodeStyleCheckerDialog.start(
-editor.getFileName(),
+editor.getFileName(), save=True, repeat=True
-save=True,
+)
-repeat=True)

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Plugins/PluginCodeStyleChecker.py

src/eric7/Plugins/PluginCodeStyleChecker.py