Vulture Checker: comparison VultureChecker/VultureCheckerDialog.py

-:2194921f5e22
+:7925ae5c9f17
 from E5Gui.E5Application import e5App
 import Preferences
 import Utilities
-from .vulture import Item
+class VultureItem(object):
+"""
+Class to hold the name, type, confidence and location of defined code.
+"""
+def __init__(self, name, typ, filename, firstLineno, lastLineno,
+confidence):
+"""
+Constructor
+@param name item name
+@type str
+@param typ item type
+@type str
+@param filename name of the file containing item
+@type str
+@param firstLineno first line number
+@type int
+@param lastLineno last line number
+@type int
+@param confidence confidence level
+@type int
+"""
+self.name = name
+self.typ = typ
+self.filename = filename
+self.first_lineno = firstLineno
+self.last_lineno = lastLineno
+self.confidence = confidence
 class VultureCheckerDialog(QDialog, Ui_VultureCheckerDialog):
 """
 Class implementing a dialog to show the vulture check results.
 "function": self.tr("Function"),
 "slot": self.tr("Slot"),
 "attribute": self.tr("Attribute"),
 "variable": self.tr("Variable"),
 "class": self.tr("Class"),
+"import": self.tr("Import"),
 }
 def __createErrorItem(self, filename, message):
 """
 Private slot to create a new error item in the result list.
 "function": [],
 "slot": [],
 "attribute": [],
 "variable": [],
 "class": [],
+"import": [],
 "__patterns__": [
 "on_*",
 "visit_*",
 ],
 }
+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"])
 @param fn file or list of files or directory to show
 the code metrics for
 @type str or list of str
 """
+self.cancelled = False
 self.__errorItem = None
 self.resultList.clear()
-self.cancelled = False
 QApplication.processEvents()
 self.buttonBox.button(QDialogButtonBox.Close).setEnabled(False)
 self.buttonBox.button(QDialogButtonBox.Cancel).setEnabled(True)
 self.buttonBox.button(QDialogButtonBox.Cancel).setDefault(True)
 self.vultureCheck()
 else:
 self.__batch = True
 self.vultureCheckBatch()
-def vultureCheck(self, codestring=''):
+def vultureCheck(self):
 """
 Public method to start a vulture check for one Python file.
 The results are reported to the __processResult slot.
-@keyparam codestring optional sourcestring
-@type str
 """
 if not self.files:
 self.checkProgressLabel.setPath("")
 self.checkProgress.setMaximum(1)
 self.checkProgress.setValue(1)
 """
 self.__createErrorItem(fn, msg)
 def __processResult(self, fn, result):
 """
-Private slot called after perfoming a vulture analysis on one file.
+Private slot called after performing a vulture analysis on one file.
 @param fn filename of the file
 @type str
 @param result result dict
 @type dict
 if not self.__batch:
 self.vultureCheck()
 def __finish(self):
 """
-Private slot called when the action or the user pressed the button.
+Private slot called when the action finished or the user pressed the
+cancel button.
 """
 if not self.__finished:
 self.__finished = True
 if not self.cancelled:
 else:
 self.resultList.header().setResizeMode(QHeaderView.Interactive)
 self.checkProgress.setVisible(False)
 self.checkProgressLabel.setVisible(False)
+if self.resultList.topLevelItemCount() == 0:
+itm = QTreeWidgetItem(self.resultList,
+[self.tr("No unused code found.")])
+itm.setFirstColumnSpanned(True)
 @pyqtSlot(QAbstractButton)
 def on_buttonBox_clicked(self, button):
 """
 Private slot called by a button of the button box clicked.
 def __prepareResultLists(self):
 """
 Private method to prepare the result lists.
 """
 self.__definedAttrs = []
+self.__definedClasses = []
 self.__definedFuncs = []
+self.__definedImports = []
 self.__definedSlots = []
 self.__definedProps = []
 self.__definedVars = []
 self.__usedAttrs = []
-self.__usedVars = []
+self.__usedNames = []
-self.__tupleAssignVars = []
-self.__namesImportedAsAliases = []
 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.__dict2Item(d) for d in result["DefinedAttributes"]]))
+self.__definedClasses.extend(self.__filteredList(
+[self.__dict2Item(d) for d in result["DefinedClasses"]]))
 self.__definedFuncs.extend(self.__filteredList(
 [self.__dict2Item(d) for d in result["DefinedFunctions"]]))
+self.__definedImports.extend(self.__filteredList(
+[self.__dict2Item(d) for d in result["DefinedImports"]]))
 self.__definedSlots.extend(self.__filteredList(
 [self.__dict2Item(d) for d in result["DefinedSlots"]]))
 self.__definedProps.extend(self.__filteredList(
 [self.__dict2Item(d) for d in result["DefinedProperties"]]))
 self.__definedVars.extend(self.__filteredList(
 [self.__dict2Item(d) for d in result["DefinedVariables"]]))
-self.__usedAttrs.extend(
+self.__usedAttrs.extend(result["UsedAttributes"])
-[self.__dict2Item(d) for d in result["UsedAttributes"]])
+self.__usedNames.extend(result["UsedNames"])
-self.__usedVars.extend(
-[self.__dict2Item(d) for d in result["UsedVariables"]])
-self.__tupleAssignVars.extend(
-[self.__dict2Item(d) for d in result["TupleVariables"]])
-self.__namesImportedAsAliases.extend(
-[self.__dict2Item(d) for d in result["Aliases"]])
 def __dict2Item(self, d):
 """
 Private method to convert an item dictionary to a vulture item.
 @param d item dictionary
 @type dict
 @return vulture item
-@rtype vulture.Item
+@rtype VultureItem
 """
