eric: eric6/Plugins/VcsPlugins/vcsGit/GitLogBrowserDialog.py@8a96736d465e (annotated)

 # -*- coding: utf-8 -*-
 # Copyright (c) 2014 - 2021 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing a dialog to browse the log history.
 """
 import os
 import collections
 import re
 from PyQt5.QtCore import (
     pyqtSlot, Qt, QDate, QProcess, QTimer, QSize, QPoint, QFileInfo
 )
 from PyQt5.QtGui import (
     QColor, QPixmap, QPainter, QPen, QIcon, QTextCursor, QPalette
 )
 from PyQt5.QtWidgets import (
     QWidget, QDialogButtonBox, QHeaderView, QTreeWidgetItem, QApplication,
     QLineEdit, QMenu, QInputDialog
 )
 from E5Gui.E5Application import e5App
 from E5Gui import E5MessageBox, E5FileDialog
 from E5Gui.E5OverrideCursor import E5OverrideCursorProcess
 from Globals import strToQByteArray
 from .Ui_GitLogBrowserDialog import Ui_GitLogBrowserDialog
 from .GitDiffHighlighter import GitDiffHighlighter
 from .GitDiffGenerator import GitDiffGenerator
 import UI.PixmapCache
 import Preferences
 import Utilities
 COLORNAMES = ["red", "green", "purple", "cyan", "olive", "magenta",
               "gray", "yellow", "darkred", "darkgreen", "darkblue",
               "darkcyan", "darkmagenta", "blue"]
 COLORS = [str(QColor(x).name()) for x in COLORNAMES]
 LIGHTCOLORS = ["#aaaaff", "#7faa7f", "#ffaaaa", "#aaffaa", "#7f7faa",
                "#ffaaff", "#aaffff", "#d5d579", "#ffaaff", "#d57979",
                "#d579d5", "#79d5d5", "#d5d5d5", "#d5d500",
                ]
 class GitLogBrowserDialog(QWidget, Ui_GitLogBrowserDialog):
     """
     Class implementing a dialog to browse the log history.
     """
     IconColumn = 0
     CommitIdColumn = 1
     AuthorColumn = 2
     DateColumn = 3
     CommitterColumn = 4
     CommitDateColumn = 5
     SubjectColumn = 6
     BranchColumn = 7
     TagsColumn = 8
     def __init__(self, vcs, parent=None):
         """
         Constructor
         @param vcs reference to the vcs object
         @param parent parent widget (QWidget)
         """
         super(GitLogBrowserDialog, self).__init__(parent)
         self.setupUi(self)
         windowFlags = self.windowFlags()
         windowFlags |= Qt.WindowContextHelpButtonHint
         self.setWindowFlags(windowFlags)
         self.mainSplitter.setSizes([300, 400])
         self.mainSplitter.setStretchFactor(0, 1)
         self.mainSplitter.setStretchFactor(1, 2)
         self.diffSplitter.setStretchFactor(0, 1)
         self.diffSplitter.setStretchFactor(1, 2)
         self.buttonBox.button(QDialogButtonBox.Close).setEnabled(False)
         self.buttonBox.button(QDialogButtonBox.Cancel).setDefault(True)
         self.filesTree.headerItem().setText(self.filesTree.columnCount(), "")
         self.filesTree.header().setSortIndicator(1, Qt.AscendingOrder)
         self.upButton.setIcon(UI.PixmapCache.getIcon("1uparrow"))
         self.downButton.setIcon(UI.PixmapCache.getIcon("1downarrow"))
         self.refreshButton = self.buttonBox.addButton(
             self.tr("&Refresh"), QDialogButtonBox.ActionRole)
         self.refreshButton.setToolTip(
             self.tr("Press to refresh the list of commits"))
         self.refreshButton.setEnabled(False)
         self.findPrevButton.setIcon(UI.PixmapCache.getIcon("1leftarrow"))
         self.findNextButton.setIcon(UI.PixmapCache.getIcon("1rightarrow"))
         self.__findBackwards = False
         self.modeComboBox.addItem(self.tr("Find"), "find")
         self.modeComboBox.addItem(self.tr("Filter"), "filter")
         self.fieldCombo.addItem(self.tr("Commit ID"), "commitId")
         self.fieldCombo.addItem(self.tr("Author"), "author")
         self.fieldCombo.addItem(self.tr("Committer"), "committer")
         self.fieldCombo.addItem(self.tr("Subject"), "subject")
         self.fieldCombo.addItem(self.tr("File"), "file")
         self.__logTreeNormalFont = self.logTree.font()
         self.__logTreeNormalFont.setBold(False)
         self.__logTreeBoldFont = self.logTree.font()
         self.__logTreeBoldFont.setBold(True)
         self.__logTreeHasDarkBackground = e5App().usesDarkPalette()
         font = Preferences.getEditorOtherFonts("MonospacedFont")
         self.diffEdit.document().setDefaultFont(font)
         self.diffHighlighter = GitDiffHighlighter(self.diffEdit.document())
         self.__diffGenerator = GitDiffGenerator(vcs, self)
         self.__diffGenerator.finished.connect(self.__generatorFinished)
         self.vcs = vcs
         self.__detailsTemplate = self.tr(
             "<table>"
             "<tr><td><b>Commit ID</b></td><td>{0}</td></tr>"
             "<tr><td><b>Date</b></td><td>{1}</td></tr>"
             "<tr><td><b>Author</b></td><td>{2} &lt;{3}&gt;</td></tr>"
             "<tr><td><b>Commit Date</b></td><td>{4}</td></tr>"
             "<tr><td><b>Committer</b></td><td>{5} &lt;{6}&gt;</td></tr>"
             "{7}"
             "<tr><td><b>Subject</b></td><td>{8}</td></tr>"
             "{9}"
             "</table>"
         )
         self.__parentsTemplate = self.tr(
             "<tr><td><b>Parents</b></td><td>{0}</td></tr>"
         )
         self.__childrenTemplate = self.tr(
             "<tr><td><b>Children</b></td><td>{0}</td></tr>"
         )
         self.__branchesTemplate = self.tr(
             "<tr><td><b>Branches</b></td><td>{0}</td></tr>"
         )
         self.__tagsTemplate = self.tr(
             "<tr><td><b>Tags</b></td><td>{0}</td></tr>"
         )
         self.__mesageTemplate = self.tr(
             "<tr><td><b>Message</b></td><td>{0}</td></tr>"
         )
         self.__formatTemplate = (
             'format:recordstart%n'
             'commit|%h%n'
             'parents|%p%n'
             'author|%an%n'
             'authormail|%ae%n'
             'authordate|%ai%n'
             'committer|%cn%n'
             'committermail|%ce%n'
             'committerdate|%ci%n'
             'refnames|%d%n'
             'subject|%s%n'
             'bodystart%n'
             '%b%n'
             'bodyend%n'
         )
         self.__filename = ""
         self.__isFile = False
         self.__selectedCommitIDs = []
         self.intercept = False
         self.__initData()
         self.fromDate.setDisplayFormat("yyyy-MM-dd")
         self.toDate.setDisplayFormat("yyyy-MM-dd")
         self.__resetUI()
         # roles used in the log tree
         self.__subjectRole = Qt.UserRole
         self.__messageRole = Qt.UserRole + 1
         self.__changesRole = Qt.UserRole + 2
         self.__edgesRole = Qt.UserRole + 3
         self.__parentsRole = Qt.UserRole + 4
         self.__branchesRole = Qt.UserRole + 5
         self.__authorMailRole = Qt.UserRole + 6
         self.__committerMailRole = Qt.UserRole + 7
         # roles used in the file tree
         self.__diffFileLineRole = Qt.UserRole
         self.__process = E5OverrideCursorProcess()
         self.__process.finished.connect(self.__procFinished)
         self.__process.readyReadStandardOutput.connect(self.__readStdout)
         self.__process.readyReadStandardError.connect(self.__readStderr)
         self.flags = {
             'A': self.tr('Added'),
             'D': self.tr('Deleted'),
             'M': self.tr('Modified'),
             'C': self.tr('Copied'),
             'R': self.tr('Renamed'),
             'T': self.tr('Type changed'),
             'U': self.tr('Unmerged'),
             'X': self.tr('Unknown'),
         }
         self.__dotRadius = 8
         self.__rowHeight = 20
         self.logTree.setIconSize(
             QSize(100 * self.__rowHeight, self.__rowHeight))
         self.detailsEdit.anchorClicked.connect(self.__commitIdClicked)
         self.__initLogTreeContextMenu()
         self.__initActionsMenu()
         self.__finishCallbacks = []
     def __addFinishCallback(self, callback):
         """
         Private method to add a method to be called once the process finished.
         The callback methods are invoke in a FIFO style and are consumed. If
         a callback method needs to be called again, it must be added again.
         @param callback callback method
         @type function
         """
         if callback not in self.__finishCallbacks:
             self.__finishCallbacks.append(callback)
     def __initLogTreeContextMenu(self):
         """
         Private method to initialize the log tree context menu.
         """
         self.__logTreeMenu = QMenu()
         # commit ID column
         act = self.__logTreeMenu.addAction(
             self.tr("Show Commit ID Column"))
         act.setToolTip(self.tr(
             "Press to show the commit ID column"))
         act.setCheckable(True)
         act.setChecked(self.vcs.getPlugin().getPreferences(
             "ShowCommitIdColumn"))
         act.triggered.connect(self.__showCommitIdColumn)
         # author and date columns
         act = self.__logTreeMenu.addAction(
             self.tr("Show Author Columns"))
         act.setToolTip(self.tr(
             "Press to show the author columns"))
         act.setCheckable(True)
         act.setChecked(self.vcs.getPlugin().getPreferences(
             "ShowAuthorColumns"))
         act.triggered.connect(self.__showAuthorColumns)
         # committer and commit date columns
         act = self.__logTreeMenu.addAction(
             self.tr("Show Committer Columns"))
         act.setToolTip(self.tr(
             "Press to show the committer columns"))
         act.setCheckable(True)
         act.setChecked(self.vcs.getPlugin().getPreferences(
             "ShowCommitterColumns"))
         act.triggered.connect(self.__showCommitterColumns)
         # branches column
         act = self.__logTreeMenu.addAction(
             self.tr("Show Branches Column"))
         act.setToolTip(self.tr(
             "Press to show the branches column"))
         act.setCheckable(True)
         act.setChecked(self.vcs.getPlugin().getPreferences(
             "ShowBranchesColumn"))
         act.triggered.connect(self.__showBranchesColumn)
         # tags column
         act = self.__logTreeMenu.addAction(
             self.tr("Show Tags Column"))
         act.setToolTip(self.tr(
             "Press to show the Tags column"))
         act.setCheckable(True)
         act.setChecked(self.vcs.getPlugin().getPreferences(
             "ShowTagsColumn"))
         act.triggered.connect(self.__showTagsColumn)
         # set column visibility as configured
         self.__showCommitIdColumn(self.vcs.getPlugin().getPreferences(
             "ShowCommitIdColumn"))
         self.__showAuthorColumns(self.vcs.getPlugin().getPreferences(
             "ShowAuthorColumns"))
         self.__showCommitterColumns(self.vcs.getPlugin().getPreferences(
             "ShowCommitterColumns"))
         self.__showBranchesColumn(self.vcs.getPlugin().getPreferences(
             "ShowBranchesColumn"))
         self.__showTagsColumn(self.vcs.getPlugin().getPreferences(
             "ShowTagsColumn"))
     def __initActionsMenu(self):
         """
         Private method to initialize the actions menu.
         """
         self.__actionsMenu = QMenu()
         self.__actionsMenu.setTearOffEnabled(True)
         self.__actionsMenu.setToolTipsVisible(True)
         self.__cherryAct = self.__actionsMenu.addAction(
             self.tr("Copy Commits"), self.__cherryActTriggered)
         self.__cherryAct.setToolTip(self.tr(
             "Cherry-pick the selected commits to the current branch"))
         self.__actionsMenu.addSeparator()
         self.__tagAct = self.__actionsMenu.addAction(
             self.tr("Tag"), self.__tagActTriggered)
         self.__tagAct.setToolTip(self.tr("Tag the selected commit"))
         self.__branchAct = self.__actionsMenu.addAction(
             self.tr("Branch"), self.__branchActTriggered)
         self.__branchAct.setToolTip(self.tr(
             "Create a new branch at the selected commit."))
         self.__branchSwitchAct = self.__actionsMenu.addAction(
             self.tr("Branch && Switch"), self.__branchSwitchActTriggered)
         self.__branchSwitchAct.setToolTip(self.tr(
             "Create a new branch at the selected commit and switch"
             " the work tree to it."))
         self.__switchAct = self.__actionsMenu.addAction(
             self.tr("Switch"), self.__switchActTriggered)
         self.__switchAct.setToolTip(self.tr(
             "Switch the working directory to the selected commit"))
         self.__actionsMenu.addSeparator()
         self.__shortlogAct = self.__actionsMenu.addAction(
             self.tr("Show Short Log"), self.__shortlogActTriggered)
         self.__shortlogAct.setToolTip(self.tr(
             "Show a dialog with a log output for release notes"))
         self.__describeAct = self.__actionsMenu.addAction(
             self.tr("Describe"), self.__describeActTriggered)
         self.__describeAct.setToolTip(self.tr(
             "Show the most recent tag reachable from a commit"))
         self.actionsButton.setIcon(
             UI.PixmapCache.getIcon("actionsToolButton"))
         self.actionsButton.setMenu(self.__actionsMenu)
     def __initData(self):
         """
         Private method to (re-)initialize some data.
         """
         self.__maxDate = QDate()
         self.__minDate = QDate()
         self.__filterLogsEnabled = True
         self.buf = []        # buffer for stdout
         self.diff = None
         self.__started = False
         self.__skipEntries = 0
         self.projectMode = False
         # attributes to store log graph data
         self.__commitIds = []
         self.__commitColors = {}
         self.__commitColor = 0
         self.__projectRevision = ""
         self.__childrenInfo = collections.defaultdict(list)
     def closeEvent(self, e):
         """
         Protected slot implementing a close event handler.
         @param e close event (QCloseEvent)
         """
         if (
             self.__process is not None and
             self.__process.state() != QProcess.NotRunning
         ):
             self.__process.terminate()
             QTimer.singleShot(2000, self.__process.kill)
             self.__process.waitForFinished(3000)
         self.vcs.getPlugin().setPreferences(
             "LogBrowserGeometry", self.saveGeometry())
         self.vcs.getPlugin().setPreferences(
             "LogBrowserSplitterStates", [
                 self.mainSplitter.saveState(),
                 self.detailsSplitter.saveState(),
                 self.diffSplitter.saveState(),
             ]
         )
         e.accept()
     def show(self):
         """
         Public slot to show the dialog.
         """
         self.__reloadGeometry()
         self.__restoreSplitterStates()
         self.__resetUI()
         super(GitLogBrowserDialog, self).show()
     def __reloadGeometry(self):
         """
         Private method to restore the geometry.
         """
         geom = self.vcs.getPlugin().getPreferences("LogBrowserGeometry")
         if geom.isEmpty():
             s = QSize(1000, 800)
             self.resize(s)
         else:
             self.restoreGeometry(geom)
     def __restoreSplitterStates(self):
         """
         Private method to restore the state of the various splitters.
         """
         states = self.vcs.getPlugin().getPreferences(
             "LogBrowserSplitterStates")
         if len(states) == 3:
             # we have three splitters
             self.mainSplitter.restoreState(states[0])
             self.detailsSplitter.restoreState(states[1])
             self.diffSplitter.restoreState(states[2])
     def __resetUI(self):
         """
         Private method to reset the user interface.
         """
         self.fromDate.setDate(QDate.currentDate())
         self.toDate.setDate(QDate.currentDate())
         self.fieldCombo.setCurrentIndex(self.fieldCombo.findData("subject"))
         self.limitSpinBox.setValue(self.vcs.getPlugin().getPreferences(
             "LogLimit"))
         self.stopCheckBox.setChecked(self.vcs.getPlugin().getPreferences(
             "StopLogOnCopy"))
         self.logTree.clear()
     def __resizeColumnsLog(self):
         """
         Private method to resize the log tree columns.
         """
         self.logTree.header().resizeSections(QHeaderView.ResizeToContents)
         self.logTree.header().setStretchLastSection(True)
     def __resizeColumnsFiles(self):
         """
         Private method to resize the changed files tree columns.
         """
         self.filesTree.header().resizeSections(QHeaderView.ResizeToContents)
         self.filesTree.header().setStretchLastSection(True)
     def __resortFiles(self):
         """
         Private method to resort the changed files tree.
         """
         self.filesTree.setSortingEnabled(True)
         self.filesTree.sortItems(1, Qt.AscendingOrder)
         self.filesTree.setSortingEnabled(False)
     def __getColor(self, n):
         """
         Private method to get the (rotating) name of the color given an index.
         @param n color index
         @type int
         @return color name
         @rtype str
         """
         if self.__logTreeHasDarkBackground:
             return LIGHTCOLORS[n % len(LIGHTCOLORS)]
         else:
             return COLORS[n % len(COLORS)]
     def __generateEdges(self, commitId, parents):
         """
         Private method to generate edge info for the give data.
         @param commitId commit id to calculate edge info for (string)
         @param parents list of parent commits (list of strings)
         @return tuple containing the column and color index for
             the given node and a list of tuples indicating the edges
             between the given node and its parents
             (integer, integer, [(integer, integer, integer), ...])
         """
         if commitId not in self.__commitIds:
             # new head
             self.__commitIds.append(commitId)
             self.__commitColors[commitId] = self.__commitColor
             self.__commitColor += 1
         col = self.__commitIds.index(commitId)
         color = self.__commitColors.pop(commitId)
         nextCommitIds = self.__commitIds[:]
         # add parents to next
         addparents = [p for p in parents if p not in nextCommitIds]
         nextCommitIds[col:col + 1] = addparents
         # set colors for the parents
         for i, p in enumerate(addparents):
             if not i:
                 self.__commitColors[p] = color
             else:
                 self.__commitColors[p] = self.__commitColor
                 self.__commitColor += 1
         # add edges to the graph
         edges = []
         if parents:
             for ecol, ecommitId in enumerate(self.__commitIds):
                 if ecommitId in nextCommitIds:
                     edges.append(
                         (ecol, nextCommitIds.index(ecommitId),
                          self.__commitColors[ecommitId]))
                 elif ecommitId == commitId:
                     for p in parents:
                         edges.append(
                             (ecol, nextCommitIds.index(p),
                              self.__commitColors[p]))
         self.__commitIds = nextCommitIds
         return col, color, edges
     def __generateIcon(self, column, color, bottomedges, topedges, dotColor,
                        currentCommit):
         """
         Private method to generate an icon containing the revision tree for the
         given data.
         @param column column index of the revision (integer)
         @param color color of the node (integer)
         @param bottomedges list of edges for the bottom of the node
             (list of tuples of three integers)
         @param topedges list of edges for the top of the node
             (list of tuples of three integers)
         @param dotColor color to be used for the dot (QColor)
         @param currentCommit flag indicating to draw the icon for the
             current commit (boolean)
         @return icon for the node (QIcon)
         """
         def col2x(col, radius):
             """
             Local function to calculate a x-position for a column.
             @param col column number (integer)
             @param radius radius of the indicator circle (integer)
             """
             return int(1.2 * radius) * col + radius // 2 + 3
         radius = self.__dotRadius
         w = len(bottomedges) * radius + 20
         h = self.__rowHeight
         dot_x = col2x(column, radius) - radius // 2
         dot_y = h // 2
         pix = QPixmap(w, h)
         pix.fill(QColor(0, 0, 0, 0))        # draw transparent background
         painter = QPainter(pix)
         painter.setRenderHint(QPainter.Antialiasing)
         # draw the revision history lines
         for y1, y2, lines in ((0, h, bottomedges),
                               (-h, 0, topedges)):
             if lines:
                 for start, end, ecolor in lines:
                     lpen = QPen(QColor(self.__getColor(ecolor)))
                     lpen.setWidth(2)
                     painter.setPen(lpen)
                     x1 = col2x(start, radius)
                     x2 = col2x(end, radius)
                     painter.drawLine(x1, dot_y + y1, x2, dot_y + y2)
         penradius = 1
         pencolor = self.logTree.palette().color(QPalette.Text)
         dot_y = (h // 2) - radius // 2
         # draw a dot for the revision
         if currentCommit:
             # enlarge dot for the current revision
             delta = 2
             radius += 2 * delta
             dot_y -= delta
             dot_x -= delta
         painter.setBrush(dotColor)
         pen = QPen(pencolor)
         pen.setWidth(penradius)
         painter.setPen(pen)
         painter.drawEllipse(dot_x, dot_y, radius, radius)
         painter.end()
         return QIcon(pix)
     def __identifyProject(self):
         """
         Private method to determine the revision of the project directory.
         """
         errMsg = ""
         args = self.vcs.initCommand("show")
         args.append("--abbrev={0}".format(
             self.vcs.getPlugin().getPreferences("CommitIdLength")))
         args.append("--format=%h")
         args.append("--no-patch")
         args.append("HEAD")
         output = ""
         process = QProcess()
         process.setWorkingDirectory(self.repodir)
         process.start('git', args)
         procStarted = process.waitForStarted(5000)
         if procStarted:
             finished = process.waitForFinished(30000)
             if finished and process.exitCode() == 0:
                 output = str(process.readAllStandardOutput(),
                              Preferences.getSystem("IOEncoding"),
                              'replace')
             else:
                 if not finished:
                     errMsg = self.tr(
                         "The git process did not finish within 30s.")
         else:
             errMsg = self.tr("Could not start the git executable.")
         if errMsg:
             E5MessageBox.critical(
                 self,
                 self.tr("Git Error"),
                 errMsg)
         if output:
             self.__projectRevision = output.strip()
     def __generateLogItem(self, author, date, committer, commitDate, subject,
                           message, commitId, changedPaths, parents, refnames,
                           authorMail, committerMail):
         """
         Private method to generate a log tree entry.
         @param author author info (string)
         @param date date info (string)
         @param committer committer info (string)
         @param commitDate commit date info (string)
         @param subject subject of the log entry (string)
         @param message text of the log message (list of strings)
         @param commitId commit id info (string)
         @param changedPaths list of dictionary objects containing
             info about the changed files/directories
         @param parents list of parent revisions (list of integers)
         @param refnames tags and branches of the commit (string)
         @param authorMail author's email address (string)
         @param committerMail committer's email address (string)
         @return reference to the generated item (QTreeWidgetItem)
         """
         branches = []
         allBranches = []
         tags = []
         names = refnames.strip()[1:-1].split(",")
         for name in names:
             name = name.strip()
             if name:
                 if "HEAD" in name:
                     tags.append(name)
                 elif name.startswith("tag: "):
                     tags.append(name.split()[1])
                 else:
                     if "/" not in name:
                         branches.append(name)
                     elif "refs/bisect/" in name:
                         bname = name.replace("refs/", "").split("-", 1)[0]
                         branches.append(bname)
                     else:
                         branches.append(name)
                     allBranches.append(name)
         logMessageColumnWidth = self.vcs.getPlugin().getPreferences(
             "LogSubjectColumnWidth")
         msgtxt = subject
         if logMessageColumnWidth and len(msgtxt) > logMessageColumnWidth:
             msgtxt = "{0}...".format(msgtxt[:logMessageColumnWidth])
         columnLabels = [
             "",
             commitId,
             author,
             date.rsplit(None, 1)[0].rsplit(":", 1)[0],
             committer,
             commitDate.rsplit(None, 1)[0].rsplit(":", 1)[0],
             msgtxt,
             ", ".join(branches),
             ", ".join(tags),
         ]
         itm = QTreeWidgetItem(self.logTree, columnLabels)
         parents = [p.strip() for p in parents.split()]
         column, color, edges = self.__generateEdges(commitId, parents)
         itm.setData(0, self.__subjectRole, subject)
         itm.setData(0, self.__messageRole, message)
         itm.setData(0, self.__changesRole, changedPaths)
         itm.setData(0, self.__edgesRole, edges)
         itm.setData(0, self.__branchesRole, allBranches)
         itm.setData(0, self.__authorMailRole, authorMail)
         itm.setData(0, self.__committerMailRole, committerMail)
         if not parents:
             itm.setData(0, self.__parentsRole, [])
         else:
             itm.setData(0, self.__parentsRole, parents)
             for parent in parents:
                 self.__childrenInfo[parent].append(commitId)
         if self.logTree.topLevelItemCount() > 1:
             topedges = (
                 self.logTree.topLevelItem(
                     self.logTree.indexOfTopLevelItem(itm) - 1)
                 .data(0, self.__edgesRole)
             )
         else:
             topedges = None
         icon = self.__generateIcon(column, color, edges, topedges,
                                    QColor("blue"),
                                    commitId == self.__projectRevision)
         itm.setIcon(0, icon)
         return itm
     def __generateFileItem(self, action, path, copyfrom, additions, deletions):
         """
         Private method to generate a changed files tree entry.
         @param action indicator for the change action ("A", "C", "D", "M",
             "R", "T", "U", "X")
         @param path path of the file in the repository (string)
         @param copyfrom path the file was copied from (string)
         @param additions number of added lines (int)
         @param deletions number of deleted lines (int)
         @return reference to the generated item (QTreeWidgetItem)
         """
         if len(action) > 1:
             # includes confidence level
             confidence = int(action[1:])
             actionTxt = self.tr("{0} ({1}%)", "action, confidence").format(
                 self.flags[action[0]], confidence)
         else:
             actionTxt = self.flags[action]
         itm = QTreeWidgetItem(self.filesTree, [
             actionTxt,
             path,
             str(additions),
             str(deletions),
             copyfrom,
         ])
         itm.setTextAlignment(2, Qt.AlignRight)
         itm.setTextAlignment(3, Qt.AlignRight)
         return itm
     def __getLogEntries(self, skip=0, noEntries=0):
         """
         Private method to retrieve log entries from the repository.
         @param skip number of log entries to skip (integer)
         @keyparam noEntries number of entries to get (0 = default) (int)
         """
         self.buttonBox.button(QDialogButtonBox.Close).setEnabled(False)
         self.buttonBox.button(QDialogButtonBox.Cancel).setEnabled(True)
         self.buttonBox.button(QDialogButtonBox.Cancel).setDefault(True)
         QApplication.processEvents()
         self.buf = []
         self.cancelled = False
         self.errors.clear()
         self.intercept = False
         if noEntries == 0:
             noEntries = self.limitSpinBox.value()
         args = self.vcs.initCommand("log")
         args.append('--max-count={0}'.format(noEntries))
         args.append('--numstat')
         args.append('--abbrev={0}'.format(
             self.vcs.getPlugin().getPreferences("CommitIdLength")))
         if self.vcs.getPlugin().getPreferences("FindCopiesHarder"):
             args.append('--find-copies-harder')
         args.append('--format={0}'.format(self.__formatTemplate))
         args.append('--full-history')
         args.append('--all')
         args.append('--skip={0}'.format(skip))
         if not self.projectMode:
             if not self.stopCheckBox.isChecked():
                 args.append('--follow')
             args.append('--')
             args.append(self.__filename)
         self.__process.kill()
         self.__process.setWorkingDirectory(self.repodir)
         self.__process.start('git', args)
         procStarted = self.__process.waitForStarted(5000)
         if not procStarted:
             self.inputGroup.setEnabled(False)
             self.inputGroup.hide()
             E5MessageBox.critical(
                 self,
                 self.tr('Process Generation Error'),
                 self.tr(
                     'The process {0} could not be started. '
                     'Ensure, that it is in the search path.'
                 ).format('git'))
     def start(self, fn, isFile=False, noEntries=0):
         """
         Public slot to start the git log command.
         @param fn filename to show the log for (string)
         @keyparam isFile flag indicating log for a file is to be shown
             (boolean)
         @keyparam noEntries number of entries to get (0 = default) (int)
         """
         self.__isFile = isFile
         self.sbsSelectLabel.clear()
         self.errorGroup.hide()
         QApplication.processEvents()
         self.__initData()
         self.__filename = fn
         self.dname, self.fname = self.vcs.splitPath(fn)
         # find the root of the repo
         self.repodir = self.dname
         while not os.path.isdir(os.path.join(self.repodir, self.vcs.adminDir)):
             self.repodir = os.path.dirname(self.repodir)
             if os.path.splitdrive(self.repodir)[1] == os.sep:
                 return
         self.projectMode = (self.fname == "." and self.dname == self.repodir)
         self.stopCheckBox.setDisabled(self.projectMode or self.fname == ".")
         self.activateWindow()
         self.raise_()
         self.logTree.clear()
         self.__started = True
         self.__identifyProject()
         self.__getLogEntries(noEntries=noEntries)
     def __procFinished(self, exitCode, exitStatus):
         """
         Private slot connected to the finished signal.
         @param exitCode exit code of the process (integer)
         @param exitStatus exit status of the process (QProcess.ExitStatus)
         """
         self.__processBuffer()
         self.__finish()
     def __finish(self):
         """
         Private slot called when the process finished or the user pressed
         the button.
         """
         if (
             self.__process is not None and
             self.__process.state() != QProcess.NotRunning
         ):
             self.__process.terminate()
             QTimer.singleShot(2000, self.__process.kill)
             self.__process.waitForFinished(3000)
         self.buttonBox.button(QDialogButtonBox.Close).setEnabled(True)
         self.buttonBox.button(QDialogButtonBox.Cancel).setEnabled(False)
         self.buttonBox.button(QDialogButtonBox.Close).setDefault(True)
         self.inputGroup.setEnabled(False)
         self.inputGroup.hide()
         self.refreshButton.setEnabled(True)
         while self.__finishCallbacks:
             self.__finishCallbacks.pop(0)()
     def __processBufferItem(self, logEntry):
         """
         Private method to process a log entry.
         @param logEntry dictionary as generated by __processBuffer
         """
         self.__generateLogItem(
             logEntry["author"], logEntry["authordate"],
             logEntry["committer"], logEntry["committerdate"],
             logEntry["subject"], logEntry["body"],
             logEntry["commit"], logEntry["changed_files"],
             logEntry["parents"], logEntry["refnames"],
             logEntry["authormail"], logEntry["committermail"]
         )
         for date in [logEntry["authordate"], logEntry["committerdate"]]:
             dt = QDate.fromString(date, Qt.ISODate)
             if (
                 not self.__maxDate.isValid() and
                 not self.__minDate.isValid()
             ):
                 self.__maxDate = dt
                 self.__minDate = dt
             else:
                 if self.__maxDate < dt:
                     self.__maxDate = dt
                 if self.__minDate > dt:
                     self.__minDate = dt
     def __processBuffer(self):
         """
         Private method to process the buffered output of the git log command.
         """
         noEntries = 0
         logEntry = {"changed_files": []}
         descriptionBody = False
         for line in self.buf:
             line = line.rstrip()
             if line == "recordstart":
                 if len(logEntry) > 1:
                     self.__processBufferItem(logEntry)
                     noEntries += 1
                 logEntry = {"changed_files": []}
                 descriptionBody = False
                 fileChanges = False
                 body = []
             elif line == "bodystart":
                 descriptionBody = True
             elif line == "bodyend":
                 if bool(body) and not bool(body[-1]):
                     body.pop()
                 logEntry["body"] = body
                 descriptionBody = False
                 fileChanges = True
             elif descriptionBody:
                 body.append(line)
             elif fileChanges:
                 if line:
                     if "changed_files" not in logEntry:
                         logEntry["changed_files"] = []
                     changeInfo = line.strip().split("\t")
                     if "=>" in changeInfo[2]:
                         # copy/move
                         if "{" in changeInfo[2] and "}" in changeInfo[2]:
                             # change info of the form
                             # test/{pack1 => pack2}/file1.py
                             head, tail = changeInfo[2].split("{", 1)
                             middle, tail = tail.split("}", 1)
                             middleSrc, middleDst = middle.split("=>")
                             src = head + middleSrc.strip() + tail
                             dst = head + middleDst.strip() + tail
                         else:
                             src, dst = changeInfo[2].split("=>")
                         logEntry["changed_files"].append({
                             "action": "C",
                             "added": changeInfo[0].strip(),
                             "deleted": changeInfo[1].strip(),
                             "path": dst.strip(),
                             "copyfrom": src.strip(),
                         })
                     else:
                         logEntry["changed_files"].append({
                             "action": "M",
                             "added": changeInfo[0].strip(),
                             "deleted": changeInfo[1].strip(),
                             "path": changeInfo[2].strip(),
                             "copyfrom": "",
                         })
             else:
                 try:
                     key, value = line.split("|", 1)
                 except ValueError:
                     key = ""
                     value = line
                 if key in ("commit", "parents", "author", "authormail",
                            "authordate", "committer", "committermail",
                            "committerdate", "refnames", "subject"):
                     logEntry[key] = value.strip()
         if len(logEntry) > 1:
             self.__processBufferItem(logEntry)
             noEntries += 1
         self.__resizeColumnsLog()
         if self.__started:
             if self.__selectedCommitIDs:
                 self.logTree.setCurrentItem(self.logTree.findItems(
                     self.__selectedCommitIDs[0], Qt.MatchExactly,
                     self.CommitIdColumn)[0])
             else:
                 self.logTree.setCurrentItem(self.logTree.topLevelItem(0))
             self.__started = False
         self.__skipEntries += noEntries
         if noEntries < self.limitSpinBox.value() and not self.cancelled:
             self.nextButton.setEnabled(False)
             self.limitSpinBox.setEnabled(False)
         else:
             self.nextButton.setEnabled(True)
             self.limitSpinBox.setEnabled(True)
         # update the log filters
         self.__filterLogsEnabled = False
         self.fromDate.setMinimumDate(self.__minDate)
         self.fromDate.setMaximumDate(self.__maxDate)
         self.fromDate.setDate(self.__minDate)
         self.toDate.setMinimumDate(self.__minDate)
         self.toDate.setMaximumDate(self.__maxDate)
         self.toDate.setDate(self.__maxDate)
         self.__filterLogsEnabled = True
         if self.__actionMode() == "filter":
             self.__filterLogs()
         self.__updateToolMenuActions()
         # restore selected items
         if self.__selectedCommitIDs:
             for commitID in self.__selectedCommitIDs:
                 items = self.logTree.findItems(
                     commitID, Qt.MatchExactly, self.CommitIdColumn)
                 if items:
                     items[0].setSelected(True)
             self.__selectedCommitIDs = []
     def __readStdout(self):
         """
         Private slot to handle the readyReadStandardOutput signal.
         It reads the output of the process and inserts it into a buffer.
         """
         self.__process.setReadChannel(QProcess.StandardOutput)
         while self.__process.canReadLine():
             line = str(self.__process.readLine(),
                        Preferences.getSystem("IOEncoding"),
                        'replace')
             self.buf.append(line)
     def __readStderr(self):
         """
         Private slot to handle the readyReadStandardError signal.
         It reads the error output of the process and inserts it into the
         error pane.
         """
         if self.__process is not None:
             s = str(self.__process.readAllStandardError(),
                     Preferences.getSystem("IOEncoding"),
                     'replace')
             self.__showError(s)
     def __showError(self, out):
         """
         Private slot to show some error.
         @param out error to be shown (string)
         """
         self.errorGroup.show()
         self.errors.insertPlainText(out)
         self.errors.ensureCursorVisible()
         # show input in case the process asked for some input
         self.inputGroup.setEnabled(True)
         self.inputGroup.show()
     def on_buttonBox_clicked(self, button):
         """
         Private slot called by a button of the button box clicked.
         @param button button that was clicked (QAbstractButton)
         """
         if button == self.buttonBox.button(QDialogButtonBox.Close):
             self.close()
 baf6da1ae288
Added the git plug-in to the core plug-ins.

Detlev Offenbach <detlev@die-offenbach&

Mercurial Repositories > eric / annotate

eric6/Plugins/VcsPlugins/vcsGit/GitLogBrowserDialog.py@8a96736d465e (annotated)

eric6/Plugins/VcsPlugins/vcsGit/GitLogBrowserDialog.py