mercurial: comparison mercurial/crecord.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 patch as patchmod,
 pycompat,
 scmutil,
 util,
 )
-from .utils import (
+from .utils import stringutil
-stringutil,
-)
 stringio = util.stringio
 # patch comments based on the git one
-diffhelptext = _("""# To remove '-' lines, make them ' ' lines (context).
+diffhelptext = _(
+"""# To remove '-' lines, make them ' ' lines (context).
 # To remove '+' lines, delete them.
 # Lines starting with # will be removed from the patch.
-""")
+"""
+)
-hunkhelptext = _("""#
+hunkhelptext = _(
+"""#
 # If the patch applies cleanly, the edited hunk will immediately be
 # added to the record list. If it does not apply cleanly, a rejects file
 # will be generated. You can use that when you try again. If all lines
 # of the hunk are removed, then the edit is aborted and the hunk is left
 # unchanged.
-""")
+"""
+)
-patchhelptext = _("""#
+patchhelptext = _(
+"""#
 # If the patch applies cleanly, the edited patch will immediately
 # be finalised. If it does not apply cleanly, rejects files will be
 # generated. You can use those when you try again.
-""")
+"""
+)
 try:
 import curses
 curses.error
 except ImportError:
 # I have no idea if wcurses works with crecord...
 try:
 import wcurses as curses
 curses.error
 except ImportError:
 # wcurses is not shipped on Windows by default, or python is not
 # compiled with curses
 curses = False
 class fallbackerror(error.Abort):
 """Error that indicates the client should try to fallback to text mode."""
 # Inherits from error.Abort so that existing behavior is preserved if the
 # calling code does not know how to fallback.
 def checkcurses(ui):
 """Return True if the user wants to use curses
 This method returns True if curses is found (and that python is built with
 it) and that the user has the correct flag for the ui.
 """
 return curses and ui.interface("chunkselector") == "curses"
 class patchnode(object):
 """abstract class for patch graph nodes
 (i.e. patchroot, header, hunk, hunkline)
 """
 return item
 # else return grandparent's next sibling (or None)
 return self.parentitem().parentitem().nextsibling()
-except AttributeError: # parent and/or grandparent was None
+except AttributeError:  # parent and/or grandparent was None
 return None
 def previtem(self):
 """
 Try to return the previous item closest to this item, regardless of
 # try previous sibling's last child's last child,
 # else try previous sibling's last child, else try previous sibling
 prevsibling = self.prevsibling()
 if prevsibling is not None:
 prevsiblinglastchild = prevsibling.lastchild()
-if ((prevsiblinglastchild is not None) and
+if (prevsiblinglastchild is not None) and not prevsibling.folded:
-not prevsibling.folded):
 prevsiblinglclc = prevsiblinglastchild.lastchild()
-if ((prevsiblinglclc is not None) and
+if (
-not prevsiblinglastchild.folded):
+prevsiblinglclc is not None
+) and not prevsiblinglastchild.folded:
 return prevsiblinglclc
 else:
 return prevsiblinglastchild
 else:
 return prevsibling
 # try parent (or None)
 return self.parentitem()
-class patch(patchnode, list): # todo: rename patchroot
+class patch(patchnode, list):  # todo: rename patchroot
 """
 list of header objects representing the patch.
 """
 def __init__(self, headerlist):
 self.extend(headerlist)
 # add parent patch object reference to each header
 for header in self:
 header.patch = self
 class uiheader(patchnode):
 """patch header
 xxx shouldn't we move this to mercurial/patch.py ?
 return self.hunks
 def __getattr__(self, name):
 return getattr(self.nonuiheader, name)
 class uihunkline(patchnode):
 "represents a changed line in a hunk"
 def __init__(self, linetext, hunk):
 self.linetext = linetext
 self.applied = True
 # the parent hunk to which this line belongs
 self.hunk = hunk
 def nextsibling(self):
 numlinesinhunk = len(self.hunk.changedlines)
 indexofthisline = self.hunk.changedlines.index(self)
-if (indexofthisline < numlinesinhunk - 1):
+if indexofthisline < numlinesinhunk - 1:
 nextline = self.hunk.changedlines[indexofthisline + 1]
 return nextline
 else:
 return None
 def lastchild(self):
 "return the last child of this item, if one exists.  otherwise None."
 # hunk-lines don't have children
 return None
 class uihunk(patchnode):
 """ui patch hunk, wraps a hunk and keep track of ui behavior """
 maxcontext = 3
 def __init__(self, hunk, header):
 self._hunk = hunk
 self.changedlines = [uihunkline(line, self) for line in hunk.hunk]
 def nextsibling(self):
 numhunksinheader = len(self.header.hunks)
 indexofthishunk = self.header.hunks.index(self)
