This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9074

rebase: add dryrun property to rebaseruntime
ClosedPublic

Authored by martinvonz on Sep 23 2020, 1:28 PM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHG25e365d5aa8f: rebase: add dryrun property to rebaseruntime
Summary

I want to be able to check the property in
rebaseruntime._rebasenode(). Passing the value via the runtime is a
convenient way.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

martinvonz created this revision.Sep 23 2020, 1:28 PM
pulkit accepted this revision.Sep 24 2020, 2:51 AM
This revision is now accepted and ready to land.Sep 24 2020, 2:51 AM
martinvonz added a commit: rHG25e365d5aa8f: rebase: add dryrun property to rebaseruntime.Sep 24 2020, 3:35 AM
Closed by commit rHG25e365d5aa8f: rebase: add dryrun property to rebaseruntime (authored by martinvonz). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mhgext/rebase.py (13 lines)

Diff 22822

hgext/rebase.py

if names: if names:
desc += b' (%s)' % b' '.join(names) desc += b' (%s)' % b' '.join(names)
return desc return desc
class rebaseruntime(object): class rebaseruntime(object):
"""This class is a container for rebase runtime state""" """This class is a container for rebase runtime state"""
def __init__(self, repo, ui, inmemory=False, opts=None): def __init__(self, repo, ui, inmemory=False, dryrun=False, opts=None):
if opts is None: if opts is None:
opts = {} opts = {}
# prepared: whether we have rebasestate prepared or not. Currently it # prepared: whether we have rebasestate prepared or not. Currently it
# decides whether "self.repo" is unfiltered or not. # decides whether "self.repo" is unfiltered or not.
# The rebasestate has explicit hash to hash instructions not depending # The rebasestate has explicit hash to hash instructions not depending
# on visibility. If rebasestate exists (in-memory or on-disk), use # on visibility. If rebasestate exists (in-memory or on-disk), use
# unfiltered repo to avoid visibility issues. # unfiltered repo to avoid visibility issues.
self.keepf = opts.get(b'keep', False) self.keepf = opts.get(b'keep', False)
self.keepbranchesf = opts.get(b'keepbranches', False) self.keepbranchesf = opts.get(b'keepbranches', False)
self.skipemptysuccessorf = rewriteutil.skip_empty_successor( self.skipemptysuccessorf = rewriteutil.skip_empty_successor(
repo.ui, b'rebase' repo.ui, b'rebase'
) )
self.obsoletenotrebased = {} self.obsoletenotrebased = {}
self.obsoletewithoutsuccessorindestination = set() self.obsoletewithoutsuccessorindestination = set()
self.inmemory = inmemory self.inmemory = inmemory
self.dryrun = dryrun
self.stateobj = statemod.cmdstate(repo, b'rebasestate') self.stateobj = statemod.cmdstate(repo, b'rebasestate')
@property @property
def repo(self): def repo(self):
if self.prepared: if self.prepared:
return self._repo.unfiltered() return self._repo.unfiltered()
else: else:
return self._repo return self._repo
clearstatus(repo) clearstatus(repo)
clearcollapsemsg(repo) clearcollapsemsg(repo)
return _dorebase(ui, repo, action, opts, inmemory=False) return _dorebase(ui, repo, action, opts, inmemory=False)
else: else:
return _dorebase(ui, repo, action, opts) return _dorebase(ui, repo, action, opts)
def _dryrunrebase(ui, repo, action, opts): def _dryrunrebase(ui, repo, action, opts):
rbsrt = rebaseruntime(repo, ui, inmemory=True, opts=opts) rbsrt = rebaseruntime(repo, ui, inmemory=True, dryrun=True, opts=opts)
confirm = opts.get(b'confirm') confirm = opts.get(b'confirm')
if confirm: if confirm:
ui.status(_(b'starting in-memory rebase\n')) ui.status(_(b'starting in-memory rebase\n'))
else: else:
ui.status( ui.status(
_(b'starting dry-run rebase; repository will not be changed\n') _(b'starting dry-run rebase; repository will not be changed\n')
) )
with repo.wlock(), repo.lock(): with repo.wlock(), repo.lock():
needsabort = True needsabort = True
try: try:
overrides = {(b'rebase', b'singletransaction'): True} overrides = {(b'rebase', b'singletransaction'): True}
with ui.configoverride(overrides, b'rebase'): with ui.configoverride(overrides, b'rebase'):
_origrebase( _origrebase(
ui, repo, action, opts, rbsrt, leaveunfinished=True, ui, repo, action, opts, rbsrt,
) )
except error.InMemoryMergeConflictsError: except error.InMemoryMergeConflictsError:
ui.status(_(b'hit a merge conflict\n')) ui.status(_(b'hit a merge conflict\n'))
return 1 return 1
except error.Abort: except error.Abort:
needsabort = False needsabort = False
raise raise
else: else:
isabort=True, isabort=True,
backup=False, backup=False,
suppwarns=True, suppwarns=True,
dryrun=opts.get(b'dry_run'), dryrun=opts.get(b'dry_run'),
) )
def _dorebase(ui, repo, action, opts, inmemory=False): def _dorebase(ui, repo, action, opts, inmemory=False):
rbsrt = rebaseruntime(repo, ui, inmemory, opts) rbsrt = rebaseruntime(repo, ui, inmemory, opts=opts)
return _origrebase(ui, repo, action, opts, rbsrt) return _origrebase(ui, repo, action, opts, rbsrt)
def _origrebase(ui, repo, action, opts, rbsrt, leaveunfinished=False): def _origrebase(ui, repo, action, opts, rbsrt):
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="
with util.acceptintervention(tr): with util.acceptintervention(tr):
# Same logic for the dirstate guard, except we don't create one when # Same logic for the dirstate guard, except we don't create one when
# rebasing in-memory (it's not needed). # rebasing in-memory (it's not needed).
dsguard = None dsguard = None
if singletr and not rbsrt.inmemory: if singletr and not rbsrt.inmemory:
dsguard = dirstateguard.dirstateguard(repo, b'rebase') dsguard = dirstateguard.dirstateguard(repo, b'rebase')
with util.acceptintervention(dsguard): with util.acceptintervention(dsguard):
rbsrt._performrebase(tr) rbsrt._performrebase(tr)
if not leaveunfinished: if not rbsrt.dryrun:
rbsrt._finishrebase() rbsrt._finishrebase()
def _definedestmap(ui, repo, inmemory, destf, srcf, basef, revf, destspace): def _definedestmap(ui, repo, inmemory, destf, srcf, basef, revf, destspace):
"""use revisions argument to define destmap {srcrev: destrev}""" """use revisions argument to define destmap {srcrev: destrev}"""
if revf is None: if revf is None:
revf = [] revf = []