eric: comparison src/eric7/Plugins/CheckerPlugins/SyntaxChecker/SyntaxCheckerDialog.py

-:ee1aadab1215
+:ff7d3d6b952d
 self.__timenow = time.monotonic()
 self.__fileList = []
 self.__project = None
 self.__arguments = ()
+self.__statistics = self.__defaultStatistics()
 self.filterFrame.setVisible(False)
 self.checkProgress.setVisible(False)
 try:
 """
 self.resultList.sortItems(
 self.resultList.sortColumn(), self.resultList.header().sortIndicatorOrder()
 )
+def __defaultStatistics(self):
+"""
+Private method to return the default statistics entry.
+@return dictionary with default statistics entry
+@rtype dict
+"""
+return {
+"files_checked": 0,
+"files_issues": 0,
+"errors": 0,
+"py_warnings": 0,
+"warnings": 0,
+}
+def __updateStatistics(self, fileStatistics):
+"""
+Private method to update the statistics.
+@param fileStatistics dictionary containing the file statistics
+@type dict
+"""
+self.__statistics["files_checked"] += 1
+if any(fileStatistics.values()):
+self.__statistics["files_issues"] += 1
+self.__statistics["errors"] += fileStatistics["errors"]
+self.__statistics["py_warnings"] += fileStatistics["py_warnings"]
+self.__statistics["warnings"] += fileStatistics["warnings"]
+def __resetStatistics(self, skipped):
+"""
+Private method to reset the statistics data.
+@param skipped number of files not being checked
+@type int
+"""
+self.__statistics["files_checked"] = 0
+self.__statistics["files_skipped"] = skipped
+self.__statistics["files_issues"] = 0
+self.__statistics["errors"] = 0
+self.__statistics["py_warnings"] = 0
+self.__statistics["warnings"] = 0
+def __createFileStatistics(self, problems):
+"""
+Private method to return the file statistics entry.
+@param problems dictionary with the keys 'error', 'py_warnings' and
+'warnings' which hold a list of issues each
+@type dict
+@return dictionary with the file statistics
+@rtype dict
+"""
+return {
+"errors": 1 if problems.get("error") else 0,
+"py_warnings": len(problems.get("py_warnings", [])),
+"warnings": len(problems.get("warnings", [])),
+}
 def __createErrorItem(self, filename, message):
 """
 Private slot to create a new error item in the result list.
 @param filename name of the file
 if not self.resultList.findItems(msg, Qt.MatchFlag.MatchExactly):
 itm = QTreeWidgetItem(self.__errorItem, [msg])
 itm.setForeground(0, Qt.GlobalColor.red)
 itm.setFirstColumnSpanned(True)
+def __createHeaderItem(self, filename, fileStatistics=None):
+"""
+Private method to create a header item in the result list.
+@param filename file name of file
+@type str
+@param fileStatistics dictionary containing statistical data of the check
+result (defaults to None)
+@type dict (optional)
+"""
+itemText = self.__project.getRelativePath(filename)
+if fileStatistics:
+statisticsTextList = []
+if fileStatistics["errors"]:
+statisticsTextList.append(
+self.tr("Errors: {0}").format(fileStatistics["errors"])
+)
+if fileStatistics["py_warnings"]:
+statisticsTextList.append(
+self.tr("Python Warnings: {0}").format(
+fileStatistics["py_warnings"]
+)
+)
+if fileStatistics["warnings"]:
+statisticsTextList.append(
+self.tr("Warnings: {0}").format(fileStatistics["warnings"])
+)
+if statisticsTextList:
+itemText += "{0}\n{1}".format(itemText, ", ".join(statisticsTextList))
+self.__lastFileItem = QTreeWidgetItem(self.resultList, [itemText])
+self.__lastFileItem.setFirstColumnSpanned(True)
+self.__lastFileItem.setExpanded(True)
+self.__lastFileItem.setData(0, self.filenameRole, filename)
 def __createResultItem(
 self, filename, line, index, error, sourcecode, isWarning=False
 ):
 """
 Private method to create an entry in the result list.
 if (
 self.__lastFileItem is None
 or self.__lastFileItem.data(0, self.filenameRole) != filename
 ):
 # It's a new file
-self.__lastFileItem = QTreeWidgetItem(
+self.__createHeaderItem(filename)
-self.resultList, [self.__project.getRelativePath(filename)]
-)
-self.__lastFileItem.setFirstColumnSpanned(True)
-self.__lastFileItem.setExpanded(True)
-self.__lastFileItem.setData(0, self.filenameRole, filename)
 itm = QTreeWidgetItem(self.__lastFileItem)
 if isWarning:
 itm.setIcon(0, EricPixmapCache.getIcon("warning"))
 else:
 self.excludeFilesEdit.setText(self.__data["ExcludeFiles"])
 self.builtinsEdit.setText(self.__data["AdditionalBuiltins"])
 self.on_startButton_clicked()  # press the start button
-def start(self, fn, codestring=""):
+def start(self, fn, codestring="", skipped=0):
 """
 Public slot to start the syntax check.
 @param fn file or list of files or directory to be checked
 @type str or list of str
 @param codestring string containing the code to be checked. If this is given,
 fn must be a single file name.
 @type str