-if (indexofthishunk < numhunksinheader - 1):
+if indexofthishunk < numhunksinheader - 1:
 nexthunk = self.header.hunks[indexofthishunk + 1]
 return nexthunk
 else:
 return None
 "return a list of all of the direct children of this node"
 return self.changedlines
 def countchanges(self):
 """changedlines -> (n+,n-)"""
-add = len([l for l in self.changedlines if l.applied
+add = len(
-and l.prettystr().startswith('+')])
+[
-rem = len([l for l in self.changedlines if l.applied
+l
-and l.prettystr().startswith('-')])
+for l in self.changedlines
+if l.applied and l.prettystr().startswith('+')
+]
+)
+rem = len(
+[
+l
+for l in self.changedlines
+if l.applied and l.prettystr().startswith('-')
+]
+)
 return add, rem
 def getfromtoline(self):
 # calculate the number of removed lines converted to context lines
 removedconvertedtocontext = self.originalremoved - self.removed
-contextlen = (len(self.before) + len(self.after) +
+contextlen = (
-removedconvertedtocontext)
+len(self.before) + len(self.after) + removedconvertedtocontext
+)
 if self.after and self.after[-1] == '\\ No newline at end of file\n':
 contextlen -= 1
 fromlen = contextlen + self.removed
 tolen = contextlen + self.added
 fromline -= 1
 if tolen == 0 and toline > 0:
 toline -= 1
 fromtoline = '@@ -%d,%d +%d,%d @@%s\n' % (
-fromline, fromlen, toline, tolen,
+fromline,
-self.proc and (' ' + self.proc))
+fromlen,
+toline,
+tolen,
+self.proc and (' ' + self.proc),
+)
 return fromtoline
 def write(self, fp):
 # updated self.added/removed, which are used by getfromtoline()
 self.added, self.removed = self.countchanges()
 elif text.startswith('+'):
 dels.append(text[1:])
 adds.append(text[1:])
 hunk = ['-%s' % l for l in dels] + ['+%s' % l for l in adds]
 h = self._hunk
-return patchmod.recordhunk(h.header, h.toline, h.fromline, h.proc,
+return patchmod.recordhunk(
-h.before, hunk, h.after)
+h.header, h.toline, h.fromline, h.proc, h.before, hunk, h.after
+)
 def __getattr__(self, name):
 return getattr(self._hunk, name)
 def __repr__(self):
 return r'<hunk %r@%d>' % (self.filename(), self.fromline)
 def filterpatch(ui, chunks, chunkselector, operation=None):
 """interactively filter patch chunks into applied-only chunks"""
 chunks = list(chunks)
 # convert chunks list into structure suitable for displaying/modifying
 # let user choose headers/hunks/lines, and mark their applied flags
 # accordingly
 ret = chunkselector(ui, uiheaders, operation=operation)
 appliedhunklist = []
 for hdr in uiheaders:
-if (hdr.applied and
+if hdr.applied and (
-(hdr.special() or len([h for h in hdr.hunks if h.applied]) > 0)):
+hdr.special() or len([h for h in hdr.hunks if h.applied]) > 0
+):
 appliedhunklist.append(hdr)
 fixoffset = 0
 for hnk in hdr.hunks:
 if hnk.applied:
 appliedhunklist.append(hnk)
 # adjust the 'to'-line offset of the hunk to be correct
 # after de-activating some of the other hunks for this file
 if fixoffset:
-#hnk = copy.copy(hnk) # necessary??
+# hnk = copy.copy(hnk) # necessary??
 hnk.toline += fixoffset
 else:
 fixoffset += hnk.removed - hnk.added
 return (appliedhunklist, ret)
 def chunkselector(ui, headerlist, operation=None):
 """
 curses interface to get selection of chunks, and mark the applied flags
 of the chosen chunks.
 finally:
 if origsigtstp is not sentinel:
 signal.signal(signal.SIGTSTP, origsigtstp)
 return chunkselector.opts
 def testdecorator(testfn, f):
 def u(*args, **kwargs):
 return f(testfn, *args, **kwargs)
 return u
 def testchunkselector(testfn, ui, headerlist, operation=None):
 """
 test interface to get selection of chunks, and mark the applied flags
 of the chosen chunks.
 chunkselector = curseschunkselector(headerlist, ui, operation)
 class dummystdscr(object):
 def clear(self):
 pass
 def refresh(self):
 pass
 chunkselector.stdscr = dummystdscr()
 if testfn and os.path.exists(testfn):
 while True:
 if chunkselector.handlekeypressed(testcommands.pop(0), test=True):
 break
 return chunkselector.opts
