| hg-reviewers |
This also updates all applicable callers so we get some testing of it.
Note that rebase and histedit can't be fixed yet because they call
cleanupnodes() only at the end and the phase may have been changed by
the user when the rebase/histedit was interrupted (due to merge
conflicts).
Also not that amend can't rely on cleanupnodes, because it allows the
phase to be overridden on the command line (using `hg amend
--secret`).
| Lint Skipped |
| Unit Tests Skipped |
| Path | Packages | |||
|---|---|---|---|---|
| M | contrib/phabricator.py (6 lines) | |||
| M | hgext/fix.py (38 lines) | |||
| M | hgext/uncommit.py (18 lines) | |||
| M | mercurial/cmdutil.py (8 lines) | |||
| M | mercurial/scmutil.py (33 lines) |
| Commit | Parents | Author | Summary | Date |
|---|---|---|---|---|
| Martin von Zweigbergk | Jun 19 2018, 2:07 PM |
| Status | Author | Revision | |
|---|---|---|---|
| Abandoned | martinvonz | ||
| Abandoned | martinvonz | ||
| Abandoned | martinvonz |
| parents = [ | parents = [ | ||||
| mapping.get(old.p1().node(), (old.p1(),))[0], | mapping.get(old.p1().node(), (old.p1(),))[0], | ||||
| mapping.get(old.p2().node(), (old.p2(),))[0], | mapping.get(old.p2().node(), (old.p2(),))[0], | ||||
| ] | ] | ||||
| new = context.metadataonlyctx( | new = context.metadataonlyctx( | ||||
| repo, old, parents=parents, text=newdesc, | repo, old, parents=parents, text=newdesc, | ||||
| user=old.user(), date=old.date(), extra=old.extra()) | user=old.user(), date=old.date(), extra=old.extra()) | ||||
| overrides = {(b'phases', b'new-commit'): old.phase()} | |||||
| with ui.configoverride(overrides, b'phabsend'): | |||||
| newnode = new.commit() | newnode = new.commit() | ||||
| mapping[old.node()] = [newnode] | mapping[old.node()] = [newnode] | ||||
| # Update diff property | # Update diff property | ||||
| writediffproperties(unfi[newnode], diffmap[old.node()]) | writediffproperties(unfi[newnode], diffmap[old.node()]) | ||||
| # Remove local tags since it's no longer necessary | # Remove local tags since it's no longer necessary | ||||
| tagname = b'D%d' % drevid | tagname = b'D%d' % drevid | ||||
| if tagname in repo.tags(): | if tagname in repo.tags(): | ||||
| tags.tag(repo, tagname, nullid, message=None, user=None, | tags.tag(repo, tagname, nullid, message=None, user=None, | ||||
| date=None, local=True) | date=None, local=True) | ||||
| scmutil.cleanupnodes(repo, mapping, b'phabsend') | scmutil.cleanupnodes(repo, mapping, b'phabsend', fixphase=True) | ||||
| if wnode in mapping: | if wnode in mapping: | ||||
| unfi.setparents(mapping[wnode][0]) | unfi.setparents(mapping[wnode][0]) | ||||
| # Map from "hg:meta" keys to header understood by "hg import". The order is | # Map from "hg:meta" keys to header understood by "hg import". The order is | ||||
| # consistent with "hg export" output. | # consistent with "hg export" output. | ||||
| _metanamemap = util.sortdict([(r'user', b'User'), (r'date', b'Date'), | _metanamemap = util.sortdict([(r'user', b'User'), (r'date', b'Date'), | ||||
| (r'node', b'Node ID'), (r'parent', b'Parent ')]) | (r'node', b'Node ID'), (r'parent', b'Parent ')]) | ||||
| if not numitems[rev]: | if not numitems[rev]: | ||||
| if rev == wdirrev: | if rev == wdirrev: | ||||
| writeworkingdir(repo, ctx, filedata[rev], replacements) | writeworkingdir(repo, ctx, filedata[rev], replacements) | ||||
| else: | else: | ||||
| replacerev(ui, repo, ctx, filedata[rev], replacements) | replacerev(ui, repo, ctx, filedata[rev], replacements) | ||||
| del filedata[rev] | del filedata[rev] | ||||
| replacements = {prec: [succ] for prec, succ in replacements.iteritems()} | replacements = {prec: [succ] for prec, succ in replacements.iteritems()} | ||||
| scmutil.cleanupnodes(repo, replacements, 'fix') | scmutil.cleanupnodes(repo, replacements, 'fix', fixphase=True) | ||||
| def getworkqueue(ui, repo, pats, opts, revstofix, basectxs): | def getworkqueue(ui, repo, pats, opts, revstofix, basectxs): | ||||
| """"Constructs the list of files to be fixed at specific revisions | """"Constructs the list of files to be fixed at specific revisions | ||||
| It is up to the caller how to consume the work items, and the only | It is up to the caller how to consume the work items, and the only | ||||
| dependence between them is that replacement revisions must be committed in | dependence between them is that replacement revisions must be committed in | ||||
| topological order. Each work item represents a file in the working copy or | topological order. Each work item represents a file in the working copy or | ||||
| in some revision that should be fixed and written back to the working copy | in some revision that should be fixed and written back to the working copy | ||||
| repo, | repo, | ||||
| memctx, | memctx, | ||||
| path=fctx.path(), | path=fctx.path(), | ||||
| data=filedata.get(path, fctx.data()), | data=filedata.get(path, fctx.data()), | ||||
| islink=fctx.islink(), | islink=fctx.islink(), | ||||
| isexec=fctx.isexec(), | isexec=fctx.isexec(), | ||||
| copied=copied) | copied=copied) | ||||
| overrides = {('phases', 'new-commit'): ctx.phase()} | |||||
| with ui.configoverride(overrides, source='fix'): | |||||
| memctx = context.memctx( | memctx = context.memctx( | ||||
| repo, | repo, | ||||
| parents=(newp1node, newp2node), | parents=(newp1node, newp2node), | ||||
| text=ctx.description(), | text=ctx.description(), | ||||
| files=set(ctx.files()) | set(filedata.keys()), | files=set(ctx.files()) | set(filedata.keys()), | ||||
| filectxfn=filectxfn, | filectxfn=filectxfn, | ||||
| user=ctx.user(), | user=ctx.user(), | ||||
| date=ctx.date(), | date=ctx.date(), | ||||
| extra=ctx.extra(), | extra=ctx.extra(), | ||||
| branch=ctx.branch(), | branch=ctx.branch(), | ||||
| editor=None) | editor=None) | ||||
| sucnode = memctx.commit() | sucnode = memctx.commit() | ||||
| prenode = ctx.node() | prenode = ctx.node() | ||||
| if prenode == sucnode: | if prenode == sucnode: | ||||
| ui.debug('node %s already existed\n' % (ctx.hex())) | ui.debug('node %s already existed\n' % (ctx.hex())) | ||||
| else: | else: | ||||
| replacements[ctx.node()] = sucnode | replacements[ctx.node()] = sucnode | ||||
| def getfixers(ui): | def getfixers(ui): | ||||
| """Returns a map of configured fixer tools indexed by their names | """Returns a map of configured fixer tools indexed by their names | ||||
| Each value is a Fixer object with methods that implement the behavior of the | Each value is a Fixer object with methods that implement the behavior of the | ||||
| fixer's config suboptions. Does not validate the config values. | fixer's config suboptions. Does not validate the config values. | ||||
| """ | """ | ||||
| result = {} | result = {} | ||||
| new = context.memctx(repo, | new = context.memctx(repo, | ||||
| parents=[base.node(), node.nullid], | parents=[base.node(), node.nullid], | ||||
| text=ctx.description(), | text=ctx.description(), | ||||
| files=files, | files=files, | ||||
| filectxfn=filectxfn, | filectxfn=filectxfn, | ||||
| user=ctx.user(), | user=ctx.user(), | ||||
| date=ctx.date(), | date=ctx.date(), | ||||
| extra=ctx.extra()) | extra=ctx.extra()) | ||||
| # phase handling | return repo.commitctx(new) | ||||
| commitphase = ctx.phase() | |||||
| overrides = {('phases', 'new-commit'): commitphase} | |||||
| with repo.ui.configoverride(overrides, 'uncommit'): | |||||
| newid = repo.commitctx(new) | |||||
| return newid | |||||
| def _fixdirstate(repo, oldctx, newctx, status): | def _fixdirstate(repo, oldctx, newctx, status): | ||||
| """ fix the dirstate after switching the working directory from oldctx to | """ fix the dirstate after switching the working directory from oldctx to | ||||
| newctx which can be result of either unamend or uncommit. | newctx which can be result of either unamend or uncommit. | ||||
| """ | """ | ||||
| ds = repo.dirstate | ds = repo.dirstate | ||||
| copies = dict(ds.copies()) | copies = dict(ds.copies()) | ||||
| s = status | s = status | ||||
| mapping = {} | mapping = {} | ||||
| if newid != old.p1().node(): | if newid != old.p1().node(): | ||||
| # Move local changes on filtered changeset | # Move local changes on filtered changeset | ||||
| mapping[old.node()] = (newid,) | mapping[old.node()] = (newid,) | ||||
| 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', fixphase=True) | ||||
| with repo.dirstate.parentchange(): | with repo.dirstate.parentchange(): | ||||
| repo.dirstate.setparents(newid, node.nullid) | repo.dirstate.setparents(newid, node.nullid) | ||||
| s = repo.status(old.p1(), old, match=match) | s = repo.status(old.p1(), old, match=match) | ||||
| _fixdirstate(repo, old, repo[newid], s) | _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""" | ||||
| newctx = context.memctx(repo, | newctx = context.memctx(repo, | ||||
| parents=(predctx.p1(), predctx.p2()), | parents=(predctx.p1(), predctx.p2()), | ||||
| text=predctx.description(), | text=predctx.description(), | ||||
| files=predctx.files(), | files=predctx.files(), | ||||
| filectxfn=filectxfn, | filectxfn=filectxfn, | ||||
| user=predctx.user(), | user=predctx.user(), | ||||
| date=predctx.date(), | date=predctx.date(), | ||||
| extra=extras) | extra=extras) | ||||
| # phase handling | |||||
| commitphase = curctx.phase() | |||||
| overrides = {('phases', 'new-commit'): commitphase} | |||||
| with repo.ui.configoverride(overrides, 'uncommit'): | |||||
| newprednode = repo.commitctx(newctx) | newprednode = repo.commitctx(newctx) | ||||
| newpredctx = repo[newprednode] | newpredctx = repo[newprednode] | ||||
| dirstate = repo.dirstate | dirstate = repo.dirstate | ||||
| with dirstate.parentchange(): | with dirstate.parentchange(): | ||||
| dirstate.setparents(newprednode, node.nullid) | dirstate.setparents(newprednode, node.nullid) | ||||
| s = repo.status(predctx, curctx) | s = repo.status(predctx, curctx) | ||||
| _fixdirstate(repo, curctx, newpredctx, s) | _fixdirstate(repo, curctx, newpredctx, s) | ||||
| mapping = {curctx.node(): (newprednode,)} | mapping = {curctx.node(): (newprednode,)} | ||||
| scmutil.cleanupnodes(repo, mapping, 'unamend') | scmutil.cleanupnodes(repo, mapping, 'unamend', fixphase=True) | ||||
| ctx.description(), | ctx.description(), | ||||
| ctx.files(), | ctx.files(), | ||||
| filectxfn, | filectxfn, | ||||
| user=ctx.user(), | user=ctx.user(), | ||||
| date=ctx.date(), | date=ctx.date(), | ||||
| extra=extra, | extra=extra, | ||||
| branch=label) | branch=label) | ||||
| commitphase = ctx.phase() | |||||
| overrides = {('phases', 'new-commit'): commitphase} | |||||
| with repo.ui.configoverride(overrides, 'branch-change'): | |||||
| newnode = repo.commitctx(mc) | newnode = repo.commitctx(mc) | ||||
| replacements[ctx.node()] = (newnode,) | replacements[ctx.node()] = (newnode,) | ||||
| ui.debug('new node id is %s\n' % hex(newnode)) | ui.debug('new node id is %s\n' % hex(newnode)) | ||||
| # create obsmarkers and move bookmarks | # create obsmarkers and move bookmarks | ||||
| scmutil.cleanupnodes(repo, replacements, 'branch-change') | scmutil.cleanupnodes(repo, replacements, 'branch-change', fixphase=True) | ||||
| # move the working copy too | # move the working copy too | ||||
| wctx = repo[None] | wctx = repo[None] | ||||
| # in-progress merge is a bit too complex for now. | # in-progress merge is a bit too complex for now. | ||||
| if len(wctx.parents()) == 1: | if len(wctx.parents()) == 1: | ||||
| newid = replacements.get(wctx.p1().node()) | newid = replacements.get(wctx.p1().node()) | ||||
| if newid is not None: | if newid is not None: | ||||
| # avoid import cycle mercurial.cmdutil -> mercurial.hg -> | # avoid import cycle mercurial.cmdutil -> mercurial.hg -> | ||||
| def __init__(self, repo, revcontainer): | def __init__(self, repo, revcontainer): | ||||
| self._torev = repo.changelog.rev | self._torev = repo.changelog.rev | ||||
| self._revcontains = revcontainer.__contains__ | self._revcontains = revcontainer.__contains__ | ||||
| def __contains__(self, node): | def __contains__(self, node): | ||||
| return self._revcontains(self._torev(node)) | return self._revcontains(self._torev(node)) | ||||
| def cleanupnodes(repo, replacements, operation, moves=None, metadata=None): | def cleanupnodes(repo, replacements, operation, moves=None, metadata=None, | ||||
| fixphase=False): | |||||
| """do common cleanups when old nodes are replaced by new nodes | """do common cleanups when old nodes are replaced by new nodes | ||||
| That includes writing obsmarkers or stripping nodes, and moving bookmarks. | That includes writing obsmarkers or stripping nodes, and moving bookmarks. | ||||
| (we might also want to move working directory parent in the future) | (we might also want to move working directory parent in the future) | ||||
| By default, bookmark moves are calculated automatically from 'replacements', | By default, bookmark moves are calculated automatically from 'replacements', | ||||
| but 'moves' can be used to override that. Also, 'moves' may include | but 'moves' can be used to override that. Also, 'moves' may include | ||||
| additional bookmark moves that should not have associated obsmarkers. | additional bookmark moves that should not have associated obsmarkers. | ||||
| if roots: | if roots: | ||||
| newnode = roots[0].node() | newnode = roots[0].node() | ||||
| else: | else: | ||||
| newnode = nullid | newnode = nullid | ||||
| else: | else: | ||||
| newnode = newnodes[0] | newnode = newnodes[0] | ||||
| moves[oldnode] = newnode | moves[oldnode] = newnode | ||||
| allnewnodes = [n for ns in replacements.values() for n in ns] | |||||
| toretract = {} | |||||
| toadvance = {} | |||||
| if fixphase: | |||||
| precursors = {} | |||||
| for oldnode, newnodes in replacements.items(): | |||||
| for newnode in newnodes: | |||||
| precursors.setdefault(newnode, []).append(oldnode) | |||||
| allnewnodes.sort(key=lambda n: repo[n].rev()) | |||||
| newphase = {} | |||||
| def phase(ctx): | |||||
| return newphase.get(ctx.node(), ctx.phase()) | |||||
| for newnode in allnewnodes: | |||||
| ctx = repo[newnode] | |||||
| oldphase = max(repo[oldnode].phase() | |||||
| for oldnode in precursors[newnode]) | |||||
| parentphase = max(phase(p) for p in ctx.parents()) | |||||
| newphase[newnode] = max(oldphase, parentphase) | |||||
| if newphase[newnode] > ctx.phase(): | |||||
| toretract.setdefault(newphase[newnode], []).append(newnode) | |||||
| elif newphase[newnode] < ctx.phase(): | |||||
| toadvance.setdefault(newphase[newnode], []).append(newnode) | |||||
| with repo.transaction('cleanup') as tr: | with repo.transaction('cleanup') as tr: | ||||
| # Move bookmarks | # Move bookmarks | ||||
| bmarks = repo._bookmarks | bmarks = repo._bookmarks | ||||
| bmarkchanges = [] | bmarkchanges = [] | ||||
| allnewnodes = [n for ns in replacements.values() for n in ns] | |||||
| for oldnode, newnode in moves.items(): | for oldnode, newnode in moves.items(): | ||||
| oldbmarks = repo.nodebookmarks(oldnode) | oldbmarks = repo.nodebookmarks(oldnode) | ||||
| if not oldbmarks: | if not oldbmarks: | ||||
| continue | continue | ||||
| from . import bookmarks # avoid import cycle | from . import bookmarks # avoid import cycle | ||||
| repo.ui.debug('moving bookmarks %r from %s to %s\n' % | repo.ui.debug('moving bookmarks %r from %s to %s\n' % | ||||
| (util.rapply(pycompat.maybebytestr, oldbmarks), | (util.rapply(pycompat.maybebytestr, oldbmarks), | ||||
| hex(oldnode), hex(newnode))) | hex(oldnode), hex(newnode))) | ||||
| # Delete divergent bookmarks being parents of related newnodes | # Delete divergent bookmarks being parents of related newnodes | ||||
| deleterevs = repo.revs('parents(roots(%ln & (::%n))) - parents(%n)', | deleterevs = repo.revs('parents(roots(%ln & (::%n))) - parents(%n)', | ||||
| allnewnodes, newnode, oldnode) | allnewnodes, newnode, oldnode) | ||||
| deletenodes = _containsnode(repo, deleterevs) | deletenodes = _containsnode(repo, deleterevs) | ||||
| for name in oldbmarks: | for name in oldbmarks: | ||||
| bmarkchanges.append((name, newnode)) | bmarkchanges.append((name, newnode)) | ||||
| for b in bookmarks.divergent2delete(repo, deletenodes, name): | for b in bookmarks.divergent2delete(repo, deletenodes, name): | ||||
| bmarkchanges.append((b, None)) | bmarkchanges.append((b, None)) | ||||
| if bmarkchanges: | if bmarkchanges: | ||||
| bmarks.applychanges(repo, tr, bmarkchanges) | bmarks.applychanges(repo, tr, bmarkchanges) | ||||
| for phase, nodes in toretract.items(): | |||||
| phases.retractboundary(repo, tr, phase, nodes) | |||||
| for phase, nodes in toadvance.items(): | |||||
| phases.advanceboundary(repo, tr, phase, nodes) | |||||
| # Obsolete or strip nodes | # Obsolete or strip nodes | ||||
| if obsolete.isenabled(repo, obsolete.createmarkersopt): | if obsolete.isenabled(repo, obsolete.createmarkersopt): | ||||
| # If a node is already obsoleted, and we want to obsolete it | # If a node is already obsoleted, and we want to obsolete it | ||||
| # without a successor, skip that obssolete request since it's | # without a successor, skip that obssolete request since it's | ||||
| # unnecessary. That's the "if s or not isobs(n)" check below. | # unnecessary. That's the "if s or not isobs(n)" check below. | ||||
| # Also sort the node in topology order, that might be useful for | # Also sort the node in topology order, that might be useful for | ||||
| # some obsstore logic. | # some obsstore logic. | ||||
| # NOTE: the filtering and sorting might belong to createmarkers. | # NOTE: the filtering and sorting might belong to createmarkers. | ||||