This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11878

filemerge: remove unused `orig` argument from tool functions
ClosedPublic

Authored by martinvonz on Dec 7 2021, 12:02 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG40522aea2f27: filemerge: remove unused `orig` argument from 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 (73 lines)

Diff 31485

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, orig, fcd, fco, fca, toolconf, labels=None): def _iprompt(repo, mynode, fcd, fco, fca, toolconf, labels=None):
"""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 = fcd.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.
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, orig, fcd, fco, fca, toolconf, labels) return _iother(repo, mynode, fcd, fco, fca, toolconf, labels)
elif choice == b'local': elif choice == b'local':
return _ilocal(repo, mynode, orig, fcd, fco, fca, toolconf, labels) return _ilocal(repo, mynode, fcd, fco, fca, toolconf, labels)
elif choice == b'unresolved': elif choice == b'unresolved':
return _ifail(repo, mynode, orig, fcd, fco, fca, toolconf, labels) return _ifail(repo, mynode, fcd, fco, fca, toolconf, labels)
except error.ResponseExpected: except error.ResponseExpected:
ui.write(b"\n") ui.write(b"\n")
return _ifail(repo, mynode, orig, fcd, fco, fca, toolconf, labels) return _ifail(repo, mynode, fcd, fco, fca, toolconf, labels)
@internaltool(b'local', nomerge) @internaltool(b'local', nomerge)
def _ilocal(repo, mynode, orig, fcd, fco, fca, toolconf, labels=None): def _ilocal(repo, mynode, fcd, fco, fca, toolconf, labels=None):
"""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, fcd.isabsent()
@internaltool(b'other', nomerge) @internaltool(b'other', nomerge)
def _iother(repo, mynode, orig, fcd, fco, fca, toolconf, labels=None): def _iother(repo, mynode, fcd, fco, fca, toolconf, labels=None):
"""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 fco.isabsent():
# local changed, remote deleted -- 'deleted' picked # local changed, remote deleted -- 'deleted' picked
_underlyingfctxifabsent(fcd).remove() _underlyingfctxifabsent(fcd).remove()
deleted = True deleted = True
else: else:
_underlyingfctxifabsent(fcd).write(fco.data(), fco.flags()) _underlyingfctxifabsent(fcd).write(fco.data(), fco.flags())
deleted = False deleted = False
return 0, deleted return 0, deleted
@internaltool(b'fail', nomerge) @internaltool(b'fail', nomerge)
def _ifail(repo, mynode, orig, fcd, fco, fca, toolconf, labels=None): def _ifail(repo, mynode, fcd, fco, fca, toolconf, labels=None):
""" """
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 fcd.isabsent():
_underlyingfctxifabsent(fcd).write(fco.data(), fco.flags()) _underlyingfctxifabsent(fcd).write(fco.data(), fco.flags())
return 1, False return 1, False
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(fcd, backup)
return 1 # continue merging return 1 # continue merging
def _mergecheck(repo, mynode, orig, 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, mynode, orig, fcd, fco, fca, toolconf, backup, labels, mode): def _merge(repo, mynode, fcd, fco, fca, toolconf, backup, labels, 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
r = simplemerge.simplemerge(ui, fcd, fca, fco, label=labels, mode=mode) r = simplemerge.simplemerge(ui, fcd, fca, fco, label=labels, 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, orig, fcd, fco, fca, toolconf, backup, labels=None): def _iunion(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None):
""" """
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( return _merge(
repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels, b'union' repo, mynode, fcd, fco, fca, toolconf, backup, labels, 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, orig, fcd, fco, fca, toolconf, backup, labels=None): def _imerge(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None):
""" """
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( return _merge(
repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels, b'merge' repo, mynode, fcd, fco, fca, toolconf, backup, labels, 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, orig, fcd, fco, fca, toolconf, backup, labels=None): def _imerge3(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None):
""" """
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."""
if not labels: if not labels:
labels = _defaultconflictlabels labels = _defaultconflictlabels
if len(labels) < 3: if len(labels) < 3:
labels.append(b'base') labels.append(b'base')
return _imerge(repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels) return _imerge(repo, mynode, fcd, fco, fca, toolconf, backup, labels)
@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( def _imerge_diff(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None):
repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=None
):
""" """
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)"""
if not labels: if not labels:
labels = _defaultconflictlabels labels = _defaultconflictlabels
if len(labels) < 3: if len(labels) < 3:
labels.append(b'base') labels.append(b'base')
return _merge( return _merge(
repo, repo, mynode, fcd, fco, fca, toolconf, backup, labels, b'mergediff'
mynode,
orig,
fcd,
fco,
fca,
toolconf,
backup,
labels,
b'mergediff',
) )
def _imergeauto( def _imergeauto(
repo, repo,
mynode, mynode,
orig,
fcd, fcd,
fco, fco,
fca, fca,
toolconf, toolconf,
backup, backup,
labels=None, labels=None,
localorother=None, localorother=None,
): ):
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( def _itagmerge(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None):
repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=None
):
""" """
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, fcd, fco, fca)
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, orig, fcd, fco, fca, toolconf, backup, labels=None): def _idump(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None):
""" """
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``.
util.writefile(a + b".local", fcd.decodeddata()) util.writefile(a + b".local", fcd.decodeddata())
repo.wwrite(fd + b".other", fco.data(), fco.flags()) repo.wwrite(fd + b".other", fco.data(), fco.flags())
repo.wwrite(fd + b".base", fca.data(), fca.flags()) repo.wwrite(fd + b".base", fca.data(), fca.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( def _forcedump(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None):
repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=None
):
""" """
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( return _idump(repo, mynode, fcd, fco, fca, toolconf, backup, labels=labels)
repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=labels
)
def _xmergeimm( def _xmergeimm(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None):
repo, mynode, orig, fcd, fco, fca, toolconf, backup, labels=None
):
# 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, orig, fcd, fco, fca, toolconf, backup, labels): def _xmerge(repo, mynode, fcd, fco, fca, toolconf, backup, labels):
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
mergetype = fullmerge mergetype = fullmerge
onfailure = _(b"merging %s failed!\n") onfailure = _(b"merging %s failed!\n")
precheck = None precheck = None
isexternal = True isexternal = True
toolconf = tool, toolpath, binary, symlink, scriptfn toolconf = tool, toolpath, binary, symlink, scriptfn
if mergetype == nomerge: if mergetype == nomerge:
r, deleted = func(repo, mynode, orig, fcd, fco, fca, toolconf, labels) r, deleted = func(repo, mynode, fcd, fco, fca, toolconf, labels)
return True, r, deleted return True, r, deleted
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:
ui.status(_(b"merging %s\n") % fduipath) ui.status(_(b"merging %s\n") % fduipath)
ui.debug(b"my %s other %s ancestor %s\n" % (fcd, fco, fca)) 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 precheck and not precheck(repo, mynode, fcd, fco, fca, toolconf):
if onfailure: if onfailure:
if wctx.isinmemory(): if wctx.isinmemory():
raise error.InMemoryMergeConflictsError( raise error.InMemoryMergeConflictsError(
b'in-memory merge does not support merge conflicts' b'in-memory merge does not support merge conflicts'
) )
ui.warn(onfailure % fduipath) ui.warn(onfailure % fduipath)
return True, 1, False return True, 1, False
) )
# 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 not r, r, False return not r, r, False
needcheck, r, deleted = func( needcheck, r, deleted = func(
repo, repo,
mynode, mynode,
orig,
fcd, fcd,
fco, fco,
fca, fca,
toolconf, toolconf,
backup, backup,
labels=formattedlabels, labels=formattedlabels,
) )