mercurial: comparison hgext/rebase.py

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 # The following constants are used throughout the rebase module. The ordering of
 # their values must be maintained.
 # Indicates that a revision needs to be rebased
 revtodo = -1
-revtodostr = '-1'
+revtodostr = b'-1'
 # legacy revstates no longer needed in current code
 # -2: nullmerge, -3: revignored, -4: revprecursor, -5: revpruned
-legacystates = {'-2', '-3', '-4', '-5'}
+legacystates = {b'-2', b'-3', b'-4', b'-5'}
 cmdtable = {}
 command = registrar.command(cmdtable)
 # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' 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 = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 def _nothingtorebase():
 return 1
 def _savegraft(ctx, extra):
-s = ctx.extra().get('source', None)
+s = ctx.extra().get(b'source', None)
 if s is not None:
-extra['source'] = s
+extra[b'source'] = s
-s = ctx.extra().get('intermediate-source', None)
+s = ctx.extra().get(b'intermediate-source', None)
 if s is not None:
-extra['intermediate-source'] = s
+extra[b'intermediate-source'] = s
 def _savebranch(ctx, extra):
-extra['branch'] = ctx.branch()
+extra[b'branch'] = ctx.branch()
 def _destrebase(repo, sourceset, destspace=None):
 """small wrapper around destmerge to pass the right extra args
 Please wrap destutil.destmerge instead."""
 return destutil.destmerge(
 repo,
-action='rebase',
+action=b'rebase',
 sourceset=sourceset,
 onheadcheck=False,
 destspace=destspace,
 )
 revsetpredicate = registrar.revsetpredicate()
-@revsetpredicate('_destrebase')
+@revsetpredicate(b'_destrebase')
 def _revsetdestrebase(repo, subset, x):
 # ``_rebasedefaultdest()``
 # default destination for rebase.
 # # XXX: Currently private because I expect the signature to change.
 if x is not None:
 sourceset = revset.getset(repo, smartset.fullreposet(repo), x)
 return subset & smartset.baseset([_destrebase(repo, sourceset)])
-@revsetpredicate('_destautoorphanrebase')
+@revsetpredicate(b'_destautoorphanrebase')
 def _revsetdestautoorphanrebase(repo, subset, x):
 # ``_destautoorphanrebase()``
 # automatic rebase destination for a single orphan revision.
 unfi = repo.unfiltered()
-obsoleted = unfi.revs('obsolete()')
+obsoleted = unfi.revs(b'obsolete()')
 src = revset.getset(repo, subset, x).first()
 # Empty src or already obsoleted - Do not return a destination
 if not src or src in obsoleted:
 return smartset.baseset()
 dests = destutil.orphanpossibledestination(repo, src)
 if len(dests) > 1:
 raise error.Abort(
-_("ambiguous automatic rebase: %r could end up on any of %r")
+_(b"ambiguous automatic rebase: %r could end up on any of %r")
 % (src, dests)
 )
 # We have zero or one destination, so we can just return here.
 return smartset.baseset(dests)
 def _ctxdesc(ctx):
 """short description for a context"""
-desc = '%d:%s "%s"' % (ctx.rev(), ctx, ctx.description().split('\n', 1)[0])
+desc = b'%d:%s "%s"' % (
+ctx.rev(),
+ctx,
+ctx.description().split(b'\n', 1)[0],
+)
 repo = ctx.repo()
 names = []
 for nsname, ns in repo.names.iteritems():
-if nsname == 'branches':
+if nsname == b'branches':
 continue
 names.extend(ns.names(repo, ctx.node()))
 if names:
-desc += ' (%s)' % ' '.join(names)
+desc += b' (%s)' % b' '.join(names)
 return desc
 class rebaseruntime(object):
 """This class is a container for rebase runtime state"""
 self.state = {}
 self.activebookmark = None
 self.destmap = {}
 self.skipped = set()
-self.collapsef = opts.get('collapse', False)
+self.collapsef = opts.get(b'collapse', False)
 self.collapsemsg = cmdutil.logmessage(ui, opts)
-self.date = opts.get('date', None)
+self.date = opts.get(b'date', None)
-e = opts.get('extrafn')  # internal, used by e.g. hgsubversion
+e = opts.get(b'extrafn')  # internal, used by e.g. hgsubversion
 self.extrafns = [_savegraft]
 if e:
 self.extrafns = [e]
-self.backupf = ui.configbool('rewrite', 'backup-bundle')
+self.backupf = ui.configbool(b'rewrite', b'backup-bundle')
-self.keepf = opts.get('keep', False)
+self.keepf = opts.get(b'keep', False)
-self.keepbranchesf = opts.get('keepbranches', False)
+self.keepbranchesf = opts.get(b'keepbranches', False)
 self.obsoletenotrebased = {}
 self.obsoletewithoutsuccessorindestination = set()
 self.inmemory = inmemory
-self.stateobj = statemod.cmdstate(repo, 'rebasestate')
+self.stateobj = statemod.cmdstate(repo, b'rebasestate')
 @property
 def repo(self):
 if self.prepared:
 return self._repo.unfiltered()
 def storestatus(self, tr=None):
 """Store the current status to allow recovery"""
 if tr:
 tr.addfilegenerator(
-'rebasestate',
+b'rebasestate',
-('rebasestate',),
+(b'rebasestate',),
 self._writestatus,
-location='plain',
+location=b'plain',
 )
 else:
-with self.repo.vfs("rebasestate", "w") as f:
+with self.repo.vfs(b"rebasestate", b"w") as f:
 self._writestatus(f)
 def _writestatus(self, f):
 repo = self.repo
 assert repo.filtername is None
-f.write(repo[self.originalwd].hex() + '\n')
+f.write(repo[self.originalwd].hex() + b'\n')
 # was "dest". we now write dest per src root below.
-f.write('\n')
+f.write(b'\n')
-f.write(repo[self.external].hex() + '\n')
+f.write(repo[self.external].hex() + b'\n')
-f.write('%d\n' % int(self.collapsef))
+f.write(b'%d\n' % int(self.collapsef))
-f.write('%d\n' % int(self.keepf))
+f.write(b'%d\n' % int(self.keepf))
-f.write('%d\n' % int(self.keepbranchesf))
+f.write(b'%d\n' % int(self.keepbranchesf))
-f.write('%s\n' % (self.activebookmark or ''))
+f.write(b'%s\n' % (self.activebookmark or b''))
 destmap = self.destmap
 for d, v in self.state.iteritems():
 oldrev = repo[d].hex()
 if v >= 0:
 newrev = repo[v].hex()
 else:
-newrev = "%d" % v
+newrev = b"%d" % v
 destnode = repo[destmap[d]].hex()
-f.write("%s:%s:%s\n" % (oldrev, newrev, destnode))
+f.write(b"%s:%s:%s\n" % (oldrev, newrev, destnode))
-repo.ui.debug('rebase status stored\n')
+repo.ui.debug(b'rebase status stored\n')
 def restorestatus(self):
 """Restore a previously stored status"""
 if not self.stateobj.exists():
-cmdutil.wrongtooltocontinue(self.repo, _('rebase'))
+cmdutil.wrongtooltocontinue(self.repo, _(b'rebase'))
 data = self._read()
-self.repo.ui.debug('rebase status resumed\n')
+self.repo.ui.debug(b'rebase status resumed\n')
-self.originalwd = data['originalwd']
+self.originalwd = data[b'originalwd']
-self.destmap = data['destmap']
+self.destmap = data[b'destmap']
-self.state = data['state']
+self.state = data[b'state']
-self.skipped = data['skipped']
+self.skipped = data[b'skipped']
-self.collapsef = data['collapse']
+self.collapsef = data[b'collapse']
-self.keepf = data['keep']
+self.keepf = data[b'keep']
-self.keepbranchesf = data['keepbranches']
+self.keepbranchesf = data[b'keepbranches']
-self.external = data['external']
+self.external = data[b'external']
-self.activebookmark = data['activebookmark']
+self.activebookmark = data[b'activebookmark']
 def _read(self):
 self.prepared = True
 repo = self.repo
 assert repo.filtername is None
 data = {
-'keepbranches': None,
+b'keepbranches': None,
-'collapse': None,
+b'collapse': None,
-'activebookmark': None,
+b'activebookmark': None,
-'external': nullrev,
+b'external': nullrev,
-'keep': None,
+b'keep': None,
-'originalwd': None,
+b'originalwd': None,
 }
 legacydest = None
 state = {}
 destmap = {}
 if True:
-f = repo.vfs("rebasestate")
+f = repo.vfs(b"rebasestate")
 for i, l in enumerate(f.read().splitlines()):
 if i == 0:
-data['originalwd'] = repo[l].rev()
+data[b'originalwd'] = repo[l].rev()
 elif i == 1:
 # this line should be empty in newer version. but legacy
 # clients may still use it
 if l:
 legacydest = repo[l].rev()
 elif i == 2:
-data['external'] = repo[l].rev()
+data[b'external'] = repo[l].rev()
 elif i == 3:
-data['collapse'] = bool(int(l))
+data[b'collapse'] = bool(int(l))
 elif i == 4:
-data['keep'] = bool(int(l))
+data[b'keep'] = bool(int(l))
 elif i == 5:
-data['keepbranches'] = bool(int(l))
+data[b'keepbranches'] = bool(int(l))
-elif i == 6 and not (len(l) == 81 and ':' in l):
+elif i == 6 and not (len(l) == 81 and b':' in l):
 # line 6 is a recent addition, so for backwards
 # compatibility check that the line doesn't look like the
 # oldrev:newrev lines
-data['activebookmark'] = l
+data[b'activebookmark'] = l
 else:
-args = l.split(':')
+args = l.split(b':')
 oldrev = repo[args[0]].rev()
 newrev = args[1]
 if newrev in legacystates:
 continue
 if len(args) > 2:
 state[oldrev] = revtodo
 # Legacy compat special case
 else:
 state[oldrev] = repo[newrev].rev()
-if data['keepbranches'] is None:
+if data[b'keepbranches'] is None:
-raise error.Abort(_('.hg/rebasestate is incomplete'))
+raise error.Abort(_(b'.hg/rebasestate is incomplete'))
-data['destmap'] = destmap
+data[b'destmap'] = destmap
-data['state'] = state
+data[b'state'] = state
 skipped = set()
 # recompute the set of skipped revs
-if not data['collapse']:
+if not data[b'collapse']:
 seen = set(destmap.values())
 for old, new in sorted(state.items()):
 if new != revtodo and new in seen:
 skipped.add(old)
 seen.add(new)
