eric: comparison eric7/DataViews/PyCoverageDialog.py

-:938039ea15ca
+:eab09a1ab8ce
 import contextlib
 import os
 import time
-from PyQt6.QtCore import pyqtSlot, Qt
+from PyQt6.QtCore import pyqtSignal, pyqtSlot, Qt
 from PyQt6.QtWidgets import (
 QDialog, QDialogButtonBox, QMenu, QHeaderView, QTreeWidgetItem,
 QApplication
 )
 class PyCoverageDialog(QDialog, Ui_PyCoverageDialog):
 """
 Class implementing a dialog to display the collected code coverage data.
+@signal openFile(str) emitted to open the given file in an editor
 """
+openFile = pyqtSignal(str)
 def __init__(self, parent=None):
 """
 Constructor
-@param parent parent widget (QWidget)
+@param parent parent widget
+@type QWidget
 """
 super().__init__(parent)
 self.setupUi(self)
 self.setWindowFlags(Qt.WindowType.Window)
 """
 Private method to format a list of integers into string by coalescing
 groups.
 @param lines list of integers
+@type list of int
 @return string representing the list
+@rtype str
 """
 pairs = []
 lines.sort()
 maxValue = lines[-1]
 start = None
 """
 Private helper function to generate a string representation of a
 pair.
 @param pair pair of integers
+@type tuple of (int, int
+@return representation of the pair
+@rtype str
 """
 start, end = pair
 if start == end:
 return "{0:d}".format(start)
 else:
 def __createResultItem(self, file, statements, executed, coverage,
 excluded, missing):
 """
 Private method to create an entry in the result list.
-@param file filename of file (string)
+@param file filename of file
-@param statements amount of statements (integer)
+@type str
-@param executed amount of executed statements (integer)
+@param statements number of statements
-@param coverage percent of coverage (integer)
+@type int
-@param excluded list of excluded lines (string)
+@param executed number of executed statements
-@param missing list of lines without coverage (string)
+@type int
+@param coverage percent of coverage
+@type int
+@param excluded list of excluded lines
+@type str
+@param missing list of lines without coverage
+@type str
 """
 itm = QTreeWidgetItem(self.resultList, [
 file,
 str(statements),
 str(executed),
 if statements != executed:
 font = itm.font(0)
 font.setBold(True)
 for col in range(itm.columnCount()):
 itm.setFont(col, font)
 def start(self, cfn, fn):
 """
 Public slot to start the coverage data evaluation.
-@param cfn basename of the coverage file (string)
+@param cfn basename of the coverage file
+@type str
 @param fn file or list of files or directory to be checked
-(string or list of strings)
+@type str or list of str
 """
 self.__cfn = cfn
 self.__fn = fn
 self.basename = os.path.splitext(cfn)[0]
 self.tr("""%n file(s) could not be parsed. Coverage"""
 """ info for these is not available.""", "",
 total_exceptions))
 self.__finish()
 def __finish(self):
 """
 Private slot called when the action finished or the user pressed the
 button.
 """
 QHeaderView.ResizeMode.ResizeToContents)
 self.resultList.header().setStretchLastSection(True)
 self.summaryList.header().resizeSections(
 QHeaderView.ResizeMode.ResizeToContents)
 self.summaryList.header().setStretchLastSection(True)
 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.StandardButton.Close
 ):
 self.close()
 elif button == self.buttonBox.button(
 QDialogButtonBox.StandardButton.Cancel
 ):
 self.__finish()
 def __showContextMenu(self, coord):
 """
 Private slot to show the context menu of the listview.
-@param coord the position of the mouse pointer (QPoint)
+@param coord position of the mouse pointer
+@type QPoint
 """
 itm = self.resultList.itemAt(coord)
 if itm:
 self.annotate.setEnabled(True)
 self.openAct.setEnabled(True)
 else:
 self.annotate.setEnabled(False)
 self.openAct.setEnabled(False)
 self.__menu.popup(self.mapToGlobal(coord))
 def __openFile(self, itm=None):
 """
 Private slot to open the selected file.
-@param itm reference to the item to be opened (QTreeWidgetItem)
+@param itm reference to the item to be opened
+@type QTreeWidgetItem
 """
 if itm is None:
 itm = self.resultList.currentItem()
 fn = itm.text(0)
-vm = ericApp().getObject("ViewManager")
+try:
-vm.openSourceFile(fn)
+vm = ericApp().getObject("ViewManager")
-editor = vm.getOpenEditor(fn)
+vm.openSourceFile(fn)
-editor.codeCoverageShowAnnotations()
+editor = vm.getOpenEditor(fn)
+editor.codeCoverageShowAnnotations(coverageFile=self.cfn)
+except KeyError:
+self.openFile.emit(fn)
+# TODO: Coverage.annotate is deprecated
 def __annotate(self):
 """
 Private slot to handle the annotate context menu action.
-This method produce an annotated coverage file of the
+This method produces an annotated coverage file of the
 selected file.
 """
 itm = self.resultList.currentItem()
 fn = itm.text(0)
 cover = Coverage(data_file=self.cfn)
 cover.exclude(self.excludeList[0])
 cover.load()
 cover.annotate([fn], None, True)
+# TODO: Coverage.annotate is deprecated
 def __annotateAll(self):
 """
 Private slot to handle the annotate all context menu action.
 This method produce an annotated coverage file of every
 if progress.wasCanceled():
 break
 cover.annotate([file], None)  # , True)
 progress.setValue(len(files))
 def __erase(self):
 """
 Private slot to handle the erase context menu action.
 This method erases the collected coverage data that is
 cover.erase()
 self.reloadButton.setEnabled(False)
 self.resultList.clear()
 self.summaryList.clear()
 def __deleteAnnotated(self):
 """
 Private slot to handle the delete annotated context menu action.
 This method deletes all annotated files. These are files
 """
 files = Utilities.direntries(self.path, True, '*,cover', False)
 for file in files:
 with contextlib.suppress(OSError):
 os.remove(file)
 @pyqtSlot()
 def on_reloadButton_clicked(self):
 """
 Private slot to reload the coverage info.
 """

Mercurial Repositories > eric / file comparison

comparison: eric7/DataViews/PyCoverageDialog.py

eric7/DataViews/PyCoverageDialog.py