mercurial: comparison hgext/mq.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 testedwith = 'ships-with-hg-core'
 configtable = {}
 configitem = registrar.configitem(configtable)
-configitem('mq', 'git',
+configitem(
-default='auto',
+'mq', 'git', default='auto',
 )
-configitem('mq', 'keepchanges',
+configitem(
-default=False,
+'mq', 'keepchanges', default=False,
 )
-configitem('mq', 'plain',
+configitem(
-default=False,
+'mq', 'plain', default=False,
 )
-configitem('mq', 'secret',
+configitem(
-default=False,
+'mq', 'secret', default=False,
 )
 # force load strip extension formerly included in mq and import some utility
 try:
 stripext = extensions.find('strip')
 # 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
 def log(self, event, msgfmt, *msgargs, **opts):
 pass
 stripext = extensions.load(dummyui(), 'strip', '')
 strip = stripext.strip
 def checksubstate(repo, baserev=None):
 '''return list of subrepos at a different revision than substate.
 Abort if any subrepos have uncommitted changes.'''
 inclsubs = []
 wctx.sub(s).bailifchanged(True)
 if s not in bctx.substate or bctx.sub(s).dirty():
 inclsubs.append(s)
 return inclsubs
 # 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 __bytes__(self):
 return hex(self.node) + ':' + self.name
 __str__ = encoding.strmethod(__bytes__)
 __repr__ = encoding.strmethod(__bytes__)
 # 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
+'# 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([], b'# Date ', b'z')
 ... except ValueError as inst: print("oops")
 if lineindex == newindex:
 lines[i] = header + value
 return lines
 if lineindex > newindex:
 bestpos = min(bestpos, i)
-break # next line
+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([], b'Date', b'z')
 ['Date: z']
 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
+if (
-l.startswith("Index:") or
+l.startswith("diff -")
-l.startswith("===========")):
+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:
 nodeid = None
 diffstart = 0
 for line in open(pf, 'rb'):
 line = line.rstrip()
-if (line.startswith('diff --git')
+if line.startswith('diff --git') or (
-or (diffstart and line.startswith('+++ '))):
+diffstart and line.startswith('+++ ')
+):
 diffstart = 2
 break
-diffstart = 0 # reset
+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
+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
+elif format != "tagdone" and (
-line.startswith("subject: "))):
+line.startswith("Subject: ") or line.startswith("subject: ")
+):
 subject = line[9:]
 format = "tag"
-elif (format != "tagdone" and (line.startswith("From: ") or
+elif format != "tagdone" and (
-line.startswith("from: "))):
+line.startswith("From: ") or line.startswith("from: ")
+):
 user = line[6:]
 format = "tag"
-elif (format != "tagdone" and (line.startswith("Date: ") or
+elif format != "tagdone" and (
-line.startswith("date: "))):
+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
 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
+self.plainmode = (
-'# HG changeset patch' not in self.comments and
+plainmode
-any(c.startswith('Date: ') or
+or '# HG changeset patch' not in self.comments
-c.startswith('From: ')
+and any(
-for c in self.comments))
+c.startswith('Date: ') or c.startswith('From: ')
+for c in self.comments
+)
+)
 def setuser(self, user):
 try:
 inserthgheader(self.comments, '# User ', user)
 except ValueError:
 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.
 overrides[('phases', 'new-commit')] = phase
 with repo.ui.configoverride(overrides, 'mq'):
 repo.ui.setconfig('ui', 'allowemptycommit', True)
 return repo.commit(*args, **kwargs)
 class AbortNoCleanup(error.Abort):
 pass
 class queue(object):
 def __init__(self, ui, baseui, path, patchdir=None):
 self.basepath = path
 try:
 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') %
+self.ui.warn(
-stringutil.pprint(entry))
+_('malformated mq status line: %s\n')
+% stringutil.pprint(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:
 self.activeguards = None
 def diffopts(self, opts=None, patchfn=None, plain=False):
 """Return diff options tweaked for this mq use, possibly upgrading to
 git format, and possibly plain and without lossy options."""
-diffopts = patchmod.difffeatureopts(self.ui, opts,
+diffopts = patchmod.difffeatureopts(
-git=True, whitespace=not plain, formatchanging=not plain)
+self.ui,
+opts,
+git=True,
+whitespace=not plain,
+formatchanging=not plain,
+)
 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'
+raise error.Abort(
-' got %s') % self.gitmode)
+_('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):
 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
-diffopts.git = any(line.startswith('diff --git')
+diffopts.git = any(
-for line in patchf)
+line.startswith('diff --git') for line in patchf
+)
 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
 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') %
+raise error.Abort(
-(patch, self.join(self.seriespath)))
+_('%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') %
+return _('guard %r starts with invalid character: %r') % (
-(guard, first))
+guard,
+first,
+)
 for c in bad_chars:
 if c in guard:
 return _('invalid character in guard %r: %r') % (guard, c)
 def setactive(self, guards):
 raise
 guards = []
 for i, guard in enumerate(guards):
 bad = self.checkguard(guard)
 if bad:
-self.ui.warn('%s:%d: %s\n' %
+self.ui.warn(
-(self.join(self.guardspath), i + 1, bad))
+'%s:%d: %s\n' % (self.join(self.guardspath), i + 1, bad)
+)
 else:
 self.activeguards.append(guard)
 return self.activeguards
 def setguards(self, idx, guards):
 idx = self.series.index(idx)
 patchguards = self.seriesguards[idx]
 if not patchguards:
 return True, None
 guards = self.active()
-exactneg = [g for g in patchguards
+exactneg = [
-if g.startswith('-') and g[1:] in guards]
+g for g in patchguards if g.startswith('-') and g[1:] in guards
+]
 if exactneg:
 return False, stringutil.pprint(exactneg[0])
 pos = [g for g in patchguards if g.startswith('+')]
 exactpos = [g for g in pos if g[1:] in guards]
 if pos:
 if isinstance(idx, bytes):
 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') %
+write(
-self.series[idx])
+_('allowing %s - no guards in effect\n')
+% self.series[idx]
+)
 else:
 if not why:
-write(_('allowing %s - no matching negative guards\n') %
+write(
-self.series[idx])
+_('allowing %s - no matching negative guards\n')
+% self.series[idx]
+)
 else:
-write(_('allowing %s - guarded by %s\n') %
+write(
-(self.series[idx], why))
+_('allowing %s - guarded by %s\n')
+% (self.series[idx], why)
+)
 if not pushable:
 if why:
-write(_('skipping %s - guarded by %s\n') %
+write(
-(self.series[idx], why))
+_('skipping %s - guarded by %s\n')
+% (self.series[idx], why)
+)
 else:
-write(_('skipping %s - no matching guards\n') %
+write(
-self.series[idx])
+_('skipping %s - no matching guards\n')
+% self.series[idx]
+)
 def savedirty(self):
 def writelist(items, path):
 fp = self.opener(path, 'wb')
 for i in items:
 fp.write("%s\n" % i)
 fp.close()
 if self.applieddirty:
 writelist(map(bytes, self.applied), self.statuspath)
 self.applieddirty = False
 if self.seriesdirty:
 writelist(self.fullseries, self.seriespath)
 if not os.path.exists(undo):
 return
 try:
 os.unlink(undo)
 except OSError as inst:
-self.ui.warn(_('error removing undo: %s\n') %
+self.ui.warn(
-stringutil.forcebytestr(inst))
+_('error removing undo: %s\n') % stringutil.forcebytestr(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):
 absorig = scmutil.backuppath(self.ui, repo, f)
-self.ui.note(_('saving current version of %s as %s\n') %
+self.ui.note(
-(f, os.path.relpath(absorig)))
+_('saving current version of %s as %s\n')
+% (f, os.path.relpath(absorig))
+)
 if copy:
 util.copyfile(absf, absorig)
 else:
 util.rename(absf, absorig)
-def printdiff(self, repo, diffopts, node1, node2=None, files=None,
+def printdiff(
-fp=None, changes=None, opts=None):
+self,
+repo,
+diffopts,
+node1,
+node2=None,
+files=None,
+fp=None,
+changes=None,
+opts=None,
+):
 if opts is None:
 opts = {}
 stat = opts.get('stat')
 m = scmutil.match(repo[node1], files, opts)
-logcmdutil.diffordiffstat(self.ui, repo, diffopts, node1, node2, m,
+logcmdutil.diffordiffstat(
-changes, stat, fp)
+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,
+(err, n) = self.apply(
-strict=True, merge=rev)
+repo, [patch], update_status=False, strict=True, merge=rev
+)
 if err == 0:
 return (err, n)
 if n is None:
 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,
+fuzz = patchmod.patch(
-files=files, eolmode=None)
+self.ui, repo, patchfile, strip=1, files=files, eolmode=None
+)
 return (True, list(files), fuzz)
 except Exception as inst:
 self.ui.note(stringutil.forcebytestr(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,
+def apply(
-strict=False, patchdir=None, merge=None, all_files=None,
+self,
-tobackup=None, keepchanges=False):
+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,
+ret = self._apply(
-strict, patchdir, merge, all_files=all_files,
+repo,
-tobackup=tobackup, keepchanges=keepchanges)
+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
+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,
+def _apply(
-strict=False, patchdir=None, merge=None, all_files=None,
+self,
-tobackup=None, keepchanges=False):
+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.
 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?"))
+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)
 if all_files and '.hgsubstate' in all_files:
 wctx = repo[None]
 pctx = repo['.']
 overwrite = False
-mergedsubstate = subrepoutil.submerge(repo, pctx, wctx, wctx,
+mergedsubstate = subrepoutil.submerge(
-overwrite)
+repo, pctx, wctx, wctx, overwrite
+)
 files += mergedsubstate.keys()
 match = scmutil.matchfiles(repo, files or [])
 oldtip = repo.changelog.tip()
-n = newcommit(repo, None, message, ph.user, ph.date, match=match,
+n = newcommit(
-force=True)
+repo, None, message, ph.user, ph.date, match=match, force=True
+)
 if repo.changelog.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 "
+self.ui.warn(
-"directory\n"))
+_("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"))
 else:
 unknown.append(p)
 if unknown:
 if numrevs:
