comparison mercurial/filemerge.py @ 48505:40522aea2f27

filemerge: remove unused `orig` argument from tool functions

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

48504:ba34141f8dbb

            if newdata != data:
                util.writefile(file, newdata)


@internaltool(b'prompt', nomerge)
def _iprompt(repo, mynode, orig, fcd, fco, fca, toolconf, labels=None):
    """Asks the user which of the local `p1()` or the other `p2()` version to
    keep as the merged version."""
    ui = repo.ui
    fd = fcd.path()
    uipathfn = scmutil.getuipathfn(repo)

                2,
            )
            choice = [b'local', b'other', b'unresolved'][index]

        if choice == b'other':
            return _iother(repo, mynode, orig, fcd, fco, fca, toolconf, labels)
        elif choice == b'local':
            return _ilocal(repo, mynode, orig, fcd, fco, fca, toolconf, labels)
        elif choice == b'unresolved':
            return _ifail(repo, mynode, orig, fcd, fco, fca, toolconf, labels)
    except error.ResponseExpected:
        ui.write(b"\n")
        return _ifail(repo, mynode, orig, fcd, fco, fca, toolconf, labels)


@internaltool(b'local', nomerge)
def _ilocal(repo, mynode, orig, fcd, fco, fca, toolconf, labels=None):
    """Uses the local `p1()` version of files as the merged version."""
    return 0, fcd.isabsent()


@internaltool(b'other', nomerge)
def _iother(repo, mynode, orig, fcd, fco, fca, toolconf, labels=None):
    """Uses the other `p2()` version of files as the merged version."""
    if fco.isabsent():
        # local changed, remote deleted -- 'deleted' picked
        _underlyingfctxifabsent(fcd).remove()
        deleted = True

        deleted = False
    return 0, deleted


@internaltool(b'fail', nomerge)
def _ifail(repo, mynode, orig, fcd, fco, fca, toolconf, labels=None):
    """
    Rather than attempting to merge files that were modified on both
    branches, it marks them as unresolved. The resolve command must be
    used to resolve these conflicts."""
    # for change/delete conflicts write out the changed version, then fail

            # restore from backup and try again
            _restorebackup(fcd, backup)
    return 1  # continue merging


def _mergecheck(repo, mynode, orig, fcd, fco, fca, toolconf):
    tool, toolpath, binary, symlink, scriptfn = toolconf
    uipathfn = scmutil.getuipathfn(repo)
    if symlink:
        repo.ui.warn(
            _(b'warning: internal %s cannot merge symlinks for %s\n')

        )
        return False
    return True


def _merge(repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels, mode):
    """
    Uses the internal non-interactive simple merge algorithm for merging
    files. It will fail if there are any conflicts and leave markers in
    the partially merged file. Markers will have two sections, one for each side
    of merge, unless mode equals 'union' which suppresses the markers."""

        b"warning: conflicts while merging %s! "
        b"(edit, then use 'hg resolve --mark')\n"
    ),
    precheck=_mergecheck,
)
def _iunion(repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=None):
    """
    Uses the internal non-interactive simple merge algorithm for merging
    files. It will use both left and right sides for conflict regions.
    No markers are inserted."""
    return _merge(
        repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels, b'union'
    )


@internaltool(
    b'merge',

        b"warning: conflicts while merging %s! "
        b"(edit, then use 'hg resolve --mark')\n"
    ),
    precheck=_mergecheck,
)
def _imerge(repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=None):
    """
    Uses the internal non-interactive simple merge algorithm for merging
    files. It will fail if there are any conflicts and leave markers in
    the partially merged file. Markers will have two sections, one for each side
    of merge."""
    return _merge(
        repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels, b'merge'
    )


