This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8712

black: format some files in preparation for subsequent changes
AbandonedPublic

Authored by dploch on Jul 8 2020, 6:50 PM.

Details

Reviewers
martinvonz
mjacob
Group Reviewers
hg-reviewers

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

dploch created this revision.Jul 8 2020, 6:50 PM
mjacob requested changes to this revision.Jul 8 2020, 8:08 PM
mjacob added a subscriber: mjacob.

Our sources should already be formatted. E.g. if I run black --config=black.toml hgext/rebase.py, it doesn’t change anything. The tests would catch if a file should be reformatted.

mercurial/state.py
33

This re-formatting is wrong. I could not find any way to run black such that it produces this change.

This revision now requires changes to proceed.Jul 8 2020, 8:08 PM
durin42 added a subscriber: durin42.Jul 8 2020, 10:25 PM

Yeah, if you’re seeing these changes I’m pretty sure you have a too-old black...

dploch abandoned this revision.Jul 10 2020, 9:12 PM

Sorry for the noise. There was some conflict between our internal fix configuration and the black.toml setup in the hg repo; I thought I had sorted it out but I was mistaken (and black apparently leaves the opinionated quotation-style changes in place, it doesn't have its own opinion about them?)

I have black --version: 19.3b0, which looks like one off from the most current version, so I don't think that's the issue. I'm still getting the changes for from foo import ( a, b ) [multiline] -> from foo import a, b [oneline] though, even from tip. Is no one else getting even those with the current version of black?

Regardless, I'm fine dropping this change since it seems to mostly be in error. I'll abandon this revision.

Revision Contents
Changeset List

PathPackages
Mhgext/rebase.py (121 lines)
Mmercurial/error.py (14 lines)
Mmercurial/shelve.py (5 lines)
Mmercurial/state.py (39 lines)

Diff 21809

hgext/rebase.py

# rebase.py - rebasing feature for mercurial # rebase.py - rebasing feature for mercurial
# #
# Copyright 2008 Stefano Tortarolo <stefano.tortarolo at gmail dot com> # Copyright 2008 Stefano Tortarolo <stefano.tortarolo at gmail dot com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
"""command to move sets of revisions to a different ancestor
'''command to move sets of revisions to a different ancestor
This extension lets you rebase changesets in an existing Mercurial This extension lets you rebase changesets in an existing Mercurial
repository. repository.
For more information: For more information:
https://mercurial-scm.org/wiki/RebaseExtension https://mercurial-scm.org/wiki/RebaseExtension
''' """
from __future__ import absolute_import from __future__ import absolute_import
import errno import errno
import os import os
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import ( from mercurial.node import nullrev, short
nullrev,
short,
)
from mercurial.pycompat import open from mercurial.pycompat import open
from mercurial import ( from mercurial import (
bookmarks, bookmarks,
cmdutil, cmdutil,
commands, commands,
copies, copies,
destutil, destutil,
dirstateguard, dirstateguard,
def _savebranch(ctx, extra): def _savebranch(ctx, extra):
extra[b'branch'] = ctx.branch() extra[b'branch'] = ctx.branch()
def _destrebase(repo, sourceset, destspace=None): def _destrebase(repo, sourceset, destspace=None):
"""small wrapper around destmerge to pass the right extra args """small wrapper around destmerge to pass the right extra args
Please wrap destutil.destmerge instead.""" Please wrap destutil.destmerge instead.
"""
return destutil.destmerge( return destutil.destmerge(
repo, repo,
action=b'rebase', action=b'rebase',
sourceset=sourceset, sourceset=sourceset,
onheadcheck=False, onheadcheck=False,
destspace=destspace, destspace=destspace,
) )
src = revset.getset(repo, subset, x).first() src = revset.getset(repo, subset, x).first()
# Empty src or already obsoleted - Do not return a destination # Empty src or already obsoleted - Do not return a destination
if not src or src in obsoleted: if not src or src in obsoleted:
return smartset.baseset() return smartset.baseset()
dests = destutil.orphanpossibledestination(repo, src) dests = destutil.orphanpossibledestination(repo, src)
if len(dests) > 1: if len(dests) > 1:
raise error.Abort( raise error.Abort(
_(b"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) % (src, dests)
) )
# We have zero or one destination, so we can just return here. # We have zero or one destination, so we can just return here.
return smartset.baseset(dests) return smartset.baseset(dests)
def _ctxdesc(ctx): def _ctxdesc(ctx):
"""short description for a context""" """short description for a context"""
if tr: if tr:
tr.addfilegenerator( tr.addfilegenerator(
b'rebasestate', b'rebasestate',
(b'rebasestate',), (b'rebasestate',),
self._writestatus, self._writestatus,
location=b'plain', location=b'plain',
) )
else: else:
with self.repo.vfs(b"rebasestate", b"w") as f: with self.repo.vfs(b'rebasestate', b'w') as f:
self._writestatus(f) self._writestatus(f)
def _writestatus(self, f): def _writestatus(self, f):
repo = self.repo repo = self.repo
assert repo.filtername is None assert repo.filtername is None
f.write(repo[self.originalwd].hex() + b'\n') f.write(repo[self.originalwd].hex() + b'\n')
# was "dest". we now write dest per src root below. # was "dest". we now write dest per src root below.
f.write(b'\n') f.write(b'\n')
f.write(repo[self.external].hex() + b'\n') f.write(repo[self.external].hex() + b'\n')
f.write(b'%d\n' % int(self.collapsef)) f.write(b'%d\n' % int(self.collapsef))
f.write(b'%d\n' % int(self.keepf)) f.write(b'%d\n' % int(self.keepf))
f.write(b'%d\n' % int(self.keepbranchesf)) f.write(b'%d\n' % int(self.keepbranchesf))
f.write(b'%s\n' % (self.activebookmark or b'')) f.write(b'%s\n' % (self.activebookmark or b''))
destmap = self.destmap destmap = self.destmap
for d, v in pycompat.iteritems(self.state): for d, v in pycompat.iteritems(self.state):
oldrev = repo[d].hex() oldrev = repo[d].hex()
if v >= 0: if v >= 0:
newrev = repo[v].hex() newrev = repo[v].hex()
else: else:
newrev = b"%d" % v newrev = b'%d' % v
destnode = repo[destmap[d]].hex() destnode = repo[destmap[d]].hex()
f.write(b"%s:%s:%s\n" % (oldrev, newrev, destnode)) f.write(b'%s:%s:%s\n' % (oldrev, newrev, destnode))
repo.ui.debug(b'rebase status stored\n') repo.ui.debug(b'rebase status stored\n')
def restorestatus(self): def restorestatus(self):
"""Restore a previously stored status""" """Restore a previously stored status"""
if not self.stateobj.exists(): if not self.stateobj.exists():
cmdutil.wrongtooltocontinue(self.repo, _(b'rebase')) cmdutil.wrongtooltocontinue(self.repo, _(b'rebase'))
data = self._read() data = self._read()
b'keep': None, b'keep': None,
b'originalwd': None, b'originalwd': None,
} }
legacydest = None legacydest = None
state = {} state = {}
destmap = {} destmap = {}
if True: if True:
f = repo.vfs(b"rebasestate") f = repo.vfs(b'rebasestate')
for i, l in enumerate(f.read().splitlines()): for i, l in enumerate(f.read().splitlines()):
if i == 0: if i == 0:
data[b'originalwd'] = repo[l].rev() data[b'originalwd'] = repo[l].rev()
elif i == 1: elif i == 1:
# this line should be empty in newer version. but legacy # this line should be empty in newer version. but legacy
# clients may still use it # clients may still use it
if l: if l:
legacydest = repo[l].rev() legacydest = repo[l].rev()
self.prepared = True self.prepared = True
def _assignworkingcopy(self): def _assignworkingcopy(self):
if self.inmemory: if self.inmemory:
from mercurial.context import overlayworkingctx from mercurial.context import overlayworkingctx
self.wctx = overlayworkingctx(self.repo) self.wctx = overlayworkingctx(self.repo)
self.repo.ui.debug(b"rebasing in-memory\n") self.repo.ui.debug(b'rebasing in-memory\n')
else: else:
self.wctx = self.repo[None] self.wctx = self.repo[None]
self.repo.ui.debug(b"rebasing on disk\n") self.repo.ui.debug(b'rebasing on disk\n')
self.repo.ui.log( self.repo.ui.log(
b"rebase", b'rebase',
b"using in-memory rebase: %r\n", b'using in-memory rebase: %r\n',
self.inmemory, self.inmemory,
rebase_imm_used=self.inmemory, rebase_imm_used=self.inmemory,
) )
def _performrebase(self, tr): def _performrebase(self, tr):
self._assignworkingcopy() self._assignworkingcopy()
repo, ui = self.repo, self.ui repo, ui = self.repo, self.ui
if self.keepbranchesf: if self.keepbranchesf:
self.storestatus() self.storestatus()
if tr: if tr:
# When using single transaction, store state when transaction # When using single transaction, store state when transaction
# commits. # commits.
self.storestatus(tr) self.storestatus(tr)
cands = [k for k, v in pycompat.iteritems(self.state) if v == revtodo] cands = [k for k, v in pycompat.iteritems(self.state) if v == revtodo]
p = repo.ui.makeprogress( p = repo.ui.makeprogress(
_(b"rebasing"), unit=_(b'changesets'), total=len(cands) _(b'rebasing'), unit=_(b'changesets'), total=len(cands)
) )
def progress(ctx): def progress(ctx):
p.increment(item=(b"%d:%s" % (ctx.rev(), ctx))) p.increment(item=(b'%d:%s' % (ctx.rev(), ctx)))
allowdivergence = self.ui.configbool( allowdivergence = self.ui.configbool(
b'experimental', b'evolution.allowdivergence' b'experimental', b'evolution.allowdivergence'
) )
for subset in sortsource(self.destmap): for subset in sortsource(self.destmap):
sortedrevs = self.repo.revs(b'sort(%ld, -topo)', subset) sortedrevs = self.repo.revs(b'sort(%ld, -topo)', subset)
if not allowdivergence: if not allowdivergence:
sortedrevs -= self.repo.revs( sortedrevs -= self.repo.revs(
b'descendants(%ld) and not %ld', b'descendants(%ld) and not %ld',
self.obsoletewithoutsuccessorindestination, self.obsoletewithoutsuccessorindestination,
self.obsoletewithoutsuccessorindestination, self.obsoletewithoutsuccessorindestination,
) )
for rev in sortedrevs: for rev in sortedrevs:
self._rebasenode(tr, rev, allowdivergence, progress) self._rebasenode(tr, rev, allowdivergence, progress)
p.complete() p.complete()
ui.note(_(b'rebase merging completed\n')) ui.note(_(b'rebase merging completed\n'))
def _concludenode(self, rev, p1, editor, commitmsg=None): def _concludenode(self, rev, p1, editor, commitmsg=None):
'''Commit the wd changes with parents p1 and p2. """Commit the wd changes with parents p1 and p2.
Reuse commit info from rev but also store useful information in extra. Reuse commit info from rev but also store useful information in extra.
Return node of committed revision.''' Return node of committed revision.
"""
repo = self.repo repo = self.repo
ctx = repo[rev] ctx = repo[rev]
if commitmsg is None: if commitmsg is None:
commitmsg = ctx.description() commitmsg = ctx.description()
date = self.date date = self.date
if date is None: if date is None:
date = ctx.date() date = ctx.date()
extra = {b'rebase_source': ctx.hex()} extra = {b'rebase_source': ctx.hex()}
# restore original working directory # restore original working directory
# (we do this before stripping) # (we do this before stripping)
newwd = self.state.get(self.originalwd, self.originalwd) newwd = self.state.get(self.originalwd, self.originalwd)
if newwd < 0: if newwd < 0:
# original directory is a parent of rebase set root or ignored # original directory is a parent of rebase set root or ignored
newwd = self.originalwd newwd = self.originalwd
if newwd not in [c.rev() for c in repo[None].parents()]: if newwd not in [c.rev() for c in repo[None].parents()]:
ui.note(_(b"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) hg.updaterepo(repo, newwd, overwrite=False)
collapsedas = None collapsedas = None
if self.collapsef and not self.keepf: if self.collapsef and not self.keepf:
collapsedas = newnode collapsedas = newnode
clearrebased( clearrebased(
ui, ui,
repo, repo,
self.destmap, self.destmap,
self.state, self.state,
self.skipped, self.skipped,
collapsedas, collapsedas,
self.keepf, self.keepf,
fm=fm, fm=fm,
backup=self.backupf, backup=self.backupf,
) )
clearstatus(repo) clearstatus(repo)
clearcollapsemsg(repo) clearcollapsemsg(repo)
ui.note(_(b"rebase completed\n")) ui.note(_(b'rebase completed\n'))
util.unlinkpath(repo.sjoin(b'undo'), ignoremissing=True) util.unlinkpath(repo.sjoin(b'undo'), ignoremissing=True)
if self.skipped: if self.skipped:
skippedlen = len(self.skipped) skippedlen = len(self.skipped)
ui.note(_(b"%d revisions have been skipped\n") % skippedlen) ui.note(_(b'%d revisions have been skipped\n') % skippedlen)
fm.end() fm.end()
if ( if (
self.activebookmark self.activebookmark
and self.activebookmark in repo._bookmarks and self.activebookmark in repo._bookmarks
and repo[b'.'].node() == repo._bookmarks[self.activebookmark] and repo[b'.'].node() == repo._bookmarks[self.activebookmark]
): ):
bookmarks.activate(repo, self.activebookmark) bookmarks.activate(repo, self.activebookmark)
def _abort(self, backup=True, suppwarns=False, dryrun=False, confirm=False): def _abort(self, backup=True, suppwarns=False, dryrun=False, confirm=False):
'''Restore the repository to its original state.''' """Restore the repository to its original state."""
repo = self.repo repo = self.repo
try: try:
# If the first commits in the rebased set get skipped during the # If the first commits in the rebased set get skipped during the
# rebase, their values within the state mapping will be the dest # rebase, their values within the state mapping will be the dest
# rev id. The rebased list must must not contain the dest rev # rev id. The rebased list must must not contain the dest rev
# (issue4896) # (issue4896)
rebased = [ rebased = [
cleanup = False cleanup = False
descendants = set() descendants = set()
if rebased: if rebased:
descendants = set(repo.changelog.descendants(rebased)) descendants = set(repo.changelog.descendants(rebased))
if descendants - set(rebased): if descendants - set(rebased):
repo.ui.warn( repo.ui.warn(
_( _(
b"warning: new changesets detected on " b'warning: new changesets detected on '
b"destination branch, can't strip\n" b"destination branch, can't strip\n"
) )
) )
cleanup = False cleanup = False
if cleanup: if cleanup:
if rebased: if rebased:
strippoints = [ strippoints = [
if opts.get(b'dry_run') or opts.get(b'confirm'): if opts.get(b'dry_run') or opts.get(b'confirm'):
return _dryrunrebase(ui, repo, action, opts) return _dryrunrebase(ui, repo, action, opts)
elif action == b'stop': elif action == b'stop':
rbsrt = rebaseruntime(repo, ui) rbsrt = rebaseruntime(repo, ui)
with repo.wlock(), repo.lock(): with repo.wlock(), repo.lock():
rbsrt.restorestatus() rbsrt.restorestatus()
if rbsrt.collapsef: if rbsrt.collapsef:
raise error.Abort(_(b"cannot stop in --collapse session")) raise error.Abort(_(b'cannot stop in --collapse session'))
allowunstable = obsolete.isenabled(repo, obsolete.allowunstableopt) allowunstable = obsolete.isenabled(repo, obsolete.allowunstableopt)
if not (rbsrt.keepf or allowunstable): if not (rbsrt.keepf or allowunstable):
raise error.Abort( raise error.Abort(
_( _(
b"cannot remove original changesets with" b'cannot remove original changesets with'
b" unrebased descendants" b' unrebased descendants'
), ),
hint=_( hint=_(
b'either enable obsmarkers to allow unstable ' b'either enable obsmarkers to allow unstable '
b'revisions or use --keep to keep original ' b'revisions or use --keep to keep original '
b'changesets' b'changesets'
), ),
) )
# update to the current working revision # update to the current working revision
): ):
assert action != b'stop' assert action != b'stop'
with repo.wlock(), repo.lock(): with repo.wlock(), repo.lock():
if opts.get(b'interactive'): if opts.get(b'interactive'):
try: try:
if extensions.find(b'histedit'): if extensions.find(b'histedit'):
enablehistedit = b'' enablehistedit = b''
except KeyError: except KeyError:
enablehistedit = b" --config extensions.histedit=" enablehistedit = b' --config extensions.histedit='
help = b"hg%s help -e histedit" % enablehistedit help = b'hg%s help -e histedit' % enablehistedit
msg = ( msg = (
_( _(
b"interactive history editing is supported by the " b'interactive history editing is supported by the '
b"'histedit' extension (see \"%s\")" b"'histedit' extension (see \"%s\")"
) )
% help % help
) )
raise error.Abort(msg) raise error.Abort(msg)
if rbsrt.collapsemsg and not rbsrt.collapsef: if rbsrt.collapsemsg and not rbsrt.collapsef:
raise error.Abort(_(b'message can only be specified with collapse')) raise error.Abort(_(b'message can only be specified with collapse'))
% (b'+'.join(bytes(repo[r]) for r in base), dest) % (b'+'.join(bytes(repo[r]) for r in base), dest)
) )
return None return None
if nodemod.wdirrev in rebaseset: if nodemod.wdirrev in rebaseset:
raise error.Abort(_(b'cannot rebase the working copy')) raise error.Abort(_(b'cannot rebase the working copy'))
rebasingwcp = repo[b'.'].rev() in rebaseset rebasingwcp = repo[b'.'].rev() in rebaseset
ui.log( ui.log(
b"rebase", b'rebase',
b"rebasing working copy parent: %r\n", b'rebasing working copy parent: %r\n',
rebasingwcp, rebasingwcp,
rebase_rebasing_wcp=rebasingwcp, rebase_rebasing_wcp=rebasingwcp,
) )
if inmemory and rebasingwcp: if inmemory and rebasingwcp:
# Check these since we did not before. # Check these since we did not before.
cmdutil.checkunfinished(repo) cmdutil.checkunfinished(repo)
cmdutil.bailifchanged(repo) cmdutil.bailifchanged(repo)
ui.status(_(b'nothing to rebase - empty destination\n')) ui.status(_(b'nothing to rebase - empty destination\n'))
return None return None
return destmap return destmap
def externalparent(repo, state, destancestors): def externalparent(repo, state, destancestors):
"""Return the revision that should be used as the second parent """Return the revision that should be used as the second parent
when the revisions in state is collapsed on top of destancestors. when the revisions in state is collapsed on top of destancestors.
Abort if there is more than one parent. Abort if there is more than one parent.
""" """
parents = set() parents = set()
source = min(state) source = min(state)
for rev in state: for rev in state:
if rev == source: if rev == source:
continue continue
for p in repo[rev].parents(): for p in repo[rev].parents():
if p.rev() not in state and p.rev() not in destancestors: if p.rev() not in state and p.rev() not in destancestors:
parents.add(p.rev()) parents.add(p.rev())
if not parents: if not parents:
return nullrev return nullrev
if len(parents) == 1: if len(parents) == 1:
return parents.pop() return parents.pop()
raise error.Abort( raise error.Abort(
_( _(
b'unable to collapse on top of %d, there is more ' b'unable to collapse on top of %d, there is more '
b'than one external parent: %s' b'than one external parent: %s'
) )
% (max(destancestors), b', '.join(b"%d" % p for p in sorted(parents))) % (max(destancestors), b', '.join(b'%d' % p for p in sorted(parents)))
) )
def commitmemorynode(repo, wctx, editor, extra, user, date, commitmsg): def commitmemorynode(repo, wctx, editor, extra, user, date, commitmsg):
'''Commit the memory changes with parents p1 and p2. """Commit the memory changes with parents p1 and p2.
Return node of committed revision.'''
Return node of committed revision.
"""
# Replicates the empty check in ``repo.commit``. # Replicates the empty check in ``repo.commit``.
if wctx.isempty() and not repo.ui.configbool(b'ui', b'allowemptycommit'): if wctx.isempty() and not repo.ui.configbool(b'ui', b'allowemptycommit'):
return None return None
# By convention, ``extra['branch']`` (set by extrafn) clobbers # By convention, ``extra['branch']`` (set by extrafn) clobbers
# ``branch`` (used when passing ``--keepbranches``). # ``branch`` (used when passing ``--keepbranches``).
branch = None branch = None
if b'branch' in extra: if b'branch' in extra:
branch = extra[b'branch'] branch = extra[b'branch']
memctx = wctx.tomemctx( memctx = wctx.tomemctx(
commitmsg, commitmsg,
date=date, date=date,
extra=extra, extra=extra,
user=user, user=user,
branch=branch, branch=branch,
editor=editor, editor=editor,
) )
commitres = repo.commitctx(memctx) commitres = repo.commitctx(memctx)
wctx.clean() # Might be reused wctx.clean() # Might be reused
return commitres return commitres
def commitnode(repo, editor, extra, user, date, commitmsg): def commitnode(repo, editor, extra, user, date, commitmsg):
'''Commit the wd changes with parents p1 and p2. """Commit the wd changes with parents p1 and p2.
Return node of committed revision.'''
Return node of committed revision.
"""
dsguard = util.nullcontextmanager() dsguard = util.nullcontextmanager()
if not repo.ui.configbool(b'rebase', b'singletransaction'): if not repo.ui.configbool(b'rebase', b'singletransaction'):
dsguard = dirstateguard.dirstateguard(repo, b'rebase') dsguard = dirstateguard.dirstateguard(repo, b'rebase')
with dsguard: with dsguard:
# Commit might fail if unresolved files exist # Commit might fail if unresolved files exist
newnode = repo.commit( newnode = repo.commit(
text=commitmsg, user=user, date=date, extra=extra, editor=editor text=commitmsg, user=user, date=date, extra=extra, editor=editor
) )
repo.dirstate.setbranch(repo[newnode].branch()) repo.dirstate.setbranch(repo[newnode].branch())
return newnode return newnode
def rebasenode(repo, rev, p1, p2, base, collapse, dest, wctx): def rebasenode(repo, rev, p1, p2, base, collapse, dest, wctx):
"""Rebase a single revision rev on top of p1 using base as merge ancestor""" """Rebase a single revision rev on top of p1 using base as merge ancestor"""
# Merge phase # Merge phase
# Update to destination and merge it with local # Update to destination and merge it with local
p1ctx = repo[p1] p1ctx = repo[p1]
if wctx.isinmemory(): if wctx.isinmemory():
wctx.setbase(p1ctx) wctx.setbase(p1ctx)
else: else:
if repo[b'.'].rev() != p1: if repo[b'.'].rev() != p1:
repo.ui.debug(b" update to %d:%s\n" % (p1, p1ctx)) repo.ui.debug(b' update to %d:%s\n' % (p1, p1ctx))
mergemod.clean_update(p1ctx) mergemod.clean_update(p1ctx)
else: else:
repo.ui.debug(b" already in destination\n") repo.ui.debug(b' already in destination\n')
# This is, alas, necessary to invalidate workingctx's manifest cache, # This is, alas, necessary to invalidate workingctx's manifest cache,
# as well as other data we litter on it in other places. # as well as other data we litter on it in other places.
wctx = repo[None] wctx = repo[None]
repo.dirstate.write(repo.currenttransaction()) repo.dirstate.write(repo.currenttransaction())
ctx = repo[rev] ctx = repo[rev]
repo.ui.debug(b" merge against %d:%s\n" % (rev, ctx)) repo.ui.debug(b' merge against %d:%s\n' % (rev, ctx))
if base is not None: if base is not None:
repo.ui.debug(b" detach base %d:%s\n" % (base, repo[base])) repo.ui.debug(b' detach base %d:%s\n' % (base, repo[base]))
# See explanation in merge.graft() # See explanation in merge.graft()
mergeancestor = repo.changelog.isancestor(p1ctx.node(), ctx.node()) mergeancestor = repo.changelog.isancestor(p1ctx.node(), ctx.node())
stats = mergemod.update( stats = mergemod.update(
repo, repo,
rev, rev,
branchmerge=True, branchmerge=True,
force=True, force=True,
successors in destination or no non-obsolete successor. successors in destination or no non-obsolete successor.
""" """
# Obsolete node with successors not in dest leads to divergence # Obsolete node with successors not in dest leads to divergence
divergenceok = ui.configbool(b'experimental', b'evolution.allowdivergence') divergenceok = ui.configbool(b'experimental', b'evolution.allowdivergence')
divergencebasecandidates = rebaseobsrevs - rebaseobsskipped divergencebasecandidates = rebaseobsrevs - rebaseobsskipped
if divergencebasecandidates and not divergenceok: if divergencebasecandidates and not divergenceok:
divhashes = (bytes(repo[r]) for r in divergencebasecandidates) divhashes = (bytes(repo[r]) for r in divergencebasecandidates)
msg = _(b"this rebase will cause divergences from: %s") msg = _(b'this rebase will cause divergences from: %s')
h = _( h = _(
b"to force the rebase please set " b'to force the rebase please set '
b"experimental.evolution.allowdivergence=True" b'experimental.evolution.allowdivergence=True'
) )
raise error.Abort(msg % (b",".join(divhashes),), hint=h) raise error.Abort(msg % (b','.join(divhashes),), hint=h)
def successorrevs(unfi, rev): def successorrevs(unfi, rev):
"""yield revision numbers for successors of rev""" """yield revision numbers for successors of rev"""
assert unfi.filtername is None assert unfi.filtername is None
get_rev = unfi.changelog.index.get_rev get_rev = unfi.changelog.index.get_rev
for s in obsutil.allsuccessors(unfi.obsstore, [unfi[rev].node()]): for s in obsutil.allsuccessors(unfi.obsstore, [unfi[rev].node()]):
r = get_rev(s) r = get_rev(s)
if i != 0: if i != 0:
if newps[i] != nullrev: if newps[i] != nullrev:
newps[0], newps[i] = newps[i], newps[0] newps[0], newps[i] = newps[i], newps[0]
bases[0], bases[i] = bases[i], bases[0] bases[0], bases[i] = bases[i], bases[0]
# "rebasenode" updates to new p1, use the corresponding merge base. # "rebasenode" updates to new p1, use the corresponding merge base.
base = bases[0] base = bases[0]
repo.ui.debug(b" 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 return newps[0], newps[1], base
def isagitpatch(repo, patchname): def isagitpatch(repo, patchname):
"""Return true if the given patch is in git format""" """Return true if the given patch is in git format"""
mqpatch = os.path.join(repo.mq.path, patchname) mqpatch = os.path.join(repo.mq.path, patchname)
for line in patch.linereader(open(mqpatch, b'rb')): for line in patch.linereader(open(mqpatch, b'rb')):
_(b'updating mq patch %s to %d:%s\n') _(b'updating mq patch %s to %d:%s\n')
% (name, state[rev], repo[state[rev]]) % (name, state[rev], repo[state[rev]])
) )
mq.qimport( mq.qimport(
repo, repo,
(), (),
patchname=name, patchname=name,
git=isgit, git=isgit,
rev=[b"%d" % state[rev]], rev=[b'%d' % state[rev]],
) )
else: else:
# Rebased and skipped # Rebased and skipped
skippedpatches.add(mqrebase[rev][0]) skippedpatches.add(mqrebase[rev][0])
# Patches were either applied and rebased and imported in # Patches were either applied and rebased and imported in
# order, applied and removed or unapplied. Discard the removed # order, applied and removed or unapplied. Discard the removed
# ones while preserving the original series order and guards. # ones while preserving the original series order and guards.
newseries = [ newseries = [
s s
for s in original_series for s in original_series
if mq.guard_re.split(s, 1)[0] not in skippedpatches if mq.guard_re.split(s, 1)[0] not in skippedpatches
] ]
mq.fullseries[:] = newseries mq.fullseries[:] = newseries
mq.seriesdirty = True mq.seriesdirty = True
mq.savedirty() mq.savedirty()
def storecollapsemsg(repo, collapsemsg): def storecollapsemsg(repo, collapsemsg):
"""Store the collapse message to allow recovery""" """Store the collapse message to allow recovery"""
collapsemsg = collapsemsg or b'' collapsemsg = collapsemsg or b''
f = repo.vfs(b"last-message.txt", b"w") f = repo.vfs(b'last-message.txt', b'w')
f.write(b"%s\n" % collapsemsg) f.write(b'%s\n' % collapsemsg)
f.close() f.close()
def clearcollapsemsg(repo): def clearcollapsemsg(repo):
"""Remove collapse message file""" """Remove collapse message file"""
repo.vfs.unlinkpath(b"last-message.txt", ignoremissing=True) repo.vfs.unlinkpath(b'last-message.txt', ignoremissing=True)
def restorecollapsemsg(repo, isabort): def restorecollapsemsg(repo, isabort):
"""Restore previously stored collapse message""" """Restore previously stored collapse message"""
try: try:
f = repo.vfs(b"last-message.txt") f = repo.vfs(b'last-message.txt')
collapsemsg = f.readline().strip() collapsemsg = f.readline().strip()
f.close() f.close()
except IOError as err: except IOError as err:
if err.errno != errno.ENOENT: if err.errno != errno.ENOENT:
raise raise
if isabort: if isabort:
# Oh well, just abort like normal # Oh well, just abort like normal
collapsemsg = b'' collapsemsg = b''
else: else:
raise error.Abort(_(b'missing .hg/last-message.txt for rebase')) raise error.Abort(_(b'missing .hg/last-message.txt for rebase'))
return collapsemsg return collapsemsg
def clearstatus(repo): def clearstatus(repo):
"""Remove the status files""" """Remove the status files"""
# Make sure the active transaction won't write the state file # Make sure the active transaction won't write the state file
tr = repo.currenttransaction() tr = repo.currenttransaction()
if tr: if tr:
tr.removefilegenerator(b'rebasestate') tr.removefilegenerator(b'rebasestate')
repo.vfs.unlinkpath(b"rebasestate", ignoremissing=True) repo.vfs.unlinkpath(b'rebasestate', ignoremissing=True)
def sortsource(destmap): def sortsource(destmap):
"""yield source revisions in an order that we only rebase things once """yield source revisions in an order that we only rebase things once
If source and destination overlaps, we should filter out revisions If source and destination overlaps, we should filter out revisions
depending on other revisions which hasn't been rebased yet. depending on other revisions which hasn't been rebased yet.
result.append(r) result.append(r)
if not result: if not result:
raise error.Abort(_(b'source and destination form a cycle')) raise error.Abort(_(b'source and destination form a cycle'))
srcset -= set(result) srcset -= set(result)
yield result yield result
def buildstate(repo, destmap, collapse): def buildstate(repo, destmap, collapse):
'''Define which revisions are going to be rebased and where """Define which revisions are going to be rebased and where
repo: repo repo: repo
destmap: {srcrev: destrev} destmap: {srcrev: destrev}
''' """
rebaseset = destmap.keys() rebaseset = destmap.keys()
originalwd = repo[b'.'].rev() originalwd = repo[b'.'].rev()
# This check isn't strictly necessary, since mq detects commits over an # This check isn't strictly necessary, since mq detects commits over an
# applied patch. But it prevents messing up the working directory when # applied patch. But it prevents messing up the working directory when
# a partially completed rebase is blocked by mq. # a partially completed rebase is blocked by mq.
if b'qtip' in repo.tags(): if b'qtip' in repo.tags():
mqapplied = {repo[s.node].rev() for s in repo.mq.applied} mqapplied = {repo[s.node].rev() for s in repo.mq.applied}
if fm: if fm:
hf = fm.hexfunc hf = fm.hexfunc
fl = fm.formatlist fl = fm.formatlist
fd = fm.formatdict fd = fm.formatdict
changes = {} changes = {}
for oldns, newn in pycompat.iteritems(replacements): for oldns, newn in pycompat.iteritems(replacements):
for oldn in oldns: for oldn in oldns:
changes[hf(oldn)] = fl([hf(n) for n in newn], name=b'node') changes[hf(oldn)] = fl([hf(n) for n in newn], name=b'node')
nodechanges = fd(changes, key=b"oldnode", value=b"newnodes") nodechanges = fd(changes, key=b'oldnode', value=b'newnodes')
fm.data(nodechanges=nodechanges) fm.data(nodechanges=nodechanges)
if keepf: if keepf:
replacements = {} replacements = {}
scmutil.cleanupnodes(repo, replacements, b'rebase', moves, backup=backup) scmutil.cleanupnodes(repo, replacements, b'rebase', moves, backup=backup)
def pullrebase(orig, ui, repo, *args, **opts): def pullrebase(orig, ui, repo, *args, **opts):
"""Call rebase after pull if the latter has been invoked with --rebase""" """Call rebase after pull if the latter has been invoked with --rebase"""
) )
) )
def uisetup(ui): def uisetup(ui):
# Replace pull with a decorator to provide --rebase option # Replace pull with a decorator to provide --rebase option
entry = extensions.wrapcommand(commands.table, b'pull', pullrebase) entry = extensions.wrapcommand(commands.table, b'pull', pullrebase)
entry[1].append( entry[1].append(
(b'', b'rebase', None, _(b"rebase working directory to branch head")) (b'', b'rebase', None, _(b'rebase working directory to branch head'))
) )
entry[1].append((b't', b'tool', b'', _(b"specify merge tool for rebase"))) entry[1].append((b't', b'tool', b'', _(b'specify merge tool for rebase')))
cmdutil.summaryhooks.add(b'rebase', summaryhook) cmdutil.summaryhooks.add(b'rebase', summaryhook)
statemod.addunfinished( statemod.addunfinished(
b'rebase', b'rebase',
fname=b'rebasestate', fname=b'rebasestate',
stopflag=True, stopflag=True,
continueflag=True, continueflag=True,
abortfunc=abortrebase, abortfunc=abortrebase,
continuefunc=continuerebase, continuefunc=continuerebase,
) )

mercurial/error.py

# error.py - Mercurial exceptions # error.py - Mercurial exceptions
# #
# Copyright 2005-2008 Matt Mackall <mpm@selenic.com> # Copyright 2005-2008 Matt Mackall <mpm@selenic.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
"""Mercurial exceptions. """Mercurial exceptions.
This allows us to catch exceptions at higher levels without forcing This allows us to catch exceptions at higher levels without forcing
imports. imports.
""" """
from __future__ import absolute_import from __future__ import absolute_import
# but do not replace it with encoding.strfromlocal(), which # but do not replace it with encoding.strfromlocal(), which
# may raise another exception. # may raise another exception.
return pycompat.sysstr(self.__bytes__()) return pycompat.sysstr(self.__bytes__())
class HookLoadError(Abort): class HookLoadError(Abort):
"""raised when loading a hook fails, aborting an operation """raised when loading a hook fails, aborting an operation
Exists to allow more specialized catching.""" Exists to allow more specialized catching.
"""
class HookAbort(Abort): class HookAbort(Abort):
"""raised when a validation hook fails, aborting an operation """raised when a validation hook fails, aborting an operation
Exists to allow more specialized catching.""" Exists to allow more specialized catching.
"""
class ConfigError(Abort): class ConfigError(Abort):
"""Exception raised when parsing config files""" """Exception raised when parsing config files"""
class UpdateAbort(Abort): class UpdateAbort(Abort):
"""Raised when an update is aborted for destination issue""" """Raised when an update is aborted for destination issue"""
class UnknownIdentifier(ParseError): class UnknownIdentifier(ParseError):
"""Exception raised when a {rev,file}set references an unknown identifier""" """Exception raised when a {rev,file}set references an unknown identifier"""
def __init__(self, function, symbols): def __init__(self, function, symbols):
from .i18n import _ from .i18n import _
ParseError.__init__(self, _(b"unknown identifier: %s") % function) ParseError.__init__(self, _(b'unknown identifier: %s') % function)
self.function = function self.function = function
self.symbols = symbols self.symbols = symbols
class RepoError(Hint, Exception): class RepoError(Hint, Exception):
__bytes__ = _tobytes __bytes__ = _tobytes
hint=_( hint=_(
b'see https://mercurial-scm.org/wiki/MergeStateRecords for ' b'see https://mercurial-scm.org/wiki/MergeStateRecords for '
b'more information' b'more information'
), ),
) )
class UnknownVersion(Abort): class UnknownVersion(Abort):
"""generic exception for aborting from an encounter with an unknown version """generic exception for aborting from an encounter with an unknown version"""
"""
def __init__(self, msg, hint=None, version=None): def __init__(self, msg, hint=None, version=None):
self.version = version self.version = version
super(UnknownVersion, self).__init__(msg, hint=hint) super(UnknownVersion, self).__init__(msg, hint=hint)
class LockError(IOError): class LockError(IOError):
def __init__(self, errno, strerror, filename, desc): def __init__(self, errno, strerror, filename, desc):
if self.params and self.values: if self.params and self.values:
assert len(self.params) == len(self.values) assert len(self.params) == len(self.values)
entries = [] entries = []
for idx, par in enumerate(self.params): for idx, par in enumerate(self.params):
val = self.values[idx] val = self.values[idx]
if val is None: if val is None:
entries.append(val) entries.append(val)
else: else:
entries.append(b"%s=%r" % (par, pycompat.maybebytestr(val))) entries.append(b'%s=%r' % (par, pycompat.maybebytestr(val)))
if entries: if entries:
msg = b'%s - %s' % (msg, b', '.join(entries)) msg = b'%s - %s' % (msg, b', '.join(entries))
ValueError.__init__(self, msg) ValueError.__init__(self, msg)
class ReadOnlyPartError(RuntimeError): class ReadOnlyPartError(RuntimeError):
"""error raised when code tries to alter a part being generated""" """error raised when code tries to alter a part being generated"""

mercurial/shelve.py

phases, phases,
pycompat, pycompat,
repair, repair,
scmutil, scmutil,
templatefilters, templatefilters,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
from .utils import ( from .utils import dateutil, stringutil
dateutil,
stringutil,
)
backupdir = b'shelve-backup' backupdir = b'shelve-backup'
shelvedir = b'shelved' shelvedir = b'shelved'
shelvefileextensions = [b'hg', b'patch', b'shelve'] shelvefileextensions = [b'hg', b'patch', b'shelve']
# universal extension is present in all types of shelves # universal extension is present in all types of shelves
patchextension = b'patch' patchextension = b'patch'
# we never need the user, so we use a # we never need the user, so we use a

mercurial/state.py

# state.py - writing and reading state files in Mercurial # state.py - writing and reading state files in Mercurial
# #
# Copyright 2018 Pulkit Goyal <pulkitmgoyal@gmail.com> # Copyright 2018 Pulkit Goyal <pulkitmgoyal@gmail.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
"""This file contains class to wrap the state for commands and other related logic.
"""
This file contains class to wrap the state for commands and other
related logic.
All the data related to the command state is stored as dictionary in the object. All the data related to the command state is stored as dictionary in the object.
The class has methods using which the data can be stored to disk in a file under The class has methods using which the data can be stored to disk in a file under
.hg/ directory. .hg/ directory.
We store the data on disk in cbor, for which we use the CBOR format to encode We store the data on disk in cbor, for which we use the CBOR format to encode
the data. the data.
""" """
from __future__ import absolute_import from __future__ import absolute_import
from .i18n import _ from .i18n import _
from . import ( from . import error, pycompat, util
error,
pycompat,
util,
)
from .utils import cborutil from .utils import cborutil
if pycompat.TYPE_CHECKING: if pycompat.TYPE_CHECKING:
from typing import ( from typing import Any, Dict
Any,
Dict,
)
for t in (Any, Dict): for t in (Any, Dict):
assert t assert t
class cmdstate(object): class cmdstate(object):
"""a wrapper class to store the state of commands like `rebase`, `graft`, """a wrapper class to store the state of commands like `rebase`, `graft`,
mjacobUnsubmitted
Not Done

This re-formatting is wrong. I could not find any way to run black such that it produces this change.

mjacob: This re-formatting is wrong. I could not find any way to run black such that it produces this…
`histedit`, `shelve` etc. Extensions can also use this to write state files. `histedit`, `shelve` etc. Extensions can also use this to write state files.
All the data for the state is stored in the form of key-value pairs in a All the data for the state is stored in the form of key-value pairs in a
dictionary. dictionary.
The class object can write all the data to a file in .hg/ directory and The class object can write all the data to a file in .hg/ directory and
can populate the object data reading that file. can populate the object data reading that file.
Uses cbor to serialize and deserialize data while writing and reading from Uses cbor to serialize and deserialize data while writing and reading from
disk. disk.
""" """
def __init__(self, repo, fname): def __init__(self, repo, fname):
""" repo is the repo object """ repo is the repo object
fname is the file name in which data should be stored in .hg directory fname is the file name in which data should be stored in .hg directory
""" """
self._repo = repo self._repo = repo
self.fname = fname self.fname = fname
def read(self): def read(self):
# type: () -> Dict[bytes, Any] # type: () -> Dict[bytes, Any]
"""read the existing state file and return a dict of data stored""" """read the existing state file and return a dict of data stored"""
return self._read() return self._read()
def save(self, version, data): def save(self, version, data):
"""write all the state data stored to .hg/<filename> file """write all the state data stored to .hg/<filename> file
we use third-party library cbor to serialize data to write in the file. we use third-party library cbor to serialize data to write in the file.
""" """
if not isinstance(version, int): if not isinstance(version, int):
raise error.ProgrammingError( raise error.ProgrammingError(
b"version of state file should be an integer" b'version of state file should be an integer'
) )
with self._repo.vfs(self.fname, b'wb', atomictemp=True) as fp: with self._repo.vfs(self.fname, b'wb', atomictemp=True) as fp:
fp.write(b'%d\n' % version) fp.write(b'%d\n' % version)
for chunk in cborutil.streamencode(data): for chunk in cborutil.streamencode(data):
fp.write(chunk) fp.write(chunk)
def _read(self): def _read(self):
"""reads the state file and returns a dictionary which contain """reads the state file and returns a dictionary which contain
data in the same format as it was before storing"""
data in the same format as it was before storing
"""
with self._repo.vfs(self.fname, b'rb') as fp: with self._repo.vfs(self.fname, b'rb') as fp:
try: try:
int(fp.readline()) int(fp.readline())
except ValueError: except ValueError:
raise error.CorruptedState( raise error.CorruptedState(
b"unknown version of state file found" b'unknown version of state file found'
) )
return cborutil.decodeall(fp.read())[0] return cborutil.decodeall(fp.read())[0]
def delete(self): def delete(self):
"""drop the state file if exists""" """drop the state file if exists"""
util.unlinkpath(self._repo.vfs.join(self.fname), ignoremissing=True) util.unlinkpath(self._repo.vfs.join(self.fname), ignoremissing=True)
def exists(self): def exists(self):
"""check whether the state file exists or not""" """check whether the state file exists or not"""
return self._repo.vfs.exists(self.fname) return self._repo.vfs.exists(self.fname)
class _statecheck(object): class _statecheck(object):
"""a utility class that deals with multistep operations like graft, """a utility class that deals with multistep operations like graft,
histedit, bisect, update etc and check whether such commands histedit, bisect, update etc and check whether such commands
are in an unfinished conditition or not and return appropriate message are in an unfinished conditition or not and return appropriate message
and hint. and hint.
It also has the ability to register and determine the states of any new It also has the ability to register and determine the states of any new
multistep operation or multistep command extension. multistep operation or multistep command extension.
""" """
def __init__( def __init__(
self._cmdmsg = cmdmsg self._cmdmsg = cmdmsg
self._cmdhint = cmdhint self._cmdhint = cmdhint
self._statushint = statushint self._statushint = statushint
self.abortfunc = abortfunc self.abortfunc = abortfunc
self.continuefunc = continuefunc self.continuefunc = continuefunc
def statusmsg(self): def statusmsg(self):
"""returns the hint message corresponding to the command for """returns the hint message corresponding to the command for
hg status --verbose hg status --verbose
""" """
if not self._statushint: if not self._statushint:
hint = _( hint = _(
b'To continue: hg %s --continue\n' b'To continue: hg %s --continue\n'
b'To abort: hg %s --abort' b'To abort: hg %s --abort'
) % (self._opname, self._opname) ) % (self._opname, self._opname)
if self._stopflag: if self._stopflag:
hint = hint + ( hint = hint + (
_(b'\nTo stop: hg %s --stop') % (self._opname) _(b'\nTo stop: hg %s --stop') % (self._opname)
) )
return hint return hint
return self._statushint return self._statushint
def hint(self): def hint(self):
"""returns the hint message corresponding to an interrupted """returns the hint message corresponding to an interrupted
operation operation
""" """
if not self._cmdhint: if not self._cmdhint:
return _(b"use 'hg %s --continue' or 'hg %s --abort'") % ( return _(b"use 'hg %s --continue' or 'hg %s --abort'") % (
self._opname, self._opname,
self._opname, self._opname,
) )
return self._cmdhint return self._cmdhint
def msg(self): def msg(self):
"""returns the status message corresponding to the command""" """returns the status message corresponding to the command"""
if not self._cmdmsg: if not self._cmdmsg:
return _(b'%s in progress') % (self._opname) return _(b'%s in progress') % (self._opname)
return self._cmdmsg return self._cmdmsg
def continuemsg(self): def continuemsg(self):
""" returns appropriate continue message corresponding to command""" """ returns appropriate continue message corresponding to command"""
return _(b'hg %s --continue') % (self._opname) return _(b'hg %s --continue') % (self._opname)
def isunfinished(self, repo): def isunfinished(self, repo):
"""determines whether a multi-step operation is in progress """determines whether a multi-step operation is in progress
or not or not
""" """
if self._opname == b'merge': if self._opname == b'merge':
return len(repo[None].parents()) > 1 return len(repo[None].parents()) > 1
else: else:
return repo.vfs.exists(self._fname) return repo.vfs.exists(self._fname)
# A list of statecheck objects for multistep operations like graft. # A list of statecheck objects for multistep operations like graft.
_unfinishedstates = [] _unfinishedstates = []
def addunfinished( def addunfinished(
opname, opname,
fname, fname,
clearable=False, clearable=False,
allowcommit=False, allowcommit=False,
reportonly=False, reportonly=False,
continueflag=False, continueflag=False,
stopflag=False, stopflag=False,
cmdmsg=b"", cmdmsg=b'',
cmdhint=b"", cmdhint=b'',
statushint=b"", statushint=b'',
abortfunc=None, abortfunc=None,
continuefunc=None, continuefunc=None,
): ):
"""this registers a new command or operation to unfinishedstates """this registers a new command or operation to unfinishedstates
opname is the name the command or operation opname is the name the command or operation
fname is the file name in which data should be stored in .hg directory. fname is the file name in which data should be stored in .hg directory.
It is None for merge command. It is None for merge command.
clearable boolean determines whether or not interrupted states can be clearable boolean determines whether or not interrupted states can be
cleared by running `hg update -C .` which in turn deletes the cleared by running `hg update -C .` which in turn deletes the
state file. state file.
allowcommit boolean decides whether commit is allowed during interrupted allowcommit boolean decides whether commit is allowed during interrupted
state or not. state or not.
addunfinished( addunfinished(
b'update', b'update',
fname=b'updatestate', fname=b'updatestate',
clearable=True, clearable=True,
cmdmsg=_(b'last update was interrupted'), cmdmsg=_(b'last update was interrupted'),
cmdhint=_(b"use 'hg update' to get a consistent checkout"), cmdhint=_(b"use 'hg update' to get a consistent checkout"),
statushint=_(b"To continue: hg update ."), statushint=_(b'To continue: hg update .'),
) )
addunfinished( addunfinished(
b'bisect', b'bisect',
fname=b'bisect.state', fname=b'bisect.state',
allowcommit=True, allowcommit=True,
reportonly=True, reportonly=True,
statushint=_( statushint=_(
b'To mark the changeset good: hg bisect --good\n' b'To mark the changeset good: hg bisect --good\n'