mercurial-scm/hg: comparison mercurial/filemerge.py

equal deleted inserted replaced

-:07069fcd9a6e
+:fd9fe2658cda
 if newdata != data:
 util.writefile(file, newdata)
 @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
 keep as the merged version."""
 ui = repo.ui
-fd = fcd.path()
+fd = local.fctx.path()
 uipathfn = scmutil.getuipathfn(repo)
 # Avoid prompting during an in-memory merge since it doesn't support merge
 # conflicts.
-if fcd.changectx().isinmemory():
+if local.fctx.changectx().isinmemory():
 raise error.InMemoryMergeConflictsError(
 b'in-memory merge does not support file conflicts'
 )
-prompts = partextras(labels)
+prompts = partextras([local.label, other.label])
 prompts[b'fd'] = uipathfn(fd)
 try:
-if fco.isabsent():
+if other.fctx.isabsent():
 index = ui.promptchoice(_localchangedotherdeletedmsg % prompts, 2)
 choice = [b'local', b'other', b'unresolved'][index]
-elif fcd.isabsent():
+elif local.fctx.isabsent():
 index = ui.promptchoice(_otherchangedlocaldeletedmsg % prompts, 2)
 choice = [b'other', b'local', b'unresolved'][index]
 else:
 # IMPORTANT: keep the last line of this prompt ("What do you want to
 # do?") very short, see comment next to _localchangedotherdeletedmsg
 2,
 )
 choice = [b'local', b'other', b'unresolved'][index]
 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':
-return _ilocal(repo, mynode, fcd, fco, fca, toolconf, labels)
+return _ilocal(repo, mynode, local, other, base, toolconf)
 elif choice == b'unresolved':
-return _ifail(repo, mynode, fcd, fco, fca, toolconf, labels)
+return _ifail(repo, mynode, local, other, base, toolconf)
 except error.ResponseExpected:
 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)
-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."""
-return 0, fcd.isabsent()
+return 0, local.fctx.isabsent()
 @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."""
-if fco.isabsent():
+if other.fctx.isabsent():
 # local changed, remote deleted -- 'deleted' picked
-_underlyingfctxifabsent(fcd).remove()
+_underlyingfctxifabsent(local.fctx).remove()
 deleted = True
 else:
-_underlyingfctxifabsent(fcd).write(fco.data(), fco.flags())
+_underlyingfctxifabsent(local.fctx).write(
+other.fctx.data(), other.fctx.flags()
+)
 deleted = False
 return 0, deleted
 @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
 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
-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
 def _underlyingfctxifabsent(filectx):
 """Sometimes when resolving, our fcd is actually an absentfilectx, but
 return filectx.changectx()[filectx.path()]
 else:
 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
-if symlink or fcd.isabsent() or fco.isabsent():
+if symlink or local.fctx.isabsent() or other.fctx.isabsent():
 return 1
 ui = repo.ui
 validkeep = [b'keep', b'keep-merge3', b'keep-mergediff']
 mode = b'merge'
 if premerge == b'keep-mergediff':
 mode = b'mergediff'
 elif premerge == b'keep-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(
 ui, local, base, other, quiet=True, mode=mode
 )
 if not r:
 ui.debug(b" premerge successful\n")
 return 0
 if premerge not in validkeep:
 # restore from backup and try again
-_restorebackup(fcd, backup)
+_restorebackup(local.fctx, backup)
 return 1  # continue merging
 def _mergecheck(repo, mynode, fcd, fco, fca, toolconf):
 tool, toolpath, binary, symlink, scriptfn = toolconf
 )
 return False
 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
 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."""
 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)
 return True, r, False
 @internaltool(
 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):
+def _iunion(repo, mynode, local, other, base, toolconf, backup):
 """
 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, fcd, fco, fca, labels, b'union')
+return _merge(repo, local, other, base, b'union')
 @internaltool(
 b'merge',
 fullmerge,
 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):