-rev  = dict((entry.name, entry.node) for entry in qfinished)
+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')
 with repo.transaction('qfinish') as tr:
 phases.advanceboundary(repo, tr, tphase, qfinished)
 def delete(self, repo, patches, opts):
 if not patches and not opts.get('rev'):
-raise error.Abort(_('qdelete requires at least one revision or '
+raise error.Abort(
-'patch name'))
+_('qdelete requires at least one revision or ' 'patch name')
+)
 realpatches = []
 for patch in patches:
 patch = self.lookup(patch, strict=True)
 info = self.isapplied(patch)
 return None, None
 def putsubstate2changes(self, substatestate, changes):
 for files in changes[:3]:
 if '.hgsubstate' in files:
-return # already listed up
+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
+else:  # modified
 changes[0].append('.hgsubstate')
 def checklocalchanges(self, repo, force=False, refresh=True):
 excsuffix = ''
 if refresh:
 s = repo.status()
 if not force:
 cmdutil.checkunfinished(repo)
 if s.modified or s.added or s.removed or s.deleted:
-_("local changes found") # i18n tool detection
+_("local changes found")  # i18n tool detection
 raise error.Abort(_("local changes found" + excsuffix))
 if checksubstate(repo):
-_("local changed subrepos found") # i18n tool detection
+_("local changed subrepos found")  # i18n tool detection
 raise error.Abort(_("local changed subrepos found" + excsuffix))
 else:
 cmdutil.checkunfinished(repo, skipmerge=True)
 return s
 _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')
+raise error.Abort(
-% name)
+_('"%s" cannot be used as the name of a patch') % name
+)
 if name != name.strip():
 # whitespace is stripped by parseseries()
-raise error.Abort(_('patch name cannot begin or end with '
+raise error.Abort(
-'whitespace'))
+_('patch name cannot begin or end with ' 'whitespace')
+)
 for prefix in ('.hg', '.mq'):
 if name.startswith(prefix):
-raise error.Abort(_('patch name cannot begin with "%s"')
+raise error.Abort(
-% prefix)
+_('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')
+raise error.Abort(
-% pycompat.bytestr(c))
+_('%r cannot be used in the name of a patch')
+% pycompat.bytestr(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')
+raise error.Abort(
-% name)
+_('"%s" already exists as a directory') % name
+)
 else:
 raise error.Abort(_('patch "%s" already exists') % name)
 def makepatchname(self, title, fallbackname):
 """Return a suitable filename for title, adding a suffix to make
 it unique in the existing list"""
 namebase = re.sub(br'[\s\W_]+', b'_', title.lower()).strip(b'_')
-namebase = namebase[:75] # avoid too long name (issue5117)
+namebase = namebase[:75]  # avoid too long name (issue5117)
 if namebase:
 try:
 self.checkreservedname(namebase)
 except error.Abort:
 namebase = fallbackname
 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
+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)
 with repo.wlock():
 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')
+raise error.Abort(
-% (patchfn, encoding.strtolocal(e.strerror)))
+_('cannot write patch "%s": %s')
+% (patchfn, encoding.strtolocal(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,
+editor = cmdutil.getcommiteditor(
-extramsg=extramsg,
+finishdesc=finishdesc,
-editform=editform)
+extramsg=extramsg,
+editform=editform,
+)
 commitmsg = msg
 else:
 commitmsg = msg or defaultmsg
-n = newcommit(repo, None, commitmsg, user, date, match=match,
+n = newcommit(
-force=True, editor=editor)
+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))
 p.write(bytes(ph))
 if commitfiles:
 parent = self.qparents(repo, n)
 if inclsubs:
 self.putsubstate2changes(substatestate, changes)
