record: add default value for operation argument

This patch is part of a series of patches to change the recording ui to reflect
the operation currently running (commit, shelve, revert ...).
This patch adds the default value of the operation argument for record's
standard and curses interface to match what is displayed in the interface
as of today.

mercurial/crecord.py

@@ -1,1601 +1,1603 b''
 # stuff related specifically to patch manipulation / parsing
 #
 # Copyright 2008 Mark Edgington <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 #
 # This code is based on the Mark Edgington's crecord extension.
 # (Itself based on Bryan O'Sullivan's record extension.)
 
 from i18n import _
 import patch as patchmod
 import util, encoding
 
 import os, re, sys, struct, signal, tempfile, locale, cStringIO
 
 # This is required for ncurses to display non-ASCII characters in default user
 # locale encoding correctly.  --immerrr
 locale.setlocale(locale.LC_ALL, '')
 
 # os.name is one of: 'posix', 'nt', 'dos', 'os2', 'mac', or 'ce'
 if os.name == 'posix':
     import curses
     import fcntl, termios
 else:
     # I have no idea if wcurses works with crecord...
     try:
         import wcurses as curses
     except ImportError:
         # wcurses is not shipped on Windows by default
         pass
 
 try:
     curses
 except NameError:
     if os.name != 'nt':  # Temporary hack to get running on Windows again
         raise util.Abort(
             _('the python curses/wcurses module is not available/installed'))
 
 _origstdout = sys.__stdout__ # used by gethw()
 
 class patchnode(object):
     """abstract class for patch graph nodes
     (i.e. patchroot, header, hunk, hunkline)
     """
 
     def firstchild(self):
         raise NotImplementedError("method must be implemented by subclass")
 
     def lastchild(self):
         raise NotImplementedError("method must be implemented by subclass")
 
     def allchildren(self):
         "Return a list of all of the direct children of this node"
         raise NotImplementedError("method must be implemented by subclass")
     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")
 
 
     def nextitem(self, constrainlevel=True, skipfolded=True):
         """
         If constrainLevel == True, 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 constrainLevel == False, then try to return the next item
         closest to this item, regardless of item's type (header, hunk, or
         HunkLine).
 
         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 constrainlevel:
             return self.nextsibling()
         elif skipfolded and itemfolded:
             nextitem = self.nextsibling()
             if nextitem is None:
                 try:
                     nextitem = self.parentitem().nextsibling()
                 except AttributeError:
                     nextitem = None
             return nextitem
         else:
             # try child
             item = self.firstchild()
             if item is not None:
                 return item
 
             # else try next sibling
             item = self.nextsibling()
             if item is not None:
                 return item
 
             try:
                 # else try parent's next sibling
                 item = self.parentitem().nextsibling()
                 if item is not None:
                     return item
 
                 # else return grandparent's next sibling (or None)
                 return self.parentitem().parentitem().nextsibling()
 
             except AttributeError: # parent and/or grandparent was None
                 return None
 
     def previtem(self, constrainlevel=True, skipfolded=True):
         """
         If constrainLevel == True, 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 constrainLevel == False, then try to return the previous item
         closest to this item, regardless of item's type (header, hunk, or
         HunkLine).
 
         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,
             # 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
                     not prevsibling.folded):
                     prevsiblinglclc = prevsiblinglastchild.lastchild()
                     if ((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
     """
     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 shoudn't we move this to mercurial/patch.py ?
     """
 
     def __init__(self, header):
         self.nonuiheader = header
         # flag to indicate whether to apply this chunk
         self.applied = True
         # flag which only affects the status display indicating if a node's
         # children are partially applied (i.e. some applied, some not).
         self.partial = False
 
         # flag to indicate whether to display as folded/unfolded to user
         self.folded = True
 
         # list of all headers in patch
         self.patch = None
 
         # flag is False if this header was ever unfolded from initial state
         self.neverunfolded = True
         self.hunks = [uihunk(h, self) for h in self.hunks]
 
 
     def prettystr(self):
         x = cStringIO.StringIO()
         self.pretty(x)
         return x.getvalue()
 
     def nextsibling(self):
         numheadersinpatch = len(self.patch)
         indexofthisheader = self.patch.index(self)
 
         if indexofthisheader < numheadersinpatch - 1:
             nextheader = self.patch[indexofthisheader + 1]
             return nextheader
         else:
             return None
 
     def prevsibling(self):
         indexofthisheader = self.patch.index(self)
         if indexofthisheader > 0:
             previousheader = self.patch[indexofthisheader - 1]
             return previousheader
         else:
             return None
 
     def parentitem(self):
         """
         there is no 'real' parent item of a header that can be selected,
         so return None.
         """
         return None
 
     def firstchild(self):
         "return the first child of this item, if one exists.  otherwise None."
         if len(self.hunks) > 0:
             return self.hunks[0]
         else:
             return None
 
     def lastchild(self):
         "return the last child of this item, if one exists.  otherwise None."
         if len(self.hunks) > 0:
             return self.hunks[-1]
         else:
             return None
 
     def allchildren(self):
         "return a list of all of the direct children of this node"
         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
         # folding lines currently is not used/needed, but this flag is needed
         # in the previtem method.
         self.folded = False
 
     def prettystr(self):
         return self.linetext
 
     def nextsibling(self):
         numlinesinhunk = len(self.hunk.changedlines)
         indexofthisline = self.hunk.changedlines.index(self)
 
         if (indexofthisline < numlinesinhunk - 1):
             nextline = self.hunk.changedlines[indexofthisline + 1]
             return nextline
         else:
             return None
 
     def prevsibling(self):
         indexofthisline = self.hunk.changedlines.index(self)
         if indexofthisline > 0:
             previousline = self.hunk.changedlines[indexofthisline - 1]
             return previousline
         else:
             return None
 
     def parentitem(self):
         "return the parent to the current item"
         return self.hunk
 
     def firstchild(self):
         "return the first child of this item, if one exists.  otherwise None."
         # hunk-lines don't have children
         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]
         self.header = header
         # used at end for detecting how many removed lines were un-applied
         self.originalremoved = self.removed
 
         # flag to indicate whether to display as folded/unfolded to user
         self.folded = True
         # flag to indicate whether to apply this chunk
         self.applied = True
         # flag which only affects the status display indicating if a node's
         # children are partially applied (i.e. some applied, some not).
         self.partial = False
 
     def nextsibling(self):
         numhunksinheader = len(self.header.hunks)
         indexofthishunk = self.header.hunks.index(self)
 
         if (indexofthishunk < numhunksinheader - 1):
             nexthunk = self.header.hunks[indexofthishunk + 1]
             return nexthunk
         else:
             return None
 
     def prevsibling(self):
         indexofthishunk = self.header.hunks.index(self)
         if indexofthishunk > 0:
             previoushunk = self.header.hunks[indexofthishunk - 1]
             return previoushunk
         else:
             return None
 
     def parentitem(self):
         "return the parent to the current item"
         return self.header
 
     def firstchild(self):
         "return the first child of this item, if one exists.  otherwise None."
         if len(self.changedlines) > 0:
             return self.changedlines[0]
         else:
             return None
 
     def lastchild(self):
         "return the last child of this item, if one exists.  otherwise None."
         if len(self.changedlines) > 0:
             return self.changedlines[-1]
         else:
             return None
 
     def allchildren(self):
         "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
                    and l.prettystr()[0] == '+'])
         rem = len([l for l in self.changedlines if l.applied
                    and l.prettystr()[0] == '-'])
         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) +
                       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
 
         # diffutils manual, section "2.2.2.2 detailed description of unified
         # format": "an empty hunk is considered to end at the line that
         # precedes the hunk."
         #
         # so, if either of hunks is empty, decrease its line start. --immerrr
         # but only do this if fromline > 0, to avoid having, e.g fromline=-1.
         fromline, toline = self.fromline, self.toline
         if fromline != 0:
             if fromlen == 0:
                 fromline -= 1
             if tolen == 0:
                 toline -= 1
 
         fromtoline = '@@ -%d,%d +%d,%d @@%s\n' % (
             fromline, 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()
         fp.write(self.getfromtoline())
 
         hunklinelist = []
         # add the following to the list: (1) all applied lines, and
         # (2) all unapplied removal lines (convert these to context lines)
         for changedline in self.changedlines:
             changedlinestr = changedline.prettystr()
             if changedline.applied:
                 hunklinelist.append(changedlinestr)
             elif changedlinestr[0] == "-":
                 hunklinelist.append(" " + changedlinestr[1:])
 
         fp.write(''.join(self.before + hunklinelist + self.after))
 
     pretty = write
 
     def prettystr(self):
         x = cStringIO.StringIO()
         self.pretty(x)
         return x.getvalue()
 
     def __getattr__(self, name):
         return getattr(self._hunk, name)
     def __repr__(self):
         return '<hunk %r@%d>' % (self.filename(), self.fromline)
 
 def filterpatch(ui, chunks, chunkselector, operation=None):
     """interactively filter patch chunks into applied-only chunks"""
 
+    if operation is None:
+        operation = _('confirm')
     chunks = list(chunks)
     # convert chunks list into structure suitable for displaying/modifying
     # with curses.  create a list of headers only.
     headers = [c for c in chunks if isinstance(c, patchmod.header)]
 
     # if there are no changed files
     if len(headers) == 0:
         return []
     uiheaders = [uiheader(h) for h in headers]
     # let user choose headers/hunks/lines, and mark their applied flags
     # accordingly
     chunkselector(ui, uiheaders)
     appliedhunklist = []
     for hdr in uiheaders:
         if (hdr.applied and
             (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.toline += fixoffset
                 else:
                     fixoffset += hnk.removed - hnk.added
 
     return appliedhunklist
 
 def gethw():
     """
     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)
     curses.wrapper(chunkselector.main)
 
 def testdecorator(testfn, f):
     def u(*args, **kwargs):
         return f(testfn, *args, **kwargs)
     return u
 
 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())
         testf.close()
         while True:
             if chunkselector.handlekeypressed(testcommands.pop(0), test=True):
                 break
 
 class curseschunkselector(object):
     def __init__(self, headerlist, ui):
         # put the headers into a patch object
         self.headerlist = patch(headerlist)
 
         self.ui = ui
 
         # list of all chunks
         self.chunklist = []
         for h in headerlist:
             self.chunklist.append(h)
             self.chunklist.extend(h.hunks)
 
         # dictionary mapping (fgcolor, bgcolor) pairs to the
         # corresponding curses color-pair value.
         self.colorpairs = {}
         # maps custom nicknames of color-pairs to curses color-pair values
         self.colorpairnames = {}
 
         # the currently selected header, hunk, or hunk-line
         self.currentselecteditem = self.headerlist[0]
 
         # updated when printing out patch-display -- the 'lines' here are the
         # line positions *in the pad*, not on the screen.
         self.selecteditemstartline = 0
         self.selecteditemendline = None
 
         # define indentation levels
         self.headerindentnumchars = 0
         self.hunkindentnumchars = 3
         self.hunklineindentnumchars = 6
 
         # the first line of the pad to print to the screen
         self.firstlineofpadtoprint = 0
 
         # keeps track of the number of lines in the pad
         self.numpadlines = None
 
         self.numstatuslines = 2
 
         # keep a running count of the number of lines printed to the pad
         # (used for determining when the selected item begins/ends)
         self.linesprintedtopadsofar = 0
 
         # the first line of the pad which is visible on the screen
         self.firstlineofpadtoprint = 0
 
         # stores optional text for a commit comment provided by the user
         self.commenttext = ""
 
         # if the last 'toggle all' command caused all changes to be applied
         self.waslasttoggleallapplied = True
 
     def uparrowevent(self):
         """
         try to select the previous item to the current item that has the
         most-indented level.  for example, if a hunk is selected, try to select
         the last hunkline of the hunk prior to the selected hunk.  or, if
         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)
 
         if nextitem is None:
             # if no parent item (i.e. currentitem is the first header), then
             # no change...
             nextitem = currentitem
 
         self.currentselecteditem = nextitem
 
     def uparrowshiftevent(self):
         """
         select (if possible) the previous item on the same level as the
         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:
             nextitem = currentitem.parentitem()
         if nextitem is None:
             # if no parent item (i.e. currentitem is the first header), then
             # no change...
             nextitem = currentitem
 
         self.currentselecteditem = nextitem
 
     def downarrowevent(self):
         """
         try to select the next item to the current item that has the
         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.
 
         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)
         # if there's no next item, keep the selection as-is
         if nextitem is None:
             nextitem = currentitem
 
         self.currentselecteditem = nextitem
 
     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()
         # if there's no previous item on this level, try choosing the parent's
         # nextitem.
         if nextitem is None:
             try:
                 nextitem = currentitem.parentitem().nextitem()
             except AttributeError:
                 # parentitem returned None, so nextitem() can't be called
                 nextitem = None
         if nextitem is None:
             # if no next item on parent-level, then no change...
             nextitem = currentitem
 
         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
         if currentitem.folded:
             self.togglefolded(currentitem)
 
         if nextitem is None:
             # if no next item on parent-level, then no change...
             nextitem = currentitem
 
         self.currentselecteditem = nextitem
 
     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):
             if not currentitem.folded:
                 self.togglefolded(item=currentitem)
                 return
 
         # if it can't be folded, try to select the parent item
         nextitem = currentitem.parentitem()
 
         if nextitem is None:
             # if no item on parent-level, then no change...
             nextitem = currentitem
             if not nextitem.folded:
                 self.togglefolded(item=nextitem)
 
         self.currentselecteditem = nextitem
 
     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:
                 self.togglefolded(item=currentitem)
                 return
 
         # select the parent item recursively until we're at a header
         while True:
             nextitem = currentitem.parentitem()
             if nextitem is None:
                 break
             else:
                 currentitem = nextitem
 
         self.currentselecteditem = currentitem
 
     def updatescroll(self):
         "scroll the screen to fully show the currently-selected"
         selstart = self.selecteditemstartline
         selend = self.selecteditemendline
         #selnumlines = selend - selstart
         padstart = self.firstlineofpadtoprint
         padend = padstart + self.yscreensize - self.numstatuslines - 1
         # 'buffered' pad start/end values which scroll with a certain
         # top/bottom context margin
         padstartbuffered = padstart + 3
         padendbuffered = padend - 3
 
         if selend > padendbuffered:
             self.scrolllines(selend - padendbuffered)
         elif selstart < padstartbuffered:
             # negative values scroll in pgup direction
             self.scrolllines(selstart - padstartbuffered)
 
 
     def scrolllines(self, numlines):
         "scroll the screen up (down) by numlines when numlines >0 (<0)."
         self.firstlineofpadtoprint += numlines
         if self.firstlineofpadtoprint < 0:
             self.firstlineofpadtoprint = 0
         if self.firstlineofpadtoprint > self.numpadlines - 1:
             self.firstlineofpadtoprint = self.numpadlines - 1
 
     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
 
         if isinstance(item, uiheader):
             item.partial = False
             if item.applied:
                 # apply all its hunks
                 for hnk in item.hunks:
                     hnk.applied = True
                     # apply all their hunklines
                     for hunkline in hnk.changedlines:
                         hunkline.applied = True
             else:
                 # un-apply all its hunks
                 for hnk in item.hunks:
                     hnk.applied = False
                     hnk.partial = False
                     # un-apply all their hunklines
                     for hunkline in hnk.changedlines:
                         hunkline.applied = False
         elif isinstance(item, uihunk):
             item.partial = False
             # apply all it's hunklines
             for hunkline in item.changedlines:
                 hunkline.applied = item.applied
 
             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)
 
             #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
                 item.header.applied = True
                 item.header.partial = (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)
 
             # if no 'sibling' lines are applied
             if nosiblingsapplied:
                 item.hunk.applied = False
                 item.hunk.partial = False
             elif allsiblingsapplied:
                 item.hunk.applied = True
                 item.hunk.partial = False
             else: # some siblings applied
                 item.hunk.applied = True
                 item.hunk.partial = True
 
             parentsiblingsapplied = [hnk.applied for hnk
                                      in item.hunk.header.hunks]
             noparentsiblingsapplied = not (True in parentsiblingsapplied)
             allparentsiblingsapplied = not (False in parentsiblingsapplied)
 
             parentsiblingspartial = [hnk.partial for hnk
                                      in item.hunk.header.hunks]
             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
                 item.hunk.header.applied = True
                 item.hunk.header.partial = (someparentsiblingspartial or
                                             not allparentsiblingsapplied)
 
     def toggleall(self):
         "toggle the applied flag of all items."
         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:
                 if not item.applied:
                     self.toggleapply(item)
         self.waslasttoggleallapplied = not self.waslasttoggleallapplied
 
     def togglefolded(self, item=None, foldparent=False):
         "toggle folded flag of specified item (defaults to currently selected)"
         if item is None:
             item = self.currentselecteditem
         if foldparent or (isinstance(item, uiheader) and item.neverunfolded):
             if not isinstance(item, uiheader):
                 # we need to select the parent item in this case
                 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
                 for child in item.allchildren():
                     child.folded = not item.folded
 
         if isinstance(item, (uiheader, uihunk)):
             item.folded = not item.folded
 
 
     def alignstring(self, instr, window):
         """
         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)
         strwidth = encoding.colwidth(instr)
         numspaces = (width - ((strwidth + xstart) % width) - 1)
         return instr + " " * numspaces + "\n"
 
     def printstring(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
         curses.color_xxxx, where xxxx is one of: [black, blue, cyan, green,
         magenta, red, white, yellow].  if pairname is provided, a color
         pair will be looked up in the self.colorpairnames dictionary.
 
         attrlist is a list containing text attributes in the form of
         curses.a_xxxx, where xxxx can be: [bold, dim, normal, standout,
         underline].
 
         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]',
                 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]
         else:
             if fgcolor is None:
                 fgcolor = -1
             if bgcolor is None:
                 bgcolor = -1
             if (fgcolor, bgcolor) in self.colorpairs:
                 colorpair = self.colorpairs[(fgcolor, bgcolor)]
             else:
                 colorpair = self.getcolorpair(fgcolor, bgcolor)
         # add attributes if possible
         if attrlist is None:
             attrlist = []
         if colorpair < 256:
             # then it is safe to apply all attributes
             for textattr in attrlist:
                 colorpair |= textattr
         else:
             # just apply a select few (safe?) attributes
             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
         # if requested, show trailing whitespace
         if showwhtspc:
             origlen = len(text)
             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)
             else:
                 # need to use t, since the x position hasn't incremented
                 extrawhitespace = self.alignstring(t, window)
             t += extrawhitespace
 
         # is reset to 0 at the beginning of printitem()
 
         linesprinted = (xstart + len(t)) / self.xscreensize
         self.linesprintedtopadsofar += linesprinted
         return t
 
     def updatescreen(self):
         self.statuswin.erase()
         self.chunkpad.erase()
 
         printstring = self.printstring
 
         # print out the status lines at the top
         try:
             printstring(self.statuswin,
                         "SELECT CHUNKS: (j/k/up/dn/pgup/pgdn) move cursor; "
                         "(space/A) toggle hunk/all; (e)dit hunk;",
                         pairname="legend")
             printstring(self.statuswin,
                         " (f)old/unfold; (c)onfirm applied; (q)uit; (?) help "
                         "| [X]=hunk applied **=folded",
                         pairname="legend")
         except curses.error:
             pass
 
         # print out the patch in the remaining part of the window
         try:
             self.printitem()
             self.updatescroll()
             self.chunkpad.refresh(self.firstlineofpadtoprint, 0,
                                   self.numstatuslines, 0,
                                   self.yscreensize + 1 - self.numstatuslines,
                                   self.xscreensize)
         except curses.error:
             pass
 
         # refresh([pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol])
         self.statuswin.refresh()
 
     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:
                 checkbox = "[x]"
         else:
             checkbox = "[ ]"
 
         try:
             if item.folded:
                 checkbox += "**"
                 if isinstance(item, uiheader):
                     # one of "m", "a", or "d" (modified, added, deleted)
                     filestatus = item.changetype
 
                     checkbox += filestatus + " "
             else:
                 checkbox += "  "
                 if isinstance(item, uiheader):
                     # add two more spaces for headers
                     checkbox += "  "
         except AttributeError: # not foldable
             checkbox += "  "
 
         return checkbox
 
     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:
             # add separating line before headers
             outstr += self.printstring(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",
                                       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
         checkbox = self.getstatusprefixstring(header)
         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,
                                    towin=towin)
         if not header.folded or ignorefolding:
             if len(textlist) > 1:
                 for line in textlist[1:]:
                     linestr = " "*(indentnumchars + len(checkbox)) + line
                     outstr += self.printstring(self.chunkpad, linestr,
                                                pair=colorpair, towin=towin)
 
         return outstr
 
     def printhunklinesbefore(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,
                                        towin=towin, align=False)
 
         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
         frtoline = "   " + hunk.getfromtoline().strip("\n")
 
 
         outstr += self.printstring(self.chunkpad, lineprefix, towin=towin,
                                    align=False) # add uncolored checkbox/indent
         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
             outstr += self.printstring(self.chunkpad, linestr, towin=towin)
 
         return outstr
 
     def printhunklinesafter(self, hunk, towin=True, ignorefolding=False):
         outstr = ""
         if hunk.folded and not ignorefolding:
             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
             outstr += self.printstring(self.chunkpad, linestr, towin=towin)
 
         return outstr
 
     def printhunkchangedline(self, hunkline, selected=False, towin=True):
         outstr = ""
         checkbox = self.getstatusprefixstring(hunkline)
 
         linestr = hunkline.prettystr().strip("\n")
 
         # select color-pair based on whether line is an addition/removal
         if selected:
             colorpair = self.getcolorpair(name="selected")
         elif linestr.startswith("+"):
             colorpair = self.getcolorpair(name="addition")
         elif linestr.startswith("-"):
             colorpair = self.getcolorpair(name="deletion")
         elif linestr.startswith("\\"):
             colorpair = self.getcolorpair(name="normal")
 
         lineprefix = " "*self.hunklineindentnumchars + checkbox
         outstr += self.printstring(self.chunkpad, lineprefix, towin=towin,
                                    align=False) # add uncolored checkbox/indent
         outstr += self.printstring(self.chunkpad, linestr, pair=colorpair,
                                    towin=towin, showwhtspc=True)
         return outstr
 
     def printitem(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)
         """
         if item is None:
             item = self.headerlist
         if recursechildren:
             self.linesprintedtopadsofar = 0
 
         outstr = []
         self.__printitem(item, ignorefolding, recursechildren, outstr,
                                   towin=towin)
         return ''.join(outstr)
 
     def outofdisplayedarea(self):
         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)
         if selected and recursechildren:
             # assumes line numbering starting from line 0
             self.selecteditemstartline = self.linesprintedtopadsofar
             selecteditemlines = self.getnumlinesdisplayed(item,
                                                           recursechildren=False)
             self.selecteditemendline = (self.selecteditemstartline +
                                         selecteditemlines - 1)
         return selected
 
     def __printitem(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.).
 
         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)
 
         # patch object is a list of headers
         if isinstance(item, patch):
             if recursechildren:
                 for hdr in item:
                     self.__printitem(hdr, ignorefolding,
                             recursechildren, outstr, towin)
         # todo: eliminate all isinstance() calls
         if isinstance(item, uiheader):
             outstr.append(self.printheader(item, selected, towin=towin,
                                        ignorefolding=ignorefolding))
             if recursechildren:
                 for hnk in item.hunks:
                     self.__printitem(hnk, ignorefolding,
                             recursechildren, outstr, towin)
         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,
                                                 ignorefolding=ignorefolding))
             if recursechildren:
                 for l in item.changedlines:
                     self.__printitem(l, ignorefolding,
                             recursechildren, outstr, towin)
                 outstr.append(self.printhunklinesafter(item, towin=towin,
                                                 ignorefolding=ignorefolding))
         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,
                              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,
                                             recursechildren, towin=False)
         numlines = len(patchdisplaystring) / self.xscreensize
         return numlines
 
     def sigwinchhandler(self, n, frame):
         "handle window resizing"
         try:
             curses.endwin()
             self.yscreensize, self.xscreensize = gethw()
             self.statuswin.resize(self.numstatuslines, self.xscreensize)
             self.numpadlines = self.getnumlinesdisplayed(ignorefolding=True) + 1
             self.chunkpad = curses.newpad(self.numpadlines, self.xscreensize)
             # todo: try to resize commit message window if possible
         except curses.error:
             pass
 
     def getcolorpair(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
         returned.
 
         it is expected that this function will be used exclusively for
         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:
                 fgcolor = -1
             if bgcolor is None:
                 bgcolor = -1
             if (fgcolor, bgcolor) in self.colorpairs:
                 colorpair = self.colorpairs[(fgcolor, bgcolor)]
             else:
                 pairindex = len(self.colorpairs) + 1
                 curses.init_pair(pairindex, fgcolor, bgcolor)
                 colorpair = self.colorpairs[(fgcolor, bgcolor)] = (
                     curses.color_pair(pairindex))
                 if name is not None:
                     self.colorpairnames[name] = curses.color_pair(pairindex)
 
         # add attributes if possible
         if attrlist is None:
             attrlist = []
         if colorpair < 256:
             # then it is safe to apply all attributes
             for textattr in attrlist:
                 colorpair |= textattr
         else:
             # just apply a select few (safe?) attributes
             for textattrib in (curses.A_UNDERLINE, curses.A_BOLD):
                 if textattrib in attrlist:
                     colorpair |= textattrib
         return colorpair
 
     def initcolorpair(self, *args, **kwargs):
         "same as getcolorpair."
         self.getcolorpair(*args, **kwargs)
 
     def helpwindow(self):
         "print a help window to the screen.  exit after any keypress."
         helptext = """            [press any key to return to the patch-display]
 
 crecord allows you to interactively choose among the changes you have made,
 and confirm only those changes you select for further processing by the command
 you are running (commit/shelve/revert), after confirming the selected
 changes, the unselected changes are still present in your working copy, so you
 can use crecord multiple times to split large changes into smaller changesets.
 the following are valid keystrokes:
 
                 [space] : (un-)select item ([~]/[x] = partly/fully applied)
                       a : (un-)select all items
     up/down-arrow [k/j] : go to previous/next unfolded item
         pgup/pgdn [k/j] : go to previous/next item of same type
  right/left-arrow [l/h] : go to child item / parent item
  shift-left-arrow   [h] : go to parent header / fold selected header
                       f : fold / unfold item, hiding/revealing its children
                       f : fold / unfold parent item and all of its ancestors
                       m : edit / resume editing the commit message
                       e : edit the currently selected hunk
                       a : toggle amend mode (hg rev >= 2.2)
                       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)"""
 
         helpwin = curses.newwin(self.yscreensize, 0, 0, 0)
         helplines = helptext.split("\n")
         helplines = helplines + [" "]*(
             self.yscreensize - self.numstatuslines - len(helplines) - 1)
         try:
             for line in helplines:
                 self.printstring(helpwin, line, pairname="legend")
         except curses.error:
             pass
         helpwin.refresh()
         try:
             helpwin.getkey()
         except curses.error:
             pass
 
     def confirmationwindow(self, windowtext):
         "display an informational window, then wait for and return a keypress."
 
         confirmwin = curses.newwin(self.yscreensize, 0, 0, 0)
         try:
             lines = windowtext.split("\n")
             for line in lines:
                 self.printstring(confirmwin, line, pairname="selected")
         except curses.error:
             pass
         self.stdscr.refresh()
         confirmwin.refresh()
         try:
             response = chr(self.stdscr.getch())
         except ValueError:
             response = None
 
         return response
 
     def confirmcommit(self, review=False):
         """ask for 'y' to be pressed to confirm selected. return True if
         confirmed."""
         if review:
             confirmtext = (
 """if you answer yes to the following, the your currently chosen patch chunks
 will be loaded into an editor.  you may modify the patch from the editor, and
 save the changes if you wish to change the patch.  otherwise, you can just
 close the editor without saving to accept the current patch as-is.
 
 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]?
 """)
         else:
             confirmtext = (
                 "are you sure you want to confirm the selected changes [yn]? ")
 
         response = self.confirmationwindow(confirmtext)
         if response is None:
             response = "n"
         if response.lower().startswith("y"):
             return True
         else:
             return False
 
     def recenterdisplayedarea(self):
         """
         once we scrolled with pg up pg down we can be pointing outside of the
         display zone. we print the patch with towin=False to compute the
         location of the selected item eventhough it is outside of the displayed
         zone and then update the scroll.
         """
         self.printitem(towin=False)
         self.updatescroll()
 
     def toggleedit(self, item=None, test=False):
         """
             edit the currently chelected chunk
         """
 
         def editpatchwitheditor(self, chunk):
             if chunk is None:
                 self.ui.write(_('cannot edit patch for whole file'))
                 self.ui.write("\n")
                 return None
             if chunk.header.binary():
                 self.ui.write(_('cannot edit patch for binary file'))
                 self.ui.write("\n")
                 return None
             # patch comment based on the git one (based on comment at end of
             # http://mercurial.selenic.com/wiki/recordextension)
             phelp = '---' + _("""
     to remove '-' lines, make them ' ' lines (context).
     to remove '+' lines, delete them.
     lines starting with # will be removed from the patch.
 
     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.
     """)
             (patchfd, patchfn) = tempfile.mkstemp(prefix="hg-editor-",
                     suffix=".diff", text=True)
             ncpatchfp = None
             try:
                 # write the initial patch
                 f = os.fdopen(patchfd, "w")
                 chunk.header.write(f)
                 chunk.write(f)
                 f.write('\n'.join(['# ' + i for i in phelp.splitlines()]))
                 f.close()
                 # start the editor and wait for it to complete
                 editor = self.ui.geteditor()
                 self.ui.system("%s \"%s\"" % (editor, patchfn),
                           environ={'hguser': self.ui.username()},
                           onerr=util.Abort, errprefix=_("edit failed"))
                 # remove comment lines
                 patchfp = open(patchfn)
                 ncpatchfp = cStringIO.StringIO()
                 for line in patchfp:
                     if not line.startswith('#'):
                         ncpatchfp.write(line)
                 patchfp.close()
                 ncpatchfp.seek(0)
                 newpatches = patchmod.parsepatch(ncpatchfp)
             finally:
                 os.unlink(patchfn)
                 del ncpatchfp
             return newpatches
         if item is None:
             item = self.currentselecteditem
         if isinstance(item, uiheader):
             return
         if isinstance(item, uihunkline):
             item = item.parentitem()
         if not isinstance(item, uihunk):
             return
 
         beforeadded, beforeremoved = item.added, item.removed
         newpatches = editpatchwitheditor(self, item)
         header = item.header
         editedhunkindex = header.hunks.index(item)
         hunksbefore = header.hunks[:editedhunkindex]
         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)
 
         for h in hunksafter:
             h.toline += offset
         for h in newhunks:
             h.folded = False
         header.hunks = hunksbefore + newhunks + hunksafter
         if self.emptypatch():
             header.hunks = hunksbefore + [item] + hunksafter
         self.currentselecteditem = header
 
         if not test:
             self.numpadlines = self.getnumlinesdisplayed(ignorefolding=True) + 1
             self.chunkpad = curses.newpad(self.numpadlines, self.xscreensize)
             self.updatescroll()
             self.stdscr.refresh()
             self.statuswin.refresh()
             self.stdscr.keypad(1)
 
     def emptypatch(self):
         item = self.headerlist
         if not item:
             return True
         for header in item:
             if header.hunks:
                 return False
         return True
 
     def handlekeypressed(self, keypressed, test=False):
         if keypressed in ["k", "KEY_UP"]:
             self.uparrowevent()
         if keypressed in ["k", "KEY_PPAGE"]:
             self.uparrowshiftevent()
         elif keypressed in ["j", "KEY_DOWN"]:
             self.downarrowevent()
         elif keypressed in ["j", "KEY_NPAGE"]:
             self.downarrowshiftevent()
         elif keypressed in ["l", "KEY_RIGHT"]:
             self.rightarrowevent()
         elif keypressed in ["h", "KEY_LEFT"]:
             self.leftarrowevent()
         elif keypressed in ["h", "KEY_SLEFT"]:
             self.leftarrowshiftevent()
         elif keypressed in ["q"]:
             raise util.Abort(_('user quit'))
         elif keypressed in ["c"]:
             if self.confirmcommit():
                 return True
         elif keypressed in ["r"]:
             if self.confirmcommit(review=True):
                 return True
         elif test and keypressed in ['X']:
             return True
         elif keypressed in [' '] or (test and keypressed in ["TOGGLE"]):
             self.toggleapply()
         elif keypressed in ['A']:
             self.toggleall()
         elif keypressed in ['e']:
             self.toggleedit(test=test)
         elif keypressed in ["f"]:
             self.togglefolded()
         elif keypressed in ["f"]:
             self.togglefolded(foldparent=True)
         elif keypressed in ["?"]:
             self.helpwindow()
 
     def main(self, stdscr):
         """
         method to be wrapped by curses.wrapper() for selecting chunks.
 
         """
         signal.signal(signal.SIGWINCH, self.sigwinchhandler)
         self.stdscr = stdscr
         self.yscreensize, self.xscreensize = self.stdscr.getmaxyx()
 
         curses.start_color()
         curses.use_default_colors()
 
         # 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,
                            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
 
         # 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
         self.chunkpad = curses.newpad(1, self.xscreensize)
 
         # add 1 so to account for last line text reaching end of line
         self.numpadlines = self.getnumlinesdisplayed(ignorefolding=True) + 1
         self.chunkpad = curses.newpad(self.numpadlines, self.xscreensize)
 
         # initialize selecteitemendline (initial start-line is 0)
         self.selecteditemendline = self.getnumlinesdisplayed(
             self.currentselecteditem, recursechildren=False)
 
         while True:
             self.updatescreen()
             try:
                 keypressed = self.statuswin.getkey()
             except curses.error:
                 keypressed = "foobar"
             if self.handlekeypressed(keypressed):
                 break