+def _imerge(repo, mynode, local, other, base, toolconf, backup):
 """
 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, fcd, fco, fca, labels, b'merge')
+return _merge(repo, local, other, base, b'merge')
 @internaltool(
 b'merge3',
 fullmerge,
 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):
+def _imerge3(repo, mynode, local, other, base, toolconf, backup):
 """
 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."""
-return _merge(repo, fcd, fco, fca, labels, b'merge3')
+return _merge(repo, local, other, base, b'merge3')
 @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):
+def _imerge_diff(repo, mynode, local, other, base, toolconf, backup):
 """
 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
 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)
-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
 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)
-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
 of the other `p2()` changes."""
-return _merge(repo, fcd, fco, fca, labels, b'other')
+return _merge(repo, local, other, base, b'other')
 @internaltool(
 b'tagmerge',
 mergeonly,
 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):
+def _itagmerge(repo, mynode, local, other, base, toolconf, backup):
 """
 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
 @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
 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``,
 same directory as ``a.txt``.
 This implies premerge. Therefore, files aren't dumped, if premerge
 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
-if isinstance(fcd, context.overlayworkingfilectx):
+if isinstance(local.fctx, context.overlayworkingfilectx):
 raise error.InMemoryMergeConflictsError(
 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
 @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.
 """
-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,
 # 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):
+def _xmerge(repo, mynode, local, other, base, toolconf, backup):
+fcd = local.fctx
+fco = other.fctx
+fca = base.fctx
 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')
 with _maketempfiles(
 repo, fco, fca, repo.wvfs.join(backup.path()), b"$output" in args
 ) as temppaths:
 basepath, otherpath, localoutputpath = temppaths
 outpath = b""
-mylabel, otherlabel = labels[:2]
-baselabel = labels[2]
 env = {
 b'HG_FILE': fcd.path(),
 b'HG_MY_NODE': short(mynode),
 b'HG_OTHER_NODE': short(fco.changectx().node()),
 b'HG_BASE_NODE': short(fca.changectx().node()),
 b'HG_MY_ISLINK': b'l' in fcd.flags(),
 b'HG_OTHER_ISLINK': b'l' in fco.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
 if b"$output" in args:
 # read input from backup, write to original
 replace = {
 b'local': localpath,
 b'base': basepath,
 b'other': otherpath,
 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(
 br'\$',
 replace,
 args,
 r = 1
 repo.ui.debug(b'merge tool returned: %d\n' % r)
 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.
 Pad is the minimum width of the label prefix, so that multiple markers
 can have aligned templated parts.
 """
 # 8 for the prefix of conflict marker lines (e.g. '<<<<<<< ')
 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.
 Returns a list of formatted labels.
 """
 ui = repo.ui
 ui, template, defaults=templatekw.keywords, resources=tres
 )
 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):
 """Return a dictionary of extra labels for use in prompts to the user
 base = simplemerge.MergeInput(fca, labels[2])
 if mergetype == nomerge:
 return func(
 repo,
 mynode,
-fcd,
+local,
-fco,
+other,
-fca,
+base,
 toolconf,
-[local.label, other.label, base.label],
 )
 if orig != fco.path():
 ui.status(
 _(b"merging %s and %s to %s\n")
 if markerstyle != b'basic':
 # respect 'tool's mergemarkertemplate (which defaults to
 # command-templates.mergemarker)
 labeltool = tool
 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(
 repo,
-fcd,
+local,
-fco,
+other,
-fca,
+base,
 toolconf,
 backup,
-labels=[local.label, other.label, base.label],
 )
 # we're done if premerge was successful (r is 0)
 if not r:
 return r, False
 local.label = labels[0]
 other.label = labels[1]
 base.label = labels[2]
 if markerstyle != b'basic':
-_formatlabels(repo, [local, other, base], tool=tool)
+_populate_label_details(repo, [local, other, base], tool=tool)
 needcheck, r, deleted = func(
 repo,
 mynode,
-fcd,
+local,
-fco,
+other,
-fca,
+base,
 toolconf,
 backup,
-labels=[local.label, other.label, base.label],
 )
 if needcheck:
 r = _check(repo, r, ui, tool, fcd, backup)

changeset 48586	fd9fe2658cda
parent 48585	07069fcd9a6e
child 48587	3c8cc987672e