merge with stable

hgext/mq.py

@@ -1,2793 +1,2795
 # mq.py - patch queues for mercurial
 #
 # Copyright 2005, 2006 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.
 
 '''manage a stack of patches
 
 This extension lets you work with a stack of patches in a Mercurial
 repository. It manages two stacks of patches - all known patches, and
 applied patches (subset of known patches).
 
 Known patches are represented as patch files in the .hg/patches
 directory. Applied patches are both patch files and changesets.
 
 Common tasks (use "hg help command" for more details)::
 
   create new patch                          qnew
   import existing patch                     qimport
 
   print patch series                        qseries
   print applied patches                     qapplied
 
   add known patch to applied stack          qpush
   remove patch from applied stack           qpop
   refresh contents of top applied patch     qrefresh
 
 By default, mq will automatically use git patches when required to
 avoid losing file mode changes, copy records, binary files or empty
 files creations or deletions. This behaviour can be configured with::
 
   [mq]
   git = auto/keep/yes/no
 
 If set to 'keep', mq will obey the [diff] section configuration while
 preserving existing git patches upon qrefresh. If set to 'yes' or
 'no', mq will override the [diff] section and always generate git or
 regular patches, possibly losing data in the second case.
 '''
 
 from mercurial.i18n import _
 from mercurial.node import bin, hex, short, nullid, nullrev
 from mercurial.lock import release
 from mercurial import commands, cmdutil, hg, patch, util
 from mercurial import repair, extensions, url, error
 import os, sys, re, errno
 
 commands.norepo += " qclone"
 
 # Patch names looks like unix-file names.
 # They must be joinable with queue directory and result in the patch path.
 normname = util.normpath
 
 class statusentry(object):
     def __init__(self, node, name):
         self.node, self.name = node, name
 
     def __str__(self):
         return hex(self.node) + ':' + self.name
 
 class patchheader(object):
     def __init__(self, pf, plainmode=False):
         def eatdiff(lines):
             while lines:
                 l = lines[-1]
                 if (l.startswith("diff -") or
                     l.startswith("Index:") or
                     l.startswith("===========")):
                     del lines[-1]
                 else:
                     break
         def eatempty(lines):
             while lines:
                 if not lines[-1].strip():
                     del lines[-1]
                 else:
                     break
 
         message = []
         comments = []
         user = None
         date = None
         parent = None
         format = None
         subject = None
         diffstart = 0
 
         for line in file(pf):
             line = line.rstrip()
             if (line.startswith('diff --git')
                 or (diffstart and line.startswith('+++ '))):
                 diffstart = 2
                 break
             diffstart = 0 # reset
             if line.startswith("--- "):
                 diffstart = 1
                 continue
             elif format == "hgpatch":
                 # parse values when importing the result of an hg export
                 if line.startswith("# User "):
                     user = line[7:]
                 elif line.startswith("# Date "):
                     date = line[7:]
                 elif line.startswith("# Parent "):
                     parent = line[9:]
                 elif not line.startswith("# ") and line:
                     message.append(line)
                     format = None
             elif line == '# HG changeset patch':
                 message = []
                 format = "hgpatch"
             elif (format != "tagdone" and (line.startswith("Subject: ") or
                                            line.startswith("subject: "))):
                 subject = line[9:]
                 format = "tag"
             elif (format != "tagdone" and (line.startswith("From: ") or
                                            line.startswith("from: "))):
                 user = line[6:]
                 format = "tag"
             elif (format != "tagdone" and (line.startswith("Date: ") or
                                            line.startswith("date: "))):
                 date = line[6:]
                 format = "tag"
             elif format == "tag" and line == "":
                 # when looking for tags (subject: from: etc) they
                 # end once you find a blank line in the source
                 format = "tagdone"
             elif message or line:
                 message.append(line)
             comments.append(line)
 
         eatdiff(message)
         eatdiff(comments)
         eatempty(message)
         eatempty(comments)
 
         # make sure message isn't empty
         if format and format.startswith("tag") and subject:
             message.insert(0, "")
             message.insert(0, subject)
 
         self.message = message
         self.comments = comments
         self.user = user
         self.date = date
         self.parent = parent
         self.haspatch = diffstart > 1
         self.plainmode = plainmode
 
     def setuser(self, user):
         if not self.updateheader(['From: ', '# User '], user):
             try:
                 patchheaderat = self.comments.index('# HG changeset patch')
                 self.comments.insert(patchheaderat + 1, '# User ' + user)
             except ValueError:
                 if self.plainmode or self._hasheader(['Date: ']):
                     self.comments = ['From: ' + user] + self.comments
                 else:
                     tmp = ['# HG changeset patch', '# User ' + user, '']
                     self.comments = tmp + self.comments
         self.user = user
 
     def setdate(self, date):
         if not self.updateheader(['Date: ', '# Date '], date):
             try:
                 patchheaderat = self.comments.index('# HG changeset patch')
                 self.comments.insert(patchheaderat + 1, '# Date ' + date)
             except ValueError:
                 if self.plainmode or self._hasheader(['From: ']):
                     self.comments = ['Date: ' + date] + self.comments
                 else:
                     tmp = ['# HG changeset patch', '# Date ' + date, '']
                     self.comments = tmp + self.comments
         self.date = date
 
     def setparent(self, parent):
         if not self.updateheader(['# Parent '], parent):
             try:
                 patchheaderat = self.comments.index('# HG changeset patch')
                 self.comments.insert(patchheaderat + 1, '# Parent ' + parent)
             except ValueError:
                 pass
         self.parent = parent
 
     def setmessage(self, message):
         if self.comments:
             self._delmsg()
         self.message = [message]
         self.comments += self.message
 
     def updateheader(self, prefixes, new):
         '''Update all references to a field in the patch header.
         Return whether the field is present.'''
         res = False
         for prefix in prefixes:
             for i in xrange(len(self.comments)):
                 if self.comments[i].startswith(prefix):
                     self.comments[i] = prefix + new
                     res = True
                     break
         return res
 
     def _hasheader(self, prefixes):
         '''Check if a header starts with any of the given prefixes.'''
         for prefix in prefixes:
             for comment in self.comments:
                 if comment.startswith(prefix):
                     return True
         return False
 
     def __str__(self):
         if not self.comments:
             return ''
         return '\n'.join(self.comments) + '\n\n'
 
     def _delmsg(self):
         '''Remove existing message, keeping the rest of the comments fields.
         If comments contains 'subject: ', message will prepend
         the field and a blank line.'''
         if self.message:
             subj = 'subject: ' + self.message[0].lower()
             for i in xrange(len(self.comments)):
                 if subj == self.comments[i].lower():
                     del self.comments[i]
                     self.message = self.message[2:]
                     break
         ci = 0
         for mi in self.message:
             while mi != self.comments[ci]:
                 ci += 1
             del self.comments[ci]
 
 class queue(object):
     def __init__(self, ui, path, patchdir=None):
         self.basepath = path
         self.path = patchdir or os.path.join(path, "patches")
         self.opener = util.opener(self.path)
         self.ui = ui
         self.applied_dirty = 0
         self.series_dirty = 0
         self.series_path = "series"
         self.status_path = "status"
         self.guards_path = "guards"
         self.active_guards = None
         self.guards_dirty = False
         # Handle mq.git as a bool with extended values
         try:
             gitmode = ui.configbool('mq', 'git', None)
             if gitmode is None:
                 raise error.ConfigError()
             self.gitmode = gitmode and 'yes' or 'no'
         except error.ConfigError:
             self.gitmode = ui.config('mq', 'git', 'auto').lower()
         self.plainmode = ui.configbool('mq', 'plain', False)
 
     @util.propertycache
     def applied(self):
         if os.path.exists(self.join(self.status_path)):
             def parse(l):
                 n, name = l.split(':', 1)
                 return statusentry(bin(n), name)
             lines = self.opener(self.status_path).read().splitlines()
             return [parse(l) for l in lines]
         return []
 
     @util.propertycache
     def full_series(self):
         if os.path.exists(self.join(self.series_path)):
             return self.opener(self.series_path).read().splitlines()
         return []
 
     @util.propertycache
     def series(self):
         self.parse_series()
         return self.series
 
     @util.propertycache
     def series_guards(self):
         self.parse_series()
         return self.series_guards
 
     def invalidate(self):
         for a in 'applied full_series series series_guards'.split():
             if a in self.__dict__:
                 delattr(self, a)
         self.applied_dirty = 0
         self.series_dirty = 0
         self.guards_dirty = False
         self.active_guards = None
 
     def diffopts(self, opts={}, patchfn=None):
         diffopts = patch.diffopts(self.ui, opts)
         if self.gitmode == 'auto':
             diffopts.upgrade = True
         elif self.gitmode == 'keep':
             pass
         elif self.gitmode in ('yes', 'no'):
             diffopts.git = self.gitmode == 'yes'
         else:
             raise util.Abort(_('mq.git option can be auto/keep/yes/no'
                                ' got %s') % self.gitmode)
         if patchfn:
             diffopts = self.patchopts(diffopts, patchfn)
         return diffopts
 
     def patchopts(self, diffopts, *patches):
         """Return a copy of input diff options with git set to true if
         referenced patch is a git patch and should be preserved as such.
         """
         diffopts = diffopts.copy()
         if not diffopts.git and self.gitmode == 'keep':
             for patchfn in patches:
                 patchf = self.opener(patchfn, 'r')
                 # if the patch was a git patch, refresh it as a git patch
                 for line in patchf:
                     if line.startswith('diff --git'):
                         diffopts.git = True
                         break
                 patchf.close()
         return diffopts
 
     def join(self, *p):
         return os.path.join(self.path, *p)
 
     def find_series(self, patch):
         def matchpatch(l):
             l = l.split('#', 1)[0]
             return l.strip() == patch
         for index, l in enumerate(self.full_series):
             if matchpatch(l):
                 return index
         return None
 
     guard_re = re.compile(r'\s?#([-+][^-+# \t\r\n\f][^# \t\r\n\f]*)')
 
     def parse_series(self):
         self.series = []
         self.series_guards = []
         for l in self.full_series:
             h = l.find('#')
             if h == -1:
                 patch = l
                 comment = ''
             elif h == 0:
                 continue
             else:
                 patch = l[:h]
                 comment = l[h:]
             patch = patch.strip()
             if patch:
                 if patch in self.series:
                     raise util.Abort(_('%s appears more than once in %s') %
                                      (patch, self.join(self.series_path)))
                 self.series.append(patch)
                 self.series_guards.append(self.guard_re.findall(comment))
 
     def check_guard(self, guard):
         if not guard:
             return _('guard cannot be an empty string')
         bad_chars = '# \t\r\n\f'
         first = guard[0]
         if first in '-+':
             return (_('guard %r starts with invalid character: %r') %
                       (guard, first))
         for c in bad_chars:
             if c in guard:
                 return _('invalid character in guard %r: %r') % (guard, c)
 
     def set_active(self, guards):
         for guard in guards:
             bad = self.check_guard(guard)
             if bad:
                 raise util.Abort(bad)
         guards = sorted(set(guards))
         self.ui.debug('active guards: %s\n' % ' '.join(guards))
         self.active_guards = guards
         self.guards_dirty = True
 
     def active(self):
         if self.active_guards is None:
             self.active_guards = []
             try:
                 guards = self.opener(self.guards_path).read().split()
             except IOError, err:
                 if err.errno != errno.ENOENT:
                     raise
                 guards = []
             for i, guard in enumerate(guards):
                 bad = self.check_guard(guard)
                 if bad:
                     self.ui.warn('%s:%d: %s\n' %
                                  (self.join(self.guards_path), i + 1, bad))
                 else:
                     self.active_guards.append(guard)
         return self.active_guards
 
     def set_guards(self, idx, guards):
         for g in guards:
             if len(g) < 2:
                 raise util.Abort(_('guard %r too short') % g)
             if g[0] not in '-+':
                 raise util.Abort(_('guard %r starts with invalid char') % g)
             bad = self.check_guard(g[1:])
             if bad:
                 raise util.Abort(bad)
         drop = self.guard_re.sub('', self.full_series[idx])
         self.full_series[idx] = drop + ''.join([' #' + g for g in guards])
         self.parse_series()
         self.series_dirty = True
 
     def pushable(self, idx):
         if isinstance(idx, str):
             idx = self.series.index(idx)
         patchguards = self.series_guards[idx]
         if not patchguards:
             return True, None
         guards = self.active()
         exactneg = [g for g in patchguards if g[0] == '-' and g[1:] in guards]
         if exactneg:
             return False, exactneg[0]
         pos = [g for g in patchguards if g[0] == '+']
         exactpos = [g for g in pos if g[1:] in guards]
         if pos:
             if exactpos:
                 return True, exactpos[0]
             return False, pos
         return True, ''
 
     def explain_pushable(self, idx, all_patches=False):
         write = all_patches and self.ui.write or self.ui.warn
         if all_patches or self.ui.verbose:
             if isinstance(idx, str):
                 idx = self.series.index(idx)
             pushable, why = self.pushable(idx)
             if all_patches and pushable:
                 if why is None:
                     write(_('allowing %s - no guards in effect\n') %
                           self.series[idx])
                 else:
                     if not why:
                         write(_('allowing %s - no matching negative guards\n') %
                               self.series[idx])
                     else:
                         write(_('allowing %s - guarded by %r\n') %
                               (self.series[idx], why))
             if not pushable:
                 if why:
                     write(_('skipping %s - guarded by %r\n') %
                           (self.series[idx], why))
                 else:
                     write(_('skipping %s - no matching guards\n') %
                           self.series[idx])
 
     def save_dirty(self):
         def write_list(items, path):
             fp = self.opener(path, 'w')
             for i in items:
                 fp.write("%s\n" % i)
             fp.close()
         if self.applied_dirty:
             write_list(map(str, self.applied), self.status_path)
         if self.series_dirty:
             write_list(self.full_series, self.series_path)
         if self.guards_dirty:
             write_list(self.active_guards, self.guards_path)
 
     def removeundo(self, repo):
         undo = repo.sjoin('undo')
         if not os.path.exists(undo):
             return
         try:
             os.unlink(undo)
         except OSError, inst:
             self.ui.warn(_('error removing undo: %s\n') % str(inst))
 
     def printdiff(self, repo, diffopts, node1, node2=None, files=None,
                   fp=None, changes=None, opts={}):
         stat = opts.get('stat')
         if stat:
             opts['unified'] = '0'
 
         m = cmdutil.match(repo, files, opts)
         chunks = patch.diff(repo, node1, node2, m, changes, diffopts)
         write = fp is None and repo.ui.write or fp.write
         if stat:
             width = self.ui.interactive() and util.termwidth() or 80
             write(patch.diffstat(util.iterlines(chunks), width=width,
                                  git=diffopts.git))
         else:
             for chunk in chunks:
                 write(chunk)
 
     def mergeone(self, repo, mergeq, head, patch, rev, diffopts):
         # first try just applying the patch
         (err, n) = self.apply(repo, [patch], update_status=False,
                               strict=True, merge=rev)
 
         if err == 0:
             return (err, n)
 
         if n is None:
             raise util.Abort(_("apply failed for patch %s") % patch)
 
         self.ui.warn(_("patch didn't work out, merging %s\n") % patch)
 
         # apply failed, strip away that rev and merge.
         hg.clean(repo, head)
         self.strip(repo, n, update=False, backup='strip')
 
         ctx = repo[rev]
         ret = hg.merge(repo, rev)
         if ret:
             raise util.Abort(_("update returned %d") % ret)
         n = repo.commit(ctx.description(), ctx.user(), force=True)
         if n is None:
             raise util.Abort(_("repo commit failed"))
         try:
             ph = patchheader(mergeq.join(patch), self.plainmode)
         except:
             raise util.Abort(_("unable to read %s") % patch)
 
         diffopts = self.patchopts(diffopts, patch)
         patchf = self.opener(patch, "w")
         comments = str(ph)
         if comments:
             patchf.write(comments)
         self.printdiff(repo, diffopts, head, n, fp=patchf)
         patchf.close()
         self.removeundo(repo)
         return (0, n)
 
     def qparents(self, repo, rev=None):
         if rev is None:
             (p1, p2) = repo.dirstate.parents()
             if p2 == nullid:
                 return p1
             if not self.applied:
                 return None
             return self.applied[-1].node
         p1, p2 = repo.changelog.parents(rev)
         if p2 != nullid and p2 in [x.node for x in self.applied]:
             return p2
         return p1
 
     def mergepatch(self, repo, mergeq, series, diffopts):
         if not self.applied:
             # each of the patches merged in will have two parents.  This
             # can confuse the qrefresh, qdiff, and strip code because it
             # needs to know which parent is actually in the patch queue.
             # so, we insert a merge marker with only one parent.  This way
             # the first patch in the queue is never a merge patch
             #
             pname = ".hg.patches.merge.marker"
             n = repo.commit('[mq]: merge marker', force=True)
             self.removeundo(repo)
             self.applied.append(statusentry(n, pname))
             self.applied_dirty = 1
 
         head = self.qparents(repo)
 
         for patch in series:
             patch = mergeq.lookup(patch, strict=True)
             if not patch:
                 self.ui.warn(_("patch %s does not exist\n") % patch)
                 return (1, None)
             pushable, reason = self.pushable(patch)
             if not pushable:
                 self.explain_pushable(patch, all_patches=True)
                 continue
             info = mergeq.isapplied(patch)
             if not info:
                 self.ui.warn(_("patch %s is not applied\n") % patch)
                 return (1, None)
             rev = info[1]
             err, head = self.mergeone(repo, mergeq, head, patch, rev, diffopts)
             if head:
                 self.applied.append(statusentry(head, patch))
                 self.applied_dirty = 1
             if err:
                 return (err, head)
         self.save_dirty()
         return (0, head)
 
     def patch(self, repo, patchfile):
         '''Apply patchfile  to the working directory.
         patchfile: name of patch file'''
         files = {}
         try:
             fuzz = patch.patch(patchfile, self.ui, strip=1, cwd=repo.root,
                                files=files, eolmode=None)
         except Exception, inst:
             self.ui.note(str(inst) + '\n')
             if not self.ui.verbose:
                 self.ui.warn(_("patch failed, unable to continue (try -v)\n"))
             return (False, files, False)
 
         return (True, files, fuzz)
 
     def apply(self, repo, series, list=False, update_status=True,
               strict=False, patchdir=None, merge=None, all_files=None):
         wlock = lock = tr = None
         try:
             wlock = repo.wlock()
             lock = repo.lock()
             tr = repo.transaction()
             try:
                 ret = self._apply(repo, series, list, update_status,
                                   strict, patchdir, merge, all_files=all_files)
                 tr.close()
                 self.save_dirty()
                 return ret
             except:
                 try:
                     tr.abort()
                 finally:
                     repo.invalidate()
                     repo.dirstate.invalidate()
                 raise
         finally:
             del tr
             release(lock, wlock)
             self.removeundo(repo)
 
     def _apply(self, repo, series, list=False, update_status=True,
                strict=False, patchdir=None, merge=None, all_files=None):
         '''returns (error, hash)
         error = 1 for unable to read, 2 for patch failed, 3 for patch fuzz'''
         # TODO unify with commands.py
         if not patchdir:
             patchdir = self.path
         err = 0
         n = None
         for patchname in series:
             pushable, reason = self.pushable(patchname)
             if not pushable:
                 self.explain_pushable(patchname, all_patches=True)
                 continue
             self.ui.status(_("applying %s\n") % patchname)
             pf = os.path.join(patchdir, patchname)
 
             try:
                 ph = patchheader(self.join(patchname), self.plainmode)
             except:
                 self.ui.warn(_("unable to read %s\n") % patchname)
                 err = 1
                 break
 
             message = ph.message
             if not message:
                 message = "imported patch %s\n" % patchname
             else:
                 if list:
                     message.append("\nimported patch %s" % patchname)
                 message = '\n'.join(message)
 
             if ph.haspatch:
                 (patcherr, files, fuzz) = self.patch(repo, pf)
                 if all_files is not None:
                     all_files.update(files)
                 patcherr = not patcherr
             else:
                 self.ui.warn(_("patch %s is empty\n") % patchname)
                 patcherr, files, fuzz = 0, [], 0
 
             if merge and files:
                 # Mark as removed/merged and update dirstate parent info
                 removed = []
                 merged = []
                 for f in files:
                     if os.path.exists(repo.wjoin(f)):
                         merged.append(f)
                     else:
                         removed.append(f)
                 for f in removed:
                     repo.dirstate.remove(f)
                 for f in merged:
                     repo.dirstate.merge(f)
                 p1, p2 = repo.dirstate.parents()
                 repo.dirstate.setparents(p1, merge)
 
             files = patch.updatedir(self.ui, repo, files)
             match = cmdutil.matchfiles(repo, files or [])
             n = repo.commit(message, ph.user, ph.date, match=match, force=True)
 
             if n is None:
                 raise util.Abort(_("repo commit failed"))
 
             if update_status:
                 self.applied.append(statusentry(n, patchname))
 
             if patcherr:
                 self.ui.warn(_("patch failed, rejects left in working dir\n"))
                 err = 2
                 break
 
             if fuzz and strict:
                 self.ui.warn(_("fuzz found when applying patch, stopping\n"))
                 err = 3
                 break
         return (err, n)
 
     def _cleanup(self, patches, numrevs, keep=False):
         if not keep:
             r = self.qrepo()
             if r:
                 r.remove(patches, True)
             else:
                 for p in patches:
                     os.unlink(self.join(p))
 
         if numrevs:
             del self.applied[:numrevs]
             self.applied_dirty = 1
 
         for i in sorted([self.find_series(p) for p in patches], reverse=True):
             del self.full_series[i]
         self.parse_series()
         self.series_dirty = 1
 
     def _revpatches(self, repo, revs):
         firstrev = repo[self.applied[0].node].rev()
         patches = []
         for i, rev in enumerate(revs):
 
             if rev < firstrev:
                 raise util.Abort(_('revision %d is not managed') % rev)
 
             ctx = repo[rev]
             base = self.applied[i].node
             if ctx.node() != base:
                 msg = _('cannot delete revision %d above applied patches')
                 raise util.Abort(msg % rev)
 
             patch = self.applied[i].name
             for fmt in ('[mq]: %s', 'imported patch %s'):
                 if ctx.description() == fmt % patch:
                     msg = _('patch %s finalized without changeset message\n')
                     repo.ui.status(msg % patch)
                     break
 
             patches.append(patch)
         return patches
 
     def finish(self, repo, revs):
         patches = self._revpatches(repo, sorted(revs))
         self._cleanup(patches, len(patches))
 
     def delete(self, repo, patches, opts):
         if not patches and not opts.get('rev'):
             raise util.Abort(_('qdelete requires at least one revision or '
                                'patch name'))
 
         realpatches = []
         for patch in patches:
             patch = self.lookup(patch, strict=True)
             info = self.isapplied(patch)
             if info:
                 raise util.Abort(_("cannot delete applied patch %s") % patch)
             if patch not in self.series:
                 raise util.Abort(_("patch %s not in series file") % patch)
             realpatches.append(patch)
 
         numrevs = 0
         if opts.get('rev'):
             if not self.applied:
                 raise util.Abort(_('no patches applied'))
             revs = cmdutil.revrange(repo, opts['rev'])
             if len(revs) > 1 and revs[0] > revs[1]:
                 revs.reverse()
             revpatches = self._revpatches(repo, revs)
             realpatches += revpatches
             numrevs = len(revpatches)
 
         self._cleanup(realpatches, numrevs, opts.get('keep'))
 
     def check_toppatch(self, repo):
         if self.applied:
             top = self.applied[-1].node
             patch = self.applied[-1].name
             pp = repo.dirstate.parents()
             if top not in pp:
                 raise util.Abort(_("working directory revision is not qtip"))
             return top, patch
         return None, None
 
     def check_localchanges(self, repo, force=False, refresh=True):
         m, a, r, d = repo.status()[:4]
         if (m or a or r or d) and not force:
             if refresh:
                 raise util.Abort(_("local changes found, refresh first"))
             else:
                 raise util.Abort(_("local changes found"))
         return m, a, r, d
 
     _reserved = ('series', 'status', 'guards')
     def check_reserved_name(self, name):
         if (name in self._reserved or name.startswith('.hg')
             or name.startswith('.mq') or '#' in name or ':' in name):
             raise util.Abort(_('"%s" cannot be used as the name of a patch')
                              % name)
 
     def new(self, repo, patchfn, *pats, **opts):
         """options:
            msg: a string or a no-argument function returning a string
         """
         msg = opts.get('msg')
         user = opts.get('user')
         date = opts.get('date')
         if date:
             date = util.parsedate(date)
         diffopts = self.diffopts({'git': opts.get('git')})
         self.check_reserved_name(patchfn)
         if os.path.exists(self.join(patchfn)):
             raise util.Abort(_('patch "%s" already exists') % patchfn)
         if opts.get('include') or opts.get('exclude') or pats:
             match = cmdutil.match(repo, pats, opts)
             # detect missing files in pats
             def badfn(f, msg):
                 raise util.Abort('%s: %s' % (f, msg))
             match.bad = badfn
             m, a, r, d = repo.status(match=match)[:4]
         else:
             m, a, r, d = self.check_localchanges(repo, force=True)
             match = cmdutil.matchfiles(repo, m + a + r)
         if len(repo[None].parents()) > 1:
             raise util.Abort(_('cannot manage merge changesets'))
         commitfiles = m + a + r
         self.check_toppatch(repo)
         insert = self.full_series_end()
         wlock = repo.wlock()
         try:
             # if patch file write fails, abort early
             p = self.opener(patchfn, "w")
             try:
                 if self.plainmode:
                     if user:
                         p.write("From: " + user + "\n")
                         if not date:
                             p.write("\n")
                     if date:
                         p.write("Date: %d %d\n\n" % date)
                 else:
                     p.write("# HG changeset patch\n")
                     p.write("# Parent "
                             + hex(repo[None].parents()[0].node()) + "\n")
                     if user:
                         p.write("# User " + user + "\n")
                     if date:
                         p.write("# Date %s %s\n\n" % date)
                 if hasattr(msg, '__call__'):
                     msg = msg()
                 commitmsg = msg and msg or ("[mq]: %s" % patchfn)
                 n = repo.commit(commitmsg, user, date, match=match, force=True)
                 if n is None:
                     raise util.Abort(_("repo commit failed"))
                 try:
                     self.full_series[insert:insert] = [patchfn]
                     self.applied.append(statusentry(n, patchfn))
                     self.parse_series()
                     self.series_dirty = 1
                     self.applied_dirty = 1
                     if msg:
                         msg = msg + "\n\n"
                         p.write(msg)
                     if commitfiles:
                         parent = self.qparents(repo, n)
                         chunks = patch.diff(repo, node1=parent, node2=n,
                                             match=match, opts=diffopts)
                         for chunk in chunks:
                             p.write(chunk)
                     p.close()
                     wlock.release()
                     wlock = None
                     r = self.qrepo()
                     if r:
                         r.add([patchfn])
                 except:
                     repo.rollback()
                     raise
             except Exception:
                 patchpath = self.join(patchfn)
                 try:
                     os.unlink(patchpath)
                 except:
                     self.ui.warn(_('error unlinking %s\n') % patchpath)
                 raise
             self.removeundo(repo)
         finally:
             release(wlock)
 
     def strip(self, repo, rev, update=True, backup="all", force=None):
         wlock = lock = None
         try:
             wlock = repo.wlock()
             lock = repo.lock()
 
             if update:
                 self.check_localchanges(repo, force=force, refresh=False)
                 urev = self.qparents(repo, rev)
                 hg.clean(repo, urev)
                 repo.dirstate.write()
 
             self.removeundo(repo)
             repair.strip(self.ui, repo, rev, backup)
             # strip may have unbundled a set of backed up revisions after
             # the actual strip
             self.removeundo(repo)
         finally:
             release(lock, wlock)
 
     def isapplied(self, patch):
         """returns (index, rev, patch)"""
         for i, a in enumerate(self.applied):
             if a.name == patch:
                 return (i, a.node, a.name)
         return None
 
     # if the exact patch name does not exist, we try a few
     # variations.  If strict is passed, we try only #1
     #
     # 1) a number to indicate an offset in the series file
     # 2) a unique substring of the patch name was given
     # 3) patchname[-+]num to indicate an offset in the series file
     def lookup(self, patch, strict=False):
         patch = patch and str(patch)
 
         def partial_name(s):
             if s in self.series:
                 return s
             matches = [x for x in self.series if s in x]
             if len(matches) > 1:
                 self.ui.warn(_('patch name "%s" is ambiguous:\n') % s)
                 for m in matches:
                     self.ui.warn('  %s\n' % m)
                 return None
             if matches:
                 return matches[0]
             if self.series and self.applied:
                 if s == 'qtip':
                     return self.series[self.series_end(True)-1]
                 if s == 'qbase':
                     return self.series[0]
             return None
 
         if patch is None:
             return None
         if patch in self.series:
             return patch
 
         if not os.path.isfile(self.join(patch)):
             try:
                 sno = int(patch)
             except (ValueError, OverflowError):
                 pass
             else:
                 if -len(self.series) <= sno < len(self.series):
                     return self.series[sno]
 
             if not strict:
                 res = partial_name(patch)
                 if res:
                     return res
                 minus = patch.rfind('-')
                 if minus >= 0:
                     res = partial_name(patch[:minus])
                     if res:
                         i = self.series.index(res)
                         try:
                             off = int(patch[minus + 1:] or 1)
                         except (ValueError, OverflowError):
                             pass
                         else:
                             if i - off >= 0:
                                 return self.series[i - off]
                 plus = patch.rfind('+')
                 if plus >= 0:
                     res = partial_name(patch[:plus])
                     if res:
                         i = self.series.index(res)
                         try:
                             off = int(patch[plus + 1:] or 1)
                         except (ValueError, OverflowError):
                             pass
                         else:
                             if i + off < len(self.series):
                                 return self.series[i + off]
         raise util.Abort(_("patch %s not in series") % patch)
 
     def push(self, repo, patch=None, force=False, list=False,
              mergeq=None, all=False):
         diffopts = self.diffopts()
         wlock = repo.wlock()
         try:
             heads = []
             for b, ls in repo.branchmap().iteritems():
                 heads += ls
             if not heads:
                 heads = [nullid]
             if repo.dirstate.parents()[0] not in heads:
                 self.ui.status(_("(working directory not at a head)\n"))
 
             if not self.series:
                 self.ui.warn(_('no patches in series\n'))
                 return 0
 
             patch = self.lookup(patch)
             # Suppose our series file is: A B C and the current 'top'
             # patch is B. qpush C should be performed (moving forward)
             # qpush B is a NOP (no change) qpush A is an error (can't
             # go backwards with qpush)
             if patch:
                 info = self.isapplied(patch)
                 if info:
                     if info[0] < len(self.applied) - 1:
                         raise util.Abort(
                             _("cannot push to a previous patch: %s") % patch)
                     self.ui.warn(
                         _('qpush: %s is already at the top\n') % patch)
                     return
                 pushable, reason = self.pushable(patch)
                 if not pushable:
                     if reason:
                         reason = _('guarded by %r') % reason
                     else:
                         reason = _('no matching guards')
                     self.ui.warn(_("cannot push '%s' - %s\n") % (patch, reason))
                     return 1
             elif all:
                 patch = self.series[-1]
                 if self.isapplied(patch):
                     self.ui.warn(_('all patches are currently applied\n'))
                     return 0
 
             # Following the above example, starting at 'top' of B:
             # qpush should be performed (pushes C), but a subsequent
             # qpush without an argument is an error (nothing to
             # apply). This allows a loop of "...while hg qpush..." to
             # work as it detects an error when done
             start = self.series_end()
             if start == len(self.series):
                 self.ui.warn(_('patch series already fully applied\n'))
                 return 1
             if not force:
                 self.check_localchanges(repo)
 
             self.applied_dirty = 1
             if start > 0:
                 self.check_toppatch(repo)
             if not patch:
                 patch = self.series[start]
                 end = start + 1
             else:
                 end = self.series.index(patch, start) + 1
 
             s = self.series[start:end]
             all_files = set()
             try:
                 if mergeq:
                     ret = self.mergepatch(repo, mergeq, s, diffopts)
                 else:
                     ret = self.apply(repo, s, list, all_files=all_files)
             except:
                 self.ui.warn(_('cleaning up working directory...'))
                 node = repo.dirstate.parents()[0]
                 hg.revert(repo, node, None)
                 # only remove unknown files that we know we touched or
                 # created while patching
                 for f in all_files:
                     if f not in repo.dirstate:
                         try:
                             util.unlink(repo.wjoin(f))
                         except OSError, inst:
                             if inst.errno != errno.ENOENT:
                                 raise
                 self.ui.warn(_('done\n'))
                 raise
 
             if not self.applied:
                 return ret[0]
             top = self.applied[-1].name
             if ret[0] and ret[0] > 1:
                 msg = _("errors during apply, please fix and refresh %s\n")
                 self.ui.write(msg % top)
             else:
                 self.ui.write(_("now at: %s\n") % top)
             return ret[0]
 
         finally:
             wlock.release()
 
     def pop(self, repo, patch=None, force=False, update=True, all=False):
         wlock = repo.wlock()
         try:
             if patch:
                 # index, rev, patch
                 info = self.isapplied(patch)
                 if not info:
                     patch = self.lookup(patch)
                 info = self.isapplied(patch)
                 if not info:
                     raise util.Abort(_("patch %s is not applied") % patch)
 
             if not self.applied:
                 # Allow qpop -a to work repeatedly,
                 # but not qpop without an argument
                 self.ui.warn(_("no patches applied\n"))
                 return not all
 
             if all:
                 start = 0
             elif patch:
                 start = info[0] + 1
             else:
                 start = len(self.applied) - 1
 
             if start >= len(self.applied):
                 self.ui.warn(_("qpop: %s is already at the top\n") % patch)
                 return
 
             if not update:
                 parents = repo.dirstate.parents()
                 rr = [x.node for x in self.applied]
                 for p in parents:
                     if p in rr:
                         self.ui.warn(_("qpop: forcing dirstate update\n"))
                         update = True
             else:
                 parents = [p.node() for p in repo[None].parents()]
                 needupdate = False
                 for entry in self.applied[start:]:
                     if entry.node in parents:
                         needupdate = True
                         break
                 update = needupdate
 
             if not force and update:
                 self.check_localchanges(repo)
 
             self.applied_dirty = 1
             end = len(self.applied)
             rev = self.applied[start].node
             if update:
                 top = self.check_toppatch(repo)[0]
 
             try:
                 heads = repo.changelog.heads(rev)
             except error.LookupError:
                 node = short(rev)
                 raise util.Abort(_('trying to pop unknown node %s') % node)
 
             if heads != [self.applied[-1].node]:
                 raise util.Abort(_("popping would remove a revision not "
                                    "managed by this patch queue"))
 
             # we know there are no local changes, so we can make a simplified
             # form of hg.update.
             if update:
                 qp = self.qparents(repo, rev)
                 ctx = repo[qp]
                 m, a, r, d = repo.status(qp, top)[:4]
                 if d:
                     raise util.Abort(_("deletions found between repo revs"))
                 for f in a:
                     try:
                         os.unlink(repo.wjoin(f))
                     except OSError, e:
                         if e.errno != errno.ENOENT:
                             raise
                     try: os.removedirs(os.path.dirname(repo.wjoin(f)))
                     except: pass
                     repo.dirstate.forget(f)
                 for f in m + r:
                     fctx = ctx[f]
                     repo.wwrite(f, fctx.data(), fctx.flags())
                     repo.dirstate.normal(f)
                 repo.dirstate.setparents(qp, nullid)
             for patch in reversed(self.applied[start:end]):
                 self.ui.status(_("popping %s\n") % patch.name)
             del self.applied[start:end]
             self.strip(repo, rev, update=False, backup='strip')
             if self.applied:
                 self.ui.write(_("now at: %s\n") % self.applied[-1].name)
             else:
                 self.ui.write(_("patch queue now empty\n"))
         finally:
             wlock.release()
 
     def diff(self, repo, pats, opts):
         top, patch = self.check_toppatch(repo)
         if not top:
             self.ui.write(_("no patches applied\n"))
             return
         qp = self.qparents(repo, top)
         if opts.get('reverse'):
             node1, node2 = None, qp
         else:
             node1, node2 = qp, None
         diffopts = self.diffopts(opts, patch)
         self.printdiff(repo, diffopts, node1, node2, files=pats, opts=opts)
 
     def refresh(self, repo, pats=None, **opts):
         if not self.applied:
             self.ui.write(_("no patches applied\n"))
             return 1
         msg = opts.get('msg', '').rstrip()
         newuser = opts.get('user')
         newdate = opts.get('date')
         if newdate:
             newdate = '%d %d' % util.parsedate(newdate)
         wlock = repo.wlock()
 
         try:
             self.check_toppatch(repo)
             (top, patchfn) = (self.applied[-1].node, self.applied[-1].name)
             if repo.changelog.heads(top) != [top]:
                 raise util.Abort(_("cannot refresh a revision with children"))
 
             cparents = repo.changelog.parents(top)
             patchparent = self.qparents(repo, top)
             ph = patchheader(self.join(patchfn), self.plainmode)
             diffopts = self.diffopts({'git': opts.get('git')}, patchfn)
             if msg:
                 ph.setmessage(msg)
             if newuser:
                 ph.setuser(newuser)
             if newdate:
                 ph.setdate(newdate)
             ph.setparent(hex(patchparent))
 
             # only commit new patch when write is complete
             patchf = self.opener(patchfn, 'w', atomictemp=True)
 
             comments = str(ph)
             if comments:
                 patchf.write(comments)
 
             # update the dirstate in place, strip off the qtip commit
             # and then commit.
             #
             # this should really read:
             #   mm, dd, aa, aa2 = repo.status(tip, patchparent)[:4]
             # but we do it backwards to take advantage of manifest/chlog
             # caching against the next repo.status call
             mm, aa, dd, aa2 = repo.status(patchparent, top)[:4]
             changes = repo.changelog.read(top)
             man = repo.manifest.read(changes[0])
             aaa = aa[:]
             matchfn = cmdutil.match(repo, pats, opts)
             # in short mode, we only diff the files included in the
             # patch already plus specified files
             if opts.get('short'):
                 # if amending a patch, we start with existing
                 # files plus specified files - unfiltered
                 match = cmdutil.matchfiles(repo, mm + aa + dd + matchfn.files())
                 # filter with inc/exl options
                 matchfn = cmdutil.match(repo, opts=opts)
             else:
                 match = cmdutil.matchall(repo)
             m, a, r, d = repo.status(match=match)[:4]
 
             # we might end up with files that were added between
             # qtip and the dirstate parent, but then changed in the
             # local dirstate. in this case, we want them to only
             # show up in the added section
             for x in m:
                 if x not in aa:
                     mm.append(x)
             # we might end up with files added by the local dirstate that
             # were deleted by the patch.  In this case, they should only
             # show up in the changed section.
             for x in a:
                 if x in dd:
                     del dd[dd.index(x)]
                     mm.append(x)
                 else:
                     aa.append(x)
             # make sure any files deleted in the local dirstate
             # are not in the add or change column of the patch
             forget = []
             for x in d + r:
                 if x in aa:
                     del aa[aa.index(x)]
                     forget.append(x)
                     continue
                 elif x in mm:
                     del mm[mm.index(x)]
                 dd.append(x)
 
             m = list(set(mm))
             r = list(set(dd))
             a = list(set(aa))
             c = [filter(matchfn, l) for l in (m, a, r)]
             match = cmdutil.matchfiles(repo, set(c[0] + c[1] + c[2]))
             chunks = patch.diff(repo, patchparent, match=match,
                                 changes=c, opts=diffopts)
             for chunk in chunks:
                 patchf.write(chunk)
 
             try:
                 if diffopts.git or diffopts.upgrade:
                     copies = {}
                     for dst in a:
                         src = repo.dirstate.copied(dst)
                         # during qfold, the source file for copies may
                         # be removed. Treat this as a simple add.
                         if src is not None and src in repo.dirstate:
                             copies.setdefault(src, []).append(dst)
                         repo.dirstate.add(dst)
                     # remember the copies between patchparent and qtip
                     for dst in aaa:
                         f = repo.file(dst)
                         src = f.renamed(man[dst])
                         if src:
                             copies.setdefault(src[0], []).extend(
                                 copies.get(dst, []))
                             if dst in a:
                                 copies[src[0]].append(dst)
                         # we can't copy a file created by the patch itself
                         if dst in copies:
                             del copies[dst]
                     for src, dsts in copies.iteritems():
                         for dst in dsts:
                             repo.dirstate.copy(src, dst)
                 else:
                     for dst in a:
                         repo.dirstate.add(dst)
                     # Drop useless copy information
                     for f in list(repo.dirstate.copies()):
                         repo.dirstate.copy(None, f)
                 for f in r:
                     repo.dirstate.remove(f)
                 # if the patch excludes a modified file, mark that
                 # file with mtime=0 so status can see it.
                 mm = []
                 for i in xrange(len(m)-1, -1, -1):
                     if not matchfn(m[i]):
                         mm.append(m[i])
                         del m[i]
                 for f in m:
                     repo.dirstate.normal(f)
                 for f in mm:
                     repo.dirstate.normallookup(f)
                 for f in forget:
                     repo.dirstate.forget(f)
 
                 if not msg:
                     if not ph.message:
                         message = "[mq]: %s\n" % patchfn
                     else:
                         message = "\n".join(ph.message)
                 else:
                     message = msg
 
                 user = ph.user or changes[1]
 
                 # assumes strip can roll itself back if interrupted
                 repo.dirstate.setparents(*cparents)
                 self.applied.pop()
                 self.applied_dirty = 1
                 self.strip(repo, top, update=False,
                            backup='strip')
             except:
                 repo.dirstate.invalidate()
                 raise
 
             try:
                 # might be nice to attempt to roll back strip after this
                 patchf.rename()
                 n = repo.commit(message, user, ph.date, match=match,
                                 force=True)
                 self.applied.append(statusentry(n, patchfn))
             except:
                 ctx = repo[cparents[0]]
                 repo.dirstate.rebuild(ctx.node(), ctx.manifest())
                 self.save_dirty()
                 self.ui.warn(_('refresh interrupted while patch was popped! '
                                '(revert --all, qpush to recover)\n'))
                 raise
         finally:
             wlock.release()
             self.removeundo(repo)
 
     def init(self, repo, create=False):
         if not create and os.path.isdir(self.path):
             raise util.Abort(_("patch queue directory already exists"))
         try:
             os.mkdir(self.path)
         except OSError, inst:
             if inst.errno != errno.EEXIST or not create:
                 raise
         if create:
             return self.qrepo(create=True)
 
     def unapplied(self, repo, patch=None):
         if patch and patch not in self.series:
             raise util.Abort(_("patch %s is not in series file") % patch)
         if not patch:
             start = self.series_end()
         else:
             start = self.series.index(patch) + 1
         unapplied = []
         for i in xrange(start, len(self.series)):
             pushable, reason = self.pushable(i)
             if pushable:
                 unapplied.append((i, self.series[i]))
             self.explain_pushable(i)
         return unapplied
 
     def qseries(self, repo, missing=None, start=0, length=None, status=None,
                 summary=False):
         def displayname(pfx, patchname):
             if summary:
                 ph = patchheader(self.join(patchname), self.plainmode)
                 msg = ph.message and ph.message[0] or ''
                 if self.ui.interactive():
                     width = util.termwidth() - len(pfx) - len(patchname) - 2
                     if width > 0:
                         msg = util.ellipsis(msg, width)
                     else:
                         msg = ''
                 msg = "%s%s: %s" % (pfx, patchname, msg)
             else:
                 msg = pfx + patchname
             self.ui.write(msg + '\n')
 
         applied = set([p.name for p in self.applied])
         if length is None:
             length = len(self.series) - start
         if not missing:
             if self.ui.verbose:
                 idxwidth = len(str(start + length - 1))
             for i in xrange(start, start + length):
                 patch = self.series[i]
                 if patch in applied:
                     stat = 'A'
                 elif self.pushable(i)[0]:
                     stat = 'U'
                 else:
                     stat = 'G'
                 pfx = ''
                 if self.ui.verbose:
                     pfx = '%*d %s ' % (idxwidth, i, stat)
                 elif status and status != stat:
                     continue
                 displayname(pfx, patch)
         else:
             msng_list = []
             for root, dirs, files in os.walk(self.path):
                 d = root[len(self.path) + 1:]
                 for f in files:
                     fl = os.path.join(d, f)
                     if (fl not in self.series and
                         fl not in (self.status_path, self.series_path,
                                    self.guards_path)
                         and not fl.startswith('.')):
                         msng_list.append(fl)
             for x in sorted(msng_list):
                 pfx = self.ui.verbose and ('D ') or ''
                 displayname(pfx, x)
 
     def issaveline(self, l):
         if l.name == '.hg.patches.save.line':
             return True
 
     def qrepo(self, create=False):
         if create or os.path.isdir(self.join(".hg")):
             return hg.repository(self.ui, path=self.path, create=create)
 
     def restore(self, repo, rev, delete=None, qupdate=None):
         desc = repo[rev].description().strip()
         lines = desc.splitlines()
         i = 0
         datastart = None
         series = []
         applied = []
         qpp = None
         for i, line in enumerate(lines):
             if line == 'Patch Data:':
                 datastart = i + 1
             elif line.startswith('Dirstate:'):
                 l = line.rstrip()
                 l = l[10:].split(' ')
                 qpp = [bin(x) for x in l]
             elif datastart != None:
                 l = line.rstrip()
                 n, name = l.split(':', 1)
                 if n:
                     applied.append(statusentry(bin(n), name))
                 else:
                     series.append(l)
         if datastart is None:
             self.ui.warn(_("No saved patch data found\n"))
             return 1
         self.ui.warn(_("restoring status: %s\n") % lines[0])
         self.full_series = series
         self.applied = applied
         self.parse_series()
         self.series_dirty = 1
         self.applied_dirty = 1
         heads = repo.changelog.heads()
         if delete:
             if rev not in heads:
                 self.ui.warn(_("save entry has children, leaving it alone\n"))
             else:
                 self.ui.warn(_("removing save entry %s\n") % short(rev))
                 pp = repo.dirstate.parents()
                 if rev in pp:
                     update = True
                 else:
                     update = False
                 self.strip(repo, rev, update=update, backup='strip')
         if qpp:
             self.ui.warn(_("saved queue repository parents: %s %s\n") %
                          (short(qpp[0]), short(qpp[1])))
             if qupdate:
                 self.ui.status(_("queue directory updating\n"))
                 r = self.qrepo()
                 if not r:
                     self.ui.warn(_("Unable to load queue repository\n"))
                     return 1
                 hg.clean(r, qpp[0])
 
     def save(self, repo, msg=None):
         if not self.applied:
             self.ui.warn(_("save: no patches applied, exiting\n"))
             return 1
         if self.issaveline(self.applied[-1]):
             self.ui.warn(_("status is already saved\n"))
             return 1
 
         if not msg:
             msg = _("hg patches saved state")
         else:
             msg = "hg patches: " + msg.rstrip('\r\n')
         r = self.qrepo()
         if r:
             pp = r.dirstate.parents()
             msg += "\nDirstate: %s %s" % (hex(pp[0]), hex(pp[1]))
         msg += "\n\nPatch Data:\n"
         msg += ''.join('%s\n' % x for x in self.applied)
         msg += ''.join(':%s\n' % x for x in self.full_series)
         n = repo.commit(msg, force=True)
         if not n:
             self.ui.warn(_("repo commit failed\n"))
             return 1
         self.applied.append(statusentry(n, '.hg.patches.save.line'))
         self.applied_dirty = 1
         self.removeundo(repo)
 
     def full_series_end(self):
         if self.applied:
             p = self.applied[-1].name
             end = self.find_series(p)
             if end is None:
                 return len(self.full_series)
             return end + 1
         return 0
 
     def series_end(self, all_patches=False):
         """If all_patches is False, return the index of the next pushable patch
         in the series, or the series length. If all_patches is True, return the
         index of the first patch past the last applied one.
         """
         end = 0
         def next(start):
             if all_patches or start >= len(self.series):
                 return start
             for i in xrange(start, len(self.series)):
                 p, reason = self.pushable(i)
                 if p:
                     break
                 self.explain_pushable(i)
             return i
         if self.applied:
             p = self.applied[-1].name
             try:
                 end = self.series.index(p)
             except ValueError:
                 return 0
             return next(end + 1)
         return next(end)
 
     def appliedname(self, index):
         pname = self.applied[index].name
         if not self.ui.verbose:
             p = pname
         else:
             p = str(self.series.index(pname)) + " " + pname
         return p
 
     def qimport(self, repo, files, patchname=None, rev=None, existing=None,
                 force=None, git=False):
         def checkseries(patchname):
             if patchname in self.series:
                 raise util.Abort(_('patch %s is already in the series file')
                                  % patchname)
         def checkfile(patchname):
             if not force and os.path.exists(self.join(patchname)):
                 raise util.Abort(_('patch "%s" already exists')
                                  % patchname)
 
         if rev:
             if files:
                 raise util.Abort(_('option "-r" not valid when importing '
                                    'files'))
             rev = cmdutil.revrange(repo, rev)
             rev.sort(reverse=True)
         if (len(files) > 1 or len(rev) > 1) and patchname:
             raise util.Abort(_('option "-n" not valid when importing multiple '
                                'patches'))
         added = []
         if rev:
             # If mq patches are applied, we can only import revisions
             # that form a linear path to qbase.
             # Otherwise, they should form a linear path to a head.
             heads = repo.changelog.heads(repo.changelog.node(rev[-1]))
             if len(heads) > 1:
                 raise util.Abort(_('revision %d is the root of more than one '
                                    'branch') % rev[-1])
             if self.applied:
                 base = repo.changelog.node(rev[0])
                 if base in [n.node for n in self.applied]:
                     raise util.Abort(_('revision %d is already managed')
                                      % rev[0])
                 if heads != [self.applied[-1].node]:
                     raise util.Abort(_('revision %d is not the parent of '
                                        'the queue') % rev[0])
                 base = repo.changelog.rev(self.applied[0].node)
                 lastparent = repo.changelog.parentrevs(base)[0]
             else:
                 if heads != [repo.changelog.node(rev[0])]:
                     raise util.Abort(_('revision %d has unmanaged children')
                                      % rev[0])
                 lastparent = None
 
             diffopts = self.diffopts({'git': git})
             for r in rev:
                 p1, p2 = repo.changelog.parentrevs(r)
                 n = repo.changelog.node(r)
                 if p2 != nullrev:
                     raise util.Abort(_('cannot import merge revision %d') % r)
                 if lastparent and lastparent != r:
                     raise util.Abort(_('revision %d is not the parent of %d')
                                      % (r, lastparent))
                 lastparent = p1
 
                 if not patchname:
                     patchname = normname('%d.diff' % r)
                 self.check_reserved_name(patchname)
                 checkseries(patchname)
                 checkfile(patchname)
                 self.full_series.insert(0, patchname)
 
                 patchf = self.opener(patchname, "w")
                 cmdutil.export(repo, [n], fp=patchf, opts=diffopts)
                 patchf.close()
 
                 se = statusentry(n, patchname)
                 self.applied.insert(0, se)
 
                 added.append(patchname)
                 patchname = None
             self.parse_series()
             self.applied_dirty = 1
 
         for i, filename in enumerate(files):
             if existing:
                 if filename == '-':
                     raise util.Abort(_('-e is incompatible with import from -'))
                 if not patchname:
                     patchname = normname(filename)
                 self.check_reserved_name(patchname)
                 if not os.path.isfile(self.join(patchname)):
                     raise util.Abort(_("patch %s does not exist") % patchname)
             else:
                 try:
                     if filename == '-':
                         if not patchname:
                             raise util.Abort(
                                 _('need --name to import a patch from -'))
                         text = sys.stdin.read()
                     else:
                         text = url.open(self.ui, filename).read()
                 except (OSError, IOError):
                     raise util.Abort(_("unable to read %s") % filename)
                 if not patchname:
                     patchname = normname(os.path.basename(filename))
                 self.check_reserved_name(patchname)
                 checkfile(patchname)
                 patchf = self.opener(patchname, "w")
                 patchf.write(text)
             if not force:
                 checkseries(patchname)
             if patchname not in self.series:
                 index = self.full_series_end() + i
                 self.full_series[index:index] = [patchname]
             self.parse_series()
             self.ui.warn(_("adding %s to series file\n") % patchname)
             added.append(patchname)
             patchname = None
         self.series_dirty = 1
         qrepo = self.qrepo()
         if qrepo:
             qrepo.add(added)
 
 def delete(ui, repo, *patches, **opts):
     """remove patches from queue
 
     The patches must not be applied, and at least one patch is required. With
     -k/--keep, the patch files are preserved in the patch directory.
 
     To stop managing a patch and move it into permanent history,
     use the qfinish command."""
     q = repo.mq
     q.delete(repo, patches, opts)
     q.save_dirty()
     return 0
 
 def applied(ui, repo, patch=None, **opts):
     """print the patches already applied"""
 
     q = repo.mq
     l = len(q.applied)
 
     if patch:
         if patch not in q.series:
             raise util.Abort(_("patch %s is not in series file") % patch)
         end = q.series.index(patch) + 1
     else:
         end = q.series_end(True)
 
     if opts.get('last') and not end:
         ui.write(_("no patches applied\n"))
         return 1
     elif opts.get('last') and end == 1:
         ui.write(_("only one patch applied\n"))
         return 1
     elif opts.get('last'):
         start = end - 2
         end = 1
     else:
         start = 0
 
     return q.qseries(repo, length=end, start=start, status='A',
                      summary=opts.get('summary'))
 
 def unapplied(ui, repo, patch=None, **opts):
     """print the patches not yet applied"""
 
     q = repo.mq
     if patch:
         if patch not in q.series:
             raise util.Abort(_("patch %s is not in series file") % patch)
         start = q.series.index(patch) + 1
     else:
         start = q.series_end(True)
 
     if start == len(q.series) and opts.get('first'):
         ui.write(_("all patches applied\n"))
         return 1
 
     length = opts.get('first') and 1 or None
     return q.qseries(repo, start=start, length=length, status='U',
                      summary=opts.get('summary'))
 
 def qimport(ui, repo, *filename, **opts):
     """import a patch
 
     The patch is inserted into the series after the last applied
     patch. If no patches have been applied, qimport prepends the patch
     to the series.
 
     The patch will have the same name as its source file unless you
     give it a new one with -n/--name.
 
     You can register an existing patch inside the patch directory with
     the -e/--existing flag.
 
     With -f/--force, an existing patch of the same name will be
     overwritten.
 
     An existing changeset may be placed under mq control with -r/--rev
     (e.g. qimport --rev tip -n patch will place tip under mq control).
     With -g/--git, patches imported with --rev will use the git diff
     format. See the diffs help topic for information on why this is
     important for preserving rename/copy information and permission
     changes.
 
     To import a patch from standard input, pass - as the patch file.
     When importing from standard input, a patch name must be specified
     using the --name flag.
     """
     q = repo.mq
     q.qimport(repo, filename, patchname=opts['name'],
               existing=opts['existing'], force=opts['force'], rev=opts['rev'],
               git=opts['git'])
     q.save_dirty()
 
     if opts.get('push') and not opts.get('rev'):
         return q.push(repo, None)
     return 0
 
 def qinit(ui, repo, create):
     """initialize a new queue repository
 
     This command also creates a series file for ordering patches, and
     an mq-specific .hgignore file in the queue repository, to exclude
     the status and guards files (these contain mostly transient state)."""
     q = repo.mq
     r = q.init(repo, create)
     q.save_dirty()
     if r:
         if not os.path.exists(r.wjoin('.hgignore')):
             fp = r.wopener('.hgignore', 'w')
             fp.write('^\\.hg\n')
             fp.write('^\\.mq\n')
             fp.write('syntax: glob\n')
             fp.write('status\n')
             fp.write('guards\n')
             fp.close()
         if not os.path.exists(r.wjoin('series')):
             r.wopener('series', 'w').close()
         r.add(['.hgignore', 'series'])
         commands.add(ui, r)
     return 0
 
 def init(ui, repo, **opts):
     """init a new queue repository (DEPRECATED)
 
     The queue repository is unversioned by default. If
     -c/--create-repo is specified, qinit will create a separate nested
     repository for patches (qinit -c may also be run later to convert
     an unversioned patch repository into a versioned one). You can use
     qcommit to commit changes to this queue repository.
 
     This command is deprecated. Without -c, it's implied by other relevant
     commands. With -c, use hg init --mq instead."""
     return qinit(ui, repo, create=opts['create_repo'])
 
 def clone(ui, source, dest=None, **opts):
     '''clone main and patch repository at same time
 
     If source is local, destination will have no patches applied. If
     source is remote, this command can not check if patches are
     applied in source, so cannot guarantee that patches are not
     applied in destination. If you clone remote repository, be sure
     before that it has no patches applied.
 
     Source patch repository is looked for in <src>/.hg/patches by
     default. Use -p <url> to change.
 
     The patch directory must be a nested Mercurial repository, as
     would be created by init --mq.
     '''
     def patchdir(repo):
         url = repo.url()
         if url.endswith('/'):
             url = url[:-1]
         return url + '/.hg/patches'
     if dest is None:
         dest = hg.defaultdest(source)
     sr = hg.repository(cmdutil.remoteui(ui, opts), ui.expandpath(source))
     if opts['patches']:
         patchespath = ui.expandpath(opts['patches'])
     else:
         patchespath = patchdir(sr)
     try:
         hg.repository(ui, patchespath)
     except error.RepoError:
         raise util.Abort(_('versioned patch repository not found'
                            ' (see init --mq)'))
     qbase, destrev = None, None
     if sr.local():
         if sr.mq.applied:
             qbase = sr.mq.applied[0].node
             if not hg.islocal(dest):
                 heads = set(sr.heads())
                 destrev = list(heads.difference(sr.heads(qbase)))
                 destrev.append(sr.changelog.parents(qbase)[0])
     elif sr.capable('lookup'):
         try:
             qbase = sr.lookup('qbase')
         except error.RepoError:
             pass
     ui.note(_('cloning main repository\n'))
     sr, dr = hg.clone(ui, sr.url(), dest,
                       pull=opts['pull'],
                       rev=destrev,
                       update=False,
                       stream=opts['uncompressed'])
     ui.note(_('cloning patch repository\n'))
     hg.clone(ui, opts['patches'] or patchdir(sr), patchdir(dr),
              pull=opts['pull'], update=not opts['noupdate'],
              stream=opts['uncompressed'])
     if dr.local():
         if qbase:
             ui.note(_('stripping applied patches from destination '
                       'repository\n'))
             dr.mq.strip(dr, qbase, update=False, backup=None)
         if not opts['noupdate']:
             ui.note(_('updating destination repository\n'))
             hg.update(dr, dr.changelog.tip())
 
 def commit(ui, repo, *pats, **opts):
     """commit changes in the queue repository (DEPRECATED)
 
     This command is deprecated; use hg commit --mq instead."""
     q = repo.mq
     r = q.qrepo()
     if not r:
         raise util.Abort('no queue repository')
     commands.commit(r.ui, r, *pats, **opts)
 
 def series(ui, repo, **opts):
     """print the entire series file"""
     repo.mq.qseries(repo, missing=opts['missing'], summary=opts['summary'])
     return 0
 
 def top(ui, repo, **opts):
     """print the name of the current patch"""
     q = repo.mq
     t = q.applied and q.series_end(True) or 0
     if t:
         return q.qseries(repo, start=t - 1, length=1, status='A',
                          summary=opts.get('summary'))
     else:
         ui.write(_("no patches applied\n"))
         return 1
 
 def next(ui, repo, **opts):
     """print the name of the next patch"""
     q = repo.mq
     end = q.series_end()
     if end == len(q.series):
         ui.write(_("all patches applied\n"))
         return 1
     return q.qseries(repo, start=end, length=1, summary=opts.get('summary'))
 
 def prev(ui, repo, **opts):
     """print the name of the previous patch"""
     q = repo.mq
     l = len(q.applied)
     if l == 1:
         ui.write(_("only one patch applied\n"))
         return 1
     if not l:
         ui.write(_("no patches applied\n"))
         return 1
     return q.qseries(repo, start=l - 2, length=1, status='A',
                      summary=opts.get('summary'))
 
 def setupheaderopts(ui, opts):
     if not opts.get('user') and opts.get('currentuser'):
         opts['user'] = ui.username()
     if not opts.get('date') and opts.get('currentdate'):
         opts['date'] = "%d %d" % util.makedate()
 
 def new(ui, repo, patch, *args, **opts):
     """create a new patch
 
     qnew creates a new patch on top of the currently-applied patch (if
     any). It will refuse to run if there are any outstanding changes
     unless -f/--force is specified, in which case the patch will be
     initialized with them. You may also use -I/--include,
     -X/--exclude, and/or a list of files after the patch name to add
     only changes to matching files to the new patch, leaving the rest
     as uncommitted modifications.
 
     -u/--user and -d/--date can be used to set the (given) user and
     date, respectively. -U/--currentuser and -D/--currentdate set user
     to current user and date to current date.
 
     -e/--edit, -m/--message or -l/--logfile set the patch header as
     well as the commit message. If none is specified, the header is
     empty and the commit message is '[mq]: PATCH'.
 
     Use the -g/--git option to keep the patch in the git extended diff
     format. Read the diffs help topic for more information on why this
     is important for preserving permission changes and copy/rename
     information.
     """
     msg = cmdutil.logmessage(opts)
     def getmsg():
         return ui.edit(msg, ui.username())
     q = repo.mq
     opts['msg'] = msg
     if opts.get('edit'):
         opts['msg'] = getmsg
     else:
         opts['msg'] = msg
     setupheaderopts(ui, opts)
     q.new(repo, patch, *args, **opts)
     q.save_dirty()
     return 0
 
 def refresh(ui, repo, *pats, **opts):
     """update the current patch
 
     If any file patterns are provided, the refreshed patch will
     contain only the modifications that match those patterns; the
     remaining modifications will remain in the working directory.
 
     If -s/--short is specified, files currently included in the patch
     will be refreshed just like matched files and remain in the patch.
 
     hg add/remove/copy/rename work as usual, though you might want to
     use git-style patches (-g/--git or [diff] git=1) to track copies
     and renames. See the diffs help topic for more information on the
     git diff format.
     """
     q = repo.mq
     message = cmdutil.logmessage(opts)
     if opts['edit']:
         if not q.applied:
             ui.write(_("no patches applied\n"))
             return 1
         if message:
             raise util.Abort(_('option "-e" incompatible with "-m" or "-l"'))
         patch = q.applied[-1].name
         ph = patchheader(q.join(patch), q.plainmode)
         message = ui.edit('\n'.join(ph.message), ph.user or ui.username())
     setupheaderopts(ui, opts)
     ret = q.refresh(repo, pats, msg=message, **opts)
     q.save_dirty()
     return ret
 
 def diff(ui, repo, *pats, **opts):
     """diff of the current patch and subsequent modifications
 
     Shows a diff which includes the current patch as well as any
     changes which have been made in the working directory since the
     last refresh (thus showing what the current patch would become
     after a qrefresh).
 
     Use 'hg diff' if you only want to see the changes made since the
     last qrefresh, or 'hg export qtip' if you want to see changes made
     by the current patch without including changes made since the
     qrefresh.
     """
     repo.mq.diff(repo, pats, opts)
     return 0
 
 def fold(ui, repo, *files, **opts):
     """fold the named patches into the current patch
 
     Patches must not yet be applied. Each patch will be successively
     applied to the current patch in the order given. If all the
     patches apply successfully, the current patch will be refreshed
     with the new cumulative patch, and the folded patches will be
     deleted. With -k/--keep, the folded patch files will not be
     removed afterwards.
 
     The header for each folded patch will be concatenated with the
     current patch header, separated by a line of '* * *'."""
 
     q = repo.mq
 
     if not files:
         raise util.Abort(_('qfold requires at least one patch name'))
     if not q.check_toppatch(repo)[0]:
         raise util.Abort(_('No patches applied'))
     q.check_localchanges(repo)
 
     message = cmdutil.logmessage(opts)
     if opts['edit']:
         if message:
             raise util.Abort(_('option "-e" incompatible with "-m" or "-l"'))
 
     parent = q.lookup('qtip')
     patches = []
     messages = []
     for f in files:
         p = q.lookup(f)
         if p in patches or p == parent:
             ui.warn(_('Skipping already folded patch %s') % p)
         if q.isapplied(p):
             raise util.Abort(_('qfold cannot fold already applied patch %s') % p)
         patches.append(p)
 
     for p in patches:
         if not message:
             ph = patchheader(q.join(p), q.plainmode)
             if ph.message:
                 messages.append(ph.message)
         pf = q.join(p)
         (patchsuccess, files, fuzz) = q.patch(repo, pf)
         if not patchsuccess:
             raise util.Abort(_('Error folding patch %s') % p)
         patch.updatedir(ui, repo, files)
 
     if not message:
         ph = patchheader(q.join(parent), q.plainmode)
         message, user = ph.message, ph.user
         for msg in messages:
             message.append('* * *')
             message.extend(msg)
         message = '\n'.join(message)
 
     if opts['edit']:
         message = ui.edit(message, user or ui.username())
 
     diffopts = q.patchopts(q.diffopts(), *patches)
     q.refresh(repo, msg=message, git=diffopts.git)
     q.delete(repo, patches, opts)
     q.save_dirty()
 
 def goto(ui, repo, patch, **opts):
     '''push or pop patches until named patch is at top of stack'''
     q = repo.mq
     patch = q.lookup(patch)
     if q.isapplied(patch):
         ret = q.pop(repo, patch, force=opts['force'])
     else:
         ret = q.push(repo, patch, force=opts['force'])
     q.save_dirty()
     return ret
 
 def guard(ui, repo, *args, **opts):
     '''set or print guards for a patch
 
     Guards control whether a patch can be pushed. A patch with no
     guards is always pushed. A patch with a positive guard ("+foo") is
     pushed only if the qselect command has activated it. A patch with
     a negative guard ("-foo") is never pushed if the qselect command
     has activated it.
 
     With no arguments, print the currently active guards.
     With arguments, set guards for the named patch.
     NOTE: Specifying negative guards now requires '--'.
 
     To set guards on another patch::
 
       hg qguard other.patch -- +2.6.17 -stable
     '''
     def status(idx):
         guards = q.series_guards[idx] or ['unguarded']
         ui.write('%s: %s\n' % (q.series[idx], ' '.join(guards)))
     q = repo.mq
     patch = None
     args = list(args)
     if opts['list']:
         if args or opts['none']:
             raise util.Abort(_('cannot mix -l/--list with options or arguments'))
         for i in xrange(len(q.series)):
             status(i)
         return
     if not args or args[0][0:1] in '-+':
         if not q.applied:
             raise util.Abort(_('no patches applied'))
         patch = q.applied[-1].name
     if patch is None and args[0][0:1] not in '-+':
         patch = args.pop(0)
     if patch is None:
         raise util.Abort(_('no patch to work with'))
     if args or opts['none']:
         idx = q.find_series(patch)
         if idx is None:
             raise util.Abort(_('no patch named %s') % patch)
         q.set_guards(idx, args)
         q.save_dirty()
     else:
         status(q.series.index(q.lookup(patch)))
 
 def header(ui, repo, patch=None):
     """print the header of the topmost or specified patch"""
     q = repo.mq
 
     if patch:
         patch = q.lookup(patch)
     else:
         if not q.applied:
             ui.write(_('no patches applied\n'))
             return 1
         patch = q.lookup('qtip')
     ph = patchheader(q.join(patch), q.plainmode)
 
     ui.write('\n'.join(ph.message) + '\n')
 
 def lastsavename(path):
     (directory, base) = os.path.split(path)
     names = os.listdir(directory)
     namere = re.compile("%s.([0-9]+)" % base)
     maxindex = None
     maxname = None
     for f in names:
         m = namere.match(f)
         if m:
             index = int(m.group(1))
             if maxindex is None or index > maxindex:
                 maxindex = index
                 maxname = f
     if maxname:
         return (os.path.join(directory, maxname), maxindex)
     return (None, None)
 
 def savename(path):
     (last, index) = lastsavename(path)
     if last is None:
         index = 0
     newpath = path + ".%d" % (index + 1)
     return newpath
 
 def push(ui, repo, patch=None, **opts):
     """push the next patch onto the stack
 
     When -f/--force is applied, all local changes in patched files
     will be lost.
     """
     q = repo.mq
     mergeq = None
 
     if opts['merge']:
         if opts['name']:
             newpath = repo.join(opts['name'])
         else:
             newpath, i = lastsavename(q.path)
         if not newpath:
             ui.warn(_("no saved queues found, please use -n\n"))
             return 1
         mergeq = queue(ui, repo.join(""), newpath)
         ui.warn(_("merging with queue at: %s\n") % mergeq.path)
     ret = q.push(repo, patch, force=opts['force'], list=opts['list'],
                  mergeq=mergeq, all=opts.get('all'))
     return ret
 
 def pop(ui, repo, patch=None, **opts):
     """pop the current patch off the stack
 
     By default, pops off the top of the patch stack. If given a patch
     name, keeps popping off patches until the named patch is at the
     top of the stack.
     """
     localupdate = True
     if opts['name']:
         q = queue(ui, repo.join(""), repo.join(opts['name']))
         ui.warn(_('using patch queue: %s\n') % q.path)
         localupdate = False
     else:
         q = repo.mq
     ret = q.pop(repo, patch, force=opts['force'], update=localupdate,
                 all=opts['all'])
     q.save_dirty()
     return ret
 
 def rename(ui, repo, patch, name=None, **opts):
     """rename a patch
 
     With one argument, renames the current patch to PATCH1.
     With two arguments, renames PATCH1 to PATCH2."""
 
     q = repo.mq
 
     if not name:
         name = patch
         patch = None
 
     if patch:
         patch = q.lookup(patch)
     else:
         if not q.applied:
             ui.write(_('no patches applied\n'))
             return
         patch = q.lookup('qtip')
     absdest = q.join(name)
     if os.path.isdir(absdest):
         name = normname(os.path.join(name, os.path.basename(patch)))
         absdest = q.join(name)
     if os.path.exists(absdest):
         raise util.Abort(_('%s already exists') % absdest)
 
     if name in q.series:
         raise util.Abort(
             _('A patch named %s already exists in the series file') % name)
 
     ui.note(_('renaming %s to %s\n') % (patch, name))
     i = q.find_series(patch)
     guards = q.guard_re.findall(q.full_series[i])
     q.full_series[i] = name + ''.join([' #' + g for g in guards])
     q.parse_series()
     q.series_dirty = 1
 
     info = q.isapplied(patch)
     if info:
         q.applied[info[0]] = statusentry(info[1], name)
     q.applied_dirty = 1
 
     util.rename(q.join(patch), absdest)
     r = q.qrepo()
     if r:
         wlock = r.wlock()
         try:
             if r.dirstate[patch] == 'a':
                 r.dirstate.forget(patch)
                 r.dirstate.add(name)
             else:
                 if r.dirstate[name] == 'r':
                     r.undelete([name])
                 r.copy(patch, name)
                 r.remove([patch], False)
         finally:
             wlock.release()
 
     q.save_dirty()
 
 def restore(ui, repo, rev, **opts):
     """restore the queue state saved by a revision (DEPRECATED)
 
     This command is deprecated, use rebase --mq instead."""
     rev = repo.lookup(rev)
     q = repo.mq
     q.restore(repo, rev, delete=opts['delete'],
               qupdate=opts['update'])
     q.save_dirty()
     return 0
 
 def save(ui, repo, **opts):
     """save current queue state (DEPRECATED)
 
     This command is deprecated, use rebase --mq instead."""
     q = repo.mq
     message = cmdutil.logmessage(opts)
     ret = q.save(repo, msg=message)
     if ret:
         return ret
     q.save_dirty()
     if opts['copy']:
         path = q.path
         if opts['name']:
             newpath = os.path.join(q.basepath, opts['name'])
             if os.path.exists(newpath):
                 if not os.path.isdir(newpath):
                     raise util.Abort(_('destination %s exists and is not '
                                        'a directory') % newpath)
                 if not opts['force']:
                     raise util.Abort(_('destination %s exists, '
                                        'use -f to force') % newpath)
         else:
             newpath = savename(path)
         ui.warn(_("copy %s to %s\n") % (path, newpath))
         util.copyfiles(path, newpath)
     if opts['empty']:
         try:
             os.unlink(q.join(q.status_path))
         except:
             pass
     return 0
 
 def strip(ui, repo, rev, **opts):
     """strip a revision and all its descendants from the repository
 
     If one of the working directory's parent revisions is stripped, the
     working directory will be updated to the parent of the stripped
     revision.
     """
     backup = 'all'
     if opts['backup']:
         backup = 'strip'
     elif opts['nobackup']:
         backup = 'none'
 
     rev = repo.lookup(rev)
     p = repo.dirstate.parents()
     cl = repo.changelog
     update = True
     if p[0] == nullid:
         update = False
     elif p[1] == nullid and rev != cl.ancestor(p[0], rev):
         update = False
     elif rev not in (cl.ancestor(p[0], rev), cl.ancestor(p[1], rev)):
         update = False
 
     repo.mq.strip(repo, rev, backup=backup, update=update, force=opts['force'])
     return 0
 
 def select(ui, repo, *args, **opts):
     '''set or print guarded patches to push
 
     Use the qguard command to set or print guards on patch, then use
     qselect to tell mq which guards to use. A patch will be pushed if
     it has no guards or any positive guards match the currently
     selected guard, but will not be pushed if any negative guards
     match the current guard. For example::
 
         qguard foo.patch -stable    (negative guard)
         qguard bar.patch +stable    (positive guard)
         qselect stable
 
     This activates the "stable" guard. mq will skip foo.patch (because
     it has a negative match) but push bar.patch (because it has a
     positive match).
 
     With no arguments, prints the currently active guards.
     With one argument, sets the active guard.
 
     Use -n/--none to deactivate guards (no other arguments needed).
     When no guards are active, patches with positive guards are
     skipped and patches with negative guards are pushed.
 
     qselect can change the guards on applied patches. It does not pop
     guarded patches by default. Use --pop to pop back to the last
     applied patch that is not guarded. Use --reapply (which implies
     --pop) to push back to the current patch afterwards, but skip
     guarded patches.
 
     Use -s/--series to print a list of all guards in the series file
     (no other arguments needed). Use -v for more information.'''
 
     q = repo.mq
     guards = q.active()
     if args or opts['none']:
         old_unapplied = q.unapplied(repo)
         old_guarded = [i for i in xrange(len(q.applied)) if
                        not q.pushable(i)[0]]
         q.set_active(args)
         q.save_dirty()
         if not args:
             ui.status(_('guards deactivated\n'))
         if not opts['pop'] and not opts['reapply']:
             unapplied = q.unapplied(repo)
             guarded = [i for i in xrange(len(q.applied))
                        if not q.pushable(i)[0]]
             if len(unapplied) != len(old_unapplied):
                 ui.status(_('number of unguarded, unapplied patches has '
                             'changed from %d to %d\n') %
                           (len(old_unapplied), len(unapplied)))
             if len(guarded) != len(old_guarded):
                 ui.status(_('number of guarded, applied patches has changed '
                             'from %d to %d\n') %
                           (len(old_guarded), len(guarded)))
     elif opts['series']:
         guards = {}
         noguards = 0
         for gs in q.series_guards:
             if not gs:
                 noguards += 1
             for g in gs:
                 guards.setdefault(g, 0)
                 guards[g] += 1
         if ui.verbose:
             guards['NONE'] = noguards
         guards = guards.items()
         guards.sort(key=lambda x: x[0][1:])
         if guards:
             ui.note(_('guards in series file:\n'))
             for guard, count in guards:
                 ui.note('%2d  ' % count)
                 ui.write(guard, '\n')
         else:
             ui.note(_('no guards in series file\n'))
     else:
         if guards:
             ui.note(_('active guards:\n'))
             for g in guards:
                 ui.write(g, '\n')
         else:
             ui.write(_('no active guards\n'))
     reapply = opts['reapply'] and q.applied and q.appliedname(-1)
     popped = False
     if opts['pop'] or opts['reapply']:
         for i in xrange(len(q.applied)):
             pushable, reason = q.pushable(i)
             if not pushable:
                 ui.status(_('popping guarded patches\n'))
                 popped = True
                 if i == 0:
                     q.pop(repo, all=True)
                 else:
                     q.pop(repo, i - 1)
                 break
     if popped:
         try:
             if reapply:
                 ui.status(_('reapplying unguarded patches\n'))
                 q.push(repo, reapply)
         finally:
             q.save_dirty()
 
 def finish(ui, repo, *revrange, **opts):
     """move applied patches into repository history
 
     Finishes the specified revisions (corresponding to applied
     patches) by moving them out of mq control into regular repository
     history.
 
     Accepts a revision range or the -a/--applied option. If --applied
     is specified, all applied mq revisions are removed from mq
     control. Otherwise, the given revisions must be at the base of the
     stack of applied patches.
 
     This can be especially useful if your changes have been applied to
     an upstream repository, or if you are about to push your changes
     to upstream.
     """
     if not opts['applied'] and not revrange:
         raise util.Abort(_('no revisions specified'))
     elif opts['applied']:
         revrange = ('qbase:qtip',) + revrange
 
     q = repo.mq
     if not q.applied:
         ui.status(_('no patches applied\n'))
         return 0
 
     revs = cmdutil.revrange(repo, revrange)
     q.finish(repo, revs)
     q.save_dirty()
     return 0
 
 def reposetup(ui, repo):
     class mqrepo(repo.__class__):
         @util.propertycache
         def mq(self):
             return queue(self.ui, self.join(""))
 
         def abort_if_wdir_patched(self, errmsg, force=False):
             if self.mq.applied and not force:
                 parent = self.dirstate.parents()[0]
                 if parent in [s.node for s in self.mq.applied]:
                     raise util.Abort(errmsg)
 
         def commit(self, text="", user=None, date=None, match=None,
                    force=False, editor=False, extra={}):
             self.abort_if_wdir_patched(
                 _('cannot commit over an applied mq patch'),
                 force)
 
             return super(mqrepo, self).commit(text, user, date, match, force,
                                               editor, extra)
 
         def push(self, remote, force=False, revs=None):
             if self.mq.applied and not force and not revs:
                 raise util.Abort(_('source has mq patches applied'))
             return super(mqrepo, self).push(remote, force, revs)
 
         def _findtags(self):
             '''augment tags from base class with patch tags'''
             result = super(mqrepo, self)._findtags()
 
             q = self.mq
             if not q.applied:
                 return result
 
             mqtags = [(patch.node, patch.name) for patch in q.applied]
 
             if mqtags[-1][0] not in self.changelog.nodemap:
                 self.ui.warn(_('mq status file refers to unknown node %s\n')
                              % short(mqtags[-1][0]))
                 return result
 
             mqtags.append((mqtags[-1][0], 'qtip'))
             mqtags.append((mqtags[0][0], 'qbase'))
             mqtags.append((self.changelog.parents(mqtags[0][0])[0], 'qparent'))
             tags = result[0]
             for patch in mqtags:
                 if patch[1] in tags:
                     self.ui.warn(_('Tag %s overrides mq patch of the same name\n')
                                  % patch[1])
                 else:
                     tags[patch[1]] = patch[0]
 
             return result
 
         def _branchtags(self, partial, lrev):
             q = self.mq
             if not q.applied:
                 return super(mqrepo, self)._branchtags(partial, lrev)
 
             cl = self.changelog
             qbasenode = q.applied[0].node
             if qbasenode not in cl.nodemap:
                 self.ui.warn(_('mq status file refers to unknown node %s\n')
                              % short(qbasenode))
                 return super(mqrepo, self)._branchtags(partial, lrev)
 
             qbase = cl.rev(qbasenode)
             start = lrev + 1
             if start < qbase:
                 # update the cache (excluding the patches) and save it