@internaltool(
    b'merge3',

        b"warning: conflicts while merging %s! "
        b"(edit, then use 'hg resolve --mark')\n"
    ),
    precheck=_mergecheck,
)
def _imerge3(repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=None):
    """
    Uses the internal non-interactive simple merge algorithm for merging
    files. It will fail if there are any conflicts and leave markers in
    the partially merged file. Marker will have three sections, one from each
    side of the merge and one for the base content."""
    if not labels:
        labels = _defaultconflictlabels
    if len(labels) < 3:
        labels.append(b'base')
    return _imerge(repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels)


@internaltool(
    b'merge3-lie-about-conflicts',
    fullmerge,

        b"warning: conflicts while merging %s! "
        b"(edit, then use 'hg resolve --mark')\n"
    ),
    precheck=_mergecheck,
)
def _imerge_diff(
    repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=None
):
    """
    Uses the internal non-interactive simple merge algorithm for merging
    files. It will fail if there are any conflicts and leave markers in
    the partially merged file. The marker will have two sections, one with the
    content from one side of the merge, and one with a diff from the base

    if not labels:
        labels = _defaultconflictlabels
    if len(labels) < 3:
        labels.append(b'base')
    return _merge(
        repo,
        mynode,
        orig,
        fcd,
        fco,
        fca,
        toolconf,
        backup,
        labels,
        b'mergediff',
    )


def _imergeauto(
    repo,
    mynode,
    orig,
    fcd,
    fco,
    fca,
    toolconf,
    backup,

        b"automatic tag merging of %s failed! "
        b"(use 'hg resolve --tool :merge' or another merge "
        b"tool of your choice)\n"
    ),
)
def _itagmerge(
    repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=None
):
    """
    Uses the internal tag merge algorithm (experimental).
    """
    success, status = tagmerge.merge(repo, fcd, fco, fca)
    return success, status, False


@internaltool(b'dump', fullmerge, binary=True, symlink=True)
def _idump(repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=None):
    """
    Creates three versions of the files to merge, containing the
    contents of local, other and base. These files can then be used to
    perform a merge manually. If the file to be merged is named
    ``a.txt``, these files will accordingly be named ``a.txt.local``,

    repo.wwrite(fd + b".base", fca.data(), fca.flags())
    return False, 1, False


@internaltool(b'forcedump', mergeonly, binary=True, symlink=True)
def _forcedump(
    repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=None
):
    """
    Creates three versions of the files as same as :dump, but omits premerge.
    """
    return _idump(
        repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=labels
    )


def _xmergeimm(
    repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=None
):
    # In-memory merge simply raises an exception on all external merge tools,
    # for now.
    #
    # It would be possible to run most tools with temporary files, but this
    # raises the question of what to do if the user only partially resolves the

        ui, tmpl, defaults=templatekw.keywords, resources=tres
    )
    ui.status(t.renderdefault(props))