-data['skipped'] = skipped
+data[b'skipped'] = skipped
 repo.ui.debug(
-'computed skipped revs: %s\n'
+b'computed skipped revs: %s\n'
-% (' '.join('%d' % r for r in sorted(skipped)) or '')
+% (b' '.join(b'%d' % r for r in sorted(skipped)) or b'')
 )
 return data
 def _handleskippingobsolete(self, obsoleterevs, destmap):
 obsoleterevs:   iterable of all obsolete revisions in rebaseset
 destmap:        {srcrev: destrev} destination revisions
 """
 self.obsoletenotrebased = {}
-if not self.ui.configbool('experimental', 'rebaseskipobsolete'):
+if not self.ui.configbool(b'experimental', b'rebaseskipobsolete'):
 return
 obsoleteset = set(obsoleterevs)
 (
 self.obsoletenotrebased,
 self.obsoletewithoutsuccessorindestination,
 if isabort:
 clearstatus(self.repo)
 clearcollapsemsg(self.repo)
 self.repo.ui.warn(
 _(
-'rebase aborted (no revision is removed,'
+b'rebase aborted (no revision is removed,'
-' only broken state is cleared)\n'
+b' only broken state is cleared)\n'
 )
 )
 return 0
 else:
-msg = _('cannot continue inconsistent rebase')
+msg = _(b'cannot continue inconsistent rebase')
-hint = _('use "hg rebase --abort" to clear broken state')
+hint = _(b'use "hg rebase --abort" to clear broken state')
 raise error.Abort(msg, hint=hint)
 if isabort:
 backup = backup and self.backupf
 return self._abort(backup=backup, suppwarns=suppwarns)
 return _nothingtorebase()
 rebaseset = destmap.keys()
 allowunstable = obsolete.isenabled(self.repo, obsolete.allowunstableopt)
 if not (self.keepf or allowunstable) and self.repo.revs(
-'first(children(%ld) - %ld)', rebaseset, rebaseset
+b'first(children(%ld) - %ld)', rebaseset, rebaseset
 ):
 raise error.Abort(
 _(
-"can't remove original changesets with"
+b"can't remove original changesets with"
-" unrebased descendants"
+b" unrebased descendants"
 ),
-hint=_('use --keep to keep original changesets'),
+hint=_(b'use --keep to keep original changesets'),
 )
 result = buildstate(self.repo, destmap, self.collapsef)
 if not result:
 # Empty state built, nothing to rebase
-self.ui.status(_('nothing to rebase\n'))
+self.ui.status(_(b'nothing to rebase\n'))
 return _nothingtorebase()
-for root in self.repo.set('roots(%ld)', rebaseset):
+for root in self.repo.set(b'roots(%ld)', rebaseset):
 if not self.keepf and not root.mutable():
 raise error.Abort(
-_("can't rebase public changeset %s") % root,
+_(b"can't rebase public changeset %s") % root,
-hint=_("see 'hg help phases' for details"),
+hint=_(b"see 'hg help phases' for details"),
 )
 (self.originalwd, self.destmap, self.state) = result
 if self.collapsef:
 dests = set(self.destmap.values())
 if len(dests) != 1:
 raise error.Abort(
-_('--collapse does not work with multiple destinations')
+_(b'--collapse does not work with multiple destinations')
 )
 destrev = next(iter(dests))
 destancestors = self.repo.changelog.ancestors(
 [destrev], inclusive=True
 )
 self.external = externalparent(self.repo, self.state, destancestors)
 for destrev in sorted(set(destmap.values())):
 dest = self.repo[destrev]
 if dest.closesbranch() and not self.keepbranchesf:
-self.ui.status(_('reopening closed branch head %s\n') % dest)
+self.ui.status(_(b'reopening closed branch head %s\n') % dest)
 self.prepared = True
 def _assignworkingcopy(self):
 if self.inmemory:
 from mercurial.context import overlayworkingctx
 self.wctx = overlayworkingctx(self.repo)
-self.repo.ui.debug("rebasing in-memory\n")
+self.repo.ui.debug(b"rebasing in-memory\n")
 else:
 self.wctx = self.repo[None]
-self.repo.ui.debug("rebasing on disk\n")
+self.repo.ui.debug(b"rebasing on disk\n")
 self.repo.ui.log(
-"rebase",
+b"rebase",
-"using in-memory rebase: %r\n",
+b"using in-memory rebase: %r\n",
 self.inmemory,
 rebase_imm_used=self.inmemory,
 )
 def _performrebase(self, tr):
 branches = set()
 for rev in self.state:
 branches.add(repo[rev].branch())
 if len(branches) > 1:
 raise error.Abort(
-_('cannot collapse multiple named ' 'branches')
+_(b'cannot collapse multiple named ' b'branches')
 )
 # Calculate self.obsoletenotrebased
 obsrevs = _filterobsoleterevs(self.repo, self.state)
 self._handleskippingobsolete(obsrevs, self.destmap)
 # commits.
 self.storestatus(tr)
 cands = [k for k, v in self.state.iteritems() if v == revtodo]
 p = repo.ui.makeprogress(
-_("rebasing"), unit=_('changesets'), total=len(cands)
+_(b"rebasing"), unit=_(b'changesets'), total=len(cands)
 )
 def progress(ctx):
-p.increment(item=("%d:%s" % (ctx.rev(), ctx)))
+p.increment(item=(b"%d:%s" % (ctx.rev(), ctx)))
 allowdivergence = self.ui.configbool(
-'experimental', 'evolution.allowdivergence'
+b'experimental', b'evolution.allowdivergence'
 )
 for subset in sortsource(self.destmap):
-sortedrevs = self.repo.revs('sort(%ld, -topo)', subset)
+sortedrevs = self.repo.revs(b'sort(%ld, -topo)', subset)
 if not allowdivergence:
 sortedrevs -= self.repo.revs(
-'descendants(%ld) and not %ld',
+b'descendants(%ld) and not %ld',
 self.obsoletewithoutsuccessorindestination,
 self.obsoletewithoutsuccessorindestination,
 )
 for rev in sortedrevs:
 self._rebasenode(tr, rev, allowdivergence, progress)
 p.complete()
-ui.note(_('rebase merging completed\n'))
+ui.note(_(b'rebase merging completed\n'))
 def _concludenode(self, rev, p1, p2, editor, commitmsg=None):
 '''Commit the wd changes with parents p1 and p2.
 Reuse commit info from rev but also store useful information in extra.
 if commitmsg is None:
 commitmsg = ctx.description()
 date = self.date
 if date is None:
 date = ctx.date()
-extra = {'rebase_source': ctx.hex()}
+extra = {b'rebase_source': ctx.hex()}
 for c in self.extrafns:
 c(ctx, extra)
 keepbranch = self.keepbranchesf and repo[p1].branch() != ctx.branch()
 destphase = max(ctx.phase(), phases.draft)
-overrides = {('phases', 'new-commit'): destphase}
+overrides = {(b'phases', b'new-commit'): destphase}
 if keepbranch:
-overrides[('ui', 'allowemptycommit')] = True
+overrides[(b'ui', b'allowemptycommit')] = True
-with repo.ui.configoverride(overrides, 'rebase'):
+with repo.ui.configoverride(overrides, b'rebase'):
 if self.inmemory:
 newnode = commitmemorynode(
 repo,
 p1,
 p2,
 repo, ui, opts = self.repo, self.ui, self.opts
 dest = self.destmap[rev]
 ctx = repo[rev]
 desc = _ctxdesc(ctx)
 if self.state[rev] == rev:
-ui.status(_('already rebased %s\n') % desc)
+ui.status(_(b'already rebased %s\n') % desc)
 elif (
 not allowdivergence
 and rev in self.obsoletewithoutsuccessorindestination
 ):
 msg = (
 _(
-'note: not rebasing %s and its descendants as '
+b'note: not rebasing %s and its descendants as '
-'this would cause divergence\n'
+b'this would cause divergence\n'
 )
 % desc
 )
 repo.ui.status(msg)
 self.skipped.add(rev)
 elif rev in self.obsoletenotrebased:
 succ = self.obsoletenotrebased[rev]
 if succ is None:
 msg = (
-_('note: not rebasing %s, it has no ' 'successor\n') % desc
+_(b'note: not rebasing %s, it has no ' b'successor\n')
+% desc
 )
 else:
 succdesc = _ctxdesc(repo[succ])
 msg = _(
-'note: not rebasing %s, already in ' 'destination as %s\n'
+b'note: not rebasing %s, already in ' b'destination as %s\n'
 ) % (desc, succdesc)
 repo.ui.status(msg)
 # Make clearrebased aware state[rev] is not a true successor
 self.skipped.add(rev)
 # Record rev as moved to its desired destination in self.state.
 dest = max(
 adjustdest(repo, rev, self.destmap, self.state, self.skipped)
 )
 self.state[rev] = dest
 elif self.state[rev] == revtodo:
-ui.status(_('rebasing %s\n') % desc)
+ui.status(_(b'rebasing %s\n') % desc)
 progressfn(ctx)
 p1, p2, base = defineparents(
 repo,
 rev,
 self.destmap,
 self.state,
 self.skipped,
 self.obsoletenotrebased,
 )
 if not self.inmemory and len(repo[None].parents()) == 2:
-repo.ui.debug('resuming interrupted rebase\n')
+repo.ui.debug(b'resuming interrupted rebase\n')
 else:
-overrides = {('ui', 'forcemerge'): opts.get('tool', '')}
+overrides = {(b'ui', b'forcemerge'): opts.get(b'tool', b'')}
-with ui.configoverride(overrides, 'rebase'):
+with ui.configoverride(overrides, b'rebase'):
 stats = rebasenode(
 repo,
 rev,
 p1,
 base,
 if self.inmemory:
 raise error.InMemoryMergeConflictsError()
 else:
 raise error.InterventionRequired(
 _(
-'unresolved conflicts (see hg '
+b'unresolved conflicts (see hg '
-'resolve, then hg rebase --continue)'
+b'resolve, then hg rebase --continue)'
 )
 )
 if not self.collapsef:
 merging = p2 != nullrev
-editform = cmdutil.mergeeditform(merging, 'rebase')
+editform = cmdutil.mergeeditform(merging, b'rebase')
 editor = cmdutil.getcommiteditor(
 editform=editform, **pycompat.strkwargs(opts)
 )
 newnode = self._concludenode(rev, p1, p2, editor)
 else:
 repo.setparents(repo[p1].node())
 newnode = None
 # Update the state
 if newnode is not None:
 self.state[rev] = repo[newnode].rev()
-ui.debug('rebased as %s\n' % short(newnode))
+ui.debug(b'rebased as %s\n' % short(newnode))
 else:
 if not self.collapsef:
 ui.warn(
 _(
-'note: not rebasing %s, its destination already '
+b'note: not rebasing %s, its destination already '
-'has all its changes\n'
+b'has all its changes\n'
 )
 % desc
 )
 self.skipped.add(rev)
 self.state[rev] = p1
-ui.debug('next revision set to %d\n' % p1)
+ui.debug(b'next revision set to %d\n' % p1)
 else:
 ui.status(
-_('already rebased %s as %s\n') % (desc, repo[self.state[rev]])
+_(b'already rebased %s as %s\n') % (desc, repo[self.state[rev]])
 )
 if not tr:
 # When not using single transaction, store state after each
 # commit is completely done. On InterventionRequired, we thus
 # won't store the status. Instead, we'll hit the "len(parents) == 2"
 # case and realize that the commit was in progress.
 self.storestatus()
 def _finishrebase(self):
 repo, ui, opts = self.repo, self.ui, self.opts
-fm = ui.formatter('rebase', opts)
+fm = ui.formatter(b'rebase', opts)
 fm.startitem()
 if self.collapsef:
 p1, p2, _base = defineparents(
 repo,
 min(self.state),
 self.destmap,
 self.state,
 self.skipped,
 self.obsoletenotrebased,
 )
-editopt = opts.get('edit')
+editopt = opts.get(b'edit')
-editform = 'rebase.collapse'
+editform = b'rebase.collapse'
 if self.collapsemsg:
 commitmsg = self.collapsemsg
 else:
-commitmsg = 'Collapsed revision'
+commitmsg = b'Collapsed revision'
 for rebased in sorted(self.state):
 if rebased not in self.skipped:
-commitmsg += '\n* %s' % repo[rebased].description()
+commitmsg += b'\n* %s' % repo[rebased].description()
 editopt = True
 editor = cmdutil.getcommiteditor(edit=editopt, editform=editform)
 revtoreuse = max(self.state)
 newnode = self._concludenode(
 if newnode is not None:
 newrev = repo[newnode].rev()
 for oldrev in self.state:
 self.state[oldrev] = newrev
-if 'qtip' in repo.tags():
+if b'qtip' in repo.tags():
 updatemq(repo, self.state, self.skipped, **pycompat.strkwargs(opts))
 # restore original working directory
 # (we do this before stripping)
 newwd = self.state.get(self.originalwd, self.originalwd)
 if newwd < 0:
 # original directory is a parent of rebase set root or ignored
 newwd = self.originalwd
 if newwd not in [c.rev() for c in repo[None].parents()]:
-ui.note(_("update back to initial working directory parent\n"))
+ui.note(_(b"update back to initial working directory parent\n"))
 hg.updaterepo(repo, newwd, overwrite=False)
 collapsedas = None
 if self.collapsef and not self.keepf:
 collapsedas = newnode
 )
 clearstatus(repo)
 clearcollapsemsg(repo)
-ui.note(_("rebase completed\n"))
+ui.note(_(b"rebase completed\n"))
-util.unlinkpath(repo.sjoin('undo'), ignoremissing=True)
+util.unlinkpath(repo.sjoin(b'undo'), ignoremissing=True)
 if self.skipped:
 skippedlen = len(self.skipped)
-ui.note(_("%d revisions have been skipped\n") % skippedlen)
+ui.note(_(b"%d revisions have been skipped\n") % skippedlen)
 fm.end()
 if (
 self.activebookmark
 and self.activebookmark in repo._bookmarks
-and repo['.'].node() == repo._bookmarks[self.activebookmark]
+and repo[b'.'].node() == repo._bookmarks[self.activebookmark]
 ):
 bookmarks.activate(repo, self.activebookmark)
 def _abort(self, backup=True, suppwarns=False):
 '''Restore the repository to its original state.'''
 ]
 immutable = [d for d in rebased if not repo[d].mutable()]
 cleanup = True
 if immutable:
 repo.ui.warn(
-_("warning: can't clean up public changesets %s\n")
+_(b"warning: can't clean up public changesets %s\n")
-% ', '.join(bytes(repo[r]) for r in immutable),
+% b', '.join(bytes(repo[r]) for r in immutable),
-hint=_("see 'hg help phases' for details"),
+hint=_(b"see 'hg help phases' for details"),
 )
 cleanup = False
 descendants = set()
 if rebased:
 descendants = set(repo.changelog.descendants(rebased))
 if descendants - set(rebased):
 repo.ui.warn(
 _(
-"warning: new changesets detected on "
+b"warning: new changesets detected on "
-"destination branch, can't strip\n"
+b"destination branch, can't strip\n"
 )
 )
 cleanup = False
 if cleanup:
 shouldupdate = False
 if rebased:
 strippoints = [
-c.node() for c in repo.set('roots(%ld)', rebased)
+c.node() for c in repo.set(b'roots(%ld)', rebased)
 ]
 updateifonnodes = set(rebased)
 updateifonnodes.update(self.destmap.values())
 updateifonnodes.add(self.originalwd)
-shouldupdate = repo['.'].rev() in updateifonnodes
+shouldupdate = repo[b'.'].rev() in updateifonnodes
 # Update away from the rebase if necessary
 if shouldupdate or needupdate(repo, self.state):
 mergemod.update(
 repo, self.originalwd, branchmerge=False, force=True
 finally:
 clearstatus(repo)
 clearcollapsemsg(repo)
 if not suppwarns:
-repo.ui.warn(_('rebase aborted\n'))
+repo.ui.warn(_(b'rebase aborted\n'))
 return 0
 @command(
-'rebase',
+b'rebase',
 [
 (
-'s',
+b's',
-'source',
+b'source',
-'',
+b'',
-_('rebase the specified changeset and descendants'),
+_(b'rebase the specified changeset and descendants'),
-_('REV'),
+_(b'REV'),
 ),
 (
-'b',
+b'b',
-'base',
+b'base',
-'',
+b'',
-_('rebase everything from branching point of specified changeset'),
+_(b'rebase everything from branching point of specified changeset'),
-_('REV'),
+_(b'REV'),
 ),
-('r', 'rev', [], _('rebase these revisions'), _('REV')),
+(b'r', b'rev', [], _(b'rebase these revisions'), _(b'REV')),
-('d', 'dest', '', _('rebase onto the specified changeset'), _('REV')),
-('', 'collapse', False, _('collapse the rebased changesets')),
 (
-'m',
+b'd',
-'message',
+b'dest',
-'',
+b'',
-_('use text as collapse commit message'),
+_(b'rebase onto the specified changeset'),
-_('TEXT'),
+_(b'REV'),
 ),
-('e', 'edit', False, _('invoke editor on commit messages')),
+(b'', b'collapse', False, _(b'collapse the rebased changesets')),
 (
-'l',
+b'm',
-'logfile',
+b'message',
-'',
+b'',
-_('read collapse commit message from file'),
+_(b'use text as collapse commit message'),
-_('FILE'),
+_(b'TEXT'),
 ),
-('k', 'keep', False, _('keep original changesets')),
+(b'e', b'edit', False, _(b'invoke editor on commit messages')),
-('', 'keepbranches', False, _('keep original branch names')),
-('D', 'detach', False, _('(DEPRECATED)')),
-('i', 'interactive', False, _('(DEPRECATED)')),
-('t', 'tool', '', _('specify merge tool')),
-('', 'stop', False, _('stop interrupted rebase')),
-('c', 'continue', False, _('continue an interrupted rebase')),
-('a', 'abort', False, _('abort an interrupted rebase')),
 (
-'',
+b'l',
-'auto-orphans',
+b'logfile',
-'',
+b'',
+_(b'read collapse commit message from file'),
+_(b'FILE'),
+),
+(b'k', b'keep', False, _(b'keep original changesets')),
+(b'', b'keepbranches', False, _(b'keep original branch names')),
+(b'D', b'detach', False, _(b'(DEPRECATED)')),
+(b'i', b'interactive', False, _(b'(DEPRECATED)')),
+(b't', b'tool', b'', _(b'specify merge tool')),
+(b'', b'stop', False, _(b'stop interrupted rebase')),
+(b'c', b'continue', False, _(b'continue an interrupted rebase')),
+(b'a', b'abort', False, _(b'abort an interrupted rebase')),
+(
+b'',
+b'auto-orphans',
+b'',
 _(
-'automatically rebase orphan revisions '
+b'automatically rebase orphan revisions '
-'in the specified revset (EXPERIMENTAL)'
+b'in the specified revset (EXPERIMENTAL)'
 ),
 ),
 ]
 + cmdutil.dryrunopts
 + cmdutil.formatteropts
 + cmdutil.confirmopts,
-_('[-s REV | -b REV] [-d REV] [OPTION]'),
+_(b'[-s REV | -b REV] [-d REV] [OPTION]'),
 helpcategory=command.CATEGORY_CHANGE_MANAGEMENT,
 )
 def rebase(ui, repo, **opts):
 """move changeset (and descendants) to a different branch
 Returns 0 on success, 1 if nothing to rebase or there are
 unresolved conflicts.
 """
 opts = pycompat.byteskwargs(opts)
-inmemory = ui.configbool('rebase', 'experimental.inmemory')
+inmemory = ui.configbool(b'rebase', b'experimental.inmemory')
-dryrun = opts.get('dry_run')
+dryrun = opts.get(b'dry_run')
-confirm = opts.get('confirm')
+confirm = opts.get(b'confirm')
-selactions = [k for k in ['abort', 'stop', 'continue'] if opts.get(k)]
+selactions = [k for k in [b'abort', b'stop', b'continue'] if opts.get(k)]
 if len(selactions) > 1:
 raise error.Abort(
-_('cannot use --%s with --%s') % tuple(selactions[:2])
+_(b'cannot use --%s with --%s') % tuple(selactions[:2])
 )
 action = selactions[0] if selactions else None
 if dryrun and action:
-raise error.Abort(_('cannot specify both --dry-run and --%s') % action)
+raise error.Abort(_(b'cannot specify both --dry-run and --%s') % action)
 if confirm and action:
-raise error.Abort(_('cannot specify both --confirm and --%s') % action)
+raise error.Abort(_(b'cannot specify both --confirm and --%s') % action)
 if dryrun and confirm:
-raise error.Abort(_('cannot specify both --confirm and --dry-run'))
+raise error.Abort(_(b'cannot specify both --confirm and --dry-run'))
 if action or repo.currenttransaction() is not None:
 # in-memory rebase is not compatible with resuming rebases.
 # (Or if it is run within a transaction, since the restart logic can
 # fail the entire transaction.)
 inmemory = False
-if opts.get('auto_orphans'):
+if opts.get(b'auto_orphans'):
 for key in opts:
-if key != 'auto_orphans' and opts.get(key):
+if key != b'auto_orphans' and opts.get(key):
 raise error.Abort(
-_('--auto-orphans is incompatible with %s') % ('--' + key)
+_(b'--auto-orphans is incompatible with %s') % (b'--' + key)
 )
-userrevs = list(repo.revs(opts.get('auto_orphans')))
+userrevs = list(repo.revs(opts.get(b'auto_orphans')))
-opts['rev'] = [revsetlang.formatspec('%ld and orphan()', userrevs)]
+opts[b'rev'] = [revsetlang.formatspec(b'%ld and orphan()', userrevs)]
-opts['dest'] = '_destautoorphanrebase(SRC)'
+opts[b'dest'] = b'_destautoorphanrebase(SRC)'
 if dryrun or confirm:
 return _dryrunrebase(ui, repo, action, opts)
-elif action == 'stop':
+elif action == b'stop':
 rbsrt = rebaseruntime(repo, ui)
 with repo.wlock(), repo.lock():
 rbsrt.restorestatus()
 if rbsrt.collapsef:
-raise error.Abort(_("cannot stop in --collapse session"))
+raise error.Abort(_(b"cannot stop in --collapse session"))
 allowunstable = obsolete.isenabled(repo, obsolete.allowunstableopt)
 if not (rbsrt.keepf or allowunstable):
 raise error.Abort(
 _(
-"cannot remove original changesets with"
+b"cannot remove original changesets with"
-" unrebased descendants"
+b" unrebased descendants"
 ),
 hint=_(
-'either enable obsmarkers to allow unstable '
+b'either enable obsmarkers to allow unstable '
-'revisions or use --keep to keep original '
+b'revisions or use --keep to keep original '
-'changesets'
+b'changesets'
 ),
 )
 if needupdate(repo, rbsrt.state):
 # update to the current working revision
 # to clear interrupted merge
 return 0
 elif inmemory:
 try:
 # in-memory merge doesn't support conflicts, so if we hit any, abort
 # and re-run as an on-disk merge.
-overrides = {('rebase', 'singletransaction'): True}
+overrides = {(b'rebase', b'singletransaction'): True}
-with ui.configoverride(overrides, 'rebase'):
+with ui.configoverride(overrides, b'rebase'):
 return _dorebase(ui, repo, action, opts, inmemory=inmemory)
 except error.InMemoryMergeConflictsError:
 ui.warn(
 _(
-'hit merge conflicts; re-running rebase without in-memory'
+b'hit merge conflicts; re-running rebase without in-memory'
-' merge\n'
+b' merge\n'
 )
 )
 # TODO: Make in-memory merge not use the on-disk merge state, so
 # we don't have to clean it here
 mergemod.mergestate.clean(repo)
 return _dorebase(ui, repo, action, opts)
 def _dryrunrebase(ui, repo, action, opts):
 rbsrt = rebaseruntime(repo, ui, inmemory=True, opts=opts)
-confirm = opts.get('confirm')
+confirm = opts.get(b'confirm')
 if confirm:
-ui.status(_('starting in-memory rebase\n'))
+ui.status(_(b'starting in-memory rebase\n'))
 else:
 ui.status(
-_('starting dry-run rebase; repository will not be ' 'changed\n')
+_(b'starting dry-run rebase; repository will not be ' b'changed\n')
 )
 with repo.wlock(), repo.lock():
 needsabort = True
 try:
-overrides = {('rebase', 'singletransaction'): True}
+overrides = {(b'rebase', b'singletransaction'): True}
-with ui.configoverride(overrides, 'rebase'):
+with ui.configoverride(overrides, b'rebase'):
 _origrebase(
 ui,
 repo,
 action,
 opts,
 rbsrt,
 inmemory=True,
 leaveunfinished=True,
 )
 except error.InMemoryMergeConflictsError:
-ui.status(_('hit a merge conflict\n'))
+ui.status(_(b'hit a merge conflict\n'))
 return 1
 except error.Abort:
 needsabort = False
 raise
 else:
 if confirm:
-ui.status(_('rebase completed successfully\n'))
+ui.status(_(b'rebase completed successfully\n'))
 if not ui.promptchoice(
 _(b'apply changes (yn)?' b'$$ &Yes $$ &No')
 ):
 # finish unfinished rebase
 rbsrt._finishrebase()
 )
 needsabort = False
 else:
 ui.status(
 _(
-'dry-run rebase completed successfully; run without'
+b'dry-run rebase completed successfully; run without'
-' -n/--dry-run to perform this rebase\n'
+b' -n/--dry-run to perform this rebase\n'
 )
 )
 return 0
 finally:
 if needsabort:
 def _origrebase(
 ui, repo, action, opts, rbsrt, inmemory=False, leaveunfinished=False
 ):
-assert action != 'stop'
+assert action != b'stop'
 with repo.wlock(), repo.lock():
 # Validate input and define rebasing points
-destf = opts.get('dest', None)
+destf = opts.get(b'dest', None)
-srcf = opts.get('source', None)
+srcf = opts.get(b'source', None)
-basef = opts.get('base', None)
+basef = opts.get(b'base', None)
-revf = opts.get('rev', [])
+revf = opts.get(b'rev', [])
 # search default destination in this space
 # used in the 'hg pull --rebase' case, see issue 5214.
-destspace = opts.get('_destspace')
+destspace = opts.get(b'_destspace')
-if opts.get('interactive'):
+if opts.get(b'interactive'):
 try:
-if extensions.find('histedit'):
+if extensions.find(b'histedit'):
-enablehistedit = ''
+enablehistedit = b''
 except KeyError:
-enablehistedit = " --config extensions.histedit="
+enablehistedit = b" --config extensions.histedit="
-help = "hg%s help -e histedit" % enablehistedit
+help = b"hg%s help -e histedit" % enablehistedit
 msg = (
 _(
-"interactive history editing is supported by the "
+b"interactive history editing is supported by the "
-"'histedit' extension (see \"%s\")"
+b"'histedit' extension (see \"%s\")"
 )
 % help
 )
 raise error.Abort(msg)
 if rbsrt.collapsemsg and not rbsrt.collapsef:
-raise error.Abort(_('message can only be specified with collapse'))
+raise error.Abort(_(b'message can only be specified with collapse'))
 if action:
 if rbsrt.collapsef:
 raise error.Abort(
-_('cannot use collapse with continue or abort')
+_(b'cannot use collapse with continue or abort')
 )
 if srcf or basef or destf:
 raise error.Abort(
-_('abort and continue do not allow specifying revisions')
+_(b'abort and continue do not allow specifying revisions')
 )
-if action == 'abort' and opts.get('tool', False):
+if action == b'abort' and opts.get(b'tool', False):
-ui.warn(_('tool option will be ignored\n'))
+ui.warn(_(b'tool option will be ignored\n'))
-if action == 'continue':
+if action == b'continue':
 ms = mergemod.mergestate.read(repo)
 mergeutil.checkunresolved(ms)
-retcode = rbsrt._prepareabortorcontinue(isabort=(action == 'abort'))
+retcode = rbsrt._prepareabortorcontinue(
+isabort=(action == b'abort')
+)
 if retcode is not None:
 return retcode
 else:
 destmap = _definedestmap(
 ui,
 return retcode
 storecollapsemsg(repo, rbsrt.collapsemsg)
 tr = None
-singletr = ui.configbool('rebase', 'singletransaction')
+singletr = ui.configbool(b'rebase', b'singletransaction')
 if singletr:
-tr = repo.transaction('rebase')
+tr = repo.transaction(b'rebase')
 # If `rebase.singletransaction` is enabled, wrap the entire operation in
 # one transaction here. Otherwise, transactions are obtained when
 # committing each node, which is slower but allows partial success.
 with util.acceptintervention(tr):
 # Same logic for the dirstate guard, except we don't create one when
 # rebasing in-memory (it's not needed).
 dsguard = None
 if singletr and not inmemory:
-dsguard = dirstateguard.dirstateguard(repo, 'rebase')
+dsguard = dirstateguard.dirstateguard(repo, b'rebase')
 with util.acceptintervention(dsguard):
 rbsrt._performrebase(tr)
 if not leaveunfinished:
 rbsrt._finishrebase()
 revf = []
 # destspace is here to work around issues with `hg pull --rebase` see
 # issue5214 for details
 if srcf and basef:
-raise error.Abort(_('cannot specify both a source and a base'))
+raise error.Abort(_(b'cannot specify both a source and a base'))
 if revf and basef:
-raise error.Abort(_('cannot specify both a revision and a base'))
+raise error.Abort(_(b'cannot specify both a revision and a base'))
 if revf and srcf:
-raise error.Abort(_('cannot specify both a revision and a source'))
+raise error.Abort(_(b'cannot specify both a revision and a source'))
 if not inmemory:
 cmdutil.checkunfinished(repo)
 cmdutil.bailifchanged(repo)
-if ui.configbool('commands', 'rebase.requiredest') and not destf:
+if ui.configbool(b'commands', b'rebase.requiredest') and not destf:
 raise error.Abort(
-_('you must specify a destination'), hint=_('use: hg rebase -d REV')
+_(b'you must specify a destination'),
+hint=_(b'use: hg rebase -d REV'),
 )
 dest = None
 if revf:
 rebaseset = scmutil.revrange(repo, revf)
 if not rebaseset:
-ui.status(_('empty "rev" revision set - nothing to rebase\n'))
+ui.status(_(b'empty "rev" revision set - nothing to rebase\n'))
 return None
 elif srcf:
 src = scmutil.revrange(repo, [srcf])
 if not src:
-ui.status(_('empty "source" revision set - nothing to rebase\n'))
+ui.status(_(b'empty "source" revision set - nothing to rebase\n'))
 return None
-rebaseset = repo.revs('(%ld)::', src)
+rebaseset = repo.revs(b'(%ld)::', src)
 assert rebaseset
 else:
-base = scmutil.revrange(repo, [basef or '.'])
+base = scmutil.revrange(repo, [basef or b'.'])
 if not base:
 ui.status(
-_('empty "base" revision set - ' "can't compute rebase set\n")
+_(b'empty "base" revision set - ' b"can't compute rebase set\n")
 )
 return None
 if destf:
 # --base does not support multiple destinations
 dest = scmutil.revsingle(repo, destf)
 destf = bytes(dest)
 roots = []  # selected children of branching points
 bpbase = {}  # {branchingpoint: [origbase]}
 for b in base:  # group bases by branching points
-bp = repo.revs('ancestor(%d, %d)', b, dest.rev()).first()
+bp = repo.revs(b'ancestor(%d, %d)', b, dest.rev()).first()
 bpbase[bp] = bpbase.get(bp, []) + [b]
 if None in bpbase:
 # emulate the old behavior, showing "nothing to rebase" (a better
 # behavior may be abort with "cannot find branching point" error)
 bpbase.clear()
 for bp, bs in bpbase.iteritems():  # calculate roots
-roots += list(repo.revs('children(%d) & ancestors(%ld)', bp, bs))
+roots += list(repo.revs(b'children(%d) & ancestors(%ld)', bp, bs))
-rebaseset = repo.revs('%ld::', roots)
+rebaseset = repo.revs(b'%ld::', roots)
 if not rebaseset:
 # transform to list because smartsets are not comparable to
 # lists. This should be improved to honor laziness of
 # smartset.
 if list(base) == [dest.rev()]:
 if basef:
 ui.status(
 _(
-'nothing to rebase - %s is both "base"'
+b'nothing to rebase - %s is both "base"'
-' and destination\n'
+b' and destination\n'
 )
 % dest
 )
 else:
 ui.status(
 _(
-'nothing to rebase - working directory '
+b'nothing to rebase - working directory '
-'parent is also destination\n'
+b'parent is also destination\n'
 )
 )
-elif not repo.revs('%ld - ::%d', base, dest.rev()):
+elif not repo.revs(b'%ld - ::%d', base, dest.rev()):
 if basef:
 ui.status(
 _(
-'nothing to rebase - "base" %s is '
+b'nothing to rebase - "base" %s is '
-'already an ancestor of destination '
+b'already an ancestor of destination '
-'%s\n'
+b'%s\n'
 )
-% ('+'.join(bytes(repo[r]) for r in base), dest)
+% (b'+'.join(bytes(repo[r]) for r in base), dest)
 )
 else:
 ui.status(
 _(
-'nothing to rebase - working '
+b'nothing to rebase - working '
-'directory parent is already an '
+b'directory parent is already an '
-'ancestor of destination %s\n'
+b'ancestor of destination %s\n'
 )
 % dest
 )
 else:  # can it happen?
 ui.status(
-_('nothing to rebase from %s to %s\n')
+_(b'nothing to rebase from %s to %s\n')
-% ('+'.join(bytes(repo[r]) for r in base), dest)
+% (b'+'.join(bytes(repo[r]) for r in base), dest)
 )
 return None
-rebasingwcp = repo['.'].rev() in rebaseset
+rebasingwcp = repo[b'.'].rev() in rebaseset
 ui.log(
-"rebase",
+b"rebase",
-"rebasing working copy parent: %r\n",
+b"rebasing working copy parent: %r\n",
 rebasingwcp,
 rebase_rebasing_wcp=rebasingwcp,
 )
 if inmemory and rebasingwcp:
 # Check these since we did not before.
 if not destf:
 dest = repo[_destrebase(repo, rebaseset, destspace=destspace)]
 destf = bytes(dest)
-allsrc = revsetlang.formatspec('%ld', rebaseset)
+allsrc = revsetlang.formatspec(b'%ld', rebaseset)
-alias = {'ALLSRC': allsrc}
+alias = {b'ALLSRC': allsrc}
 if dest is None:
 try:
 # fast path: try to resolve dest without SRC alias
 dest = scmutil.revsingle(repo, destf, localalias=alias)
 except error.RepoLookupError:
 # multi-dest path: resolve dest for each SRC separately
 destmap = {}
 for r in rebaseset:
-alias['SRC'] = revsetlang.formatspec('%d', r)
+alias[b'SRC'] = revsetlang.formatspec(b'%d', r)
 # use repo.anyrevs instead of scmutil.revsingle because we
 # don't want to abort if destset is empty.
 destset = repo.anyrevs([destf], user=True, localalias=alias)
 size = len(destset)
 if size == 1:
 destmap[r] = destset.first()
 elif size == 0:
-ui.note(_('skipping %s - empty destination\n') % repo[r])
+ui.note(_(b'skipping %s - empty destination\n') % repo[r])
 else:
 raise error.Abort(
-_('rebase destination for %s is not ' 'unique')
+_(b'rebase destination for %s is not ' b'unique')
 % repo[r]
 )
 if dest is not None:
 # single-dest case: assign dest to each rev in rebaseset
 destrev = dest.rev()
 destmap = {r: destrev for r in rebaseset}  # {srcrev: destrev}
 if not destmap:
-ui.status(_('nothing to rebase - empty destination\n'))
+ui.status(_(b'nothing to rebase - empty destination\n'))
 return None
 return destmap
 return nullrev
 if len(parents) == 1:
 return parents.pop()
 raise error.Abort(
 _(
-'unable to collapse on top of %d, there is more '
+b'unable to collapse on top of %d, there is more '
-'than one external parent: %s'
+b'than one external parent: %s'
 )
-% (max(destancestors), ', '.join("%d" % p for p in sorted(parents)))
+% (max(destancestors), b', '.join(b"%d" % p for p in sorted(parents)))
 )
 def commitmemorynode(repo, p1, p2, wctx, editor, extra, user, date, commitmsg):
 '''Commit the memory changes with parents p1 and p2.
 Return node of committed revision.'''
 # Replicates the empty check in ``repo.commit``.
-if wctx.isempty() and not repo.ui.configbool('ui', 'allowemptycommit'):
+if wctx.isempty() and not repo.ui.configbool(b'ui', b'allowemptycommit'):
 return None
 # By convention, ``extra['branch']`` (set by extrafn) clobbers
 # ``branch`` (used when passing ``--keepbranches``).
 branch = repo[p1].branch()
-if 'branch' in extra:
+if b'branch' in extra:
-branch = extra['branch']
+branch = extra[b'branch']
 memctx = wctx.tomemctx(
 commitmsg,
 parents=(p1, p2),
 date=date,
 def commitnode(repo, p1, p2, editor, extra, user, date, commitmsg):
 '''Commit the wd changes with parents p1 and p2.
 Return node of committed revision.'''
 dsguard = util.nullcontextmanager()
-if not repo.ui.configbool('rebase', 'singletransaction'):
+if not repo.ui.configbool(b'rebase', b'singletransaction'):
-dsguard = dirstateguard.dirstateguard(repo, 'rebase')
+dsguard = dirstateguard.dirstateguard(repo, b'rebase')
 with dsguard:
 repo.setparents(repo[p1].node(), repo[p2].node())
 # Commit might fail if unresolved files exist
 newnode = repo.commit(
 repo.dirstate.setbranch(repo[newnode].branch())
 return newnode
 def rebasenode(repo, rev, p1, base, collapse, dest, wctx):
-'Rebase a single revision rev on top of p1 using base as merge ancestor'
+b'Rebase a single revision rev on top of p1 using base as merge ancestor'
 # Merge phase
 # Update to destination and merge it with local
 if wctx.isinmemory():
 wctx.setbase(repo[p1])
 else:
-if repo['.'].rev() != p1:
+if repo[b'.'].rev() != p1:
-repo.ui.debug(" update to %d:%s\n" % (p1, repo[p1]))
+repo.ui.debug(b" update to %d:%s\n" % (p1, repo[p1]))
 mergemod.update(repo, p1, branchmerge=False, force=True)
 else:
-repo.ui.debug(" already in destination\n")
+repo.ui.debug(b" already in destination\n")
 # This is, alas, necessary to invalidate workingctx's manifest cache,
 # as well as other data we litter on it in other places.
 wctx = repo[None]
 repo.dirstate.write(repo.currenttransaction())
-repo.ui.debug(" merge against %d:%s\n" % (rev, repo[rev]))
+repo.ui.debug(b" merge against %d:%s\n" % (rev, repo[rev]))
 if base is not None:
-repo.ui.debug("   detach base %d:%s\n" % (base, repo[base]))
+repo.ui.debug(b"   detach base %d:%s\n" % (base, repo[base]))
 # When collapsing in-place, the parent is the common ancestor, we
 # have to allow merging with it.
 stats = mergemod.update(
 repo,
 rev,
 branchmerge=True,
 force=True,
 ancestor=base,
 mergeancestor=collapse,
-labels=['dest', 'source'],
+labels=[b'dest', b'source'],
 wc=wctx,
 )
 if collapse:
 copies.duplicatecopies(repo, wctx, rev, dest)
 else:
 result = []
 for prev in repo.changelog.parentrevs(rev):
 adjusted = dest
 if prev != nullrev:
-candidate = repo.revs('max(%ld and (::%d))', source, prev).first()
+candidate = repo.revs(b'max(%ld and (::%d))', source, prev).first()
 if candidate is not None:
 adjusted = state[candidate]
 if adjusted == dest and dest in state:
 adjusted = state[dest]
 if adjusted == revtodo:
 # sortsource should produce an order that makes this impossible
 raise error.ProgrammingError(
-'rev %d should be rebased already at this time' % dest
+b'rev %d should be rebased already at this time' % dest
 )
 result.append(adjusted)
 return result
 `rebaseobsrevs`: set of obsolete revision in source
 `rebaseobsskipped`: set of revisions from source skipped because they have
 successors in destination or no non-obsolete successor.
 """
 # Obsolete node with successors not in dest leads to divergence
