comparison mercurial/merge.py @ 45274:0e18861f96ab

merge: return a mergeresult obj from manifestmerge(), calculateupdates() (API)

Earlier, manifestmerge() and calculateupdates() returns a tuple of three things.
I wanted to add one more thing to return value.

Introducing a special class which represents results of a merge will help
understand better and also ease adding new return values.

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

45270:c8655782ef19

            raise error.Abort(
                _(b'conflict in file \'%s\' is outside narrow clone') % f
            )


def manifestmerge(
    repo,
    wctx,
    p2,
    pa,

    branchmerge and force are as passed in to update
    matcher = matcher to filter file lists
    acceptremote = accept the incoming changes without prompting

    Returns:

    actions: dict of filename as keys and action related info as values
    diverge: mapping of source name -> list of dest name for divergent renames
    renamedelete: mapping of source name -> list of destinations for files
                  deleted on one side and renamed on other.
    """
    if matcher is not None and matcher.always():
        matcher = None

    # manifests fetched in order are going to be faster, so prime the caches

        _filternarrowactions(narrowmatch, branchmerge, actions)

    renamedelete = branch_copies1.renamedelete
    renamedelete.update(branch_copies2.renamedelete)

    return actions, diverge, renamedelete


def _resolvetrivial(repo, wctx, mctx, ancestor, actions):
    """Resolves false conflicts where the nodeid changed but the content
       remained the same."""

    perform for merging two manifests. If there are multiple ancestors, uses bid
    merge if enabled.

    Also filters out actions which are unrequired if repository is sparse.

    Returns same 3 element tuple as manifestmerge().
    """
    # Avoid cycle.
    from . import sparse

    if len(ancestors) == 1:  # default
        actions, diverge, renamedelete = manifestmerge(
            repo,
            wctx,
            mctx,
            ancestors[0],
            branchmerge,
            force,
            matcher,
            acceptremote,
            followcopies,
        )
        _checkunknownfiles(repo, wctx, mctx, force, actions, mergeforce)

    else:  # only when merge.preferancestor=* - the default
        repo.ui.note(
            _(b"note: merging %s and %s using bids from ancestors %s\n")
            % (

            {}
        )  # mapping filename to bids (action method to list af actions)
        diverge, renamedelete = None, None
        for ancestor in ancestors:
            repo.ui.note(_(b'\ncalculating bids for ancestor %s\n') % ancestor)
            actions, diverge1, renamedelete1 = manifestmerge(
                repo,
                wctx,
                mctx,
                ancestor,
                branchmerge,

                matcher,
                acceptremote,
                followcopies,
                forcefulldiff=True,
            )
            _checkunknownfiles(repo, wctx, mctx, force, actions, mergeforce)

            # Track the shortest set of warning on the theory that bid
            # merge will correctly incorporate more information
            if diverge is None or len(diverge1) < len(diverge):
                diverge = diverge1
            if renamedelete is None or len(renamedelete) < len(renamedelete1):
                renamedelete = renamedelete1

            for f, a in sorted(pycompat.iteritems(actions)):
                m, args, msg = a
                if m == mergestatemod.ACTION_GET_OTHER_AND_STORE:
                    m = mergestatemod.ACTION_GET
                repo.ui.debug(b' %s: %s -> %s\n' % (f, msg, m))
                if f in fbids:

                _(b' %s: ambiguous merge - picked %s action\n') % (f, m)
            )
            actions[f] = l[0]
            continue
        repo.ui.note(_(b'end of auction\n\n'))

    if wctx.rev() is None:
        fractions = _forgetremoved(wctx, mctx, branchmerge)
        actions.update(fractions)

    prunedactions = sparse.filterupdatesactions(
        repo, wctx, mctx, branchmerge, actions
    )
    _resolvetrivial(repo, wctx, mctx, ancestors[0], actions)

    return prunedactions, diverge, renamedelete


def _getcwd():
    try:
        return encoding.getcwd()

            followcopies = False
        if not branchmerge and not wc.dirty(missing=True):
            followcopies = False

        ### calculate phase
        actionbyfile, diverge, renamedelete = calculateupdates(
            repo,
            wc,
            p2,
            pas,
            branchmerge,

            mergeancestor,
            followcopies,
            matcher=matcher,
            mergeforce=mergeforce,
        )

        if updatecheck == UPDATECHECK_NO_CONFLICT:
            for f, (m, args, msg) in pycompat.iteritems(actionbyfile):
                if m not in (
                    mergestatemod.ACTION_GET,

                _checkcollision(repo, p2.manifest(), None)
            else:
                _checkcollision(repo, wc.manifest(), actions)

        # divergent renames
        for f, fl in sorted(pycompat.iteritems(diverge)):
            repo.ui.warn(
                _(
                    b"note: possible conflict - %s was renamed "
                    b"multiple times to:\n"
                )

            )
            for nf in sorted(fl):
                repo.ui.warn(b" %s\n" % nf)

        # rename and delete
        for f, fl in sorted(pycompat.iteritems(renamedelete)):
            repo.ui.warn(
                _(
                    b"note: possible conflict - %s was deleted "
                    b"and renamed to:\n"
                )

45274:0e18861f96ab

            raise error.Abort(
                _(b'conflict in file \'%s\' is outside narrow clone') % f
            )


class mergeresult(object):
    ''''An object representing result of merging manifests.

    It has information about what actions need to be performed on dirstate
    mapping of divergent renames and other such cases. '''

    def __init__(self, actions, diverge, renamedelete):
        """
        actions: dict of filename as keys and action related info as values
        diverge: mapping of source name -> list of dest name for
                 divergent renames
        renamedelete: mapping of source name -> list of destinations for files
                      deleted on one side and renamed on other.
        """

        self._actions = actions
        self._diverge = diverge
        self._renamedelete = renamedelete

    @property
    def actions(self):
        return self._actions

    @property
    def diverge(self):
        return self._diverge

    @property
    def renamedelete(self):
        return self._renamedelete

    def setactions(self, actions):
        self._actions = actions


def manifestmerge(
    repo,
    wctx,
    p2,
    pa,

    branchmerge and force are as passed in to update
    matcher = matcher to filter file lists
    acceptremote = accept the incoming changes without prompting

    Returns an object of mergeresult class
    """
    if matcher is not None and matcher.always():
        matcher = None

    # manifests fetched in order are going to be faster, so prime the caches

        _filternarrowactions(narrowmatch, branchmerge, actions)

    renamedelete = branch_copies1.renamedelete
    renamedelete.update(branch_copies2.renamedelete)

    return mergeresult(actions, diverge, renamedelete)


def _resolvetrivial(repo, wctx, mctx, ancestor, actions):
    """Resolves false conflicts where the nodeid changed but the content
       remained the same."""

    perform for merging two manifests. If there are multiple ancestors, uses bid
    merge if enabled.

    Also filters out actions which are unrequired if repository is sparse.

    Returns mergeresult object same as manifestmerge().
    """
    # Avoid cycle.
    from . import sparse

    if len(ancestors) == 1:  # default
        mresult = manifestmerge(
            repo,
            wctx,
            mctx,
            ancestors[0],
            branchmerge,
            force,
            matcher,
            acceptremote,
            followcopies,
        )
        _checkunknownfiles(repo, wctx, mctx, force, mresult.actions, mergeforce)

    else:  # only when merge.preferancestor=* - the default
        repo.ui.note(
            _(b"note: merging %s and %s using bids from ancestors %s\n")
            % (

            {}
        )  # mapping filename to bids (action method to list af actions)
        diverge, renamedelete = None, None
        for ancestor in ancestors:
            repo.ui.note(_(b'\ncalculating bids for ancestor %s\n') % ancestor)
            mresult1 = manifestmerge(
                repo,
                wctx,
                mctx,
                ancestor,
                branchmerge,

                matcher,
                acceptremote,
                followcopies,
                forcefulldiff=True,
            )
            _checkunknownfiles(
                repo, wctx, mctx, force, mresult1.actions, mergeforce
            )

            # Track the shortest set of warning on the theory that bid
            # merge will correctly incorporate more information
            if diverge is None or len(mresult1.diverge) < len(diverge):
                diverge = mresult1.diverge
            if renamedelete is None or len(renamedelete) < len(
                mresult1.renamedelete
            ):
                renamedelete = mresult1.renamedelete

            for f, a in sorted(pycompat.iteritems(mresult1.actions)):
                m, args, msg = a
                if m == mergestatemod.ACTION_GET_OTHER_AND_STORE:
                    m = mergestatemod.ACTION_GET
                repo.ui.debug(b' %s: %s -> %s\n' % (f, msg, m))
                if f in fbids:

                _(b' %s: ambiguous merge - picked %s action\n') % (f, m)
            )
            actions[f] = l[0]
            continue
        repo.ui.note(_(b'end of auction\n\n'))
        mresult = mergeresult(actions, diverge, renamedelete)

    if wctx.rev() is None:
        fractions = _forgetremoved(wctx, mctx, branchmerge)
        mresult.actions.update(fractions)

    prunedactions = sparse.filterupdatesactions(
        repo, wctx, mctx, branchmerge, mresult.actions
    )
    _resolvetrivial(repo, wctx, mctx, ancestors[0], mresult.actions)

    mresult.setactions(prunedactions)
    return mresult


def _getcwd():
    try:
        return encoding.getcwd()

            followcopies = False
        if not branchmerge and not wc.dirty(missing=True):
            followcopies = False

        ### calculate phase
        mresult = calculateupdates(
            repo,
            wc,
            p2,
            pas,
            branchmerge,

            mergeancestor,
            followcopies,
            matcher=matcher,
            mergeforce=mergeforce,
        )

        actionbyfile = mresult.actions

        if updatecheck == UPDATECHECK_NO_CONFLICT:
            for f, (m, args, msg) in pycompat.iteritems(actionbyfile):
                if m not in (
                    mergestatemod.ACTION_GET,

                _checkcollision(repo, p2.manifest(), None)
            else:
                _checkcollision(repo, wc.manifest(), actions)

        # divergent renames
        for f, fl in sorted(pycompat.iteritems(mresult.diverge)):
            repo.ui.warn(
                _(
                    b"note: possible conflict - %s was renamed "
                    b"multiple times to:\n"
                )

            )
            for nf in sorted(fl):
                repo.ui.warn(b" %s\n" % nf)

        # rename and delete
        for f, fl in sorted(pycompat.iteritems(mresult.renamedelete)):
            repo.ui.warn(
                _(
                    b"note: possible conflict - %s was deleted "
                    b"and renamed to:\n"
                )