Vulture Checker: comparison VultureChecker/VultureCheckerDialog.py

-:d7a6b7ea640d
+:3c2922b45a9f
 Module implementing a dialog to show the vulture check results.
 """
 import os
 import fnmatch
+import contextlib
 from PyQt5.QtCore import pyqtSlot, qVersion, Qt, QTimer, QRegExp
 from PyQt5.QtWidgets import (
 QDialog, QDialogButtonBox, QAbstractButton, QHeaderView, QTreeWidgetItem,
 QApplication, QMenu
 import Preferences
 import Utilities
-class VultureItem(object):
+class VultureItem:
 """
 Class to hold the name, type, confidence and location of defined code.
 """
 def __init__(self, name, typ, filename, firstLineno, lastLineno,
 confidence):
 @param vultureService reference to the service
 @type VulturePlugin
 @param parent reference to the parent widget
 @type QWidget
 """
-super(VultureCheckerDialog, self).__init__(parent)
+super().__init__(parent)
 self.setupUi(self)
 self.setWindowFlags(Qt.Window)
 self.buttonBox.button(QDialogButtonBox.Close).setEnabled(False)
 self.buttonBox.button(QDialogButtonBox.Cancel).setDefault(True)
 self.filterFrame.setVisible(False)
 self.__translatedTypes = {
 "property": self.tr("Property"),
 "function": self.tr("Function"),
-"slot": self.tr("Slot"),
+"method": self.tr("Methode"),
 "attribute": self.tr("Attribute"),
 "variable": self.tr("Variable"),
 "class": self.tr("Class"),
 "import": self.tr("Import"),
 }
 self.__data["ExcludeFiles"] = ""
 if "WhiteLists" not in self.__data:
 self.__data["WhiteLists"] = {
 "property": [],
 "function": [],
-"slot": [],
 "attribute": [],
 "variable": [],
 "class": [],
 "import": [],
 "__patterns__": [
 "on_*",
 "visit_*",
 ],
 }
+if "method" not in self.__data["WhiteLists"]:
+self.__data["WhiteLists"]["method"] = []
 if "import" not in self.__data["WhiteLists"]:
 self.__data["WhiteLists"]["import"] = []
-if "SlotsAreUsed" not in self.__data:
-self.__data["SlotsAreUsed"] = True
 self.excludeFilesEdit.setText(self.__data["ExcludeFiles"])
-self.slotsCheckBox.setChecked(self.__data["SlotsAreUsed"])
 def start(self, fn):
 """
 Public slot to start the code metrics determination.
 Public method to start a vulture check batch job.
 The results are reported to the __processResult slot.
 """
 self.checkProgressLabel.setPath(self.tr("Preparing files..."))
-progress = 0
 argumentsList = []
-for filename in self.files:
+for progress, filename in enumerate(self.files, start=1):
-progress += 1
 self.checkProgress.setValue(progress)
 QApplication.processEvents()
 try:
 source = Utilities.readEncodedFile(filename)[0]
 if filterList:
 for fileFilter in filterList:
 fileList = [f for f in fileList
 if not fnmatch.fnmatch(f, fileFilter)]
