eric: comparison eric6/Plugins/CheckerPlugins/CodeStyleChecker/CodeStyleCheckerDialog.py

-:a3a4760b59ec
+:d5aff4fd0ef8
 import os
 import fnmatch
-from PyQt5.QtCore import pyqtSlot, Qt, QTimer
+from PyQt5.QtCore import pyqtSlot, Qt, QTimer, QCoreApplication
 from PyQt5.QtGui import QIcon
 from PyQt5.QtWidgets import (
 QDialog, QTreeWidgetItem, QAbstractButton, QDialogButtonBox, QApplication,
 QHeaderView, QListWidgetItem
 )
 availableFutures = [
 'division', 'absolute_import', 'with_statement',
 'print_function', 'unicode_literals', 'generator_stop',
 'annotations']
+checkCategories = {
+"A": QCoreApplication.translate(
+"CheckerCategories",
+"Annotations"),
+"C": QCoreApplication.translate(
+"CheckerCategories",
+"Code Complexity"),
+"D": QCoreApplication.translate(
+"CheckerCategories",
+"Documentation"),
+"E": QCoreApplication.translate(
+"CheckerCategories",
+"Errors"),
+"M": QCoreApplication.translate(
+"CheckerCategories",
+"Miscellaneous"),
+"N": QCoreApplication.translate(
+"CheckerCategories",
+"Naming"),
+"W": QCoreApplication.translate(
+"CheckerCategories",
+"Warnings"),
+}
 noResults = 0
 noFiles = 1
 hasResults = 2
 def __init__(self, styleCheckService, parent=None):
 """
 Constructor
 @param styleCheckService reference to the service
-(CodeStyleCheckService)
+@type CodeStyleCheckService
-@param parent reference to the parent widget (QWidget)
+@param parent reference to the parent widget
+@type QWidget
 """
 super(CodeStyleCheckerDialog, self).__init__(parent)
 self.setupUi(self)
 self.setWindowFlags(Qt.Window)
 self.noFixIssuesSelectButton.setIcon(
 UI.PixmapCache.getIcon("select"))
 self.docTypeComboBox.addItem(self.tr("PEP-257"), "pep257")
 self.docTypeComboBox.addItem(self.tr("Eric"), "eric")
+for category, text in CodeStyleCheckerDialog.checkCategories.items():
+itm = QListWidgetItem(text, self.categoriesList)
+itm.setData(Qt.UserRole, category)
+itm.setFlags(itm.flags() | Qt.ItemIsUserCheckable)
+itm.setCheckState(Qt.Unchecked)
 for future in CodeStyleCheckerDialog.availableFutures:
 itm = QListWidgetItem(future, self.futuresList)
 itm.setFlags(itm.flags() | Qt.ItemIsUserCheckable)
 itm.setCheckState(Qt.Unchecked)
 def __createResultItem(self, filename, line, pos, message, fixed,
 autofixing, ignored):
 """
 Private method to create an entry in the result list.
-@param filename file name of the file (string)
+@param filename file name of the file
-@param line line number of issue (integer or string)
+@type str
-@param pos character position of issue (integer or string)
+@param line line number of issue
-@param message message text (string)
+@type int or str
-@param fixed flag indicating a fixed issue (boolean)
+@param pos character position of issue
+@type int or str
+@param message message text
+@type str
+@param fixed flag indicating a fixed issue
+@type bool
 @param autofixing flag indicating, that we are fixing issues
-automatically (boolean)
+automatically
-@param ignored flag indicating an ignored issue (boolean)
+@type bool
-@return reference to the created item (QTreeWidgetItem)
+@param ignored flag indicating an ignored issue
+@type bool
+@return reference to the created item
+@rtype QTreeWidgetItem
 """
 from .CodeStyleFixer import FixableCodeStyleIssues
 if self.__lastFileItem is None:
 # It's a new file
 itm = QTreeWidgetItem(
 self.__lastFileItem,
 ["{0:6}".format(line), code, message])
 if code.startswith(("W", "-", "C", "M")):
 itm.setIcon(1, UI.PixmapCache.getIcon("warning"))