-divergenceok = ui.configbool('experimental', 'evolution.allowdivergence')
+divergenceok = ui.configbool(b'experimental', b'evolution.allowdivergence')
 divergencebasecandidates = rebaseobsrevs - rebaseobsskipped
 if divergencebasecandidates and not divergenceok:
 divhashes = (bytes(repo[r]) for r in divergencebasecandidates)
-msg = _("this rebase will cause " "divergences from: %s")
+msg = _(b"this rebase will cause " b"divergences from: %s")
 h = _(
-"to force the rebase please set "
+b"to force the rebase please set "
-"experimental.evolution.allowdivergence=True"
+b"experimental.evolution.allowdivergence=True"
 )
-raise error.Abort(msg % (",".join(divhashes),), hint=h)
+raise error.Abort(msg % (b",".join(divhashes),), hint=h)
 def successorrevs(unfi, rev):
 """yield revision numbers for successors of rev"""
 assert unfi.filtername is None
 #    /|    # None of A and B will be changed to D and rebase fails.
 #   A B D
 if set(newps) == set(oldps) and dest not in newps:
 raise error.Abort(
 _(
-'cannot rebase %d:%s without '
+b'cannot rebase %d:%s without '
-'moving at least one of its parents'
+b'moving at least one of its parents'
 )
 % (rev, repo[rev])
 )
 # Source should not be ancestor of dest. The check here guarantees it's
 # impossible. With multi-dest, the initial check does not cover complex
 # cases since we don't have abstractions to dry-run rebase cheaply.
 if any(p != nullrev and isancestor(rev, p) for p in newps):