-                self._updatebranchcache(partial, lrev + 1, qbase)
+                ctxgen = (self[r] for r in xrange(lrev + 1, qbase))
+                self._updatebranchcache(partial, ctxgen)
                 self._writebranchcache(partial, cl.node(qbase - 1), qbase - 1)
                 start = qbase
             # if start = qbase, the cache is as updated as it should be.
             # if start > qbase, the cache includes (part of) the patches.
             # we might as well use it, but we won't save it.
 
             # update the cache up to the tip
-            self._updatebranchcache(partial, start, len(cl))
+            ctxgen = (self[r] for r in xrange(start, len(cl)))
+            self._updatebranchcache(partial, ctxgen)
 
             return partial
 
     if repo.local():
         repo.__class__ = mqrepo
 
 def mqimport(orig, ui, repo, *args, **kwargs):
     if (hasattr(repo, 'abort_if_wdir_patched')
         and not kwargs.get('no_commit', False)):
         repo.abort_if_wdir_patched(_('cannot import over an applied patch'),
                                    kwargs.get('force'))
     return orig(ui, repo, *args, **kwargs)
 
 def mqinit(orig, ui, *args, **kwargs):
     mq = kwargs.pop('mq', None)
 
     if not mq:
         return orig(ui, *args, **kwargs)
 
     if args:
         repopath = args[0]
         if not hg.islocal(repopath):
             raise util.Abort(_('only a local queue repository '
                                'may be initialized'))
     else:
         repopath = cmdutil.findrepo(os.getcwd())
         if not repopath:
             raise util.Abort(_('There is no Mercurial repository here '
                                '(.hg not found)'))
     repo = hg.repository(ui, repopath)
     return qinit(ui, repo, True)
 
 def mqcommand(orig, ui, repo, *args, **kwargs):
     """Add --mq option to operate on patch repository instead of main"""
 
     # some commands do not like getting unknown options
     mq = kwargs.pop('mq', None)
 
     if not mq:
         return orig(ui, repo, *args, **kwargs)
 
     q = repo.mq
     r = q.qrepo()
     if not r:
         raise util.Abort('no queue repository')
     return orig(r.ui, r, *args, **kwargs)
 
 def uisetup(ui):
     mqopt = [('', 'mq', None, _("operate on patch repository"))]
 
     extensions.wrapcommand(commands.table, 'import', mqimport)
 
     entry = extensions.wrapcommand(commands.table, 'init', mqinit)
     entry[1].extend(mqopt)
 
     for cmd in commands.table.keys():
         cmd = cmdutil.parsealiases(cmd)[0]
         if cmd in commands.norepo:
             continue
         entry = extensions.wrapcommand(commands.table, cmd, mqcommand)
         entry[1].extend(mqopt)
 
 seriesopts = [('s', 'summary', None, _('print first line of patch header'))]
 
 cmdtable = {
     "qapplied":
         (applied,
          [('1', 'last', None, _('show only the last patch'))] + seriesopts,
          _('hg qapplied [-1] [-s] [PATCH]')),
     "qclone":
         (clone,
          [('', 'pull', None, _('use pull protocol to copy metadata')),
           ('U', 'noupdate', None, _('do not update the new working directories')),
           ('', 'uncompressed', None,
            _('use uncompressed transfer (fast over LAN)')),
           ('p', 'patches', '', _('location of source patch repository')),
          ] + commands.remoteopts,
          _('hg qclone [OPTION]... SOURCE [DEST]')),
     "qcommit|qci":
         (commit,
          commands.table["^commit|ci"][1],
          _('hg qcommit [OPTION]... [FILE]...')),
     "^qdiff":
         (diff,
          commands.diffopts + commands.diffopts2 + commands.walkopts,
          _('hg qdiff [OPTION]... [FILE]...')),
     "qdelete|qremove|qrm":
         (delete,
          [('k', 'keep', None, _('keep patch file')),
           ('r', 'rev', [], _('stop managing a revision (DEPRECATED)'))],
          _('hg qdelete [-k] [-r REV]... [PATCH]...')),
     'qfold':
         (fold,
          [('e', 'edit', None, _('edit patch header')),
           ('k', 'keep', None, _('keep folded patch files')),
          ] + commands.commitopts,
          _('hg qfold [-e] [-k] [-m TEXT] [-l FILE] PATCH...')),
     'qgoto':
         (goto,
          [('f', 'force', None, _('overwrite any local changes'))],
          _('hg qgoto [OPTION]... PATCH')),
     'qguard':
         (guard,
          [('l', 'list', None, _('list all patches and guards')),
           ('n', 'none', None, _('drop all guards'))],
          _('hg qguard [-l] [-n] [PATCH] [-- [+GUARD]... [-GUARD]...]')),
     'qheader': (header, [], _('hg qheader [PATCH]')),
     "^qimport":
         (qimport,
          [('e', 'existing', None, _('import file in patch directory')),
           ('n', 'name', '', _('name of patch file')),
           ('f', 'force', None, _('overwrite existing files')),
           ('r', 'rev', [], _('place existing revisions under mq control')),
           ('g', 'git', None, _('use git extended diff format')),
           ('P', 'push', None, _('qpush after importing'))],
          _('hg qimport [-e] [-n NAME] [-f] [-g] [-P] [-r REV]... FILE...')),
     "^qinit":
         (init,
          [('c', 'create-repo', None, _('create queue repository'))],
          _('hg qinit [-c]')),
     "qnew":
         (new,
          [('e', 'edit', None, _('edit commit message')),
           ('f', 'force', None, _('import uncommitted changes (DEPRECATED)')),
           ('g', 'git', None, _('use git extended diff format')),
           ('U', 'currentuser', None, _('add "From: <current user>" to patch')),
           ('u', 'user', '', _('add "From: <given user>" to patch')),
           ('D', 'currentdate', None, _('add "Date: <current date>" to patch')),
           ('d', 'date', '', _('add "Date: <given date>" to patch'))
           ] + commands.walkopts + commands.commitopts,
          _('hg qnew [-e] [-m TEXT] [-l FILE] [-f] PATCH [FILE]...')),
     "qnext": (next, [] + seriesopts, _('hg qnext [-s]')),
     "qprev": (prev, [] + seriesopts, _('hg qprev [-s]')),
     "^qpop":
         (pop,
          [('a', 'all', None, _('pop all patches')),
           ('n', 'name', '', _('queue name to pop (DEPRECATED)')),
           ('f', 'force', None, _('forget any local changes to patched files'))],
          _('hg qpop [-a] [-n NAME] [-f] [PATCH | INDEX]')),
     "^qpush":
         (push,
          [('f', 'force', None, _('apply if the patch has rejects')),
           ('l', 'list', None, _('list patch name in commit text')),
           ('a', 'all', None, _('apply all patches')),
           ('m', 'merge', None, _('merge from another queue (DEPRECATED)')),
           ('n', 'name', '', _('merge queue name (DEPRECATED)'))],
          _('hg qpush [-f] [-l] [-a] [-m] [-n NAME] [PATCH | INDEX]')),
     "^qrefresh":
         (refresh,
          [('e', 'edit', None, _('edit commit message')),
           ('g', 'git', None, _('use git extended diff format')),
           ('s', 'short', None,
            _('refresh only files already in the patch and specified files')),
           ('U', 'currentuser', None,
            _('add/update author field in patch with current user')),
           ('u', 'user', '',
            _('add/update author field in patch with given user')),
           ('D', 'currentdate', None,
            _('add/update date field in patch with current date')),
           ('d', 'date', '',
            _('add/update date field in patch with given date'))
           ] + commands.walkopts + commands.commitopts,
          _('hg qrefresh [-I] [-X] [-e] [-m TEXT] [-l FILE] [-s] [FILE]...')),
     'qrename|qmv':
         (rename, [], _('hg qrename PATCH1 [PATCH2]')),
     "qrestore":
         (restore,
          [('d', 'delete', None, _('delete save entry')),
           ('u', 'update', None, _('update queue working directory'))],
          _('hg qrestore [-d] [-u] REV')),
     "qsave":
         (save,
          [('c', 'copy', None, _('copy patch directory')),
           ('n', 'name', '', _('copy directory name')),
           ('e', 'empty', None, _('clear queue status file')),
           ('f', 'force', None, _('force copy'))] + commands.commitopts,
          _('hg qsave [-m TEXT] [-l FILE] [-c] [-n NAME] [-e] [-f]')),
     "qselect":
         (select,
          [('n', 'none', None, _('disable all guards')),
           ('s', 'series', None, _('list all guards in series file')),
           ('', 'pop', None, _('pop to before first guarded applied patch')),
           ('', 'reapply', None, _('pop, then reapply patches'))],
          _('hg qselect [OPTION]... [GUARD]...')),
     "qseries":
         (series,
          [('m', 'missing', None, _('print patches not in series')),
          ] + seriesopts,
          _('hg qseries [-ms]')),
     "^strip":
         (strip,
          [('f', 'force', None, _('force removal with local changes')),
           ('b', 'backup', None, _('bundle unrelated changesets')),
           ('n', 'nobackup', None, _('no backups'))],
          _('hg strip [-f] [-b] [-n] REV')),
     "qtop": (top, [] + seriesopts, _('hg qtop [-s]')),
     "qunapplied":
         (unapplied,
          [('1', 'first', None, _('show only the first patch'))] + seriesopts,
          _('hg qunapplied [-1] [-s] [PATCH]')),
     "qfinish":
         (finish,
          [('a', 'applied', None, _('finish all applied changesets'))],
          _('hg qfinish [-a] [REV]...')),
 }