-elif code.startswith("N"):
+elif code.startswith(("A", "N")):
 itm.setIcon(1, UI.PixmapCache.getIcon("namingError"))
 elif code.startswith("D"):
 itm.setIcon(1, UI.PixmapCache.getIcon("docstringError"))
 else:
 itm.setIcon(1, UI.PixmapCache.getIcon("syntaxError"))
 def __modifyFixedResultItem(self, itm, text, fixed):
 """
 Private method to modify a result list entry to show its
 positive fixed state.
-@param itm reference to the item to modify (QTreeWidgetItem)
+@param itm reference to the item to modify
-@param text text to be appended (string)
+@type QTreeWidgetItem
-@param fixed flag indicating a fixed issue (boolean)
+@param text text to be appended
+@type str
+@param fixed flag indicating a fixed issue
+@type bool
 """
 if fixed:
 code, message = text.split(None, 1)
 itm.setText(2, message)
 itm.setIcon(0, UI.PixmapCache.getIcon("issueFixed"))
 """
 Private method to update the collected statistics.
 @param statistics dictionary of statistical data with
 message code as key and message count as value
-@param fixer reference to the code style fixer (CodeStyleFixer)
+@type dict
-@param ignoredErrors number of ignored errors (integer)
+@param fixer reference to the code style fixer
+@type CodeStyleFixer
+@param ignoredErrors number of ignored errors
+@type int
 """
 self.__statistics["_FilesCount"] += 1
 stats = [k for k in statistics.keys() if k[0].isupper()]
 if stats:
 self.__statistics["_FilesIssues"] += 1
 def __updateFixerStatistics(self, fixer):
 """
 Private method to update the collected fixer related statistics.
-@param fixer reference to the code style fixer (CodeStyleFixer)
+@param fixer reference to the code style fixer
+@type CodeStyleFixer
 """
 self.__statistics["_IssuesFixed"] += fixer
 def __resetStatistics(self):
 """
 def prepare(self, fileList, project):
 """
 Public method to prepare the dialog with a list of filenames.
-@param fileList list of filenames (list of strings)
+@param fileList list of filenames
-@param project reference to the project object (Project)
+@type list of str
+@param project reference to the project object
+@type Project
 """
 self.__fileOrFileList = fileList[:]
 self.__project = project
 self.__forProject = True
 "IncludeMessages": "",
 "RepeatMessages": False,
 "FixCodes": "",
 "FixIssues": False,
 }
+if "EnabledCheckerCategories" not in self.__data:
+self.__data["EnabledCheckerCategories"] = ",".join(
+CodeStyleCheckerDialog.checkCategories.keys())
 if "MaxLineLength" not in self.__data:
 self.__data["MaxLineLength"] = pycodestyle.MAX_LINE_LENGTH
 if "MaxDocLineLength" not in self.__data:
 # Use MAX_LINE_LENGTH to avoid messages on existing code
 self.__data["MaxDocLineLength"] = pycodestyle.MAX_LINE_LENGTH
 self.__data["AnnotationsChecker"] = {
 "MinimumCoverage": 75,
 "MaximumComplexity": 3,
 }
+self.__initCategoriesList(self.__data["EnabledCheckerCategories"])
 self.excludeFilesEdit.setText(self.__data["ExcludeFiles"])
 self.excludeMessagesEdit.setText(self.__data["ExcludeMessages"])
 self.includeMessagesEdit.setText(self.__data["IncludeMessages"])
 self.repeatCheckBox.setChecked(self.__data["RepeatMessages"])
 self.fixIssuesEdit.setText(self.__data["FixCodes"])
 self.__data["CommentedCodeChecker"]["Aggressive"])
 self.minAnnotationsCoverageSpinBox.setValue(
 self.__data["AnnotationsChecker"]["MinimumCoverage"])
 self.maxAnnotationsComplexitySpinBox.setValue(
 self.__data["AnnotationsChecker"]["MaximumComplexity"])
+self.__cleanupData()
 def start(self, fn, save=False, repeat=None):
 """
 Public slot to start the code style check.
 @param fn file or list of files or directory to be checked
