eric: comparison eric7/DataViews/PyCoverageDialog.py

-:2b9bd8f97576
+:4ac66b6c33a4
 """
 Module implementing a Python code coverage dialog.
 """
-import contextlib
 import os
 import time
-from PyQt6.QtCore import pyqtSlot, Qt
+from PyQt6.QtCore import pyqtSignal, pyqtSlot, Qt, QUrl
+from PyQt6.QtGui import QDesktopServices
 from PyQt6.QtWidgets import (
 QDialog, QDialogButtonBox, QMenu, QHeaderView, QTreeWidgetItem,
 QApplication
 )
 from EricWidgets import EricMessageBox
 from EricWidgets.EricApplication import ericApp
-from EricWidgets.EricProgressDialog import EricProgressDialog
 from .Ui_PyCoverageDialog import Ui_PyCoverageDialog
 import Utilities
 from coverage import Coverage
 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)
 self.cancelled = False
 self.path = '.'
 self.reload = False
 self.excludeList = ['# *pragma[: ]*[nN][oO] *[cC][oO][vV][eE][rR]']
+self.__reportsMenu = QMenu(self.tr("Create Report"), self)
+self.__reportsMenu.addAction(self.tr("HTML Report"), self.__htmlReport)
+self.__reportsMenu.addSeparator()
+self.__reportsMenu.addAction(self.tr("JSON Report"), self.__jsonReport)
+self.__reportsMenu.addAction(self.tr("LCOV Report"), self.__lcovReport)
 self.__menu = QMenu(self)
 self.__menu.addSeparator()
 self.openAct = self.__menu.addAction(
 self.tr("Open"), self.__openFile)
 self.__menu.addSeparator()
-self.annotate = self.__menu.addAction(
+self.__menu.addMenu(self.__reportsMenu)
-self.tr('Annotate'), self.__annotate)
-self.__menu.addAction(self.tr('Annotate all'), self.__annotateAll)
-self.__menu.addAction(
-self.tr('Delete annotated files'), self.__deleteAnnotated)
 self.__menu.addSeparator()
 self.__menu.addAction(self.tr('Erase Coverage Info'), self.__erase)
 self.resultList.setContextMenuPolicy(
 Qt.ContextMenuPolicy.CustomContextMenu)
 self.resultList.customContextMenuRequested.connect(
 """
 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
 """
+# initialize the dialog
+self.resultList.clear()
+self.summaryList.clear()
+self.cancelled = False
+self.buttonBox.button(
+QDialogButtonBox.StandardButton.Close).setEnabled(False)
+self.buttonBox.button(
+QDialogButtonBox.StandardButton.Cancel).setEnabled(True)
+self.buttonBox.button(
+QDialogButtonBox.StandardButton.Cancel).setDefault(True)
 self.__cfn = cfn
 self.__fn = fn
-self.basename = os.path.splitext(cfn)[0]
+self.cfn = (
+cfn
-self.cfn = "{0}.coverage".format(self.basename)
+if cfn.endswith(".coverage") else
+"{0}.coverage".format(os.path.splitext(cfn)[0])
+)
 if isinstance(fn, list):
 files = fn
 self.path = os.path.dirname(cfn)
 elif os.path.isdir(fn):
 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.__reportsMenu.setEnabled(
+bool(self.resultList.topLevelItemCount()))
 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)
-def __annotate(self):
+except KeyError:
-"""
+self.openFile.emit(fn)
-Private slot to handle the annotate context menu action.
+def __prepareReportGeneration(self):
-This method produce an annotated coverage file of the
+"""
-selected file.
+Private method to prepare a report generation.
-"""
-itm = self.resultList.currentItem()
+@return tuple containing a reference to the Coverage object and the
-fn = itm.text(0)
+list of files to report
+@rtype tuple of (Coverage, list of str)
+"""
+count = self.resultList.topLevelItemCount()
+if count == 0:
+return None, []
+# get list of all filenames
+files = [
+self.resultList.topLevelItem(index).text(0)
+for index in range(count)
+]
 cover = Coverage(data_file=self.cfn)
 cover.exclude(self.excludeList[0])
 cover.load()