-chunks = patchmod.diff(repo, node1=parent, node2=n,
+chunks = patchmod.diff(
-changes=changes, opts=diffopts)
+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
+except:  # re-raises
 repo.rollback()
 raise
 except Exception:
 patchpath = self.join(patchfn)
 try:
 if minus >= 0:
 res = partialname(patch[:minus])
 if res:
 i = self.series.index(res)
 try:
-off = int(patch[minus + 1:] or 1)
+off = int(patch[minus + 1 :] or 1)
 except (ValueError, OverflowError):
 pass
 else:
 if i - off >= 0:
 return self.series[i - off]
 if plus >= 0:
 res = partialname(patch[:plus])
 if res:
 i = self.series.index(res)
 try:
-off = int(patch[plus + 1:] or 1)
+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,
+def push(
-all=False, move=False, exact=False, nobackup=False,
+self,
-keepchanges=False):
+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()
 with repo.wlock():
 heads = []
 for hs in repo.branchmap().iterheads():
 # 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(
+self.ui.warn(_('qpush: %s is already at the top\n') % patch)
-_('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)
+_("cannot push to a previous patch: %s") % patch
+)
 else:
 if reason:
 reason = _('guarded by %s') % reason
 else:
 reason = _('no matching guards')
 self.checklocalchanges(repo, refresh=self.applied)
 if exact:
 if keepchanges:
 raise error.Abort(
-_("cannot use --exact and --keep-changes together"))
+_("cannot use --exact and --keep-changes together")
+)
 if move:
-raise error.Abort(_('cannot use --exact and --move '
+raise error.Abort(
-'together'))
+_('cannot use --exact and --move ' 'together')
+)
 if self.applied:
-raise error.Abort(_('cannot push --exact with applied '
+raise error.Abort(
-'patches'))
+_('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)
+_("%s does not have a parent recorded") % root
+)
 if not repo[target] == repo['.']:
 hg.update(repo, target)
 if move:
 if not patch:
 tobackup = set()
 if (not nobackup and force) or keepchanges:
 status = self.checklocalchanges(repo, force=True)
 if keepchanges:
-tobackup.update(status.modified + status.added +
+tobackup.update(
-status.removed + status.deleted)
+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,
+ret = self.apply(
-tobackup=tobackup, keepchanges=keepchanges)
+repo,
+s,
+list,
+all_files=all_files,
+tobackup=tobackup,
+keepchanges=keepchanges,
+)
 except AbortNoCleanup:
 raise
-except: # re-raises
+except:  # re-raises
 self.ui.warn(_('cleaning up working directory...\n'))
-cmdutil.revert(self.ui, repo, repo['.'],
+cmdutil.revert(
-repo.dirstate.parents(), no_backup=True)
+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:
 repo.wvfs.unlinkpath(f, ignoremissing=True)
 self.ui.write(msg % top)
 else:
 self.ui.write(_("now at: %s\n") % top)
 return ret[0]
-def pop(self, repo, patch=None, force=False, update=True, all=False,
+def pop(
-nobackup=False, keepchanges=False):
+self,
+repo,
+patch=None,
+force=False,
+update=True,
+all=False,
+nobackup=False,
+keepchanges=False,
+):
 self.checkkeepchanges(keepchanges, force)
 with repo.wlock():
 if patch:
 # index, rev, patch
 info = self.isapplied(patch)
 if p in rr:
 self.ui.warn(_("qpop: forcing dirstate update\n"))
 update = True
 else:
 parents = [p.node() for p in repo[None].parents()]
-update = any(entry.node in parents
+update = any(
-for entry in self.applied[start:])
+entry.node in parents for entry in self.applied[start:]
+)
 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 +
+tobackup.update(
-s.removed + s.deleted)
+s.modified + s.added + s.removed + s.deleted
+)
 self.applieddirty = True
 end = len(self.applied)
 rev = self.applied[start].node
 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 "
+raise error.Abort(
-"managed by this patch queue"))
+_(
+"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"))
+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)
 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"),
+raise error.Abort(
-hint=_("see 'hg help phases' for details"))
+_("cannot qrefresh public revision"),
+hint=_("see 'hg help phases' for details"),
+)
 cparents = repo.changelog.parents(top)
 patchparent = self.qparents(repo, top)
 inclsubs = checksubstate(repo, patchparent)
 if inclsubs:
 substatestate = repo.dirstate['.hgsubstate']
 ph = patchheader(self.join(patchfn), self.plainmode)
-diffopts = self.diffopts({'git': opts.get('git')}, patchfn,
+diffopts = self.diffopts(
-plain=True)
+{'git': opts.get('git')}, patchfn, plain=True
+)
 if newuser:
 ph.setuser(newuser)
 if newdate:
 ph.setdate(newdate)
 ph.setparent(hex(patchparent))
 # remember the copies between patchparent and qtip
 for dst in aaa:
 src = ctx[dst].copysource()
 if src:
 copies.setdefault(src, []).extend(
-copies.get(dst, []))
+copies.get(dst, [])
+)
 if dst in a:
 copies[src].append(dst)
 # we can't copy a file created by the patch itself
 if dst in copies:
 del copies[dst]
 # 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,
+editor = cmdutil.getcommiteditor(
-extramsg=extramsg,
+finishdesc=finishdesc,
-editform=editform)
+extramsg=extramsg,
+editform=editform,
+)
 message = msg or "\n".join(ph.message)
 elif not msg:
 if not ph.message:
 message = defaultmsg
 else:
 # the old one.
 lock = tr = None
 try:
 lock = repo.lock()
 tr = repo.transaction('mq')
-n = newcommit(repo, oldphase, message, user, ph.date,
+n = newcommit(
-match=match, force=True, editor=editor)
+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,
+chunks = patchmod.diff(
-changes=c, opts=diffopts)
+repo, patchparent, changes=c, opts=diffopts
+)
 comments = bytes(ph)
 if comments:
 patchf.write(comments)
 for chunk in chunks:
 patchf.write(chunk)
 tr.close()
 self.applied.append(statusentry(n, patchfn))
 finally:
 lockmod.release(tr, lock)
-except: # re-raises
+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! '
+self.ui.warn(
-'(revert --all, qpush to recover)\n'))
+_(
+'qrefresh interrupted while patch was popped! '
+'(revert --all, qpush to recover)\n'
+)
+)
 raise
 finally:
 wlock.release()
 self.removeundo(repo)
 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,
+def qseries(
-summary=False):
+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)
 continue
 displayname(pfx, patch, state)
 else:
 msng_list = []
 for root, dirs, files in os.walk(self.path):
-d = root[len(self.path) + 1:]
+d = root[len(self.path) + 1 :]
 for f in files:
 fl = os.path.join(d, f)
