This is an archive of the discontinued Mercurial Phabricator instance.

Differential D971

uncommit: unify functions _uncommitdirstate and _unamenddirstate to one
ClosedPublic

Authored by pulkit on Oct 5 2017, 6:59 PM.

Details

Reviewers
mbthomas
durin42
Group Reviewers
hg-reviewers
Commits
rHG9dadcb99cc17: uncommit: unify functions _uncommitdirstate and _unamenddirstate to one
Summary

The _unamenddirstate() function was inspired by _uncommitdirstate() function as
the logic was same but we were unable to use the latter function directly. So
previous patch introduced the _unamenddirstate() function and now this patch
unifies both the function and we have a _fixdirstate() function.

Adding function in previous patch and unifying in a later patch makes the
reasoning easier and also leaves the last patch dedicated to what it is meant to
be.

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

pulkit created this revision.Oct 5 2017, 6:59 PM
mbthomas accepted this revision.Nov 7 2017, 10:12 AM
pulkit updated this revision to Diff 3422.Nov 11 2017, 9:11 AM
durin42 added subscribers: hooper, martinvonz, durin42.Nov 13 2017, 5:27 PM
durin42 accepted this revision as: durin42.

(Marking accepted, but consider just moving this to scmutil or rewriteutil (I made that second one up, but it might be a sensible thing to have?) in parallel with the inevitable bikeshedding over on D821.

hgext/uncommit.py
101–103

This looks like it should be a utility method in core. I think @martinvonz or @hooper ran into a case where this would have been helpful.

pulkit added a comment.Nov 17 2017, 9:19 AM
In D971#22932, @durin42 wrote:

(Marking accepted, but consider just moving this to scmutil or rewriteutil (I made that second one up, but it might be a sensible thing to have?) in parallel with the inevitable bikeshedding over on D821.

rewriteutil sounds good. This aligns with our plans of moving evolve to core and I will do that.

pulkit updated this revision to Diff 3672.Nov 20 2017, 3:04 PM
Closed by commit rHG9dadcb99cc17: uncommit: unify functions _uncommitdirstate and _unamenddirstate to one (authored by pulkit). · Explain WhyDec 1 2017, 12:33 PM
This revision was automatically updated to reflect the committed changes.
taapas1128 added a subscriber: taapas1128.Mar 11 2019, 2:54 PM
This comment was removed by taapas1128.

Revision Contents
Changeset List

PathPackages
Mhgext/uncommit.py (59 lines)

Diff 4055

hgext/uncommit.py

extra=ctx.extra()) extra=ctx.extra())
# phase handling # phase handling
commitphase = ctx.phase() commitphase = ctx.phase()
overrides = {('phases', 'new-commit'): commitphase} overrides = {('phases', 'new-commit'): commitphase}
with repo.ui.configoverride(overrides, 'uncommit'): with repo.ui.configoverride(overrides, 'uncommit'):
newid = repo.commitctx(new) newid = repo.commitctx(new)
return newid return newid
def _uncommitdirstate(repo, oldctx, match): def _fixdirstate(repo, oldctx, newctx, status):
"""Fix the dirstate after switching the working directory from """ fix the dirstate after switching the working directory from oldctx to
oldctx to a copy of oldctx not containing changed files matched by newctx which can be result of either unamend or uncommit.
durin42Unsubmitted
Not Done

This looks like it should be a utility method in core. I think @martinvonz or @hooper ran into a case where this would have been helpful.

