comparison mercurial/scmutil.py @ 34353:2dbd6d259cd2 stable

cleanupnodes: rename "mapping" to "replacements"

The next patch will pass in overrides for bookmark moves, which is a
mapping itself, so let's rename "mapping" to "replacements" to
distinguish them better.

Differential Revision: https://phab.mercurial-scm.org/D749

34352:033a5befbaf7

        self._revcontains = revcontainer.__contains__

    def __contains__(self, node):
        return self._revcontains(self._torev(node))

def cleanupnodes(repo, mapping, operation):
    """do common cleanups when old nodes are replaced by new nodes

    That includes writing obsmarkers or stripping nodes, and moving bookmarks.
    (we might also want to move working directory parent in the future)

    mapping is {oldnode: [newnode]} or a iterable of nodes if they do not have
    replacements. operation is a string, like "rebase".
    """
    if not util.safehasattr(mapping, 'items'):
        mapping = {n: () for n in mapping}

    # Calculate bookmark movements
    moves = {}
    # Unfiltered repo is needed since nodes in mapping might be hidden.
    unfi = repo.unfiltered()
    for oldnode, newnodes in mapping.items():
        if len(newnodes) > 1:
            # usually a split, take the one with biggest rev number
            newnode = next(unfi.set('max(%ln)', newnodes)).node()
        elif len(newnodes) == 0:
            # move bookmark backwards
            roots = list(unfi.set('max((::%n) - %ln)', oldnode,
                                  list(mapping)))
            if roots:
                newnode = roots[0].node()
            else:
                newnode = nullid
        else:

    with repo.transaction('cleanup') as tr:
        # Move bookmarks
        bmarks = repo._bookmarks
        bmarkchanges = []
        allnewnodes = [n for ns in mapping.values() for n in ns]
        for oldnode, newnode in moves.items():
            oldbmarks = repo.nodebookmarks(oldnode)
            if not oldbmarks:
                continue
            from . import bookmarks # avoid import cycle

            # NOTE: the filtering and sorting might belong to createmarkers.
            isobs = unfi.obsstore.successors.__contains__
            torev = unfi.changelog.rev
            sortfunc = lambda ns: torev(ns[0])
            rels = [(unfi[n], tuple(unfi[m] for m in s))
                    for n, s in sorted(mapping.items(), key=sortfunc)
                    if s or not isobs(n)]
            obsolete.createmarkers(repo, rels, operation=operation)
        else:
            from . import repair # avoid import cycle
            repair.delayedstrip(repo.ui, repo, list(mapping), operation)

def addremove(repo, matcher, prefix, opts=None, dry_run=None, similarity=None):
    if opts is None:
        opts = {}
    m = matcher

34353:2dbd6d259cd2

        self._revcontains = revcontainer.__contains__

    def __contains__(self, node):
        return self._revcontains(self._torev(node))

def cleanupnodes(repo, replacements, operation):
    """do common cleanups when old nodes are replaced by new nodes

    That includes writing obsmarkers or stripping nodes, and moving bookmarks.
    (we might also want to move working directory parent in the future)

    replacements is {oldnode: [newnode]} or a iterable of nodes if they do not
    have replacements. operation is a string, like "rebase".
    """
    if not util.safehasattr(replacements, 'items'):
        replacements = {n: () for n in replacements}

    # Calculate bookmark movements
    moves = {}
    # Unfiltered repo is needed since nodes in replacements might be hidden.
    unfi = repo.unfiltered()
    for oldnode, newnodes in replacements.items():
        if len(newnodes) > 1:
            # usually a split, take the one with biggest rev number
            newnode = next(unfi.set('max(%ln)', newnodes)).node()
        elif len(newnodes) == 0:
            # move bookmark backwards
            roots = list(unfi.set('max((::%n) - %ln)', oldnode,
                                  list(replacements)))
            if roots:
                newnode = roots[0].node()
            else:
                newnode = nullid
        else:

    with repo.transaction('cleanup') as tr:
        # Move bookmarks
        bmarks = repo._bookmarks
        bmarkchanges = []
        allnewnodes = [n for ns in replacements.values() for n in ns]
        for oldnode, newnode in moves.items():
            oldbmarks = repo.nodebookmarks(oldnode)
            if not oldbmarks:
                continue
            from . import bookmarks # avoid import cycle

            # NOTE: the filtering and sorting might belong to createmarkers.
            isobs = unfi.obsstore.successors.__contains__
            torev = unfi.changelog.rev
            sortfunc = lambda ns: torev(ns[0])
            rels = [(unfi[n], tuple(unfi[m] for m in s))
                    for n, s in sorted(replacements.items(), key=sortfunc)
                    if s or not isobs(n)]
            obsolete.createmarkers(repo, rels, operation=operation)
        else:
            from . import repair # avoid import cycle
            repair.delayedstrip(repo.ui, repo, list(replacements), operation)

def addremove(repo, matcher, prefix, opts=None, dry_run=None, similarity=None):
    if opts is None:
        opts = {}
    m = matcher