-cover.annotate([fn], None, True)
+return cover, files
-def __annotateAll(self):
-"""
+@pyqtSlot()
-Private slot to handle the annotate all context menu action.
+def __htmlReport(self):
+"""
-This method produce an annotated coverage file of every
+Private slot to generate a HTML report of the shown data.
-file listed in the listview.
+"""
-"""
+from .PyCoverageHtmlReportDialog import PyCoverageHtmlReportDialog
-amount = self.resultList.topLevelItemCount()
-if amount == 0:
+dlg = PyCoverageHtmlReportDialog(os.path.dirname(self.cfn), self)
-return
+if dlg.exec() == QDialog.DialogCode.Accepted:
+title, outputDirectory, extraCSS, openReport = dlg.getData()
-# get list of all filenames
-files = []
+cover, files = self.__prepareReportGeneration()
-for index in range(amount):
+cover.html_report(morfs=files, directory=outputDirectory,
-itm = self.resultList.topLevelItem(index)
+ignore_errors=True, extra_css=extraCSS,
-files.append(itm.text(0))
+title=title)
-cover = Coverage(data_file=self.cfn)
+if openReport:
-cover.exclude(self.excludeList[0])
+QDesktopServices.openUrl(QUrl.fromLocalFile(os.path.join(
-cover.load()
+outputDirectory, "index.html")))
-# now process them
+@pyqtSlot()
-progress = EricProgressDialog(
+def __jsonReport(self):
-self.tr("Annotating files..."), self.tr("Abort"),
+"""
-0, len(files), self.tr("%v/%m Files"), self)
+Private slot to generate a JSON report of the shown data.
-progress.setMinimumDuration(0)
+"""
-progress.setWindowTitle(self.tr("Coverage"))
+from .PyCoverageJsonReportDialog import PyCoverageJsonReportDialog
-for count, file in enumerate(files):
+dlg = PyCoverageJsonReportDialog(os.path.dirname(self.cfn), self)
-progress.setValue(count)
+if dlg.exec() == QDialog.DialogCode.Accepted:
-if progress.wasCanceled():
+filename, compact = dlg.getData()
-break
+cover, files = self.__prepareReportGeneration()
-cover.annotate([file], None)  # , True)
+cover.json_report(morfs=files, outfile=filename,
+ignore_errors=True, pretty_print=not compact)
-progress.setValue(len(files))
+@pyqtSlot()
+def __lcovReport(self):
+"""
+Private slot to generate a LCOV report of the shown data.
+"""
+from EricWidgets import EricPathPickerDialog
+from EricWidgets.EricPathPicker import EricPathPickerModes
+filename, ok = EricPathPickerDialog.getPath(
+self,
+self.tr("LCOV Report"),
+self.tr("Enter the path of the output file:"),
+mode=EricPathPickerModes.SAVE_FILE_ENSURE_EXTENSION_MODE,
+path=os.path.join(os.path.dirname(self.cfn), "coverage.lcov"),
+defaultDirectory=os.path.dirname(self.cfn),
+filters=self.tr("LCOV Files (*.lcov);;All Files (*)")
+)
+if ok:
+cover, files = self.__prepareReportGeneration()
+cover.lcov_report(morfs=files, outfile=filename,
+ignore_errors=True)
 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
-ending with ',cover'.
-"""
-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.
 """
-self.resultList.clear()
-self.summaryList.clear()
 self.reload = True
 excludePattern = self.excludeCombo.currentText()
 if excludePattern in self.excludeList:
 self.excludeList.remove(excludePattern)
 self.excludeList.insert(0, excludePattern)
-self.cancelled = False
-self.buttonBox.button(
-QDialogButtonBox.StandardButton.Close).setEnabled(False)
-self.buttonBox.button(
-QDialogButtonBox.StandardButton.Cancel).setEnabled(True)
-self.buttonBox.button(
-QDialogButtonBox.StandardButton.Cancel).setDefault(True)
 self.start(self.__cfn, self.__fn)
 @pyqtSlot(QTreeWidgetItem, int)
 def on_resultList_itemActivated(self, item, column):
 """

Mercurial Repositories > eric / file comparison

comparison: eric7/DataViews/PyCoverageDialog.py

eric7/DataViews/PyCoverageDialog.py