-if (fl not in self.series and
+if (
-fl not in (self.statuspath, self.seriespath,
+fl not in self.series
-self.guardspath)
+and fl
-and not fl.startswith('.')):
+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 ''
+pfx = self.ui.verbose and 'D ' or ''
 displayname(pfx, x, 'missing')
 def issaveline(self, l):
 if l.name == '.hg.patches.save.line':
 return True
 ui = self.baseui.copy()
 # copy back attributes set by ui.pager()
 if self.ui.pageractive and not ui.pageractive:
 ui.pageractive = self.ui.pageractive
 # internal config: ui.formatted
-ui.setconfig('ui', 'formatted',
+ui.setconfig(
-self.ui.config('ui', 'formatted'), 'mqpager')
+'ui', 'formatted', self.ui.config('ui', 'formatted'), 'mqpager'
-ui.setconfig('ui', 'interactive',
+)
-self.ui.config('ui', 'interactive'), 'mqpager')
+ui.setconfig(
+'ui',
+'interactive',
+self.ui.config('ui', 'interactive'),
+'mqpager',
+)
 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()
 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") %
+self.ui.warn(
-(short(qpp[0]), short(qpp[1])))
+_("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"))
 """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 pycompat.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:
 p = pname
 else:
 p = ("%d" % self.series.index(pname)) + " " + pname
 return p
-def qimport(self, repo, files, patchname=None, rev=None, existing=None,
+def qimport(
-force=None, git=False):
+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')
+raise error.Abort(
-% patchname)
+_('patch %s is already in the series file') % patchname
+)
 if rev:
 if files:
-raise error.Abort(_('option "-r" not valid when importing '
+raise error.Abort(
-'files'))
+_('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 '
+raise error.Abort(
-'patches'))
+_('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 '
+raise error.Abort(
-'branch') % rev.last())
+_('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')
+raise error.Abort(
-% rev.first())
+_('revision %d is already managed') % rev.first()
+)
 if heads != [self.applied[-1].node]:
-raise error.Abort(_('revision %d is not the parent of '
+raise error.Abort(
-'the queue') % rev.first())
+_('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')
+raise error.Abort(
-% rev.first())
+_('revision %d has unmanaged children') % rev.first()
+)
 lastparent = None
 diffopts = self.diffopts({'git': git})
 with repo.transaction('qimport') as tr:
 for r in rev:
 if not repo[r].mutable():
-raise error.Abort(_('revision %d is not mutable') % r,
+raise error.Abort(
-hint=_("see 'hg help phases' "
+_('revision %d is not mutable') % r,
-'for details'))
+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')
+raise error.Abort(
-% r)
+_('cannot import merge revision %d') % r
+)
 if lastparent and lastparent != r:
-raise error.Abort(_('revision %d is not the parent of '
+raise error.Abort(
-'%d')
+_('revision %d is not the parent of ' '%d')
-% (r, lastparent))
+% (r, lastparent)
+)
 lastparent = p1
 if not patchname:
 patchname = self.makepatchname(
 repo[r].description().split('\n', 1)[0],
-'%d.diff' % r)
+'%d.diff' % r,
+)
 checkseries(patchname)
 self.checkpatchname(patchname, force)
 self.fullseries.insert(0, patchname)
 with self.opener(patchname, "w") as fp:
 self.seriesdirty = True
 for i, filename in enumerate(files):
 if existing:
 if filename == '-':
-raise error.Abort(_('-e is incompatible with import from -')
+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)
+_("patch %s does not exist") % filename
+)
 if patchname:
 self.checkpatchname(patchname, force)
-self.ui.write(_('renaming %s to %s\n')
+self.ui.write(
-% (filename, patchname))
+_('renaming %s to %s\n') % (filename, patchname)
+)
 util.rename(originpath, self.join(patchname))
 else:
 patchname = filename
 else:
 patchname = None
 self.removeundo(repo)
 return imported
 def fixkeepchangesopts(ui, opts):
-if (not ui.configbool('mq', 'keepchanges') or opts.get('force')
+if (
-or opts.get('exact')):
+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')),
+@command(
-('r', 'rev', [],
+"qdelete|qremove|qrm",
-_('stop managing a revision (DEPRECATED)'), _('REV'))],
+[
-_('hg qdelete [-k] [PATCH]...'),
+('k', 'keep', None, _('keep patch file')),
-helpcategory=command.CATEGORY_CHANGE_ORGANIZATION)
+('r', 'rev', [], _('stop managing a revision (DEPRECATED)'), _('REV')),
+],
+_('hg qdelete [-k] [PATCH]...'),
+helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
+)
 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
 q = repo.mq
 q.delete(repo, patches, pycompat.byteskwargs(opts))
 q.savedirty()
 return 0
-@command("qapplied",
-[('1', 'last', None, _('show only the preceding applied patch'))
+@command(
-] + seriesopts,
+"qapplied",
-_('hg qapplied [-1] [-s] [PATCH]'),
+[('1', 'last', None, _('show only the preceding applied patch'))]
-helpcategory=command.CATEGORY_CHANGE_ORGANIZATION)
++ seriesopts,
+_('hg qapplied [-1] [-s] [PATCH]'),
+helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
+)
 def applied(ui, repo, patch=None, **opts):
 """print the patches already applied
 Returns 0 on success."""
 start = end - 2
 end = 1
 else:
 start = 0
-q.qseries(repo, length=end, start=start, status='A',
+q.qseries(
-summary=opts.get('summary'))
+repo, length=end, start=start, status='A', summary=opts.get('summary')
+)
-@command("qunapplied",
-[('1', 'first', None, _('show only the first patch'))] + seriesopts,
+@command(
-_('hg qunapplied [-1] [-s] [PATCH]'),
+"qunapplied",
-helpcategory=command.CATEGORY_CHANGE_ORGANIZATION)
+[('1', 'first', None, _('show only the first patch'))] + seriesopts,
+_('hg qunapplied [-1] [-s] [PATCH]'),
+helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
+)
 def unapplied(ui, repo, patch=None, **opts):
 """print the patches not yet applied
 Returns 0 on success."""
 if opts.get('first'):
 length = 1
 else:
 length = None
-q.qseries(repo, start=start, length=length, status='U',
+q.qseries(
-summary=opts.get('summary'))
+repo,
+start=start,
-@command("qimport",
+length=length,
-[('e', 'existing', None, _('import file in patch directory')),
+status='U',
-('n', 'name', '',
+summary=opts.get('summary'),
-_('name of patch file'), _('NAME')),
+)
-('f', 'force', None, _('overwrite existing files')),
-('r', 'rev', [],
-_('place existing revisions under mq control'), _('REV')),
+@command(
-('g', 'git', None, _('use git extended diff format')),
+"qimport",
-('P', 'push', None, _('qpush after importing'))],
+[
-_('hg qimport [-e] [-n NAME] [-f] [-g] [-P] [-r REV]... [FILE]...'),
+('e', 'existing', None, _('import file in patch directory')),
-helpcategory=command.CATEGORY_IMPORT_EXPORT)
+('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]...'),
+helpcategory=command.CATEGORY_IMPORT_EXPORT,
+)
 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
 hg qimport -e existing-patch -n new-name
 Returns 0 if import succeeded.
 """
 opts = pycompat.byteskwargs(opts)