-(string or list of strings)
+@type str or list of str
-@keyparam save flag indicating to save the given
+@param save flag indicating to save the given file/file list/directory
-file/file list/directory (boolean)
+@type bool
-@keyparam repeat state of the repeat check box if it is not None
+@param repeat state of the repeat check box if it is not None
-(None or boolean)
+@type None or bool
 """
 if self.__project is None:
 self.__project = e5App().getObject("Project")
 self.mainWidget.setCurrentWidget(self.runTab)
 ]
 self.__errorItem = None
 self.__resetStatistics()
 self.__clearErrors(self.files)
+self.__cleanupData()
 if len(self.files) > 0:
 self.checkProgress.setMaximum(len(self.files))
 self.checkProgressLabel.setVisible(len(self.files) > 1)
 self.checkProgress.setVisible(len(self.files) > 1)
 QApplication.processEvents()
 # extract the configuration values
-excludeMessages = self.excludeMessagesEdit.text()
+excludeMessages = self.__assembleExcludeMessages()
 includeMessages = self.includeMessagesEdit.text()
 repeatMessages = self.repeatCheckBox.isChecked()
 fixCodes = self.fixIssuesEdit.text()
 noFixCodes = self.noFixIssuesEdit.text()
 self.__noFixCodesList = [
 This method looks for comment lines like '# eflag: noqa = M601'
 at the end of the source in order to extend the list of excluded
 messages for one file only.
-@param source source text (list of str or str)
+@param source source text
+@type list of str or str
 @return list of checker options
+@rtype list
 """
 options = self.__options[:]
 flags = Utilities.extractFlags(source)
 if "noqa" in flags and isinstance(flags["noqa"], basestring):
 excludeMessages = options[0].strip().rstrip(",")
 """
 Public method to start a style check for one file.
 The results are reported to the __processResult slot.
-@keyparam codestring optional sourcestring (str)
+@param codestring optional sourcestring
+@type str
 """
 if not self.files:
 self.checkProgressLabel.setPath("")
 self.checkProgress.setMaximum(1)
 self.checkProgress.setValue(1)
 def __processResult(self, fn, codeStyleCheckerStats, fixes, results):
 """
 Private slot called after perfoming a style check on one file.
-@param fn filename of the just checked file (str)
+@param fn filename of the just checked file
-@param codeStyleCheckerStats stats of style and name check (dict)
+@type str
-@param fixes number of applied fixes (int)
+@param codeStyleCheckerStats stats of style and name check
+@type dict
+@param fixes number of applied fixes
+@type int
 @param results tuple for each found violation of style (tuple of
-lineno (int), position (int), text (str), ignored (bool),
+lineno, position, text, ignored, fixed, autofixing)
-fixed (bool), autofixing (bool))
+@type tuplt of tuple of (int, int, str, bool, bool, bool)
 """
 if self.__finished:
 return
 # Check if it's the requested file, otherwise ignore signal if not
 def __getEol(self, fn):
 """
 Private method to get the applicable eol string.
-@param fn filename where to determine the line ending (str)
+@param fn filename where to determine the line ending
-@return eol string (string)
+@type str
+@return eol string
+@rtype str
 """
 if self.__project.isOpen() and self.__project.isProjectFile(fn):
 eol = self.__project.getEolString()
 else:
 eol = Utilities.linesep()
 @pyqtSlot()
 def on_startButton_clicked(self):
 """
 Private slot to start a code style check run.
 """