mercurial/patch.py

@@ -1,2478 +1,2480 b''
 # patch.py - patch file parsing routines
 #
 # Copyright 2006 Brendan Cully <[e-mail]>
 # Copyright 2007 Chris Mason <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 import collections
 import cStringIO, email, os, errno, re, posixpath, copy
 import tempfile, zlib, shutil
 # On python2.4 you have to import these by name or they fail to
 # load. This was not a problem on Python 2.7.
 import email.Generator
 import email.Parser
 
 from i18n import _
 from node import hex, short
 import base85, mdiff, scmutil, util, diffhelpers, copies, encoding, error
 import pathutil
 
 gitre = re.compile('diff --git a/(.*) b/(.*)')
 tabsplitter = re.compile(r'(\t+|[^\t]+)')
 
 class PatchError(Exception):
     pass
 
 
 # public functions
 
 def split(stream):
     '''return an iterator of individual patches from a stream'''
     def isheader(line, inheader):
         if inheader and line[0] in (' ', '\t'):
             # continuation
             return True
         if line[0] in (' ', '-', '+'):
             # diff line - don't check for header pattern in there
             return False
         l = line.split(': ', 1)
         return len(l) == 2 and ' ' not in l[0]
 
     def chunk(lines):
         return cStringIO.StringIO(''.join(lines))
 
     def hgsplit(stream, cur):
         inheader = True
 
         for line in stream:
             if not line.strip():
                 inheader = False
             if not inheader and line.startswith('# HG changeset patch'):
                 yield chunk(cur)
                 cur = []
                 inheader = True
 
             cur.append(line)
 
         if cur:
             yield chunk(cur)
 
     def mboxsplit(stream, cur):
         for line in stream:
             if line.startswith('From '):
                 for c in split(chunk(cur[1:])):
                     yield c
                 cur = []
 
             cur.append(line)
 
         if cur:
             for c in split(chunk(cur[1:])):
                 yield c
 
     def mimesplit(stream, cur):
         def msgfp(m):
             fp = cStringIO.StringIO()
             g = email.Generator.Generator(fp, mangle_from_=False)
             g.flatten(m)
             fp.seek(0)
             return fp
 
         for line in stream:
             cur.append(line)
         c = chunk(cur)
 
         m = email.Parser.Parser().parse(c)
         if not m.is_multipart():
             yield msgfp(m)
         else:
             ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')
             for part in m.walk():
                 ct = part.get_content_type()
                 if ct not in ok_types:
                     continue
                 yield msgfp(part)
 
     def headersplit(stream, cur):
         inheader = False
 
         for line in stream:
             if not inheader and isheader(line, inheader):
                 yield chunk(cur)
                 cur = []
                 inheader = True
             if inheader and not isheader(line, inheader):
                 inheader = False
 
             cur.append(line)
 
         if cur:
             yield chunk(cur)
 
     def remainder(cur):
         yield chunk(cur)
 
     class fiter(object):
         def __init__(self, fp):
             self.fp = fp
 
         def __iter__(self):
             return self
 
         def next(self):
             l = self.fp.readline()
             if not l:
                 raise StopIteration
             return l
 
     inheader = False
     cur = []
 
     mimeheaders = ['content-type']
 
     if not util.safehasattr(stream, 'next'):
         # http responses, for example, have readline but not next
         stream = fiter(stream)
 
     for line in stream:
         cur.append(line)
         if line.startswith('# HG changeset patch'):
             return hgsplit(stream, cur)
         elif line.startswith('From '):
             return mboxsplit(stream, cur)
         elif isheader(line, inheader):
             inheader = True
             if line.split(':', 1)[0].lower() in mimeheaders:
                 # let email parser handle this
                 return mimesplit(stream, cur)
         elif line.startswith('--- ') and inheader:
             # No evil headers seen by diff start, split by hand
             return headersplit(stream, cur)
         # Not enough info, keep reading
 
     # if we are here, we have a very plain patch
     return remainder(cur)
 
 def extract(ui, fileobj):
     '''extract patch from data read from fileobj.
 
     patch can be a normal patch or contained in an email message.
 
     return tuple (filename, message, user, date, branch, node, p1, p2).
     Any item in the returned tuple can be None. If filename is None,
     fileobj did not contain a patch. Caller must unlink filename when done.'''
 
     # attempt to detect the start of a patch
     # (this heuristic is borrowed from quilt)
     diffre = re.compile(r'^(?:Index:[ \t]|diff[ \t]|RCS file: |'
                         r'retrieving revision [0-9]+(\.[0-9]+)*$|'
                         r'---[ \t].*?^\+\+\+[ \t]|'
                         r'\*\*\*[ \t].*?^---[ \t])', re.MULTILINE|re.DOTALL)
 
     fd, tmpname = tempfile.mkstemp(prefix='hg-patch-')
     tmpfp = os.fdopen(fd, 'w')
     try:
         msg = email.Parser.Parser().parse(fileobj)
 
         subject = msg['Subject']
         user = msg['From']
         if not subject and not user:
             # Not an email, restore parsed headers if any
             subject = '\n'.join(': '.join(h) for h in msg.items()) + '\n'
 
         # should try to parse msg['Date']
         date = None
         nodeid = None
         branch = None
         parents = []
 
         if subject:
             if subject.startswith('[PATCH'):
                 pend = subject.find(']')
                 if pend >= 0:
                     subject = subject[pend + 1:].lstrip()
             subject = re.sub(r'\n[ \t]+', ' ', subject)
             ui.debug('Subject: %s\n' % subject)
         if user:
             ui.debug('From: %s\n' % user)
         diffs_seen = 0
         ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')
         message = ''
         for part in msg.walk():
             content_type = part.get_content_type()
             ui.debug('Content-Type: %s\n' % content_type)
             if content_type not in ok_types:
                 continue
             payload = part.get_payload(decode=True)
             m = diffre.search(payload)
             if m:
                 hgpatch = False
                 hgpatchheader = False
                 ignoretext = False
 
                 ui.debug('found patch at byte %d\n' % m.start(0))
                 diffs_seen += 1
                 cfp = cStringIO.StringIO()
                 for line in payload[:m.start(0)].splitlines():
                     if line.startswith('# HG changeset patch') and not hgpatch:
                         ui.debug('patch generated by hg export\n')
                         hgpatch = True
                         hgpatchheader = True
                         # drop earlier commit message content
                         cfp.seek(0)
                         cfp.truncate()
                         subject = None
                     elif hgpatchheader:
                         if line.startswith('# User '):
                             user = line[7:]
                             ui.debug('From: %s\n' % user)
                         elif line.startswith("# Date "):
                             date = line[7:]
                         elif line.startswith("# Branch "):
                             branch = line[9:]
                         elif line.startswith("# Node ID "):
                             nodeid = line[10:]
                         elif line.startswith("# Parent "):
                             parents.append(line[9:].lstrip())
                         elif not line.startswith("# "):
                             hgpatchheader = False
                     elif line == '---':
                         ignoretext = True
                     if not hgpatchheader and not ignoretext:
                         cfp.write(line)
                         cfp.write('\n')
                 message = cfp.getvalue()
                 if tmpfp:
                     tmpfp.write(payload)
                     if not payload.endswith('\n'):
                         tmpfp.write('\n')
             elif not diffs_seen and message and content_type == 'text/plain':
                 message += '\n' + payload
     except: # re-raises
         tmpfp.close()
         os.unlink(tmpname)
         raise
 
     if subject and not message.startswith(subject):
         message = '%s\n%s' % (subject, message)
     tmpfp.close()
     if not diffs_seen:
         os.unlink(tmpname)
         return None, message, user, date, branch, None, None, None
 
     if parents:
         p1 = parents.pop(0)
     else:
         p1 = None
 
     if parents:
         p2 = parents.pop(0)
     else:
         p2 = None
 
     return tmpname, message, user, date, branch, nodeid, p1, p2
 
 class patchmeta(object):
     """Patched file metadata
 
     'op' is the performed operation within ADD, DELETE, RENAME, MODIFY
     or COPY.  'path' is patched file path. 'oldpath' is set to the
     origin file when 'op' is either COPY or RENAME, None otherwise. If
     file mode is changed, 'mode' is a tuple (islink, isexec) where
     'islink' is True if the file is a symlink and 'isexec' is True if
     the file is executable. Otherwise, 'mode' is None.
     """
     def __init__(self, path):
         self.path = path
         self.oldpath = None
         self.mode = None
         self.op = 'MODIFY'
         self.binary = False
 
     def setmode(self, mode):
         islink = mode & 020000
         isexec = mode & 0100
         self.mode = (islink, isexec)
 
     def copy(self):
         other = patchmeta(self.path)
         other.oldpath = self.oldpath
         other.mode = self.mode
         other.op = self.op
         other.binary = self.binary
         return other
 
     def _ispatchinga(self, afile):
         if afile == '/dev/null':
             return self.op == 'ADD'
         return afile == 'a/' + (self.oldpath or self.path)
 
     def _ispatchingb(self, bfile):
         if bfile == '/dev/null':
             return self.op == 'DELETE'
         return bfile == 'b/' + self.path
 
     def ispatching(self, afile, bfile):
         return self._ispatchinga(afile) and self._ispatchingb(bfile)
 
     def __repr__(self):
         return "<patchmeta %s %r>" % (self.op, self.path)
 
 def readgitpatch(lr):
     """extract git-style metadata about patches from <patchname>"""
 
     # Filter patch for git information
     gp = None
     gitpatches = []
     for line in lr:
         line = line.rstrip(' \r\n')
         if line.startswith('diff --git a/'):
             m = gitre.match(line)
             if m:
                 if gp:
                     gitpatches.append(gp)
                 dst = m.group(2)
                 gp = patchmeta(dst)
         elif gp:
             if line.startswith('--- '):
                 gitpatches.append(gp)
                 gp = None
                 continue
             if line.startswith('rename from '):
                 gp.op = 'RENAME'
                 gp.oldpath = line[12:]
             elif line.startswith('rename to '):
                 gp.path = line[10:]
             elif line.startswith('copy from '):
                 gp.op = 'COPY'
                 gp.oldpath = line[10:]
             elif line.startswith('copy to '):
                 gp.path = line[8:]
             elif line.startswith('deleted file'):
                 gp.op = 'DELETE'
             elif line.startswith('new file mode '):
                 gp.op = 'ADD'
                 gp.setmode(int(line[-6:], 8))
             elif line.startswith('new mode '):
                 gp.setmode(int(line[-6:], 8))
             elif line.startswith('GIT binary patch'):
                 gp.binary = True
     if gp:
         gitpatches.append(gp)
 
     return gitpatches
 
 class linereader(object):
     # simple class to allow pushing lines back into the input stream
     def __init__(self, fp):
         self.fp = fp
         self.buf = []
 
     def push(self, line):
         if line is not None:
             self.buf.append(line)
 
     def readline(self):
         if self.buf:
             l = self.buf[0]
             del self.buf[0]
             return l
         return self.fp.readline()
 
     def __iter__(self):
         while True:
             l = self.readline()
             if not l:
                 break
             yield l
 
 class abstractbackend(object):
     def __init__(self, ui):
         self.ui = ui
 
     def getfile(self, fname):
         """Return target file data and flags as a (data, (islink,
         isexec)) tuple. Data is None if file is missing/deleted.
         """
         raise NotImplementedError
 
     def setfile(self, fname, data, mode, copysource):
         """Write data to target file fname and set its mode. mode is a
         (islink, isexec) tuple. If data is None, the file content should
         be left unchanged. If the file is modified after being copied,
         copysource is set to the original file name.
         """
         raise NotImplementedError
 
     def unlink(self, fname):
         """Unlink target file."""
         raise NotImplementedError
 
     def writerej(self, fname, failed, total, lines):
         """Write rejected lines for fname. total is the number of hunks
         which failed to apply and total the total number of hunks for this
         files.
         """
         pass
 
     def exists(self, fname):
         raise NotImplementedError
 
 class fsbackend(abstractbackend):
     def __init__(self, ui, basedir):
         super(fsbackend, self).__init__(ui)
         self.opener = scmutil.opener(basedir)
 
     def _join(self, f):
         return os.path.join(self.opener.base, f)
 
     def getfile(self, fname):
         if self.opener.islink(fname):
             return (self.opener.readlink(fname), (True, False))
 
         isexec = False
         try:
             isexec = self.opener.lstat(fname).st_mode & 0100 != 0
         except OSError, e:
             if e.errno != errno.ENOENT:
                 raise
         try:
             return (self.opener.read(fname), (False, isexec))
         except IOError, e:
             if e.errno != errno.ENOENT:
                 raise
             return None, None
 
     def setfile(self, fname, data, mode, copysource):
         islink, isexec = mode
         if data is None:
             self.opener.setflags(fname, islink, isexec)
             return
         if islink:
             self.opener.symlink(data, fname)
         else:
             self.opener.write(fname, data)
             if isexec:
                 self.opener.setflags(fname, False, True)
 
     def unlink(self, fname):
         self.opener.unlinkpath(fname, ignoremissing=True)
 
     def writerej(self, fname, failed, total, lines):
         fname = fname + ".rej"
         self.ui.warn(
             _("%d out of %d hunks FAILED -- saving rejects to file %s\n") %
             (failed, total, fname))
         fp = self.opener(fname, 'w')
         fp.writelines(lines)
         fp.close()
 
     def exists(self, fname):
         return self.opener.lexists(fname)
 
 class workingbackend(fsbackend):
     def __init__(self, ui, repo, similarity):
         super(workingbackend, self).__init__(ui, repo.root)
         self.repo = repo
         self.similarity = similarity
         self.removed = set()
         self.changed = set()
         self.copied = []
 
     def _checkknown(self, fname):
         if self.repo.dirstate[fname] == '?' and self.exists(fname):
             raise PatchError(_('cannot patch %s: file is not tracked') % fname)
 
     def setfile(self, fname, data, mode, copysource):
         self._checkknown(fname)
         super(workingbackend, self).setfile(fname, data, mode, copysource)
         if copysource is not None:
             self.copied.append((copysource, fname))
         self.changed.add(fname)
 
     def unlink(self, fname):
         self._checkknown(fname)
         super(workingbackend, self).unlink(fname)
         self.removed.add(fname)
         self.changed.add(fname)
 
     def close(self):
         wctx = self.repo[None]
         changed = set(self.changed)
         for src, dst in self.copied:
             scmutil.dirstatecopy(self.ui, self.repo, wctx, src, dst)
         if self.removed:
             wctx.forget(sorted(self.removed))
             for f in self.removed:
                 if f not in self.repo.dirstate:
                     # File was deleted and no longer belongs to the
                     # dirstate, it was probably marked added then
                     # deleted, and should not be considered by
                     # marktouched().
                     changed.discard(f)
         if changed:
             scmutil.marktouched(self.repo, changed, self.similarity)
         return sorted(self.changed)
 
 class filestore(object):
     def __init__(self, maxsize=None):
         self.opener = None
         self.files = {}
         self.created = 0
         self.maxsize = maxsize
         if self.maxsize is None:
             self.maxsize = 4*(2**20)
         self.size = 0
         self.data = {}
 
     def setfile(self, fname, data, mode, copied=None):
         if self.maxsize < 0 or (len(data) + self.size) <= self.maxsize:
             self.data[fname] = (data, mode, copied)
             self.size += len(data)
         else:
             if self.opener is None:
                 root = tempfile.mkdtemp(prefix='hg-patch-')
                 self.opener = scmutil.opener(root)
             # Avoid filename issues with these simple names
             fn = str(self.created)
             self.opener.write(fn, data)
             self.created += 1
             self.files[fname] = (fn, mode, copied)
 
     def getfile(self, fname):
         if fname in self.data:
             return self.data[fname]
         if not self.opener or fname not in self.files:
             return None, None, None
         fn, mode, copied = self.files[fname]
         return self.opener.read(fn), mode, copied
 
     def close(self):
         if self.opener:
             shutil.rmtree(self.opener.base)
 
 class repobackend(abstractbackend):
     def __init__(self, ui, repo, ctx, store):
         super(repobackend, self).__init__(ui)
         self.repo = repo
         self.ctx = ctx
         self.store = store
         self.changed = set()
         self.removed = set()
         self.copied = {}
 
     def _checkknown(self, fname):
         if fname not in self.ctx:
             raise PatchError(_('cannot patch %s: file is not tracked') % fname)
 
     def getfile(self, fname):
         try:
             fctx = self.ctx[fname]
         except error.LookupError:
             return None, None
         flags = fctx.flags()
         return fctx.data(), ('l' in flags, 'x' in flags)
 
     def setfile(self, fname, data, mode, copysource):
         if copysource:
             self._checkknown(copysource)
         if data is None:
             data = self.ctx[fname].data()
         self.store.setfile(fname, data, mode, copysource)
         self.changed.add(fname)
         if copysource:
             self.copied[fname] = copysource
 
     def unlink(self, fname):
         self._checkknown(fname)
         self.removed.add(fname)
 
     def exists(self, fname):
         return fname in self.ctx
 
     def close(self):
         return self.changed | self.removed
 
 # @@ -start,len +start,len @@ or @@ -start +start @@ if len is 1
 unidesc = re.compile('@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@')
 contextdesc = re.compile('(?:---|\*\*\*) (\d+)(?:,(\d+))? (?:---|\*\*\*)')
 eolmodes = ['strict', 'crlf', 'lf', 'auto']
 
 class patchfile(object):
     def __init__(self, ui, gp, backend, store, eolmode='strict'):
         self.fname = gp.path
         self.eolmode = eolmode
         self.eol = None
         self.backend = backend
         self.ui = ui
         self.lines = []
         self.exists = False
         self.missing = True
         self.mode = gp.mode
         self.copysource = gp.oldpath
         self.create = gp.op in ('ADD', 'COPY', 'RENAME')
         self.remove = gp.op == 'DELETE'
         if self.copysource is None:
             data, mode = backend.getfile(self.fname)
         else:
             data, mode = store.getfile(self.copysource)[:2]
         if data is not None:
             self.exists = self.copysource is None or backend.exists(self.fname)
             self.missing = False
             if data:
                 self.lines = mdiff.splitnewlines(data)
             if self.mode is None:
                 self.mode = mode
             if self.lines:
                 # Normalize line endings
                 if self.lines[0].endswith('\r\n'):
                     self.eol = '\r\n'
                 elif self.lines[0].endswith('\n'):
                     self.eol = '\n'
                 if eolmode != 'strict':
                     nlines = []
                     for l in self.lines:
                         if l.endswith('\r\n'):
                             l = l[:-2] + '\n'
                         nlines.append(l)
                     self.lines = nlines
         else:
             if self.create:
                 self.missing = False
             if self.mode is None:
                 self.mode = (False, False)
         if self.missing:
             self.ui.warn(_("unable to find '%s' for patching\n") % self.fname)
 
         self.hash = {}
         self.dirty = 0
         self.offset = 0
         self.skew = 0
         self.rej = []
         self.fileprinted = False
         self.printfile(False)
         self.hunks = 0
 
     def writelines(self, fname, lines, mode):
         if self.eolmode == 'auto':
             eol = self.eol
         elif self.eolmode == 'crlf':
             eol = '\r\n'
         else:
             eol = '\n'
 
         if self.eolmode != 'strict' and eol and eol != '\n':
             rawlines = []
             for l in lines:
                 if l and l[-1] == '\n':
                     l = l[:-1] + eol
                 rawlines.append(l)
             lines = rawlines
 
         self.backend.setfile(fname, ''.join(lines), mode, self.copysource)
 
     def printfile(self, warn):
         if self.fileprinted:
             return
         if warn or self.ui.verbose:
             self.fileprinted = True
         s = _("patching file %s\n") % self.fname
         if warn:
             self.ui.warn(s)
         else:
             self.ui.note(s)
 
 
     def findlines(self, l, linenum):
         # looks through the hash and finds candidate lines.  The
         # result is a list of line numbers sorted based on distance
         # from linenum
 
         cand = self.hash.get(l, [])
         if len(cand) > 1:
             # resort our list of potentials forward then back.
             cand.sort(key=lambda x: abs(x - linenum))
         return cand
 
     def write_rej(self):
         # our rejects are a little different from patch(1).  This always
         # creates rejects in the same form as the original patch.  A file
         # header is inserted so that you can run the reject through patch again
         # without having to type the filename.
         if not self.rej:
             return
         base = os.path.basename(self.fname)
         lines = ["--- %s\n+++ %s\n" % (base, base)]
         for x in self.rej:
             for l in x.hunk:
                 lines.append(l)
                 if l[-1] != '\n':
                     lines.append("\n\ No newline at end of file\n")
         self.backend.writerej(self.fname, len(self.rej), self.hunks, lines)
 
     def apply(self, h):
         if not h.complete():
             raise PatchError(_("bad hunk #%d %s (%d %d %d %d)") %
                             (h.number, h.desc, len(h.a), h.lena, len(h.b),
                             h.lenb))
 
         self.hunks += 1
 
         if self.missing:
             self.rej.append(h)
             return -1
 
         if self.exists and self.create:
             if self.copysource:
                 self.ui.warn(_("cannot create %s: destination already "
                                "exists\n") % self.fname)
             else:
                 self.ui.warn(_("file %s already exists\n") % self.fname)
             self.rej.append(h)
             return -1
 
         if isinstance(h, binhunk):
             if self.remove:
                 self.backend.unlink(self.fname)
             else:
                 l = h.new(self.lines)
                 self.lines[:] = l
                 self.offset += len(l)
                 self.dirty = True
             return 0
 
         horig = h
         if (self.eolmode in ('crlf', 'lf')
             or self.eolmode == 'auto' and self.eol):
             # If new eols are going to be normalized, then normalize
             # hunk data before patching. Otherwise, preserve input
             # line-endings.
             h = h.getnormalized()
 
         # fast case first, no offsets, no fuzz
         old, oldstart, new, newstart = h.fuzzit(0, False)
         oldstart += self.offset
         orig_start = oldstart
         # if there's skew we want to emit the "(offset %d lines)" even
         # when the hunk cleanly applies at start + skew, so skip the
         # fast case code
         if (self.skew == 0 and
             diffhelpers.testhunk(old, self.lines, oldstart) == 0):
             if self.remove:
                 self.backend.unlink(self.fname)
             else:
                 self.lines[oldstart:oldstart + len(old)] = new
                 self.offset += len(new) - len(old)
                 self.dirty = True
             return 0
 
         # ok, we couldn't match the hunk. Lets look for offsets and fuzz it
         self.hash = {}
         for x, s in enumerate(self.lines):
             self.hash.setdefault(s, []).append(x)
 
         for fuzzlen in xrange(3):
             for toponly in [True, False]:
                 old, oldstart, new, newstart = h.fuzzit(fuzzlen, toponly)
                 oldstart = oldstart + self.offset + self.skew
                 oldstart = min(oldstart, len(self.lines))
                 if old:
                     cand = self.findlines(old[0][1:], oldstart)
                 else:
                     # Only adding lines with no or fuzzed context, just
                     # take the skew in account
                     cand = [oldstart]
 
                 for l in cand:
                     if not old or diffhelpers.testhunk(old, self.lines, l) == 0:
                         self.lines[l : l + len(old)] = new
                         self.offset += len(new) - len(old)
                         self.skew = l - orig_start
                         self.dirty = True
                         offset = l - orig_start - fuzzlen
                         if fuzzlen:
                             msg = _("Hunk #%d succeeded at %d "
                                     "with fuzz %d "
                                     "(offset %d lines).\n")
                             self.printfile(True)
                             self.ui.warn(msg %
                                 (h.number, l + 1, fuzzlen, offset))
                         else:
                             msg = _("Hunk #%d succeeded at %d "
                                     "(offset %d lines).\n")
                             self.ui.note(msg % (h.number, l + 1, offset))
                         return fuzzlen
         self.printfile(True)
         self.ui.warn(_("Hunk #%d FAILED at %d\n") % (h.number, orig_start))
         self.rej.append(horig)
         return -1
 
     def close(self):
         if self.dirty:
             self.writelines(self.fname, self.lines, self.mode)
         self.write_rej()
         return len(self.rej)
 
 class header(object):
     """patch header
     """
     diffgit_re = re.compile('diff --git a/(.*) b/(.*)$')
     diff_re = re.compile('diff -r .* (.*)$')
     allhunks_re = re.compile('(?:index|deleted file) ')
     pretty_re = re.compile('(?:new file|deleted file) ')
     special_re = re.compile('(?:index|deleted|copy|rename) ')
     newfile_re = re.compile('(?:new file)')
 
     def __init__(self, header):
         self.header = header
         self.hunks = []
 
     def binary(self):
         return any(h.startswith('index ') for h in self.header)
 
     def pretty(self, fp):
         for h in self.header:
             if h.startswith('index '):
                 fp.write(_('this modifies a binary file (all or nothing)\n'))
                 break
             if self.pretty_re.match(h):
                 fp.write(h)
                 if self.binary():
                     fp.write(_('this is a binary file\n'))
                 break
             if h.startswith('---'):
                 fp.write(_('%d hunks, %d lines changed\n') %
                          (len(self.hunks),
                           sum([max(h.added, h.removed) for h in self.hunks])))
                 break
             fp.write(h)
 
     def write(self, fp):
         fp.write(''.join(self.header))
 
     def allhunks(self):
         return any(self.allhunks_re.match(h) for h in self.header)
 
     def files(self):
         match = self.diffgit_re.match(self.header[0])
         if match:
             fromfile, tofile = match.groups()
             if fromfile == tofile:
                 return [fromfile]
             return [fromfile, tofile]
         else:
             return self.diff_re.match(self.header[0]).groups()
 
     def filename(self):
         return self.files()[-1]
 
     def __repr__(self):
         return '<header %s>' % (' '.join(map(repr, self.files())))
 
     def isnewfile(self):
         return any(self.newfile_re.match(h) for h in self.header)
 
     def special(self):
         # Special files are shown only at the header level and not at the hunk
         # level for example a file that has been deleted is a special file.
         # The user cannot change the content of the operation, in the case of
         # the deleted file he has to take the deletion or not take it, he
         # cannot take some of it.
         # Newly added files are special if they are empty, they are not special
         # if they have some content as we want to be able to change it
         nocontent = len(self.header) == 2
         emptynewfile = self.isnewfile() and nocontent
         return emptynewfile or \
                 any(self.special_re.match(h) for h in self.header)
 
 class recordhunk(object):
     """patch hunk
 
     XXX shouldn't we merge this with the other hunk class?
     """
     maxcontext = 3
 
     def __init__(self, header, fromline, toline, proc, before, hunk, after):
         def trimcontext(number, lines):
             delta = len(lines) - self.maxcontext
             if False and delta > 0:
                 return number + delta, lines[:self.maxcontext]
             return number, lines
 
         self.header = header
         self.fromline, self.before = trimcontext(fromline, before)
         self.toline, self.after = trimcontext(toline, after)
         self.proc = proc
         self.hunk = hunk
         self.added, self.removed = self.countchanges(self.hunk)
 
     def __eq__(self, v):
         if not isinstance(v, recordhunk):
             return False
 
         return ((v.hunk == self.hunk) and
                 (v.proc == self.proc) and
                 (self.fromline == v.fromline) and
                 (self.header.files() == v.header.files()))
 
     def __hash__(self):
         return hash((tuple(self.hunk),
             tuple(self.header.files()),
             self.fromline,
             self.proc))
 
     def countchanges(self, hunk):
         """hunk -> (n+,n-)"""
         add = len([h for h in hunk if h[0] == '+'])
         rem = len([h for h in hunk if h[0] == '-'])
         return add, rem
 
     def write(self, fp):
         delta = len(self.before) + len(self.after)
         if self.after and self.after[-1] == '\\ No newline at end of file\n':
             delta -= 1
         fromlen = delta + self.removed
         tolen = delta + self.added
         fp.write('@@ -%d,%d +%d,%d @@%s\n' %
                  (self.fromline, fromlen, self.toline, tolen,
                   self.proc and (' ' + self.proc)))
         fp.write(''.join(self.before + self.hunk + self.after))
 
     pretty = write
 
     def filename(self):
         return self.header.filename()
 
     def __repr__(self):
         return '<hunk %r@%d>' % (self.filename(), self.fromline)
 
 def filterpatch(ui, headers, operation=None):
     """Interactively filter patch chunks into applied-only chunks"""