def _xmerge(repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels):
    tool, toolpath, binary, symlink, scriptfn = toolconf
    uipathfn = scmutil.getuipathfn(repo)
    if fcd.isabsent() or fco.isabsent():
        repo.ui.warn(
            _(b'warning: %s cannot merge change/delete conflict for %s\n')

        isexternal = True

    toolconf = tool, toolpath, binary, symlink, scriptfn

    if mergetype == nomerge:
        r, deleted = func(repo, mynode, orig, fcd, fco, fca, toolconf, labels)
        return True, r, deleted

    if orig != fco.path():
        ui.status(
            _(b"merging %s and %s to %s\n")

    else:
        ui.status(_(b"merging %s\n") % fduipath)

    ui.debug(b"my %s other %s ancestor %s\n" % (fcd, fco, fca))

    if precheck and not precheck(repo, mynode, orig, fcd, fco, fca, toolconf):
        if onfailure:
            if wctx.isinmemory():
                raise error.InMemoryMergeConflictsError(
                    b'in-memory merge does not support merge conflicts'
                )

                return not r, r, False

        needcheck, r, deleted = func(
            repo,
            mynode,
            orig,
            fcd,
            fco,
            fca,
            toolconf,
            backup,

48505:40522aea2f27

            if newdata != data:
                util.writefile(file, newdata)


@internaltool(b'prompt', nomerge)
def _iprompt(repo, mynode, fcd, fco, fca, toolconf, labels=None):
    """Asks the user which of the local `p1()` or the other `p2()` version to
    keep as the merged version."""
    ui = repo.ui
    fd = fcd.path()
    uipathfn = scmutil.getuipathfn(repo)

                2,
            )
            choice = [b'local', b'other', b'unresolved'][index]

        if choice == b'other':
            return _iother(repo, mynode, fcd, fco, fca, toolconf, labels)
        elif choice == b'local':
            return _ilocal(repo, mynode, fcd, fco, fca, toolconf, labels)
        elif choice == b'unresolved':
            return _ifail(repo, mynode, fcd, fco, fca, toolconf, labels)
    except error.ResponseExpected:
        ui.write(b"\n")
        return _ifail(repo, mynode, fcd, fco, fca, toolconf, labels)


@internaltool(b'local', nomerge)
def _ilocal(repo, mynode, fcd, fco, fca, toolconf, labels=None):
    """Uses the local `p1()` version of files as the merged version."""
    return 0, fcd.isabsent()


@internaltool(b'other', nomerge)
def _iother(repo, mynode, fcd, fco, fca, toolconf, labels=None):
    """Uses the other `p2()` version of files as the merged version."""
    if fco.isabsent():
        # local changed, remote deleted -- 'deleted' picked
        _underlyingfctxifabsent(fcd).remove()
        deleted = True

        deleted = False
    return 0, deleted


@internaltool(b'fail', nomerge)
def _ifail(repo, mynode, fcd, fco, fca, toolconf, labels=None):
    """
    Rather than attempting to merge files that were modified on both
    branches, it marks them as unresolved. The resolve command must be
    used to resolve these conflicts."""
    # for change/delete conflicts write out the changed version, then fail

            # restore from backup and try again
            _restorebackup(fcd, backup)
    return 1  # continue merging


def _mergecheck(repo, mynode, fcd, fco, fca, toolconf):
    tool, toolpath, binary, symlink, scriptfn = toolconf
    uipathfn = scmutil.getuipathfn(repo)
    if symlink:
        repo.ui.warn(
            _(b'warning: internal %s cannot merge symlinks for %s\n')

        )
        return False
    return True


def _merge(repo, mynode, fcd, fco, fca, toolconf, backup, labels, mode):
    """
    Uses the internal non-interactive simple merge algorithm for merging
    files. It will fail if there are any conflicts and leave markers in
    the partially merged file. Markers will have two sections, one for each side
    of merge, unless mode equals 'union' which suppresses the markers."""

        b"warning: conflicts while merging %s! "
        b"(edit, then use 'hg resolve --mark')\n"
    ),
    precheck=_mergecheck,
)
def _iunion(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None):
    """
    Uses the internal non-interactive simple merge algorithm for merging
    files. It will use both left and right sides for conflict regions.
    No markers are inserted."""
    return _merge(
        repo, mynode, fcd, fco, fca, toolconf, backup, labels, b'union'
    )


@internaltool(
    b'merge',

        b"warning: conflicts while merging %s! "
        b"(edit, then use 'hg resolve --mark')\n"
    ),
    precheck=_mergecheck,
)
def _imerge(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None):
    """
    Uses the internal non-interactive simple merge algorithm for merging
    files. It will fail if there are any conflicts and leave markers in
    the partially merged file. Markers will have two sections, one for each side
    of merge."""
    return _merge(
        repo, mynode, fcd, fco, fca, toolconf, backup, labels, b'merge'
    )


