Radon Code Metrics: comparison RadonMetrics/CyclomaticComplexityDialog.py

-:6422943b388f
+:0843dd7239f6
 self.radonService.complexityDone.connect(self.__processResult)
 self.radonService.error.connect(self.__processError)
 self.radonService.batchFinished.connect(self.__batchFinished)
 self.__isSingle = isSingle
+self.__batch = False
 self.cancelled = False
 self.__project = ericApp().getObject("Project")
 self.__locale = QLocale()
 self.__finished = True
 self.__errorItem = None
 self.__fileList = []
 self.filterFrame.setVisible(False)
+self.summaryHeader.setText(self.tr("<b>Summary:</b>"))
+self.explanationHeader.setText(self.tr("<b>Ranking:</b>"))
 self.explanationLabel.setText(
 self.tr(
 "<table>"
-"<tr><td colspan=3><b>Ranking:</b></td></tr>"
 "<tr><td><b>A</b></td><td>1 - 5</td>"
 "<td>(low risk - simple block)</td></tr>"
 "<tr><td><b>B</b></td><td>6 - 10</td>"
 "<td>(low risk - well structured and stable block)</td></tr>"
 "<tr><td><b>C</b></td><td>11 - 20</td>"
 "<tr><td><b>F</b></td><td>&gt; 40</td>"
 "<td>(very high risk - error-prone, unstable block)</td></tr>"
 "</table>"
 )
 )
+self.typeHeader.setText(self.tr("<b>Type:</b>"))
 self.typeLabel.setText(
 self.tr(
 "<table>"
-"<tr><td colspan=2><b>Type:</b></td></tr>"
 "<tr><td><b>C</b></td><td>Class</td></tr>"
 "<tr><td><b>F</b></td><td>Function</td></tr>"
 "<tr><td><b>M</b></td><td>Method</td></tr>"
 "</table>"
 )
 self.__minimumRank = self.__data["MinimumRank"]
 self.rankComboBox.setCurrentIndex(
 self.rankComboBox.findText(self.__minimumRank)
 )
-def start(self, fn, minRank="D"):
+def start(self, fn):
 """
 Public slot to start the cyclomatic complexity determination.
 @param fn file or list of files or directory to show
 the cyclomatic complexity for
 @type str or list of str
-@param minRank minimum rank of entries to be shown
-@type str (one character out of A - F)
 """
 self.cancelled = False
 self.__errorItem = None
 self.resultList.clear()
 self.summaryLabel.clear()
 self.__ccCount = 0
 self.__minimumRank = self.rankComboBox.currentText()
 if len(self.files) > 0:
-# disable updates of the list for speed
-self.resultList.setUpdatesEnabled(False)
 self.resultList.setSortingEnabled(False)
 self.checkProgress.setMaximum(len(self.files))
 self.checkProgress.setVisible(len(self.files) > 1)
 QApplication.processEvents()
 self.cyclomaticComplexity()
 else:
 self.__batch = True
 self.cyclomaticComplexityBatch()
-def cyclomaticComplexity(self, codestring=""):
+def cyclomaticComplexity(self):
 """
 Public method to start a cyclomatic complexity calculation for one
 Python file.
 The results are reported to the __processResult slot.
-@param codestring optional sourcestring
-@type str
 """
 if not self.files:
 self.checkProgress.setMaximum(1)
 self.checkProgress.setValue(1)
 self.__finish()
 return
 self.filename = self.files.pop(0)
 self.checkProgress.setValue(self.progress)
-QApplication.processEvents()
 if self.cancelled:
 return
 try:
 self.__lastFileItem = None
 argumentsList = []
 for progress, filename in enumerate(self.files, start=1):
 self.checkProgress.setValue(progress)
-QApplication.processEvents()
 try:
 source = Utilities.readEncodedFile(filename)[0]
 source = Utilities.normalizeCode(source)
 except (UnicodeError, OSError) as msg:
 argumentsList.append((filename, source))
 # reset the progress bar to the checked files
 self.checkProgress.setValue(self.progress)
-QApplication.processEvents()
 self.__finished = False
 self.radonService.cyclomaticComplexityBatch(argumentsList)
 def __batchFinished(self, type_):
 self.__ccSum += result["total_cc"]
 for rank in result["summary"]:
 self.__summary[rank] += result["summary"][rank]
 self.progress += 1
 self.checkProgress.setValue(self.progress)
-QApplication.processEvents()
 if not self.__batch:
 self.cyclomaticComplexity()
 def __finish(self):
 from radon.complexity import cc_rank
 if not self.__finished:
 self.__finished = True
-# re-enable updates of the list
 self.resultList.setSortingEnabled(True)
 self.resultList.sortItems(0, Qt.SortOrder.AscendingOrder)
 self.resultList.sortItems(1, Qt.SortOrder.AscendingOrder)
-self.resultList.setUpdatesEnabled(True)
 self.cancelled = True
 self.buttonBox.button(QDialogButtonBox.StandardButton.Close).setEnabled(
 True
 )
 averageCC = float(self.__ccSum) / (self.__ccCount or 1)
 self.summaryLabel.setText(
 self.tr(
-"<b>Summary:</b><br/>"
 "{0} blocks (classes, functions, methods) analyzed.<br/>"
 "Average complexity: {7} ({8})"
 "<table>"
 "<tr><td width=30><b>A</b></td>"
 "<td align='right'>{1} blocks</td></tr>"
 )
 )
 self.checkProgress.setVisible(False)
+def __cancel(self):
+"""
+Private method to cancel the current check run.
+"""
+if self.__batch:
+self.radonService.cancelComplexityBatch()
+QTimer.singleShot(1000, self.__finish)
+else:
+self.__finish()
+def closeEvent(self, evt):
+"""
+Protected method to handle a close event.
+@param evt reference to the close event
+@type QCloseEvent
+"""
+self.__cancel()
 @pyqtSlot(QAbstractButton)
 def on_buttonBox_clicked(self, button):
 """
 Private slot called by a button of the button box clicked.
 @type QAbstractButton
 """
 if button == self.buttonBox.button(QDialogButtonBox.StandardButton.Close):
 self.close()
 elif button == self.buttonBox.button(QDialogButtonBox.StandardButton.Cancel):
-if self.__batch:
+self.__cancel()
-self.radonService.cancelComplexityBatch()
-QTimer.singleShot(1000, self.__finish)
-else:
-self.__finish()
 @pyqtSlot()
 def on_startButton_clicked(self):
 """
 Private slot to start a cyclomatic complexity run.
 lineno = item.data(0, self.LineNumberRole)
 if filename:
 vm = ericApp().getObject("ViewManager")
 vm.openSourceFile(filename, lineno)
-@pyqtSlot(str)
+@pyqtSlot(int)
-def on_rankComboBox_activated(self, rank):
+def on_rankComboBox_activated(self, index):
 """
 Private slot to handle the selection of a minimum rank.
-@param rank selected minimum rank
+@param index index of the selected minimum rank
 @type str
 """
 if self.__isSingle:
 self.start(self.__fileList[:])

Mercurial Repositories > Radon Code Metrics / file comparison

comparison: RadonMetrics/CyclomaticComplexityDialog.py

RadonMetrics/CyclomaticComplexityDialog.py