+    if operation is None:
+        operation = _('record')
 
     def prompt(skipfile, skipall, query, chunk):
         """prompt query, and process base inputs
 
         - y/n for the rest of file
         - y/n for the rest
         - ? (help)
         - q (quit)
 
         Return True/False and possibly updated skipfile and skipall.
         """
         newpatches = None
         if skipall is not None:
             return skipall, skipfile, skipall, newpatches
         if skipfile is not None:
             return skipfile, skipfile, skipall, newpatches
         while True:
             resps = _('[Ynesfdaq?]'
                       '$$ &Yes, record this change'
                       '$$ &No, skip this change'
                       '$$ &Edit this change manually'
                       '$$ &Skip remaining changes to this file'
                       '$$ Record remaining changes to this &file'
                       '$$ &Done, skip remaining changes and files'
                       '$$ Record &all changes to all remaining files'
                       '$$ &Quit, recording no changes'
                       '$$ &? (display help)')
             r = ui.promptchoice("%s %s" % (query, resps))
             ui.write("\n")
             if r == 8: # ?
                 for c, t in ui.extractchoices(resps)[1]:
                     ui.write('%s - %s\n' % (c, t.lower()))
                 continue
             elif r == 0: # yes
                 ret = True
             elif r == 1: # no
                 ret = False
             elif r == 2: # Edit patch
                 if chunk is None:
                     ui.write(_('cannot edit patch for whole file'))
                     ui.write("\n")
                     continue
                 if chunk.header.binary():
                     ui.write(_('cannot edit patch for binary file'))
                     ui.write("\n")
                     continue
                 # Patch comment based on the Git one (based on comment at end of
                 # http://mercurial.selenic.com/wiki/RecordExtension)
                 phelp = '---' + _("""
 To remove '-' lines, make them ' ' lines (context).
 To remove '+' lines, delete them.
 Lines starting with # will be removed from the patch.
 
 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.
 """)
                 (patchfd, patchfn) = tempfile.mkstemp(prefix="hg-editor-",
                         suffix=".diff", text=True)
                 ncpatchfp = None
                 try:
                     # Write the initial patch
                     f = os.fdopen(patchfd, "w")
                     chunk.header.write(f)
                     chunk.write(f)
                     f.write('\n'.join(['# ' + i for i in phelp.splitlines()]))
                     f.close()
                     # Start the editor and wait for it to complete
                     editor = ui.geteditor()
                     ui.system("%s \"%s\"" % (editor, patchfn),
                               environ={'HGUSER': ui.username()},
                               onerr=util.Abort, errprefix=_("edit failed"))
                     # Remove comment lines
                     patchfp = open(patchfn)
                     ncpatchfp = cStringIO.StringIO()
                     for line in patchfp:
                         if not line.startswith('#'):
                             ncpatchfp.write(line)
                     patchfp.close()
                     ncpatchfp.seek(0)
                     newpatches = parsepatch(ncpatchfp)
                 finally:
                     os.unlink(patchfn)
                     del ncpatchfp
                 # Signal that the chunk shouldn't be applied as-is, but
                 # provide the new patch to be used instead.
                 ret = False
             elif r == 3: # Skip
                 ret = skipfile = False
             elif r == 4: # file (Record remaining)
                 ret = skipfile = True
             elif r == 5: # done, skip remaining
                 ret = skipall = False
             elif r == 6: # all
                 ret = skipall = True
             elif r == 7: # quit
                 raise util.Abort(_('user quit'))
             return ret, skipfile, skipall, newpatches
 
     seen = set()
     applied = {}        # 'filename' -> [] of chunks
     skipfile, skipall = None, None
     pos, total = 1, sum(len(h.hunks) for h in headers)
     for h in headers:
         pos += len(h.hunks)
         skipfile = None
         fixoffset = 0
         hdr = ''.join(h.header)
         if hdr in seen:
             continue
         seen.add(hdr)
         if skipall is None:
             h.pretty(ui)
         msg = (_('examine changes to %s?') %
                _(' and ').join("'%s'" % f for f in h.files()))
         r, skipfile, skipall, np = prompt(skipfile, skipall, msg, None)
         if not r:
             continue
         applied[h.filename()] = [h]
         if h.allhunks():
             applied[h.filename()] += h.hunks
             continue
         for i, chunk in enumerate(h.hunks):
             if skipfile is None and skipall is None:
                 chunk.pretty(ui)
             if total == 1:
                 msg = _("record this change to '%s'?") % chunk.filename()
             else:
                 idx = pos - len(h.hunks) + i
                 msg = _("record change %d/%d to '%s'?") % (idx, total,
                                                            chunk.filename())
             r, skipfile, skipall, newpatches = prompt(skipfile,
                     skipall, msg, chunk)
             if r:
                 if fixoffset:
                     chunk = copy.copy(chunk)
                     chunk.toline += fixoffset
                 applied[chunk.filename()].append(chunk)
             elif newpatches is not None:
                 for newpatch in newpatches:
                     for newhunk in newpatch.hunks:
                         if fixoffset:
                             newhunk.toline += fixoffset
                         applied[newhunk.filename()].append(newhunk)
             else:
                 fixoffset += chunk.removed - chunk.added
     return sum([h for h in applied.itervalues()
                if h[0].special() or len(h) > 1], [])
 class hunk(object):
     def __init__(self, desc, num, lr, context):
         self.number = num
         self.desc = desc
         self.hunk = [desc]
         self.a = []
         self.b = []
         self.starta = self.lena = None
         self.startb = self.lenb = None
         if lr is not None:
             if context:
                 self.read_context_hunk(lr)
             else:
                 self.read_unified_hunk(lr)
 
     def getnormalized(self):
         """Return a copy with line endings normalized to LF."""
 
         def normalize(lines):
             nlines = []
             for line in lines:
                 if line.endswith('\r\n'):
                     line = line[:-2] + '\n'
                 nlines.append(line)
             return nlines
 
         # Dummy object, it is rebuilt manually
         nh = hunk(self.desc, self.number, None, None)
         nh.number = self.number
         nh.desc = self.desc
         nh.hunk = self.hunk
         nh.a = normalize(self.a)
         nh.b = normalize(self.b)
         nh.starta = self.starta
         nh.startb = self.startb
         nh.lena = self.lena
         nh.lenb = self.lenb
         return nh
 
     def read_unified_hunk(self, lr):
         m = unidesc.match(self.desc)
         if not m:
             raise PatchError(_("bad hunk #%d") % self.number)
         self.starta, self.lena, self.startb, self.lenb = m.groups()
         if self.lena is None:
             self.lena = 1
         else:
             self.lena = int(self.lena)
         if self.lenb is None:
             self.lenb = 1
         else:
             self.lenb = int(self.lenb)
         self.starta = int(self.starta)
         self.startb = int(self.startb)
         diffhelpers.addlines(lr, self.hunk, self.lena, self.lenb, self.a,
                              self.b)
         # if we hit eof before finishing out the hunk, the last line will
         # be zero length.  Lets try to fix it up.
         while len(self.hunk[-1]) == 0:
             del self.hunk[-1]
             del self.a[-1]
             del self.b[-1]
             self.lena -= 1
             self.lenb -= 1
         self._fixnewline(lr)
 
     def read_context_hunk(self, lr):
         self.desc = lr.readline()
         m = contextdesc.match(self.desc)
         if not m:
             raise PatchError(_("bad hunk #%d") % self.number)
         self.starta, aend = m.groups()
         self.starta = int(self.starta)
         if aend is None:
             aend = self.starta
         self.lena = int(aend) - self.starta
         if self.starta:
             self.lena += 1
         for x in xrange(self.lena):
             l = lr.readline()
             if l.startswith('---'):
                 # lines addition, old block is empty
                 lr.push(l)
                 break
             s = l[2:]
             if l.startswith('- ') or l.startswith('! '):
                 u = '-' + s
             elif l.startswith('  '):
                 u = ' ' + s
             else:
                 raise PatchError(_("bad hunk #%d old text line %d") %
                                  (self.number, x))
             self.a.append(u)
             self.hunk.append(u)
 
         l = lr.readline()
         if l.startswith('\ '):
             s = self.a[-1][:-1]
             self.a[-1] = s
             self.hunk[-1] = s
             l = lr.readline()
         m = contextdesc.match(l)
         if not m:
             raise PatchError(_("bad hunk #%d") % self.number)
         self.startb, bend = m.groups()
         self.startb = int(self.startb)
         if bend is None:
             bend = self.startb
         self.lenb = int(bend) - self.startb
         if self.startb:
             self.lenb += 1
         hunki = 1
         for x in xrange(self.lenb):
             l = lr.readline()
             if l.startswith('\ '):
                 # XXX: the only way to hit this is with an invalid line range.
                 # The no-eol marker is not counted in the line range, but I
                 # guess there are diff(1) out there which behave differently.
                 s = self.b[-1][:-1]
                 self.b[-1] = s
                 self.hunk[hunki - 1] = s
                 continue
             if not l:
                 # line deletions, new block is empty and we hit EOF
                 lr.push(l)
                 break
             s = l[2:]
             if l.startswith('+ ') or l.startswith('! '):
                 u = '+' + s
             elif l.startswith('  '):
                 u = ' ' + s
             elif len(self.b) == 0:
                 # line deletions, new block is empty
                 lr.push(l)
                 break
             else:
                 raise PatchError(_("bad hunk #%d old text line %d") %
                                  (self.number, x))
             self.b.append(s)
             while True:
                 if hunki >= len(self.hunk):
                     h = ""
                 else:
                     h = self.hunk[hunki]
                 hunki += 1
                 if h == u:
                     break
                 elif h.startswith('-'):
                     continue
                 else:
                     self.hunk.insert(hunki - 1, u)
                     break
 
         if not self.a:
             # this happens when lines were only added to the hunk
             for x in self.hunk:
                 if x.startswith('-') or x.startswith(' '):
                     self.a.append(x)
         if not self.b:
             # this happens when lines were only deleted from the hunk
             for x in self.hunk:
                 if x.startswith('+') or x.startswith(' '):
                     self.b.append(x[1:])
         # @@ -start,len +start,len @@
         self.desc = "@@ -%d,%d +%d,%d @@\n" % (self.starta, self.lena,
                                              self.startb, self.lenb)
         self.hunk[0] = self.desc
         self._fixnewline(lr)
 
     def _fixnewline(self, lr):
         l = lr.readline()
         if l.startswith('\ '):
             diffhelpers.fix_newline(self.hunk, self.a, self.b)
         else:
             lr.push(l)
 
     def complete(self):
         return len(self.a) == self.lena and len(self.b) == self.lenb
 
     def _fuzzit(self, old, new, fuzz, toponly):
         # this removes context lines from the top and bottom of list 'l'.  It
         # checks the hunk to make sure only context lines are removed, and then
         # returns a new shortened list of lines.
         fuzz = min(fuzz, len(old))
         if fuzz:
             top = 0
             bot = 0
             hlen = len(self.hunk)
             for x in xrange(hlen - 1):
                 # the hunk starts with the @@ line, so use x+1
                 if self.hunk[x + 1][0] == ' ':
                     top += 1
                 else:
                     break
             if not toponly:
                 for x in xrange(hlen - 1):
                     if self.hunk[hlen - bot - 1][0] == ' ':
                         bot += 1
                     else:
                         break
 
             bot = min(fuzz, bot)
             top = min(fuzz, top)
             return old[top:len(old) - bot], new[top:len(new) - bot], top
         return old, new, 0
 
     def fuzzit(self, fuzz, toponly):
         old, new, top = self._fuzzit(self.a, self.b, fuzz, toponly)
         oldstart = self.starta + top
         newstart = self.startb + top
         # zero length hunk ranges already have their start decremented
         if self.lena and oldstart > 0:
             oldstart -= 1
         if self.lenb and newstart > 0:
             newstart -= 1
         return old, oldstart, new, newstart
 
 class binhunk(object):
     'A binary patch file.'
     def __init__(self, lr, fname):
         self.text = None
         self.delta = False
         self.hunk = ['GIT binary patch\n']
         self._fname = fname
         self._read(lr)
 
     def complete(self):
         return self.text is not None
 
     def new(self, lines):
         if self.delta:
             return [applybindelta(self.text, ''.join(lines))]
         return [self.text]
 
     def _read(self, lr):
         def getline(lr, hunk):
             l = lr.readline()
             hunk.append(l)
             return l.rstrip('\r\n')
 
         size = 0
         while True:
             line = getline(lr, self.hunk)
             if not line:
                 raise PatchError(_('could not extract "%s" binary data')
                                  % self._fname)
             if line.startswith('literal '):
                 size = int(line[8:].rstrip())
                 break
             if line.startswith('delta '):
                 size = int(line[6:].rstrip())
                 self.delta = True
                 break
         dec = []
         line = getline(lr, self.hunk)
         while len(line) > 1:
             l = line[0]
             if l <= 'Z' and l >= 'A':
                 l = ord(l) - ord('A') + 1
             else:
                 l = ord(l) - ord('a') + 27
             try:
                 dec.append(base85.b85decode(line[1:])[:l])
             except ValueError, e:
                 raise PatchError(_('could not decode "%s" binary patch: %s')
                                  % (self._fname, str(e)))
             line = getline(lr, self.hunk)
         text = zlib.decompress(''.join(dec))
         if len(text) != size:
             raise PatchError(_('"%s" length is %d bytes, should be %d')
                              % (self._fname, len(text), size))
         self.text = text
 
 def parsefilename(str):
     # --- filename \t|space stuff
     s = str[4:].rstrip('\r\n')
     i = s.find('\t')
     if i < 0:
         i = s.find(' ')
         if i < 0:
             return s
     return s[:i]
 
 def parsepatch(originalchunks):
     """patch -> [] of headers -> [] of hunks """
     class parser(object):
         """patch parsing state machine"""
         def __init__(self):
             self.fromline = 0
             self.toline = 0
             self.proc = ''
             self.header = None
             self.context = []
             self.before = []
             self.hunk = []
             self.headers = []
 
         def addrange(self, limits):
             fromstart, fromend, tostart, toend, proc = limits
             self.fromline = int(fromstart)
             self.toline = int(tostart)
             self.proc = proc
 
         def addcontext(self, context):
             if self.hunk:
                 h = recordhunk(self.header, self.fromline, self.toline,
                         self.proc, self.before, self.hunk, context)
                 self.header.hunks.append(h)
                 self.fromline += len(self.before) + h.removed
                 self.toline += len(self.before) + h.added
                 self.before = []
                 self.hunk = []
                 self.proc = ''
             self.context = context
 
         def addhunk(self, hunk):
             if self.context:
                 self.before = self.context
                 self.context = []
             self.hunk = hunk
 
         def newfile(self, hdr):
             self.addcontext([])
             h = header(hdr)
             self.headers.append(h)
             self.header = h
 
         def addother(self, line):
             pass # 'other' lines are ignored
 
         def finished(self):
             self.addcontext([])
             return self.headers
 
         transitions = {
             'file': {'context': addcontext,
                      'file': newfile,
                      'hunk': addhunk,
                      'range': addrange},
             'context': {'file': newfile,
                         'hunk': addhunk,
                         'range': addrange,
                         'other': addother},
             'hunk': {'context': addcontext,
                      'file': newfile,
                      'range': addrange},
             'range': {'context': addcontext,
                       'hunk': addhunk},
             'other': {'other': addother},
             }
 
     p = parser()
     fp = cStringIO.StringIO()
     fp.write(''.join(originalchunks))
     fp.seek(0)
 
     state = 'context'
     for newstate, data in scanpatch(fp):
         try:
             p.transitions[state][newstate](p, data)
         except KeyError:
             raise PatchError('unhandled transition: %s -> %s' %
                                    (state, newstate))
         state = newstate
     del fp
     return p.finished()
 
 def pathtransform(path, strip, prefix):
     '''turn a path from a patch into a path suitable for the repository
 
     prefix, if not empty, is expected to be normalized with a / at the end.
 
     Returns (stripped components, path in repository).
 
     >>> pathtransform('a/b/c', 0, '')
     ('', 'a/b/c')
     >>> pathtransform('   a/b/c   ', 0, '')
     ('', '   a/b/c')
     >>> pathtransform('   a/b/c   ', 2, '')
     ('a/b/', 'c')
     >>> pathtransform('a/b/c', 0, 'd/e/')
     ('', 'd/e/a/b/c')
     >>> pathtransform('   a//b/c   ', 2, 'd/e/')
     ('a//b/', 'd/e/c')
     >>> pathtransform('a/b/c', 3, '')
     Traceback (most recent call last):
     PatchError: unable to strip away 1 of 3 dirs from a/b/c
     '''
     pathlen = len(path)
     i = 0
     if strip == 0:
         return '', prefix + path.rstrip()
     count = strip
     while count > 0:
         i = path.find('/', i)
         if i == -1:
             raise PatchError(_("unable to strip away %d of %d dirs from %s") %
                              (count, strip, path))
         i += 1
         # consume '//' in the path
         while i < pathlen - 1 and path[i] == '/':
             i += 1
         count -= 1
     return path[:i].lstrip(), prefix + path[i:].rstrip()
 
 def makepatchmeta(backend, afile_orig, bfile_orig, hunk, strip, prefix):
     nulla = afile_orig == "/dev/null"
     nullb = bfile_orig == "/dev/null"
     create = nulla and hunk.starta == 0 and hunk.lena == 0
     remove = nullb and hunk.startb == 0 and hunk.lenb == 0
     abase, afile = pathtransform(afile_orig, strip, prefix)
     gooda = not nulla and backend.exists(afile)
     bbase, bfile = pathtransform(bfile_orig, strip, prefix)
     if afile == bfile:
         goodb = gooda
     else:
         goodb = not nullb and backend.exists(bfile)
     missing = not goodb and not gooda and not create
 
     # some diff programs apparently produce patches where the afile is
     # not /dev/null, but afile starts with bfile
     abasedir = afile[:afile.rfind('/') + 1]
     bbasedir = bfile[:bfile.rfind('/') + 1]
     if (missing and abasedir == bbasedir and afile.startswith(bfile)
         and hunk.starta == 0 and hunk.lena == 0):
         create = True
         missing = False
 
     # If afile is "a/b/foo" and bfile is "a/b/foo.orig" we assume the
     # diff is between a file and its backup. In this case, the original
     # file should be patched (see original mpatch code).
     isbackup = (abase == bbase and bfile.startswith(afile))
     fname = None
     if not missing:
         if gooda and goodb:
             if isbackup:
                 fname = afile
             else:
                 fname = bfile
         elif gooda:
             fname = afile
 
     if not fname:
         if not nullb:
             if isbackup:
                 fname = afile
             else:
                 fname = bfile
         elif not nulla:
             fname = afile
         else:
             raise PatchError(_("undefined source and destination files"))
 
     gp = patchmeta(fname)
     if create:
         gp.op = 'ADD'
     elif remove:
         gp.op = 'DELETE'
     return gp
 
 def scanpatch(fp):
     """like patch.iterhunks, but yield different events
 
     - ('file',    [header_lines + fromfile + tofile])
     - ('context', [context_lines])
     - ('hunk',    [hunk_lines])
     - ('range',   (-start,len, +start,len, proc))
     """
     lines_re = re.compile(r'@@ -(\d+),(\d+) \+(\d+),(\d+) @@\s*(.*)')
     lr = linereader(fp)
 
     def scanwhile(first, p):
         """scan lr while predicate holds"""
         lines = [first]
         while True:
             line = lr.readline()
             if not line:
                 break
             if p(line):
                 lines.append(line)
             else:
                 lr.push(line)
                 break
         return lines
 
     while True:
         line = lr.readline()
         if not line:
             break
         if line.startswith('diff --git a/') or line.startswith('diff -r '):
             def notheader(line):
                 s = line.split(None, 1)
                 return not s or s[0] not in ('---', 'diff')
             header = scanwhile(line, notheader)
             fromfile = lr.readline()
             if fromfile.startswith('---'):
                 tofile = lr.readline()
                 header += [fromfile, tofile]
             else:
                 lr.push(fromfile)
             yield 'file', header
         elif line[0] == ' ':
             yield 'context', scanwhile(line, lambda l: l[0] in ' \\')
         elif line[0] in '-+':
             yield 'hunk', scanwhile(line, lambda l: l[0] in '-+\\')
         else:
             m = lines_re.match(line)
             if m:
                 yield 'range', m.groups()
             else:
                 yield 'other', line
 
 def scangitpatch(lr, firstline):
     """
     Git patches can emit:
     - rename a to b
     - change b
     - copy a to c
     - change c
 
     We cannot apply this sequence as-is, the renamed 'a' could not be
     found for it would have been renamed already. And we cannot copy
     from 'b' instead because 'b' would have been changed already. So
     we scan the git patch for copy and rename commands so we can
     perform the copies ahead of time.
     """
     pos = 0
     try:
         pos = lr.fp.tell()
         fp = lr.fp
     except IOError:
         fp = cStringIO.StringIO(lr.fp.read())
     gitlr = linereader(fp)
     gitlr.push(firstline)
     gitpatches = readgitpatch(gitlr)
     fp.seek(pos)
     return gitpatches
 
 def iterhunks(fp):
     """Read a patch and yield the following events:
     - ("file", afile, bfile, firsthunk): select a new target file.
     - ("hunk", hunk): a new hunk is ready to be applied, follows a
     "file" event.
     - ("git", gitchanges): current diff is in git format, gitchanges
     maps filenames to gitpatch records. Unique event.
     """
     afile = ""
     bfile = ""
     state = None
     hunknum = 0
     emitfile = newfile = False
     gitpatches = None
 
     # our states
     BFILE = 1
     context = None
     lr = linereader(fp)
 
     while True:
         x = lr.readline()
         if not x:
             break
         if state == BFILE and (
             (not context and x[0] == '@')
             or (context is not False and x.startswith('***************'))
             or x.startswith('GIT binary patch')):
             gp = None
             if (gitpatches and
                 gitpatches[-1].ispatching(afile, bfile)):
                 gp = gitpatches.pop()
             if x.startswith('GIT binary patch'):
                 h = binhunk(lr, gp.path)
             else:
                 if context is None and x.startswith('***************'):
                     context = True
                 h = hunk(x, hunknum + 1, lr, context)
             hunknum += 1
             if emitfile:
                 emitfile = False
                 yield 'file', (afile, bfile, h, gp and gp.copy() or None)
             yield 'hunk', h
         elif x.startswith('diff --git a/'):
             m = gitre.match(x.rstrip(' \r\n'))
             if not m:
                 continue
             if gitpatches is None:
                 # scan whole input for git metadata
                 gitpatches = scangitpatch(lr, x)
                 yield 'git', [g.copy() for g in gitpatches
                               if g.op in ('COPY', 'RENAME')]
                 gitpatches.reverse()
             afile = 'a/' + m.group(1)
             bfile = 'b/' + m.group(2)
             while gitpatches and not gitpatches[-1].ispatching(afile, bfile):
                 gp = gitpatches.pop()
                 yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp.copy())
             if not gitpatches:
                 raise PatchError(_('failed to synchronize metadata for "%s"')
                                  % afile[2:])
             gp = gitpatches[-1]
             newfile = True
         elif x.startswith('---'):
             # check for a unified diff
             l2 = lr.readline()
             if not l2.startswith('+++'):
                 lr.push(l2)
                 continue
             newfile = True
             context = False
             afile = parsefilename(x)
             bfile = parsefilename(l2)
         elif x.startswith('***'):
             # check for a context diff
             l2 = lr.readline()
             if not l2.startswith('---'):
                 lr.push(l2)
                 continue
             l3 = lr.readline()
             lr.push(l3)
             if not l3.startswith("***************"):
                 lr.push(l2)
                 continue
             newfile = True
             context = True
             afile = parsefilename(x)
             bfile = parsefilename(l2)
 
         if newfile:
             newfile = False
             emitfile = True
             state = BFILE
             hunknum = 0
 
     while gitpatches:
         gp = gitpatches.pop()
         yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp.copy())
 
 def applybindelta(binchunk, data):
     """Apply a binary delta hunk
     The algorithm used is the algorithm from git's patch-delta.c
     """
     def deltahead(binchunk):
         i = 0
         for c in binchunk:
             i += 1
             if not (ord(c) & 0x80):
                 return i
         return i
     out = ""
     s = deltahead(binchunk)
     binchunk = binchunk[s:]
     s = deltahead(binchunk)
     binchunk = binchunk[s:]
     i = 0
     while i < len(binchunk):
         cmd = ord(binchunk[i])
         i += 1
         if (cmd & 0x80):
             offset = 0
             size = 0
             if (cmd & 0x01):
                 offset = ord(binchunk[i])
                 i += 1
             if (cmd & 0x02):
                 offset |= ord(binchunk[i]) << 8
                 i += 1
             if (cmd & 0x04):
                 offset |= ord(binchunk[i]) << 16
                 i += 1
             if (cmd & 0x08):
                 offset |= ord(binchunk[i]) << 24
                 i += 1
             if (cmd & 0x10):
                 size = ord(binchunk[i])
                 i += 1
             if (cmd & 0x20):
                 size |= ord(binchunk[i]) << 8
                 i += 1
             if (cmd & 0x40):
                 size |= ord(binchunk[i]) << 16
                 i += 1
             if size == 0:
                 size = 0x10000
             offset_end = offset + size
             out += data[offset:offset_end]
         elif cmd != 0:
             offset_end = i + cmd
             out += binchunk[i:offset_end]
             i += cmd
         else:
             raise PatchError(_('unexpected delta opcode 0'))
     return out
 
 def applydiff(ui, fp, backend, store, strip=1, prefix='', eolmode='strict'):
     """Reads a patch from fp and tries to apply it.
 
     Returns 0 for a clean patch, -1 if any rejects were found and 1 if
     there was any fuzz.
 
     If 'eolmode' is 'strict', the patch content and patched file are
     read in binary mode. Otherwise, line endings are ignored when
     patching then normalized according to 'eolmode'.
     """
     return _applydiff(ui, fp, patchfile, backend, store, strip=strip,
                       prefix=prefix, eolmode=eolmode)
 
 def _applydiff(ui, fp, patcher, backend, store, strip=1, prefix='',
                eolmode='strict'):
 
     if prefix:
         prefix = pathutil.canonpath(backend.repo.root, backend.repo.getcwd(),
                                     prefix)
         if prefix != '':
             prefix += '/'
     def pstrip(p):
         return pathtransform(p, strip - 1, prefix)[1]
 
     rejects = 0
     err = 0
     current_file = None
 
     for state, values in iterhunks(fp):
         if state == 'hunk':
             if not current_file:
                 continue
             ret = current_file.apply(values)
             if ret > 0:
                 err = 1
         elif state == 'file':
             if current_file:
                 rejects += current_file.close()
                 current_file = None
             afile, bfile, first_hunk, gp = values
             if gp:
                 gp.path = pstrip(gp.path)
                 if gp.oldpath:
                     gp.oldpath = pstrip(gp.oldpath)
             else:
                 gp = makepatchmeta(backend, afile, bfile, first_hunk, strip,
                                    prefix)
             if gp.op == 'RENAME':
                 backend.unlink(gp.oldpath)
             if not first_hunk:
                 if gp.op == 'DELETE':
                     backend.unlink(gp.path)
                     continue
                 data, mode = None, None
                 if gp.op in ('RENAME', 'COPY'):
                     data, mode = store.getfile(gp.oldpath)[:2]
                     # FIXME: failing getfile has never been handled here
                     assert data is not None
                 if gp.mode:
                     mode = gp.mode
                     if gp.op == 'ADD':
                         # Added files without content have no hunk and
                         # must be created
                         data = ''
                 if data or mode:
                     if (gp.op in ('ADD', 'RENAME', 'COPY')
                         and backend.exists(gp.path)):
                         raise PatchError(_("cannot create %s: destination "
                                            "already exists") % gp.path)
                     backend.setfile(gp.path, data, mode, gp.oldpath)
                 continue
             try:
                 current_file = patcher(ui, gp, backend, store,
                                        eolmode=eolmode)
             except PatchError, inst:
                 ui.warn(str(inst) + '\n')
                 current_file = None
                 rejects += 1
                 continue
         elif state == 'git':
             for gp in values:
                 path = pstrip(gp.oldpath)
                 data, mode = backend.getfile(path)
                 if data is None:
                     # The error ignored here will trigger a getfile()
                     # error in a place more appropriate for error
                     # handling, and will not interrupt the patching
                     # process.
                     pass
                 else:
                     store.setfile(path, data, mode)
         else:
             raise util.Abort(_('unsupported parser state: %s') % state)
 
     if current_file:
         rejects += current_file.close()
 
     if rejects:
         return -1
     return err
 
 def _externalpatch(ui, repo, patcher, patchname, strip, files,
                    similarity):
     """use <patcher> to apply <patchname> to the working directory.
     returns whether patch was applied with fuzz factor."""
 
     fuzz = False
     args = []
     cwd = repo.root
     if cwd:
         args.append('-d %s' % util.shellquote(cwd))
     fp = util.popen('%s %s -p%d < %s' % (patcher, ' '.join(args), strip,
                                        util.shellquote(patchname)))
     try:
         for line in fp:
             line = line.rstrip()
             ui.note(line + '\n')
             if line.startswith('patching file '):
                 pf = util.parsepatchoutput(line)
                 printed_file = False
                 files.add(pf)
             elif line.find('with fuzz') >= 0:
                 fuzz = True
                 if not printed_file:
                     ui.warn(pf + '\n')
                     printed_file = True
                 ui.warn(line + '\n')
             elif line.find('saving rejects to file') >= 0:
                 ui.warn(line + '\n')
             elif line.find('FAILED') >= 0:
                 if not printed_file:
                     ui.warn(pf + '\n')
                     printed_file = True
                 ui.warn(line + '\n')
     finally:
         if files:
             scmutil.marktouched(repo, files, similarity)
     code = fp.close()
     if code:
         raise PatchError(_("patch command failed: %s") %
                          util.explainexit(code)[0])
     return fuzz
 
 def patchbackend(ui, backend, patchobj, strip, prefix, files=None,
                  eolmode='strict'):
     if files is None:
         files = set()
     if eolmode is None:
         eolmode = ui.config('patch', 'eol', 'strict')
     if eolmode.lower() not in eolmodes:
         raise util.Abort(_('unsupported line endings type: %s') % eolmode)
     eolmode = eolmode.lower()
 
     store = filestore()
     try:
         fp = open(patchobj, 'rb')
     except TypeError:
         fp = patchobj
     try:
         ret = applydiff(ui, fp, backend, store, strip=strip, prefix=prefix,
                         eolmode=eolmode)
     finally:
         if fp != patchobj:
             fp.close()
         files.update(backend.close())
         store.close()
     if ret < 0:
         raise PatchError(_('patch failed to apply'))
     return ret > 0
 
 def internalpatch(ui, repo, patchobj, strip, prefix='', files=None,
                   eolmode='strict', similarity=0):
     """use builtin patch to apply <patchobj> to the working directory.
     returns whether patch was applied with fuzz factor."""
     backend = workingbackend(ui, repo, similarity)
     return patchbackend(ui, backend, patchobj, strip, prefix, files, eolmode)
 
 def patchrepo(ui, repo, ctx, store, patchobj, strip, prefix, files=None,
               eolmode='strict'):
     backend = repobackend(ui, repo, ctx, store)
     return patchbackend(ui, backend, patchobj, strip, prefix, files, eolmode)
 
 def patch(ui, repo, patchname, strip=1, prefix='', files=None, eolmode='strict',
           similarity=0):
     """Apply <patchname> to the working directory.
 
     'eolmode' specifies how end of lines should be handled. It can be:
     - 'strict': inputs are read in binary mode, EOLs are preserved
     - 'crlf': EOLs are ignored when patching and reset to CRLF
     - 'lf': EOLs are ignored when patching and reset to LF
     - None: get it from user settings, default to 'strict'
     'eolmode' is ignored when using an external patcher program.
 
     Returns whether patch was applied with fuzz factor.
     """
     patcher = ui.config('ui', 'patch')
     if files is None:
         files = set()
     if patcher:
         return _externalpatch(ui, repo, patcher, patchname, strip,
                               files, similarity)
     return internalpatch(ui, repo, patchname, strip, prefix, files, eolmode,
                          similarity)
 
 def changedfiles(ui, repo, patchpath, strip=1):
     backend = fsbackend(ui, repo.root)
     fp = open(patchpath, 'rb')
     try:
         changed = set()
         for state, values in iterhunks(fp):
             if state == 'file':
                 afile, bfile, first_hunk, gp = values
                 if gp:
                     gp.path = pathtransform(gp.path, strip - 1, '')[1]
                     if gp.oldpath:
                         gp.oldpath = pathtransform(gp.oldpath, strip - 1, '')[1]
                 else:
                     gp = makepatchmeta(backend, afile, bfile, first_hunk, strip,
                                        '')
                 changed.add(gp.path)
                 if gp.op == 'RENAME':
                     changed.add(gp.oldpath)
             elif state not in ('hunk', 'git'):
                 raise util.Abort(_('unsupported parser state: %s') % state)
         return changed
     finally:
         fp.close()
 
 class GitDiffRequired(Exception):
     pass
 
 def diffallopts(ui, opts=None, untrusted=False, section='diff'):
     '''return diffopts with all features supported and parsed'''
     return difffeatureopts(ui, opts=opts, untrusted=untrusted, section=section,
                            git=True, whitespace=True, formatchanging=True)
 
 diffopts = diffallopts
 
 def difffeatureopts(ui, opts=None, untrusted=False, section='diff', git=False,
                     whitespace=False, formatchanging=False):
     '''return diffopts with only opted-in features parsed
 
     Features:
     - git: git-style diffs
     - whitespace: whitespace options like ignoreblanklines and ignorews
     - formatchanging: options that will likely break or cause correctness issues
       with most diff parsers
     '''
     def get(key, name=None, getter=ui.configbool, forceplain=None):
         if opts:
             v = opts.get(key)
             if v:
                 return v
         if forceplain is not None and ui.plain():
             return forceplain
         return getter(section, name or key, None, untrusted=untrusted)
 
     # core options, expected to be understood by every diff parser
     buildopts = {
         'nodates': get('nodates'),
         'showfunc': get('show_function', 'showfunc'),
         'context': get('unified', getter=ui.config),
     }
 
     if git:
         buildopts['git'] = get('git')
     if whitespace:
         buildopts['ignorews'] = get('ignore_all_space', 'ignorews')
         buildopts['ignorewsamount'] = get('ignore_space_change',
                                           'ignorewsamount')
         buildopts['ignoreblanklines'] = get('ignore_blank_lines',
                                             'ignoreblanklines')
     if formatchanging:
         buildopts['text'] = opts and opts.get('text')
         buildopts['nobinary'] = get('nobinary')
         buildopts['noprefix'] = get('noprefix', forceplain=False)
 
     return mdiff.diffopts(**buildopts)
 
 def diff(repo, node1=None, node2=None, match=None, changes=None, opts=None,
          losedatafn=None, prefix='', relroot=''):
     '''yields diff of changes to files between two nodes, or node and
     working directory.
 
     if node1 is None, use first dirstate parent instead.
     if node2 is None, compare node1 with working directory.
 
     losedatafn(**kwarg) is a callable run when opts.upgrade=True and
     every time some change cannot be represented with the current
     patch format. Return False to upgrade to git patch format, True to
     accept the loss or raise an exception to abort the diff. It is
     called with the name of current file being diffed as 'fn'. If set
     to None, patches will always be upgraded to git format when
     necessary.
 
     prefix is a filename prefix that is prepended to all filenames on
     display (used for subrepos).
 
     relroot, if not empty, must be normalized with a trailing /. Any match
     patterns that fall outside it will be ignored.'''
 
     if opts is None:
         opts = mdiff.defaultopts
 
     if not node1 and not node2:
         node1 = repo.dirstate.p1()
 
     def lrugetfilectx():
         cache = {}
         order = collections.deque()
         def getfilectx(f, ctx):
             fctx = ctx.filectx(f, filelog=cache.get(f))
             if f not in cache:
                 if len(cache) > 20:
                     del cache[order.popleft()]
                 cache[f] = fctx.filelog()
             else:
                 order.remove(f)
             order.append(f)
             return fctx
         return getfilectx
     getfilectx = lrugetfilectx()
 
     ctx1 = repo[node1]
     ctx2 = repo[node2]
 
     relfiltered = False
     if relroot != '' and match.always():
         # as a special case, create a new matcher with just the relroot
         pats = [relroot]
         match = scmutil.match(ctx2, pats, default='path')
         relfiltered = True
 
     if not changes:
         changes = repo.status(ctx1, ctx2, match=match)
     modified, added, removed = changes[:3]
 
     if not modified and not added and not removed:
         return []
 
     if repo.ui.debugflag:
         hexfunc = hex
     else:
         hexfunc = short
     revs = [hexfunc(node) for node in [ctx1.node(), ctx2.node()] if node]
 
     copy = {}
     if opts.git or opts.upgrade:
         copy = copies.pathcopies(ctx1, ctx2, match=match)
 
     if relroot is not None:
         if not relfiltered:
             # XXX this would ideally be done in the matcher, but that is
             # generally meant to 'or' patterns, not 'and' them. In this case we
             # need to 'and' all the patterns from the matcher with relroot.
             def filterrel(l):
                 return [f for f in l if f.startswith(relroot)]
             modified = filterrel(modified)
             added = filterrel(added)
             removed = filterrel(removed)
             relfiltered = True
         # filter out copies where either side isn't inside the relative root
         copy = dict(((dst, src) for (dst, src) in copy.iteritems()
                      if dst.startswith(relroot)
                      and src.startswith(relroot)))
 
     def difffn(opts, losedata):
         return trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
                        copy, getfilectx, opts, losedata, prefix, relroot)
     if opts.upgrade and not opts.git:
         try:
             def losedata(fn):
                 if not losedatafn or not losedatafn(fn=fn):
                     raise GitDiffRequired
             # Buffer the whole output until we are sure it can be generated
             return list(difffn(opts.copy(git=False), losedata))
         except GitDiffRequired:
             return difffn(opts.copy(git=True), None)
     else:
         return difffn(opts, None)
 
 def difflabel(func, *args, **kw):
     '''yields 2-tuples of (output, label) based on the output of func()'''
     headprefixes = [('diff', 'diff.diffline'),
                     ('copy', 'diff.extended'),
                     ('rename', 'diff.extended'),
                     ('old', 'diff.extended'),
                     ('new', 'diff.extended'),
                     ('deleted', 'diff.extended'),
                     ('---', 'diff.file_a'),
                     ('+++', 'diff.file_b')]
     textprefixes = [('@', 'diff.hunk'),
                     ('-', 'diff.deleted'),
                     ('+', 'diff.inserted')]
     head = False
     for chunk in func(*args, **kw):
         lines = chunk.split('\n')
         for i, line in enumerate(lines):
             if i != 0:
                 yield ('\n', '')
             if head:
                 if line.startswith('@'):
                     head = False
             else:
                 if line and line[0] not in ' +-@\\':
                     head = True
             stripline = line
             diffline = False
             if not head and line and line[0] in '+-':
                 # highlight tabs and trailing whitespace, but only in
                 # changed lines
                 stripline = line.rstrip()
                 diffline = True
 
             prefixes = textprefixes
             if head:
                 prefixes = headprefixes
             for prefix, label in prefixes:
                 if stripline.startswith(prefix):
                     if diffline:
                         for token in tabsplitter.findall(stripline):
                             if '\t' == token[0]:
                                 yield (token, 'diff.tab')
                             else:
                                 yield (token, label)
                     else:
                         yield (stripline, label)
                     break
             else:
                 yield (line, '')
             if line != stripline:
                 yield (line[len(stripline):], 'diff.trailingwhitespace')
 
 def diffui(*args, **kw):
     '''like diff(), but yields 2-tuples of (output, label) for ui.write()'''
     return difflabel(diff, *args, **kw)
 
 def _filepairs(ctx1, modified, added, removed, copy, opts):
     '''generates tuples (f1, f2, copyop), where f1 is the name of the file
     before and f2 is the the name after. For added files, f1 will be None,
     and for removed files, f2 will be None. copyop may be set to None, 'copy'
     or 'rename' (the latter two only if opts.git is set).'''
     gone = set()
 
     copyto = dict([(v, k) for k, v in copy.items()])
 
     addedset, removedset = set(added), set(removed)
     # Fix up  added, since merged-in additions appear as
     # modifications during merges
     for f in modified:
         if f not in ctx1:
             addedset.add(f)
 
     for f in sorted(modified + added + removed):
         copyop = None
         f1, f2 = f, f
         if f in addedset:
             f1 = None
             if f in copy:
                 if opts.git:
                     f1 = copy[f]
                     if f1 in removedset and f1 not in gone:
                         copyop = 'rename'
                         gone.add(f1)
                     else:
                         copyop = 'copy'
         elif f in removedset:
             f2 = None
             if opts.git:
                 # have we already reported a copy above?
                 if (f in copyto and copyto[f] in addedset
                     and copy[copyto[f]] == f):
                     continue
         yield f1, f2, copyop
 
 def trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
             copy, getfilectx, opts, losedatafn, prefix, relroot):
     '''given input data, generate a diff and yield it in blocks
 
     If generating a diff would lose data like flags or binary data and
     losedatafn is not None, it will be called.
 
     relroot is removed and prefix is added to every path in the diff output.
 
     If relroot is not empty, this function expects every path in modified,
     added, removed and copy to start with it.'''
 
     def gitindex(text):
         if not text:
             text = ""
         l = len(text)
         s = util.sha1('blob %d\0' % l)
         s.update(text)
         return s.hexdigest()
 
     if opts.noprefix:
         aprefix = bprefix = ''
     else:
         aprefix = 'a/'
         bprefix = 'b/'
 
     def diffline(f, revs):
         revinfo = ' '.join(["-r %s" % rev for rev in revs])
         return 'diff %s %s' % (revinfo, f)
 
     date1 = util.datestr(ctx1.date())
     date2 = util.datestr(ctx2.date())
 
     gitmode = {'l': '120000', 'x': '100755', '': '100644'}
 
     if relroot != '' and (repo.ui.configbool('devel', 'all')
                           or repo.ui.configbool('devel', 'check-relroot')):
         for f in modified + added + removed + copy.keys() + copy.values():
             if f is not None and not f.startswith(relroot):
                 raise AssertionError(
                     "file %s doesn't start with relroot %s" % (f, relroot))
 
     for f1, f2, copyop in _filepairs(
             ctx1, modified, added, removed, copy, opts):
         content1 = None
         content2 = None
         flag1 = None
         flag2 = None
         if f1:
             content1 = getfilectx(f1, ctx1).data()
             if opts.git or losedatafn:
                 flag1 = ctx1.flags(f1)
         if f2:
             content2 = getfilectx(f2, ctx2).data()
             if opts.git or losedatafn:
                 flag2 = ctx2.flags(f2)
         binary = False
         if opts.git or losedatafn:
             binary = util.binary(content1) or util.binary(content2)
 
         if losedatafn and not opts.git:
             if (binary or
                 # copy/rename
                 f2 in copy or
                 # empty file creation
                 (not f1 and not content2) or
                 # empty file deletion
                 (not content1 and not f2) or
                 # create with flags
                 (not f1 and flag2) or
                 # change flags
                 (f1 and f2 and flag1 != flag2)):
                 losedatafn(f2 or f1)
 
         path1 = f1 or f2
         path2 = f2 or f1
         path1 = posixpath.join(prefix, path1[len(relroot):])
         path2 = posixpath.join(prefix, path2[len(relroot):])
         header = []
         if opts.git:
             header.append('diff --git %s%s %s%s' %
                           (aprefix, path1, bprefix, path2))
             if not f1: # added
                 header.append('new file mode %s' % gitmode[flag2])
             elif not f2: # removed
                 header.append('deleted file mode %s' % gitmode[flag1])
             else:  # modified/copied/renamed
                 mode1, mode2 = gitmode[flag1], gitmode[flag2]
                 if mode1 != mode2:
                     header.append('old mode %s' % mode1)
                     header.append('new mode %s' % mode2)
                 if copyop is not None:
                     header.append('%s from %s' % (copyop, path1))
                     header.append('%s to %s' % (copyop, path2))
         elif revs and not repo.ui.quiet:
             header.append(diffline(path1, revs))
 
         if binary and opts.git and not opts.nobinary:
             text = mdiff.b85diff(content1, content2)
             if text:
                 header.append('index %s..%s' %
                               (gitindex(content1), gitindex(content2)))
         else:
             text = mdiff.unidiff(content1, date1,
                                  content2, date2,
                                  path1, path2, opts=opts)
         if header and (text or len(header) > 1):
             yield '\n'.join(header) + '\n'
         if text:
             yield text
 
 def diffstatsum(stats):
     maxfile, maxtotal, addtotal, removetotal, binary = 0, 0, 0, 0, False
     for f, a, r, b in stats:
         maxfile = max(maxfile, encoding.colwidth(f))
         maxtotal = max(maxtotal, a + r)
         addtotal += a
         removetotal += r
         binary = binary or b
 
     return maxfile, maxtotal, addtotal, removetotal, binary
 
 def diffstatdata(lines):
     diffre = re.compile('^diff .*-r [a-z0-9]+\s(.*)$')
 
     results = []
     filename, adds, removes, isbinary = None, 0, 0, False
 
     def addresult():
         if filename:
             results.append((filename, adds, removes, isbinary))
 
     for line in lines:
         if line.startswith('diff'):
             addresult()
             # set numbers to 0 anyway when starting new file
             adds, removes, isbinary = 0, 0, False
             if line.startswith('diff --git a/'):
                 filename = gitre.search(line).group(2)
             elif line.startswith('diff -r'):
                 # format: "diff -r ... -r ... filename"
                 filename = diffre.search(line).group(1)
         elif line.startswith('+') and not line.startswith('+++ '):
             adds += 1
         elif line.startswith('-') and not line.startswith('--- '):
             removes += 1
         elif (line.startswith('GIT binary patch') or
               line.startswith('Binary file')):
             isbinary = True
     addresult()
     return results
 
 def diffstat(lines, width=80, git=False):
     output = []
     stats = diffstatdata(lines)
     maxname, maxtotal, totaladds, totalremoves, hasbinary = diffstatsum(stats)
 
     countwidth = len(str(maxtotal))
     if hasbinary and countwidth < 3:
         countwidth = 3
     graphwidth = width - countwidth - maxname - 6
     if graphwidth < 10:
         graphwidth = 10
 
     def scale(i):
         if maxtotal <= graphwidth:
             return i
         # If diffstat runs out of room it doesn't print anything,
         # which isn't very useful, so always print at least one + or -
         # if there were at least some changes.
         return max(i * graphwidth // maxtotal, int(bool(i)))
 
     for filename, adds, removes, isbinary in stats:
         if isbinary:
             count = 'Bin'
         else:
             count = adds + removes
         pluses = '+' * scale(adds)
         minuses = '-' * scale(removes)
         output.append(' %s%s |  %*s %s%s\n' %
                       (filename, ' ' * (maxname - encoding.colwidth(filename)),
                        countwidth, count, pluses, minuses))
 
     if stats:
         output.append(_(' %d files changed, %d insertions(+), '
                         '%d deletions(-)\n')
                       % (len(stats), totaladds, totalremoves))
 
     return ''.join(output)
 
 def diffstatui(*args, **kw):
     '''like diffstat(), but yields 2-tuples of (output, label) for
     ui.write()
     '''
 
     for line in diffstat(*args, **kw).splitlines():
         if line and line[-1] in '+-':
             name, graph = line.rsplit(' ', 1)
             yield (name + ' ', '')
             m = re.search(r'\++', graph)
             if m:
                 yield (m.group(0), 'diffstat.inserted')
             m = re.search(r'-+', graph)
             if m:
                 yield (m.group(0), 'diffstat.deleted')
         else:
             yield (line, '')
         yield ('\n', '')