-self.__slotsAreUsed = self.slotsCheckBox.isChecked()
-if self.__slotsAreUsed != self.__data["SlotsAreUsed"]:
-self.__data["SlotsAreUsed"] = self.__slotsAreUsed
-self.__project.setData(
-"CHECKERSPARMS", "Vulture", self.__data)
 self.start(fileList)
 def clear(self):
 """
 Public method to clear all results.
 def __prepareResultLists(self):
 """
 Private method to prepare the result lists.
 """
-self.__definedAttrs = []
+self.__unusedAttrs = []
-self.__definedClasses = []
+self.__unusedClasses = []
-self.__definedFuncs = []
+self.__unusedFuncs = []
-self.__definedImports = []
+self.__unusedMethods = []
-self.__definedSlots = []
+self.__unusedImports = []
-self.__definedProps = []
+self.__unusedProps = []
-self.__definedVars = []
+self.__unusedVars = []
-self.__usedAttrs = []
-self.__usedNames = []
 def __storeResult(self, result):
 """
 Private method to store the result of an analysis.
 @param result result dictionary
 @type dict
 """
-self.__definedAttrs.extend(self.__filteredList(
+self.__unusedAttrs.extend(self.__filteredList(
-[self.__dict2Item(d) for d in result["DefinedAttributes"]]))
+[self.__dict2Item(d) for d in result["UnusedAttributes"]]))
-self.__definedClasses.extend(self.__filteredList(
+self.__unusedClasses.extend(self.__filteredList(
-[self.__dict2Item(d) for d in result["DefinedClasses"]]))
+[self.__dict2Item(d) for d in result["UnusedClasses"]]))
-self.__definedFuncs.extend(self.__filteredList(
+self.__unusedFuncs.extend(self.__filteredList(
-[self.__dict2Item(d) for d in result["DefinedFunctions"]]))
+[self.__dict2Item(d) for d in result["UnusedFunctions"]]))
-self.__definedImports.extend(self.__filteredList(
+self.__unusedMethods.extend(self.__filteredList(
-[self.__dict2Item(d) for d in result["DefinedImports"]]))
+[self.__dict2Item(d) for d in result["UnusedMethods"]]))
-self.__definedSlots.extend(self.__filteredList(
+self.__unusedImports.extend(self.__filteredList(
-[self.__dict2Item(d) for d in result["DefinedSlots"]]))
+[self.__dict2Item(d) for d in result["UnusedImports"]]))
-self.__definedProps.extend(self.__filteredList(
+self.__unusedProps.extend(self.__filteredList(
-[self.__dict2Item(d) for d in result["DefinedProperties"]]))
+[self.__dict2Item(d) for d in result["UnusedProperties"]]))
-self.__definedVars.extend(self.__filteredList(
+self.__unusedVars.extend(self.__filteredList(
-[self.__dict2Item(d) for d in result["DefinedVariables"]]))
+[self.__dict2Item(d) for d in result["UnusedVariables"]]))
-self.__usedAttrs.extend(result["UsedAttributes"])
-self.__usedNames.extend(result["UsedNames"])
 def __dict2Item(self, d):
 """
 Private method to convert an item dictionary to a vulture item.
 regExp = QRegExp(pattern, Qt.CaseSensitive, QRegExp.Wildcard)
 filteredList = [item for item in filteredList
 if not regExp.exactMatch(item.name)]
 return filteredList     # __IGNORE_WARNING_M834__
-def __getUnusedItems(self, defined, used):
+def __filterUnusedItems(self, unused, whitelistName):
 """
 Private method to get a list of unused items.
-@param defined list of defined items
+@param unused list of unused items
 @type list of VultureItem
-@param used list of used names
+@param whitelistName name of the whitelist to use as a filter
-@type list of str
+@type str
 @return list of unused items
 @rtype list of VultureItem
 """
-return [item for item in set(defined) if item.name not in used]
+return [
+item for item in set(unused)
-def __unusedFunctions(self):
+if item.name not in self.__data["WhiteLists"][whitelistName]
+]
+def __filterUnusedFunctions(self):
 """
 Private method to get the list of unused functions.
 @return list of unused functions
 @rtype list of VultureItem
 """
