mercurial: comparison mercurial/crecord.py

equal deleted inserted replaced

-:66d085e55ecd
+:f571ea254f75
 def nextsibling(self):
 """
 Return the closest next item of the same type where there are no items
 of different types between the current item and this closest item.
 If no such item exists, return None.
 """
 raise NotImplementedError("method must be implemented by subclass")
 def prevsibling(self):
 """
 Return the closest previous item of the same type where there are no
 items of different types between the current item and this closest item.
 If no such item exists, return None.
 """
 raise NotImplementedError("method must be implemented by subclass")
 def parentitem(self):
 raise NotImplementedError("method must be implemented by subclass")
 If skipFolded == True, and the current item is folded, then the child
 items that are hidden due to folding will be skipped when determining
 the next item.
 If it is not possible to get the next item, return None.
 """
 try:
 itemfolded = self.folded
 except AttributeError:
 itemfolded = False
 If skipFolded == True, and the current item is folded, then the items
 that are hidden due to folding will be skipped when determining the
 next item.
 If it is not possible to get the previous item, return None.
 """
 if constrainlevel:
 return self.prevsibling()
 else:
 # try previous sibling's last child's last child,
 return self.parentitem()
 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:
 magically get the current height and width of the window (without initscr)
 this is a rip-off of a rip-off - taken from the bpython code.  it is
 useful / necessary because otherwise curses.initscr() must be called,
 which can leave the terminal in a nasty state after exiting.
 """
 h, w = struct.unpack(
 "hhhh", fcntl.ioctl(_origstdout, termios.TIOCGWINSZ, "\000"*8))[0:2]
 return h, w
 def chunkselector(ui, headerlist):
 """
 curses interface to get selection of chunks, and mark the applied flags
 of the chosen chunks.
 """
 ui.write(_('starting interactive selection\n'))
 chunkselector = curseschunkselector(headerlist, ui)
 f = signal.getsignal(signal.SIGTSTP)
 curses.wrapper(chunkselector.main)
 def testchunkselector(testfn, ui, headerlist):
 """
 test interface to get selection of chunks, and mark the applied flags
 of the chosen chunks.
 """
 chunkselector = curseschunkselector(headerlist, ui)
 if testfn and os.path.exists(testfn):
 testf = open(testfn)
 testcommands = map(lambda x: x.rstrip('\n'), testf.readlines())
 the first hunkline of a hunk is currently selected, then select the
 hunk itself.
 if the currently selected item is already at the top of the screen,
 scroll the screen down to show the new-selected item.
 """
 currentitem = self.currentselecteditem
 nextitem = currentitem.previtem(constrainlevel=False)
 currently selected item.  otherwise, select (if possible) the
 parent-item of the currently selected item.
 if the currently selected item is already at the top of the screen,
 scroll the screen down to show the new-selected item.
 """
 currentitem = self.currentselecteditem
 nextitem = currentitem.previtem()
 # if there's no previous item on this level, try choosing the parent
 if nextitem is None:
 a hunk is currently selected, then select the next hunk, if one exists,
 or if not, the next header if one exists.
 if the currently selected item is already at the bottom of the screen,
 scroll the screen up to show the new-selected item.
 """
 #self.startprintline += 1 #debug
 currentitem = self.currentselecteditem
 nextitem = currentitem.nextitem(constrainlevel=False)
 def downarrowshiftevent(self):
 """
 if the cursor is already at the bottom chunk, scroll the screen up and
 move the cursor-position to the subsequent chunk.  otherwise, only move
 the cursor position down one chunk.
 """
 # todo: update docstring
 currentitem = self.currentselecteditem
 nextitem = currentitem.nextitem()
 self.currentselecteditem = nextitem
 def rightarrowevent(self):
 """
 select (if possible) the first of this item's child-items.
 """
 currentitem = self.currentselecteditem
 nextitem = currentitem.firstchild()
 # turn off folding if we want to show a child-item
 def leftarrowevent(self):
 """
 if the current item can be folded (i.e. it is an unfolded header or
 hunk), then fold it.  otherwise try select (if possible) the parent
 of this item.
 """
 currentitem = self.currentselecteditem
 # try to fold the item
 if not isinstance(currentitem, uihunkline):
 def leftarrowshiftevent(self):
 """
 select the header of the current item (or fold current item if the
 current item is already a header).
 """
 currentitem = self.currentselecteditem
 if isinstance(currentitem, uiheader):
 if not currentitem.folded:
 def toggleapply(self, item=None):
 """
 toggle the applied flag of the specified item.  if no item is specified,
 toggle the flag of the currently selected item.
 """
 if item is None:
 item = self.currentselecteditem
 item.applied = not item.applied
 """
 add whitespace to the end of a string in order to make it fill
 the screen in the x direction.  the current cursor position is
 taken into account when making this calculation.  the string can span
 multiple lines.
 """
 y, xstart = window.getyx()
 width = self.xscreensize
 # turn tabs into spaces
 instr = instr.expandtabs(4)
 if align == True, whitespace is added to the printed string such that
 the string stretches to the right border of the window.
 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(r'[\x00-\x08\x0a-\x1f]',
 def getstatusprefixstring(self, item):
 """
 create a string to prefix a line with which indicates whether 'item'
 is applied and/or folded.
+"""
-"""
 # create checkbox string
 if item.applied:
 if not isinstance(item, uihunkline) and item.partial:
 checkbox = "[~]"
 else:
 def printheader(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.
+"""
-"""
 outstr = ""
 text = header.prettystr()
 chunkindex = self.chunklist.index(header)
 if chunkindex != 0 and not header.folded:
 """
 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)
 """
 if item is None:
 item = self.headerlist
 if recursechildren:
 self.linesprintedtopadsofar = 0
 if ignorefolding is True, then folded items are printed out.
 if recursechildren is False, then only print the item without its
 child items.
+"""
-"""
 if towin and self.outofdisplayedarea():
 return
 selected = self.handleselection(item, recursechildren)
 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,
 recursechildren, towin=False)
 numlines = len(patchdisplaystring) / self.xscreensize
 return numlines
 initializing color pairs, and not curses.init_pair().
 attrlist is used to 'flavor' the returned color-pair.  this information
 is not stored in self.colorpairs.  it contains attribute values like
 curses.A_BOLD.
+"""
-"""
 if (name is not None) and name in self.colorpairnames:
 # then get the associated color pair and return it
 colorpair = self.colorpairnames[name]
 else:
 if fgcolor is None:
 """Toggle the amend flag.
 When the amend flag is set, a commit will modify the most recently
 committed changeset, instead of creating a new changeset.  Otherwise, a
 new changeset will be created (the normal commit behavior).
+"""
-"""
 try:
 ver = float(util.version()[:3])
 except ValueError:
 ver = 1
 if ver < 2.19:
 self.stdscr.refresh()
 def main(self, stdscr):
 """
 method to be wrapped by curses.wrapper() for selecting chunks.
+"""
-"""
 signal.signal(signal.SIGWINCH, self.sigwinchhandler)
 self.stdscr = stdscr
 # error during initialization, cannot be printed in the curses
 # interface, it should be printed by the calling code
 self.initerr = None

changeset 28579	f571ea254f75
parent 28543	f7874de435c5
child 28580	8b41ad798fb7