@internaltool(
    b'merge3',

        b"warning: conflicts while merging %s! "
        b"(edit, then use 'hg resolve --mark')\n"
    ),
    precheck=_mergecheck,
)
def _imerge3(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None):
    """
    Uses the internal non-interactive simple merge algorithm for merging
    files. It will fail if there are any conflicts and leave markers in
    the partially merged file. Marker will have three sections, one from each
    side of the merge and one for the base content."""
    if not labels:
        labels = _defaultconflictlabels
    if len(labels) < 3:
        labels.append(b'base')
    return _imerge(repo, mynode, fcd, fco, fca, toolconf, backup, labels)


@internaltool(
    b'merge3-lie-about-conflicts',
    fullmerge,

        b"warning: conflicts while merging %s! "
        b"(edit, then use 'hg resolve --mark')\n"
    ),
    precheck=_mergecheck,
)
def _imerge_diff(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None):
    """
    Uses the internal non-interactive simple merge algorithm for merging
    files. It will fail if there are any conflicts and leave markers in
    the partially merged file. The marker will have two sections, one with the
    content from one side of the merge, and one with a diff from the base

    if not labels:
        labels = _defaultconflictlabels
    if len(labels) < 3:
        labels.append(b'base')
    return _merge(
        repo, mynode, fcd, fco, fca, toolconf, backup, labels, b'mergediff'
    )


def _imergeauto(
    repo,
    mynode,
    fcd,
    fco,
    fca,
    toolconf,
    backup,

        b"automatic tag merging of %s failed! "
        b"(use 'hg resolve --tool :merge' or another merge "
        b"tool of your choice)\n"
    ),
)
def _itagmerge(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None):
    """
    Uses the internal tag merge algorithm (experimental).
    """
    success, status = tagmerge.merge(repo, fcd, fco, fca)
    return success, status, False


@internaltool(b'dump', fullmerge, binary=True, symlink=True)
def _idump(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None):
    """
    Creates three versions of the files to merge, containing the
    contents of local, other and base. These files can then be used to
    perform a merge manually. If the file to be merged is named
    ``a.txt``, these files will accordingly be named ``a.txt.local``,

    repo.wwrite(fd + b".base", fca.data(), fca.flags())
    return False, 1, False


@internaltool(b'forcedump', mergeonly, binary=True, symlink=True)
def _forcedump(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None):
    """
    Creates three versions of the files as same as :dump, but omits premerge.
    """
    return _idump(repo, mynode, fcd, fco, fca, toolconf, backup, labels=labels)


def _xmergeimm(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None):
    # In-memory merge simply raises an exception on all external merge tools,
    # for now.
    #
    # It would be possible to run most tools with temporary files, but this
    # raises the question of what to do if the user only partially resolves the

        ui, tmpl, defaults=templatekw.keywords, resources=tres
    )
    ui.status(t.renderdefault(props))


def _xmerge(repo, mynode, fcd, fco, fca, toolconf, backup, labels):
    tool, toolpath, binary, symlink, scriptfn = toolconf
    uipathfn = scmutil.getuipathfn(repo)
    if fcd.isabsent() or fco.isabsent():
        repo.ui.warn(
            _(b'warning: %s cannot merge change/delete conflict for %s\n')

        isexternal = True

    toolconf = tool, toolpath, binary, symlink, scriptfn

    if mergetype == nomerge:
        r, deleted = func(repo, mynode, fcd, fco, fca, toolconf, labels)
        return True, r, deleted

    if orig != fco.path():
        ui.status(
            _(b"merging %s and %s to %s\n")

    else:
        ui.status(_(b"merging %s\n") % fduipath)

    ui.debug(b"my %s other %s ancestor %s\n" % (fcd, fco, fca))

    if precheck and not precheck(repo, mynode, fcd, fco, fca, toolconf):
        if onfailure:
            if wctx.isinmemory():
                raise error.InMemoryMergeConflictsError(
                    b'in-memory merge does not support merge conflicts'
                )

                return not r, r, False

        needcheck, r, deleted = func(
            repo,
            mynode,
            fcd,
            fco,
            fca,
            toolconf,
            backup,