-with repo.lock(): # cause this may move phase
+with repo.lock():  # cause this may move phase
 q = repo.mq
 try:
 imported = q.qimport(
-repo, filename, patchname=opts.get('name'),
+repo,
-existing=opts.get('existing'), force=opts.get('force'),
+filename,
-rev=opts.get('rev'), git=opts.get('git'))
+patchname=opts.get('name'),
+existing=opts.get('existing'),
+force=opts.get('force'),
+rev=opts.get('rev'),
+git=opts.get('git'),
+)
 finally:
 q.savedirty()
 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
 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'))],
+@command(
-_('hg qinit [-c]'),
+"qinit",
-helpcategory=command.CATEGORY_REPO_CREATION,
+[('c', 'create-repo', None, _('create queue repository'))],
-helpbasic=True)
+_('hg qinit [-c]'),
+helpcategory=command.CATEGORY_REPO_CREATION,
+helpbasic=True,
+)
 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
 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(r'create_repo'))
-@command("qclone",
-[('', 'pull', None, _('use pull protocol to copy metadata')),
+@command(
-('U', 'noupdate', None,
+"qclone",
-_('do not update the new working directories')),
+[
-('', 'uncompressed', None,
+('', 'pull', None, _('use pull protocol to copy metadata')),
-_('use uncompressed transfer (fast over LAN)')),
+('U', 'noupdate', None, _('do not update the new working directories')),
-('p', 'patches', '',
+(
-_('location of source patch repository'), _('REPO')),
+'',
-] + cmdutil.remoteopts,
+'uncompressed',
-_('hg qclone [OPTION]... SOURCE [DEST]'),
+None,
-helpcategory=command.CATEGORY_REPO_CREATION,
+_('use uncompressed transfer (fast over LAN)'),
-norepo=True)
+),
+(
+'p',
+'patches',
+'',
+_('location of source patch repository'),
+_('REPO'),
+),
+]
++ cmdutil.remoteopts,
+_('hg qclone [OPTION]... SOURCE [DEST]'),
+helpcategory=command.CATEGORY_REPO_CREATION,
+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
 would be created by :hg:`init --mq`.
 Return 0 on success.
 '''
 opts = pycompat.byteskwargs(opts)
 def patchdir(repo):
 """compute a patch repo url from a repo object"""
 url = repo.url()
 if url.endswith('/'):
 url = url[:-1]
 else:
 patchespath = patchdir(sr)
 try:
 hg.peer(ui, opts, patchespath)
 except error.RepoError:
-raise error.Abort(_('versioned patch repository not found'
+raise error.Abort(
-' (see init --mq)'))
+_('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
 qbase = sr.lookup('qbase')
 except error.RepoError:
 pass
 ui.note(_('cloning main repository\n'))
-sr, dr = hg.clone(ui, opts, sr.url(), dest,
+sr, dr = hg.clone(
-pull=opts.get('pull'),
+ui,
-revs=destrev,
+opts,
-update=False,
+sr.url(),
-stream=opts.get('uncompressed'))
+dest,
+pull=opts.get('pull'),
+revs=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),
+hg.clone(
-pull=opts.get('pull'), update=not opts.get('noupdate'),
+ui,
-stream=opts.get('uncompressed'))
+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 '
+ui.note(
-'repository\n'))
+_('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],
+@command(
-_('hg qcommit [OPTION]... [FILE]...'),
+"qcommit|qci",
-helpcategory=command.CATEGORY_COMMITTING,
+commands.table["commit|ci"][1],
-inferrepo=True)
+_('hg qcommit [OPTION]... [FILE]...'),
+helpcategory=command.CATEGORY_COMMITTING,
+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')),
+@command(
-] + seriesopts,
+"qseries",
-_('hg qseries [-ms]'),
+[('m', 'missing', None, _('print patches not in series')),] + seriesopts,
-helpcategory=command.CATEGORY_CHANGE_ORGANIZATION)
+_('hg qseries [-ms]'),
+helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
+)
 def series(ui, repo, **opts):
 """print the entire series file
 Returns 0 on success."""
-repo.mq.qseries(repo, missing=opts.get(r'missing'),
+repo.mq.qseries(
-summary=opts.get(r'summary'))
+repo, missing=opts.get(r'missing'), summary=opts.get(r'summary')
+)
 return 0
-@command("qtop", seriesopts, _('hg qtop [-s]'),
-helpcategory=command.CATEGORY_CHANGE_ORGANIZATION)
+@command(
+"qtop",
+seriesopts,
+_('hg qtop [-s]'),
+helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
+)
 def top(ui, repo, **opts):
 """print the name of the current patch
 Returns 0 on success."""
 q = repo.mq
 t = q.seriesend(True)
 else:
 t = 0
 if t:
-q.qseries(repo, start=t - 1, length=1, status='A',
+q.qseries(
-summary=opts.get(r'summary'))
+repo,
+start=t - 1,
+length=1,
+status='A',
+summary=opts.get(r'summary'),
+)
 else:
 ui.write(_("no patches applied\n"))
 return 1
-@command("qnext", seriesopts, _('hg qnext [-s]'),
-helpcategory=command.CATEGORY_CHANGE_ORGANIZATION)
+@command(
+"qnext",
+seriesopts,
+_('hg qnext [-s]'),
+helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
+)
 def next(ui, repo, **opts):
 """print the name of the next pushable patch
 Returns 0 on success."""
 q = repo.mq
 if end == len(q.series):
 ui.write(_("all patches applied\n"))
 return 1
 q.qseries(repo, start=end, length=1, summary=opts.get(r'summary'))
-@command("qprev", seriesopts, _('hg qprev [-s]'),
-helpcategory=command.CATEGORY_CHANGE_ORGANIZATION)
+@command(
+"qprev",
+seriesopts,
+_('hg qprev [-s]'),
+helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
+)
 def prev(ui, repo, **opts):
 """print the name of the preceding applied patch
 Returns 0 on success."""
 q = repo.mq
 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',
+q.qseries(
-summary=opts.get(r'summary'))
+repo, start=idx, length=1, status='A', summary=opts.get(r'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" % dateutil.makedate()
-@command("qnew",
-[('e', 'edit', None, _('invoke editor on commit messages')),
+@command(
-('f', 'force', None, _('import uncommitted changes (DEPRECATED)')),
+"qnew",
-('g', 'git', None, _('use git extended diff format')),
+[
-('U', 'currentuser', None, _('add "From: <current user>" to patch')),
+('e', 'edit', None, _('invoke editor on commit messages')),
-('u', 'user', '',
+('f', 'force', None, _('import uncommitted changes (DEPRECATED)')),
-_('add "From: <USER>" to patch'), _('USER')),
+('g', 'git', None, _('use git extended diff format')),
-('D', 'currentdate', None, _('add "Date: <current date>" to patch')),
+('U', 'currentuser', None, _('add "From: <current user>" to patch')),
-('d', 'date', '',
+('u', 'user', '', _('add "From: <USER>" to patch'), _('USER')),
-_('add "Date: <DATE>" to patch'), _('DATE'))
+('D', 'currentdate', None, _('add "Date: <current date>" to patch')),
-] + cmdutil.walkopts + cmdutil.commitopts,
+('d', 'date', '', _('add "Date: <DATE>" to patch'), _('DATE')),
-_('hg qnew [-e] [-m TEXT] [-l FILE] PATCH [FILE]...'),
+]
-helpcategory=command.CATEGORY_COMMITTING, helpbasic=True,
++ cmdutil.walkopts
-inferrepo=True)
++ cmdutil.commitopts,
+_('hg qnew [-e] [-m TEXT] [-l FILE] PATCH [FILE]...'),
+helpcategory=command.CATEGORY_COMMITTING,
+helpbasic=True,
+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
 setupheaderopts(ui, opts)
 q.new(repo, patch, *args, **pycompat.strkwargs(opts))
 q.savedirty()
 return 0
-@command("qrefresh",
-[('e', 'edit', None, _('invoke editor on commit messages')),
+@command(
-('g', 'git', None, _('use git extended diff format')),
+"qrefresh",
-('s', 'short', None,
+[
-_('refresh only files already in the patch and specified files')),
+('e', 'edit', None, _('invoke editor on commit messages')),
-('U', 'currentuser', None,
+('g', 'git', None, _('use git extended diff format')),
-_('add/update author field in patch with current user')),
+(
-('u', 'user', '',
+'s',
-_('add/update author field in patch with given user'), _('USER')),
+'short',
-('D', 'currentdate', None,
+None,
-_('add/update date field in patch with current date')),
+_('refresh only files already in the patch and specified files'),
-('d', 'date', '',
+),
-_('add/update date field in patch with given date'), _('DATE'))
+(
-] + cmdutil.walkopts + cmdutil.commitopts,
+'U',
-_('hg qrefresh [-I] [-X] [-e] [-m TEXT] [-l FILE] [-s] [FILE]...'),
+'currentuser',
-helpcategory=command.CATEGORY_COMMITTING, helpbasic=True,
+None,
-inferrepo=True)
+_('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'),
+),
+]
++ cmdutil.walkopts
++ cmdutil.commitopts,
+_('hg qrefresh [-I] [-X] [-e] [-m TEXT] [-l FILE] [-s] [FILE]...'),
+helpcategory=command.CATEGORY_COMMITTING,
+helpbasic=True,
+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
 with repo.wlock():
 ret = q.refresh(repo, pats, msg=message, **pycompat.strkwargs(opts))
 q.savedirty()
 return ret
-@command("qdiff",
-cmdutil.diffopts + cmdutil.diffopts2 + cmdutil.walkopts,
+@command(
-_('hg qdiff [OPTION]... [FILE]...'),
+"qdiff",
-helpcategory=command.CATEGORY_FILE_CONTENTS, helpbasic=True,
+cmdutil.diffopts + cmdutil.diffopts2 + cmdutil.walkopts,
-inferrepo=True)
+_('hg qdiff [OPTION]... [FILE]...'),
+helpcategory=command.CATEGORY_FILE_CONTENTS,
+helpbasic=True,
+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
 """
 ui.pager('qdiff')
 repo.mq.diff(repo, pats, pycompat.byteskwargs(opts))
 return 0
-@command('qfold',
-[('e', 'edit', None, _('invoke editor on commit messages')),
+@command(
-('k', 'keep', None, _('keep folded patch files')),
+'qfold',
-] + cmdutil.commitopts,
+[
-_('hg qfold [-e] [-k] [-m TEXT] [-l FILE] PATCH...'),
+('e', 'edit', None, _('invoke editor on commit messages')),
-helpcategory=command.CATEGORY_CHANGE_MANAGEMENT)
+('k', 'keep', None, _('keep folded patch files')),
+]
++ cmdutil.commitopts,
+_('hg qfold [-e] [-k] [-m TEXT] [-l FILE] PATCH...'),
+helpcategory=command.CATEGORY_CHANGE_MANAGEMENT,
+)
 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
 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')
+raise error.Abort(
-% p)
+_('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)
 message.extend(msg)
 message = '\n'.join(message)
 diffopts = q.patchopts(q.diffopts(), *patches)
 with repo.wlock():
-q.refresh(repo, msg=message, git=diffopts.git, edit=opts.get('edit'),
+q.refresh(
-editform='mq.qfold')
+repo,
+msg=message,
+git=diffopts.git,
+edit=opts.get('edit'),
+editform='mq.qfold',
+)
 q.delete(repo, patches, opts)
 q.savedirty()
-@command("qgoto",
-[('', 'keep-changes', None,
+@command(
-_('tolerate non-conflicting local changes')),
+"qgoto",
-('f', 'force', None, _('overwrite any local changes')),
+[
-('', 'no-backup', None, _('do not save backup copies of files'))],
+('', 'keep-changes', None, _('tolerate non-conflicting local changes')),
-_('hg qgoto [OPTION]... PATCH'),
+('f', 'force', None, _('overwrite any local changes')),
-helpcategory=command.CATEGORY_CHANGE_ORGANIZATION)
+('', 'no-backup', None, _('do not save backup copies of files')),
+],
+_('hg qgoto [OPTION]... PATCH'),
+helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
+)
 def goto(ui, repo, patch, **opts):
 '''push or pop patches until named patch is at top of stack
 Returns 0 on success.'''
 opts = pycompat.byteskwargs(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,
+ret = q.pop(
-keepchanges=keepchanges)
+repo,
+patch,
+force=opts.get('force'),
+nobackup=nobackup,
+keepchanges=keepchanges,
+)
 else:
-ret = q.push(repo, patch, force=opts.get('force'), nobackup=nobackup,
+ret = q.push(
-keepchanges=keepchanges)
+repo,
+patch,
+force=opts.get('force'),
+nobackup=nobackup,
+keepchanges=keepchanges,
+)
 q.savedirty()
 return ret
-@command("qguard",
-[('l', 'list', None, _('list all patches and guards')),
+@command(
-('n', 'none', None, _('drop all guards'))],
+"qguard",
-_('hg qguard [-l] [-n] [PATCH] [-- [+GUARD]... [-GUARD]...]'),
+[
-helpcategory=command.CATEGORY_CHANGE_ORGANIZATION)
+('l', 'list', None, _('list all patches and guards')),
+('n', 'none', None, _('drop all guards')),
+],
+_('hg qguard [-l] [-n] [PATCH] [-- [+GUARD]... [-GUARD]...]'),
+helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
+)
 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
 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]:
 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(r'list'):
 if args or opts.get(r'none'):
-raise error.Abort(_('cannot mix -l/--list with options or '
+raise error.Abort(
-'arguments'))
+_('cannot mix -l/--list with options or ' 'arguments')
+)
 for i in pycompat.xrange(len(q.series)):
 status(i)
 return
 if not args or args[0][0:1] in '-+':
 if not q.applied:
 q.setguards(idx, args)
 q.savedirty()
 else:
 status(q.series.index(q.lookup(patch)))
-@command("qheader", [], _('hg qheader [PATCH]'),
-helpcategory=command.CATEGORY_CHANGE_ORGANIZATION)
+@command(
+"qheader",
+[],
+_('hg qheader [PATCH]'),
+helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
+)
 def header(ui, repo, patch=None):
 """print the header of the topmost or specified patch
 Returns 0 on success."""
 q = repo.mq
 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)
 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,
+@command(
-_('tolerate non-conflicting local changes')),
+"qpush",
-('f', 'force', None, _('apply on top of local changes')),
+[
-('e', 'exact', None,
+('', 'keep-changes', None, _('tolerate non-conflicting local changes')),
-_('apply the target patch to its recorded parent')),
+('f', 'force', None, _('apply on top of local changes')),
-('l', 'list', None, _('list patch name in commit text')),
+(
-('a', 'all', None, _('apply all patches')),
+'e',
-('m', 'merge', None, _('merge from another queue (DEPRECATED)')),
+'exact',
-('n', 'name', '',
+None,
-_('merge queue name (DEPRECATED)'), _('NAME')),
+_('apply the target patch to its recorded parent'),
-('', 'move', None,
+),
-_('reorder patch series and apply only the patch')),
+('l', 'list', None, _('list patch name in commit text')),
-('', 'no-backup', None, _('do not save backup copies of files'))],
+('a', 'all', None, _('apply all patches')),
-_('hg qpush [-f] [-l] [-a] [--move] [PATCH | INDEX]'),
+('m', 'merge', None, _('merge from another queue (DEPRECATED)')),
-helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
+('n', 'name', '', _('merge queue name (DEPRECATED)'), _('NAME')),
-helpbasic=True)
+('', '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]'),
+helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
+helpbasic=True,
+)
 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
 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'),
+ret = q.push(
-mergeq=mergeq, all=opts.get('all'), move=opts.get('move'),
+repo,
-exact=opts.get('exact'), nobackup=opts.get('no_backup'),
+patch,
-keepchanges=opts.get('keep_changes'))
+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')),
+@command(
-('n', 'name', '',
+"qpop",
-_('queue name to pop (DEPRECATED)'), _('NAME')),
+[
-('', 'keep-changes', None,
+('a', 'all', None, _('pop all patches')),
-_('tolerate non-conflicting local changes')),
+('n', 'name', '', _('queue name to pop (DEPRECATED)'), _('NAME')),
-('f', 'force', None, _('forget any local changes to patched files')),
+('', 'keep-changes', None, _('tolerate non-conflicting local changes')),
-('', 'no-backup', None, _('do not save backup copies of files'))],
+('f', 'force', None, _('forget any local changes to patched files')),
-_('hg qpop [-a] [-f] [PATCH | INDEX]'),
+('', 'no-backup', None, _('do not save backup copies of files')),
-helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
+],
-helpbasic=True)
+_('hg qpop [-a] [-f] [PATCH | INDEX]'),
+helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
+helpbasic=True,
+)
 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
 q = queue(ui, repo.baseui, repo.path, repo.vfs.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,
+ret = q.pop(
-all=opts.get('all'), nobackup=opts.get('no_backup'),
+repo,
-keepchanges=opts.get('keep_changes'))
+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]'),
-helpcategory=command.CATEGORY_CHANGE_ORGANIZATION)
+@command(
+"qrename|qmv",
+[],
+_('hg qrename PATCH1 [PATCH2]'),
+helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
+)
 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.
 wctx.copy(patch, name)
 wctx.forget([patch])
 q.savedirty()
-@command("qrestore",
-[('d', 'delete', None, _('delete save entry')),
+@command(
-('u', 'update', None, _('update queue working directory'))],
+"qrestore",
-_('hg qrestore [-d] [-u] REV'),
+[
-helpcategory=command.CATEGORY_CHANGE_ORGANIZATION)
+('d', 'delete', None, _('delete save entry')),
+('u', 'update', None, _('update queue working directory')),
+],
+_('hg qrestore [-d] [-u] REV'),
+helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
+)
 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(r'delete'),
+q.restore(
-qupdate=opts.get(r'update'))
+repo, rev, delete=opts.get(r'delete'), qupdate=opts.get(r'update')
+)
 q.savedirty()
 return 0
-@command("qsave",
-[('c', 'copy', None, _('copy patch directory')),
+@command(
-('n', 'name', '',
+"qsave",
-_('copy directory name'), _('NAME')),
+[
-('e', 'empty', None, _('clear queue status file')),
+('c', 'copy', None, _('copy patch directory')),
-('f', 'force', None, _('force copy'))] + cmdutil.commitopts,
+('n', 'name', '', _('copy directory name'), _('NAME')),
-_('hg qsave [-m TEXT] [-l FILE] [-c] [-n NAME] [-e] [-f]'),
+('e', 'empty', None, _('clear queue status file')),
-helpcategory=command.CATEGORY_CHANGE_ORGANIZATION)
+('f', 'force', None, _('force copy')),
+]
++ cmdutil.commitopts,
+_('hg qsave [-m TEXT] [-l FILE] [-c] [-n NAME] [-e] [-f]'),
+helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
+)
 def save(ui, repo, **opts):
 """save current queue state (DEPRECATED)
 This command is deprecated, use :hg:`rebase` instead."""
 q = repo.mq
 opts = pycompat.byteskwargs(opts)
 message = cmdutil.logmessage(ui, opts)
 ret = q.save(repo, msg=message)
 if ret:
 return ret
-q.savedirty() # save to .hg/patches before copying
+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 '
+raise error.Abort(
-'a directory') % newpath)
+_('destination %s exists and is not ' 'a directory')
+% newpath
+)
 if not opts.get('force'):
-raise error.Abort(_('destination %s exists, '
+raise error.Abort(
-'use -f to force') % newpath)
+_('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'):
 q.applieddirty = True
 q.savedirty()
 return 0
-@command("qselect",
+@command(
-[('n', 'none', None, _('disable all guards')),
+"qselect",
-('s', 'series', None, _('list all guards in series file')),
+[
-('', 'pop', None, _('pop to before first guarded applied patch')),
+('n', 'none', None, _('disable all guards')),
-('', 'reapply', None, _('pop, then reapply patches'))],
+('s', 'series', None, _('list all guards in series file')),
-_('hg qselect [OPTION]... [GUARD]...'),
+('', 'pop', None, _('pop to before first guarded applied patch')),
-helpcategory=command.CATEGORY_CHANGE_ORGANIZATION)
+('', 'reapply', None, _('pop, then reapply patches')),
+],
+_('hg qselect [OPTION]... [GUARD]...'),
+helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
+)
 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
 opts = pycompat.byteskwargs(opts)
 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 pycompat.xrange(len(q.applied))
+old_guarded = [
-if not pushable(i)]
+i for i in pycompat.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 pycompat.xrange(len(q.applied))
+guarded = [
-if not pushable(i)]
+i for i in pycompat.xrange(len(q.applied)) if not pushable(i)
+]
 if len(unapplied) != len(old_unapplied):
-ui.status(_('number of unguarded, unapplied patches has '
+ui.status(
-'changed from %d to %d\n') %
+_(
-(len(old_unapplied), len(unapplied)))
+'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 '
+ui.status(
-'from %d to %d\n') %
+_(
-(len(old_guarded), len(guarded)))
+'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:
 ui.status(_('reapplying unguarded patches\n'))
 q.push(repo, reapply)
 finally:
 q.savedirty()
-@command("qfinish",
-[('a', 'applied', None, _('finish all applied changesets'))],
+@command(
-_('hg qfinish [-a] [REV]...'),
+"qfinish",
-helpcategory=command.CATEGORY_CHANGE_ORGANIZATION)
+[('a', 'applied', None, _('finish all applied changesets'))],
+_('hg qfinish [-a] [REV]...'),
+helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
+)
 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
 with repo.lock():
 q.finish(repo, revs)
 q.savedirty()
 return 0
-@command("qqueue",
-[('l', 'list', False, _('list all available queues')),
+@command(
-('', 'active', False, _('print name of active queue')),
+"qqueue",
-('c', 'create', False, _('create new queue')),
+[
-('', 'rename', False, _('rename active queue')),
+('l', 'list', False, _('list all available queues')),
-('', 'delete', False, _('delete reference to queue')),
+('', 'active', False, _('print name of active queue')),
-('', 'purge', False, _('delete queue, and remove patch dir')),
+('c', 'create', False, _('create new queue')),
-],
+('', 'rename', False, _('rename active queue')),
-_('[OPTION] [QUEUE]'),
+('', 'delete', False, _('delete reference to queue')),
-helpcategory=command.CATEGORY_CHANGE_ORGANIZATION)
+('', 'purge', False, _('delete queue, and remove patch dir')),
+],
+_('[OPTION] [QUEUE]'),
+helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
+)
 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.
 return sorted(queues)
 def _setactive(name):
 if q.applied:
-raise error.Abort(_('new queue created, but cannot make active '
+raise error.Abort(
-'as patches are applied'))
+_(
+'new queue created, but cannot make active '
+'as patches are applied'
+)
+)
 _setactivenocheck(name)
 def _setactivenocheck(name):
 fh = repo.vfs(_activequeue, 'w')
 if name != 'patches':
 ui.write('\n')
 return
 if not _validname(name):
 raise error.Abort(
-_('invalid queue name, may not contain the characters ":\\/."'))
+_('invalid queue name, may not contain the characters ":\\/."')
+)
 with repo.wlock():
 existing = _getqueues()
 if opts.get('create'):
 _addqueue(name)
 _setactive(name)
 elif opts.get('rename'):
 current = _getcurrent()
 if name == current:
-raise error.Abort(_('can\'t rename "%s" to its current name')
+raise error.Abort(
-% name)
+_('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') %
+raise error.Abort(
-newdir)
+_('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,))
 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'):
 mqphase = phases.secret
 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)
 parents = self.dirstate.parents()
 patches = [s.node for s in self.mq.applied]
 if any(p in patches for p in parents):
 raise error.Abort(errmsg)
-def commit(self, text="", user=None, date=None, match=None,
+def commit(
-force=False, editor=False, extra=None):
+self,
+text="",
+user=None,
+date=None,
+match=None,
+force=False,
+editor=False,
+extra=None,
+):
 if extra is None:
 extra = {}
 self.abortifwdirpatched(
-_('cannot commit over an applied mq patch'),
+_('cannot commit over an applied mq patch'), force
-force)
+)
-return super(mqrepo, self).commit(text, user, date, match, force,
+return super(mqrepo, self).commit(
-editor, extra)
+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:
 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')
+self.ui.warn(
-% short(mqtags[-1][0]))
+_('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])]
 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 '
+self.ui.warn(
-'name\n') % patch[1])
+_('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')
+if util.safehasattr(repo, 'abortifwdirpatched') and not kwargs.get(
-and not kwargs.get(r'no_commit', False)):
+r'no_commit', False
-repo.abortifwdirpatched(_('cannot import over an applied patch'),
+):
-kwargs.get(r'force'))
+repo.abortifwdirpatched(
+_('cannot import over an applied patch'), kwargs.get(r'force')
+)
 return orig(ui, repo, *args, **kwargs)
 def mqinit(orig, ui, *args, **kwargs):
 mq = kwargs.pop(r'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 '
+raise error.Abort(
-'may be initialized'))
+_('only a local queue repository ' 'may be initialized')
+)
 else:
 repopath = cmdutil.findrepo(encoding.getcwd())
 if not repopath:
-raise error.Abort(_('there is no Mercurial repository here '
+raise error.Abort(
-'(.hg not found)'))
+_('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
 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))
 ui.write(_("mq:     %s\n") % ', '.join(m))
 else:
 # i18n: column positioning for "hg summary"
 ui.note(_("mq:     (empty queue)\n"))
 revsetpredicate = registrar.revsetpredicate()
 @revsetpredicate('mq()')
 def revsetmq(repo, subset, x):
 """Changesets managed by MQ.
 """
 revsetlang.getargs(x, 0, 0, _("mq takes no arguments"))
 applied = {repo[r.node].rev() for r in repo.mq.applied}
 return smartset.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"))]
 for extname, extmodule in extensions.extensions():
 if extmodule.__file__ != __file__:
 dotable(getattr(extmodule, 'cmdtable', {}))
-colortable = {'qguard.negative': 'red',
-'qguard.positive': 'yellow',
+colortable = {
-'qguard.unguarded': 'green',
+'qguard.negative': 'red',
-'qseries.applied': 'blue bold underline',
+'qguard.positive': 'yellow',
-'qseries.guarded': 'black bold',
+'qguard.unguarded': 'green',
-'qseries.missing': 'red bold',
+'qseries.applied': 'blue bold underline',
-'qseries.unapplied': 'black bold'}
+'qseries.guarded': 'black bold',
+'qseries.missing': 'red bold',
+'qseries.unapplied': 'black bold',
+}

changeset 43076	2372284d9457
parent 42597	51e52a495214
child 43077	687b865b95ad