durin42: This looks like it should be a utility method in core. I think @martinvonz or @hooper ran into…
match.
""" """
ctx = repo['.']
ds = repo.dirstate ds = repo.dirstate
copies = dict(ds.copies()) copies = dict(ds.copies())
s = repo.status(oldctx.p1(), oldctx, match=match) s = status
for f in s.modified: for f in s.modified:
if ds[f] == 'r': if ds[f] == 'r':
# modified + removed -> removed # modified + removed -> removed
continue continue
ds.normallookup(f) ds.normallookup(f)
for f in s.added: for f in s.added:
if ds[f] == 'r': if ds[f] == 'r':
src = oldctx[f].renamed() src = oldctx[f].renamed()
if src: if src:
oldcopies[f] = src[0] oldcopies[f] = src[0]
oldcopies.update(copies) oldcopies.update(copies)
copies = dict((dst, oldcopies.get(src, src)) copies = dict((dst, oldcopies.get(src, src))
for dst, src in oldcopies.iteritems()) for dst, src in oldcopies.iteritems())
# Adjust the dirstate copies # Adjust the dirstate copies
for dst, src in copies.iteritems(): for dst, src in copies.iteritems():
if (src not in ctx or dst in ctx or ds[dst] != 'a'): if (src not in newctx or dst in newctx or ds[dst] != 'a'):
src = None src = None
ds.copy(src, dst) ds.copy(src, dst)
@command('uncommit', @command('uncommit',
[('', 'keep', False, _('allow an empty commit after uncommiting')), [('', 'keep', False, _('allow an empty commit after uncommiting')),
] + commands.walkopts, ] + commands.walkopts,
_('[OPTION]... [FILE]...')) _('[OPTION]... [FILE]...'))
def uncommit(ui, repo, *pats, **opts): def uncommit(ui, repo, *pats, **opts):
else: else:
# Fully removed the old commit # Fully removed the old commit
mapping[old.node()] = () mapping[old.node()] = ()
scmutil.cleanupnodes(repo, mapping, 'uncommit') scmutil.cleanupnodes(repo, mapping, 'uncommit')
with repo.dirstate.parentchange(): with repo.dirstate.parentchange():
repo.dirstate.setparents(newid, node.nullid) repo.dirstate.setparents(newid, node.nullid)
_uncommitdirstate(repo, old, match) s = repo.status(old.p1(), old, match=match)
_fixdirstate(repo, old, repo[newid], s)
def predecessormarkers(ctx): def predecessormarkers(ctx):
"""yields the obsolete markers marking the given changeset as a successor""" """yields the obsolete markers marking the given changeset as a successor"""
for data in ctx.repo().obsstore.predecessors.get(ctx.node(), ()): for data in ctx.repo().obsstore.predecessors.get(ctx.node(), ()):
yield obsutil.marker(ctx.repo(), data) yield obsutil.marker(ctx.repo(), data)
def _unamenddirstate(repo, predctx, curctx):
""""""
s = repo.status(predctx, curctx)
ds = repo.dirstate
copies = dict(ds.copies())
for f in s.modified:
if ds[f] == 'r':
# modified + removed -> removed
continue
ds.normallookup(f)
for f in s.added:
if ds[f] == 'r':
# added + removed -> unknown
ds.drop(f)
elif ds[f] != 'a':
ds.add(f)
for f in s.removed:
if ds[f] == 'a':
# removed + added -> normal
ds.normallookup(f)
elif ds[f] != 'r':
ds.remove(f)
# Merge old parent and old working dir copies
oldcopies = {}
for f in (s.modified + s.added):
src = curctx[f].renamed()
if src:
oldcopies[f] = src[0]
oldcopies.update(copies)
copies = dict((dst, oldcopies.get(src, src))
for dst, src in oldcopies.iteritems())
# Adjust the dirstate copies
for dst, src in copies.iteritems():
if (src not in predctx or dst in predctx or ds[dst] != 'a'):
src = None
ds.copy(src, dst)
@command('^unamend', []) @command('^unamend', [])
def unamend(ui, repo, **opts): def unamend(ui, repo, **opts):
""" """
undo the most recent amend operation on a current changeset undo the most recent amend operation on a current changeset
This command will roll back to the previous version of a changeset, This command will roll back to the previous version of a changeset,
leaving working directory in state in which it was before running leaving working directory in state in which it was before running
`hg amend` (e.g. files modified as part of an amend will be `hg amend` (e.g. files modified as part of an amend will be
wm = wctx.manifest() wm = wctx.manifest()
cm = newpredctx.manifest() cm = newpredctx.manifest()
dirstate = repo.dirstate dirstate = repo.dirstate
diff = cm.diff(wm) diff = cm.diff(wm)
changedfiles.extend(diff.iterkeys()) changedfiles.extend(diff.iterkeys())
with dirstate.parentchange(): with dirstate.parentchange():
dirstate.setparents(newprednode, node.nullid) dirstate.setparents(newprednode, node.nullid)
_unamenddirstate(repo, newpredctx, curctx) s = repo.status(predctx, curctx)
_fixdirstate(repo, curctx, newpredctx, s)
mapping = {curctx.node(): (newprednode,)} mapping = {curctx.node(): (newprednode,)}
scmutil.cleanupnodes(repo, mapping, 'unamend') scmutil.cleanupnodes(repo, mapping, 'unamend')