-_headermessages = { # {operation: text}
+_headermessages = {  # {operation: text}
 'apply': _('Select hunks to apply'),
 'discard': _('Select hunks to discard'),
 'keep': _('Select hunks to keep'),
 None: _('Select hunks to record'),
 }
 class curseschunkselector(object):
 def __init__(self, headerlist, ui, operation=None):
 # put the headers into a patch object
 self.headerlist = patch(headerlist)
 most-indented level.  for example, if a hunk is selected, select
 the first hunkline of the selected hunk.  or, if the last hunkline of
 a hunk is currently selected, then select the next hunk, if one exists,
 or if not, the next header if one exists.
 """
-#self.startprintline += 1 #debug
+# self.startprintline += 1 #debug
 currentitem = self.currentselecteditem
 nextitem = currentitem.nextitem()
 # if there's no next item, keep the selection as-is
 if nextitem is None:
 siblingappliedstatus = [hnk.applied for hnk in item.header.hunks]
 allsiblingsapplied = not (False in siblingappliedstatus)
 nosiblingsapplied = not (True in siblingappliedstatus)
 siblingspartialstatus = [hnk.partial for hnk in item.header.hunks]
-somesiblingspartial = (True in siblingspartialstatus)
+somesiblingspartial = True in siblingspartialstatus
-#cases where applied or partial should be removed from header
+# cases where applied or partial should be removed from header
 # if no 'sibling' hunks are applied (including this hunk)
 if nosiblingsapplied:
 if not item.header.special():
 item.header.applied = False
 item.header.partial = False
-else: # some/all parent siblings are applied
+else:  # some/all parent siblings are applied
 item.header.applied = True
-item.header.partial = (somesiblingspartial or
+item.header.partial = (
-not allsiblingsapplied)
+somesiblingspartial or not allsiblingsapplied
+)
 elif isinstance(item, uihunkline):
 siblingappliedstatus = [ln.applied for ln in item.hunk.changedlines]
 allsiblingsapplied = not (False in siblingappliedstatus)
 nosiblingsapplied = not (True in siblingappliedstatus)
 item.hunk.applied = False
 item.hunk.partial = False
 elif allsiblingsapplied:
 item.hunk.applied = True
 item.hunk.partial = False
-else: # some siblings applied
+else:  # some siblings applied
 item.hunk.applied = True
 item.hunk.partial = True
-parentsiblingsapplied = [hnk.applied for hnk
+parentsiblingsapplied = [
-in item.hunk.header.hunks]
+hnk.applied for hnk in item.hunk.header.hunks
+]
 noparentsiblingsapplied = not (True in parentsiblingsapplied)
 allparentsiblingsapplied = not (False in parentsiblingsapplied)
-parentsiblingspartial = [hnk.partial for hnk
+parentsiblingspartial = [
-in item.hunk.header.hunks]
+hnk.partial for hnk in item.hunk.header.hunks
-someparentsiblingspartial = (True in parentsiblingspartial)
+]
+someparentsiblingspartial = True in parentsiblingspartial
 # if all parent hunks are not applied, un-apply header
 if noparentsiblingsapplied:
 if not item.hunk.header.special():
 item.hunk.header.applied = False
 item.hunk.header.partial = False
 # set the applied and partial status of the header if needed
-else: # some/all parent siblings are applied
+else:  # some/all parent siblings are applied
 item.hunk.header.applied = True
-item.hunk.header.partial = (someparentsiblingspartial or
+item.hunk.header.partial = (
-not allparentsiblingsapplied)
+someparentsiblingspartial or not allparentsiblingsapplied
+)
 def toggleall(self):
 "toggle the applied flag of all items."
-if self.waslasttoggleallapplied: # then unapply them this time
+if self.waslasttoggleallapplied:  # then unapply them this time
 for item in self.headerlist:
 if item.applied:
 self.toggleapply(item)
 else:
 for item in self.headerlist:
 self.toggleapply(item)
 self.waslasttoggleallapplied = not self.waslasttoggleallapplied
 def toggleallbetween(self):
 "toggle applied on or off for all items in range [lastapplied,current]."
-if (not self.lastapplieditem or
+if (
-self.currentselecteditem == self.lastapplieditem):
+not self.lastapplieditem
+or self.currentselecteditem == self.lastapplieditem
+):
 # Treat this like a normal 'x'/' '
 self.toggleapply()
 return
 startitem = self.lastapplieditem
 self.currentselecteditem = item = item.parentitem()
 elif item.neverunfolded:
 item.neverunfolded = False
 # also fold any foldable children of the parent/current item
-if isinstance(item, uiheader): # the original or 'new' item
+if isinstance(item, uiheader):  # the original or 'new' item
 for child in item.allchildren():
 child.folded = not item.folded
 if isinstance(item, (uiheader, uihunk)):
 item.folded = not item.folded
 y, xstart = window.getyx()
 width = self.xscreensize
 # turn tabs into spaces
 instr = instr.expandtabs(4)
 strwidth = encoding.colwidth(instr)
-numspaces = (width - ((strwidth + xstart) % width))
+numspaces = width - ((strwidth + xstart) % width)
 return instr + " " * numspaces
-def printstring(self, window, text, fgcolor=None, bgcolor=None, pair=None,
+def printstring(
-pairname=None, attrlist=None, towin=True, align=True, showwhtspc=False):
+self,
+window,
+text,
+fgcolor=None,
+bgcolor=None,
+pair=None,
+pairname=None,
+attrlist=None,
+towin=True,
+align=True,
+showwhtspc=False,
+):
 """
 print the string, text, with the specified colors and attributes, to
 the specified curses window object.
 the foreground and background colors are of the form
 if showwhtspc == True, trailing whitespace of a string is highlighted.
 """
 # preprocess the text, converting tabs to spaces
 text = text.expandtabs(4)
 # strip \n, and convert control characters to ^[char] representation
-text = re.sub(br'[\x00-\x08\x0a-\x1f]',
+text = re.sub(
-lambda m:'^' + chr(ord(m.group()) + 64), text.strip('\n'))
+br'[\x00-\x08\x0a-\x1f]',
+lambda m: '^' + chr(ord(m.group()) + 64),
+text.strip('\n'),
+)
 if pair is not None:
 colorpair = pair
 elif pairname is not None:
 colorpair = self.colorpairnames[pairname]
 for textattr in (curses.A_UNDERLINE, curses.A_BOLD):
 if textattr in attrlist:
 colorpair |= textattr
 y, xstart = self.chunkpad.getyx()
-t = "" # variable for counting lines printed
+t = ""  # variable for counting lines printed
 # if requested, show trailing whitespace
 if showwhtspc:
 origlen = len(text)
-text = text.rstrip(' \n') # tabs have already been expanded
+text = text.rstrip(' \n')  # tabs have already been expanded
 strippedlen = len(text)
 numtrailingspaces = origlen - strippedlen
 if towin:
 window.addstr(text, colorpair)
 t += text
 if showwhtspc:
 wscolorpair = colorpair | curses.A_REVERSE
 if towin:
 for i in range(numtrailingspaces):
 window.addch(curses.ACS_CKBOARD, wscolorpair)
 t += " " * numtrailingspaces
 if align:
 if towin:
 extrawhitespace = self.alignstring("", window)
 window.addstr(extrawhitespace, colorpair)
 spaceselect = _('space/enter: select')
 spacedeselect = _('space/enter: deselect')
 # Format the selected label into a place as long as the longer of the
 # two possible labels.  This may vary by language.
 spacelen = max(len(spaceselect), len(spacedeselect))
-selectedlabel = '%-*s' % (spacelen,
+selectedlabel = '%-*s' % (
-spacedeselect if selected else spaceselect)
+spacelen,
+spacedeselect if selected else spaceselect,
+)
 segments = [
 _headermessages[self.operation],
 '-',
 _('[x]=selected **=collapsed'),
 _('c: confirm'),
 # print out the patch in the remaining part of the window
 try:
 self.printitem()
 self.updatescroll()
-self.chunkpad.refresh(self.firstlineofpadtoprint, 0,
+self.chunkpad.refresh(
-self.numstatuslines, 0,
+self.firstlineofpadtoprint,
-self.yscreensize - self.numstatuslines,
+0,
-self.xscreensize)
+self.numstatuslines,
+0,
+self.yscreensize - self.numstatuslines,
+self.xscreensize,
+)
 except curses.error:
 pass
 def getstatusprefixstring(self, item):
 """
 else:
 checkbox += "  "
 if isinstance(item, uiheader):
 # add two more spaces for headers
 checkbox += "  "
-except AttributeError: # not foldable
+except AttributeError:  # not foldable
 checkbox += "  "
 return checkbox
-def printheader(self, header, selected=False, towin=True,
+def printheader(
-ignorefolding=False):
+self, header, selected=False, towin=True, ignorefolding=False
+):
 """
 print the header to the pad.  if countlines is True, don't print
 anything, but just count the number of lines which would be printed.
 """
 text = header.prettystr()
 chunkindex = self.chunklist.index(header)
 if chunkindex != 0 and not header.folded:
 # add separating line before headers
-outstr += self.printstring(self.chunkpad, '_' * self.xscreensize,
+outstr += self.printstring(
-towin=towin, align=False)
+self.chunkpad, '_' * self.xscreensize, towin=towin, align=False
+)
 # select color-pair based on if the header is selected
-colorpair = self.getcolorpair(name=selected and "selected" or "normal",
+colorpair = self.getcolorpair(
-attrlist=[curses.A_BOLD])
+name=selected and "selected" or "normal", attrlist=[curses.A_BOLD]
+)
 # print out each line of the chunk, expanding it to screen width
 # number of characters to indent lines on this level by
 indentnumchars = 0
 if not header.folded or ignorefolding:
 textlist = text.split("\n")
 linestr = checkbox + textlist[0]
 else:
 linestr = checkbox + header.filename()
-outstr += self.printstring(self.chunkpad, linestr, pair=colorpair,
+outstr += self.printstring(
-towin=towin)
+self.chunkpad, linestr, pair=colorpair, towin=towin
+)
 if not header.folded or ignorefolding:
 if len(textlist) > 1:
 for line in textlist[1:]:
-linestr = " "*(indentnumchars + len(checkbox)) + line
+linestr = " " * (indentnumchars + len(checkbox)) + line
-outstr += self.printstring(self.chunkpad, linestr,
+outstr += self.printstring(
-pair=colorpair, towin=towin)
+self.chunkpad, linestr, pair=colorpair, towin=towin
+)
 return outstr
-def printhunklinesbefore(self, hunk, selected=False, towin=True,
+def printhunklinesbefore(
-ignorefolding=False):
+self, hunk, selected=False, towin=True, ignorefolding=False
+):
 "includes start/end line indicator"
 outstr = ""
 # where hunk is in list of siblings
 hunkindex = hunk.header.hunks.index(hunk)
 if hunkindex != 0:
 # add separating line before headers
-outstr += self.printstring(self.chunkpad, ' '*self.xscreensize,
+outstr += self.printstring(
-towin=towin, align=False)
+self.chunkpad, ' ' * self.xscreensize, towin=towin, align=False
+)
-colorpair = self.getcolorpair(name=selected and "selected" or "normal",
-attrlist=[curses.A_BOLD])
+colorpair = self.getcolorpair(
+name=selected and "selected" or "normal", attrlist=[curses.A_BOLD]
+)
 # print out from-to line with checkbox
 checkbox = self.getstatusprefixstring(hunk)
-lineprefix = " "*self.hunkindentnumchars + checkbox
+lineprefix = " " * self.hunkindentnumchars + checkbox
 frtoline = "   " + hunk.getfromtoline().strip("\n")
-outstr += self.printstring(self.chunkpad, lineprefix, towin=towin,
+outstr += self.printstring(
-align=False) # add uncolored checkbox/indent
+self.chunkpad, lineprefix, towin=towin, align=False
-outstr += self.printstring(self.chunkpad, frtoline, pair=colorpair,
+)  # add uncolored checkbox/indent
-towin=towin)
+outstr += self.printstring(
+self.chunkpad, frtoline, pair=colorpair, towin=towin
+)
 if hunk.folded and not ignorefolding:
 # skip remainder of output
 return outstr
 # print out lines of the chunk preceeding changed-lines
 for line in hunk.before:
-linestr = " "*(self.hunklineindentnumchars + len(checkbox)) + line
+linestr = " " * (self.hunklineindentnumchars + len(checkbox)) + line
 outstr += self.printstring(self.chunkpad, linestr, towin=towin)
 return outstr
 def printhunklinesafter(self, hunk, towin=True, ignorefolding=False):
 return outstr
 # a bit superfluous, but to avoid hard-coding indent amount
 checkbox = self.getstatusprefixstring(hunk)
 for line in hunk.after:
-linestr = " "*(self.hunklineindentnumchars + len(checkbox)) + line
+linestr = " " * (self.hunklineindentnumchars + len(checkbox)) + line
 outstr += self.printstring(self.chunkpad, linestr, towin=towin)
 return outstr
 def printhunkchangedline(self, hunkline, selected=False, towin=True):
 elif linestr.startswith("-"):
 colorpair = self.getcolorpair(name="deletion")
 elif linestr.startswith("\\"):
 colorpair = self.getcolorpair(name="normal")
-lineprefix = " "*self.hunklineindentnumchars + checkbox
+lineprefix = " " * self.hunklineindentnumchars + checkbox
-outstr += self.printstring(self.chunkpad, lineprefix, towin=towin,
+outstr += self.printstring(
-align=False) # add uncolored checkbox/indent
+self.chunkpad, lineprefix, towin=towin, align=False
-outstr += self.printstring(self.chunkpad, linestr, pair=colorpair,
+)  # add uncolored checkbox/indent
-towin=towin, showwhtspc=True)
+outstr += self.printstring(
+self.chunkpad, linestr, pair=colorpair, towin=towin, showwhtspc=True
+)
 return outstr
-def printitem(self, item=None, ignorefolding=False, recursechildren=True,
+def printitem(
-towin=True):
+self, item=None, ignorefolding=False, recursechildren=True, towin=True
+):
 """
 use __printitem() to print the the specified item.applied.
 if item is not specified, then print the entire patch.
 (hiding folded elements, etc. -- see __printitem() docstring)
 """
 item = self.headerlist
 if recursechildren:
 self.linesprintedtopadsofar = 0
 outstr = []
-self.__printitem(item, ignorefolding, recursechildren, outstr,
+self.__printitem(
-towin=towin)
+item, ignorefolding, recursechildren, outstr, towin=towin
+)
 return ''.join(outstr)
 def outofdisplayedarea(self):
-y, _ = self.chunkpad.getyx() # cursor location
+y, _ = self.chunkpad.getyx()  # cursor location
 # * 2 here works but an optimization would be the max number of
 # consecutive non selectable lines
 # i.e the max number of context line for any hunk in the patch
 miny = min(0, self.firstlineofpadtoprint - self.yscreensize)
 maxy = self.firstlineofpadtoprint + self.yscreensize * 2
 return y < miny or y > maxy
 def handleselection(self, item, recursechildren):
-selected = (item is self.currentselecteditem)
+selected = item is self.currentselecteditem
 if selected and recursechildren:
 # assumes line numbering starting from line 0
 self.selecteditemstartline = self.linesprintedtopadsofar
-selecteditemlines = self.getnumlinesdisplayed(item,
+selecteditemlines = self.getnumlinesdisplayed(
-recursechildren=False)
+item, recursechildren=False
-self.selecteditemendline = (self.selecteditemstartline +
+)
-selecteditemlines - 1)
+self.selecteditemendline = (
+self.selecteditemstartline + selecteditemlines - 1
+)
 return selected
-def __printitem(self, item, ignorefolding, recursechildren, outstr,
+def __printitem(
-towin=True):
+self, item, ignorefolding, recursechildren, outstr, towin=True
+):
 """
 recursive method for printing out patch/header/hunk/hunk-line data to
 screen.  also returns a string with all of the content of the displayed
 patch (not including coloring, etc.).
 # patch object is a list of headers
 if isinstance(item, patch):
 if recursechildren:
 for hdr in item:
-self.__printitem(hdr, ignorefolding,
+self.__printitem(
-recursechildren, outstr, towin)
+hdr, ignorefolding, recursechildren, outstr, towin
+)
 # todo: eliminate all isinstance() calls
 if isinstance(item, uiheader):
-outstr.append(self.printheader(item, selected, towin=towin,
+outstr.append(
-ignorefolding=ignorefolding))
+self.printheader(
+item, selected, towin=towin, ignorefolding=ignorefolding
+)
+)
 if recursechildren:
 for hnk in item.hunks:
-self.__printitem(hnk, ignorefolding,
+self.__printitem(
-recursechildren, outstr, towin)
+hnk, ignorefolding, recursechildren, outstr, towin
-elif (isinstance(item, uihunk) and
+)
-((not item.header.folded) or ignorefolding)):
+elif isinstance(item, uihunk) and (
+(not item.header.folded) or ignorefolding
+):
 # print the hunk data which comes before the changed-lines
-outstr.append(self.printhunklinesbefore(item, selected, towin=towin,
+outstr.append(
-ignorefolding=ignorefolding))
+self.printhunklinesbefore(
+item, selected, towin=towin, ignorefolding=ignorefolding
+)
+)
 if recursechildren:
 for l in item.changedlines:
-self.__printitem(l, ignorefolding,
+self.__printitem(
-recursechildren, outstr, towin)
+l, ignorefolding, recursechildren, outstr, towin
-outstr.append(self.printhunklinesafter(item, towin=towin,
+)
-ignorefolding=ignorefolding))
+outstr.append(
-elif (isinstance(item, uihunkline) and
+self.printhunklinesafter(
-((not item.hunk.folded) or ignorefolding)):
+item, towin=towin, ignorefolding=ignorefolding
-outstr.append(self.printhunkchangedline(item, selected,
+)
-towin=towin))
+)
+elif isinstance(item, uihunkline) and (
+(not item.hunk.folded) or ignorefolding
+):
+outstr.append(
+self.printhunkchangedline(item, selected, towin=towin)
+)
 return outstr
-def getnumlinesdisplayed(self, item=None, ignorefolding=False,
+def getnumlinesdisplayed(
-recursechildren=True):
+self, item=None, ignorefolding=False, recursechildren=True
+):
 """
 return the number of lines which would be displayed if the item were
 to be printed to the display.  the item will not be printed to the
 display (pad).
 if no item is given, assume the entire patch.
 if ignorefolding is True, folded items will be unfolded when counting
 the number of lines.
 """
 # temporarily disable printing to windows by printstring
-patchdisplaystring = self.printitem(item, ignorefolding,
+patchdisplaystring = self.printitem(
-recursechildren, towin=False)
+item, ignorefolding, recursechildren, towin=False
+)
 numlines = len(patchdisplaystring) // self.xscreensize
 return numlines
 def sigwinchhandler(self, n, frame):
 "handle window resizing"
 self.numpadlines = self.getnumlinesdisplayed(ignorefolding=True) + 1
 self.chunkpad = curses.newpad(self.numpadlines, self.xscreensize)
 except curses.error:
 pass
-def getcolorpair(self, fgcolor=None, bgcolor=None, name=None,
+def getcolorpair(
-attrlist=None):
+self, fgcolor=None, bgcolor=None, name=None, attrlist=None
+):
 """
 get a curses color pair, adding it to self.colorpairs if it is not
 already defined.  an optional string, name, can be passed as a shortcut
 for referring to the color-pair.  by default, if no arguments are
 specified, the white foreground / black background color-pair is
 colorpair = self.colorpairs[(fgcolor, bgcolor)]
 else:
 pairindex = len(self.colorpairs) + 1
 if self.usecolor:
 curses.init_pair(pairindex, fgcolor, bgcolor)
-colorpair = self.colorpairs[(fgcolor, bgcolor)] = (
+colorpair = self.colorpairs[
-curses.color_pair(pairindex))
+(fgcolor, bgcolor)
+] = curses.color_pair(pairindex)
 if name is not None:
 self.colorpairnames[name] = curses.color_pair(pairindex)
 else:
 cval = 0
 if name is not None:
 e : edit the currently selected hunk
 a : toggle amend mode, only with commit -i
 c : confirm selected changes
 r : review/edit and confirm selected changes
 q : quit without confirming (no changes will be made)
-? : help (what you're currently reading)""")
+? : help (what you're currently reading)"""
+)
 helpwin = curses.newwin(self.yscreensize, 0, 0, 0)
 helplines = helptext.split("\n")
-helplines = helplines + [" "]*(
+helplines = helplines + [" "] * (
-self.yscreensize - self.numstatuslines - len(helplines) - 1)
+self.yscreensize - self.numstatuslines - len(helplines) - 1
+)
 try:
 for line in helplines:
 self.printstring(helpwin, line, pairname="legend")
 except curses.error:
 pass
 curses.def_prog_mode()
 curses.endwin()
 self.commenttext = self.ui.edit(self.commenttext, self.ui.username())
 curses.cbreak()
 self.stdscr.refresh()
-self.stdscr.keypad(1) # allow arrow-keys to continue to function
+self.stdscr.keypad(1)  # allow arrow-keys to continue to function
 def handlefirstlineevent(self):
 """
 Handle 'g' to navigate to the top most file in the ncurses window.
 """
 def reviewcommit(self):
 """ask for 'y' to be pressed to confirm selected. return True if
 confirmed."""
 confirmtext = _(
 """If you answer yes to the following, your currently chosen patch chunks
 will be loaded into an editor. To modify the patch, make the changes in your
 editor and save. To accept the current patch as-is, close the editor without
 saving.
 note: don't add/remove lines unless you also modify the range information.
 failing to follow this rule will result in the commit aborting.
 are you sure you want to review/edit and confirm the selected changes [yn]?
-""")
+"""
+)
 with self.ui.timeblockedsection('crecord'):
 response = self.confirmationwindow(confirmtext)
 if response is None:
 response = "n"
 if response.lower().startswith("y"):
 new changeset will be created (the normal commit behavior).
 """
 if opts.get('amend') is None:
 opts['amend'] = True
-msg = _("Amend option is turned on -- committing the currently "
+msg = _(
-"selected changes will not create a new changeset, but "
+"Amend option is turned on -- committing the currently "
-"instead update the most recently committed changeset.\n\n"
+"selected changes will not create a new changeset, but "
-"Press any key to continue.")
+"instead update the most recently committed changeset.\n\n"
+"Press any key to continue."
+)
 elif opts.get('amend') is True:
 opts['amend'] = None
-msg = _("Amend option is turned off -- committing the currently "
+msg = _(
-"selected changes will create a new changeset.\n\n"
+"Amend option is turned off -- committing the currently "
-"Press any key to continue.")
+"selected changes will create a new changeset.\n\n"
+"Press any key to continue."
+)
 if not test:
 self.confirmationwindow(msg)
 def recenterdisplayedarea(self):
 """
 def toggleedit(self, item=None, test=False):
 """
 edit the currently selected chunk
 """
 def updateui(self):
 self.numpadlines = self.getnumlinesdisplayed(ignorefolding=True) + 1
 self.chunkpad = curses.newpad(self.numpadlines, self.xscreensize)
 self.updatescroll()
 self.stdscr.refresh()
 finally:
 self.stdscr.clear()
 self.stdscr.refresh()
 # remove comment lines
-patch = [line + '\n' for line in patch.splitlines()
+patch = [
-if not line.startswith('#')]
+line + '\n'
+for line in patch.splitlines()
+if not line.startswith('#')
+]
 return patchmod.parsepatch(patch)
 if item is None:
 item = self.currentselecteditem
 if isinstance(item, uiheader):
 updateui(self)
 return
 header = item.header
 editedhunkindex = header.hunks.index(item)
 hunksbefore = header.hunks[:editedhunkindex]
-hunksafter = header.hunks[editedhunkindex + 1:]
+hunksafter = header.hunks[editedhunkindex + 1 :]
 newpatchheader = newpatches[0]
 newhunks = [uihunk(h, header) for h in newpatchheader.hunks]
 newadded = sum([h.added for h in newhunks])
 newremoved = sum([h.removed for h in newhunks])
 offset = (newadded - beforeadded) - (newremoved - beforeremoved)
 method to be wrapped by curses.wrapper() for selecting chunks.
 """
 origsigwinch = sentinel = object()
 if util.safehasattr(signal, 'SIGWINCH'):
-origsigwinch = signal.signal(signal.SIGWINCH,
+origsigwinch = signal.signal(signal.SIGWINCH, self.sigwinchhandler)
-self.sigwinchhandler)
 try:
 return self._main(stdscr)
 finally:
 if origsigwinch is not sentinel:
 signal.signal(signal.SIGWINCH, origsigwinch)
 pass
 # available colors: black, blue, cyan, green, magenta, white, yellow
 # init_pair(color_id, foreground_color, background_color)
 self.initcolorpair(None, None, name="normal")
-self.initcolorpair(curses.COLOR_WHITE, curses.COLOR_MAGENTA,
+self.initcolorpair(
-name="selected")
+curses.COLOR_WHITE, curses.COLOR_MAGENTA, name="selected"
+)
 self.initcolorpair(curses.COLOR_RED, None, name="deletion")
 self.initcolorpair(curses.COLOR_GREEN, None, name="addition")
 self.initcolorpair(curses.COLOR_WHITE, curses.COLOR_BLUE, name="legend")
 # newwin([height, width,] begin_y, begin_x)
 self.statuswin = curses.newwin(self.numstatuslines, 0, 0, 0)
-self.statuswin.keypad(1) # interpret arrow-key, etc. esc sequences
+self.statuswin.keypad(1)  # interpret arrow-key, etc. esc sequences
 # figure out how much space to allocate for the chunk-pad which is
 # used for displaying the patch
 # stupid hack to prevent getnumlinesdisplayed from failing
 try:
 self.chunkpad = curses.newpad(self.numpadlines, self.xscreensize)
 except curses.error:
 self.initexc = fallbackerror(
-_('this diff is too large to be displayed'))
+_('this diff is too large to be displayed')
+)
 return
 # initialize selecteditemendline (initial start-line is 0)
 self.selecteditemendline = self.getnumlinesdisplayed(
-self.currentselecteditem, recursechildren=False)
+self.currentselecteditem, recursechildren=False
+)
 while True:
 self.updatescreen()
 try:
 with self.ui.timeblockedsection('crecord'):
 keypressed = "foobar"
 if self.handlekeypressed(keypressed):
 break
 if self.commenttext != "":
-whitespaceremoved = re.sub(br"(?m)^\s.*(\n|$)", b"",
+whitespaceremoved = re.sub(
-self.commenttext)
+br"(?m)^\s.*(\n|$)", b"", self.commenttext
+)
 if whitespaceremoved != "":
 self.opts['message'] = self.commenttext

changeset 43076	2372284d9457
parent 42659	701341f57ceb
child 43077	687b865b95ad