mq: let the user choose where .orig files are kept

This patch uses cmdutil.origpath to let the user decide where .orig files are
kept when backup files are created.

hgext/mq.py

@@ -1,3594 +1,3596
 # 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 behavior 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.
 
 It may be desirable for mq changesets to be kept in the secret phase (see
 :hg:`help phases`), which can be enabled with the following setting::
 
   [mq]
   secret = True
 
 You will by default be managing a patch queue named "patches". You can
 create other, independent patch queues with the :hg:`qqueue` command.
 
 If the working directory contains uncommitted files, qpush, qpop and
 qgoto abort immediately. If -f/--force is used, the changes are
 discarded. Setting::
 
   [mq]
   keepchanges = True
 
 make them behave as if --keep-changes were passed, and non-conflicting
 local changes will be tolerated and preserved. If incompatible options
 such as -f/--force or --exact are passed, this setting is ignored.
 
 This extension used to provide a strip command. This command now lives
 in the strip extension.
 '''
 
 from mercurial.i18n import _
 from mercurial.node import bin, hex, short, nullid, nullrev
 from mercurial.lock import release
 from mercurial import commands, cmdutil, hg, scmutil, util, revset
 from mercurial import extensions, error, phases
 from mercurial import patch as patchmod
 from mercurial import localrepo
 from mercurial import subrepo
 import os, re, errno, shutil
 
 seriesopts = [('s', 'summary', None, _('print first line of patch header'))]
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
 # Note for extension authors: ONLY specify testedwith = 'internal' for
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
 testedwith = 'internal'
 
 # force load strip extension formerly included in mq and import some utility
 try:
     stripext = extensions.find('strip')
 except KeyError:
     # note: load is lazy so we could avoid the try-except,
     # but I (marmoute) prefer this explicit code.
     class dummyui(object):
         def debug(self, msg):
             pass
     stripext = extensions.load(dummyui(), 'strip', '')
 
 strip = stripext.strip
 checksubstate = stripext.checksubstate
 checklocalchanges = stripext.checklocalchanges
 
 
 # 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 __repr__(self):
         return hex(self.node) + ':' + self.name
 
 # The order of the headers in 'hg export' HG patches:
 HGHEADERS = [
 #   '# HG changeset patch',
     '# User ',
     '# Date ',
     '#      ',
     '# Branch ',
     '# Node ID ',
     '# Parent  ', # can occur twice for merges - but that is not relevant for mq
     ]
 # The order of headers in plain 'mail style' patches:
 PLAINHEADERS = {
     'from': 0,
     'date': 1,
     'subject': 2,
     }
 
 def inserthgheader(lines, header, value):
     """Assuming lines contains a HG patch header, add a header line with value.
     >>> try: inserthgheader([], '# Date ', 'z')
     ... except ValueError, inst: print "oops"
     oops
     >>> inserthgheader(['# HG changeset patch'], '# Date ', 'z')
     ['# HG changeset patch', '# Date z']
     >>> inserthgheader(['# HG changeset patch', ''], '# Date ', 'z')
     ['# HG changeset patch', '# Date z', '']
     >>> inserthgheader(['# HG changeset patch', '# User y'], '# Date ', 'z')
     ['# HG changeset patch', '# User y', '# Date z']
     >>> inserthgheader(['# HG changeset patch', '# Date x', '# User y'],
     ...                '# User ', 'z')
     ['# HG changeset patch', '# Date x', '# User z']
     >>> inserthgheader(['# HG changeset patch', '# Date y'], '# Date ', 'z')
     ['# HG changeset patch', '# Date z']
     >>> inserthgheader(['# HG changeset patch', '', '# Date y'], '# Date ', 'z')
     ['# HG changeset patch', '# Date z', '', '# Date y']
     >>> inserthgheader(['# HG changeset patch', '# Parent  y'], '# Date ', 'z')
     ['# HG changeset patch', '# Date z', '# Parent  y']
     """
     start = lines.index('# HG changeset patch') + 1
     newindex = HGHEADERS.index(header)
     bestpos = len(lines)
     for i in range(start, len(lines)):
         line = lines[i]
         if not line.startswith('# '):
             bestpos = min(bestpos, i)
             break
         for lineindex, h in enumerate(HGHEADERS):
             if line.startswith(h):
                 if lineindex == newindex:
                     lines[i] = header + value
                     return lines
                 if lineindex > newindex:
                     bestpos = min(bestpos, i)
                 break # next line
     lines.insert(bestpos, header + value)
     return lines
 
 def insertplainheader(lines, header, value):
     """For lines containing a plain patch header, add a header line with value.
     >>> insertplainheader([], 'Date', 'z')
     ['Date: z']
     >>> insertplainheader([''], 'Date', 'z')
     ['Date: z', '']
     >>> insertplainheader(['x'], 'Date', 'z')
     ['Date: z', '', 'x']
     >>> insertplainheader(['From: y', 'x'], 'Date', 'z')
     ['From: y', 'Date: z', '', 'x']
     >>> insertplainheader([' date : x', ' from : y', ''], 'From', 'z')
     [' date : x', 'From: z', '']
     >>> insertplainheader(['', 'Date: y'], 'Date', 'z')
     ['Date: z', '', 'Date: y']
     >>> insertplainheader(['foo: bar', 'DATE: z', 'x'], 'From', 'y')
     ['From: y', 'foo: bar', 'DATE: z', '', 'x']
     """
     newprio = PLAINHEADERS[header.lower()]
     bestpos = len(lines)
     for i, line in enumerate(lines):
         if ':' in line:
             lheader = line.split(':', 1)[0].strip().lower()
             lprio = PLAINHEADERS.get(lheader, newprio + 1)
             if lprio == newprio:
                 lines[i] = '%s: %s' % (header, value)
                 return lines
             if lprio > newprio and i < bestpos:
                 bestpos = i
         else:
             if line:
                 lines.insert(i, '')
             if i < bestpos:
                 bestpos = i
             break
     lines.insert(bestpos, '%s: %s' % (header, value))
     return lines
 
 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
         branch = None
         nodeid = 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:].lstrip() # handle double trailing space
                 elif line.startswith("# Branch "):
                     branch = line[9:]
                 elif line.startswith("# Node ID "):
                     nodeid = line[10:]
                 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)
         # Remember the exact starting line of the patch diffs before consuming
         # empty lines, for external use by TortoiseHg and others
         self.diffstartline = len(comments)
         eatempty(message)
         eatempty(comments)
 
         # make sure message isn't empty
         if format and format.startswith("tag") and subject:
             message.insert(0, subject)
 
         self.message = message
         self.comments = comments
         self.user = user
         self.date = date
         self.parent = parent
         # nodeid and branch are for external use by TortoiseHg and others
         self.nodeid = nodeid
         self.branch = branch
         self.haspatch = diffstart > 1
         self.plainmode = (plainmode or
                           '# HG changeset patch' not in self.comments and
                           any(c.startswith('Date: ') or
                                    c.startswith('From: ')
                                    for c in self.comments))
 
     def setuser(self, user):
         try:
             inserthgheader(self.comments, '# User ', user)
         except ValueError:
             if self.plainmode:
                 insertplainheader(self.comments, 'From', user)
             else:
                 tmp = ['# HG changeset patch', '# User ' + user]
                 self.comments = tmp + self.comments
         self.user = user
 
     def setdate(self, date):
         try:
             inserthgheader(self.comments, '# Date ', date)
         except ValueError:
             if self.plainmode:
                 insertplainheader(self.comments, 'Date', date)
             else:
                 tmp = ['# HG changeset patch', '# Date ' + date]
                 self.comments = tmp + self.comments
         self.date = date
 
     def setparent(self, parent):
         try:
             inserthgheader(self.comments, '# Parent  ', parent)
         except ValueError:
             if not self.plainmode:
                 tmp = ['# HG changeset patch', '# Parent  ' + parent]
                 self.comments = tmp + self.comments
         self.parent = parent
 
     def setmessage(self, message):
         if self.comments:
             self._delmsg()
         self.message = [message]
         if message:
             if self.plainmode and self.comments and self.comments[-1]:
                 self.comments.append('')
             self.comments.append(message)
 
     def __str__(self):
         s = '\n'.join(self.comments).rstrip()
         if not s:
             return ''
         return s + '\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]
 
 def newcommit(repo, phase, *args, **kwargs):
     """helper dedicated to ensure a commit respect mq.secret setting
 
     It should be used instead of repo.commit inside the mq source for operation
     creating new changeset.
     """
     repo = repo.unfiltered()
     if phase is None:
         if repo.ui.configbool('mq', 'secret', False):
             phase = phases.secret
     if phase is not None:
         phasebackup = repo.ui.backupconfig('phases', 'new-commit')
     allowemptybackup = repo.ui.backupconfig('ui', 'allowemptycommit')
     try:
         if phase is not None:
             repo.ui.setconfig('phases', 'new-commit', phase, 'mq')
         repo.ui.setconfig('ui', 'allowemptycommit', True)
         return repo.commit(*args, **kwargs)
     finally:
         repo.ui.restoreconfig(allowemptybackup)
         if phase is not None:
             repo.ui.restoreconfig(phasebackup)
 
 class AbortNoCleanup(error.Abort):
     pass
 
 def makepatchname(existing, title):
     """Return a suitable filename for title, adding a suffix to make
     it unique in the existing list"""
     namebase = re.sub('[\s\W_]+', '_', title.lower()).strip('_')
     name = namebase
     i = 0
     while name in existing:
         i += 1
         name = '%s__%s' % (namebase, i)
     return name
 
 class queue(object):
     def __init__(self, ui, baseui, path, patchdir=None):
         self.basepath = path
         try:
             fh = open(os.path.join(path, 'patches.queue'))
             cur = fh.read().rstrip()
             fh.close()
             if not cur:
                 curpath = os.path.join(path, 'patches')
             else:
                 curpath = os.path.join(path, 'patches-' + cur)
         except IOError:
             curpath = os.path.join(path, 'patches')
         self.path = patchdir or curpath
         self.opener = scmutil.opener(self.path)
         self.ui = ui
         self.baseui = baseui
         self.applieddirty = False
         self.seriesdirty = False
         self.added = []
         self.seriespath = "series"
         self.statuspath = "status"
         self.guardspath = "guards"
         self.activeguards = None
         self.guardsdirty = False
         # Handle mq.git as a bool with extended values
         try:
             gitmode = ui.configbool('mq', 'git', None)
             if gitmode is None:
                 raise error.ConfigError
             if gitmode:
                 self.gitmode = 'yes'
             else:
                 self.gitmode = 'no'
         except error.ConfigError:
             # let's have check-config ignore the type mismatch
             self.gitmode = ui.config(r'mq', 'git', 'auto').lower()
         # deprecated config: mq.plain
         self.plainmode = ui.configbool('mq', 'plain', False)
         self.checkapplied = True
 
     @util.propertycache
     def applied(self):
         def parselines(lines):
             for l in lines:
                 entry = l.split(':', 1)
                 if len(entry) > 1:
                     n, name = entry
                     yield statusentry(bin(n), name)
                 elif l.strip():
                     self.ui.warn(_('malformated mq status line: %s\n') % entry)
                 # else we ignore empty lines
         try:
             lines = self.opener.read(self.statuspath).splitlines()
             return list(parselines(lines))
         except IOError as e:
             if e.errno == errno.ENOENT:
                 return []
             raise
 
     @util.propertycache
     def fullseries(self):
         try:
             return self.opener.read(self.seriespath).splitlines()
         except IOError as e:
             if e.errno == errno.ENOENT:
                 return []
             raise
 
     @util.propertycache
     def series(self):
         self.parseseries()
         return self.series
 
     @util.propertycache
     def seriesguards(self):
         self.parseseries()
         return self.seriesguards
 
     def invalidate(self):
         for a in 'applied fullseries series seriesguards'.split():
             if a in self.__dict__:
                 delattr(self, a)
         self.applieddirty = False
         self.seriesdirty = False
         self.guardsdirty = False
         self.activeguards = None
 
     def diffopts(self, opts=None, patchfn=None):
         diffopts = patchmod.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 error.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 findseries(self, patch):
         def matchpatch(l):
             l = l.split('#', 1)[0]
             return l.strip() == patch
         for index, l in enumerate(self.fullseries):
             if matchpatch(l):
                 return index
         return None
 
     guard_re = re.compile(r'\s?#([-+][^-+# \t\r\n\f][^# \t\r\n\f]*)')
 
     def parseseries(self):
         self.series = []
         self.seriesguards = []
         for l in self.fullseries:
             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 error.Abort(_('%s appears more than once in %s') %
                                      (patch, self.join(self.seriespath)))
                 self.series.append(patch)
                 self.seriesguards.append(self.guard_re.findall(comment))
 
     def checkguard(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 setactive(self, guards):
         for guard in guards:
             bad = self.checkguard(guard)
             if bad:
                 raise error.Abort(bad)
         guards = sorted(set(guards))
         self.ui.debug('active guards: %s\n' % ' '.join(guards))
         self.activeguards = guards
         self.guardsdirty = True
 
     def active(self):
         if self.activeguards is None:
             self.activeguards = []
             try:
                 guards = self.opener.read(self.guardspath).split()
             except IOError as err:
                 if err.errno != errno.ENOENT:
                     raise
                 guards = []
             for i, guard in enumerate(guards):
                 bad = self.checkguard(guard)
                 if bad:
                     self.ui.warn('%s:%d: %s\n' %
                                  (self.join(self.guardspath), i + 1, bad))
                 else:
                     self.activeguards.append(guard)
         return self.activeguards
 
     def setguards(self, idx, guards):
         for g in guards:
             if len(g) < 2:
                 raise error.Abort(_('guard %r too short') % g)
             if g[0] not in '-+':
                 raise error.Abort(_('guard %r starts with invalid char') % g)
             bad = self.checkguard(g[1:])
             if bad:
                 raise error.Abort(bad)
         drop = self.guard_re.sub('', self.fullseries[idx])
         self.fullseries[idx] = drop + ''.join([' #' + g for g in guards])
         self.parseseries()
         self.seriesdirty = True
 
     def pushable(self, idx):
         if isinstance(idx, str):
             idx = self.series.index(idx)
         patchguards = self.seriesguards[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, repr(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, repr(exactpos[0])
             return False, ' '.join(map(repr, pos))
         return True, ''
 
     def explainpushable(self, idx, all_patches=False):
         if all_patches:
             write = self.ui.write
         else:
             write = 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 %s\n') %
                               (self.series[idx], why))
             if not pushable:
                 if why:
                     write(_('skipping %s - guarded by %s\n') %
                           (self.series[idx], why))
                 else:
                     write(_('skipping %s - no matching guards\n') %
                           self.series[idx])
 
     def savedirty(self):
         def writelist(items, path):
             fp = self.opener(path, 'w')
             for i in items:
                 fp.write("%s\n" % i)
             fp.close()
         if self.applieddirty:
             writelist(map(str, self.applied), self.statuspath)
             self.applieddirty = False
         if self.seriesdirty:
             writelist(self.fullseries, self.seriespath)
             self.seriesdirty = False
         if self.guardsdirty:
             writelist(self.activeguards, self.guardspath)
             self.guardsdirty = False
         if self.added:
             qrepo = self.qrepo()
             if qrepo:
                 qrepo[None].add(f for f in self.added if f not in qrepo[None])
             self.added = []
 
     def removeundo(self, repo):
         undo = repo.sjoin('undo')
         if not os.path.exists(undo):
             return
         try:
             os.unlink(undo)
         except OSError as inst:
             self.ui.warn(_('error removing undo: %s\n') % str(inst))
 
     def backup(self, repo, files, copy=False):
         # backup local changes in --force case
         for f in sorted(files):
             absf = repo.wjoin(f)
             if os.path.lexists(absf):
                 self.ui.note(_('saving current version of %s as %s\n') %
-                             (f, f + '.orig'))
+                             (f, cmdutil.origpath(self.ui, repo, f)))
+
+                absorig = cmdutil.origpath(self.ui, repo, absf)
                 if copy:
-                    util.copyfile(absf, absf + '.orig')
+                    util.copyfile(absf, absorig)
                 else:
-                    util.rename(absf, absf + '.orig')
+                    util.rename(absf, absorig)
 
     def printdiff(self, repo, diffopts, node1, node2=None, files=None,
                   fp=None, changes=None, opts={}):
         stat = opts.get('stat')
         m = scmutil.match(repo[node1], files, opts)
         cmdutil.diffordiffstat(self.ui, repo, diffopts, node1, node2,  m,
                                changes, stat, fp)
 
     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 error.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)
         strip(self.ui, repo, [n], update=False, backup=False)
 
         ctx = repo[rev]
         ret = hg.merge(repo, rev)
         if ret:
             raise error.Abort(_("update returned %d") % ret)
         n = newcommit(repo, None, ctx.description(), ctx.user(), force=True)
         if n is None:
             raise error.Abort(_("repo commit failed"))
         try:
             ph = patchheader(mergeq.join(patch), self.plainmode)
         except Exception:
             raise error.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):
         """return the mq handled parent or p1
 
         In some case where mq get himself in being the parent of a merge the
         appropriate parent may be p2.
         (eg: an in progress merge started with mq disabled)
 
         If no parent are managed by mq, p1 is returned.
         """
         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 = newcommit(repo, None, '[mq]: merge marker', force=True)
             self.removeundo(repo)
             self.applied.append(statusentry(n, pname))
             self.applieddirty = True
 
         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.explainpushable(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.applieddirty = True
             if err:
                 return (err, head)
         self.savedirty()
         return (0, head)
 
     def patch(self, repo, patchfile):
         '''Apply patchfile  to the working directory.
         patchfile: name of patch file'''
         files = set()
         try:
             fuzz = patchmod.patch(self.ui, repo, patchfile, strip=1,
                                   files=files, eolmode=None)
             return (True, list(files), fuzz)
         except Exception as inst:
             self.ui.note(str(inst) + '\n')
             if not self.ui.verbose:
                 self.ui.warn(_("patch failed, unable to continue (try -v)\n"))
             self.ui.traceback()
             return (False, list(files), False)
 
     def apply(self, repo, series, list=False, update_status=True,
               strict=False, patchdir=None, merge=None, all_files=None,
               tobackup=None, keepchanges=False):
         wlock = lock = tr = None
         try:
             wlock = repo.wlock()
             lock = repo.lock()
             tr = repo.transaction("qpush")
             try:
                 ret = self._apply(repo, series, list, update_status,
                                   strict, patchdir, merge, all_files=all_files,
                                   tobackup=tobackup, keepchanges=keepchanges)
                 tr.close()
                 self.savedirty()
                 return ret
             except AbortNoCleanup:
                 tr.close()
                 self.savedirty()
                 raise
             except: # re-raises
                 try:
                     tr.abort()
                 finally:
                     self.invalidate()
                 raise
         finally:
             release(tr, lock, wlock)
             self.removeundo(repo)
 
     def _apply(self, repo, series, list=False, update_status=True,
                strict=False, patchdir=None, merge=None, all_files=None,
                tobackup=None, keepchanges=False):
         """returns (error, hash)
 
         error = 1 for unable to read, 2 for patch failed, 3 for patch
         fuzz. tobackup is None or a set of files to backup before they
         are modified by a patch.
         """
         # 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.explainpushable(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 IOError:
                 self.ui.warn(_("unable to read %s\n") % patchname)
                 err = 1
                 break
 
             message = ph.message
             if not message:
                 # The commit message should not be translated
                 message = "imported patch %s\n" % patchname
             else:
                 if list:
                     # The commit message should not be translated
                     message.append("\nimported patch %s" % patchname)
                 message = '\n'.join(message)
 
             if ph.haspatch:
                 if tobackup:
                     touched = patchmod.changedfiles(self.ui, repo, pf)
                     touched = set(touched) & tobackup
                     if touched and keepchanges:
                         raise AbortNoCleanup(
                             _("conflicting local changes found"),
                             hint=_("did you forget to qrefresh?"))
                     self.backup(repo, touched, copy=True)
                     tobackup = tobackup - touched
                 (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.lexists(repo.wjoin(f)):
                         merged.append(f)
                     else:
                         removed.append(f)
                 repo.dirstate.beginparentchange()
                 for f in removed:
                     repo.dirstate.remove(f)
                 for f in merged:
                     repo.dirstate.merge(f)
                 p1, p2 = repo.dirstate.parents()
                 repo.setparents(p1, merge)
                 repo.dirstate.endparentchange()
 
             if all_files and '.hgsubstate' in all_files:
                 wctx = repo[None]
                 pctx = repo['.']
                 overwrite = False
                 mergedsubstate = subrepo.submerge(repo, pctx, wctx, wctx,
                     overwrite)
                 files += mergedsubstate.keys()
 
             match = scmutil.matchfiles(repo, files or [])
             oldtip = repo['tip']
             n = newcommit(repo, None, message, ph.user, ph.date, match=match,
                           force=True)
             if repo['tip'] == oldtip:
                 raise error.Abort(_("qpush exactly duplicates child changeset"))
             if n is None:
                 raise error.Abort(_("repository commit failed"))
 
             if update_status:
                 self.applied.append(statusentry(n, patchname))
 
             if patcherr:
                 self.ui.warn(_("patch failed, rejects left in working "
                                "directory\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[None].forget(patches)
             for p in patches:
                 try:
                     os.unlink(self.join(p))
                 except OSError as inst:
                     if inst.errno != errno.ENOENT:
                         raise
 
         qfinished = []
         if numrevs:
             qfinished = self.applied[:numrevs]
             del self.applied[:numrevs]
             self.applieddirty = True
 
         unknown = []
 
         for (i, p) in sorted([(self.findseries(p), p) for p in patches],
                              reverse=True):
             if i is not None:
                 del self.fullseries[i]
             else:
                 unknown.append(p)
 
         if unknown:
             if numrevs:
                 rev  = dict((entry.name, entry.node) for entry in qfinished)
                 for p in unknown:
                     msg = _('revision %s refers to unknown patches: %s\n')
                     self.ui.warn(msg % (short(rev[p]), p))
             else:
                 msg = _('unknown patches: %s\n')
                 raise error.Abort(''.join(msg % p for p in unknown))
 
         self.parseseries()
         self.seriesdirty = True
         return [entry.node for entry in qfinished]
 
     def _revpatches(self, repo, revs):
         firstrev = repo[self.applied[0].node].rev()
         patches = []
         for i, rev in enumerate(revs):
 
             if rev < firstrev:
                 raise error.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 error.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):
         # Manually trigger phase computation to ensure phasedefaults is
         # executed before we remove the patches.
         repo._phasecache
         patches = self._revpatches(repo, sorted(revs))
         qfinished = self._cleanup(patches, len(patches))
         if qfinished and repo.ui.configbool('mq', 'secret', False):
             # only use this logic when the secret option is added
             oldqbase = repo[qfinished[0]]
             tphase = repo.ui.config('phases', 'new-commit', phases.draft)
             if oldqbase.phase() > tphase and oldqbase.p1().phase() <= tphase:
                 tr = repo.transaction('qfinish')
                 try:
                     phases.advanceboundary(repo, tr, tphase, qfinished)
                     tr.close()
                 finally:
                     tr.release()
 
     def delete(self, repo, patches, opts):
         if not patches and not opts.get('rev'):
             raise error.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 error.Abort(_("cannot delete applied patch %s") % patch)
             if patch not in self.series:
                 raise error.Abort(_("patch %s not in series file") % patch)
             if patch not in realpatches:
                 realpatches.append(patch)
 
         numrevs = 0
         if opts.get('rev'):
             if not self.applied:
                 raise error.Abort(_('no patches applied'))
             revs = scmutil.revrange(repo, opts.get('rev'))
             revs.sort()
             revpatches = self._revpatches(repo, revs)
             realpatches += revpatches
             numrevs = len(revpatches)
 
         self._cleanup(realpatches, numrevs, opts.get('keep'))
 
     def checktoppatch(self, repo):
         '''check that working directory is at qtip'''
         if self.applied:
             top = self.applied[-1].node
             patch = self.applied[-1].name
             if repo.dirstate.p1() != top:
                 raise error.Abort(_("working directory revision is not qtip"))
             return top, patch
         return None, None
 
     def putsubstate2changes(self, substatestate, changes):
         for files in changes[:3]:
             if '.hgsubstate' in files:
                 return # already listed up
         # not yet listed up
         if substatestate in 'a?':
             changes[1].append('.hgsubstate')
         elif substatestate in 'r':
             changes[2].append('.hgsubstate')
         else: # modified
             changes[0].append('.hgsubstate')
 
     def checklocalchanges(self, repo, force=False, refresh=True):
         excsuffix = ''
         if refresh:
             excsuffix = ', qrefresh first'
             # plain versions for i18n tool to detect them
             _("local changes found, qrefresh first")
             _("local changed subrepos found, qrefresh first")
         return checklocalchanges(repo, force, excsuffix)
 
     _reserved = ('series', 'status', 'guards', '.', '..')
     def checkreservedname(self, name):
         if name in self._reserved:
             raise error.Abort(_('"%s" cannot be used as the name of a patch')
                              % name)
         for prefix in ('.hg', '.mq'):
             if name.startswith(prefix):
                 raise error.Abort(_('patch name cannot begin with "%s"')
                                  % prefix)
         for c in ('#', ':', '\r', '\n'):
             if c in name:
                 raise error.Abort(_('%r cannot be used in the name of a patch')
                                  % c)
 
     def checkpatchname(self, name, force=False):
         self.checkreservedname(name)
         if not force and os.path.exists(self.join(name)):
             if os.path.isdir(self.join(name)):
                 raise error.Abort(_('"%s" already exists as a directory')
                                  % name)
             else:
                 raise error.Abort(_('patch "%s" already exists') % name)
 
     def checkkeepchanges(self, keepchanges, force):
         if force and keepchanges:
             raise error.Abort(_('cannot use both --force and --keep-changes'))
 
     def new(self, repo, patchfn, *pats, **opts):
         """options:
            msg: a string or a no-argument function returning a string
         """
         msg = opts.get('msg')
         edit = opts.get('edit')
         editform = opts.get('editform', 'mq.qnew')
         user = opts.get('user')
         date = opts.get('date')
         if date:
             date = util.parsedate(date)
         diffopts = self.diffopts({'git': opts.get('git')})
         if opts.get('checkname', True):
             self.checkpatchname(patchfn)
         inclsubs = checksubstate(repo)
         if inclsubs:
             substatestate = repo.dirstate['.hgsubstate']
         if opts.get('include') or opts.get('exclude') or pats:
             # detect missing files in pats
             def badfn(f, msg):
                 if f != '.hgsubstate': # .hgsubstate is auto-created
                     raise error.Abort('%s: %s' % (f, msg))
             match = scmutil.match(repo[None], pats, opts, badfn=badfn)
             changes = repo.status(match=match)
         else:
             changes = self.checklocalchanges(repo, force=True)
         commitfiles = list(inclsubs)
         for files in changes[:3]:
             commitfiles.extend(files)
         match = scmutil.matchfiles(repo, commitfiles)
         if len(repo[None].parents()) > 1:
             raise error.Abort(_('cannot manage merge changesets'))
         self.checktoppatch(repo)
         insert = self.fullseriesend()
         wlock = repo.wlock()
         try:
             try:
                 # if patch file write fails, abort early
                 p = self.opener(patchfn, "w")
             except IOError as e:
                 raise error.Abort(_('cannot write patch "%s": %s')
                                  % (patchfn, e.strerror))
             try:
                 defaultmsg = "[mq]: %s" % patchfn
                 editor = cmdutil.getcommiteditor(editform=editform)
                 if edit:
                     def finishdesc(desc):
                         if desc.rstrip():
                             return desc
                         else:
                             return defaultmsg
                     # i18n: this message is shown in editor with "HG: " prefix
                     extramsg = _('Leave message empty to use default message.')
                     editor = cmdutil.getcommiteditor(finishdesc=finishdesc,
                                                      extramsg=extramsg,
                                                      editform=editform)
                     commitmsg = msg
                 else:
                     commitmsg = msg or defaultmsg
 
                 n = newcommit(repo, None, commitmsg, user, date, match=match,
                               force=True, editor=editor)
                 if n is None:
                     raise error.Abort(_("repo commit failed"))
                 try:
                     self.fullseries[insert:insert] = [patchfn]
                     self.applied.append(statusentry(n, patchfn))
                     self.parseseries()
                     self.seriesdirty = True
                     self.applieddirty = True
                     nctx = repo[n]
                     ph = patchheader(self.join(patchfn), self.plainmode)
                     if user:
                         ph.setuser(user)
                     if date:
                         ph.setdate('%s %s' % date)
                     ph.setparent(hex(nctx.p1().node()))
                     msg = nctx.description().strip()
                     if msg == defaultmsg.strip():
                         msg = ''
                     ph.setmessage(msg)
                     p.write(str(ph))
                     if commitfiles:
                         parent = self.qparents(repo, n)
                         if inclsubs:
                             self.putsubstate2changes(substatestate, changes)
                         chunks = patchmod.diff(repo, node1=parent, node2=n,
                                                changes=changes, opts=diffopts)
                         for chunk in chunks:
                             p.write(chunk)
                     p.close()
                     r = self.qrepo()
                     if r:
                         r[None].add([patchfn])
                 except: # re-raises
                     repo.rollback()
                     raise
             except Exception:
                 patchpath = self.join(patchfn)
                 try:
                     os.unlink(patchpath)
                 except OSError:
                     self.ui.warn(_('error unlinking %s\n') % patchpath)
                 raise
             self.removeundo(repo)
         finally:
             release(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 (as string) 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):
         def partialname(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.seriesend(True) - 1]
                 if s == 'qbase':
                     return self.series[0]
             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 = partialname(patch)
                 if res:
                     return res
                 minus = patch.rfind('-')
                 if minus >= 0:
                     res = partialname(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 = partialname(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 error.Abort(_("patch %s not in series") % patch)
 
     def push(self, repo, patch=None, force=False, list=False, mergeq=None,
              all=False, move=False, exact=False, nobackup=False,
              keepchanges=False):
         self.checkkeepchanges(keepchanges, force)
         diffopts = self.diffopts()
         wlock = repo.wlock()
         try:
             heads = []
             for hs in repo.branchmap().itervalues():
                 heads.extend(hs)
             if not heads:
                 heads = [nullid]
             if repo.dirstate.p1() not in heads and not exact:
                 self.ui.status(_("(working directory not at a head)\n"))
 
             if not self.series:
                 self.ui.warn(_('no patches in series\n'))
                 return 0
 
             # 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:
                 patch = self.lookup(patch)
                 info = self.isapplied(patch)
                 if info and info[0] >= len(self.applied) - 1:
                     self.ui.warn(
                         _('qpush: %s is already at the top\n') % patch)
                     return 0
 
                 pushable, reason = self.pushable(patch)
                 if pushable:
                     if self.series.index(patch) < self.seriesend():
                         raise error.Abort(
                             _("cannot push to a previous patch: %s") % patch)
                 else:
                     if reason:
                         reason = _('guarded by %s') % 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.seriesend()
             if start == len(self.series):
                 self.ui.warn(_('patch series already fully applied\n'))
                 return 1
             if not force and not keepchanges:
                 self.checklocalchanges(repo, refresh=self.applied)
 
             if exact:
                 if keepchanges:
                     raise error.Abort(
                         _("cannot use --exact and --keep-changes together"))
                 if move:
                     raise error.Abort(_('cannot use --exact and --move '
                                        'together'))
                 if self.applied:
                     raise error.Abort(_('cannot push --exact with applied '
                                        'patches'))
                 root = self.series[start]
                 target = patchheader(self.join(root), self.plainmode).parent
                 if not target:
                     raise error.Abort(
                         _("%s does not have a parent recorded") % root)
                 if not repo[target] == repo['.']:
                     hg.update(repo, target)
 
             if move:
                 if not patch:
                     raise error.Abort(_("please specify the patch to move"))
                 for fullstart, rpn in enumerate(self.fullseries):
                     # strip markers for patch guards
                     if self.guard_re.split(rpn, 1)[0] == self.series[start]:
                         break
                 for i, rpn in enumerate(self.fullseries[fullstart:]):
                     # strip markers for patch guards
                     if self.guard_re.split(rpn, 1)[0] == patch:
                         break
                 index = fullstart + i
                 assert index < len(self.fullseries)
                 fullpatch = self.fullseries[index]
                 del self.fullseries[index]
                 self.fullseries.insert(fullstart, fullpatch)
                 self.parseseries()
                 self.seriesdirty = True
 
             self.applieddirty = True
             if start > 0:
                 self.checktoppatch(repo)
             if not patch:
                 patch = self.series[start]
                 end = start + 1
             else:
                 end = self.series.index(patch, start) + 1
 
             tobackup = set()
             if (not nobackup and force) or keepchanges:
                 status = self.checklocalchanges(repo, force=True)
                 if keepchanges:
                     tobackup.update(status.modified + status.added +
                                     status.removed + status.deleted)
                 else:
                     tobackup.update(status.modified + status.added)
 
             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,
                                      tobackup=tobackup, keepchanges=keepchanges)
             except AbortNoCleanup:
                 raise
             except: # re-raises
                 self.ui.warn(_('cleaning up working directory...\n'))
                 cmdutil.revert(self.ui, repo, repo['.'],
                                repo.dirstate.parents(), no_backup=True)
                 # only remove unknown files that we know we touched or
                 # created while patching
                 for f in all_files:
                     if f not in repo.dirstate:
                         util.unlinkpath(repo.wjoin(f), ignoremissing=True)
                 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 qrefresh %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,
             nobackup=False, keepchanges=False):
         self.checkkeepchanges(keepchanges, force)
         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 error.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
 
             tobackup = set()
             if update:
                 s = self.checklocalchanges(repo, force=force or keepchanges)
                 if force:
                     if not nobackup:
                         tobackup.update(s.modified + s.added)
                 elif keepchanges:
                     tobackup.update(s.modified + s.added +
                                     s.removed + s.deleted)
 
             self.applieddirty = True
             end = len(self.applied)
             rev = self.applied[start].node
 
             try:
                 heads = repo.changelog.heads(rev)
             except error.LookupError:
                 node = short(rev)
                 raise error.Abort(_('trying to pop unknown node %s') % node)
 
             if heads != [self.applied[-1].node]:
                 raise error.Abort(_("popping would remove a revision not "
                                    "managed by this patch queue"))
             if not repo[self.applied[-1].node].mutable():
                 raise error.Abort(
                     _("popping would remove a public revision"),
                     hint=_('see "hg help phases" for details'))
 
             # 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, '.')[:4]
                 if d:
                     raise error.Abort(_("deletions found between repo revs"))
 
                 tobackup = set(a + m + r) & tobackup
                 if keepchanges and tobackup:
                     raise error.Abort(_("local changes found, qrefresh first"))
                 self.backup(repo, tobackup)
                 repo.dirstate.beginparentchange()
                 for f in a:
                     util.unlinkpath(repo.wjoin(f), ignoremissing=True)
                     repo.dirstate.drop(f)
                 for f in m + r:
                     fctx = ctx[f]
                     repo.wwrite(f, fctx.data(), fctx.flags())
                     repo.dirstate.normal(f)
                 repo.setparents(qp, nullid)
                 repo.dirstate.endparentchange()
             for patch in reversed(self.applied[start:end]):
                 self.ui.status(_("popping %s\n") % patch.name)
             del self.applied[start:end]
             strip(self.ui, repo, [rev], update=False, backup=False)
             for s, state in repo['.'].substate.items():
                 repo['.'].sub(s).get(state)
             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.checktoppatch(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()
         edit = opts.get('edit')
         editform = opts.get('editform', 'mq.qrefresh')
         newuser = opts.get('user')
         newdate = opts.get('date')
         if newdate:
             newdate = '%d %d' % util.parsedate(newdate)
         wlock = repo.wlock()
 
         try:
             self.checktoppatch(repo)
             (top, patchfn) = (self.applied[-1].node, self.applied[-1].name)
             if repo.changelog.heads(top) != [top]:
                 raise error.Abort(_("cannot qrefresh a revision with children"))
             if not repo[top].mutable():
                 raise error.Abort(_("cannot qrefresh public revision"),
                                  hint=_('see "hg help phases" for details'))
 
             cparents = repo.changelog.parents(top)
             patchparent = self.qparents(repo, top)
 
             inclsubs = checksubstate(repo, hex(patchparent))
             if inclsubs:
                 substatestate = repo.dirstate['.hgsubstate']
 
             ph = patchheader(self.join(patchfn), self.plainmode)
             diffopts = self.diffopts({'git': opts.get('git')}, patchfn)
             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)
 
             # update the dirstate in place, strip off the qtip commit
             # and then commit.
             #
             # this should really read:
             #   mm, dd, aa = repo.status(top, patchparent)[:3]
             # but we do it backwards to take advantage of manifest/changelog
             # caching against the next repo.status call
             mm, aa, dd = repo.status(patchparent, top)[:3]
             changes = repo.changelog.read(top)
             man = repo.manifest.read(changes[0])
             aaa = aa[:]
             matchfn = scmutil.match(repo[None], 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 = scmutil.matchfiles(repo, mm + aa + dd + matchfn.files())
                 # filter with include/exclude options
                 matchfn = scmutil.match(repo[None], opts=opts)
             else:
                 match = scmutil.matchall(repo)
             m, a, r, d = repo.status(match=match)[:4]
             mm = set(mm)
             aa = set(aa)
             dd = set(dd)
 
             # 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.add(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:
                     dd.remove(x)
                     mm.add(x)
                 else:
                     aa.add(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:
                     aa.remove(x)
                     forget.append(x)
                     continue
                 else:
                     mm.discard(x)
                 dd.add(x)
 
             m = list(mm)
             r = list(dd)
             a = list(aa)
 
             # create 'match' that includes the files to be recommitted.
             # apply matchfn via repo.status to ensure correct case handling.
             cm, ca, cr, cd = repo.status(patchparent, match=matchfn)[:4]
             allmatches = set(cm + ca + cr + cd)
             refreshchanges = [x.intersection(allmatches) for x in (mm, aa, dd)]
 
             files = set(inclsubs)
             for x in refreshchanges:
                 files.update(x)
             match = scmutil.matchfiles(repo, files)
 
             bmlist = repo[top].bookmarks()
 
             dsguard = None
             try:
                 dsguard = cmdutil.dirstateguard(repo, 'mq.refresh')
                 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.drop(f)
 
                 user = ph.user or changes[1]
 
                 oldphase = repo[top].phase()
 
                 # assumes strip can roll itself back if interrupted
                 repo.setparents(*cparents)
                 self.applied.pop()
                 self.applieddirty = True
                 strip(self.ui, repo, [top], update=False, backup=False)
                 dsguard.close()
             finally:
                 release(dsguard)
 
             try:
                 # might be nice to attempt to roll back strip after this
 
                 defaultmsg = "[mq]: %s" % patchfn
                 editor = cmdutil.getcommiteditor(editform=editform)
                 if edit:
                     def finishdesc(desc):
                         if desc.rstrip():
                             ph.setmessage(desc)
                             return desc
                         return defaultmsg
                     # i18n: this message is shown in editor with "HG: " prefix
                     extramsg = _('Leave message empty to use default message.')
                     editor = cmdutil.getcommiteditor(finishdesc=finishdesc,
                                                      extramsg=extramsg,
                                                      editform=editform)
                     message = msg or "\n".join(ph.message)
                 elif not msg:
                     if not ph.message:
                         message = defaultmsg
                     else:
                         message = "\n".join(ph.message)
                 else:
                     message = msg
                     ph.setmessage(msg)
 
                 # Ensure we create a new changeset in the same phase than
                 # the old one.
                 n = newcommit(repo, oldphase, message, user, ph.date,
                               match=match, force=True, editor=editor)
                 # only write patch after a successful commit
                 c = [list(x) for x in refreshchanges]
                 if inclsubs:
                     self.putsubstate2changes(substatestate, c)
                 chunks = patchmod.diff(repo, patchparent,
                                        changes=c, opts=diffopts)
                 comments = str(ph)
                 if comments:
                     patchf.write(comments)
                 for chunk in chunks:
                     patchf.write(chunk)
                 patchf.close()
 
                 marks = repo._bookmarks
                 for bm in bmlist:
                     marks[bm] = n
                 marks.write()
 
                 self.applied.append(statusentry(n, patchfn))
             except: # re-raises
                 ctx = repo[cparents[0]]
                 repo.dirstate.rebuild(ctx.node(), ctx.manifest())
                 self.savedirty()
                 self.ui.warn(_('qrefresh 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 error.Abort(_("patch queue directory already exists"))
         try:
             os.mkdir(self.path)
         except OSError as 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 error.Abort(_("patch %s is not in series file") % patch)
         if not patch:
             start = self.seriesend()
         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.explainpushable(i)
         return unapplied
 
     def qseries(self, repo, missing=None, start=0, length=None, status=None,
                 summary=False):
         def displayname(pfx, patchname, state):
             if pfx:
                 self.ui.write(pfx)
             if summary:
                 ph = patchheader(self.join(patchname), self.plainmode)
                 if ph.message:
                     msg = ph.message[0]
                 else:
                     msg = ''
 
                 if self.ui.formatted():
                     width = self.ui.termwidth() - len(pfx) - len(patchname) - 2
                     if width > 0:
                         msg = util.ellipsis(msg, width)
                     else:
                         msg = ''
                 self.ui.write(patchname, label='qseries.' + state)
                 self.ui.write(': ')
                 self.ui.write(msg, label='qseries.message.' + state)
             else:
                 self.ui.write(patchname, label='qseries.' + state)
             self.ui.write('\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:
                     char, state = 'A', 'applied'
                 elif self.pushable(i)[0]:
                     char, state = 'U', 'unapplied'
                 else:
                     char, state = 'G', 'guarded'
                 pfx = ''
                 if self.ui.verbose:
                     pfx = '%*d %s ' % (idxwidth, i, char)
                 elif status and status != char:
                     continue
                 displayname(pfx, patch, state)
         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.statuspath, self.seriespath,
                                    self.guardspath)
                         and not fl.startswith('.')):
                         msng_list.append(fl)
             for x in sorted(msng_list):
                 pfx = self.ui.verbose and ('D ') or ''
                 displayname(pfx, x, 'missing')
 
     def issaveline(self, l):
         if l.name == '.hg.patches.save.line':
             return True
 
     def qrepo(self, create=False):
         ui = self.baseui.copy()
         if create or os.path.isdir(self.join(".hg")):
             return hg.repository(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 is not 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.fullseries = series
         self.applied = applied
         self.parseseries()
         self.seriesdirty = True
         self.applieddirty = True
         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
                 strip(self.ui, repo, [rev], update=update, backup=False)
         if qpp:
             self.ui.warn(_("saved queue repository parents: %s %s\n") %
                          (short(qpp[0]), short(qpp[1])))
             if qupdate:
                 self.ui.status(_("updating queue directory\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.fullseries)
         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.applieddirty = True
         self.removeundo(repo)
 
     def fullseriesend(self):
         if self.applied:
             p = self.applied[-1].name
             end = self.findseries(p)
             if end is None:
                 return len(self.fullseries)
             return end + 1
         return 0
 
     def seriesend(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 nextpatch(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:
                     return i
                 self.explainpushable(i)
             return len(self.series)
         if self.applied:
             p = self.applied[-1].name
             try:
                 end = self.series.index(p)
             except ValueError:
                 return 0
             return nextpatch(end + 1)
         return nextpatch(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 error.Abort(_('patch %s is already in the series file')
                                  % patchname)
 
         if rev:
             if files:
                 raise error.Abort(_('option "-r" not valid when importing '
                                    'files'))
             rev = scmutil.revrange(repo, rev)
             rev.sort(reverse=True)
         elif not files:
             raise error.Abort(_('no files or revisions specified'))
         if (len(files) > 1 or len(rev) > 1) and patchname:
             raise error.Abort(_('option "-n" not valid when importing multiple '
                                'patches'))
         imported = []
         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.first()))
             if len(heads) > 1:
                 raise error.Abort(_('revision %d is the root of more than one '
                                    'branch') % rev.last())
             if self.applied:
                 base = repo.changelog.node(rev.first())
                 if base in [n.node for n in self.applied]:
                     raise error.Abort(_('revision %d is already managed')
                                      % rev.first())
                 if heads != [self.applied[-1].node]:
                     raise error.Abort(_('revision %d is not the parent of '
                                        'the queue') % rev.first())
                 base = repo.changelog.rev(self.applied[0].node)
                 lastparent = repo.changelog.parentrevs(base)[0]
             else:
                 if heads != [repo.changelog.node(rev.first())]:
                     raise error.Abort(_('revision %d has unmanaged children')
                                      % rev.first())
                 lastparent = None
 
             diffopts = self.diffopts({'git': git})
             tr = repo.transaction('qimport')
             try:
                 for r in rev:
                     if not repo[r].mutable():
                         raise error.Abort(_('revision %d is not mutable') % r,
                                          hint=_('see "hg help phases" '
                                                 'for details'))
                     p1, p2 = repo.changelog.parentrevs(r)
                     n = repo.changelog.node(r)
                     if p2 != nullrev:
                         raise error.Abort(_('cannot import merge revision %d')
                                          % r)
                     if lastparent and lastparent != r:
                         raise error.Abort(_('revision %d is not the parent of '
                                            '%d')
                                          % (r, lastparent))
                     lastparent = p1
 
                     if not patchname:
                         patchname = makepatchname(self.fullseries,
                             repo[r].description().split('\n', 1)[0])
                     checkseries(patchname)
                     self.checkpatchname(patchname, force)
                     self.fullseries.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)
 
                     self.added.append(patchname)
                     imported.append(patchname)
                     patchname = None
                     if rev and repo.ui.configbool('mq', 'secret', False):
                         # if we added anything with --rev, move the secret root
                         phases.retractboundary(repo, tr, phases.secret, [n])
                     self.parseseries()
                     self.applieddirty = True
                     self.seriesdirty = True
                 tr.close()
             finally:
                 tr.release()
 
         for i, filename in enumerate(files):
             if existing:
                 if filename == '-':
                     raise error.Abort(_('-e is incompatible with import from -')
                                      )
                 filename = normname(filename)
                 self.checkreservedname(filename)
                 if util.url(filename).islocal():
                     originpath = self.join(filename)
                     if not os.path.isfile(originpath):
                         raise error.Abort(
                             _("patch %s does not exist") % filename)
 
                 if patchname:
                     self.checkpatchname(patchname, force)
 
                     self.ui.write(_('renaming %s to %s\n')
                                         % (filename, patchname))
                     util.rename(originpath, self.join(patchname))
                 else:
                     patchname = filename
 
             else:
                 if filename == '-' and not patchname:
                     raise error.Abort(_('need --name to import a patch from -'))
                 elif not patchname:
                     patchname = normname(os.path.basename(filename.rstrip('/')))
                 self.checkpatchname(patchname, force)
                 try:
                     if filename == '-':
                         text = self.ui.fin.read()
                     else:
                         fp = hg.openpath(self.ui, filename)
                         text = fp.read()
                         fp.close()
                 except (OSError, IOError):
                     raise error.Abort(_("unable to read file %s") % filename)
                 patchf = self.opener(patchname, "w")
                 patchf.write(text)
                 patchf.close()
             if not force:
                 checkseries(patchname)
             if patchname not in self.series:
                 index = self.fullseriesend() + i
                 self.fullseries[index:index] = [patchname]
             self.parseseries()
             self.seriesdirty = True
             self.ui.warn(_("adding %s to series file\n") % patchname)
             self.added.append(patchname)
             imported.append(patchname)
             patchname = None
 
         self.removeundo(repo)
         return imported
 
 def fixkeepchangesopts(ui, opts):
     if (not ui.configbool('mq', 'keepchanges') or opts.get('force')
         or opts.get('exact')):
         return opts
     opts = dict(opts)
     opts['keep_changes'] = True
     return opts
 
 @command("qdelete|qremove|qrm",
          [('k', 'keep', None, _('keep patch file')),
           ('r', 'rev', [],
            _('stop managing a revision (DEPRECATED)'), _('REV'))],
          _('hg qdelete [-k] [PATCH]...'))
 def delete(ui, repo, *patches, **opts):
     """remove patches from queue
 
     The patches must not be applied, and at least one patch is required. Exact
     patch identifiers must be given. 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 :hg:`qfinish` command."""
     q = repo.mq
     q.delete(repo, patches, opts)
     q.savedirty()
     return 0
 
 @command("qapplied",
          [('1', 'last', None, _('show only the preceding applied patch'))
           ] + seriesopts,
          _('hg qapplied [-1] [-s] [PATCH]'))
 def applied(ui, repo, patch=None, **opts):
     """print the patches already applied
 
     Returns 0 on success."""
 
     q = repo.mq
 
     if patch:
         if patch not in q.series:
             raise error.Abort(_("patch %s is not in series file") % patch)
         end = q.series.index(patch) + 1
     else:
         end = q.seriesend(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
 
     q.qseries(repo, length=end, start=start, status='A',
               summary=opts.get('summary'))
 
 
 @command("qunapplied",
          [('1', 'first', None, _('show only the first patch'))] + seriesopts,
          _('hg qunapplied [-1] [-s] [PATCH]'))
 def unapplied(ui, repo, patch=None, **opts):
     """print the patches not yet applied
 
     Returns 0 on success."""
 
     q = repo.mq
     if patch:
         if patch not in q.series:
             raise error.Abort(_("patch %s is not in series file") % patch)
         start = q.series.index(patch) + 1
     else:
         start = q.seriesend(True)
 
     if start == len(q.series) and opts.get('first'):
         ui.write(_("all patches applied\n"))
         return 1
 
     if opts.get('first'):
         length = 1
     else:
         length = None
     q.qseries(repo, start=start, length=length, status='U',
               summary=opts.get('summary'))
 
 @command("qimport",
          [('e', 'existing', None, _('import file in patch directory')),
           ('n', 'name', '',
            _('name of patch file'), _('NAME')),
           ('f', 'force', None, _('overwrite existing files')),
           ('r', 'rev', [],
            _('place existing revisions under mq control'), _('REV')),
           ('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]...'))
 def qimport(ui, repo, *filename, **opts):
     """import a patch or existing changeset
 
     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 . -n patch will place the current revision
     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. Use :hg:`qfinish` to remove changesets
     from mq control.
 
     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.
 
     To import an existing patch while renaming it::
 
       hg qimport -e existing-patch -n new-name
 
     Returns 0 if import succeeded.
     """
     lock = repo.lock() # cause this may move phase
     try:
         q = repo.mq
         try:
             imported = q.qimport(
                 repo, filename, patchname=opts.get('name'),
                 existing=opts.get('existing'), force=opts.get('force'),
                 rev=opts.get('rev'), git=opts.get('git'))
         finally:
             q.savedirty()
     finally:
         lock.release()
 
     if imported and opts.get('push') and not opts.get('rev'):
         return q.push(repo, imported[-1])
     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).
 
     Returns 0 if initialization succeeded."""
     q = repo.mq
     r = q.init(repo, create)
     q.savedirty()
     if r:
         if not os.path.exists(r.wjoin('.hgignore')):
             fp = r.wvfs('.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.wvfs('series', 'w').close()
         r[None].add(['.hgignore', 'series'])
         commands.add(ui, r)
     return 0
 
 @command("^qinit",
          [('c', 'create-repo', None, _('create queue repository'))],
          _('hg qinit [-c]'))
 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.get('create_repo'))
 
 @command("qclone",
          [('', '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'), _('REPO')),
          ] + commands.remoteopts,
          _('hg qclone [OPTION]... SOURCE [DEST]'),
          norepo=True)
 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 :hg:`init --mq`.
 
     Return 0 on success.
     '''
     def patchdir(repo):
         """compute a patch repo url from a repo object"""
         url = repo.url()
         if url.endswith('/'):
             url = url[:-1]
         return url + '/.hg/patches'
 
     # main repo (destination and sources)
     if dest is None:
         dest = hg.defaultdest(source)
     sr = hg.peer(ui, opts, ui.expandpath(source))
 
     # patches repo (source only)
     if opts.get('patches'):
         patchespath = ui.expandpath(opts.get('patches'))
     else:
         patchespath = patchdir(sr)
     try:
         hg.peer(ui, opts, patchespath)
     except error.RepoError:
         raise error.Abort(_('versioned patch repository not found'
                            ' (see init --mq)'))
     qbase, destrev = None, None
     if sr.local():
         repo = sr.local()
         if repo.mq.applied and repo[qbase].phase() != phases.secret:
             qbase = repo.mq.applied[0].node
             if not hg.islocal(dest):
                 heads = set(repo.heads())
                 destrev = list(heads.difference(repo.heads(qbase)))
                 destrev.append(repo.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, opts, sr.url(), dest,
                       pull=opts.get('pull'),
                       rev=destrev,
                       update=False,
                       stream=opts.get('uncompressed'))
 
     ui.note(_('cloning patch repository\n'))
     hg.clone(ui, opts, opts.get('patches') or patchdir(sr), patchdir(dr),
              pull=opts.get('pull'), update=not opts.get('noupdate'),
              stream=opts.get('uncompressed'))
 
     if dr.local():
         repo = dr.local()
         if qbase:
             ui.note(_('stripping applied patches from destination '
                       'repository\n'))
             strip(ui, repo, [qbase], update=False, backup=None)
         if not opts.get('noupdate'):
             ui.note(_('updating destination repository\n'))
             hg.update(repo, repo.changelog.tip())
 
 @command("qcommit|qci",
          commands.table["^commit|ci"][1],
          _('hg qcommit [OPTION]... [FILE]...'),
          inferrepo=True)
 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 error.Abort('no queue repository')
     commands.commit(r.ui, r, *pats, **opts)
 
 @command("qseries",
          [('m', 'missing', None, _('print patches not in series')),
          ] + seriesopts,
           _('hg qseries [-ms]'))
 def series(ui, repo, **opts):
     """print the entire series file
 
     Returns 0 on success."""
     repo.mq.qseries(repo, missing=opts.get('missing'),
                     summary=opts.get('summary'))
     return 0
 
 @command("qtop", seriesopts, _('hg qtop [-s]'))
 def top(ui, repo, **opts):
     """print the name of the current patch
 
     Returns 0 on success."""
     q = repo.mq
     if q.applied:
         t = q.seriesend(True)
     else:
         t = 0
 
     if t:
         q.qseries(repo, start=t - 1, length=1, status='A',
                   summary=opts.get('summary'))
     else:
         ui.write(_("no patches applied\n"))
         return 1
 
 @command("qnext", seriesopts, _('hg qnext [-s]'))
 def next(ui, repo, **opts):
     """print the name of the next pushable patch
 
     Returns 0 on success."""
     q = repo.mq
     end = q.seriesend()
     if end == len(q.series):
         ui.write(_("all patches applied\n"))
         return 1
     q.qseries(repo, start=end, length=1, summary=opts.get('summary'))
 
 @command("qprev", seriesopts, _('hg qprev [-s]'))
 def prev(ui, repo, **opts):
     """print the name of the preceding applied patch
 
     Returns 0 on success."""
     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
     idx = q.series.index(q.applied[-2].name)
     q.qseries(repo, start=idx, 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()
 
 @command("^qnew",
          [('e', 'edit', None, _('invoke editor on commit messages')),
           ('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: <USER>" to patch'), _('USER')),
           ('D', 'currentdate', None, _('add "Date: <current date>" to patch')),
           ('d', 'date', '',
            _('add "Date: <DATE>" to patch'), _('DATE'))
           ] + commands.walkopts + commands.commitopts,
          _('hg qnew [-e] [-m TEXT] [-l FILE] PATCH [FILE]...'),
          inferrepo=True)
 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). The patch will be initialized with any outstanding changes
     in the working directory. 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.
 
     Returns 0 on successful creation of a new patch.
     """
     msg = cmdutil.logmessage(ui, opts)
     q = repo.mq
     opts['msg'] = msg
     setupheaderopts(ui, opts)
     q.new(repo, patch, *args, **opts)
     q.savedirty()
     return 0
 
 @command("^qrefresh",
          [('e', 'edit', None, _('invoke editor on commit messages')),
           ('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'), _('USER')),
           ('D', 'currentdate', None,
            _('add/update date field in patch with current date')),
           ('d', 'date', '',
            _('add/update date field in patch with given date'), _('DATE'))
           ] + commands.walkopts + commands.commitopts,
          _('hg qrefresh [-I] [-X] [-e] [-m TEXT] [-l FILE] [-s] [FILE]...'),
          inferrepo=True)
 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.
 
     If -e/--edit is specified, Mercurial will start your configured editor for
     you to enter a message. In case qrefresh fails, you will find a backup of
     your message in ``.hg/last-message.txt``.
 
     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.
 
     Returns 0 on success.
     """
     q = repo.mq
     message = cmdutil.logmessage(ui, opts)
     setupheaderopts(ui, opts)
     wlock = repo.wlock()
     try:
         ret = q.refresh(repo, pats, msg=message, **opts)
         q.savedirty()
         return ret
     finally:
         wlock.release()
 
 @command("^qdiff",
          commands.diffopts + commands.diffopts2 + commands.walkopts,
          _('hg qdiff [OPTION]... [FILE]...'),
          inferrepo=True)
 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.
 
     Returns 0 on success.
     """
     repo.mq.diff(repo, pats, opts)
     return 0
 
 @command('qfold',
          [('e', 'edit', None, _('invoke editor on commit messages')),
           ('k', 'keep', None, _('keep folded patch files')),
          ] + commands.commitopts,
          _('hg qfold [-e] [-k] [-m TEXT] [-l FILE] PATCH...'))
 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 ``* * *``.
 
     Returns 0 on success."""
     q = repo.mq
     if not files:
         raise error.Abort(_('qfold requires at least one patch name'))
     if not q.checktoppatch(repo)[0]:
         raise error.Abort(_('no patches applied'))
     q.checklocalchanges(repo)
 
     message = cmdutil.logmessage(ui, opts)
 
     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\n') % p)
         if q.isapplied(p):
             raise error.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 error.Abort(_('error folding patch %s') % p)
 
     if not message:
         ph = patchheader(q.join(parent), q.plainmode)
         message = ph.message
         for msg in messages:
             if msg:
                 if message:
                     message.append('* * *')
                 message.extend(msg)
         message = '\n'.join(message)
 
     diffopts = q.patchopts(q.diffopts(), *patches)
     wlock = repo.wlock()
     try:
         q.refresh(repo, msg=message, git=diffopts.git, edit=opts.get('edit'),
                   editform='mq.qfold')
         q.delete(repo, patches, opts)
         q.savedirty()
     finally:
         wlock.release()
 
 @command("qgoto",
          [('', 'keep-changes', None,
            _('tolerate non-conflicting local changes')),
           ('f', 'force', None, _('overwrite any local changes')),
           ('', 'no-backup', None, _('do not save backup copies of files'))],
          _('hg qgoto [OPTION]... PATCH'))
 def goto(ui, repo, patch, **opts):
     '''push or pop patches until named patch is at top of stack
 
     Returns 0 on success.'''
     opts = fixkeepchangesopts(ui, opts)
     q = repo.mq
     patch = q.lookup(patch)
     nobackup = opts.get('no_backup')
     keepchanges = opts.get('keep_changes')
     if q.isapplied(patch):
         ret = q.pop(repo, patch, force=opts.get('force'), nobackup=nobackup,
                     keepchanges=keepchanges)
     else:
         ret = q.push(repo, patch, force=opts.get('force'), nobackup=nobackup,
                      keepchanges=keepchanges)
     q.savedirty()
     return ret
 
 @command("qguard",
          [('l', 'list', None, _('list all patches and guards')),
           ('n', 'none', None, _('drop all guards'))],
          _('hg qguard [-l] [-n] [PATCH] [-- [+GUARD]... [-GUARD]...]'))
 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 :hg:`qselect` command has activated it. A patch with
     a negative guard ("-foo") is never pushed if the :hg:`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
 
     Returns 0 on success.
     '''
     def status(idx):
         guards = q.seriesguards[idx] or ['unguarded']
         if q.series[idx] in applied:
             state = 'applied'
         elif q.pushable(idx)[0]:
             state = 'unapplied'
         else:
             state = 'guarded'
         label = 'qguard.patch qguard.%s qseries.%s' % (state, state)
         ui.write('%s: ' % ui.label(q.series[idx], label))
 
         for i, guard in enumerate(guards):
             if guard.startswith('+'):
                 ui.write(guard, label='qguard.positive')
             elif guard.startswith('-'):
                 ui.write(guard, label='qguard.negative')
             else:
                 ui.write(guard, label='qguard.unguarded')
             if i != len(guards) - 1:
                 ui.write(' ')
         ui.write('\n')
     q = repo.mq
     applied = set(p.name for p in q.applied)
     patch = None
     args = list(args)
     if opts.get('list'):
         if args or opts.get('none'):
             raise error.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 error.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 error.Abort(_('no patch to work with'))
     if args or opts.get('none'):
         idx = q.findseries(patch)
         if idx is None:
             raise error.Abort(_('no patch named %s') % patch)
         q.setguards(idx, args)
         q.savedirty()
     else:
         status(q.series.index(q.lookup(patch)))
 
 @command("qheader", [], _('hg qheader [PATCH]'))
 def header(ui, repo, patch=None):
     """print the header of the topmost or specified patch
 
     Returns 0 on success."""
     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
 
 @command("^qpush",
          [('', 'keep-changes', None,
            _('tolerate non-conflicting local changes')),
           ('f', 'force', None, _('apply on top of local changes')),
           ('e', 'exact', None,
            _('apply the target patch to its recorded parent')),
           ('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)'), _('NAME')),
           ('', 'move', None,
            _('reorder patch series and apply only the patch')),
           ('', 'no-backup', None, _('do not save backup copies of files'))],
          _('hg qpush [-f] [-l] [-a] [--move] [PATCH | INDEX]'))
 def push(ui, repo, patch=None, **opts):
     """push the next patch onto the stack
 
     By default, abort if the working directory contains uncommitted
     changes. With --keep-changes, abort only if the uncommitted files
     overlap with patched files. With -f/--force, backup and patch over
     uncommitted changes.
 
     Return 0 on success.
     """
     q = repo.mq
     mergeq = None
 
     opts = fixkeepchangesopts(ui, opts)
     if opts.get('merge'):
         if opts.get('name'):
             newpath = repo.join(opts.get('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.baseui, repo.path, newpath)
         ui.warn(_("merging with queue at: %s\n") % mergeq.path)
     ret = q.push(repo, patch, force=opts.get('force'), list=opts.get('list'),
                  mergeq=mergeq, all=opts.get('all'), move=opts.get('move'),
                  exact=opts.get('exact'), nobackup=opts.get('no_backup'),
                  keepchanges=opts.get('keep_changes'))
     return ret
 
 @command("^qpop",
          [('a', 'all', None, _('pop all patches')),
           ('n', 'name', '',
            _('queue name to pop (DEPRECATED)'), _('NAME')),
           ('', 'keep-changes', None,
            _('tolerate non-conflicting local changes')),
           ('f', 'force', None, _('forget any local changes to patched files')),
           ('', 'no-backup', None, _('do not save backup copies of files'))],
          _('hg qpop [-a] [-f] [PATCH | INDEX]'))
 def pop(ui, repo, patch=None, **opts):
     """pop the current patch off the stack
 
     Without argument, 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.
 
     By default, abort if the working directory contains uncommitted
     changes. With --keep-changes, abort only if the uncommitted files
     overlap with patched files. With -f/--force, backup and discard
     changes made to such files.
 
     Return 0 on success.
     """
     opts = fixkeepchangesopts(ui, opts)
     localupdate = True
     if opts.get('name'):
         q = queue(ui, repo.baseui, repo.path, repo.join(opts.get('name')))
         ui.warn(_('using patch queue: %s\n') % q.path)
         localupdate = False
     else:
         q = repo.mq
     ret = q.pop(repo, patch, force=opts.get('force'), update=localupdate,
                 all=opts.get('all'), nobackup=opts.get('no_backup'),
                 keepchanges=opts.get('keep_changes'))
     q.savedirty()
     return ret
 
 @command("qrename|qmv", [], _('hg qrename PATCH1 [PATCH2]'))
 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.
 
     Returns 0 on success."""
     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)
     q.checkpatchname(name)
 
     ui.note(_('renaming %s to %s\n') % (patch, name))
     i = q.findseries(patch)
     guards = q.guard_re.findall(q.fullseries[i])
     q.fullseries[i] = name + ''.join([' #' + g for g in guards])
     q.parseseries()
     q.seriesdirty = True
 
     info = q.isapplied(patch)
     if info:
         q.applied[info[0]] = statusentry(info[1], name)
     q.applieddirty = True
 
     destdir = os.path.dirname(absdest)
     if not os.path.isdir(destdir):
         os.makedirs(destdir)
     util.rename(q.join(patch), absdest)
     r = q.qrepo()
     if r and patch in r.dirstate:
         wctx = r[None]
         wlock = r.wlock()
         try:
             if r.dirstate[patch] == 'a':
                 r.dirstate.drop(patch)
                 r.dirstate.add(name)
             else:
                 wctx.copy(patch, name)
                 wctx.forget([patch])
         finally:
             wlock.release()
 
     q.savedirty()
 
 @command("qrestore",
          [('d', 'delete', None, _('delete save entry')),
           ('u', 'update', None, _('update queue working directory'))],
          _('hg qrestore [-d] [-u] REV'))
 def restore(ui, repo, rev, **opts):
     """restore the queue state saved by a revision (DEPRECATED)
 
     This command is deprecated, use :hg:`rebase` instead."""
     rev = repo.lookup(rev)
     q = repo.mq
     q.restore(repo, rev, delete=opts.get('delete'),
               qupdate=opts.get('update'))
     q.savedirty()
     return 0
 
 @command("qsave",
          [('c', 'copy', None, _('copy patch directory')),
           ('n', 'name', '',
            _('copy directory name'), _('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]'))
 def save(ui, repo, **opts):
     """save current queue state (DEPRECATED)
 
     This command is deprecated, use :hg:`rebase` instead."""
     q = repo.mq
     message = cmdutil.logmessage(ui, opts)
     ret = q.save(repo, msg=message)
     if ret:
         return ret
     q.savedirty() # save to .hg/patches before copying
     if opts.get('copy'):
         path = q.path
         if opts.get('name'):
             newpath = os.path.join(q.basepath, opts.get('name'))
             if os.path.exists(newpath):
                 if not os.path.isdir(newpath):
                     raise error.Abort(_('destination %s exists and is not '
                                        'a directory') % newpath)
                 if not opts.get('force'):
                     raise error.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.get('empty'):
         del q.applied[:]
         q.applieddirty = True
         q.savedirty()
     return 0
 
 
 @command("qselect",
          [('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]...'))
 def select(ui, repo, *args, **opts):
     '''set or print guarded patches to push
 
     Use the :hg:`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.
 
     Returns 0 on success.'''
 
     q = repo.mq
     guards = q.active()
     pushable = lambda i: q.pushable(q.applied[i].name)[0]
     if args or opts.get('none'):
         old_unapplied = q.unapplied(repo)
         old_guarded = [i for i in xrange(len(q.applied)) if not pushable(i)]
         q.setactive(args)
         q.savedirty()
         if not args:
             ui.status(_('guards deactivated\n'))
         if not opts.get('pop') and not opts.get('reapply'):
             unapplied = q.unapplied(repo)
             guarded = [i for i in xrange(len(q.applied)) if not pushable(i)]
             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.get('series'):
         guards = {}
         noguards = 0
         for gs in q.seriesguards:
             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.get('reapply') and q.applied and q.applied[-1].name
     popped = False
     if opts.get('pop') or opts.get('reapply'):
         for i in xrange(len(q.applied)):
             if not pushable(i):
                 ui.status(_('popping guarded patches\n'))
                 popped = True
                 if i == 0:
                     q.pop(repo, all=True)
                 else:
                     q.pop(repo, q.applied[i - 1].name)
                 break
     if popped:
         try:
             if reapply:
                 ui.status(_('reapplying unguarded patches\n'))
                 q.push(repo, reapply)
         finally:
             q.savedirty()
 
 @command("qfinish",
          [('a', 'applied', None, _('finish all applied changesets'))],
          _('hg qfinish [-a] [REV]...'))
 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.
 
     Returns 0 on success.
     """
     if not opts.get('applied') and not revrange:
         raise error.Abort(_('no revisions specified'))
     elif opts.get('applied'):
         revrange = ('qbase::qtip',) + revrange
 
     q = repo.mq
     if not q.applied:
         ui.status(_('no patches applied\n'))
         return 0
 
     revs = scmutil.revrange(repo, revrange)
     if repo['.'].rev() in revs and repo[None].files():
         ui.warn(_('warning: uncommitted changes in the working directory\n'))
     # queue.finish may changes phases but leave the responsibility to lock the
     # repo to the caller to avoid deadlock with wlock. This command code is
     # responsibility for this locking.
     lock = repo.lock()
     try:
         q.finish(repo, revs)
         q.savedirty()
     finally:
         lock.release()
     return 0
 
 @command("qqueue",
          [('l', 'list', False, _('list all available queues')),
           ('', 'active', False, _('print name of active queue')),
           ('c', 'create', False, _('create new queue')),
           ('', 'rename', False, _('rename active queue')),
           ('', 'delete', False, _('delete reference to queue')),
           ('', 'purge', False, _('delete queue, and remove patch dir')),
          ],
          _('[OPTION] [QUEUE]'))
 def qqueue(ui, repo, name=None, **opts):
     '''manage multiple patch queues
 
     Supports switching between different patch queues, as well as creating
     new patch queues and deleting existing ones.
 
     Omitting a queue name or specifying -l/--list will show you the registered
     queues - by default the "normal" patches queue is registered. The currently
     active queue will be marked with "(active)". Specifying --active will print
     only the name of the active queue.
 
     To create a new queue, use -c/--create. The queue is automatically made
     active, except in the case where there are applied patches from the
     currently active queue in the repository. Then the queue will only be
     created and switching will fail.
 
     To delete an existing queue, use --delete. You cannot delete the currently
     active queue.
 
     Returns 0 on success.
     '''
     q = repo.mq
     _defaultqueue = 'patches'
     _allqueues = 'patches.queues'
     _activequeue = 'patches.queue'
 
     def _getcurrent():
         cur = os.path.basename(q.path)
         if cur.startswith('patches-'):
             cur = cur[8:]
         return cur
 
     def _noqueues():
         try:
             fh = repo.vfs(_allqueues, 'r')
             fh.close()
         except IOError:
             return True
 
         return False
 
     def _getqueues():
         current = _getcurrent()
 
         try:
             fh = repo.vfs(_allqueues, 'r')
             queues = [queue.strip() for queue in fh if queue.strip()]
             fh.close()
             if current not in queues:
                 queues.append(current)
         except IOError:
             queues = [_defaultqueue]
 
         return sorted(queues)
 
     def _setactive(name):
         if q.applied:
             raise error.Abort(_('new queue created, but cannot make active '
                                'as patches are applied'))
         _setactivenocheck(name)
 
     def _setactivenocheck(name):
         fh = repo.vfs(_activequeue, 'w')
         if name != 'patches':
             fh.write(name)
         fh.close()
 
     def _addqueue(name):
         fh = repo.vfs(_allqueues, 'a')
         fh.write('%s\n' % (name,))
         fh.close()
 
     def _queuedir(name):
         if name == 'patches':
             return repo.join('patches')
         else:
             return repo.join('patches-' + name)
 
     def _validname(name):
         for n in name:
             if n in ':\\/.':
                 return False
         return True
 
     def _delete(name):
         if name not in existing:
             raise error.Abort(_('cannot delete queue that does not exist'))
 
         current = _getcurrent()
 
         if name == current:
             raise error.Abort(_('cannot delete currently active queue'))
 
         fh = repo.vfs('patches.queues.new', 'w')
         for queue in existing:
             if queue == name:
                 continue
             fh.write('%s\n' % (queue,))
         fh.close()
         util.rename(repo.join('patches.queues.new'), repo.join(_allqueues))
 
     if not name or opts.get('list') or opts.get('active'):
         current = _getcurrent()
         if opts.get('active'):
             ui.write('%s\n' % (current,))
             return
         for queue in _getqueues():
             ui.write('%s' % (queue,))
             if queue == current and not ui.quiet:
                 ui.write(_(' (active)\n'))
             else:
                 ui.write('\n')
         return
 
     if not _validname(name):
         raise error.Abort(
                 _('invalid queue name, may not contain the characters ":\\/."'))
 
     existing = _getqueues()
 
     if opts.get('create'):
         if name in existing:
             raise error.Abort(_('queue "%s" already exists') % name)
         if _noqueues():
             _addqueue(_defaultqueue)
         _addqueue(name)
         _setactive(name)
     elif opts.get('rename'):
         current = _getcurrent()
         if name == current:
             raise error.Abort(_('can\'t rename "%s" to its current name')
                               % name)
         if name in existing:
             raise error.Abort(_('queue "%s" already exists') % name)
 
         olddir = _queuedir(current)
         newdir = _queuedir(name)
 
         if os.path.exists(newdir):
             raise error.Abort(_('non-queue directory "%s" already exists') %
                     newdir)
 
         fh = repo.vfs('patches.queues.new', 'w')
         for queue in existing:
             if queue == current:
                 fh.write('%s\n' % (name,))
                 if os.path.exists(olddir):
                     util.rename(olddir, newdir)
             else:
                 fh.write('%s\n' % (queue,))
         fh.close()
         util.rename(repo.join('patches.queues.new'), repo.join(_allqueues))
         _setactivenocheck(name)
     elif opts.get('delete'):
         _delete(name)
     elif opts.get('purge'):
         if name in existing:
             _delete(name)
         qdir = _queuedir(name)
         if os.path.exists(qdir):
             shutil.rmtree(qdir)
     else:
         if name not in existing:
             raise error.Abort(_('use --create to create a new queue'))
         _setactive(name)
 
 def mqphasedefaults(repo, roots):
     """callback used to set mq changeset as secret when no phase data exists"""
     if repo.mq.applied:
         if repo.ui.configbool('mq', 'secret', False):
             mqphase = phases.secret
         else:
             mqphase = phases.draft
         qbase = repo[repo.mq.applied[0].node]
         roots[mqphase].add(qbase.node())
     return roots
 
 def reposetup(ui, repo):
     class mqrepo(repo.__class__):
         @localrepo.unfilteredpropertycache
         def mq(self):
             return queue(self.ui, self.baseui, self.path)
 
         def invalidateall(self):
             super(mqrepo, self).invalidateall()
             if localrepo.hasunfilteredcache(self, 'mq'):
                 # recreate mq in case queue path was changed
                 delattr(self.unfiltered(), 'mq')
 
         def abortifwdirpatched(self, errmsg, force=False):
             if self.mq.applied and self.mq.checkapplied and not force:
                 parents = self.dirstate.parents()
                 patches = [s.node for s in self.mq.applied]
                 if parents[0] in patches or parents[1] in patches:
                     raise error.Abort(errmsg)
 
         def commit(self, text="", user=None, date=None, match=None,
                    force=False, editor=False, extra={}):
             self.abortifwdirpatched(
                 _('cannot commit over an applied mq patch'),
                 force)
 
             return super(mqrepo, self).commit(text, user, date, match, force,
                                               editor, extra)
 
         def checkpush(self, pushop):
             if self.mq.applied and self.mq.checkapplied and not pushop.force:
                 outapplied = [e.node for e in self.mq.applied]
                 if pushop.revs:
                     # Assume applied patches have no non-patch descendants and
                     # are not on remote already. Filtering any changeset not
                     # pushed.
                     heads = set(pushop.revs)
                     for node in reversed(outapplied):
                         if node in heads:
                             break
                         else:
                             outapplied.pop()
                 # looking for pushed and shared changeset
                 for node in outapplied:
                     if self[node].phase() < phases.secret:
                         raise error.Abort(_('source has mq patches applied'))
                 # no non-secret patches pushed
             super(mqrepo, self).checkpush(pushop)
 
         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]
 
             try:
                 # for now ignore filtering business
                 self.unfiltered().changelog.rev(mqtags[-1][0])
             except error.LookupError:
                 self.ui.warn(_('mq status file refers to unknown node %s\n')
                              % short(mqtags[-1][0]))
                 return result
 
             # do not add fake tags for filtered revisions
             included = self.changelog.hasnode
             mqtags = [mqt for mqt in mqtags if included(mqt[0])]
             if not mqtags:
                 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
 
     if repo.local():
         repo.__class__ = mqrepo
 
         repo._phasedefaults.append(mqphasedefaults)
 
 def mqimport(orig, ui, repo, *args, **kwargs):
     if (util.safehasattr(repo, 'abortifwdirpatched')
         and not kwargs.get('no_commit', False)):
         repo.abortifwdirpatched(_('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 error.Abort(_('only a local queue repository '
                                'may be initialized'))
     else:
         repopath = cmdutil.findrepo(os.getcwd())
         if not repopath:
             raise error.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 error.Abort(_('no queue repository'))
     return orig(r.ui, r, *args, **kwargs)
 
 def summaryhook(ui, repo):
     q = repo.mq
     m = []
     a, u = len(q.applied), len(q.unapplied(repo))
     if a:
         m.append(ui.label(_("%d applied"), 'qseries.applied') % a)
     if u:
         m.append(ui.label(_("%d unapplied"), 'qseries.unapplied') % u)
     if m:
         # i18n: column positioning for "hg summary"
         ui.write(_("mq:     %s\n") % ', '.join(m))
     else:
         # i18n: column positioning for "hg summary"
         ui.note(_("mq:     (empty queue)\n"))
 
 def revsetmq(repo, subset, x):
     """``mq()``
     Changesets managed by MQ.
     """
     revset.getargs(x, 0, 0, _("mq takes no arguments"))
     applied = set([repo[r.node].rev() for r in repo.mq.applied])
     return revset.baseset([r for r in subset if r in applied])
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = [revsetmq]
 
 def extsetup(ui):
     # Ensure mq wrappers are called first, regardless of extension load order by
     # NOT wrapping in uisetup() and instead deferring to init stage two here.
     mqopt = [('', 'mq', None, _("operate on patch repository"))]
 
     extensions.wrapcommand(commands.table, 'import', mqimport)
     cmdutil.summaryhooks.add('mq', summaryhook)
 
     entry = extensions.wrapcommand(commands.table, 'init', mqinit)
     entry[1].extend(mqopt)
 
     nowrap = set(commands.norepo.split(" "))
 
     def dotable(cmdtable):
         for cmd in cmdtable.keys():
             cmd = cmdutil.parsealiases(cmd)[0]
             if cmd in nowrap:
                 continue
             entry = extensions.wrapcommand(cmdtable, cmd, mqcommand)
             entry[1].extend(mqopt)
 
     dotable(commands.table)
 
     for extname, extmodule in extensions.extensions():
         if extmodule.__file__ != __file__:
             dotable(getattr(extmodule, 'cmdtable', {}))
 
     revset.symbols['mq'] = revsetmq
 
 colortable = {'qguard.negative': 'red',
               'qguard.positive': 'yellow',
               'qguard.unguarded': 'green',
               'qseries.applied': 'blue bold underline',
               'qseries.guarded': 'black bold',
               'qseries.missing': 'red bold',
               'qseries.unapplied': 'black bold'}

tests/test-mq-qpush-fail.t

@@ -1,464 +1,470
 Test that qpush cleans things up if it doesn't complete
 
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "mq=" >> $HGRCPATH
   $ hg init repo
   $ cd repo
   $ echo foo > foo
   $ hg ci -Am 'add foo'
   adding foo
   $ touch untracked-file
   $ echo 'syntax: glob' > .hgignore
   $ echo '.hgignore' >> .hgignore
   $ hg qinit
 
 test qpush on empty series
 
   $ hg qpush
   no patches in series
   $ hg qnew patch1
   $ echo >> foo
   $ hg qrefresh -m 'patch 1'
   $ hg qnew patch2
   $ echo bar > bar
   $ hg add bar
   $ hg qrefresh -m 'patch 2'
   $ hg qnew --config 'mq.plain=true' -U bad-patch
   $ echo >> foo
   $ hg qrefresh
   $ hg qpop -a
   popping bad-patch
   popping patch2
   popping patch1
   patch queue now empty
   $ $PYTHON -c 'print "\xe9"' > message
   $ cat .hg/patches/bad-patch >> message
   $ mv message .hg/patches/bad-patch
   $ cat > $TESTTMP/wrapplayback.py <<EOF
   > import os
   > from mercurial import extensions, transaction
   > def wrapplayback(orig,
   >                  journal, report, opener, vfsmap, entries, backupentries,
   >                  unlink=True):
   >     orig(journal, report, opener, vfsmap, entries, backupentries, unlink)
   >     # Touching files truncated at "transaction.abort" causes
   >     # forcible re-loading invalidated filecache properties
   >     # (including repo.changelog)
   >     for f, o, _ignore in entries:
   >         if o or not unlink:
   >             os.utime(opener.join(f), (0.0, 0.0))
   > def extsetup(ui):
   >     extensions.wrapfunction(transaction, '_playback', wrapplayback)
   > EOF
   $ hg qpush -a --config extensions.wrapplayback=$TESTTMP/wrapplayback.py  && echo 'qpush succeeded?!'
   applying patch1
   applying patch2
   applying bad-patch
   transaction abort!
   rollback completed
   cleaning up working directory...
   reverting foo
   done
   abort: decoding near '\xe9': 'ascii' codec can't decode byte 0xe9 in position 0: ordinal not in range(128)! (esc)
   [255]
   $ hg parents
   changeset:   0:bbd179dfa0a7
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add foo
   
 
 test corrupt status file
   $ hg qpush
   applying patch1
   now at: patch1
   $ cp .hg/patches/status .hg/patches/status.orig
   $ hg qpop
   popping patch1
   patch queue now empty
   $ cp .hg/patches/status.orig .hg/patches/status
   $ hg qpush
   abort: working directory revision is not qtip
   [255]
   $ rm .hg/patches/status .hg/patches/status.orig
 
 
 bar should be gone; other unknown/ignored files should still be around
 
   $ hg status -A
   ? untracked-file
   I .hgignore
   C foo
 
 preparing qpush of a missing patch
 
   $ hg qpop -a
   no patches applied
   $ hg qpush
   applying patch1
   now at: patch1
   $ rm .hg/patches/patch2
 
 now we expect the push to fail, but it should NOT complain about patch1
 
   $ hg qpush
   applying patch2
   unable to read patch2
   now at: patch1
   [1]
 
 preparing qpush of missing patch with no patch applied
 
   $ hg qpop -a
   popping patch1
   patch queue now empty
   $ rm .hg/patches/patch1
 
 qpush should fail the same way as below
 
   $ hg qpush
   applying patch1
   unable to read patch1
   [1]
 
 Test qpush to a patch below the currently applied patch.
 
   $ hg qq -c guardedseriesorder
   $ hg qnew a
   $ hg qguard +block
   $ hg qnew b
   $ hg qnew c
 
   $ hg qpop -a
   popping c
   popping b
   popping a
   patch queue now empty
 
 try to push and pop while a is guarded
 
   $ hg qpush a
   cannot push 'a' - guarded by '+block'
   [1]
   $ hg qpush -a
   applying b
   patch b is empty
   applying c
   patch c is empty
   now at: c
 
 now try it when a is unguarded, and we're at the top of the queue
 
   $ hg qapplied -v
   0 G a
   1 A b
   2 A c
   $ hg qsel block
   $ hg qpush b
   abort: cannot push to a previous patch: b
   [255]
   $ hg qpush a
   abort: cannot push to a previous patch: a
   [255]
 
 and now we try it one more time with a unguarded, while we're not at the top of the queue
 
   $ hg qpop b
   popping c
   now at: b
   $ hg qpush a
   abort: cannot push to a previous patch: a
   [255]
 
 test qpop --force and backup files
 
   $ hg qpop -a
   popping b
   patch queue now empty
   $ hg qq --create force
   $ echo a > a
   $ echo b > b
   $ echo c > c
   $ hg ci -Am add a b c
   $ echo a >> a
   $ hg rm b
   $ hg rm c
   $ hg qnew p1
   $ echo a >> a
   $ echo bb > b
   $ hg add b
   $ echo cc > c
   $ hg add c
   $ hg qpop --force --verbose
   saving current version of a as a.orig
   saving current version of b as b.orig
   saving current version of c as c.orig
   popping p1
   patch queue now empty
   $ hg st
   ? a.orig
   ? b.orig
   ? c.orig
   ? untracked-file
   $ cat a.orig
   a
   a
   a
   $ cat b.orig
   bb
   $ cat c.orig
   cc
 
 test qpop --force --no-backup
 
   $ hg qpush
   applying p1
   now at: p1
   $ rm a.orig
   $ echo a >> a
   $ hg qpop --force --no-backup --verbose
   popping p1
   patch queue now empty
   $ test -f a.orig && echo 'error: backup with --no-backup'
   [1]
 
 test qpop --keep-changes
 
   $ hg qpush
   applying p1
   now at: p1
   $ hg qpop --keep-changes --force
   abort: cannot use both --force and --keep-changes
   [255]
   $ echo a >> a
   $ hg qpop --keep-changes
   abort: local changes found, qrefresh first
   [255]
   $ hg revert -qa a
   $ rm a
   $ hg qpop --keep-changes
   abort: local changes found, qrefresh first
   [255]
   $ hg rm -A a
   $ hg qpop --keep-changes
   abort: local changes found, qrefresh first
   [255]
   $ hg revert -qa a
   $ echo b > b
   $ hg add b
   $ hg qpop --keep-changes
   abort: local changes found, qrefresh first
   [255]
   $ hg forget b
   $ echo d > d
   $ hg add d
   $ hg qpop --keep-changes
   popping p1
   patch queue now empty
   $ hg forget d
   $ rm d
 
 test qpush --force and backup files
 
   $ echo a >> a
   $ hg qnew p2
   $ echo b >> b
   $ echo d > d
   $ echo e > e
   $ hg add d e
   $ hg rm c
   $ hg qnew p3
   $ hg qpop -a
   popping p3
   popping p2
   patch queue now empty
   $ echo a >> a
   $ echo b1 >> b
   $ echo d1 > d
   $ hg add d
   $ echo e1 > e
   $ hg qpush -a --force --verbose
   applying p2
   saving current version of a as a.orig
   patching file a
   committing files:
   a
   committing manifest
   committing changelog
   applying p3
   saving current version of b as b.orig
   saving current version of d as d.orig
   patching file b
   patching file c
   patching file d
   file d already exists
   1 out of 1 hunks FAILED -- saving rejects to file d.rej
   patching file e
   file e already exists
   1 out of 1 hunks FAILED -- saving rejects to file e.rej
   patch failed to apply
   committing files:
   b
   committing manifest
   committing changelog
   patch failed, rejects left in working directory
   errors during apply, please fix and qrefresh p3
   [2]
   $ cat a.orig
   a
   a
   $ cat b.orig
   b
   b1
   $ cat d.orig
   d1
 
 test qpush --force --no-backup
 
   $ hg revert -qa
   $ hg qpop -a
   popping p3
   popping p2
   patch queue now empty
   $ echo a >> a
   $ rm a.orig
   $ hg qpush --force --no-backup --verbose
   applying p2
   patching file a
   committing files:
   a
   committing manifest
   committing changelog
   now at: p2
   $ test -f a.orig && echo 'error: backup with --no-backup'
   [1]
 
 test qgoto --force --no-backup
 
   $ hg qpop
   popping p2
   patch queue now empty
   $ echo a >> a
   $ hg qgoto --force --no-backup p2 --verbose
   applying p2
   patching file a
   committing files:
   a
   committing manifest
   committing changelog
   now at: p2
   $ test -f a.orig && echo 'error: backup with --no-backup'
   [1]
 
 test qpush --keep-changes
 
   $ hg qpush --keep-changes --force
   abort: cannot use both --force and --keep-changes
   [255]
   $ hg qpush --keep-changes --exact
   abort: cannot use --exact and --keep-changes together
   [255]
   $ echo b >> b
   $ hg qpush --keep-changes
   applying p3
   abort: conflicting local changes found
   (did you forget to qrefresh?)
   [255]
   $ rm b
   $ hg qpush --keep-changes
   applying p3
   abort: conflicting local changes found
   (did you forget to qrefresh?)
   [255]
   $ hg rm -A b
   $ hg qpush --keep-changes
   applying p3
   abort: conflicting local changes found
   (did you forget to qrefresh?)
   [255]
   $ hg revert -aq b
   $ echo d > d
   $ hg add d
   $ hg qpush --keep-changes
   applying p3
   abort: conflicting local changes found
   (did you forget to qrefresh?)
   [255]
   $ hg forget d
   $ rm d
   $ hg qpop
   popping p2
   patch queue now empty
   $ echo b >> b
   $ hg qpush -a --keep-changes
   applying p2
   applying p3
   abort: conflicting local changes found
   (did you forget to qrefresh?)
   [255]
   $ hg qtop
   p2
   $ hg parents --template "{rev} {desc}\n"
   2 imported patch p2
   $ hg st b
   M b
   $ cat b
   b
   b
 
 test qgoto --keep-changes
 
   $ hg revert -aq b
   $ rm e
   $ hg qgoto --keep-changes --force p3
   abort: cannot use both --force and --keep-changes
   [255]
   $ echo a >> a
   $ hg qgoto --keep-changes p3
   applying p3
   now at: p3
   $ hg st a
   M a
   $ hg qgoto --keep-changes p2
   popping p3
   now at: p2
   $ hg st a
   M a
 
 test mq.keepchanges setting
 
   $ hg --config mq.keepchanges=1 qpush
   applying p3
   now at: p3
   $ hg st a
   M a
   $ hg --config mq.keepchanges=1 qpop
   popping p3
   now at: p2
   $ hg st a
   M a
   $ hg --config mq.keepchanges=1 qgoto p3
   applying p3
   now at: p3
   $ hg st a
   M a
   $ echo b >> b
-  $ hg --config mq.keepchanges=1 qpop --force
+  $ hg --config mq.keepchanges=1 qpop --force --config 'ui.origbackuppath=.hg/origbackups'
   popping p3
   now at: p2
   $ hg st b
   $ hg --config mq.keepchanges=1 qpush --exact
   abort: local changes found, qrefresh first
   [255]
   $ hg revert -qa a
   $ hg qpop
   popping p2
   patch queue now empty
   $ echo a >> a
   $ hg --config mq.keepchanges=1 qpush --force
   applying p2
   now at: p2
   $ hg st a
 
+test previous qpop (with --force and --config) saved .orig files to where user
+wants them
+  $ ls .hg/origbackups
+  b.orig
+  $ rm -rf .hg/origbackups
+
   $ cd ..

tests/test-mq.t

@@ -1,1608 +1,1612
   $ checkundo()
   > {
   >     if [ -f .hg/store/undo ]; then
   >     echo ".hg/store/undo still exists after $1"
   >     fi
   > }
 
   $ cat <<EOF >> $HGRCPATH
   > [extensions]
   > mq =
   > [mq]
   > plain = true
   > EOF
 
 
 help
 
   $ hg help mq
   mq extension - 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 behavior 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.
   
   It may be desirable for mq changesets to be kept in the secret phase (see "hg
   help phases"), which can be enabled with the following setting:
   
     [mq]
     secret = True
   
   You will by default be managing a patch queue named "patches". You can create
   other, independent patch queues with the "hg qqueue" command.
   
   If the working directory contains uncommitted files, qpush, qpop and qgoto
   abort immediately. If -f/--force is used, the changes are discarded. Setting:
   
     [mq]
     keepchanges = True
   
   make them behave as if --keep-changes were passed, and non-conflicting local
   changes will be tolerated and preserved. If incompatible options such as
   -f/--force or --exact are passed, this setting is ignored.
   
   This extension used to provide a strip command. This command now lives in the
   strip extension.
   
   list of commands:
   
    qapplied      print the patches already applied
    qclone        clone main and patch repository at same time
    qdelete       remove patches from queue
    qdiff         diff of the current patch and subsequent modifications
    qfinish       move applied patches into repository history
    qfold         fold the named patches into the current patch
    qgoto         push or pop patches until named patch is at top of stack
    qguard        set or print guards for a patch
    qheader       print the header of the topmost or specified patch
    qimport       import a patch or existing changeset
    qnew          create a new patch
    qnext         print the name of the next pushable patch
    qpop          pop the current patch off the stack
    qprev         print the name of the preceding applied patch
    qpush         push the next patch onto the stack
    qqueue        manage multiple patch queues
    qrefresh      update the current patch
    qrename       rename a patch
    qselect       set or print guarded patches to push
    qseries       print the entire series file
    qtop          print the name of the current patch
    qunapplied    print the patches not yet applied
   
   (use "hg help -v mq" to show built-in aliases and global options)
 
   $ hg init a
   $ cd a
   $ echo a > a
   $ hg ci -Ama
   adding a
 
   $ hg clone . ../k
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ mkdir b
   $ echo z > b/z
   $ hg ci -Ama
   adding b/z
 
 
 qinit
 
   $ hg qinit
 
   $ cd ..
   $ hg init b
 
 
 -R qinit
 
   $ hg -R b qinit
 
   $ hg init c
 
 
 qinit -c
 
   $ hg --cwd c qinit -c
   $ hg -R c/.hg/patches st
   A .hgignore
   A series
 
 
 qinit; qinit -c
 
   $ hg init d
   $ cd d
   $ hg qinit
   $ hg qinit -c
 
 qinit -c should create both files if they don't exist
 
   $ cat .hg/patches/.hgignore
   ^\.hg
   ^\.mq
   syntax: glob
   status
   guards
   $ cat .hg/patches/series
   $ hg qinit -c
   abort: repository $TESTTMP/d/.hg/patches already exists! (glob)
   [255]
   $ cd ..
 
   $ echo '% qinit; <stuff>; qinit -c'
   % qinit; <stuff>; qinit -c
   $ hg init e
   $ cd e
   $ hg qnew A
   $ checkundo qnew
   $ echo foo > foo
   $ hg phase -r qbase
   0: draft
   $ hg add foo
   $ hg qrefresh
   $ hg phase -r qbase
   0: draft
   $ hg qnew B
   $ echo >> foo
   $ hg qrefresh
   $ echo status >> .hg/patches/.hgignore
   $ echo bleh >> .hg/patches/.hgignore
   $ hg qinit -c
   adding .hg/patches/A (glob)
   adding .hg/patches/B (glob)
   $ hg -R .hg/patches status
   A .hgignore
   A A
   A B
   A series
 
 qinit -c shouldn't touch these files if they already exist
 
   $ cat .hg/patches/.hgignore
   status
   bleh
   $ cat .hg/patches/series
   A
   B
 
 add an untracked file
 
   $ echo >> .hg/patches/flaf
 
 status --mq with color (issue2096)
 
   $ hg status --mq --config extensions.color= --config color.mode=ansi --color=always
   \x1b[0;32;1mA \x1b[0m\x1b[0;32;1m.hgignore\x1b[0m (esc)
   \x1b[0;32;1mA \x1b[0m\x1b[0;32;1mA\x1b[0m (esc)
   \x1b[0;32;1mA \x1b[0m\x1b[0;32;1mB\x1b[0m (esc)
   \x1b[0;32;1mA \x1b[0m\x1b[0;32;1mseries\x1b[0m (esc)
   \x1b[0;35;1;4m? \x1b[0m\x1b[0;35;1;4mflaf\x1b[0m (esc)
 
 try the --mq option on a command provided by an extension
 
   $ hg purge --mq --verbose --config extensions.purge=
   removing file flaf
 
   $ cd ..
 
 #if no-outer-repo
 
 init --mq without repo
 
   $ mkdir f
   $ cd f
   $ hg init --mq
   abort: there is no Mercurial repository here (.hg not found)
   [255]
   $ cd ..
 
 #endif
 
 init --mq with repo path
 
   $ hg init g
   $ hg init --mq g
   $ test -d g/.hg/patches/.hg
 
 init --mq with nonexistent directory
 
   $ hg init --mq nonexistentdir
   abort: repository nonexistentdir not found!
   [255]
 
 
 init --mq with bundle (non "local")
 
   $ hg -R a bundle --all a.bundle >/dev/null
   $ hg init --mq a.bundle
   abort: only a local queue repository may be initialized
   [255]
 
   $ cd a
 
   $ hg qnew -m 'foo bar' test.patch
 
   $ echo '# comment' > .hg/patches/series.tmp
   $ echo >> .hg/patches/series.tmp # empty line
   $ cat .hg/patches/series >> .hg/patches/series.tmp
   $ mv .hg/patches/series.tmp .hg/patches/series
 
 
 qrefresh
 
   $ echo a >> a
   $ hg qrefresh
   $ cat .hg/patches/test.patch
   foo bar
   
   diff -r [a-f0-9]* a (re)
   --- a/a\t(?P<date>.*) (re)
   \+\+\+ b/a\t(?P<date2>.*) (re)
   @@ -1,1 +1,2 @@
    a
   +a
 
 empty qrefresh
 
   $ hg qrefresh -X a
 
 revision:
 
   $ hg diff -r -2 -r -1
 
 patch:
 
   $ cat .hg/patches/test.patch
   foo bar
   
 
 working dir diff:
 
   $ hg diff --nodates -q
   --- a/a
   +++ b/a
   @@ -1,1 +1,2 @@
    a
   +a
 
 restore things
 
   $ hg qrefresh
   $ checkundo qrefresh
 
 
 qpop
 
   $ hg qpop
   popping test.patch
   patch queue now empty
   $ checkundo qpop
 
 
 qpush with dump of tag cache
 Dump the tag cache to ensure that it has exactly one head after qpush.
 
   $ rm -f .hg/cache/tags2-visible
   $ hg tags > /dev/null
 
 .hg/cache/tags2-visible (pre qpush):
 
   $ cat .hg/cache/tags2-visible
   1 [\da-f]{40} (re)
   $ hg qpush
   applying test.patch
   now at: test.patch
   $ hg phase -r qbase
   2: draft
   $ hg tags > /dev/null
 
 .hg/cache/tags2-visible (post qpush):
 
   $ cat .hg/cache/tags2-visible
   2 [\da-f]{40} (re)
   $ checkundo qpush
   $ cd ..
 
 
 pop/push outside repo
   $ hg -R a qpop
   popping test.patch
   patch queue now empty
   $ hg -R a qpush
   applying test.patch
   now at: test.patch
 
   $ cd a
   $ hg qnew test2.patch
 
 qrefresh in subdir
 
   $ cd b
   $ echo a > a
   $ hg add a
   $ hg qrefresh
 
 pop/push -a in subdir
 
   $ hg qpop -a
   popping test2.patch
   popping test.patch
   patch queue now empty
   $ hg --traceback qpush -a
   applying test.patch
   applying test2.patch
   now at: test2.patch
 
 
 setting columns & formatted tests truncating (issue1912)
 
   $ COLUMNS=4 hg qseries --config ui.formatted=true
   test.patch
   test2.patch
   $ COLUMNS=20 hg qseries --config ui.formatted=true -vs
   0 A test.patch: f...
   1 A test2.patch: 
   $ hg qpop
   popping test2.patch
   now at: test.patch
   $ hg qseries -vs
   0 A test.patch: foo bar
   1 U test2.patch: 
   $ hg sum | grep mq
   mq:     1 applied, 1 unapplied
   $ hg qpush
   applying test2.patch
   now at: test2.patch
   $ hg sum | grep mq
   mq:     2 applied
   $ hg qapplied
   test.patch
   test2.patch
   $ hg qtop
   test2.patch
 
 
 prev
 
   $ hg qapp -1
   test.patch
 
 next
 
   $ hg qunapp -1
   all patches applied
   [1]
 
   $ hg qpop
   popping test2.patch
   now at: test.patch
 
 commit should fail
 
   $ hg commit
   abort: cannot commit over an applied mq patch
   [255]
 
 push should fail if draft
 
   $ hg push ../../k
   pushing to ../../k
   abort: source has mq patches applied
   [255]
 
 
 import should fail
 
   $ hg st .
   $ echo foo >> ../a
   $ hg diff > ../../import.diff
   $ hg revert --no-backup ../a
   $ hg import ../../import.diff
   abort: cannot import over an applied patch
   [255]
   $ hg st
 
 import --no-commit should succeed
 
   $ hg import --no-commit ../../import.diff
   applying ../../import.diff
   $ hg st
   M a
   $ hg revert --no-backup ../a
 
 
 qunapplied
 
   $ hg qunapplied
   test2.patch
 
 
 qpush/qpop with index
 
   $ hg qnew test1b.patch
   $ echo 1b > 1b
   $ hg add 1b
   $ hg qrefresh
   $ hg qpush 2
   applying test2.patch
   now at: test2.patch
   $ hg qpop 0
   popping test2.patch
   popping test1b.patch
   now at: test.patch
   $ hg qpush test.patch+1
   applying test1b.patch
   now at: test1b.patch
   $ hg qpush test.patch+2
   applying test2.patch
   now at: test2.patch
   $ hg qpop test2.patch-1
   popping test2.patch
   now at: test1b.patch
   $ hg qpop test2.patch-2
   popping test1b.patch
   now at: test.patch
   $ hg qpush test1b.patch+1
   applying test1b.patch
   applying test2.patch
   now at: test2.patch
 
 
 qpush --move
 
   $ hg qpop -a
   popping test2.patch
   popping test1b.patch
   popping test.patch
   patch queue now empty
   $ hg qguard test1b.patch -- -negguard
   $ hg qguard test2.patch -- +posguard
   $ hg qpush --move test2.patch # can't move guarded patch
   cannot push 'test2.patch' - guarded by '+posguard'
   [1]
   $ hg qselect posguard
   number of unguarded, unapplied patches has changed from 2 to 3
   $ hg qpush --move test2.patch # move to front
   applying test2.patch
   now at: test2.patch
   $ hg qpush --move test1b.patch # negative guard unselected
   applying test1b.patch
   now at: test1b.patch
   $ hg qpush --move test.patch # noop move
   applying test.patch
   now at: test.patch
   $ hg qseries -v
   0 A test2.patch
   1 A test1b.patch
   2 A test.patch
   $ hg qpop -a
   popping test.patch
   popping test1b.patch
   popping test2.patch
   patch queue now empty
 
 cleaning up
 
   $ hg qselect --none
   guards deactivated
   number of unguarded, unapplied patches has changed from 3 to 2
   $ hg qguard --none test1b.patch
   $ hg qguard --none test2.patch
   $ hg qpush --move test.patch
   applying test.patch
   now at: test.patch
   $ hg qpush --move test1b.patch
   applying test1b.patch
   now at: test1b.patch
   $ hg qpush --move bogus # nonexistent patch
   abort: patch bogus not in series
   [255]
   $ hg qpush --move # no patch
   abort: please specify the patch to move
   [255]
   $ hg qpush --move test.patch # already applied
   abort: cannot push to a previous patch: test.patch
   [255]
   $ sed '2i\
   > # make qtip index different in series and fullseries
   > ' `hg root`/.hg/patches/series > $TESTTMP/sedtmp
   $ cp $TESTTMP/sedtmp `hg root`/.hg/patches/series
   $ cat `hg root`/.hg/patches/series
   # comment
   # make qtip index different in series and fullseries
   
   test.patch
   test1b.patch
   test2.patch
   $ hg qpush --move test2.patch
   applying test2.patch
   now at: test2.patch
 
 
 series after move
 
   $ cat `hg root`/.hg/patches/series
   # comment
   # make qtip index different in series and fullseries
   
   test.patch
   test1b.patch
   test2.patch
 
 
 pop, qapplied, qunapplied
 
   $ hg qseries -v
   0 A test.patch
   1 A test1b.patch
   2 A test2.patch
 
 qapplied -1 test.patch
 
   $ hg qapplied -1 test.patch
   only one patch applied
   [1]
 
 qapplied -1 test1b.patch
 
   $ hg qapplied -1 test1b.patch
   test.patch
 
 qapplied -1 test2.patch
 
   $ hg qapplied -1 test2.patch
   test1b.patch
 
 qapplied -1
 
   $ hg qapplied -1
   test1b.patch
 
 qapplied
 
   $ hg qapplied
   test.patch
   test1b.patch
   test2.patch
 
 qapplied test1b.patch
 
   $ hg qapplied test1b.patch
   test.patch
   test1b.patch
 
 qunapplied -1
 
   $ hg qunapplied -1
   all patches applied
   [1]
 
 qunapplied
 
   $ hg qunapplied
 
 popping
 
   $ hg qpop
   popping test2.patch
   now at: test1b.patch
 
 qunapplied -1
 
   $ hg qunapplied -1
   test2.patch
 
 qunapplied
 
   $ hg qunapplied
   test2.patch
 
 qunapplied test2.patch
 
   $ hg qunapplied test2.patch
 
 qunapplied -1 test2.patch
 
   $ hg qunapplied -1 test2.patch
   all patches applied
   [1]
 
 popping -a
 
   $ hg qpop -a
   popping test1b.patch
   popping test.patch
   patch queue now empty
 
 qapplied
 
   $ hg qapplied
 
 qapplied -1
 
   $ hg qapplied -1
   no patches applied
   [1]
   $ hg qpush
   applying test.patch
   now at: test.patch
 
 
 push should succeed
 
   $ hg qpop -a
   popping test.patch
   patch queue now empty
   $ hg push ../../k
   pushing to ../../k
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 
 we want to start with some patches applied
 
   $ hg qpush -a
   applying test.patch
   applying test1b.patch
   applying test2.patch
   now at: test2.patch
 
 % pops all patches and succeeds
 
   $ hg qpop -a
   popping test2.patch
   popping test1b.patch
   popping test.patch
   patch queue now empty
 
 % does nothing and succeeds
 
   $ hg qpop -a
   no patches applied
 
 % fails - nothing else to pop
 
   $ hg qpop
   no patches applied
   [1]
 
 % pushes a patch and succeeds
 
   $ hg qpush
   applying test.patch
   now at: test.patch
 
 % pops a patch and succeeds
 
   $ hg qpop
   popping test.patch
   patch queue now empty
 
 % pushes up to test1b.patch and succeeds
 
   $ hg qpush test1b.patch
   applying test.patch
   applying test1b.patch
   now at: test1b.patch
 
 % does nothing and succeeds
 
   $ hg qpush test1b.patch
   qpush: test1b.patch is already at the top
 
 % does nothing and succeeds
 
   $ hg qpop test1b.patch
   qpop: test1b.patch is already at the top
 
 % fails - can't push to this patch
 
   $ hg qpush test.patch
   abort: cannot push to a previous patch: test.patch
   [255]
 
 % fails - can't pop to this patch
 
   $ hg qpop test2.patch
   abort: patch test2.patch is not applied
   [255]
 
 % pops up to test.patch and succeeds
 
   $ hg qpop test.patch
   popping test1b.patch
   now at: test.patch
 
 % pushes all patches and succeeds
 
   $ hg qpush -a
   applying test1b.patch
   applying test2.patch
   now at: test2.patch
 
 % does nothing and succeeds
 
   $ hg qpush -a
   all patches are currently applied
 
 % fails - nothing else to push
 
   $ hg qpush
   patch series already fully applied
   [1]
 
 % does nothing and succeeds
 
   $ hg qpush test2.patch
   qpush: test2.patch is already at the top
 
 strip
 
   $ cd ../../b
   $ echo x>x
   $ hg ci -Ama
   adding x
   $ hg strip tip
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/b/.hg/strip-backup/*-backup.hg (glob)
   $ hg unbundle .hg/strip-backup/*
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   (run 'hg update' to get a working copy)
 
 
 strip with local changes, should complain
 
   $ hg up
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo y>y
   $ hg add y
   $ hg strip tip
   abort: local changes found
   [255]
 
 --force strip with local changes
 
   $ hg strip -f tip
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/b/.hg/strip-backup/770eb8fce608-0ddcae0f-backup.hg (glob)
   $ cd ..
 
 
 cd b; hg qrefresh
 
   $ hg init refresh
   $ cd refresh
   $ echo a > a
   $ hg ci -Ama
   adding a
   $ hg qnew -mfoo foo
   $ echo a >> a
   $ hg qrefresh
   $ mkdir b
   $ cd b
   $ echo f > f
   $ hg add f
   $ hg qrefresh
   $ cat ../.hg/patches/foo
   foo
   
   diff -r cb9a9f314b8b a
   --- a/a\t(?P<date>.*) (re)
   \+\+\+ b/a\t(?P<date>.*) (re)
   @@ -1,1 +1,2 @@
    a
   +a
   diff -r cb9a9f314b8b b/f
   --- /dev/null\t(?P<date>.*) (re)
   \+\+\+ b/b/f\t(?P<date>.*) (re)
   @@ -0,0 +1,1 @@
   +f
 
 hg qrefresh .
 
   $ hg qrefresh .
   $ cat ../.hg/patches/foo
   foo
   
   diff -r cb9a9f314b8b b/f
   --- /dev/null\t(?P<date>.*) (re)
   \+\+\+ b/b/f\t(?P<date>.*) (re)
   @@ -0,0 +1,1 @@
   +f
   $ hg status
   M a
 
 
 qpush failure
 
   $ cd ..
   $ hg qrefresh
   $ hg qnew -mbar bar
   $ echo foo > foo
   $ echo bar > bar
   $ hg add foo bar
   $ hg qrefresh
   $ hg qpop -a
   popping bar
   popping foo
   patch queue now empty
   $ echo bar > foo
   $ hg qpush -a
   applying foo
   applying bar
   file foo already exists
   1 out of 1 hunks FAILED -- saving rejects to file foo.rej
   patch failed, unable to continue (try -v)
   patch failed, rejects left in working directory
   errors during apply, please fix and qrefresh bar
   [2]
   $ hg st
   ? foo
   ? foo.rej
 
 
 mq tags
 
   $ hg log --template '{rev} {tags}\n' -r qparent:qtip
   0 qparent
   1 foo qbase
   2 bar qtip tip
 
 mq revset
 
   $ hg log -r 'mq()' --template '{rev}\n'
   1
   2
   $ hg help revsets | grep -i mq
       "mq()"
         Changesets managed by MQ.
 
 bad node in status
 
   $ hg qpop
   popping bar
   now at: foo
   $ hg strip -qn tip
   $ hg tip
   changeset:   0:cb9a9f314b8b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
   $ hg branches
   default                        0:cb9a9f314b8b
   $ hg qpop
   no patches applied
   [1]
 
   $ cd ..
 
 
 git patches
 
   $ cat >>$HGRCPATH <<EOF
   > [diff]
   > git = True
   > EOF
   $ hg init git
   $ cd git
   $ hg qinit
 
   $ hg qnew -m'new file' new
   $ echo foo > new
 #if execbit
   $ chmod +x new
 #endif
   $ hg add new
   $ hg qrefresh
 #if execbit
   $ cat .hg/patches/new
   new file
   
   diff --git a/new b/new
   new file mode 100755
   --- /dev/null
   +++ b/new
   @@ -0,0 +1,1 @@
   +foo
 #else
   $ cat .hg/patches/new
   new file
   
   diff --git a/new b/new
   new file mode 100644
   --- /dev/null
   +++ b/new
   @@ -0,0 +1,1 @@
   +foo
 #endif
 
   $ hg qnew -m'copy file' copy
   $ hg cp new copy
   $ hg qrefresh
   $ cat .hg/patches/copy
   copy file
   
   diff --git a/new b/copy
   copy from new
   copy to copy
 
   $ hg qpop
   popping copy
   now at: new
   $ hg qpush
   applying copy
   now at: copy
   $ hg qdiff
   diff --git a/new b/copy
   copy from new
   copy to copy
   $ cat >>$HGRCPATH <<EOF
   > [diff]
   > git = False
   > EOF
   $ hg qdiff --git
   diff --git a/new b/copy
   copy from new
   copy to copy
   $ cd ..
 
 empty lines in status
 
   $ hg init emptystatus
   $ cd emptystatus
   $ hg qinit
   $ printf '\n\n' > .hg/patches/status
   $ hg qser
   $ cd ..
 
 bad line in status (without ":")
 
   $ hg init badstatus
   $ cd badstatus
   $ hg qinit
   $ printf 'babar has no colon in this line\n' > .hg/patches/status
   $ hg qser
   malformated mq status line: ['babar has no colon in this line']
   $ cd ..
 
 
 test file addition in slow path
 
   $ hg init slow
   $ cd slow
   $ hg qinit
   $ echo foo > foo
   $ hg add foo
   $ hg ci -m 'add foo'
   $ hg qnew bar
   $ echo bar > bar
   $ hg add bar
   $ hg mv foo baz
   $ hg qrefresh --git
   $ hg up -C 0
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo >> foo
   $ hg ci -m 'change foo'
   created new head
   $ hg up -C 1
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg qrefresh --git
   $ cat .hg/patches/bar
   diff --git a/bar b/bar
   new file mode 100644
   --- /dev/null
   +++ b/bar
   @@ -0,0 +1,1 @@
   +bar
   diff --git a/foo b/baz
   rename from foo
   rename to baz
   $ hg log -v --template '{rev} {file_copies}\n' -r .
   2 baz (foo)
   $ hg qrefresh --git
   $ cat .hg/patches/bar
   diff --git a/bar b/bar
   new file mode 100644
   --- /dev/null
   +++ b/bar
   @@ -0,0 +1,1 @@
   +bar
   diff --git a/foo b/baz
   rename from foo
   rename to baz
   $ hg log -v --template '{rev} {file_copies}\n' -r .
   2 baz (foo)
   $ hg qrefresh
   $ grep 'diff --git' .hg/patches/bar
   diff --git a/bar b/bar
   diff --git a/foo b/baz
 
 
 test file move chains in the slow path
 
   $ hg up -C 1
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo >> foo
   $ hg ci -m 'change foo again'
   $ hg up -C 2
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg mv bar quux
   $ hg mv baz bleh
   $ hg qrefresh --git
   $ cat .hg/patches/bar
   diff --git a/foo b/bleh
   rename from foo
   rename to bleh
   diff --git a/quux b/quux
   new file mode 100644
   --- /dev/null
   +++ b/quux
   @@ -0,0 +1,1 @@
   +bar
   $ hg log -v --template '{rev} {file_copies}\n' -r .
   3 bleh (foo)
   $ hg mv quux fred
   $ hg mv bleh barney
   $ hg qrefresh --git
   $ cat .hg/patches/bar
   diff --git a/foo b/barney
   rename from foo
   rename to barney
   diff --git a/fred b/fred
   new file mode 100644
   --- /dev/null
   +++ b/fred
   @@ -0,0 +1,1 @@
   +bar
   $ hg log -v --template '{rev} {file_copies}\n' -r .
   3 barney (foo)
 
 
 refresh omitting an added file
 
   $ hg qnew baz
   $ echo newfile > newfile
   $ hg add newfile
   $ hg qrefresh
   $ hg st -A newfile
   C newfile
   $ hg qrefresh -X newfile
   $ hg st -A newfile
   A newfile
   $ hg revert newfile
   $ rm newfile
   $ hg qpop
   popping baz
   now at: bar
 
 test qdel/qrm
 
   $ hg qdel baz
   $ echo p >> .hg/patches/series
   $ hg qrm p
   $ hg qser
   bar
 
 create a git patch
 
   $ echo a > alexander
   $ hg add alexander
   $ hg qnew -f --git addalexander
   $ grep diff .hg/patches/addalexander
   diff --git a/alexander b/alexander
 
 
 create a git binary patch
 
   $ cat > writebin.py <<EOF
   > import sys
   > path = sys.argv[1]
   > open(path, 'wb').write('BIN\x00ARY')
   > EOF
   $ python writebin.py bucephalus
 
   $ python "$TESTDIR/md5sum.py" bucephalus
   8ba2a2f3e77b55d03051ff9c24ad65e7  bucephalus
   $ hg add bucephalus
   $ hg qnew -f --git addbucephalus
   $ grep diff .hg/patches/addbucephalus
   diff --git a/bucephalus b/bucephalus
 
 
 check binary patches can be popped and pushed
 
   $ hg qpop
   popping addbucephalus
   now at: addalexander
   $ test -f bucephalus && echo % bucephalus should not be there
   [1]
   $ hg qpush
   applying addbucephalus
   now at: addbucephalus
   $ test -f bucephalus
   $ python "$TESTDIR/md5sum.py" bucephalus
   8ba2a2f3e77b55d03051ff9c24ad65e7  bucephalus
 
 
 
 strip again
 
   $ cd ..
   $ hg init strip
   $ cd strip
   $ touch foo
   $ hg add foo
   $ hg ci -m 'add foo'
   $ echo >> foo
   $ hg ci -m 'change foo 1'
   $ hg up -C 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 1 >> foo
   $ hg ci -m 'change foo 2'
   created new head
   $ HGMERGE=true hg merge
   merging foo
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m merge
   $ hg log
   changeset:   3:99615015637b
   tag:         tip
   parent:      2:20cbbe65cff7
   parent:      1:d2871fc282d4
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge
   
   changeset:   2:20cbbe65cff7
   parent:      0:53245c60e682
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     change foo 2
   
   changeset:   1:d2871fc282d4
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     change foo 1
   
   changeset:   0:53245c60e682
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add foo
   
   $ hg strip 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/strip/.hg/strip-backup/*-backup.hg (glob)
   $ checkundo strip
   $ hg log
   changeset:   1:20cbbe65cff7
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     change foo 2
   
   changeset:   0:53245c60e682
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add foo
   
   $ cd ..
 
 
 qclone
 
   $ qlog()
   > {
   >     echo 'main repo:'
   >     hg log --template '    rev {rev}: {desc}\n'
   >     echo 'patch repo:'
   >     hg -R .hg/patches log --template '    rev {rev}: {desc}\n'
   > }
   $ hg init qclonesource
   $ cd qclonesource
   $ echo foo > foo
   $ hg add foo
   $ hg ci -m 'add foo'
   $ hg qinit
   $ hg qnew patch1
   $ echo bar >> foo
   $ hg qrefresh -m 'change foo'
   $ cd ..
 
 
 repo with unversioned patch dir
 
   $ hg qclone qclonesource failure
   abort: versioned patch repository not found (see init --mq)
   [255]
 
   $ cd qclonesource
   $ hg qinit -c
   adding .hg/patches/patch1 (glob)
   $ hg qci -m checkpoint
   $ qlog
   main repo:
       rev 1: change foo
       rev 0: add foo
   patch repo:
       rev 0: checkpoint
   $ cd ..
 
 
 repo with patches applied
 
   $ hg qclone qclonesource qclonedest
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd qclonedest
   $ qlog
   main repo:
       rev 0: add foo
   patch repo:
       rev 0: checkpoint
   $ cd ..
 
 
 repo with patches unapplied
 
   $ cd qclonesource
   $ hg qpop -a
   popping patch1
   patch queue now empty
   $ qlog
   main repo:
       rev 0: add foo
   patch repo:
       rev 0: checkpoint
   $ cd ..
   $ hg qclone qclonesource qclonedest2
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd qclonedest2
   $ qlog
   main repo:
       rev 0: add foo
   patch repo:
       rev 0: checkpoint
   $ cd ..
 
 
 Issue1033: test applying on an empty file
 
   $ hg init empty
   $ cd empty
   $ touch a
   $ hg ci -Am addempty
   adding a
   $ echo a > a
   $ hg qnew -f -e changea
   $ hg qpop
   popping changea
   patch queue now empty
   $ hg qpush
   applying changea
   now at: changea
   $ cd ..
 
 test qpush with --force, issue1087
 
   $ hg init forcepush
   $ cd forcepush
   $ echo hello > hello.txt
   $ echo bye > bye.txt
   $ hg ci -Ama
   adding bye.txt
   adding hello.txt
   $ hg qnew -d '0 0' empty
   $ hg qpop
   popping empty
   patch queue now empty
   $ echo world >> hello.txt
 
 
 qpush should fail, local changes
 
   $ hg qpush
   abort: local changes found
   [255]
 
 
 apply force, should not discard changes with empty patch
 
   $ hg qpush -f
   applying empty
   patch empty is empty
   now at: empty
   $ hg diff --config diff.nodates=True
   diff -r d58265112590 hello.txt
   --- a/hello.txt
   +++ b/hello.txt
   @@ -1,1 +1,2 @@
    hello
   +world
   $ hg qdiff --config diff.nodates=True
   diff -r 9ecee4f634e3 hello.txt
   --- a/hello.txt
   +++ b/hello.txt
   @@ -1,1 +1,2 @@
    hello
   +world
   $ hg log -l1 -p
   changeset:   1:d58265112590
   tag:         empty
   tag:         qbase
   tag:         qtip
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     imported patch empty
   
   
   $ hg qref -d '0 0'
   $ hg qpop
   popping empty
   patch queue now empty
   $ echo universe >> hello.txt
   $ echo universe >> bye.txt
 
 
 qpush should fail, local changes
 
   $ hg qpush
   abort: local changes found
   [255]
 
 
 apply force, should discard changes in hello, but not bye
 
-  $ hg qpush -f --verbose
+  $ hg qpush -f --verbose --config 'ui.origbackuppath=.hg/origbackups'
   applying empty
-  saving current version of hello.txt as hello.txt.orig
+  creating directory: $TESTTMP/forcepush/.hg/origbackups
+  saving current version of hello.txt as $TESTTMP/forcepush/.hg/origbackups/hello.txt.orig
   patching file hello.txt
   committing files:
   hello.txt
   committing manifest
   committing changelog
   now at: empty
   $ hg st
   M bye.txt
-  ? hello.txt.orig
   $ hg diff --config diff.nodates=True
   diff -r ba252371dbc1 bye.txt
   --- a/bye.txt
   +++ b/bye.txt
   @@ -1,1 +1,2 @@
    bye
   +universe
   $ hg qdiff --config diff.nodates=True
   diff -r 9ecee4f634e3 bye.txt
   --- a/bye.txt
   +++ b/bye.txt
   @@ -1,1 +1,2 @@
    bye
   +universe
   diff -r 9ecee4f634e3 hello.txt
   --- a/hello.txt
   +++ b/hello.txt
   @@ -1,1 +1,3 @@
    hello
   +world
   +universe
 
+test that the previous call to qpush with -f (--force) and --config actually put
+the orig files out of the working copy
+  $ ls .hg/origbackups
+  hello.txt.orig
 
 test popping revisions not in working dir ancestry
 
   $ hg qseries -v
   0 A empty
   $ hg up qparent
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg qpop
   popping empty
   patch queue now empty
 
   $ cd ..
   $ hg init deletion-order
   $ cd deletion-order
 
   $ touch a
   $ hg ci -Aqm0
 
   $ hg qnew rename-dir
   $ hg rm a
   $ hg qrefresh
 
   $ mkdir a b
   $ touch a/a b/b
   $ hg add -q a b
   $ hg qrefresh
 
 
 test popping must remove files added in subdirectories first
 
   $ hg qpop
   popping rename-dir
   patch queue now empty
   $ cd ..
 
 
 test case preservation through patch pushing especially on case
 insensitive filesystem
 
   $ hg init casepreserve
   $ cd casepreserve
 
   $ hg qnew add-file1
   $ echo a > TeXtFiLe.TxT
   $ hg add TeXtFiLe.TxT
   $ hg qrefresh
 
   $ hg qnew add-file2
   $ echo b > AnOtHeRFiLe.TxT
   $ hg add AnOtHeRFiLe.TxT
   $ hg qrefresh
 
   $ hg qnew modify-file
   $ echo c >> AnOtHeRFiLe.TxT
   $ hg qrefresh
 
   $ hg qapplied
   add-file1
   add-file2
   modify-file
   $ hg qpop -a
   popping modify-file
   popping add-file2
   popping add-file1
   patch queue now empty
 
 this qpush causes problems below, if case preservation on case
 insensitive filesystem is not enough:
 (1) unexpected "adding ..." messages are shown
 (2) patching fails in modification of (1) files
 
   $ hg qpush -a
   applying add-file1
   applying add-file2
   applying modify-file
   now at: modify-file
 
 Proper phase default with mq:
 
 1. mq.secret=false
 
   $ rm .hg/store/phaseroots
   $ hg phase 'qparent::'
   -1: public
   0: draft
   1: draft
   2: draft
   $ echo '[mq]' >> $HGRCPATH
   $ echo 'secret=true' >> $HGRCPATH
   $ rm -f .hg/store/phaseroots
   $ hg phase 'qparent::'
   -1: public
   0: secret
   1: secret
   2: secret
 
 Test that qfinish change phase when mq.secret=true
 
   $ hg qfinish qbase
   patch add-file1 finalized without changeset message
   $ hg phase 'all()'
   0: draft
   1: secret
   2: secret
 
 Test that qfinish respect phases.new-commit setting
 
   $ echo '[phases]' >> $HGRCPATH
   $ echo 'new-commit=secret' >> $HGRCPATH
   $ hg qfinish qbase
   patch add-file2 finalized without changeset message
   $ hg phase 'all()'
   0: draft
   1: secret
   2: secret
 
 (restore env for next test)
 
   $ sed -e 's/new-commit=secret//' $HGRCPATH > $TESTTMP/sedtmp
   $ cp $TESTTMP/sedtmp $HGRCPATH
   $ hg qimport -r 1 --name  add-file2
 
 Test that qfinish preserve phase when mq.secret=false
 
   $ sed -e 's/secret=true/secret=false/' $HGRCPATH > $TESTTMP/sedtmp
   $ cp $TESTTMP/sedtmp $HGRCPATH
   $ hg qfinish qbase
   patch add-file2 finalized without changeset message
   $ hg phase 'all()'
   0: draft
   1: secret
   2: secret
 
 Test that secret mq patch does not break hgweb
 
   $ cat > hgweb.cgi <<HGWEB
   > from mercurial import demandimport; demandimport.enable()
   > from mercurial.hgweb import hgweb
   > from mercurial.hgweb import wsgicgi
   > import cgitb
   > cgitb.enable()
   > app = hgweb('.', 'test')
   > wsgicgi.launch(app)
   > HGWEB
   $ . "$TESTDIR/cgienv"
 #if msys
   $ PATH_INFO=//tags; export PATH_INFO
 #else
   $ PATH_INFO=/tags; export PATH_INFO
 #endif
   $ QUERY_STRING='style=raw'
   $ python hgweb.cgi | grep '^tip'
   tip	[0-9a-f]{40} (re)
 
   $ cd ..
 
 Test interaction with revset (issue4426)
 
   $ hg init issue4426
   $ cd issue4426
 
   $ echo a > a
   $ hg ci -Am a
   adding a
   $ echo a >> a
   $ hg ci -m a
   $ echo a >> a
   $ hg ci -m a
   $ hg qimport -r 0::
 
 reimport things
 
   $ hg qimport -r 1::
   abort: revision 2 is already managed
   [255]
 
 
   $ cd ..