mercurial/localrepo.py

@@ -1,2224 +1,2215
 # localrepo.py - read/write repository class for mercurial
 #
 # Copyright 2005-2007 Matt Mackall <[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.
 
 from node import bin, hex, nullid, nullrev, short
 from i18n import _
 import repo, changegroup, subrepo
 import changelog, dirstate, filelog, manifest, context
 import lock, transaction, store, encoding
 import util, extensions, hook, error
 import match as matchmod
 import merge as mergemod
 import tags as tagsmod
 from lock import release
 import weakref, stat, errno, os, time, inspect
 propertycache = util.propertycache
 
 class localrepository(repo.repository):
     capabilities = set(('lookup', 'changegroupsubset', 'branchmap'))
     supported = set('revlogv1 store fncache shared'.split())
 
     def __init__(self, baseui, path=None, create=0):
         repo.repository.__init__(self)
         self.root = os.path.realpath(path)
         self.path = os.path.join(self.root, ".hg")
         self.origroot = path
         self.opener = util.opener(self.path)
         self.wopener = util.opener(self.root)
         self.baseui = baseui
         self.ui = baseui.copy()
 
         try:
             self.ui.readconfig(self.join("hgrc"), self.root)
             extensions.loadall(self.ui)
         except IOError:
             pass
 
         if not os.path.isdir(self.path):
             if create:
                 if not os.path.exists(path):
                     os.mkdir(path)
                 os.mkdir(self.path)
                 requirements = ["revlogv1"]
                 if self.ui.configbool('format', 'usestore', True):
                     os.mkdir(os.path.join(self.path, "store"))
                     requirements.append("store")
                     if self.ui.configbool('format', 'usefncache', True):
                         requirements.append("fncache")
                     # create an invalid changelog
                     self.opener("00changelog.i", "a").write(
                         '\0\0\0\2' # represents revlogv2
                         ' dummy changelog to prevent using the old repo layout'
                     )
                 reqfile = self.opener("requires", "w")
                 for r in requirements:
                     reqfile.write("%s\n" % r)
                 reqfile.close()
             else:
                 raise error.RepoError(_("repository %s not found") % path)
         elif create:
             raise error.RepoError(_("repository %s already exists") % path)
         else:
             # find requirements
             requirements = set()
             try:
                 requirements = set(self.opener("requires").read().splitlines())
             except IOError, inst:
                 if inst.errno != errno.ENOENT:
                     raise
             for r in requirements - self.supported:
                 raise error.RepoError(_("requirement '%s' not supported") % r)
 
         self.sharedpath = self.path
         try:
             s = os.path.realpath(self.opener("sharedpath").read())
             if not os.path.exists(s):
                 raise error.RepoError(
                     _('.hg/sharedpath points to nonexistent directory %s') % s)
             self.sharedpath = s
         except IOError, inst:
             if inst.errno != errno.ENOENT:
                 raise
 
         self.store = store.store(requirements, self.sharedpath, util.opener)
         self.spath = self.store.path
         self.sopener = self.store.opener
         self.sjoin = self.store.join
         self.opener.createmode = self.store.createmode
         self.sopener.options = {}
 
         # These two define the set of tags for this repository.  _tags
         # maps tag name to node; _tagtypes maps tag name to 'global' or
         # 'local'.  (Global tags are defined by .hgtags across all
         # heads, and local tags are defined in .hg/localtags.)  They
         # constitute the in-memory cache of tags.
         self._tags = None
         self._tagtypes = None
 
         self._branchcache = None  # in UTF-8
         self._branchcachetip = None
         self.nodetagscache = None
         self.filterpats = {}
         self._datafilters = {}
         self._transref = self._lockref = self._wlockref = None
 
     @propertycache
     def changelog(self):
         c = changelog.changelog(self.sopener)
         if 'HG_PENDING' in os.environ:
             p = os.environ['HG_PENDING']
             if p.startswith(self.root):
                 c.readpending('00changelog.i.a')
         self.sopener.options['defversion'] = c.version
         return c
 
     @propertycache
     def manifest(self):
         return manifest.manifest(self.sopener)
 
     @propertycache
     def dirstate(self):
         return dirstate.dirstate(self.opener, self.ui, self.root)
 
     def __getitem__(self, changeid):
         if changeid is None:
             return context.workingctx(self)
         return context.changectx(self, changeid)
 
     def __contains__(self, changeid):
         try:
             return bool(self.lookup(changeid))
         except error.RepoLookupError:
             return False
 
     def __nonzero__(self):
         return True
 
     def __len__(self):
         return len(self.changelog)
 
     def __iter__(self):
         for i in xrange(len(self)):
             yield i
 
     def url(self):
         return 'file:' + self.root
 
     def hook(self, name, throw=False, **args):
         return hook.hook(self.ui, self, name, throw, **args)
 
     tag_disallowed = ':\r\n'
 
     def _tag(self, names, node, message, local, user, date, extra={}):
         if isinstance(names, str):
             allchars = names
             names = (names,)
         else:
             allchars = ''.join(names)
         for c in self.tag_disallowed:
             if c in allchars:
                 raise util.Abort(_('%r cannot be used in a tag name') % c)
 
         for name in names:
             self.hook('pretag', throw=True, node=hex(node), tag=name,
                       local=local)
 
         def writetags(fp, names, munge, prevtags):
             fp.seek(0, 2)
             if prevtags and prevtags[-1] != '\n':
                 fp.write('\n')
             for name in names:
                 m = munge and munge(name) or name
                 if self._tagtypes and name in self._tagtypes:
                     old = self._tags.get(name, nullid)
                     fp.write('%s %s\n' % (hex(old), m))
                 fp.write('%s %s\n' % (hex(node), m))
             fp.close()
 
         prevtags = ''
         if local:
             try:
                 fp = self.opener('localtags', 'r+')
             except IOError:
                 fp = self.opener('localtags', 'a')
             else:
                 prevtags = fp.read()
 
             # local tags are stored in the current charset
             writetags(fp, names, None, prevtags)
             for name in names:
                 self.hook('tag', node=hex(node), tag=name, local=local)
             return
 
         try:
             fp = self.wfile('.hgtags', 'rb+')
         except IOError:
             fp = self.wfile('.hgtags', 'ab')
         else:
             prevtags = fp.read()
 
         # committed tags are stored in UTF-8
         writetags(fp, names, encoding.fromlocal, prevtags)
 
         if '.hgtags' not in self.dirstate:
             self.add(['.hgtags'])
 
         m = matchmod.exact(self.root, '', ['.hgtags'])
         tagnode = self.commit(message, user, date, extra=extra, match=m)
 
         for name in names:
             self.hook('tag', node=hex(node), tag=name, local=local)
 
         return tagnode
 
     def tag(self, names, node, message, local, user, date):
         '''tag a revision with one or more symbolic names.
 
         names is a list of strings or, when adding a single tag, names may be a
         string.
 
         if local is True, the tags are stored in a per-repository file.
         otherwise, they are stored in the .hgtags file, and a new
         changeset is committed with the change.
 
         keyword arguments:
 
         local: whether to store tags in non-version-controlled file
         (default False)
 
         message: commit message to use if committing
 
         user: name of user to use if committing
 
         date: date tuple to use if committing'''
 
         for x in self.status()[:5]:
             if '.hgtags' in x:
                 raise util.Abort(_('working copy of .hgtags is changed '
                                    '(please commit .hgtags manually)'))
 
         self.tags() # instantiate the cache
         self._tag(names, node, message, local, user, date)
 
     def tags(self):
         '''return a mapping of tag to node'''
         if self._tags is None:
             (self._tags, self._tagtypes) = self._findtags()
 
         return self._tags
 
     def _findtags(self):
         '''Do the hard work of finding tags.  Return a pair of dicts
         (tags, tagtypes) where tags maps tag name to node, and tagtypes
         maps tag name to a string like \'global\' or \'local\'.
         Subclasses or extensions are free to add their own tags, but
         should be aware that the returned dicts will be retained for the
         duration of the localrepo object.'''
 
         # XXX what tagtype should subclasses/extensions use?  Currently
         # mq and bookmarks add tags, but do not set the tagtype at all.
         # Should each extension invent its own tag type?  Should there
         # be one tagtype for all such "virtual" tags?  Or is the status
         # quo fine?
 
         alltags = {}                    # map tag name to (node, hist)
         tagtypes = {}
 
         tagsmod.findglobaltags(self.ui, self, alltags, tagtypes)
         tagsmod.readlocaltags(self.ui, self, alltags, tagtypes)
 
         # Build the return dicts.  Have to re-encode tag names because
         # the tags module always uses UTF-8 (in order not to lose info
         # writing to the cache), but the rest of Mercurial wants them in
         # local encoding.
         tags = {}
         for (name, (node, hist)) in alltags.iteritems():
             if node != nullid:
                 tags[encoding.tolocal(name)] = node
         tags['tip'] = self.changelog.tip()
         tagtypes = dict([(encoding.tolocal(name), value)
                          for (name, value) in tagtypes.iteritems()])
         return (tags, tagtypes)
 
     def tagtype(self, tagname):
         '''
         return the type of the given tag. result can be:
 
         'local'  : a local tag
         'global' : a global tag
         None     : tag does not exist
         '''
 
         self.tags()
 
         return self._tagtypes.get(tagname)
 
     def tagslist(self):
         '''return a list of tags ordered by revision'''
         l = []
         for t, n in self.tags().iteritems():
             try:
                 r = self.changelog.rev(n)
             except:
                 r = -2 # sort to the beginning of the list if unknown
             l.append((r, t, n))
         return [(t, n) for r, t, n in sorted(l)]
 
     def nodetags(self, node):
         '''return the tags associated with a node'''
         if not self.nodetagscache:
             self.nodetagscache = {}
             for t, n in self.tags().iteritems():
                 self.nodetagscache.setdefault(n, []).append(t)
         return self.nodetagscache.get(node, [])
 
     def _branchtags(self, partial, lrev):
         # TODO: rename this function?
         tiprev = len(self) - 1
         if lrev != tiprev:
-            self._updatebranchcache(partial, lrev + 1, tiprev + 1)
+            ctxgen = (self[r] for r in xrange(lrev + 1, tiprev + 1))
+            self._updatebranchcache(partial, ctxgen)
             self._writebranchcache(partial, self.changelog.tip(), tiprev)
 
         return partial
 
     def branchmap(self):
         '''returns a dictionary {branch: [branchheads]}'''
         tip = self.changelog.tip()
         if self._branchcache is not None and self._branchcachetip == tip:
             return self._branchcache
 
         oldtip = self._branchcachetip
         self._branchcachetip = tip
         if oldtip is None or oldtip not in self.changelog.nodemap:
             partial, last, lrev = self._readbranchcache()
         else:
             lrev = self.changelog.rev(oldtip)
             partial = self._branchcache
 
         self._branchtags(partial, lrev)
         # this private cache holds all heads (not just tips)
         self._branchcache = partial
 
         return self._branchcache
 
     def branchtags(self):
         '''return a dict where branch names map to the tipmost head of
         the branch, open heads come before closed'''
         bt = {}
         for bn, heads in self.branchmap().iteritems():
             tip = heads[-1]
             for h in reversed(heads):
                 if 'close' not in self.changelog.read(h)[5]:
                     tip = h
                     break
             bt[bn] = tip
         return bt
 
 
     def _readbranchcache(self):
         partial = {}
         try:
             f = self.opener("branchheads.cache")
             lines = f.read().split('\n')
             f.close()
         except (IOError, OSError):
             return {}, nullid, nullrev
 
         try:
             last, lrev = lines.pop(0).split(" ", 1)
             last, lrev = bin(last), int(lrev)
             if lrev >= len(self) or self[lrev].node() != last:
                 # invalidate the cache
                 raise ValueError('invalidating branch cache (tip differs)')
             for l in lines:
                 if not l:
                     continue
                 node, label = l.split(" ", 1)
                 partial.setdefault(label.strip(), []).append(bin(node))
         except KeyboardInterrupt:
             raise
         except Exception, inst:
             if self.ui.debugflag:
                 self.ui.warn(str(inst), '\n')
             partial, last, lrev = {}, nullid, nullrev
         return partial, last, lrev
 
     def _writebranchcache(self, branches, tip, tiprev):
         try:
             f = self.opener("branchheads.cache", "w", atomictemp=True)
             f.write("%s %s\n" % (hex(tip), tiprev))
             for label, nodes in branches.iteritems():
                 for node in nodes:
                     f.write("%s %s\n" % (hex(node), label))
             f.rename()
         except (IOError, OSError):
             pass
 