+self.__cleanupData()
 if self.__forProject:
 data = {
+"EnabledCheckerCategories": self.__getCategories(True),
 "ExcludeFiles": self.excludeFilesEdit.text(),
 "ExcludeMessages": self.excludeMessagesEdit.text(),
 "IncludeMessages": self.includeMessagesEdit.text(),
 "RepeatMessages": self.repeatCheckBox.isChecked(),
 "FixCodes": self.fixIssuesEdit.text(),
 """
 Private slot to restart a code style check run.
 """
 self.on_startButton_clicked()
-def __selectCodes(self, edit, showFixCodes):
+def __selectCodes(self, edit, categories, showFixCodes):
 """
 Private method to select message codes via a selection dialog.
-@param edit reference of the line edit to be populated (QLineEdit)
+@param edit reference of the line edit to be populated
+@type QLineEdit
+@param categories list of message categories to omit
+@type list of str
 @param showFixCodes flag indicating to show a list of fixable
-issues (boolean)
+issues
+@type bool
 """
 from .CodeStyleCodeSelectionDialog import CodeStyleCodeSelectionDialog
-dlg = CodeStyleCodeSelectionDialog(edit.text(), showFixCodes, self)
+dlg = CodeStyleCodeSelectionDialog(edit.text(), categories,
+showFixCodes, self)
 if dlg.exec_() == QDialog.Accepted:
 edit.setText(dlg.getSelectedCodes())
 @pyqtSlot()
 def on_excludeMessagesSelectButton_clicked(self):
 """
 Private slot to select the message codes to be excluded via a
 selection dialog.
 """
-self.__selectCodes(self.excludeMessagesEdit, False)
+self.__selectCodes(self.excludeMessagesEdit,
+self.__getCategories(False, asList=True),
+False)
 @pyqtSlot()
 def on_includeMessagesSelectButton_clicked(self):
 """
 Private slot to select the message codes to be included via a
 selection dialog.
 """
-self.__selectCodes(self.includeMessagesEdit, False)
+self.__selectCodes(self.includeMessagesEdit,
+self.__getCategories(True, asList=True),
+False)
 @pyqtSlot()
 def on_fixIssuesSelectButton_clicked(self):
 """
 Private slot to select the issue codes to be fixed via a
 selection dialog.
 """
-self.__selectCodes(self.fixIssuesEdit, True)
+self.__selectCodes(self.fixIssuesEdit, [], True)
 @pyqtSlot()
 def on_noFixIssuesSelectButton_clicked(self):
 """
 Private slot to select the issue codes not to be fixed via a
 selection dialog.
 """
-self.__selectCodes(self.noFixIssuesEdit, True)
+self.__selectCodes(self.noFixIssuesEdit, [], True)
 @pyqtSlot(QTreeWidgetItem, int)
 def on_resultList_itemActivated(self, item, column):
 """
 Private slot to handle the activation of an item.
-@param item reference to the activated item (QTreeWidgetItem)
+@param item reference to the activated item
-@param column column the item was activated in (integer)
+@type QTreeWidgetItem
+@param column column the item was activated in
+@type int
 """
 if self.results != CodeStyleCheckerDialog.hasResults:
 return
 if item.parent():
 @pyqtSlot()
 def on_loadDefaultButton_clicked(self):
 """
 Private slot to load the default configuration values.
 """
+self.__initCategoriesList(Preferences.Prefs.settings.value(
+"PEP8/EnabledCheckerCategories",
+",".join(CodeStyleCheckerDialog.checkCategories.keys())))
 self.excludeFilesEdit.setText(Preferences.Prefs.settings.value(
 "PEP8/ExcludeFilePatterns", ""))
 self.excludeMessagesEdit.setText(Preferences.Prefs.settings.value(
 "PEP8/ExcludeMessages", pycodestyle.DEFAULT_IGNORE))
 self.includeMessagesEdit.setText(Preferences.Prefs.settings.value(
 Preferences.Prefs.settings.value(
 "PEP8/MinimumAnnotationsCoverage", 75)))
 self.maxAnnotationsComplexitySpinBox.setValue(int(
 Preferences.Prefs.settings.value(
 "PEP8/MaximumAnnotationComplexity", 3)))
+self.__cleanupData()
 @pyqtSlot()
 def on_storeDefaultButton_clicked(self):
 """
 Private slot to store the current configuration values as
 default values.
 """
 Preferences.Prefs.settings.setValue(
+"PEP8/EnabledCheckerCategories", self.__getCategories(True))
+Preferences.Prefs.settings.setValue(
 "PEP8/ExcludeFilePatterns", self.excludeFilesEdit.text())
 Preferences.Prefs.settings.setValue(
 "PEP8/ExcludeMessages", self.excludeMessagesEdit.text())
 Preferences.Prefs.settings.setValue(
 "PEP8/IncludeMessages", self.includeMessagesEdit.text())
 @pyqtSlot()
 def on_resetDefaultButton_clicked(self):
 """
 Private slot to reset the configuration values to their default values.
 """
+Preferences.Prefs.settings.setValue(
+"PEP8/EnabledCheckerCategories",
+",".join(CodeStyleCheckerDialog.checkCategories.keys()))
 Preferences.Prefs.settings.setValue("PEP8/ExcludeFilePatterns", "")
 Preferences.Prefs.settings.setValue(
 "PEP8/ExcludeMessages", pycodestyle.DEFAULT_IGNORE)
 Preferences.Prefs.settings.setValue("PEP8/IncludeMessages", "")
 Preferences.Prefs.settings.setValue("PEP8/RepeatMessages", False)
 @pyqtSlot(QAbstractButton)
 def on_buttonBox_clicked(self, button):
 """
 Private slot called by a button of the button box clicked.
-@param button button that was clicked (QAbstractButton)
+@param button button that was clicked
+@type QAbstractButton
 """
 if button == self.buttonBox.button(QDialogButtonBox.Close):
 self.close()
 elif button == self.buttonBox.button(QDialogButtonBox.Cancel):
 if self.__batch:
 def __clearErrors(self, files):
 """
 Private method to clear all warning markers of open editors to be
 checked.
-@param files list of files to be checked (list of string)
+@param files list of files to be checked
+@type list of str
 """
 vm = e5App().getObject("ViewManager")
 openFiles = vm.getOpenFilenames()
 for file in [f for f in openFiles if f in files]:
 editor = vm.getOpenEditor(file)
 def on_fixButton_clicked(self):
 """
 Private slot to fix selected issues.
 Build a dictionary of issues to fix. Update the initialized __options.
 Then call check with the dict as keyparam to fix selected issues.
 """
 fixableItems = self.__getSelectedFixableItems()
 # dictionary of lists of tuples containing the issue and the item
 fixesDict = {}
 for itm in fixableItems:
 def __getSelectedFixableItems(self):
 """
 Private method to extract all selected items for fixable issues.
-@return selected items for fixable issues (list of QTreeWidgetItem)
+@return selected items for fixable issues
+@rtype list of QTreeWidgetItem
 """
 fixableItems = []
 for itm in self.resultList.selectedItems():
 if itm.childCount() > 0:
 for index in range(itm.childCount()):
 def __itemFixable(self, itm):
 """
 Private method to check, if an item has a fixable issue.
-@param itm item to be checked (QTreeWidgetItem)
+@param itm item to be checked
-@return flag indicating a fixable issue (boolean)
+@type QTreeWidgetItem
+@return flag indicating a fixable issue
+@rtype bool
 """
 return (itm.data(0, self.fixableRole) and
 not itm.data(0, self.ignoredRole))
 def __initFuturesList(self, selectedFutures):
 """
 for itm in self.builtinsAssignmentList.selectedItems():
 index = self.builtinsAssignmentList.indexOfTopLevelItem(itm)
 self.builtinsAssignmentList.takeTopLevelItem(index)
 del itm
+def __initCategoriesList(self, enabledCategories):
+"""
+Private method to set the enabled status of the checker categories.
+@param enabledCategories comma separated list of enabled checker
+categories
+@type str
+"""
+if enabledCategories:
+enabledCategoriesList = [
+c.strip() for c in enabledCategories.split(",")
+if bool(c.strip())]
+else:
+enabledCategoriesList = list(
+CodeStyleCheckerDialog.checkCategories.keys())
+for row in range(self.categoriesList.count()):
+itm = self.categoriesList.item(row)
+if itm.data(Qt.UserRole) in enabledCategoriesList:
+itm.setCheckState(Qt.Checked)
+else:
+itm.setCheckState(Qt.Unchecked)
+def __getCategories(self, enabled, asList=False):
+"""
+Private method to get the enabled or disabled checker categories.
+@param enabled flag indicating to return enabled categories
+@type bool
+@param asList flag indicating to return the checker categories as a
+Python list
+@type bool
+@return checker categories as a list or comma separated string
+@rtype str or list of str
+"""
+state = Qt.Checked if enabled else Qt.Unchecked
+checkerList = []
+for row in range(self.categoriesList.count()):
+itm = self.categoriesList.item(row)
+if itm.checkState() == state:
+checkerList.append(itm.data(Qt.UserRole))
+if asList:
+return checkerList
+else:
+return ", ".join(checkerList)
+def __assembleExcludeMessages(self):
+"""
+Private method to assemble the list of excluded checks.
+@return list of excluded checks as a comma separated string.
+@rtype str
+"""
+excludeMessages = self.excludeMessagesEdit.text()
+disabledCategories = self.__getCategories(False)
+if excludeMessages and disabledCategories:
+return disabledCategories + "," + excludeMessages
+elif disabledCategories:
+return disabledCategories
+elif excludeMessages:
+return excludeMessages
+else:
+return ""
+def __cleanupData(self):
+"""
+Private method to clean the loaded/entered data of redundant entries.
+"""
+# Migrate single letter exclude messages to disabled checker categories
+# and delete them from exlude messages
+excludedMessages = [
+m.strip()
+for m in self.excludeMessagesEdit.text().split(",")
+if bool(m)
+]
+excludedMessageCategories = [
+c for c in excludedMessages if len(c) == 1
+]
+enabledCheckers = self.__getCategories(True, asList=True)
+for category in excludedMessageCategories:
+if category in enabledCheckers:
+enabledCheckers.remove(category)
+excludedMessages.remove(category)
+# Remove excluded messages of an already excluded category
+disabledCheckers = self.__getCategories(False, asList=True)
+for message in excludedMessages[:]:
+if message[0] in disabledCheckers:
+excludedMessages.remove(message)
+self.excludeMessagesEdit.setText(",".join(excludedMessages))
+self.__initCategoriesList(",".join(enabledCheckers))

Mercurial Repositories > eric / file comparison

comparison: eric6/Plugins/CheckerPlugins/CodeStyleChecker/CodeStyleCheckerDialog.py

eric6/Plugins/CheckerPlugins/CodeStyleChecker/CodeStyleCheckerDialog.py