-return self.__getUnusedItems(
+return self.__filterUnusedItems(self.__unusedFuncs, "function")
-self.__definedFuncs,
-self.__usedAttrs + self.__usedNames +
+def __filterUnusedMethods(self):
-self.__data["WhiteLists"]["function"]
+"""
-)
+Private method to get the list of unused methods.
-def __unusedSlots(self):
+@return list of unused methods
-"""
+@rtype list of VultureItem
-Private method to get the list of unused PyQt/PySide slots.
+"""
+return self.__filterUnusedItems(self.__unusedMethods, "method")
-@return list of unused PyQt/PySide slots
-@rtype list of VultureItem
+def __filterUnusedClasses(self):
-"""
-return self.__getUnusedItems(
-self.__definedSlots,
-self.__usedAttrs + self.__usedNames +
-self.__data["WhiteLists"]["slot"]
-)
-def __unusedClasses(self):
 """
 Private method to get the list of unused classes.
 @return list of unused classes
 @rtype list of VultureItem
 """
-return self.__getUnusedItems(
+return self.__filterUnusedItems(self.__unusedClasses, "class")
-self.__definedClasses,
-self.__usedAttrs + self.__usedNames +
+def __filterUnusedImports(self):
-self.__data["WhiteLists"]["class"]
-)
-def __unusedImports(self):
 """
 Private method to get a list of unused imports.
 @return list of unused imports
 @rtype list of VultureItem
 """
-return self.__getUnusedItems(
+return self.__filterUnusedItems(self.__unusedImports, "import")
-self.__definedClasses,
-self.__usedAttrs + self.__usedNames +
+def __filterUnusedProperties(self):
-self.__data["WhiteLists"]["import"]
-)
-def __unusedProperties(self):
 """
 Private method to get the list of unused properties.
 @return list of unused properties
 @rtype list of VultureItem
 """
-return self.__getUnusedItems(
+return self.__filterUnusedItems(self.__unusedProps, "property")
-self.__definedProps,
-self.__usedAttrs +
+def __filterUnusedVariables(self):
-self.__data["WhiteLists"]["property"]
-)
-def __unusedVariables(self):
 """
 Private method to get the list of unused variables.
 @return list of unused variables
 @rtype list of VultureItem
 """
-return self.__getUnusedItems(
+return self.__filterUnusedItems(self.__unusedVars, "variable")
-self.__definedVars,
-self.__usedAttrs + self.__usedNames +
+def __filterUnusedAttributes(self):
-self.__data["WhiteLists"]["variable"]
-)
-def __unusedAttributes(self):
 """
 Private method to get the list of unused attributes.
 @return list of unused attributes
 @rtype list of VultureItem
 """
-return self.__getUnusedItems(
+return self.__filterUnusedItems(self.__unusedAttrs, "attribute")
-self.__definedAttrs,
-self.__usedAttrs +
-self.__data["WhiteLists"]["attribute"]
-)
 def __createResultItems(self):
 """
 Private method to populate the list with the analysis result.
 """
 lastFileItem = None
 lastFileName = ""
-items = (self.__unusedFunctions() +
+items = (self.__filterUnusedFunctions() +
-self.__unusedClasses() +
+self.__filterUnusedMethods() +
-self.__unusedImports() +
+self.__filterUnusedClasses() +
-self.__unusedProperties() +
+self.__filterUnusedImports() +
-self.__unusedVariables() +
+self.__filterUnusedProperties() +
-self.__unusedAttributes())
+self.__filterUnusedVariables() +
-if not self.__slotsAreUsed:
+self.__filterUnusedAttributes())
-items += self.__unusedSlots()
 for item in sorted(items, key=lambda item: item.filename):
 if lastFileItem is None or lastFileName != item.filename:
 lastFileItem = self.__createFileItem(item.filename)
 lastFileName = item.filename
 """
 whitelists = {}
 for key in self.__data["WhiteLists"]:
 whitelists[key] = self.__data["WhiteLists"][key][:]
 for itm in self.__getSelectedNonFileItems():
-try:
+with contextlib.suppress(KeyError):
 whitelists[itm.data(0, self.TypeRole)].append(itm.text(1))
-except KeyError:
-# ignore non-existing types
-pass
 # remove the item from the result list
 pitm = itm.parent()
 pitm.removeChild(itm)
 del itm
 if pitm.childCount() == 0:
 @type dict of list of str
 """
 changed = False
 for key in whitelists:
 whitelist = list(set(whitelists[key]))
-try:
+with contextlib.suppress(KeyError):
 if sorted(whitelist) != sorted(self.__data["WhiteLists"][key]):
 self.__data["WhiteLists"][key] = whitelist[:]
 changed = True
-except KeyError:
-# ignore non-existing types
-pass
 if changed:
 self.__project.setData("CHECKERSPARMS", "Vulture", self.__data)

Mercurial Repositories > Vulture Checker / file comparison

comparison: VultureChecker/VultureCheckerDialog.py

VultureChecker/VultureCheckerDialog.py