-    def _updatebranchcache(self, partial, start, end):
+    def _updatebranchcache(self, partial, ctxgen):
         # collect new branch entries
         newbranches = {}
-        for r in xrange(start, end):
-            c = self[r]
+        for c in ctxgen:
             newbranches.setdefault(c.branch(), []).append(c.node())
         # if older branchheads are reachable from new ones, they aren't
         # really branchheads. Note checking parents is insufficient:
         # 1 (branch a) -> 2 (branch b) -> 3 (branch a)
         for branch, newnodes in newbranches.iteritems():
             bheads = partial.setdefault(branch, [])
             bheads.extend(newnodes)
             if len(bheads) < 2:
                 continue
             newbheads = []
             # starting from tip means fewer passes over reachable
             while newnodes:
                 latest = newnodes.pop()
                 if latest not in bheads:
                     continue
                 minbhrev = self[min([self[bh].rev() for bh in bheads])].node()
                 reachable = self.changelog.reachable(latest, minbhrev)
                 bheads = [b for b in bheads if b not in reachable]
                 newbheads.insert(0, latest)
             bheads.extend(newbheads)
             partial[branch] = bheads
 
     def lookup(self, key):
         if isinstance(key, int):
             return self.changelog.node(key)
         elif key == '.':
             return self.dirstate.parents()[0]
         elif key == 'null':
             return nullid
         elif key == 'tip':
             return self.changelog.tip()
         n = self.changelog._match(key)
         if n:
             return n
         if key in self.tags():
             return self.tags()[key]
         if key in self.branchtags():
             return self.branchtags()[key]
         n = self.changelog._partialmatch(key)
         if n:
             return n
 
         # can't find key, check if it might have come from damaged dirstate
         if key in self.dirstate.parents():
             raise error.Abort(_("working directory has unknown parent '%s'!")
                               % short(key))
         try:
             if len(key) == 20:
                 key = hex(key)
         except:
             pass
         raise error.RepoLookupError(_("unknown revision '%s'") % key)
 
     def local(self):
         return True
 
     def join(self, f):
         return os.path.join(self.path, f)
 
     def wjoin(self, f):
         return os.path.join(self.root, f)
 
     def rjoin(self, f):
         return os.path.join(self.root, util.pconvert(f))
 
     def file(self, f):
         if f[0] == '/':
             f = f[1:]
         return filelog.filelog(self.sopener, f)
 
     def changectx(self, changeid):
         return self[changeid]
 
     def parents(self, changeid=None):
         '''get list of changectxs for parents of changeid'''
         return self[changeid].parents()
 
     def filectx(self, path, changeid=None, fileid=None):
         """changeid can be a changeset revision, node, or tag.
            fileid can be a file revision or node."""
         return context.filectx(self, path, changeid, fileid)
 
     def getcwd(self):
         return self.dirstate.getcwd()
 
     def pathto(self, f, cwd=None):
         return self.dirstate.pathto(f, cwd)
 
     def wfile(self, f, mode='r'):
         return self.wopener(f, mode)
 
     def _link(self, f):
         return os.path.islink(self.wjoin(f))
 
     def _filter(self, filter, filename, data):
         if filter not in self.filterpats:
             l = []
             for pat, cmd in self.ui.configitems(filter):
                 if cmd == '!':
                     continue
                 mf = matchmod.match(self.root, '', [pat])
                 fn = None
                 params = cmd
                 for name, filterfn in self._datafilters.iteritems():
                     if cmd.startswith(name):
                         fn = filterfn
                         params = cmd[len(name):].lstrip()
                         break
                 if not fn:
                     fn = lambda s, c, **kwargs: util.filter(s, c)
                 # Wrap old filters not supporting keyword arguments
                 if not inspect.getargspec(fn)[2]:
                     oldfn = fn
                     fn = lambda s, c, **kwargs: oldfn(s, c)
                 l.append((mf, fn, params))
             self.filterpats[filter] = l
 
         for mf, fn, cmd in self.filterpats[filter]:
             if mf(filename):
                 self.ui.debug("filtering %s through %s\n" % (filename, cmd))
                 data = fn(data, cmd, ui=self.ui, repo=self, filename=filename)
                 break
 
         return data
 
     def adddatafilter(self, name, filter):
         self._datafilters[name] = filter
 
     def wread(self, filename):
         if self._link(filename):
             data = os.readlink(self.wjoin(filename))
         else:
             data = self.wopener(filename, 'r').read()
         return self._filter("encode", filename, data)
 
     def wwrite(self, filename, data, flags):
         data = self._filter("decode", filename, data)
         try:
             os.unlink(self.wjoin(filename))
         except OSError:
             pass
         if 'l' in flags:
             self.wopener.symlink(data, filename)
         else:
             self.wopener(filename, 'w').write(data)
             if 'x' in flags:
                 util.set_flags(self.wjoin(filename), False, True)
 
     def wwritedata(self, filename, data):
         return self._filter("decode", filename, data)
 
     def transaction(self):
         tr = self._transref and self._transref() or None
         if tr and tr.running():
             return tr.nest()
 
         # abort here if the journal already exists
         if os.path.exists(self.sjoin("journal")):
             raise error.RepoError(
                 _("abandoned transaction found - run hg recover"))
 
         # save dirstate for rollback
         try:
             ds = self.opener("dirstate").read()
         except IOError:
             ds = ""
         self.opener("journal.dirstate", "w").write(ds)
         self.opener("journal.branch", "w").write(self.dirstate.branch())
 
         renames = [(self.sjoin("journal"), self.sjoin("undo")),
                    (self.join("journal.dirstate"), self.join("undo.dirstate")),
                    (self.join("journal.branch"), self.join("undo.branch"))]
         tr = transaction.transaction(self.ui.warn, self.sopener,
                                      self.sjoin("journal"),
                                      aftertrans(renames),
                                      self.store.createmode)
         self._transref = weakref.ref(tr)
         return tr
 
     def recover(self):
         lock = self.lock()
         try:
             if os.path.exists(self.sjoin("journal")):
                 self.ui.status(_("rolling back interrupted transaction\n"))
                 transaction.rollback(self.sopener, self.sjoin("journal"),
                                      self.ui.warn)
                 self.invalidate()
                 return True
             else:
                 self.ui.warn(_("no interrupted transaction available\n"))
                 return False
         finally:
             lock.release()
 
     def rollback(self):
         wlock = lock = None
         try:
             wlock = self.wlock()
             lock = self.lock()
             if os.path.exists(self.sjoin("undo")):
                 self.ui.status(_("rolling back last transaction\n"))
                 transaction.rollback(self.sopener, self.sjoin("undo"),
                                      self.ui.warn)
                 util.rename(self.join("undo.dirstate"), self.join("dirstate"))
                 try:
                     branch = self.opener("undo.branch").read()
                     self.dirstate.setbranch(branch)
                 except IOError:
                     self.ui.warn(_("Named branch could not be reset, "
                                    "current branch still is: %s\n")
                                  % encoding.tolocal(self.dirstate.branch()))
                 self.invalidate()
                 self.dirstate.invalidate()
                 self.destroyed()
             else:
                 self.ui.warn(_("no rollback information available\n"))
         finally:
             release(lock, wlock)
 
     def invalidatecaches(self):
         self._tags = None
         self._tagtypes = None
         self.nodetagscache = None
         self._branchcache = None # in UTF-8
         self._branchcachetip = None
 
     def invalidate(self):
         for a in "changelog manifest".split():
             if a in self.__dict__:
                 delattr(self, a)
         self.invalidatecaches()
 
     def _lock(self, lockname, wait, releasefn, acquirefn, desc):
         try:
             l = lock.lock(lockname, 0, releasefn, desc=desc)
         except error.LockHeld, inst:
             if not wait:
                 raise
             self.ui.warn(_("waiting for lock on %s held by %r\n") %
                          (desc, inst.locker))
             # default to 600 seconds timeout
             l = lock.lock(lockname, int(self.ui.config("ui", "timeout", "600")),
                           releasefn, desc=desc)
         if acquirefn:
             acquirefn()
         return l
 
     def lock(self, wait=True):
         '''Lock the repository store (.hg/store) and return a weak reference
         to the lock. Use this before modifying the store (e.g. committing or
         stripping). If you are opening a transaction, get a lock as well.)'''
         l = self._lockref and self._lockref()
         if l is not None and l.held:
             l.lock()
             return l
 
         l = self._lock(self.sjoin("lock"), wait, None, self.invalidate,
                        _('repository %s') % self.origroot)
         self._lockref = weakref.ref(l)
         return l
 
     def wlock(self, wait=True):
         '''Lock the non-store parts of the repository (everything under
         .hg except .hg/store) and return a weak reference to the lock.
         Use this before modifying files in .hg.'''
         l = self._wlockref and self._wlockref()
         if l is not None and l.held:
             l.lock()
             return l
 
         l = self._lock(self.join("wlock"), wait, self.dirstate.write,
                        self.dirstate.invalidate, _('working directory of %s') %
                        self.origroot)
         self._wlockref = weakref.ref(l)
         return l
 
     def _filecommit(self, fctx, manifest1, manifest2, linkrev, tr, changelist):
         """
         commit an individual file as part of a larger transaction
         """
 
         fname = fctx.path()
         text = fctx.data()
         flog = self.file(fname)
         fparent1 = manifest1.get(fname, nullid)
         fparent2 = fparent2o = manifest2.get(fname, nullid)
 
         meta = {}
         copy = fctx.renamed()
         if copy and copy[0] != fname:
             # Mark the new revision of this file as a copy of another
             # file.  This copy data will effectively act as a parent
             # of this new revision.  If this is a merge, the first
             # parent will be the nullid (meaning "look up the copy data")
             # and the second one will be the other parent.  For example:
             #
             # 0 --- 1 --- 3   rev1 changes file foo
             #   \       /     rev2 renames foo to bar and changes it
             #    \- 2 -/      rev3 should have bar with all changes and
             #                      should record that bar descends from
             #                      bar in rev2 and foo in rev1
             #
             # this allows this merge to succeed:
             #
             # 0 --- 1 --- 3   rev4 reverts the content change from rev2
             #   \       /     merging rev3 and rev4 should use bar@rev2
             #    \- 2 --- 4        as the merge base
             #
 
             cfname = copy[0]
             crev = manifest1.get(cfname)
             newfparent = fparent2
 
             if manifest2: # branch merge
                 if fparent2 == nullid or crev is None: # copied on remote side
                     if cfname in manifest2:
                         crev = manifest2[cfname]
                         newfparent = fparent1
 
             # find source in nearest ancestor if we've lost track
             if not crev:
                 self.ui.debug(" %s: searching for copy revision for %s\n" %
                               (fname, cfname))
                 for ancestor in self['.'].ancestors():
                     if cfname in ancestor:
                         crev = ancestor[cfname].filenode()
                         break
 
             self.ui.debug(" %s: copy %s:%s\n" % (fname, cfname, hex(crev)))
             meta["copy"] = cfname
             meta["copyrev"] = hex(crev)
             fparent1, fparent2 = nullid, newfparent
         elif fparent2 != nullid:
             # is one parent an ancestor of the other?
             fparentancestor = flog.ancestor(fparent1, fparent2)
             if fparentancestor == fparent1:
                 fparent1, fparent2 = fparent2, nullid
             elif fparentancestor == fparent2:
                 fparent2 = nullid
 
         # is the file changed?
         if fparent2 != nullid or flog.cmp(fparent1, text) or meta:
             changelist.append(fname)
             return flog.add(text, meta, tr, linkrev, fparent1, fparent2)
 
         # are just the flags changed during merge?
         if fparent1 != fparent2o and manifest1.flags(fname) != fctx.flags():
             changelist.append(fname)
 
         return fparent1
 
     def commit(self, text="", user=None, date=None, match=None, force=False,
                editor=False, extra={}):
         """Add a new revision to current repository.
 
         Revision information is gathered from the working directory,
         match can be used to filter the committed files. If editor is
         supplied, it is called to get a commit message.
         """
 
         def fail(f, msg):
             raise util.Abort('%s: %s' % (f, msg))
 
         if not match:
             match = matchmod.always(self.root, '')
 
         if not force:
             vdirs = []
             match.dir = vdirs.append
             match.bad = fail
 
         wlock = self.wlock()
         try:
             p1, p2 = self.dirstate.parents()
             wctx = self[None]
 
             if (not force and p2 != nullid and match and
                 (match.files() or match.anypats())):
                 raise util.Abort(_('cannot partially commit a merge '
                                    '(do not specify files or patterns)'))
 
             changes = self.status(match=match, clean=force)
             if force:
                 changes[0].extend(changes[6]) # mq may commit unchanged files
 
             # check subrepos
             subs = []
             removedsubs = set()
             for p in wctx.parents():
                 removedsubs.update(s for s in p.substate if match(s))
             for s in wctx.substate:
                 removedsubs.discard(s)
                 if match(s) and wctx.sub(s).dirty():
                     subs.append(s)
             if (subs or removedsubs) and '.hgsubstate' not in changes[0]:
                 changes[0].insert(0, '.hgsubstate')
 
             # make sure all explicit patterns are matched
             if not force and match.files():
                 matched = set(changes[0] + changes[1] + changes[2])
 
                 for f in match.files():
                     if f == '.' or f in matched or f in wctx.substate:
                         continue
                     if f in changes[3]: # missing
                         fail(f, _('file not found!'))
                     if f in vdirs: # visited directory
                         d = f + '/'
                         for mf in matched:
                             if mf.startswith(d):
                                 break
                         else:
                             fail(f, _("no match under directory!"))
                     elif f not in self.dirstate:
                         fail(f, _("file not tracked!"))
 
             if (not force and not extra.get("close") and p2 == nullid
                 and not (changes[0] or changes[1] or changes[2])
                 and self[None].branch() == self['.'].branch()):
                 return None
 
             ms = mergemod.mergestate(self)
             for f in changes[0]:
                 if f in ms and ms[f] == 'u':
                     raise util.Abort(_("unresolved merge conflicts "
                                                     "(see hg resolve)"))
 
             cctx = context.workingctx(self, (p1, p2), text, user, date,
                                       extra, changes)
             if editor:
                 cctx._text = editor(self, cctx, subs)
             edited = (text != cctx._text)
 
             # commit subs
             if subs or removedsubs:
                 state = wctx.substate.copy()
                 for s in subs:
                     self.ui.status(_('committing subrepository %s\n') % s)
                     sr = wctx.sub(s).commit(cctx._text, user, date)
                     state[s] = (state[s][0], sr)
                 subrepo.writestate(self, state)
 
             # Save commit message in case this transaction gets rolled back
             # (e.g. by a pretxncommit hook).  Leave the content alone on
             # the assumption that the user will use the same editor again.
             msgfile = self.opener('last-message.txt', 'wb')
             msgfile.write(cctx._text)
             msgfile.close()
 
             try:
                 hookp1, hookp2 = hex(p1), (p2 != nullid and hex(p2) or '')
                 self.hook("precommit", throw=True, parent1=hookp1, parent2=hookp2)
                 ret = self.commitctx(cctx, True)
             except:
                 if edited:
                     msgfn = self.pathto(msgfile.name[len(self.root)+1:])
                     self.ui.write(
                         _('note: commit message saved in %s\n') % msgfn)
                 raise
 
             # update dirstate and mergestate
             for f in changes[0] + changes[1]:
                 self.dirstate.normal(f)
             for f in changes[2]:
                 self.dirstate.forget(f)
             self.dirstate.setparents(ret)
             ms.reset()
         finally:
             wlock.release()
 
         self.hook("commit", node=hex(ret), parent1=hookp1, parent2=hookp2)
         return ret
 
     def commitctx(self, ctx, error=False):
         """Add a new revision to current repository.
         Revision information is passed via the context argument.
         """
 
         tr = lock = None
         removed = ctx.removed()
         p1, p2 = ctx.p1(), ctx.p2()
         m1 = p1.manifest().copy()
         m2 = p2.manifest()
         user = ctx.user()
 
         lock = self.lock()
         try:
             tr = self.transaction()
             trp = weakref.proxy(tr)
 
             # check in files
             new = {}
             changed = []
             linkrev = len(self)
             for f in sorted(ctx.modified() + ctx.added()):
                 self.ui.note(f + "\n")
                 try:
                     fctx = ctx[f]
                     new[f] = self._filecommit(fctx, m1, m2, linkrev, trp,
                                               changed)
                     m1.set(f, fctx.flags())
                 except OSError, inst:
                     self.ui.warn(_("trouble committing %s!\n") % f)
                     raise
                 except IOError, inst:
                     errcode = getattr(inst, 'errno', errno.ENOENT)
                     if error or errcode and errcode != errno.ENOENT:
                         self.ui.warn(_("trouble committing %s!\n") % f)
                         raise
                     else:
                         removed.append(f)
 
             # update manifest
             m1.update(new)
             removed = [f for f in sorted(removed) if f in m1 or f in m2]
             drop = [f for f in removed if f in m1]
             for f in drop:
                 del m1[f]
             mn = self.manifest.add(m1, trp, linkrev, p1.manifestnode(),
                                    p2.manifestnode(), (new, drop))
 
             # update changelog
             self.changelog.delayupdate()
             n = self.changelog.add(mn, changed + removed, ctx.description(),
                                    trp, p1.node(), p2.node(),
                                    user, ctx.date(), ctx.extra().copy())
             p = lambda: self.changelog.writepending() and self.root or ""
             xp1, xp2 = p1.hex(), p2 and p2.hex() or ''
             self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1,
                       parent2=xp2, pending=p)
             self.changelog.finalize(trp)
             tr.close()
 
             if self._branchcache:
                 self.branchtags()
             return n
         finally:
             del tr
             lock.release()
 
     def destroyed(self):
         '''Inform the repository that nodes have been destroyed.
         Intended for use by strip and rollback, so there's a common
         place for anything that has to be done after destroying history.'''
         # XXX it might be nice if we could take the list of destroyed
         # nodes, but I don't see an easy way for rollback() to do that
 
         # Ensure the persistent tag cache is updated.  Doing it now
         # means that the tag cache only has to worry about destroyed
         # heads immediately after a strip/rollback.  That in turn
         # guarantees that "cachetip == currenttip" (comparing both rev
         # and node) always means no nodes have been added or destroyed.
 
         # XXX this is suboptimal when qrefresh'ing: we strip the current
         # head, refresh the tag cache, then immediately add a new head.
         # But I think doing it this way is necessary for the "instant
         # tag cache retrieval" case to work.
         self.invalidatecaches()
 
     def walk(self, match, node=None):
         '''
         walk recursively through the directory tree or a given
         changeset, finding all files matched by the match
         function
         '''
         return self[node].walk(match)
 
     def status(self, node1='.', node2=None, match=None,
                ignored=False, clean=False, unknown=False):
         """return status of files between two nodes or node and working directory
 
         If node1 is None, use the first dirstate parent instead.
         If node2 is None, compare node1 with working directory.
         """
 
         def mfmatches(ctx):
             mf = ctx.manifest().copy()
             for fn in mf.keys():
                 if not match(fn):
                     del mf[fn]
             return mf
 
         if isinstance(node1, context.changectx):
             ctx1 = node1
         else:
             ctx1 = self[node1]
         if isinstance(node2, context.changectx):
             ctx2 = node2
         else:
             ctx2 = self[node2]
 
         working = ctx2.rev() is None
         parentworking = working and ctx1 == self['.']
         match = match or matchmod.always(self.root, self.getcwd())
         listignored, listclean, listunknown = ignored, clean, unknown
 
         # load earliest manifest first for caching reasons
         if not working and ctx2.rev() < ctx1.rev():
             ctx2.manifest()
 
         if not parentworking:
             def bad(f, msg):
                 if f not in ctx1:
                     self.ui.warn('%s: %s\n' % (self.dirstate.pathto(f), msg))
             match.bad = bad
 
         if working: # we need to scan the working dir
             subrepos = ctx1.substate.keys()
             s = self.dirstate.status(match, subrepos, listignored,
                                      listclean, listunknown)
             cmp, modified, added, removed, deleted, unknown, ignored, clean = s
 
             # check for any possibly clean files
             if parentworking and cmp:
                 fixup = []
                 # do a full compare of any files that might have changed
                 for f in sorted(cmp):
                     if (f not in ctx1 or ctx2.flags(f) != ctx1.flags(f)
                         or ctx1[f].cmp(ctx2[f].data())):
                         modified.append(f)
                     else:
                         fixup.append(f)
 
                 if listclean:
                     clean += fixup
 
                 # update dirstate for files that are actually clean
                 if fixup:
                     try:
                         # updating the dirstate is optional
                         # so we don't wait on the lock
                         wlock = self.wlock(False)
                         try:
                             for f in fixup:
                                 self.dirstate.normal(f)
                         finally:
                             wlock.release()
                     except error.LockError:
                         pass
 
         if not parentworking:
             mf1 = mfmatches(ctx1)
             if working:
                 # we are comparing working dir against non-parent
                 # generate a pseudo-manifest for the working dir
                 mf2 = mfmatches(self['.'])
                 for f in cmp + modified + added:
                     mf2[f] = None
                     mf2.set(f, ctx2.flags(f))
                 for f in removed:
                     if f in mf2:
                         del mf2[f]
             else:
                 # we are comparing two revisions
                 deleted, unknown, ignored = [], [], []
                 mf2 = mfmatches(ctx2)
 
             modified, added, clean = [], [], []
             for fn in mf2:
                 if fn in mf1:
                     if (mf1.flags(fn) != mf2.flags(fn) or
                         (mf1[fn] != mf2[fn] and
                          (mf2[fn] or ctx1[fn].cmp(ctx2[fn].data())))):
                         modified.append(fn)
                     elif listclean:
                         clean.append(fn)
                     del mf1[fn]
                 else:
                     added.append(fn)
             removed = mf1.keys()
 
         r = modified, added, removed, deleted, unknown, ignored, clean
         [l.sort() for l in r]
         return r
 
     def add(self, list):
         wlock = self.wlock()
         try:
             rejected = []
             for f in list:
                 p = self.wjoin(f)
                 try:
                     st = os.lstat(p)
                 except:
                     self.ui.warn(_("%s does not exist!\n") % f)
                     rejected.append(f)
                     continue
                 if st.st_size > 10000000:
                     self.ui.warn(_("%s: up to %d MB of RAM may be required "
                                    "to manage this file\n"
                                    "(use 'hg revert %s' to cancel the "
                                    "pending addition)\n")
                                    % (f, 3 * st.st_size // 1000000, f))
                 if not (stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode)):
                     self.ui.warn(_("%s not added: only files and symlinks "
                                    "supported currently\n") % f)
                     rejected.append(p)
                 elif self.dirstate[f] in 'amn':
                     self.ui.warn(_("%s already tracked!\n") % f)
                 elif self.dirstate[f] == 'r':
                     self.dirstate.normallookup(f)
                 else:
                     self.dirstate.add(f)
             return rejected
         finally:
             wlock.release()
 
     def forget(self, list):
         wlock = self.wlock()
         try:
             for f in list:
                 if self.dirstate[f] != 'a':
                     self.ui.warn(_("%s not added!\n") % f)
                 else:
                     self.dirstate.forget(f)
         finally:
             wlock.release()
 
     def remove(self, list, unlink=False):
         if unlink:
             for f in list:
                 try:
                     util.unlink(self.wjoin(f))
                 except OSError, inst:
                     if inst.errno != errno.ENOENT:
                         raise
         wlock = self.wlock()
         try:
             for f in list:
                 if unlink and os.path.exists(self.wjoin(f)):
                     self.ui.warn(_("%s still exists!\n") % f)
                 elif self.dirstate[f] == 'a':
                     self.dirstate.forget(f)
                 elif f not in self.dirstate:
                     self.ui.warn(_("%s not tracked!\n") % f)
                 else:
                     self.dirstate.remove(f)
         finally:
             wlock.release()
 
     def undelete(self, list):
         manifests = [self.manifest.read(self.changelog.read(p)[0])
                      for p in self.dirstate.parents() if p != nullid]
         wlock = self.wlock()
         try:
             for f in list:
                 if self.dirstate[f] != 'r':
                     self.ui.warn(_("%s not removed!\n") % f)
                 else:
                     m = f in manifests[0] and manifests[0] or manifests[1]
                     t = self.file(f).read(m[f])
                     self.wwrite(f, t, m.flags(f))
                     self.dirstate.normal(f)
         finally:
             wlock.release()
 
     def copy(self, source, dest):
         p = self.wjoin(dest)
         if not (os.path.exists(p) or os.path.islink(p)):
             self.ui.warn(_("%s does not exist!\n") % dest)
         elif not (os.path.isfile(p) or os.path.islink(p)):
             self.ui.warn(_("copy failed: %s is not a file or a "
                            "symbolic link\n") % dest)
         else:
             wlock = self.wlock()
             try:
                 if self.dirstate[dest] in '?r':
                     self.dirstate.add(dest)
                 self.dirstate.copy(source, dest)
             finally:
                 wlock.release()
 
     def heads(self, start=None):
         heads = self.changelog.heads(start)
         # sort the output in rev descending order
         heads = [(-self.changelog.rev(h), h) for h in heads]
         return [n for (r, n) in sorted(heads)]
 
     def branchheads(self, branch=None, start=None, closed=False):
         '''return a (possibly filtered) list of heads for the given branch
 
         Heads are returned in topological order, from newest to oldest.
         If branch is None, use the dirstate branch.
         If start is not None, return only heads reachable from start.
         If closed is True, return heads that are marked as closed as well.
         '''
         if branch is None:
             branch = self[None].branch()
         branches = self.branchmap()
         if branch not in branches:
             return []
         # the cache returns heads ordered lowest to highest
         bheads = list(reversed(branches[branch]))
         if start is not None:
             # filter out the heads that cannot be reached from startrev
             fbheads = set(self.changelog.nodesbetween([start], bheads)[2])
             bheads = [h for h in bheads if h in fbheads]
         if not closed:
             bheads = [h for h in bheads if
                       ('close' not in self.changelog.read(h)[5])]
         return bheads
 
     def branches(self, nodes):
         if not nodes:
             nodes = [self.changelog.tip()]
         b = []
         for n in nodes:
             t = n
             while 1:
                 p = self.changelog.parents(n)
                 if p[1] != nullid or p[0] == nullid:
                     b.append((t, n, p[0], p[1]))
                     break
                 n = p[0]
         return b
 
     def between(self, pairs):
         r = []
 
         for top, bottom in pairs:
             n, l, i = top, [], 0
             f = 1
 
             while n != bottom and n != nullid:
                 p = self.changelog.parents(n)[0]
                 if i == f:
                     l.append(n)
                     f = f * 2
                 n = p
                 i += 1
 
             r.append(l)
 
         return r
 
     def findincoming(self, remote, base=None, heads=None, force=False):
         """Return list of roots of the subsets of missing nodes from remote
 
         If base dict is specified, assume that these nodes and their parents
         exist on the remote side and that no child of a node of base exists
         in both remote and self.
         Furthermore base will be updated to include the nodes that exists
         in self and remote but no children exists in self and remote.
         If a list of heads is specified, return only nodes which are heads
         or ancestors of these heads.
 
         All the ancestors of base are in self and in remote.
         All the descendants of the list returned are missing in self.
         (and so we know that the rest of the nodes are missing in remote, see
         outgoing)
         """
         return self.findcommonincoming(remote, base, heads, force)[1]
 
     def findcommonincoming(self, remote, base=None, heads=None, force=False):
         """Return a tuple (common, missing roots, heads) used to identify
         missing nodes from remote.
 
         If base dict is specified, assume that these nodes and their parents
         exist on the remote side and that no child of a node of base exists
         in both remote and self.
         Furthermore base will be updated to include the nodes that exists
         in self and remote but no children exists in self and remote.
         If a list of heads is specified, return only nodes which are heads
         or ancestors of these heads.
 
         All the ancestors of base are in self and in remote.
         """
         m = self.changelog.nodemap
         search = []
         fetch = set()
         seen = set()
         seenbranch = set()
         if base is None:
             base = {}
 
         if not heads:
             heads = remote.heads()
 
         if self.changelog.tip() == nullid:
             base[nullid] = 1
             if heads != [nullid]:
                 return [nullid], [nullid], list(heads)
             return [nullid], [], []
 
         # assume we're closer to the tip than the root
         # and start by examining the heads
         self.ui.status(_("searching for changes\n"))
 
         unknown = []
         for h in heads:
             if h not in m:
                 unknown.append(h)
             else:
                 base[h] = 1
 
         heads = unknown
         if not unknown:
             return base.keys(), [], []
 
         req = set(unknown)
         reqcnt = 0
 
         # search through remote branches
         # a 'branch' here is a linear segment of history, with four parts:
         # head, root, first parent, second parent
         # (a branch always has two parents (or none) by definition)
         unknown = remote.branches(unknown)
         while unknown:
             r = []
             while unknown:
                 n = unknown.pop(0)
                 if n[0] in seen:
                     continue
 
                 self.ui.debug("examining %s:%s\n"
                               % (short(n[0]), short(n[1])))
                 if n[0] == nullid: # found the end of the branch
                     pass
                 elif n in seenbranch:
                     self.ui.debug("branch already found\n")
                     continue
                 elif n[1] and n[1] in m: # do we know the base?
                     self.ui.debug("found incomplete branch %s:%s\n"
                                   % (short(n[0]), short(n[1])))
                     search.append(n[0:2]) # schedule branch range for scanning
                     seenbranch.add(n)
                 else:
                     if n[1] not in seen and n[1] not in fetch:
                         if n[2] in m and n[3] in m:
                             self.ui.debug("found new changeset %s\n" %
                                           short(n[1]))
                             fetch.add(n[1]) # earliest unknown
                         for p in n[2:4]:
                             if p in m:
                                 base[p] = 1 # latest known
 
                     for p in n[2:4]:
                         if p not in req and p not in m:
                             r.append(p)
                             req.add(p)
                 seen.add(n[0])
 
             if r:
                 reqcnt += 1
                 self.ui.progress(_('searching'), reqcnt, unit=_('queries'))
                 self.ui.debug("request %d: %s\n" %
                             (reqcnt, " ".join(map(short, r))))
                 for p in xrange(0, len(r), 10):
                     for b in remote.branches(r[p:p + 10]):
                         self.ui.debug("received %s:%s\n" %
                                       (short(b[0]), short(b[1])))
                         unknown.append(b)
 
         # do binary search on the branches we found
         while search:
             newsearch = []
             reqcnt += 1
             self.ui.progress(_('searching'), reqcnt, unit=_('queries'))
             for n, l in zip(search, remote.between(search)):
                 l.append(n[1])
                 p = n[0]
                 f = 1
                 for i in l:
                     self.ui.debug("narrowing %d:%d %s\n" % (f, len(l), short(i)))
                     if i in m:
                         if f <= 2:
                             self.ui.debug("found new branch changeset %s\n" %
                                               short(p))
                             fetch.add(p)
                             base[i] = 1
                         else:
                             self.ui.debug("narrowed branch search to %s:%s\n"
                                           % (short(p), short(i)))
                             newsearch.append((p, i))
                         break
                     p, f = i, f * 2
                 search = newsearch
 
         # sanity check our fetch list
         for f in fetch:
             if f in m:
                 raise error.RepoError(_("already have changeset ")
                                       + short(f[:4]))
 
         if base.keys() == [nullid]:
             if force:
                 self.ui.warn(_("warning: repository is unrelated\n"))
             else:
                 raise util.Abort(_("repository is unrelated"))
 
         self.ui.debug("found new changesets starting at " +
                      " ".join([short(f) for f in fetch]) + "\n")
 
         self.ui.progress(_('searching'), None)
         self.ui.debug("%d total queries\n" % reqcnt)
 
         return base.keys(), list(fetch), heads
 
     def findoutgoing(self, remote, base=None, heads=None, force=False):
         """Return list of nodes that are roots of subsets not in remote
 
         If base dict is specified, assume that these nodes and their parents
         exist on the remote side.
         If a list of heads is specified, return only nodes which are heads
         or ancestors of these heads, and return a second element which
         contains all remote heads which get new children.
         """
         if base is None:
             base = {}
             self.findincoming(remote, base, heads, force=force)
 
         self.ui.debug("common changesets up to "
                       + " ".join(map(short, base.keys())) + "\n")
 
         remain = set(self.changelog.nodemap)
 
         # prune everything remote has from the tree
         remain.remove(nullid)
         remove = base.keys()
         while remove:
             n = remove.pop(0)
             if n in remain:
                 remain.remove(n)
                 for p in self.changelog.parents(n):
                     remove.append(p)
 
         # find every node whose parents have been pruned
         subset = []
         # find every remote head that will get new children
         updated_heads = set()
         for n in remain:
             p1, p2 = self.changelog.parents(n)
             if p1 not in remain and p2 not in remain:
                 subset.append(n)
             if heads:
                 if p1 in heads:
                     updated_heads.add(p1)
                 if p2 in heads:
                     updated_heads.add(p2)
 
         # this is the set of all roots we have to push
         if heads:
             return subset, list(updated_heads)
         else:
             return subset
 
     def pull(self, remote, heads=None, force=False):
         lock = self.lock()
         try:
             common, fetch, rheads = self.findcommonincoming(remote, heads=heads,
                                                             force=force)
             if fetch == [nullid]:
                 self.ui.status(_("requesting all changes\n"))
 
             if not fetch:
                 self.ui.status(_("no changes found\n"))
                 return 0
 
             if heads is None and remote.capable('changegroupsubset'):
                 heads = rheads
 
             if heads is None:
                 cg = remote.changegroup(fetch, 'pull')
             else:
                 if not remote.capable('changegroupsubset'):
                     raise util.Abort(_("Partial pull cannot be done because "
                                        "other repository doesn't support "
                                        "changegroupsubset."))
                 cg = remote.changegroupsubset(fetch, heads, 'pull')
             return self.addchangegroup(cg, 'pull', remote.url())
         finally:
             lock.release()
 
     def push(self, remote, force=False, revs=None):
         # there are two ways to push to remote repo:
         #
         # addchangegroup assumes local user can lock remote
         # repo (local filesystem, old ssh servers).
         #
         # unbundle assumes local user cannot lock remote repo (new ssh
         # servers, http servers).
 
         if remote.capable('unbundle'):
             return self.push_unbundle(remote, force, revs)
         return self.push_addchangegroup(remote, force, revs)
 
     def prepush(self, remote, force, revs):
         '''Analyze the local and remote repositories and determine which
         changesets need to be pushed to the remote.  Return a tuple
         (changegroup, remoteheads).  changegroup is a readable file-like
         object whose read() returns successive changegroup chunks ready to
         be sent over the wire.  remoteheads is the list of remote heads.
         '''
         common = {}
         remote_heads = remote.heads()
         inc = self.findincoming(remote, common, remote_heads, force=force)
 
         update, updated_heads = self.findoutgoing(remote, common, remote_heads)
         msng_cl, bases, heads = self.changelog.nodesbetween(update, revs)
 
-        def checkbranch(lheads, rheads, updatelb, branchname=None):
+        def checkbranch(lheads, rheads, branchname=None):
             '''
             check whether there are more local heads than remote heads on
             a specific branch.
 
             lheads: local branch heads
             rheads: remote branch heads
-            updatelb: outgoing local branch bases
             '''
 
             warn = 0
 
-            if not revs and len(lheads) > len(rheads):
+            if len(lheads) > len(rheads):
                 warn = 1
             else:
-                # add local heads involved in the push
-                updatelheads = [self.changelog.heads(x, lheads)
-                                for x in updatelb]
-                newheads = set(sum(updatelheads, [])) & set(lheads)
-
-                if not newheads:
-                    return True
-
                 # add heads we don't have or that are not involved in the push
+                newheads = set(lheads)
                 for r in rheads:
                     if r in self.changelog.nodemap:
                         desc = self.changelog.heads(r, heads)
                         l = [h for h in heads if h in desc]
                         if not l:
                             newheads.add(r)
                     else:
                         newheads.add(r)
                 if len(newheads) > len(rheads):
                     warn = 1
 
             if warn:
                 if branchname is not None:
                     msg = _("abort: push creates new remote heads"
                             " on branch '%s'!\n") % branchname
                 else:
                     msg = _("abort: push creates new remote heads!\n")
                 self.ui.warn(msg)
                 if len(lheads) > len(rheads):
                     self.ui.status(_("(did you forget to merge?"
                                      " use push -f to force)\n"))
                 else:
                     self.ui.status(_("(you should pull and merge or"
                                      " use push -f to force)\n"))
                 return False
             return True
 
         if not bases:
             self.ui.status(_("no changes found\n"))
             return None, 1
         elif not force:
             # Check for each named branch if we're creating new remote heads.
             # To be a remote head after push, node must be either:
             # - unknown locally
             # - a local outgoing head descended from update
             # - a remote head that's known locally and not
             #   ancestral to an outgoing head
             #
             # New named branches cannot be created without --force.
 
             if remote_heads != [nullid]:
                 if remote.capable('branchmap'):
                     remotebrheads = remote.branchmap()
 
                     if not revs:
                         localbrheads = self.branchmap()
                     else:
                         localbrheads = {}
-                        for n in heads:
-                            branch = self[n].branch()
-                            localbrheads.setdefault(branch, []).append(n)
+                        ctxgen = (self[n] for n in msng_cl)
+                        self._updatebranchcache(localbrheads, ctxgen)
 
                     newbranches = list(set(localbrheads) - set(remotebrheads))
                     if newbranches: # new branch requires --force
                         branchnames = ', '.join("%s" % b for b in newbranches)
                         self.ui.warn(_("abort: push creates "
                                        "new remote branches: %s!\n")
                                      % branchnames)
                         # propose 'push -b .' in the msg too?
                         self.ui.status(_("(use 'hg push -f' to force)\n"))
                         return None, 0
                     for branch, lheads in localbrheads.iteritems():
                         if branch in remotebrheads:
                             rheads = remotebrheads[branch]
-                            if not checkbranch(lheads, rheads, update, branch):
+                            if not checkbranch(lheads, rheads, branch):
                                 return None, 0
                 else:
-                    if not checkbranch(heads, remote_heads, update):
+                    if not checkbranch(heads, remote_heads):
                         return None, 0
 
             if inc:
                 self.ui.warn(_("note: unsynced remote changes!\n"))
 
 
         if revs is None:
             # use the fast path, no race possible on push
             nodes = self.changelog.findmissing(common.keys())
             cg = self._changegroup(nodes, 'push')
         else:
             cg = self.changegroupsubset(update, revs, 'push')
         return cg, remote_heads
 
     def push_addchangegroup(self, remote, force, revs):
         lock = remote.lock()
         try:
             ret = self.prepush(remote, force, revs)
             if ret[0] is not None:
                 cg, remote_heads = ret
                 return remote.addchangegroup(cg, 'push', self.url())
             return ret[1]
         finally:
             lock.release()
 
     def push_unbundle(self, remote, force, revs):
         # local repo finds heads on server, finds out what revs it
         # must push.  once revs transferred, if server finds it has
         # different heads (someone else won commit/push race), server
         # aborts.
 
         ret = self.prepush(remote, force, revs)
         if ret[0] is not None:
             cg, remote_heads = ret
             if force:
                 remote_heads = ['force']
             return remote.unbundle(cg, remote_heads, 'push')
         return ret[1]
 
     def changegroupinfo(self, nodes, source):
         if self.ui.verbose or source == 'bundle':
             self.ui.status(_("%d changesets found\n") % len(nodes))
         if self.ui.debugflag:
             self.ui.debug("list of changesets:\n")
             for node in nodes:
                 self.ui.debug("%s\n" % hex(node))
 
     def changegroupsubset(self, bases, heads, source, extranodes=None):
         """Compute a changegroup consisting of all the nodes that are
         descendents of any of the bases and ancestors of any of the heads.
         Return a chunkbuffer object whose read() method will return
         successive changegroup chunks.
 
         It is fairly complex as determining which filenodes and which
         manifest nodes need to be included for the changeset to be complete
         is non-trivial.
 
         Another wrinkle is doing the reverse, figuring out which changeset in
         the changegroup a particular filenode or manifestnode belongs to.
 
         The caller can specify some nodes that must be included in the
         changegroup using the extranodes argument.  It should be a dict
         where the keys are the filenames (or 1 for the manifest), and the
         values are lists of (node, linknode) tuples, where node is a wanted
         node and linknode is the changelog node that should be transmitted as
         the linkrev.
         """
 
         # Set up some initial variables
         # Make it easy to refer to self.changelog
         cl = self.changelog
         # msng is short for missing - compute the list of changesets in this
         # changegroup.
         if not bases:
             bases = [nullid]
         msng_cl_lst, bases, heads = cl.nodesbetween(bases, heads)
 
         if extranodes is None:
             # can we go through the fast path ?
             heads.sort()
             allheads = self.heads()
             allheads.sort()
             if heads == allheads:
                 return self._changegroup(msng_cl_lst, source)
 
         # slow path
         self.hook('preoutgoing', throw=True, source=source)
 
         self.changegroupinfo(msng_cl_lst, source)
         # Some bases may turn out to be superfluous, and some heads may be
         # too.  nodesbetween will return the minimal set of bases and heads
         # necessary to re-create the changegroup.
 
         # Known heads are the list of heads that it is assumed the recipient
         # of this changegroup will know about.
         knownheads = set()
         # We assume that all parents of bases are known heads.
         for n in bases:
             knownheads.update(cl.parents(n))
         knownheads.discard(nullid)
         knownheads = list(knownheads)
         if knownheads:
             # Now that we know what heads are known, we can compute which
             # changesets are known.  The recipient must know about all
             # changesets required to reach the known heads from the null
             # changeset.
             has_cl_set, junk, junk = cl.nodesbetween(None, knownheads)
             junk = None
             # Transform the list into a set.
             has_cl_set = set(has_cl_set)
         else:
             # If there were no known heads, the recipient cannot be assumed to
             # know about any changesets.
             has_cl_set = set()
 
         # Make it easy to refer to self.manifest
         mnfst = self.manifest
         # We don't know which manifests are missing yet
         msng_mnfst_set = {}
         # Nor do we know which filenodes are missing.
         msng_filenode_set = {}
 
         junk = mnfst.index[len(mnfst) - 1] # Get around a bug in lazyindex
         junk = None
 
         # A changeset always belongs to itself, so the changenode lookup
         # function for a changenode is identity.
         def identity(x):
             return x
 
         # If we determine that a particular file or manifest node must be a
         # node that the recipient of the changegroup will already have, we can
         # also assume the recipient will have all the parents.  This function
         # prunes them from the set of missing nodes.
         def prune_parents(revlog, hasset, msngset):
             for r in revlog.ancestors(*[revlog.rev(n) for n in hasset]):
                 msngset.pop(revlog.node(r), None)
 
         # Use the information collected in collect_manifests_and_files to say
         # which changenode any manifestnode belongs to.
         def lookup_manifest_link(mnfstnode):
             return msng_mnfst_set[mnfstnode]
 
         # A function generating function that sets up the initial environment
         # the inner function.
         def filenode_collector(changedfiles):
             # This gathers information from each manifestnode included in the
             # changegroup about which filenodes the manifest node references
             # so we can include those in the changegroup too.
             #
             # It also remembers which changenode each filenode belongs to.  It
             # does this by assuming the a filenode belongs to the changenode
             # the first manifest that references it belongs to.
             def collect_msng_filenodes(mnfstnode):
                 r = mnfst.rev(mnfstnode)
                 if r - 1 in mnfst.parentrevs(r):
                     # If the previous rev is one of the parents,
                     # we only need to see a diff.
                     deltamf = mnfst.readdelta(mnfstnode)
                     # For each line in the delta
                     for f, fnode in deltamf.iteritems():
                         f = changedfiles.get(f, None)
                         # And if the file is in the list of files we care
                         # about.
                         if f is not None:
                             # Get the changenode this manifest belongs to
                             clnode = msng_mnfst_set[mnfstnode]
                             # Create the set of filenodes for the file if
                             # there isn't one already.
                             ndset = msng_filenode_set.setdefault(f, {})
                             # And set the filenode's changelog node to the
                             # manifest's if it hasn't been set already.
                             ndset.setdefault(fnode, clnode)
                 else:
                     # Otherwise we need a full manifest.
                     m = mnfst.read(mnfstnode)
                     # For every file in we care about.
                     for f in changedfiles:
                         fnode = m.get(f, None)
                         # If it's in the manifest
                         if fnode is not None:
                             # See comments above.
                             clnode = msng_mnfst_set[mnfstnode]
                             ndset = msng_filenode_set.setdefault(f, {})
                             ndset.setdefault(fnode, clnode)
             return collect_msng_filenodes
 
         # We have a list of filenodes we think we need for a file, lets remove
         # all those we know the recipient must have.
         def prune_filenodes(f, filerevlog):
             msngset = msng_filenode_set[f]
             hasset = set()
             # If a 'missing' filenode thinks it belongs to a changenode we
             # assume the recipient must have, then the recipient must have
             # that filenode.
             for n in msngset:
                 clnode = cl.node(filerevlog.linkrev(filerevlog.rev(n)))
                 if clnode in has_cl_set:
                     hasset.add(n)
             prune_parents(filerevlog, hasset, msngset)
 
         # A function generator function that sets up the a context for the
         # inner function.
         def lookup_filenode_link_func(fname):
             msngset = msng_filenode_set[fname]
             # Lookup the changenode the filenode belongs to.
             def lookup_filenode_link(fnode):
                 return msngset[fnode]
             return lookup_filenode_link
 
         # Add the nodes that were explicitly requested.
         def add_extra_nodes(name, nodes):
             if not extranodes or name not in extranodes:
                 return
 
             for node, linknode in extranodes[name]:
                 if node not in nodes:
                     nodes[node] = linknode
 
         # Now that we have all theses utility functions to help out and
         # logically divide up the task, generate the group.
         def gengroup():
             # The set of changed files starts empty.
             changedfiles = {}
             collect = changegroup.collector(cl, msng_mnfst_set, changedfiles)
 
             # Create a changenode group generator that will call our functions
             # back to lookup the owning changenode and collect information.
             group = cl.group(msng_cl_lst, identity, collect)
             cnt = 0
             for chnk in group:
                 yield chnk
                 self.ui.progress(_('bundling changes'), cnt, unit=_('chunks'))
                 cnt += 1
             self.ui.progress(_('bundling changes'), None)
 
 
             # Figure out which manifest nodes (of the ones we think might be
             # part of the changegroup) the recipient must know about and
             # remove them from the changegroup.
             has_mnfst_set = set()
             for n in msng_mnfst_set:
                 # If a 'missing' manifest thinks it belongs to a changenode
                 # the recipient is assumed to have, obviously the recipient
                 # must have that manifest.
                 linknode = cl.node(mnfst.linkrev(mnfst.rev(n)))
                 if linknode in has_cl_set:
                     has_mnfst_set.add(n)
             prune_parents(mnfst, has_mnfst_set, msng_mnfst_set)
             add_extra_nodes(1, msng_mnfst_set)
             msng_mnfst_lst = msng_mnfst_set.keys()
             # Sort the manifestnodes by revision number.
             msng_mnfst_lst.sort(key=mnfst.rev)
             # Create a generator for the manifestnodes that calls our lookup
             # and data collection functions back.
             group = mnfst.group(msng_mnfst_lst, lookup_manifest_link,
                                 filenode_collector(changedfiles))
             cnt = 0
             for chnk in group:
                 yield chnk
                 self.ui.progress(_('bundling manifests'), cnt, unit=_('chunks'))
                 cnt += 1
             self.ui.progress(_('bundling manifests'), None)
 
             # These are no longer needed, dereference and toss the memory for
             # them.
             msng_mnfst_lst = None
             msng_mnfst_set.clear()
 
             if extranodes:
                 for fname in extranodes:
                     if isinstance(fname, int):
                         continue
                     msng_filenode_set.setdefault(fname, {})
                     changedfiles[fname] = 1
             # Go through all our files in order sorted by name.
             cnt = 0
             for fname in sorted(changedfiles):
                 filerevlog = self.file(fname)
                 if not len(filerevlog):
                     raise util.Abort(_("empty or missing revlog for %s") % fname)
                 # Toss out the filenodes that the recipient isn't really
                 # missing.
                 if fname in msng_filenode_set:
                     prune_filenodes(fname, filerevlog)
                     add_extra_nodes(fname, msng_filenode_set[fname])
                     msng_filenode_lst = msng_filenode_set[fname].keys()
                 else:
                     msng_filenode_lst = []
                 # If any filenodes are left, generate the group for them,
                 # otherwise don't bother.
                 if len(msng_filenode_lst) > 0:
                     yield changegroup.chunkheader(len(fname))
                     yield fname
                     # Sort the filenodes by their revision #
                     msng_filenode_lst.sort(key=filerevlog.rev)
                     # Create a group generator and only pass in a changenode
                     # lookup function as we need to collect no information
                     # from filenodes.
                     group = filerevlog.group(msng_filenode_lst,
                                              lookup_filenode_link_func(fname))
                     for chnk in group:
                         self.ui.progress(
                             _('bundling files'), cnt, item=fname, unit=_('chunks'))
                         cnt += 1
                         yield chnk
                 if fname in msng_filenode_set:
                     # Don't need this anymore, toss it to free memory.
                     del msng_filenode_set[fname]
             # Signal that no more groups are left.
             yield changegroup.closechunk()
             self.ui.progress(_('bundling files'), None)
 
             if msng_cl_lst:
                 self.hook('outgoing', node=hex(msng_cl_lst[0]), source=source)
 
         return util.chunkbuffer(gengroup())
 
     def changegroup(self, basenodes, source):
         # to avoid a race we use changegroupsubset() (issue1320)
         return self.changegroupsubset(basenodes, self.heads(), source)
 
     def _changegroup(self, nodes, source):
         """Compute the changegroup of all nodes that we have that a recipient
         doesn't.  Return a chunkbuffer object whose read() method will return
         successive changegroup chunks.
 
         This is much easier than the previous function as we can assume that
         the recipient has any changenode we aren't sending them.
 
         nodes is the set of nodes to send"""
 
         self.hook('preoutgoing', throw=True, source=source)
 
         cl = self.changelog
         revset = set([cl.rev(n) for n in nodes])
         self.changegroupinfo(nodes, source)
 
         def identity(x):
             return x
 
         def gennodelst(log):
             for r in log:
                 if log.linkrev(r) in revset:
                     yield log.node(r)
 
         def lookuprevlink_func(revlog):
             def lookuprevlink(n):
                 return cl.node(revlog.linkrev(revlog.rev(n)))
             return lookuprevlink
 
         def gengroup():
             '''yield a sequence of changegroup chunks (strings)'''
             # construct a list of all changed files
             changedfiles = {}
             mmfs = {}
             collect = changegroup.collector(cl, mmfs, changedfiles)
 
             cnt = 0
             for chnk in cl.group(nodes, identity, collect):
                 self.ui.progress(_('bundling changes'), cnt, unit=_('chunks'))
                 cnt += 1
                 yield chnk
             self.ui.progress(_('bundling changes'), None)
 
             mnfst = self.manifest
             nodeiter = gennodelst(mnfst)
             cnt = 0
             for chnk in mnfst.group(nodeiter, lookuprevlink_func(mnfst)):
                 self.ui.progress(_('bundling manifests'), cnt, unit=_('chunks'))
                 cnt += 1
                 yield chnk
             self.ui.progress(_('bundling manifests'), None)
 
             cnt = 0
             for fname in sorted(changedfiles):
                 filerevlog = self.file(fname)
                 if not len(filerevlog):
                     raise util.Abort(_("empty or missing revlog for %s") % fname)
                 nodeiter = gennodelst(filerevlog)
                 nodeiter = list(nodeiter)
                 if nodeiter:
                     yield changegroup.chunkheader(len(fname))
                     yield fname
                     lookup = lookuprevlink_func(filerevlog)
                     for chnk in filerevlog.group(nodeiter, lookup):
                         self.ui.progress(
                             _('bundling files'), cnt, item=fname, unit=_('chunks'))
                         cnt += 1
                         yield chnk
             self.ui.progress(_('bundling files'), None)
 
             yield changegroup.closechunk()
 
             if nodes:
                 self.hook('outgoing', node=hex(nodes[0]), source=source)
 
         return util.chunkbuffer(gengroup())
 
     def addchangegroup(self, source, srctype, url, emptyok=False):
         """add changegroup to repo.
 
         return values:
         - nothing changed or no source: 0
         - more heads than before: 1+added heads (2..n)
         - less heads than before: -1-removed heads (-2..-n)
         - number of heads stays the same: 1
         """
         def csmap(x):
             self.ui.debug("add changeset %s\n" % short(x))
             return len(cl)
 
         def revmap(x):
             return cl.rev(x)
 
         if not source:
             return 0
 
         self.hook('prechangegroup', throw=True, source=srctype, url=url)
 
         changesets = files = revisions = 0
 
         # write changelog data to temp files so concurrent readers will not see
         # inconsistent view
         cl = self.changelog
         cl.delayupdate()
         oldheads = len(cl.heads())
 
         tr = self.transaction()
         try:
             trp = weakref.proxy(tr)
             # pull off the changeset group
             self.ui.status(_("adding changesets\n"))
             clstart = len(cl)
             class prog(object):
                 step = _('changesets')
                 count = 1
                 ui = self.ui
                 def __call__(self):
                     self.ui.progress(self.step, self.count, unit=_('chunks'))
                     self.count += 1
             pr = prog()
             chunkiter = changegroup.chunkiter(source, progress=pr)
             if cl.addgroup(chunkiter, csmap, trp) is None and not emptyok:
                 raise util.Abort(_("received changelog group is empty"))
             clend = len(cl)
             changesets = clend - clstart
             self.ui.progress(_('changesets'), None)
 
             # pull off the manifest group
             self.ui.status(_("adding manifests\n"))
             pr.step = _('manifests')
             pr.count = 1
             chunkiter = changegroup.chunkiter(source, progress=pr)
             # no need to check for empty manifest group here:
             # if the result of the merge of 1 and 2 is the same in 3 and 4,
             # no new manifest will be created and the manifest group will
             # be empty during the pull
             self.manifest.addgroup(chunkiter, revmap, trp)
             self.ui.progress(_('manifests'), None)
 
             needfiles = {}
             if self.ui.configbool('server', 'validate', default=False):
                 # validate incoming csets have their manifests
                 for cset in xrange(clstart, clend):
                     mfest = self.changelog.read(self.changelog.node(cset))[0]
                     mfest = self.manifest.readdelta(mfest)
                     # store file nodes we must see
                     for f, n in mfest.iteritems():
                         needfiles.setdefault(f, set()).add(n)
 
             # process the files
             self.ui.status(_("adding file changes\n"))
             pr.step = 'files'
             pr.count = 1
             while 1:
                 f = changegroup.getchunk(source)
                 if not f:
                     break
                 self.ui.debug("adding %s revisions\n" % f)
                 fl = self.file(f)
                 o = len(fl)
                 chunkiter = changegroup.chunkiter(source, progress=pr)
                 if fl.addgroup(chunkiter, revmap, trp) is None:
                     raise util.Abort(_("received file revlog group is empty"))
                 revisions += len(fl) - o
                 files += 1
                 if f in needfiles:
                     needs = needfiles[f]
                     for new in xrange(o, len(fl)):
                         n = fl.node(new)
                         if n in needs:
                             needs.remove(n)
                     if not needs:
                         del needfiles[f]
             self.ui.progress(_('files'), None)
 
             for f, needs in needfiles.iteritems():
                 fl = self.file(f)
                 for n in needs:
                     try:
                         fl.rev(n)
                     except error.LookupError:
                         raise util.Abort(
                             _('missing file data for %s:%s - run hg verify') %
                             (f, hex(n)))
 
             newheads = len(cl.heads())
             heads = ""
             if oldheads and newheads != oldheads:
                 heads = _(" (%+d heads)") % (newheads - oldheads)
 
             self.ui.status(_("added %d changesets"
                              " with %d changes to %d files%s\n")
                              % (changesets, revisions, files, heads))
 
             if changesets > 0:
                 p = lambda: cl.writepending() and self.root or ""
                 self.hook('pretxnchangegroup', throw=True,
                           node=hex(cl.node(clstart)), source=srctype,
                           url=url, pending=p)
 
             # make changelog see real files again
             cl.finalize(trp)
 
             tr.close()
         finally:
             del tr
 
         if changesets > 0:
             # forcefully update the on-disk branch cache
             self.ui.debug("updating the branch cache\n")
             self.branchtags()
             self.hook("changegroup", node=hex(cl.node(clstart)),
                       source=srctype, url=url)
 
             for i in xrange(clstart, clend):
                 self.hook("incoming", node=hex(cl.node(i)),
                           source=srctype, url=url)
 
         # never return 0 here:
         if newheads < oldheads:
             return newheads - oldheads - 1
         else:
             return newheads - oldheads + 1
 
 
     def stream_in(self, remote):
         fp = remote.stream_out()
         l = fp.readline()
         try:
             resp = int(l)
         except ValueError:
             raise error.ResponseError(
                 _('Unexpected response from remote server:'), l)
         if resp == 1:
             raise util.Abort(_('operation forbidden by server'))
         elif resp == 2:
             raise util.Abort(_('locking the remote repository failed'))
         elif resp != 0:
             raise util.Abort(_('the server sent an unknown error code'))
         self.ui.status(_('streaming all changes\n'))
         l = fp.readline()
         try:
             total_files, total_bytes = map(int, l.split(' ', 1))
         except (ValueError, TypeError):
             raise error.ResponseError(
                 _('Unexpected response from remote server:'), l)
         self.ui.status(_('%d files to transfer, %s of data\n') %
                        (total_files, util.bytecount(total_bytes)))
         start = time.time()
         for i in xrange(total_files):
             # XXX doesn't support '\n' or '\r' in filenames
             l = fp.readline()
             try:
                 name, size = l.split('\0', 1)
                 size = int(size)
             except (ValueError, TypeError):
                 raise error.ResponseError(
                     _('Unexpected response from remote server:'), l)
             self.ui.debug('adding %s (%s)\n' % (name, util.bytecount(size)))
             # for backwards compat, name was partially encoded
             ofp = self.sopener(store.decodedir(name), 'w')
             for chunk in util.filechunkiter(fp, limit=size):
                 ofp.write(chunk)
             ofp.close()
         elapsed = time.time() - start
         if elapsed <= 0:
             elapsed = 0.001
         self.ui.status(_('transferred %s in %.1f seconds (%s/sec)\n') %
                        (util.bytecount(total_bytes), elapsed,
                         util.bytecount(total_bytes / elapsed)))
         self.invalidate()
         return len(self.heads()) + 1
 
     def clone(self, remote, heads=[], stream=False):
         '''clone remote repository.
 
         keyword arguments:
         heads: list of revs to clone (forces use of pull)
         stream: use streaming clone if possible'''
 
         # now, all clients that can request uncompressed clones can
         # read repo formats supported by all servers that can serve
         # them.
 
         # if revlog format changes, client will have to check version
         # and format flags on "stream" capability, and use
         # uncompressed only if compatible.
 
         if stream and not heads and remote.capable('stream'):
             return self.stream_in(remote)
         return self.pull(remote, heads)
 
 # used to avoid circular references so destructors work
 def aftertrans(files):
     renamefiles = [tuple(t) for t in files]
     def a():
         for src, dest in renamefiles:
             util.rename(src, dest)
     return a
 
 def instance(ui, path, create):
     return localrepository(ui, util.drop_scheme('file', path), create)
 
 def islocal(path):
     return True

tests/test-push-warn

@@ -1,169 +1,197
 #!/bin/sh
 
 mkdir a
 cd a
 hg init
 echo foo > t1
 hg add t1
 hg commit -m "1" -d "1000000 0"
 
 cd ..
 hg clone a b
 
 cd a
 echo foo > t2
 hg add t2
 hg commit -m "2" -d "1000000 0"
 
 cd ../b
 echo foo > t3
 hg add t3
 hg commit -m "3" -d "1000000 0"
 
 hg push ../a
 hg pull ../a
 hg push ../a
 hg merge
 hg commit -m "4" -d "1000000 0"
 hg push ../a
 cd ..
 
 hg init c
 cd c
 for i in 0 1 2; do
     echo $i >> foo
     hg ci -Am $i -d "1000000 0"
 done
 cd ..
 
 hg clone c d
 cd d
 for i in 0 1; do
     hg co -C $i
     echo d-$i >> foo
     hg ci -m d-$i -d "1000000 0"
 done
 
 HGMERGE=true hg merge 3
 hg ci -m c-d -d "1000000 0"
 
 hg push ../c; echo $?
 hg push -r 2 ../c; echo $?
 hg push -r 3 ../c; echo $?
 hg push -r 3 -r 4 ../c; echo $?
 hg push -f -r 3 -r 4 ../c; echo $?
 hg push -r 5 ../c; echo $?
 
 # issue 450
 hg init ../e
 hg push -r 0 ../e ; echo $?
 hg push -r 1 ../e ; echo $?
 
 cd ..
 
 # issue 736
 echo % issue 736
 hg init f
 cd f
 hg -q branch a
 echo 0 > foo
 hg -q ci -d "1000000 0" -Am 0
 echo 1 > foo
 hg -q ci -d "1000000 0" -m 1
 hg -q up 0
 echo 2 > foo
 hg -q ci -d "1000000 0" -m 2
 hg -q up 0
 hg -q branch b
 echo 3 > foo
 hg -q ci -d "1000000 0" -m 3
 cd ..
 
 hg -q clone f g
 cd g
 
 echo % push on existing branch and new branch
 hg -q up 1
 echo 4 > foo
 hg -q ci -d "1000000 0" -m 4
 hg -q up 0
 echo 5 > foo
 hg -q branch c
 hg -q ci -d "1000000 0" -m 5
 hg push ../f; echo $?
 hg push -r 4 -r 5 ../f; echo $?
 
 echo % multiple new branches
 hg -q branch d
 echo 6 > foo
 hg -q ci -d "1000000 0" -m 6
 hg push ../f; echo $?
 hg push -r 4 -r 6 ../f; echo $?
 cd ../g
 
 echo % fail on multiple head push
 hg -q up 1
 echo 7 > foo
 hg -q ci -d "1000000 0" -m 7
 hg push -r 4 -r 7 ../f; echo $?
 
 echo % push replacement head on existing branches
 hg -q up 3
 echo 8 > foo
 hg -q ci -d "1000000 0" -m 8
 hg push -r 7 -r 8 ../f; echo $?
 
 echo % merge of branch a to other branch b followed by unrelated push on branch a
 hg -q up 7
 HGMERGE=true hg -q merge 8
 hg -q ci -d "1000000 0" -m 9
 hg -q up 8
 echo 10 > foo
 hg -q ci -d "1000000 0" -m 10
 hg push -r 9 ../f; echo $?
 hg push -r 10 ../f; echo $?
 
 echo % cheating the counting algorithm
 hg -q up 9
 HGMERGE=true hg -q merge 2
 hg -q ci -d "1000000 0" -m 11
 hg -q up 1
 echo 12 > foo
 hg -q ci -d "1000000 0" -m 12
 hg push -r 11 -r 12 ../f; echo $?
 
 echo % checking prepush logic does not allow silently pushing multiple new heads
 cd ..
 hg init h
 echo init > h/init
 hg -R h ci -Am init
 echo a > h/a
 hg -R h ci -Am a
 hg clone h i
 hg -R h up 0
 echo b > h/b
 hg -R h ci -Am b
 hg -R i up 0
 echo c > i/c
 hg -R i ci -Am c
 hg -R i push h
 echo
 
 echo % check prepush logic with merged branches
 hg init j
 hg -R j branch a
 echo init > j/foo
 hg -R j ci -Am init
 hg clone j k
 echo a1 > j/foo
 hg -R j ci -m a1
 hg -R k branch b
 echo b > k/foo
 hg -R k ci -m b
 hg -R k up 0
 hg -R k merge b
 hg -R k ci -m merge
 hg -R k push -r a j
 echo
 
+echo % prepush -r should not allow you to sneak in new heads
+hg init l
+cd l
+echo a >> foo
+hg -q add foo
+hg -q branch a
+hg -q ci -d '0 0' -ma
+hg -q up null
+echo a >> foo
+hg -q add foo
+hg -q branch b
+hg -q ci -d '0 0' -mb
+cd ..
+hg -q clone l m -u a
+cd m
+hg -q merge b
+hg -q ci -d '0 0' -mmb
+hg -q up 0
+echo a >> foo
+hg -q ci -ma2
+hg -q up 2
+echo a >> foo
+hg -q branch -f b
+hg -q ci -d '0 0' -mb2
+hg -q merge 3
+hg -q ci -d '0 0' -mma
+hg push ../l -b b
+
 exit 0

tests/test-push-warn.out

@@ -1,172 +1,177
 updating to branch default
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 pushing to ../a
 searching for changes
 abort: push creates new remote heads on branch 'default'!
 (you should pull and merge or use push -f to force)
 pulling from ../a
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files (+1 heads)
 (run 'hg heads' to see heads, 'hg merge' to merge)
 pushing to ../a
 searching for changes
 abort: push creates new remote heads on branch 'default'!
 (did you forget to merge? use push -f to force)
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 (branch merge, don't forget to commit)
 pushing to ../a
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 2 changesets with 1 changes to 1 files
 adding foo
 updating to branch default
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 created new head
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 created new head
 merging foo
 0 files updated, 1 files merged, 0 files removed, 0 files unresolved
 (branch merge, don't forget to commit)
 pushing to ../c
 searching for changes
 abort: push creates new remote heads on branch 'default'!
 (did you forget to merge? use push -f to force)
 1
 pushing to ../c
 searching for changes
 no changes found
 0
 pushing to ../c
 searching for changes
 abort: push creates new remote heads on branch 'default'!
 (you should pull and merge or use push -f to force)
 1
 pushing to ../c
 searching for changes
 abort: push creates new remote heads on branch 'default'!
 (did you forget to merge? use push -f to force)
 1
 pushing to ../c
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 2 changesets with 2 changes to 1 files (+2 heads)
 0
 pushing to ../c
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files (-1 heads)
 0
 pushing to ../e
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 0
 pushing to ../e
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 0
 % issue 736
 % push on existing branch and new branch
 pushing to ../f
 searching for changes
 abort: push creates new remote branches: c!
 (use 'hg push -f' to force)
 1
 pushing to ../f
 searching for changes
 abort: push creates new remote branches: c!
 (use 'hg push -f' to force)
 1
 % multiple new branches
 pushing to ../f
 searching for changes
 abort: push creates new remote branches: c, d!
 (use 'hg push -f' to force)
 1
 pushing to ../f
 searching for changes
-abort: push creates new remote branches: d!
+abort: push creates new remote branches: c, d!
 (use 'hg push -f' to force)
 1
 % fail on multiple head push
 pushing to ../f
 searching for changes
 abort: push creates new remote heads on branch 'a'!
 (you should pull and merge or use push -f to force)
 1
 % push replacement head on existing branches
 pushing to ../f
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 2 changesets with 2 changes to 1 files
 0
 % merge of branch a to other branch b followed by unrelated push on branch a
 pushing to ../f
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files (-1 heads)
 0
 pushing to ../f
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files (+1 heads)
 0
 % cheating the counting algorithm
 pushing to ../f
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 2 changesets with 2 changes to 1 files
 0
 % checking prepush logic does not allow silently pushing multiple new heads
 adding init
 adding a
 updating to branch default
 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 adding b
 created new head
 0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 adding c
 created new head
 pushing to h
 searching for changes
 abort: push creates new remote heads on branch 'default'!
 (you should pull and merge or use push -f to force)
 
 % check prepush logic with merged branches
 marked working directory as branch a
 adding foo
 updating to branch a
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 marked working directory as branch b
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 (branch merge, don't forget to commit)
 pushing to j
 searching for changes
+abort: push creates new remote branches: b!
+(use 'hg push -f' to force)
+
+% prepush -r should not allow you to sneak in new heads
+pushing to ../l
+searching for changes
 abort: push creates new remote heads on branch 'a'!
-(you should pull and merge or use push -f to force)
-
+(did you forget to merge? use push -f to force)