+@param skipped number of files not being checked
+@type int
 """
 self.__batch = False
 if self.syntaxCheckService is not None:
 if self.__project is None:
 else:
 self.files = [fn]
 self.__errorItem = None
 self.__clearErrors(self.files)
+self.__resetStatistics(skipped)
 if codestring or len(self.files) > 0:
 self.checkProgress.setMaximum(max(1, len(self.files)))
 self.checkProgress.setVisible(len(self.files) > 1)
 QApplication.processEvents()
 """
 Private slot to display the reported messages.
 @param fn filename of the checked file
 @type str
-@param problems dictionary with the keys 'error' and 'warnings' which
+@param problems dictionary with the keys 'error', 'py_warnings' and
-hold a list containing details about the error/ warnings
+'warnings' which hold a list containing details about the error or
-(file name, line number, column, codestring (only at syntax
+warnings (file name, line number, column, codestring (only at syntax
-errors), the message)
+errors), message)
 @type dict
 """
 if self.__finished:
 return
 # Check if it's the requested file, otherwise ignore signal if not
 # in batch mode
 if not self.__batch and fn != self.filename:
 return
-error = problems.get("error")
+fileStatistics = self.__createFileStatistics(problems)
-if error:
+self.__updateStatistics(fileStatistics)
-self.noResults = False
+if any(fileStatistics.values()):
-_fn, lineno, col, code, msg = error
+self.__createHeaderItem(fn, fileStatistics)
-self.__createResultItem(_fn, lineno, col, msg, code, False)
+error = problems.get("error")
-warnings = problems.get("py_warnings", []) + problems.get("warnings", [])
+if error:
-if warnings:
-if self.__batch:
-try:
-source = Utilities.readEncodedFile(fn)[0]
-source = Utilities.normalizeCode(source)
-source = source.splitlines()
-except (OSError, UnicodeError):
-source = ""
-else:
-source = self.source.splitlines()
-for filename, lineno, col, _code, msg in warnings:
 self.noResults = False
-if source:
+filename, lineno, col, code, msg = error
+self.__createResultItem(filename, lineno, col, msg, code, False)
+warnings = problems.get("py_warnings", []) + problems.get("warnings", [])
+if warnings:
+if self.__batch:
 try:
-src_line = source[lineno - 1].strip()
+source = Utilities.readEncodedFile(fn)[0]
-except IndexError:
+source = Utilities.normalizeCode(source)
+source = source.splitlines()
+except (OSError, UnicodeError):
+source = ""
+else:
+source = self.source.splitlines()
+for filename, lineno, col, _code, msg in warnings:
+self.noResults = False
+if source:
+try:
+src_line = source[lineno - 1].strip()
+except IndexError:
+src_line = ""
+else:
 src_line = ""
-else:
+self.__createResultItem(filename, lineno, col, msg, src_line, True)
-src_line = ""
-self.__createResultItem(filename, lineno, col, msg, src_line, True)
 self.progress += 1
 self.checkProgress.setValue(self.progress)
 if time.monotonic() - self.__timenow > 0.01:
 QApplication.processEvents()
 self.__timenow = time.monotonic()
 self.__resort()
 if not self.__batch:
 self.check()
+def __updateStatisticsArea(self):
+"""
+Private method to update the statistics area of the dialog.
+"""
+self.totalLabel.setText(
+str(self.__statistics["files_skipped"] + self.__statistics["files_checked"])
+)
+self.skippedLabel.setText(str(self.__statistics["files_skipped"]))
+self.checkedLabel.setText(str(self.__statistics["files_checked"]))
+self.issuesLabel.setText(str(self.__statistics["files_issues"]))
+self.errorsLabel.setText(str(self.__statistics["errors"]))
+self.warningsLabel.setText(str(self.__statistics["warnings"]))
+self.pyWarningsLabel.setText(str(self.__statistics["py_warnings"]))
 def __finish(self):
 """
 Private slot called when the syntax check finished or the user
 pressed the button.
 self.showButton.setEnabled(True)
 self.resultList.header().resizeSections(
 QHeaderView.ResizeMode.ResizeToContents
 )
 self.resultList.header().setStretchLastSection(True)
+self.__updateStatisticsArea()
 self.checkProgress.setVisible(False)
 def __cancel(self):
 """
 def on_startButton_clicked(self):
 """
 Private slot to start a syntax check run.
 """
 fileList = self.__fileList[:]
+totalLen = len(fileList)
 filterString = self.excludeFilesEdit.text()
 self.__data["ExcludeFiles"] = filterString
 self.__data["AdditionalBuiltins"] = self.builtinsEdit.text().strip()
 if self.__data != self.__project.getData("CHECKERSPARMS", "SyntaxChecker"):
 self.resultList.clear()
 self.noResults = True
 self.cancelled = False
 self.setArguments((self.__data["AdditionalBuiltins"].split(),))
-self.start(fileList)
+self.start(fileList, skipped=totalLen - len(fileList))
 @pyqtSlot(QTreeWidgetItem, int)
 def on_resultList_itemActivated(self, itm, col):
 """
 Private slot to handle the activation of an item.

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Plugins/CheckerPlugins/SyntaxChecker/SyntaxCheckerDialog.py

src/eric7/Plugins/CheckerPlugins/SyntaxChecker/SyntaxCheckerDialog.py