-raise error.Abort(_('source is ancestor of destination'))
+raise error.Abort(_(b'source is ancestor of destination'))
 # "rebasenode" updates to new p1, use the corresponding merge base.
 if bases[0] != nullrev:
 base = bases[0]
 else:
 if base == nullrev:
 continue
 # Revisions in the side (not chosen as merge base) branch that
 # might contain "surprising" contents
 siderevs = list(
-repo.revs('((%ld-%d) %% (%d+%d))', bases, base, base, dest)
+repo.revs(b'((%ld-%d) %% (%d+%d))', bases, base, base, dest)
 )
 # If those revisions are covered by rebaseset, the result is good.
 # A merge in rebaseset would be considered to cover its ancestors.
 if siderevs:
 merges = [
 r for r in rebaseset if cl.parentrevs(r)[1] != nullrev
 ]
 unwanted[i] = list(
 repo.revs(
-'%ld - (::%ld) - %ld', siderevs, merges, rebaseset
+b'%ld - (::%ld) - %ld', siderevs, merges, rebaseset
 )
 )
 # Choose a merge base that has a minimal number of unwanted revs.
 l, i = min(
 newps[0], newps[i] = newps[i], newps[0]
 # The merge will include unwanted revisions. Abort now. Revisit this if
 # we have a more advanced merge algorithm that handles multiple bases.
 if l > 0:
-unwanteddesc = _(' or ').join(
+unwanteddesc = _(b' or ').join(
 (
-', '.join('%d:%s' % (r, repo[r]) for r in revs)
+b', '.join(b'%d:%s' % (r, repo[r]) for r in revs)
 for revs in unwanted
 if revs is not None
 )
 )
 raise error.Abort(
-_('rebasing %d:%s will include unwanted changes from %s')
+_(b'rebasing %d:%s will include unwanted changes from %s')
 % (rev, repo[rev], unwanteddesc)
 )
-repo.ui.debug(" future parents are %d and %d\n" % tuple(newps))
+repo.ui.debug(b" future parents are %d and %d\n" % tuple(newps))
 return newps[0], newps[1], base
 def isagitpatch(repo, patchname):
-'Return true if the given patch is in git format'
+b'Return true if the given patch is in git format'
 mqpatch = os.path.join(repo.mq.path, patchname)
-for line in patch.linereader(open(mqpatch, 'rb')):
+for line in patch.linereader(open(mqpatch, b'rb')):
-if line.startswith('diff --git'):
+if line.startswith(b'diff --git'):
 return True
 return False
 def updatemq(repo, state, skipped, **opts):
-'Update rebased mq patches - finalize and then import them'
+b'Update rebased mq patches - finalize and then import them'
 mqrebase = {}
 mq = repo.mq
 original_series = mq.fullseries[:]
 skippedpatches = set()
 for p in mq.applied:
 rev = repo[p.node].rev()
 if rev in state:
 repo.ui.debug(
-'revision %d is an mq patch (%s), finalize it.\n'
+b'revision %d is an mq patch (%s), finalize it.\n'
 % (rev, p.name)
 )
 mqrebase[rev] = (p.name, isagitpatch(repo, p.name))
 else:
 # Applied but not rebased, not sure this should happen
 # We must start import from the newest revision
 for rev in sorted(mqrebase, reverse=True):
 if rev not in skipped:
 name, isgit = mqrebase[rev]
 repo.ui.note(
-_('updating mq patch %s to %d:%s\n')
+_(b'updating mq patch %s to %d:%s\n')
 % (name, state[rev], repo[state[rev]])
 )
 mq.qimport(
-repo, (), patchname=name, git=isgit, rev=["%d" % state[rev]]
+repo,
+(),
+patchname=name,
+git=isgit,
+rev=[b"%d" % state[rev]],
 )
 else:
 # Rebased and skipped
 skippedpatches.add(mqrebase[rev][0])
 mq.seriesdirty = True
 mq.savedirty()
 def storecollapsemsg(repo, collapsemsg):
-'Store the collapse message to allow recovery'
+b'Store the collapse message to allow recovery'
-collapsemsg = collapsemsg or ''
+collapsemsg = collapsemsg or b''
-f = repo.vfs("last-message.txt", "w")
+f = repo.vfs(b"last-message.txt", b"w")
-f.write("%s\n" % collapsemsg)
+f.write(b"%s\n" % collapsemsg)
 f.close()
 def clearcollapsemsg(repo):
-'Remove collapse message file'
+b'Remove collapse message file'
-repo.vfs.unlinkpath("last-message.txt", ignoremissing=True)
+repo.vfs.unlinkpath(b"last-message.txt", ignoremissing=True)
 def restorecollapsemsg(repo, isabort):
-'Restore previously stored collapse message'
+b'Restore previously stored collapse message'
 try:
-f = repo.vfs("last-message.txt")
+f = repo.vfs(b"last-message.txt")
 collapsemsg = f.readline().strip()
 f.close()
 except IOError as err:
 if err.errno != errno.ENOENT:
 raise
 if isabort:
 # Oh well, just abort like normal
-collapsemsg = ''
+collapsemsg = b''
 else:
-raise error.Abort(_('missing .hg/last-message.txt for rebase'))
+raise error.Abort(_(b'missing .hg/last-message.txt for rebase'))
 return collapsemsg
 def clearstatus(repo):
-'Remove the status files'
+b'Remove the status files'
 # Make sure the active transaction won't write the state file
 tr = repo.currenttransaction()
 if tr:
-tr.removefilegenerator('rebasestate')
+tr.removefilegenerator(b'rebasestate')
-repo.vfs.unlinkpath("rebasestate", ignoremissing=True)
+repo.vfs.unlinkpath(b"rebasestate", ignoremissing=True)
 def needupdate(repo, state):
 '''check whether we should `update --clean` away from a merge, or if
 somehow the working dir got forcibly updated, e.g. by older hg'''
 result = []
 for r in srclist:
 if destmap[r] not in srcset:
 result.append(r)
 if not result:
-raise error.Abort(_('source and destination form a cycle'))
+raise error.Abort(_(b'source and destination form a cycle'))
 srcset -= set(result)
 yield result
 def buildstate(repo, destmap, collapse):
 repo: repo
 destmap: {srcrev: destrev}
 '''
 rebaseset = destmap.keys()
-originalwd = repo['.'].rev()
+originalwd = repo[b'.'].rev()
 # This check isn't strictly necessary, since mq detects commits over an
 # applied patch. But it prevents messing up the working directory when
 # a partially completed rebase is blocked by mq.
-if 'qtip' in repo.tags():
+if b'qtip' in repo.tags():
 mqapplied = set(repo[s.node].rev() for s in repo.mq.applied)
 if set(destmap.values()) & mqapplied:
-raise error.Abort(_('cannot rebase onto an applied mq patch'))
+raise error.Abort(_(b'cannot rebase onto an applied mq patch'))
 # Get "cycle" error early by exhausting the generator.
 sortedsrc = list(sortsource(destmap))  # a list of sorted revs
 if not sortedsrc:
-raise error.Abort(_('no matching revisions'))
+raise error.Abort(_(b'no matching revisions'))
 # Only check the first batch of revisions to rebase not depending on other
 # rebaseset. This means "source is ancestor of destination" for the second
 # (and following) batches of revisions are not checked here. We rely on
 # "defineparents" to do that check.
-roots = list(repo.set('roots(%ld)', sortedsrc[0]))
+roots = list(repo.set(b'roots(%ld)', sortedsrc[0]))
 if not roots:
-raise error.Abort(_('no matching revisions'))
+raise error.Abort(_(b'no matching revisions'))
 def revof(r):
 return r.rev()
 roots = sorted(roots, key=revof)
 emptyrebase = len(sortedsrc) == 1
 for root in roots:
 dest = repo[destmap[root.rev()]]
 commonbase = root.ancestor(dest)
 if commonbase == root:
-raise error.Abort(_('source is ancestor of destination'))
+raise error.Abort(_(b'source is ancestor of destination'))
 if commonbase == dest:
 wctx = repo[None]
 if dest == wctx.p1():
 # when rebasing to '.', it will use the current wd branch name
 samebranch = root.branch() == wctx.branch()
 samebranch = root.branch() == dest.branch()
 if not collapse and samebranch and dest in root.parents():
 # mark the revision as done by setting its new revision
 # equal to its old (current) revisions
 state[root.rev()] = root.rev()
-repo.ui.debug('source is a child of destination\n')
+repo.ui.debug(b'source is a child of destination\n')
 continue
 emptyrebase = False
-repo.ui.debug('rebase onto %s starting from %s\n' % (dest, root))
+repo.ui.debug(b'rebase onto %s starting from %s\n' % (dest, root))
 if emptyrebase:
 return None
 for rev in sorted(state):
 parents = [p for p in repo.changelog.parentrevs(rev) if p != nullrev]
 # if all parents of this revision are done, then so is this revision
 fl = fm.formatlist
 fd = fm.formatdict
 changes = {}
 for oldns, newn in replacements.iteritems():
 for oldn in oldns:
-changes[hf(oldn)] = fl([hf(n) for n in newn], name='node')
+changes[hf(oldn)] = fl([hf(n) for n in newn], name=b'node')
-nodechanges = fd(changes, key="oldnode", value="newnodes")
+nodechanges = fd(changes, key=b"oldnode", value=b"newnodes")
 fm.data(nodechanges=nodechanges)
 if keepf:
 replacements = {}
-scmutil.cleanupnodes(repo, replacements, 'rebase', moves, backup=backup)
+scmutil.cleanupnodes(repo, replacements, b'rebase', moves, backup=backup)
 def pullrebase(orig, ui, repo, *args, **opts):
-'Call rebase after pull if the latter has been invoked with --rebase'
+b'Call rebase after pull if the latter has been invoked with --rebase'
 if opts.get(r'rebase'):
-if ui.configbool('commands', 'rebase.requiredest'):
+if ui.configbool(b'commands', b'rebase.requiredest'):
-msg = _('rebase destination required by configuration')
+msg = _(b'rebase destination required by configuration')
-hint = _('use hg pull followed by hg rebase -d DEST')
+hint = _(b'use hg pull followed by hg rebase -d DEST')
 raise error.Abort(msg, hint=hint)
 with repo.wlock(), repo.lock():
 if opts.get(r'update'):
 del opts[r'update']
 ui.debug(
-'--update and --rebase are not compatible, ignoring '
+b'--update and --rebase are not compatible, ignoring '
-'the update flag\n'
+b'the update flag\n'
 )
 cmdutil.checkunfinished(repo, skipmerge=True)
 cmdutil.bailifchanged(
 repo,
 hint=_(
-'cannot pull with rebase: '
+b'cannot pull with rebase: '
-'please commit or shelve your changes first'
+b'please commit or shelve your changes first'
 ),
 )
 revsprepull = len(repo)
 origpostincoming = commands.postincoming
 try:
 rebase(ui, repo, **opts)
 except error.NoMergeDestAbort:
 # we can maybe update instead
 rev, _a, _b = destutil.destupdate(repo)
-if rev == repo['.'].rev():
+if rev == repo[b'.'].rev():
-ui.status(_('nothing to rebase\n'))
+ui.status(_(b'nothing to rebase\n'))
 else:
-ui.status(_('nothing to rebase - updating instead\n'))
+ui.status(_(b'nothing to rebase - updating instead\n'))
 # not passing argument to get the bare update behavior
 # with warning and trumpets
 commands.update(ui, repo)
 else:
 if opts.get(r'tool'):
-raise error.Abort(_('--tool can only be used with --rebase'))
+raise error.Abort(_(b'--tool can only be used with --rebase'))
 ret = orig(ui, repo, *args, **opts)
 return ret
 obsoleteextinctsuccessors = set()
 assert repo.filtername is None
 cl = repo.changelog
 nodemap = cl.nodemap
-extinctrevs = set(repo.revs('extinct()'))
+extinctrevs = set(repo.revs(b'extinct()'))
 for srcrev in rebaseobsrevs:
 srcnode = cl.node(srcrev)
 # XXX: more advanced APIs are required to handle split correctly
 successors = set(obsutil.allsuccessors(repo.obsstore, [srcnode]))
 # obsutil.allsuccessors includes node itself
 rbsrt._performrebase(None)
 rbsrt._finishrebase()
 def summaryhook(ui, repo):
-if not repo.vfs.exists('rebasestate'):
+if not repo.vfs.exists(b'rebasestate'):
 return
 try:
 rbsrt = rebaseruntime(repo, ui, {})
 rbsrt.restorestatus()
 state = rbsrt.state
 except error.RepoLookupError:
 # i18n: column positioning for "hg summary"
-msg = _('rebase: (use "hg rebase --abort" to clear broken state)\n')
+msg = _(b'rebase: (use "hg rebase --abort" to clear broken state)\n')
 ui.write(msg)
 return
 numrebased = len([i for i in state.itervalues() if i >= 0])
 # i18n: column positioning for "hg summary"
 ui.write(
-_('rebase: %s, %s (rebase --continue)\n')
+_(b'rebase: %s, %s (rebase --continue)\n')
 % (
-ui.label(_('%d rebased'), 'rebase.rebased') % numrebased,
+ui.label(_(b'%d rebased'), b'rebase.rebased') % numrebased,
-ui.label(_('%d remaining'), 'rebase.remaining')
+ui.label(_(b'%d remaining'), b'rebase.remaining')
 % (len(state) - numrebased),
 )
 )
 def uisetup(ui):
 # Replace pull with a decorator to provide --rebase option
-entry = extensions.wrapcommand(commands.table, 'pull', pullrebase)
+entry = extensions.wrapcommand(commands.table, b'pull', pullrebase)
 entry[1].append(
-('', 'rebase', None, _("rebase working directory to branch head"))
+(b'', b'rebase', None, _(b"rebase working directory to branch head"))
 )
-entry[1].append(('t', 'tool', '', _("specify merge tool for rebase")))
+entry[1].append((b't', b'tool', b'', _(b"specify merge tool for rebase")))
-cmdutil.summaryhooks.add('rebase', summaryhook)
+cmdutil.summaryhooks.add(b'rebase', summaryhook)
 statemod.addunfinished(
-'rebase',
+b'rebase',
-fname='rebasestate',
+fname=b'rebasestate',
 stopflag=True,
 continueflag=True,
 abortfunc=abortrebase,
 continuefunc=continuerebase,
 )

changeset 43077	687b865b95ad
parent 43076	2372284d9457
child 43085	eef9a2d67051