-return Item(d["name"], d["type"], d["file"], d["line"])
+return VultureItem(d["name"], d["type"], d["file"], d["first_line"],
+d["last_line"], confidence=d["confidence"])
 def __filteredList(self, itemList):
 """
 Private method to filter a list against the whitelist patterns
 returning items not matching the whitelist.
 @param itemList list of items to be filtered
-@type list of vulture.Item
+@type list of VultureItem
 @return list of filtered items
-@rtype list of vulture.Item
+@rtype list of VultureItem
 """
 filteredList = itemList
 for pattern in self.__data["WhiteLists"]["__patterns__"]:
 regExp = QRegExp(pattern, Qt.CaseSensitive, QRegExp.Wildcard)
-filteredList = [name for name in filteredList
+filteredList = [item for item in filteredList
-if not regExp.exactMatch(name)]
+if not regExp.exactMatch(item.name)]
 return filteredList
 def __getUnusedItems(self, defined, used):
 """
 Private method to get a list of unused items.
 @param defined list of defined items
-@type list of vulture.Item
+@type list of VultureItem
-@param used list of used items
+@param used list of used names
-@type list of vulture.Item
+@type list of str
 @return list of unused items
-@rtype list of vulture.Item
+@rtype list of VultureItem
 """
-return list(set(defined) - set(used))
+unusedItems = [item for item in set(defined)
+if item.name not in used]
+return unusedItems
 def __unusedFunctions(self):
 """
 Private method to get the list of unused functions.
 @return list of unused functions
-@rtype list of vulture.Item
+@rtype list of VultureItem
 """
 return self.__getUnusedItems(
 self.__definedFuncs,
-self.__usedAttrs + self.__usedVars +
+self.__usedAttrs + self.__usedNames +
-self.__namesImportedAsAliases +
+self.__data["WhiteLists"]["function"]
-self.__data["WhiteLists"]["function"] +
+)
-self.__data["WhiteLists"]["class"])
 def __unusedSlots(self):
 """
-Private method to get the list of unused PyQt slots.
+Private method to get the list of unused PyQt/PySide slots.
-@return list of unused PyQt slots
+@return list of unused PyQt/PySide slots
-@rtype list of vulture.Item
+@rtype list of VultureItem
 """
 return self.__getUnusedItems(
 self.__definedSlots,
-self.__usedAttrs + self.__usedVars +
+self.__usedAttrs + self.__usedNames +
-self.__namesImportedAsAliases +
+self.__data["WhiteLists"]["slot"]
-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(
+self.__definedClasses,
+self.__usedAttrs + self.__usedNames +
+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(
+self.__definedClasses,
+self.__usedAttrs + self.__usedNames +
+self.__data["WhiteLists"]["import"]
+)
 def __unusedProperties(self):
 """
 Private method to get the list of unused properties.
 @return list of unused properties
-@rtype list of vulture.Item
+@rtype list of VultureItem
 """
 return self.__getUnusedItems(
 self.__definedProps,
-self.__usedAttrs + self.__data["WhiteLists"]["property"])
+self.__usedAttrs +
+self.__data["WhiteLists"]["property"]
+)
 def __unusedVariables(self):
 """
 Private method to get the list of unused variables.
 @return list of unused variables
-@rtype list of vulture.Item
+@rtype list of VultureItem
 """
 return self.__getUnusedItems(
 self.__definedVars,
-self.__usedAttrs + self.__usedVars + self.__tupleAssignVars +
+self.__usedAttrs + self.__usedNames +
-self.__namesImportedAsAliases +
+self.__data["WhiteLists"]["variable"]
-self.__data["WhiteLists"]["variable"])
+)
 def __unusedAttributes(self):
 """
 Private method to get the list of unused attributes.
 @return list of unused attributes
-@rtype list of vulture.Item
+@rtype list of VultureItem
 """
 return self.__getUnusedItems(
 self.__definedAttrs,
-self.__usedAttrs + self.__usedVars +
+self.__usedAttrs +
-self.__data["WhiteLists"]["attribute"])
+self.__data["WhiteLists"]["attribute"]
+)
 def __createResultItems(self):
 """
 Private method to populate the list with the analysis result.
 """         # __IGNORE_WARNING__
 return item.filename
 lastFileItem = None
 lastFileName = ""
 items = (self.__unusedFunctions() +
+self.__unusedClasses() +
+self.__unusedImports() +
 self.__unusedProperties() +
 self.__unusedVariables() +
 self.__unusedAttributes())
 if not self.__slotsAreUsed:
 items += self.__unusedSlots()
 Private method to create a result item.
 @param parent reference to the parent item
 @type QTreeWidgetItem
 @param item reference to the item
-@type vulture.Item
+@type VultureItem
 """
 try:
 translatedType = self.__translatedTypes[item.typ]
 except KeyError:
 translatedType = item.typ
 itm = QTreeWidgetItem(parent, [
-"{0:6d}".format(item.lineno), str(item), translatedType])
+"{0:6d}".format(item.first_lineno), item.name,
+"{0:3d}%".format(item.confidence), translatedType])
 itm.setData(0, self.FilePathRole, item.filename)
 itm.setData(0, self.TypeRole, item.typ)
-itm.setTextAlignment(0, Qt.Alignment(Qt.AlignRight))
+itm.setTextAlignment(0, Qt.Alignment(Qt.AlignRight))    # line no
+itm.setTextAlignment(2, Qt.Alignment(Qt.AlignRight))    # confidence
 def __createFileItem(self, filename):
 """
 Private method to create a file item.

Mercurial Repositories > Vulture Checker / file comparison

comparison: VultureChecker/VultureCheckerDialog.py

VultureChecker/VultureCheckerDialog.py