( )⚙ D12018 filemerge: pass `simplemerge.MergeInput` to tool functions

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12018

filemerge: pass `simplemerge.MergeInput` to tool functions
ClosedPublic

Authored by martinvonz on Jan 21 2022, 6:31 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGfd9fe2658cda: filemerge: pass `simplemerge.MergeInput` to tool functions

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Revision Contents
Changeset List

PathPackages
Mmercurial/filemerge.py (160 lines)

Diff 31718

mercurial/filemerge.py

style = _eoltype(data) style = _eoltype(data)
if style: if style:
newdata = data.replace(style, tostyle) newdata = data.replace(style, tostyle)
if newdata != data: if newdata != data:
util.writefile(file, newdata) util.writefile(file, newdata)
@internaltool(b'prompt', nomerge) @internaltool(b'prompt', nomerge)
def _iprompt(repo, mynode, fcd, fco, fca, toolconf, labels=None): def _iprompt(repo, mynode, local, other, base, toolconf):
"""Asks the user which of the local `p1()` or the other `p2()` version to """Asks the user which of the local `p1()` or the other `p2()` version to
keep as the merged version.""" keep as the merged version."""
ui = repo.ui ui = repo.ui
fd = fcd.path() fd = local.fctx.path()
uipathfn = scmutil.getuipathfn(repo) uipathfn = scmutil.getuipathfn(repo)
# Avoid prompting during an in-memory merge since it doesn't support merge # Avoid prompting during an in-memory merge since it doesn't support merge
# conflicts. # conflicts.
if fcd.changectx().isinmemory(): if local.fctx.changectx().isinmemory():
raise error.InMemoryMergeConflictsError( raise error.InMemoryMergeConflictsError(
b'in-memory merge does not support file conflicts' b'in-memory merge does not support file conflicts'
) )
prompts = partextras(labels) prompts = partextras([local.label, other.label])
prompts[b'fd'] = uipathfn(fd) prompts[b'fd'] = uipathfn(fd)
try: try:
if fco.isabsent(): if other.fctx.isabsent():
index = ui.promptchoice(_localchangedotherdeletedmsg % prompts, 2) index = ui.promptchoice(_localchangedotherdeletedmsg % prompts, 2)
choice = [b'local', b'other', b'unresolved'][index] choice = [b'local', b'other', b'unresolved'][index]
elif fcd.isabsent(): elif local.fctx.isabsent():
index = ui.promptchoice(_otherchangedlocaldeletedmsg % prompts, 2) index = ui.promptchoice(_otherchangedlocaldeletedmsg % prompts, 2)
choice = [b'other', b'local', b'unresolved'][index] choice = [b'other', b'local', b'unresolved'][index]
else: else:
# IMPORTANT: keep the last line of this prompt ("What do you want to # IMPORTANT: keep the last line of this prompt ("What do you want to
# do?") very short, see comment next to _localchangedotherdeletedmsg # do?") very short, see comment next to _localchangedotherdeletedmsg
# at the top of the file for details. # at the top of the file for details.
index = ui.promptchoice( index = ui.promptchoice(
_( _(
b"file '%(fd)s' needs to be resolved.\n" b"file '%(fd)s' needs to be resolved.\n"
b"You can keep (l)ocal%(l)s, take (o)ther%(o)s, or leave " b"You can keep (l)ocal%(l)s, take (o)ther%(o)s, or leave "
b"(u)nresolved.\n" b"(u)nresolved.\n"
b"What do you want to do?" b"What do you want to do?"
b"$$ &Local $$ &Other $$ &Unresolved" b"$$ &Local $$ &Other $$ &Unresolved"
) )
% prompts, % prompts,
2, 2,
) )
choice = [b'local', b'other', b'unresolved'][index] choice = [b'local', b'other', b'unresolved'][index]
if choice == b'other': if choice == b'other':
return _iother(repo, mynode, fcd, fco, fca, toolconf, labels) return _iother(repo, mynode, local, other, base, toolconf)
elif choice == b'local': elif choice == b'local':
return _ilocal(repo, mynode, fcd, fco, fca, toolconf, labels) return _ilocal(repo, mynode, local, other, base, toolconf)
elif choice == b'unresolved': elif choice == b'unresolved':
return _ifail(repo, mynode, fcd, fco, fca, toolconf, labels) return _ifail(repo, mynode, local, other, base, toolconf)
except error.ResponseExpected: except error.ResponseExpected:
ui.write(b"\n") ui.write(b"\n")
return _ifail(repo, mynode, fcd, fco, fca, toolconf, labels) return _ifail(repo, mynode, local, other, base, toolconf)
@internaltool(b'local', nomerge) @internaltool(b'local', nomerge)
def _ilocal(repo, mynode, fcd, fco, fca, toolconf, labels=None): def _ilocal(repo, mynode, local, other, base, toolconf):
"""Uses the local `p1()` version of files as the merged version.""" """Uses the local `p1()` version of files as the merged version."""
return 0, fcd.isabsent() return 0, local.fctx.isabsent()
@internaltool(b'other', nomerge) @internaltool(b'other', nomerge)
def _iother(repo, mynode, fcd, fco, fca, toolconf, labels=None): def _iother(repo, mynode, local, other, base, toolconf):
"""Uses the other `p2()` version of files as the merged version.""" """Uses the other `p2()` version of files as the merged version."""
if fco.isabsent(): if other.fctx.isabsent():
# local changed, remote deleted -- 'deleted' picked # local changed, remote deleted -- 'deleted' picked
_underlyingfctxifabsent(fcd).remove() _underlyingfctxifabsent(local.fctx).remove()
deleted = True deleted = True
else: else:
_underlyingfctxifabsent(fcd).write(fco.data(), fco.flags()) _underlyingfctxifabsent(local.fctx).write(
other.fctx.data(), other.fctx.flags()
)
deleted = False deleted = False
return 0, deleted return 0, deleted
@internaltool(b'fail', nomerge) @internaltool(b'fail', nomerge)
def _ifail(repo, mynode, fcd, fco, fca, toolconf, labels=None): def _ifail(repo, mynode, local, other, base, toolconf):
""" """
Rather than attempting to merge files that were modified on both Rather than attempting to merge files that were modified on both
branches, it marks them as unresolved. The resolve command must be branches, it marks them as unresolved. The resolve command must be
used to resolve these conflicts.""" used to resolve these conflicts."""
# for change/delete conflicts write out the changed version, then fail # for change/delete conflicts write out the changed version, then fail
if fcd.isabsent(): if local.fctx.isabsent():
_underlyingfctxifabsent(fcd).write(fco.data(), fco.flags()) _underlyingfctxifabsent(local.fctx).write(
other.fctx.data(), other.fctx.flags()
)
return 1, False return 1, False
def _underlyingfctxifabsent(filectx): def _underlyingfctxifabsent(filectx):
"""Sometimes when resolving, our fcd is actually an absentfilectx, but """Sometimes when resolving, our fcd is actually an absentfilectx, but
we want to write to it (to do the resolve). This helper returns the we want to write to it (to do the resolve). This helper returns the
underyling workingfilectx in that case. underyling workingfilectx in that case.
""" """
if filectx.isabsent(): if filectx.isabsent():
return filectx.changectx()[filectx.path()] return filectx.changectx()[filectx.path()]
else: else:
return filectx return filectx
def _premerge(repo, fcd, fco, fca, toolconf, backup, labels): def _premerge(repo, local, other, base, toolconf, backup):
tool, toolpath, binary, symlink, scriptfn = toolconf tool, toolpath, binary, symlink, scriptfn = toolconf
if symlink or fcd.isabsent() or fco.isabsent(): if symlink or local.fctx.isabsent() or other.fctx.isabsent():
return 1 return 1
ui = repo.ui ui = repo.ui
validkeep = [b'keep', b'keep-merge3', b'keep-mergediff'] validkeep = [b'keep', b'keep-merge3', b'keep-mergediff']
# do we attempt to simplemerge first? # do we attempt to simplemerge first?
try: try:
premerge = _toolbool(ui, tool, b"premerge", not binary) premerge = _toolbool(ui, tool, b"premerge", not binary)
except error.ConfigError: except error.ConfigError:
premerge = _toolstr(ui, tool, b"premerge", b"").lower() premerge = _toolstr(ui, tool, b"premerge", b"").lower()
if premerge not in validkeep: if premerge not in validkeep:
_valid = b', '.join([b"'" + v + b"'" for v in validkeep]) _valid = b', '.join([b"'" + v + b"'" for v in validkeep])
raise error.ConfigError( raise error.ConfigError(
_(b"%s.premerge not valid ('%s' is neither boolean nor %s)") _(b"%s.premerge not valid ('%s' is neither boolean nor %s)")
% (tool, premerge, _valid) % (tool, premerge, _valid)
) )
if premerge: if premerge:
mode = b'merge' mode = b'merge'
if premerge == b'keep-mergediff': if premerge == b'keep-mergediff':
mode = b'mergediff' mode = b'mergediff'
elif premerge == b'keep-merge3': elif premerge == b'keep-merge3':
mode = b'merge3' mode = b'merge3'
local = simplemerge.MergeInput(fcd, labels[0])
other = simplemerge.MergeInput(fco, labels[1])
base = simplemerge.MergeInput(fca, labels[2])
r = simplemerge.simplemerge( r = simplemerge.simplemerge(
ui, local, base, other, quiet=True, mode=mode ui, local, base, other, quiet=True, mode=mode
) )
if not r: if not r:
ui.debug(b" premerge successful\n") ui.debug(b" premerge successful\n")
return 0 return 0
if premerge not in validkeep: if premerge not in validkeep:
# restore from backup and try again # restore from backup and try again
_restorebackup(fcd, backup) _restorebackup(local.fctx, backup)
return 1 # continue merging return 1 # continue merging
def _mergecheck(repo, mynode, fcd, fco, fca, toolconf): def _mergecheck(repo, mynode, fcd, fco, fca, toolconf):
tool, toolpath, binary, symlink, scriptfn = toolconf tool, toolpath, binary, symlink, scriptfn = toolconf
uipathfn = scmutil.getuipathfn(repo) uipathfn = scmutil.getuipathfn(repo)
if symlink: if symlink:
repo.ui.warn( repo.ui.warn(
_(b'warning: internal %s cannot merge symlinks for %s\n') _(b'warning: internal %s cannot merge symlinks for %s\n')
% (tool, uipathfn(fcd.path())) % (tool, uipathfn(fcd.path()))
) )
return False return False
if fcd.isabsent() or fco.isabsent(): if fcd.isabsent() or fco.isabsent():
repo.ui.warn( repo.ui.warn(
_( _(
b'warning: internal %s cannot merge change/delete ' b'warning: internal %s cannot merge change/delete '
b'conflict for %s\n' b'conflict for %s\n'
) )
% (tool, uipathfn(fcd.path())) % (tool, uipathfn(fcd.path()))
) )
return False return False
return True return True
def _merge(repo, fcd, fco, fca, labels, mode): def _merge(repo, local, other, base, mode):
""" """
Uses the internal non-interactive simple merge algorithm for merging Uses the internal non-interactive simple merge algorithm for merging
files. It will fail if there are any conflicts and leave markers in 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 the partially merged file. Markers will have two sections, one for each side
of merge, unless mode equals 'union' which suppresses the markers.""" of merge, unless mode equals 'union' which suppresses the markers."""
ui = repo.ui ui = repo.ui
local = simplemerge.MergeInput(fcd)
local.label = labels[0]
other = simplemerge.MergeInput(fco)
other.label = labels[1]
base = simplemerge.MergeInput(fca)
base.label = labels[2]
r = simplemerge.simplemerge(ui, local, base, other, mode=mode) r = simplemerge.simplemerge(ui, local, base, other, mode=mode)
return True, r, False return True, r, False
@internaltool( @internaltool(
b'union', b'union',
fullmerge, fullmerge,
_( _(
b"warning: conflicts while merging %s! " b"warning: conflicts while merging %s! "
b"(edit, then use 'hg resolve --mark')\n" b"(edit, then use 'hg resolve --mark')\n"
), ),
precheck=_mergecheck, precheck=_mergecheck,
) )
def _iunion(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None): def _iunion(repo, mynode, local, other, base, toolconf, backup):
""" """
Uses the internal non-interactive simple merge algorithm for merging Uses the internal non-interactive simple merge algorithm for merging
files. It will use both left and right sides for conflict regions. files. It will use both left and right sides for conflict regions.
No markers are inserted.""" No markers are inserted."""
return _merge(repo, fcd, fco, fca, labels, b'union') return _merge(repo, local, other, base, b'union')
@internaltool( @internaltool(
b'merge', b'merge',
fullmerge, fullmerge,
_( _(
b"warning: conflicts while merging %s! " b"warning: conflicts while merging %s! "
b"(edit, then use 'hg resolve --mark')\n" b"(edit, then use 'hg resolve --mark')\n"
), ),
precheck=_mergecheck, precheck=_mergecheck,
) )
def _imerge(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None): def _imerge(repo, mynode, local, other, base, toolconf, backup):
""" """
Uses the internal non-interactive simple merge algorithm for merging Uses the internal non-interactive simple merge algorithm for merging
files. It will fail if there are any conflicts and leave markers in 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 the partially merged file. Markers will have two sections, one for each side
of merge.""" of merge."""
return _merge(repo, fcd, fco, fca, labels, b'merge') return _merge(repo, local, other, base, b'merge')
@internaltool( @internaltool(
b'merge3', b'merge3',
fullmerge, fullmerge,
_( _(
b"warning: conflicts while merging %s! " b"warning: conflicts while merging %s! "
b"(edit, then use 'hg resolve --mark')\n" b"(edit, then use 'hg resolve --mark')\n"
), ),
precheck=_mergecheck, precheck=_mergecheck,
) )
def _imerge3(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None): def _imerge3(repo, mynode, local, other, base, toolconf, backup):
""" """
Uses the internal non-interactive simple merge algorithm for merging Uses the internal non-interactive simple merge algorithm for merging
files. It will fail if there are any conflicts and leave markers in 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 the partially merged file. Marker will have three sections, one from each
side of the merge and one for the base content.""" side of the merge and one for the base content."""
return _merge(repo, fcd, fco, fca, labels, b'merge3') return _merge(repo, local, other, base, b'merge3')
@internaltool( @internaltool(
b'merge3-lie-about-conflicts', b'merge3-lie-about-conflicts',
fullmerge, fullmerge,
b'', b'',
precheck=_mergecheck, precheck=_mergecheck,
) )
b'mergediff', b'mergediff',
fullmerge, fullmerge,
_( _(
b"warning: conflicts while merging %s! " b"warning: conflicts while merging %s! "
b"(edit, then use 'hg resolve --mark')\n" b"(edit, then use 'hg resolve --mark')\n"
), ),
precheck=_mergecheck, precheck=_mergecheck,
) )
def _imerge_diff(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None): def _imerge_diff(repo, mynode, local, other, base, toolconf, backup):
""" """
Uses the internal non-interactive simple merge algorithm for merging Uses the internal non-interactive simple merge algorithm for merging
files. It will fail if there are any conflicts and leave markers in 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 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 content from one side of the merge, and one with a diff from the base
content to the content on the other side. (experimental)""" content to the content on the other side. (experimental)"""
return _merge(repo, fcd, fco, fca, labels, b'mergediff') return _merge(repo, local, other, base, b'mergediff')
@internaltool(b'merge-local', mergeonly, precheck=_mergecheck) @internaltool(b'merge-local', mergeonly, precheck=_mergecheck)
def _imergelocal(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None): def _imergelocal(repo, mynode, local, other, base, toolconf, backup):
""" """
Like :merge, but resolve all conflicts non-interactively in favor Like :merge, but resolve all conflicts non-interactively in favor
of the local `p1()` changes.""" of the local `p1()` changes."""
return _merge(repo, fcd, fco, fca, labels, b'local') return _merge(repo, local, other, base, b'local')
@internaltool(b'merge-other', mergeonly, precheck=_mergecheck) @internaltool(b'merge-other', mergeonly, precheck=_mergecheck)
def _imergeother(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None): def _imergeother(repo, mynode, local, other, base, toolconf, backup):
""" """
Like :merge, but resolve all conflicts non-interactively in favor Like :merge, but resolve all conflicts non-interactively in favor
of the other `p2()` changes.""" of the other `p2()` changes."""
return _merge(repo, fcd, fco, fca, labels, b'other') return _merge(repo, local, other, base, b'other')
@internaltool( @internaltool(
b'tagmerge', b'tagmerge',
mergeonly, mergeonly,
_( _(
b"automatic tag merging of %s failed! " b"automatic tag merging of %s failed! "
b"(use 'hg resolve --tool :merge' or another merge " b"(use 'hg resolve --tool :merge' or another merge "
b"tool of your choice)\n" b"tool of your choice)\n"
), ),
) )
def _itagmerge(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None): def _itagmerge(repo, mynode, local, other, base, toolconf, backup):
""" """
Uses the internal tag merge algorithm (experimental). Uses the internal tag merge algorithm (experimental).
""" """
success, status = tagmerge.merge(repo, fcd, fco, fca) success, status = tagmerge.merge(repo, local.fctx, other.fctx, base.fctx)
return success, status, False return success, status, False
@internaltool(b'dump', fullmerge, binary=True, symlink=True) @internaltool(b'dump', fullmerge, binary=True, symlink=True)
def _idump(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None): def _idump(repo, mynode, local, other, base, toolconf, backup):
""" """
Creates three versions of the files to merge, containing the Creates three versions of the files to merge, containing the
contents of local, other and base. These files can then be used to 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 perform a merge manually. If the file to be merged is named
``a.txt``, these files will accordingly be named ``a.txt.local``, ``a.txt``, these files will accordingly be named ``a.txt.local``,
``a.txt.other`` and ``a.txt.base`` and they will be placed in the ``a.txt.other`` and ``a.txt.base`` and they will be placed in the
same directory as ``a.txt``. same directory as ``a.txt``.
This implies premerge. Therefore, files aren't dumped, if premerge This implies premerge. Therefore, files aren't dumped, if premerge
runs successfully. Use :forcedump to forcibly write files out. runs successfully. Use :forcedump to forcibly write files out.
""" """
a = _workingpath(repo, fcd) a = _workingpath(repo, local.fctx)
fd = fcd.path() fd = local.fctx.path()
from . import context from . import context
if isinstance(fcd, context.overlayworkingfilectx): if isinstance(local.fctx, context.overlayworkingfilectx):
raise error.InMemoryMergeConflictsError( raise error.InMemoryMergeConflictsError(
b'in-memory merge does not support the :dump tool.' b'in-memory merge does not support the :dump tool.'
) )
util.writefile(a + b".local", fcd.decodeddata()) util.writefile(a + b".local", local.fctx.decodeddata())
repo.wwrite(fd + b".other", fco.data(), fco.flags()) repo.wwrite(fd + b".other", other.fctx.data(), other.fctx.flags())
repo.wwrite(fd + b".base", fca.data(), fca.flags()) repo.wwrite(fd + b".base", base.fctx.data(), base.fctx.flags())
return False, 1, False return False, 1, False
@internaltool(b'forcedump', mergeonly, binary=True, symlink=True) @internaltool(b'forcedump', mergeonly, binary=True, symlink=True)
def _forcedump(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None): def _forcedump(repo, mynode, local, other, base, toolconf, backup):
""" """
Creates three versions of the files as same as :dump, but omits premerge. Creates three versions of the files as same as :dump, but omits premerge.
""" """
return _idump(repo, mynode, fcd, fco, fca, toolconf, backup, labels=labels) return _idump(repo, mynode, local, other, base, toolconf, backup)
def _xmergeimm(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None): def _xmergeimm(repo, mynode, local, other, base, toolconf, backup):
# In-memory merge simply raises an exception on all external merge tools, # In-memory merge simply raises an exception on all external merge tools,
# for now. # for now.
# #
# It would be possible to run most tools with temporary files, but this # 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 # raises the question of what to do if the user only partially resolves the
# file -- we can't leave a merge state. (Copy to somewhere in the .hg/ # file -- we can't leave a merge state. (Copy to somewhere in the .hg/
# directory and tell the user how to get it is my best idea, but it's # directory and tell the user how to get it is my best idea, but it's
# clunky.) # clunky.)
# things for us to import cmdutil. # things for us to import cmdutil.
tres = formatter.templateresources(ui, repo) tres = formatter.templateresources(ui, repo)
t = formatter.maketemplater( t = formatter.maketemplater(
ui, tmpl, defaults=templatekw.keywords, resources=tres ui, tmpl, defaults=templatekw.keywords, resources=tres
) )
ui.status(t.renderdefault(props)) ui.status(t.renderdefault(props))
def _xmerge(repo, mynode, fcd, fco, fca, toolconf, backup, labels): def _xmerge(repo, mynode, local, other, base, toolconf, backup):
fcd = local.fctx
fco = other.fctx
fca = base.fctx
tool, toolpath, binary, symlink, scriptfn = toolconf tool, toolpath, binary, symlink, scriptfn = toolconf
uipathfn = scmutil.getuipathfn(repo) uipathfn = scmutil.getuipathfn(repo)
if fcd.isabsent() or fco.isabsent(): if fcd.isabsent() or fco.isabsent():
repo.ui.warn( repo.ui.warn(
_(b'warning: %s cannot merge change/delete conflict for %s\n') _(b'warning: %s cannot merge change/delete conflict for %s\n')
% (tool, uipathfn(fcd.path())) % (tool, uipathfn(fcd.path()))
) )
return False, 1, None return False, 1, None
localpath = _workingpath(repo, fcd) localpath = _workingpath(repo, fcd)
args = _toolstr(repo.ui, tool, b"args") args = _toolstr(repo.ui, tool, b"args")
with _maketempfiles( with _maketempfiles(
repo, fco, fca, repo.wvfs.join(backup.path()), b"$output" in args repo, fco, fca, repo.wvfs.join(backup.path()), b"$output" in args
) as temppaths: ) as temppaths:
basepath, otherpath, localoutputpath = temppaths basepath, otherpath, localoutputpath = temppaths
outpath = b"" outpath = b""
mylabel, otherlabel = labels[:2]
baselabel = labels[2]
env = { env = {
b'HG_FILE': fcd.path(), b'HG_FILE': fcd.path(),
b'HG_MY_NODE': short(mynode), b'HG_MY_NODE': short(mynode),
b'HG_OTHER_NODE': short(fco.changectx().node()), b'HG_OTHER_NODE': short(fco.changectx().node()),
b'HG_BASE_NODE': short(fca.changectx().node()), b'HG_BASE_NODE': short(fca.changectx().node()),
b'HG_MY_ISLINK': b'l' in fcd.flags(), b'HG_MY_ISLINK': b'l' in fcd.flags(),
b'HG_OTHER_ISLINK': b'l' in fco.flags(), b'HG_OTHER_ISLINK': b'l' in fco.flags(),
b'HG_BASE_ISLINK': b'l' in fca.flags(), b'HG_BASE_ISLINK': b'l' in fca.flags(),
b'HG_MY_LABEL': mylabel, b'HG_MY_LABEL': local.label,
b'HG_OTHER_LABEL': otherlabel, b'HG_OTHER_LABEL': other.label,
b'HG_BASE_LABEL': baselabel, b'HG_BASE_LABEL': base.label,
} }
ui = repo.ui ui = repo.ui
if b"$output" in args: if b"$output" in args:
# read input from backup, write to original # read input from backup, write to original
outpath = localpath outpath = localpath
localpath = localoutputpath localpath = localoutputpath
replace = { replace = {
b'local': localpath, b'local': localpath,
b'base': basepath, b'base': basepath,
b'other': otherpath, b'other': otherpath,
b'output': outpath, b'output': outpath,
b'labellocal': mylabel, b'labellocal': local.label,
b'labelother': otherlabel, b'labelother': other.label,
b'labelbase': baselabel, b'labelbase': base.label,
} }
args = util.interpolate( args = util.interpolate(
br'\$', br'\$',
replace, replace,
args, args,
lambda s: procutil.shellquote(util.localpath(s)), lambda s: procutil.shellquote(util.localpath(s)),
) )
if _toolbool(ui, tool, b"gui"): if _toolbool(ui, tool, b"gui"):
ui, repo, b"merge", toolpath, mergefn, {b'args': argslist}, True ui, repo, b"merge", toolpath, mergefn, {b'args': argslist}, True
) )
if raised: if raised:
r = 1 r = 1
repo.ui.debug(b'merge tool returned: %d\n' % r) repo.ui.debug(b'merge tool returned: %d\n' % r)
return True, r, False return True, r, False
def _formatlabel(input, template, pad): def _populate_label_detail(input, template, pad):
"""Applies the given template to the ctx, prefixed by the label. """Applies the given template to the ctx, prefixed by the label.
Pad is the minimum width of the label prefix, so that multiple markers Pad is the minimum width of the label prefix, so that multiple markers
can have aligned templated parts. can have aligned templated parts.
""" """
ctx = input.fctx.changectx() ctx = input.fctx.changectx()
if ctx.node() is None: if ctx.node() is None:
ctx = ctx.p1() ctx = ctx.p1()
props = {b'ctx': ctx} props = {b'ctx': ctx}
templateresult = template.renderdefault(props) templateresult = template.renderdefault(props)
label = (b'%s:' % input.label).ljust(pad + 1) label = (b'%s:' % input.label).ljust(pad + 1)
mark = b'%s %s' % (label, templateresult) mark = b'%s %s' % (label, templateresult)
mark = mark.splitlines()[0] # split for safety mark = mark.splitlines()[0] # split for safety
# 8 for the prefix of conflict marker lines (e.g. '<<<<<<< ') # 8 for the prefix of conflict marker lines (e.g. '<<<<<<< ')
input.label = stringutil.ellipsis(mark, 80 - 8) input.label = stringutil.ellipsis(mark, 80 - 8)
def _formatlabels(repo, inputs, tool=None): def _populate_label_details(repo, inputs, tool=None):
"""Formats the given labels using the conflict marker template. """Formats the given labels using the conflict marker template.
Returns a list of formatted labels. Returns a list of formatted labels.
""" """
ui = repo.ui ui = repo.ui
template = ui.config(b'command-templates', b'mergemarker') template = ui.config(b'command-templates', b'mergemarker')
if tool is not None: if tool is not None:
template = _toolstr(ui, tool, b'mergemarkertemplate', template) template = _toolstr(ui, tool, b'mergemarkertemplate', template)
template = templater.unquotestring(template) template = templater.unquotestring(template)
tres = formatter.templateresources(ui, repo) tres = formatter.templateresources(ui, repo)
tmpl = formatter.maketemplater( tmpl = formatter.maketemplater(
ui, template, defaults=templatekw.keywords, resources=tres ui, template, defaults=templatekw.keywords, resources=tres
) )
pad = max(len(input.label) for input in inputs) pad = max(len(input.label) for input in inputs)
return [_formatlabel(input, tmpl, pad) for input in inputs] for input in inputs:
_populate_label_detail(input, tmpl, pad)
def partextras(labels): def partextras(labels):
"""Return a dictionary of extra labels for use in prompts to the user """Return a dictionary of extra labels for use in prompts to the user
Intended use is in strings of the form "(l)ocal%(l)s". Intended use is in strings of the form "(l)ocal%(l)s".
""" """
if labels is None: if labels is None:
labels.append(b'base') labels.append(b'base')
local = simplemerge.MergeInput(fcd, labels[0]) local = simplemerge.MergeInput(fcd, labels[0])
other = simplemerge.MergeInput(fco, labels[1]) other = simplemerge.MergeInput(fco, labels[1])
base = simplemerge.MergeInput(fca, labels[2]) base = simplemerge.MergeInput(fca, labels[2])
if mergetype == nomerge: if mergetype == nomerge:
return func( return func(
repo, repo,
mynode, mynode,
fcd, local,
fco, other,
fca, base,
toolconf, toolconf,
[local.label, other.label, base.label],
) )
if orig != fco.path(): if orig != fco.path():
ui.status( ui.status(
_(b"merging %s and %s to %s\n") _(b"merging %s and %s to %s\n")
% (uipathfn(orig), uipathfn(fco.path()), fduipath) % (uipathfn(orig), uipathfn(fco.path()), fduipath)
) )
else: else:
# space-constrained areas of the UI, but still get full information # space-constrained areas of the UI, but still get full information
# in conflict markers if premerge is 'keep' or 'keep-merge3'. # in conflict markers if premerge is 'keep' or 'keep-merge3'.
labeltool = None labeltool = None
if markerstyle != b'basic': if markerstyle != b'basic':
# respect 'tool's mergemarkertemplate (which defaults to # respect 'tool's mergemarkertemplate (which defaults to
# command-templates.mergemarker) # command-templates.mergemarker)
labeltool = tool labeltool = tool
if internalmarkerstyle != b'basic' or markerstyle != b'basic': if internalmarkerstyle != b'basic' or markerstyle != b'basic':
_formatlabels(repo, [local, other, base], tool=labeltool) _populate_label_details(
repo, [local, other, base], tool=labeltool
)
r = _premerge( r = _premerge(
repo, repo,
fcd, local,
fco, other,
fca, base,
toolconf, toolconf,
backup, backup,
labels=[local.label, other.label, base.label],
) )
# we're done if premerge was successful (r is 0) # we're done if premerge was successful (r is 0)
if not r: if not r:
return r, False return r, False
# Reset to basic labels # Reset to basic labels
local.label = labels[0] local.label = labels[0]
other.label = labels[1] other.label = labels[1]
base.label = labels[2] base.label = labels[2]
if markerstyle != b'basic': if markerstyle != b'basic':
_formatlabels(repo, [local, other, base], tool=tool) _populate_label_details(repo, [local, other, base], tool=tool)
needcheck, r, deleted = func( needcheck, r, deleted = func(
repo, repo,
mynode, mynode,
fcd, local,
fco, other,
fca, base,
toolconf, toolconf,
backup, backup,
labels=[local.label, other.label, base.label],
) )
if needcheck: if needcheck:
r = _check(repo, r, ui, tool, fcd, backup) r = _check(repo, r, ui, tool, fcd, backup)
if r: if r:
if onfailure: if onfailure:
if wctx.isinmemory(): if wctx.isinmemory():