filemerge.py
1233 lines
| 39.7 KiB
| text/x-python
|
PythonLexer
/ mercurial / filemerge.py
|
r6003 | # filemerge.py - file-level merge handling for Mercurial | ||
# | ||||
|
r47575 | # Copyright 2006, 2007, 2008 Olivia Mackall <olivia@selenic.com> | ||
|
r6003 | # | ||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r6003 | |||
|
r25949 | from __future__ import absolute_import | ||
|
r37016 | import contextlib | ||
|
r25949 | import os | ||
import re | ||||
|
r37017 | import shutil | ||
|
r25949 | |||
from .i18n import _ | ||||
|
r40512 | from .node import ( | ||
hex, | ||||
short, | ||||
) | ||||
|
r43359 | from .pycompat import ( | ||
getattr, | ||||
) | ||||
|
r25949 | |||
from . import ( | ||||
|
r30636 | encoding, | ||
|
r25949 | error, | ||
|
r28955 | formatter, | ||
|
r25949 | match, | ||
|
r30073 | pycompat, | ||
|
r33663 | registrar, | ||
|
r27651 | scmutil, | ||
|
r25949 | simplemerge, | ||
tagmerge, | ||||
templatekw, | ||||
templater, | ||||
|
r40512 | templateutil, | ||
|
r25949 | util, | ||
) | ||||
|
r6004 | |||
|
r37102 | from .utils import ( | ||
|
r37138 | procutil, | ||
|
r49597 | stringutil, | ||
|
r37102 | ) | ||
|
r43346 | |||
|
r34827 | def _toolstr(ui, tool, part, *args): | ||
|
r43347 | return ui.config(b"merge-tools", tool + b"." + part, *args) | ||
|
r6004 | |||
|
r43346 | |||
def _toolbool(ui, tool, part, *args): | ||||
|
r43347 | return ui.configbool(b"merge-tools", tool + b"." + part, *args) | ||
|
r6004 | |||
|
r43346 | |||
|
r34827 | def _toollist(ui, tool, part): | ||
|
r43347 | return ui.configlist(b"merge-tools", tool + b"." + part) | ||
|
r11148 | |||
|
r43346 | |||
|
r16126 | internals = {} | ||
|
r24099 | # Merge tools to document. | ||
internalsdoc = {} | ||||
|
r16125 | |||
|
r33663 | internaltool = registrar.internalmerge() | ||
|
r26525 | # internal tool merge types | ||
|
r33663 | nomerge = internaltool.nomerge | ||
|
r43346 | mergeonly = internaltool.mergeonly # just the full merge, no premerge | ||
fullmerge = internaltool.fullmerge # both premerge and merge | ||||
|
r26525 | |||
|
r42765 | # IMPORTANT: keep the last line of this prompt very short ("What do you want to | ||
# do?") because of issue6158, ideally to <40 English characters (to allow other | ||||
# languages that may take more columns to still have a chance to fit in an | ||||
# 80-column screen). | ||||
|
r32318 | _localchangedotherdeletedmsg = _( | ||
|
r43347 | b"file '%(fd)s' was deleted in other%(o)s but was modified in local%(l)s.\n" | ||
b"You can use (c)hanged version, (d)elete, or leave (u)nresolved.\n" | ||||
b"What do you want to do?" | ||||
b"$$ &Changed $$ &Delete $$ &Unresolved" | ||||
|
r43346 | ) | ||
|
r32318 | |||
_otherchangedlocaldeletedmsg = _( | ||||
|
r43347 | b"file '%(fd)s' was deleted in local%(l)s but was modified in other%(o)s.\n" | ||
b"You can use (c)hanged version, leave (d)eleted, or leave (u)nresolved.\n" | ||||
b"What do you want to do?" | ||||
b"$$ &Changed $$ &Deleted $$ &Unresolved" | ||||
|
r43346 | ) | ||
|
r32318 | |||
|
r26979 | class absentfilectx(object): | ||
"""Represents a file that's ostensibly in a context but is actually not | ||||
present in it. | ||||
This is here because it's very specific to the filemerge code for now -- | ||||
other code is likely going to break with the values this returns.""" | ||||
|
r43346 | |||
|
r26979 | def __init__(self, ctx, f): | ||
self._ctx = ctx | ||||
self._f = f | ||||
|
r45408 | def __bytes__(self): | ||
return b'absent file %s@%s' % (self._f, self._ctx) | ||||
|
r26979 | def path(self): | ||
return self._f | ||||
def size(self): | ||||
return None | ||||
def data(self): | ||||
return None | ||||
def filenode(self): | ||||
|
r47771 | return self._ctx.repo().nullid | ||
|
r26979 | |||
_customcmp = True | ||||
|
r43346 | |||
|
r26979 | def cmp(self, fctx): | ||
"""compare with other file context | ||||
returns True if different from fctx. | ||||
""" | ||||
|
r43346 | return not ( | ||
fctx.isabsent() | ||||
|
r44305 | and fctx.changectx() == self.changectx() | ||
|
r43346 | and fctx.path() == self.path() | ||
) | ||||
|
r26979 | |||
def flags(self): | ||||
|
r43347 | return b'' | ||
|
r26979 | |||
def changectx(self): | ||||
return self._ctx | ||||
def isbinary(self): | ||||
return False | ||||
def isabsent(self): | ||||
return True | ||||
|
r43346 | |||
|
r6004 | def _findtool(ui, tool): | ||
|
r16126 | if tool in internals: | ||
|
r6522 | return tool | ||
|
r43347 | cmd = _toolstr(ui, tool, b"executable", tool) | ||
if cmd.startswith(b'python:'): | ||||
|
r38052 | return cmd | ||
|
r23148 | return findexternaltool(ui, tool) | ||
|
r43346 | |||
|
r38052 | def _quotetoolpath(cmd): | ||
|
r43347 | if cmd.startswith(b'python:'): | ||
|
r38052 | return cmd | ||
return procutil.shellquote(cmd) | ||||
|
r43346 | |||
|
r23148 | def findexternaltool(ui, tool): | ||
|
r43347 | for kn in (b"regkey", b"regkeyalt"): | ||
|
r13565 | k = _toolstr(ui, tool, kn) | ||
if not k: | ||||
continue | ||||
|
r43347 | p = util.lookupreg(k, _toolstr(ui, tool, b"regname")) | ||
|
r6006 | if p: | ||
|
r43347 | p = procutil.findexe(p + _toolstr(ui, tool, b"regappend", b"")) | ||
|
r6006 | if p: | ||
return p | ||||
|
r43347 | exe = _toolstr(ui, tool, b"executable", tool) | ||
|
r37138 | return procutil.findexe(util.expandpath(exe)) | ||
|
r6004 | |||
|
r43346 | |||
|
r27039 | def _picktool(repo, ui, path, binary, symlink, changedelete): | ||
|
r43347 | strictcheck = ui.configbool(b'merge', b'strict-capability-check') | ||
|
r39161 | |||
|
r39159 | def hascapability(tool, capability, strict=False): | ||
|
r39302 | if tool in internals: | ||
return strict and internals[tool].capabilities.get(capability) | ||||
|
r39159 | return _toolbool(ui, tool, capability) | ||
|
r27039 | def supportscd(tool): | ||
return tool in internals and internals[tool].mergetype == nomerge | ||||
def check(tool, pat, symlink, binary, changedelete): | ||||
|
r6004 | tmsg = tool | ||
if pat: | ||||
|
r43347 | tmsg = _(b"%s (for pattern %s)") % (tool, pat) | ||
|
r7397 | if not _findtool(ui, tool): | ||
|
r43346 | if pat: # explicitly requested tool deserves a warning | ||
|
r43347 | ui.warn(_(b"couldn't find merge tool %s\n") % tmsg) | ||
|
r43346 | else: # configured but non-existing tools are more silent | ||
|
r43347 | ui.note(_(b"couldn't find merge tool %s\n") % tmsg) | ||
elif symlink and not hascapability(tool, b"symlink", strictcheck): | ||||
ui.warn(_(b"tool %s can't handle symlinks\n") % tmsg) | ||||
elif binary and not hascapability(tool, b"binary", strictcheck): | ||||
ui.warn(_(b"tool %s can't handle binary\n") % tmsg) | ||||
|
r27039 | elif changedelete and not supportscd(tool): | ||
# the nomerge tools are the only tools that support change/delete | ||||
# conflicts | ||||
pass | ||||
|
r43347 | elif not procutil.gui() and _toolbool(ui, tool, b"gui"): | ||
ui.warn(_(b"tool %s requires a GUI\n") % tmsg) | ||||
|
r6004 | else: | ||
return True | ||||
return False | ||||
|
r25835 | # internal config: ui.forcemerge | ||
|
r12788 | # forcemerge comes from command line arguments, highest priority | ||
|
r43347 | force = ui.config(b'ui', b'forcemerge') | ||
|
r12788 | if force: | ||
toolpath = _findtool(ui, force) | ||||
|
r27039 | if changedelete and not supportscd(toolpath): | ||
|
r43347 | return b":prompt", None | ||
|
r12788 | else: | ||
|
r27039 | if toolpath: | ||
|
r38052 | return (force, _quotetoolpath(toolpath)) | ||
|
r27039 | else: | ||
# mimic HGMERGE if given tool not found | ||||
return (force, force) | ||||
|
r12788 | |||
# HGMERGE takes next precedence | ||||
|
r43347 | hgmerge = encoding.environ.get(b"HGMERGE") | ||
|
r6025 | if hgmerge: | ||
|
r27039 | if changedelete and not supportscd(hgmerge): | ||
|
r43347 | return b":prompt", None | ||
|
r27039 | else: | ||
return (hgmerge, hgmerge) | ||||
|
r6004 | |||
# then patterns | ||||
|
r39161 | |||
# whether binary capability should be checked strictly | ||||
binarycap = binary and strictcheck | ||||
|
r43347 | for pat, tool in ui.configitems(b"merge-patterns"): | ||
mf = match.match(repo.root, b'', [pat]) | ||||
|
r39161 | if mf(path) and check(tool, pat, symlink, binarycap, changedelete): | ||
|
r43347 | if binary and not hascapability(tool, b"binary", strict=True): | ||
|
r43346 | ui.warn( | ||
_( | ||||
|
r43347 | b"warning: check merge-patterns configurations," | ||
b" if %r for binary file %r is unintentional\n" | ||||
b"(see 'hg help merge-tools'" | ||||
b" for binary files capability)\n" | ||||
|
r43346 | ) | ||
% (pycompat.bytestr(tool), pycompat.bytestr(path)) | ||||
) | ||||
|
r10339 | toolpath = _findtool(ui, tool) | ||
|
r38052 | return (tool, _quotetoolpath(toolpath)) | ||
|
r6004 | |||
# then merge tools | ||||
tools = {} | ||||
|
r26730 | disabled = set() | ||
|
r43347 | for k, v in ui.configitems(b"merge-tools"): | ||
t = k.split(b'.')[0] | ||||
|
r6004 | if t not in tools: | ||
|
r43347 | tools[t] = int(_toolstr(ui, t, b"priority")) | ||
if _toolbool(ui, t, b"disabled"): | ||||
|
r26730 | disabled.add(t) | ||
|
r6076 | names = tools.keys() | ||
|
r43346 | tools = sorted( | ||
[(-p, tool) for tool, p in tools.items() if tool not in disabled] | ||||
) | ||||
|
r43347 | uimerge = ui.config(b"ui", b"merge") | ||
|
r6076 | if uimerge: | ||
|
r27039 | # external tools defined in uimerge won't be able to handle | ||
# change/delete conflicts | ||||
|
r38987 | if check(uimerge, path, symlink, binary, changedelete): | ||
if uimerge not in names and not changedelete: | ||||
return (uimerge, uimerge) | ||||
|
r43346 | tools.insert(0, (None, uimerge)) # highest priority | ||
|
r43347 | tools.append((None, b"hgmerge")) # the old default, if found | ||
|
r10282 | for p, t in tools: | ||
|
r27039 | if check(t, None, symlink, binary, changedelete): | ||
|
r7397 | toolpath = _findtool(ui, t) | ||
|
r38052 | return (t, _quotetoolpath(toolpath)) | ||
|
r16254 | |||
# internal merge or prompt as last resort | ||||
|
r27039 | if symlink or binary or changedelete: | ||
|
r32253 | if not changedelete and len(tools): | ||
# any tool is rejected by capability for symlink or binary | ||||
|
r43347 | ui.warn(_(b"no tool found to merge %s\n") % path) | ||
return b":prompt", None | ||||
return b":merge", None | ||||
|
r6003 | |||
|
r43346 | |||
|
r6005 | def _eoltype(data): | ||
|
r44226 | """Guess the EOL type of a file""" | ||
|
r43347 | if b'\0' in data: # binary | ||
|
r6005 | return None | ||
|
r43347 | if b'\r\n' in data: # Windows | ||
return b'\r\n' | ||||
if b'\r' in data: # Old Mac | ||||
return b'\r' | ||||
if b'\n' in data: # UNIX | ||||
return b'\n' | ||||
|
r43346 | return None # unknown | ||
|
r6005 | |||
|
r49334 | def _matcheol(file, backup): | ||
|
r44226 | """Convert EOL markers in a file to match origfile""" | ||
|
r49334 | tostyle = _eoltype(backup.data()) # No repo.wread filters? | ||
|
r6005 | if tostyle: | ||
|
r14168 | data = util.readfile(file) | ||
|
r6005 | style = _eoltype(data) | ||
if style: | ||||
newdata = data.replace(style, tostyle) | ||||
if newdata != data: | ||||
|
r14168 | util.writefile(file, newdata) | ||
|
r6005 | |||
|
r43346 | |||
|
r43347 | @internaltool(b'prompt', nomerge) | ||
|
r49432 | def _iprompt(repo, mynode, local, other, base, toolconf): | ||
|
r28640 | """Asks the user which of the local `p1()` or the other `p2()` version to | ||
keep as the merged version.""" | ||||
|
r16125 | ui = repo.ui | ||
|
r49432 | fd = local.fctx.path() | ||
|
r41651 | uipathfn = scmutil.getuipathfn(repo) | ||
|
r16125 | |||
|
r35283 | # Avoid prompting during an in-memory merge since it doesn't support merge | ||
# conflicts. | ||||
|
r49432 | if local.fctx.changectx().isinmemory(): | ||
|
r43346 | raise error.InMemoryMergeConflictsError( | ||
|
r43387 | b'in-memory merge does not support file conflicts' | ||
|
r43346 | ) | ||
|
r35283 | |||
|
r49432 | prompts = partextras([local.label, other.label]) | ||
|
r43347 | prompts[b'fd'] = uipathfn(fd) | ||
|
r26898 | try: | ||
|
r49432 | if other.fctx.isabsent(): | ||
|
r43346 | index = ui.promptchoice(_localchangedotherdeletedmsg % prompts, 2) | ||
|
r43347 | choice = [b'local', b'other', b'unresolved'][index] | ||
|
r49432 | elif local.fctx.isabsent(): | ||
|
r43346 | index = ui.promptchoice(_otherchangedlocaldeletedmsg % prompts, 2) | ||
|
r43347 | choice = [b'other', b'local', b'unresolved'][index] | ||
|
r27038 | else: | ||
|
r42765 | # IMPORTANT: keep the last line of this prompt ("What do you want to | ||
# do?") very short, see comment next to _localchangedotherdeletedmsg | ||||
# at the top of the file for details. | ||||
|
r27162 | index = ui.promptchoice( | ||
|
r43346 | _( | ||
|
r43347 | 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"(u)nresolved.\n" | ||||
b"What do you want to do?" | ||||
b"$$ &Local $$ &Other $$ &Unresolved" | ||||
|
r43346 | ) | ||
% prompts, | ||||
2, | ||||
) | ||||
|
r43347 | choice = [b'local', b'other', b'unresolved'][index] | ||
|
r26851 | |||
|
r43347 | if choice == b'other': | ||
|
r49432 | return _iother(repo, mynode, local, other, base, toolconf) | ||
|
r43347 | elif choice == b'local': | ||
|
r49432 | return _ilocal(repo, mynode, local, other, base, toolconf) | ||
|
r43347 | elif choice == b'unresolved': | ||
|
r49432 | return _ifail(repo, mynode, local, other, base, toolconf) | ||
|
r26898 | except error.ResponseExpected: | ||
|
r43347 | ui.write(b"\n") | ||
|
r49432 | return _ifail(repo, mynode, local, other, base, toolconf) | ||
|
r43346 | |||
|
r16125 | |||
|
r43347 | @internaltool(b'local', nomerge) | ||
|
r49432 | def _ilocal(repo, mynode, local, other, base, toolconf): | ||
|
r28640 | """Uses the local `p1()` version of files as the merged version.""" | ||
|
r49432 | return 0, local.fctx.isabsent() | ||
|
r16125 | |||
|
r43346 | |||
|
r43347 | @internaltool(b'other', nomerge) | ||
|
r49432 | def _iother(repo, mynode, local, other, base, toolconf): | ||
|
r28640 | """Uses the other `p2()` version of files as the merged version.""" | ||
|
r49432 | if other.fctx.isabsent(): | ||
|
r27037 | # local changed, remote deleted -- 'deleted' picked | ||
|
r49432 | _underlyingfctxifabsent(local.fctx).remove() | ||
|
r27037 | deleted = True | ||
else: | ||||
|
r49432 | _underlyingfctxifabsent(local.fctx).write( | ||
other.fctx.data(), other.fctx.flags() | ||||
) | ||||
|
r27037 | deleted = False | ||
return 0, deleted | ||||
|
r16125 | |||
|
r43346 | |||
|
r43347 | @internaltool(b'fail', nomerge) | ||
|
r49432 | def _ifail(repo, mynode, local, other, base, toolconf): | ||
|
r16127 | """ | ||
|
r16126 | 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.""" | ||||
|
r27123 | # for change/delete conflicts write out the changed version, then fail | ||
|
r49432 | if local.fctx.isabsent(): | ||
_underlyingfctxifabsent(local.fctx).write( | ||||
other.fctx.data(), other.fctx.flags() | ||||
) | ||||
|
r27032 | return 1, False | ||
|
r16125 | |||
|
r43346 | |||
|
r33152 | def _underlyingfctxifabsent(filectx): | ||
"""Sometimes when resolving, our fcd is actually an absentfilectx, but | ||||
we want to write to it (to do the resolve). This helper returns the | ||||
underyling workingfilectx in that case. | ||||
""" | ||||
if filectx.isabsent(): | ||||
return filectx.changectx()[filectx.path()] | ||||
else: | ||||
return filectx | ||||
|
r43346 | |||
|
r49597 | def _verifytext(input, ui): | ||
"""verifies that text is non-binary""" | ||||
if stringutil.binary(input.text()): | ||||
msg = _(b"%s looks like a binary file.") % input.fctx.path() | ||||
ui.warn(_(b'warning: %s\n') % msg) | ||||
raise error.Abort(msg) | ||||
|
r49600 | def _premerge(repo, local, other, base, toolconf): | ||
|
r38052 | tool, toolpath, binary, symlink, scriptfn = toolconf | ||
|
r49432 | if symlink or local.fctx.isabsent() or other.fctx.isabsent(): | ||
|
r18257 | return 1 | ||
|
r16125 | |||
ui = repo.ui | ||||
|
r46755 | validkeep = [b'keep', b'keep-merge3', b'keep-mergediff'] | ||
|
r22031 | |||
|
r16125 | # do we attempt to simplemerge first? | ||
try: | ||||
|
r43347 | premerge = _toolbool(ui, tool, b"premerge", not binary) | ||
|
r16125 | except error.ConfigError: | ||
|
r43347 | premerge = _toolstr(ui, tool, b"premerge", b"").lower() | ||
|
r22031 | if premerge not in validkeep: | ||
|
r43347 | _valid = b', '.join([b"'" + v + b"'" for v in validkeep]) | ||
|
r43346 | raise error.ConfigError( | ||
|
r43387 | _(b"%s.premerge not valid ('%s' is neither boolean nor %s)") | ||
|
r43346 | % (tool, premerge, _valid) | ||
) | ||||
|
r16125 | |||
if premerge: | ||||
|
r46755 | mode = b'merge' | ||
|
r49404 | if premerge == b'keep-mergediff': | ||
mode = b'mergediff' | ||||
elif premerge == b'keep-merge3': | ||||
mode = b'merge3' | ||||
|
r49597 | if any( | ||
stringutil.binary(input.text()) for input in (local, base, other) | ||||
): | ||||
return 1 # continue merging | ||||
|
r49599 | merged_text, conflicts = simplemerge.simplemerge( | ||
|
r49602 | local, base, other, mode=mode | ||
|
r46755 | ) | ||
|
r49600 | if not conflicts or premerge in validkeep: | ||
# fcd.flags() already has the merged flags (done in | ||||
# mergestate.resolve()) | ||||
local.fctx.write(merged_text, local.fctx.flags()) | ||||
|
r49599 | if not conflicts: | ||
|
r43347 | ui.debug(b" premerge successful\n") | ||
|
r16125 | return 0 | ||
|
r43346 | return 1 # continue merging | ||
|
r16125 | |||
|
r49336 | def _mergecheck(repo, mynode, fcd, fco, fca, toolconf): | ||
|
r38052 | tool, toolpath, binary, symlink, scriptfn = toolconf | ||
|
r41651 | uipathfn = scmutil.getuipathfn(repo) | ||
|
r26515 | if symlink: | ||
|
r43346 | repo.ui.warn( | ||
|
r43387 | _(b'warning: internal %s cannot merge symlinks for %s\n') | ||
|
r43346 | % (tool, uipathfn(fcd.path())) | ||
) | ||||
|
r26515 | return False | ||
|
r27040 | if fcd.isabsent() or fco.isabsent(): | ||
|
r43346 | repo.ui.warn( | ||
_( | ||||
|
r43347 | b'warning: internal %s cannot merge change/delete ' | ||
b'conflict for %s\n' | ||||
|
r43346 | ) | ||
% (tool, uipathfn(fcd.path())) | ||||
) | ||||
|
r27040 | return False | ||
|
r26515 | return True | ||
|
r43346 | |||
|
r49432 | def _merge(repo, local, other, base, mode): | ||
|
r16127 | """ | ||
|
r16126 | Uses the internal non-interactive simple merge algorithm for merging | ||
files. It will fail if there are any conflicts and leave markers in | ||||
|
r22027 | the partially merged file. Markers will have two sections, one for each side | ||
|
r26070 | of merge, unless mode equals 'union' which suppresses the markers.""" | ||
|
r26572 | ui = repo.ui | ||
|
r16125 | |||
|
r49597 | try: | ||
_verifytext(local, ui) | ||||
_verifytext(base, ui) | ||||
_verifytext(other, ui) | ||||
except error.Abort: | ||||
return True, True, False | ||||
|
r49599 | else: | ||
merged_text, conflicts = simplemerge.simplemerge( | ||||
|
r49602 | local, base, other, mode=mode | ||
|
r49599 | ) | ||
# fcd.flags() already has the merged flags (done in | ||||
# mergestate.resolve()) | ||||
local.fctx.write(merged_text, local.fctx.flags()) | ||||
return True, conflicts, False | ||||
|
r16125 | |||
|
r43346 | |||
@internaltool( | ||||
|
r43347 | b'union', | ||
|
r43346 | fullmerge, | ||
_( | ||||
|
r43347 | b"warning: conflicts while merging %s! " | ||
b"(edit, then use 'hg resolve --mark')\n" | ||||
|
r43346 | ), | ||
precheck=_mergecheck, | ||||
) | ||||
|
r49432 | def _iunion(repo, mynode, local, other, base, toolconf, backup): | ||
|
r26071 | """ | ||
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.""" | ||||
|
r49432 | return _merge(repo, local, other, base, b'union') | ||
|
r43346 | |||
|
r26071 | |||
|
r43346 | @internaltool( | ||
|
r43347 | b'merge', | ||
|
r43346 | fullmerge, | ||
_( | ||||
|
r43347 | b"warning: conflicts while merging %s! " | ||
b"(edit, then use 'hg resolve --mark')\n" | ||||
|
r43346 | ), | ||
precheck=_mergecheck, | ||||
) | ||||
|
r49432 | def _imerge(repo, mynode, local, other, base, toolconf, backup): | ||
|
r26070 | """ | ||
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.""" | ||||
|
r49432 | return _merge(repo, local, other, base, b'merge') | ||
|
r43346 | |||
|
r26070 | |||
|
r43346 | @internaltool( | ||
|
r43347 | b'merge3', | ||
|
r43346 | fullmerge, | ||
_( | ||||
|
r43347 | b"warning: conflicts while merging %s! " | ||
b"(edit, then use 'hg resolve --mark')\n" | ||||
|
r43346 | ), | ||
precheck=_mergecheck, | ||||
) | ||||
|
r49432 | def _imerge3(repo, mynode, local, other, base, toolconf, backup): | ||
|
r22028 | """ | ||
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.""" | ||||
|
r49432 | return _merge(repo, local, other, base, b'merge3') | ||
|
r22028 | |||
|
r43346 | |||
|
r46724 | @internaltool( | ||
|
r47072 | b'merge3-lie-about-conflicts', | ||
fullmerge, | ||||
b'', | ||||
precheck=_mergecheck, | ||||
) | ||||
def _imerge3alwaysgood(*args, **kwargs): | ||||
# Like merge3, but record conflicts as resolved with markers in place. | ||||
# | ||||
|
r47246 | # This is used for `diff.merge` to show the differences between | ||
|
r47072 | # the auto-merge state and the committed merge state. It may be | ||
# useful for other things. | ||||
b1, junk, b2 = _imerge3(*args, **kwargs) | ||||
# TODO is this right? I'm not sure what these return values mean, | ||||
# but as far as I can tell this will indicate to callers tha the | ||||
# merge succeeded. | ||||
return b1, False, b2 | ||||
@internaltool( | ||||
|
r46724 | b'mergediff', | ||
fullmerge, | ||||
_( | ||||
b"warning: conflicts while merging %s! " | ||||
b"(edit, then use 'hg resolve --mark')\n" | ||||
), | ||||
precheck=_mergecheck, | ||||
) | ||||
|
r49432 | def _imerge_diff(repo, mynode, local, other, base, toolconf, backup): | ||
|
r46724 | """ | ||
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)""" | ||||
|
r49432 | return _merge(repo, local, other, base, b'mergediff') | ||
|
r46724 | |||
|
r43347 | @internaltool(b'merge-local', mergeonly, precheck=_mergecheck) | ||
|
r49432 | def _imergelocal(repo, mynode, local, other, base, toolconf, backup): | ||
|
r26224 | """ | ||
Like :merge, but resolve all conflicts non-interactively in favor | ||||
|
r28640 | of the local `p1()` changes.""" | ||
|
r49432 | return _merge(repo, local, other, base, b'local') | ||
|
r26224 | |||
|
r43346 | |||
|
r43347 | @internaltool(b'merge-other', mergeonly, precheck=_mergecheck) | ||
|
r49432 | def _imergeother(repo, mynode, local, other, base, toolconf, backup): | ||
|
r26224 | """ | ||
Like :merge, but resolve all conflicts non-interactively in favor | ||||
|
r28640 | of the other `p2()` changes.""" | ||
|
r49432 | return _merge(repo, local, other, base, b'other') | ||
|
r26224 | |||
|
r43346 | |||
@internaltool( | ||||
|
r43347 | b'tagmerge', | ||
|
r43346 | mergeonly, | ||
_( | ||||
|
r43347 | b"automatic tag merging of %s failed! " | ||
b"(use 'hg resolve --tool :merge' or another merge " | ||||
b"tool of your choice)\n" | ||||
|
r43346 | ), | ||
) | ||||
|
r49432 | def _itagmerge(repo, mynode, local, other, base, toolconf, backup): | ||
|
r21922 | """ | ||
Uses the internal tag merge algorithm (experimental). | ||||
""" | ||||
|
r49432 | success, status = tagmerge.merge(repo, local.fctx, other.fctx, base.fctx) | ||
|
r27033 | return success, status, False | ||
|
r21922 | |||
|
r43346 | |||
|
r43347 | @internaltool(b'dump', fullmerge, binary=True, symlink=True) | ||
|
r49432 | def _idump(repo, mynode, local, other, base, toolconf, backup): | ||
|
r16127 | """ | ||
|
r16126 | 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``, | ||||
``a.txt.other`` and ``a.txt.base`` and they will be placed in the | ||||
|
r32255 | same directory as ``a.txt``. | ||
|
r34916 | This implies premerge. Therefore, files aren't dumped, if premerge | ||
|
r32255 | runs successfully. Use :forcedump to forcibly write files out. | ||
""" | ||||
|
r49432 | a = _workingpath(repo, local.fctx) | ||
fd = local.fctx.path() | ||||
|
r16125 | |||
|
r34786 | from . import context | ||
|
r43346 | |||
|
r49432 | if isinstance(local.fctx, context.overlayworkingfilectx): | ||
|
r43346 | raise error.InMemoryMergeConflictsError( | ||
|
r43387 | b'in-memory merge does not support the :dump tool.' | ||
|
r43346 | ) | ||
|
r34786 | |||
|
r49432 | util.writefile(a + b".local", local.fctx.decodeddata()) | ||
repo.wwrite(fd + b".other", other.fctx.data(), other.fctx.flags()) | ||||
repo.wwrite(fd + b".base", base.fctx.data(), base.fctx.flags()) | ||||
|
r27033 | return False, 1, False | ||
|
r16125 | |||
|
r43346 | |||
|
r43347 | @internaltool(b'forcedump', mergeonly, binary=True, symlink=True) | ||
|
r49432 | def _forcedump(repo, mynode, local, other, base, toolconf, backup): | ||
|
r32255 | """ | ||
Creates three versions of the files as same as :dump, but omits premerge. | ||||
""" | ||||
|
r49432 | return _idump(repo, mynode, local, other, base, toolconf, backup) | ||
|
r43346 | |||
|
r32255 | |||
|
r49432 | def _xmergeimm(repo, mynode, local, other, base, toolconf, backup): | ||
|
r35479 | # 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 | ||||
# 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 | ||||
# clunky.) | ||||
|
r43346 | raise error.InMemoryMergeConflictsError( | ||
|
r43387 | b'in-memory merge does not support external merge tools' | ||
|
r43346 | ) | ||
|
r35479 | |||
|
r40512 | def _describemerge(ui, repo, mynode, fcl, fcb, fco, env, toolpath, args): | ||
|
r46353 | tmpl = ui.config(b'command-templates', b'pre-merge-tool-output') | ||
|
r40512 | if not tmpl: | ||
return | ||||
mappingdict = templateutil.mappingdict | ||||
|
r43346 | props = { | ||
|
r43347 | b'ctx': fcl.changectx(), | ||
b'node': hex(mynode), | ||||
b'path': fcl.path(), | ||||
b'local': mappingdict( | ||||
|
r43346 | { | ||
|
r43347 | b'ctx': fcl.changectx(), | ||
b'fctx': fcl, | ||||
b'node': hex(mynode), | ||||
b'name': _(b'local'), | ||||
b'islink': b'l' in fcl.flags(), | ||||
b'label': env[b'HG_MY_LABEL'], | ||||
|
r43346 | } | ||
), | ||||
|
r43347 | b'base': mappingdict( | ||
|
r43346 | { | ||
|
r43347 | b'ctx': fcb.changectx(), | ||
b'fctx': fcb, | ||||
b'name': _(b'base'), | ||||
b'islink': b'l' in fcb.flags(), | ||||
b'label': env[b'HG_BASE_LABEL'], | ||||
|
r43346 | } | ||
), | ||||
|
r43347 | b'other': mappingdict( | ||
|
r43346 | { | ||
|
r43347 | b'ctx': fco.changectx(), | ||
b'fctx': fco, | ||||
b'name': _(b'other'), | ||||
b'islink': b'l' in fco.flags(), | ||||
b'label': env[b'HG_OTHER_LABEL'], | ||||
|
r43346 | } | ||
), | ||||
|
r43347 | b'toolpath': toolpath, | ||
b'toolargs': args, | ||||
|
r43346 | } | ||
|
r40512 | |||
# TODO: make all of this something that can be specified on a per-tool basis | ||||
tmpl = templater.unquotestring(tmpl) | ||||
# Not using cmdutil.rendertemplate here since it causes errors importing | ||||
# things for us to import cmdutil. | ||||
tres = formatter.templateresources(ui, repo) | ||||
|
r43346 | t = formatter.maketemplater( | ||
ui, tmpl, defaults=templatekw.keywords, resources=tres | ||||
) | ||||
|
r40512 | ui.status(t.renderdefault(props)) | ||
|
r43346 | |||
|
r49432 | def _xmerge(repo, mynode, local, other, base, toolconf, backup): | ||
fcd = local.fctx | ||||
fco = other.fctx | ||||
fca = base.fctx | ||||
|
r38052 | tool, toolpath, binary, symlink, scriptfn = toolconf | ||
|
r41651 | uipathfn = scmutil.getuipathfn(repo) | ||
|
r27042 | if fcd.isabsent() or fco.isabsent(): | ||
|
r43346 | repo.ui.warn( | ||
|
r43387 | _(b'warning: %s cannot merge change/delete conflict for %s\n') | ||
|
r43346 | % (tool, uipathfn(fcd.path())) | ||
) | ||||
|
r27042 | return False, 1, None | ||
|
r36994 | localpath = _workingpath(repo, fcd) | ||
|
r43347 | args = _toolstr(repo.ui, tool, b"args") | ||
|
r49637 | |||
files = [ | ||||
(b"base", fca.path(), fca.decodeddata()), | ||||
(b"other", fco.path(), fco.decodeddata()), | ||||
] | ||||
outpath = b"" | ||||
|
r49633 | if b"$output" in args: | ||
|
r49637 | # read input from backup, write to original | ||
outpath = localpath | ||||
|
r49633 | localoutputpath = backup.path() | ||
|
r49634 | # Remove the .orig to make syntax-highlighting more likely. | ||
if localoutputpath.endswith(b'.orig'): | ||||
localoutputpath, ext = os.path.splitext(localoutputpath) | ||||
|
r49637 | localdata = util.readfile(localpath) | ||
files.append((b"local", localoutputpath, localdata)) | ||||
|
r37095 | |||
|
r49637 | with _maketempfiles(files) as temppaths: | ||
basepath, otherpath = temppaths[:2] | ||||
if len(temppaths) == 3: | ||||
localpath = temppaths[2] | ||||
|
r49433 | |||
def format_label(input): | ||||
if input.label_detail: | ||||
return b'%s: %s' % (input.label, input.label_detail) | ||||
else: | ||||
return input.label | ||||
|
r43346 | env = { | ||
|
r43347 | 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(), | ||||
|
r49433 | b'HG_MY_LABEL': format_label(local), | ||
b'HG_OTHER_LABEL': format_label(other), | ||||
b'HG_BASE_LABEL': format_label(base), | ||||
|
r43346 | } | ||
|
r34037 | ui = repo.ui | ||
|
r16125 | |||
|
r43346 | replace = { | ||
|
r43347 | b'local': localpath, | ||
b'base': basepath, | ||||
b'other': otherpath, | ||||
b'output': outpath, | ||||
|
r49433 | b'labellocal': format_label(local), | ||
b'labelother': format_label(other), | ||||
b'labelbase': format_label(base), | ||||
|
r43346 | } | ||
|
r37138 | args = util.interpolate( | ||
|
r43346 | br'\$', | ||
replace, | ||||
args, | ||||
lambda s: procutil.shellquote(util.localpath(s)), | ||||
) | ||||
|
r43347 | if _toolbool(ui, tool, b"gui"): | ||
|
r43346 | repo.ui.status( | ||
|
r43347 | _(b'running merge tool %s for file %s\n') | ||
|
r43346 | % (tool, uipathfn(fcd.path())) | ||
) | ||||
|
r38052 | if scriptfn is None: | ||
|
r43347 | cmd = toolpath + b' ' + args | ||
repo.ui.debug(b'launching merge tool: %s\n' % cmd) | ||||
|
r40512 | _describemerge(ui, repo, mynode, fcd, fca, fco, env, toolpath, args) | ||
|
r43346 | r = ui.system( | ||
|
r43347 | cmd, cwd=repo.root, environ=env, blockedtag=b'mergetool' | ||
|
r43346 | ) | ||
|
r38052 | else: | ||
|
r43346 | repo.ui.debug( | ||
|
r43347 | b'launching python merge script: %s:%s\n' % (toolpath, scriptfn) | ||
|
r43346 | ) | ||
|
r38052 | r = 0 | ||
try: | ||||
# avoid cycle cmdutil->merge->filemerge->extensions->cmdutil | ||||
from . import extensions | ||||
|
r43346 | |||
|
r43347 | mod = extensions.loadpath(toolpath, b'hgmerge.%s' % tool) | ||
|
r38052 | except Exception: | ||
|
r43346 | raise error.Abort( | ||
|
r43347 | _(b"loading python merge script failed: %s") % toolpath | ||
|
r43346 | ) | ||
|
r38052 | mergefn = getattr(mod, scriptfn, None) | ||
if mergefn is None: | ||||
|
r43346 | raise error.Abort( | ||
|
r43347 | _(b"%s does not have function: %s") % (toolpath, scriptfn) | ||
|
r43346 | ) | ||
|
r38052 | argslist = procutil.shellsplit(args) | ||
# avoid cycle cmdutil->merge->filemerge->hook->extensions->cmdutil | ||||
from . import hook | ||||
|
r43346 | |||
ret, raised = hook.pythonhook( | ||||
|
r43347 | ui, repo, b"merge", toolpath, mergefn, {b'args': argslist}, True | ||
|
r43346 | ) | ||
|
r38052 | if raised: | ||
r = 1 | ||||
|
r43347 | repo.ui.debug(b'merge tool returned: %d\n' % r) | ||
|
r34037 | return True, r, False | ||
|
r16125 | |||
|
r43346 | |||
|
r49433 | def _populate_label_detail(input, template): | ||
"""Applies the given template to the ctx and stores it in the input.""" | ||||
|
r49431 | ctx = input.fctx.changectx() | ||
|
r21519 | if ctx.node() is None: | ||
ctx = ctx.p1() | ||||
|
r43347 | props = {b'ctx': ctx} | ||
|
r37003 | templateresult = template.renderdefault(props) | ||
|
r49433 | input.label_detail = templateresult.splitlines()[0] # split for safety | ||
|
r21519 | |||
|
r43346 | |||
|
r49432 | def _populate_label_details(repo, inputs, tool=None): | ||
|
r49433 | """Populates the label details using the conflict marker template.""" | ||
|
r21519 | ui = repo.ui | ||
|
r46352 | template = ui.config(b'command-templates', b'mergemarker') | ||
|
r35925 | if tool is not None: | ||
|
r43347 | template = _toolstr(ui, tool, b'mergemarkertemplate', template) | ||
|
r32047 | template = templater.unquotestring(template) | ||
|
r35485 | tres = formatter.templateresources(ui, repo) | ||
|
r43346 | tmpl = formatter.maketemplater( | ||
ui, template, defaults=templatekw.keywords, resources=tres | ||||
) | ||||
|
r21519 | |||
|
r49432 | for input in inputs: | ||
|
r49433 | _populate_label_detail(input, tmpl) | ||
|
r21519 | |||
|
r43346 | |||
|
r29774 | def partextras(labels): | ||
"""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". | ||||
""" | ||||
if labels is None: | ||||
return { | ||||
|
r43347 | b"l": b"", | ||
b"o": b"", | ||||
|
r29774 | } | ||
return { | ||||
|
r43347 | b"l": b" [%s]" % labels[0], | ||
b"o": b" [%s]" % labels[1], | ||||
|
r29774 | } | ||
|
r43346 | |||
|
r49631 | def _makebackup(repo, ui, fcd): | ||
|
r34783 | """Makes and returns a filectx-like object for ``fcd``'s backup file. | ||
|
r34033 | |||
In addition to preserving the user's pre-existing modifications to `fcd` | ||||
(if any), the backup is used to undo certain premerges, confirm whether a | ||||
merge changed anything, and determine what line endings the new file should | ||||
have. | ||||
|
r35720 | |||
|
r49262 | Backups only need to be written once since their content doesn't change | ||
afterwards. | ||||
|
r34033 | """ | ||
if fcd.isabsent(): | ||||
return None | ||||
|
r34783 | # TODO: Break this import cycle somehow. (filectx -> ctx -> fileset -> | ||
# merge -> filemerge). (I suspect the fileset import is the weakest link) | ||||
from . import context | ||||
|
r43346 | |||
|
r49631 | if isinstance(fcd, context.overlayworkingfilectx): | ||
# If we're merging in-memory, we're free to put the backup anywhere. | ||||
fd, backup = pycompat.mkstemp(b'hg-merge-backup') | ||||
with os.fdopen(fd, 'wb') as f: | ||||
f.write(fcd.data()) | ||||
|
r34785 | else: | ||
|
r49631 | backup = scmutil.backuppath(ui, repo, fcd.path()) | ||
a = _workingpath(repo, fcd) | ||||
util.copyfile(a, backup) | ||||
return context.arbitraryfilectx(backup, repo=repo) | ||||
|
r34033 | |||
|
r43346 | |||
|
r37016 | @contextlib.contextmanager | ||
|
r49637 | def _maketempfiles(files): | ||
"""Creates a temporary file for each (prefix, path, data) tuple in `files`, | ||||
so an external merge tool may use them. | ||||
|
r34033 | """ | ||
|
r49624 | tmproot = pycompat.mkdtemp(prefix=b'hgmerge-') | ||
|
r37017 | |||
|
r49636 | def maketempfrompath(prefix, path, data): | ||
|
r37095 | fullbase, ext = os.path.splitext(path) | ||
|
r43347 | pre = b"%s~%s" % (os.path.basename(fullbase), prefix) | ||
|
r49624 | name = os.path.join(tmproot, pre) | ||
if ext: | ||||
name += ext | ||||
|
r49636 | util.writefile(name, data) | ||
return name | ||||
|
r37095 | |||
|
r49637 | temp_files = [] | ||
for prefix, path, data in files: | ||||
temp_files.append(maketempfrompath(prefix, path, data)) | ||||
|
r37016 | try: | ||
|
r49637 | yield temp_files | ||
|
r37016 | finally: | ||
|
r49624 | shutil.rmtree(tmproot) | ||
|
r34033 | |||
|
r43346 | |||
|
r49261 | def filemerge(repo, wctx, mynode, orig, fcd, fco, fca, labels=None): | ||
|
r6003 | """perform a 3-way merge in the working directory | ||
|
r6512 | mynode = parent node before merge | ||
orig = original local filename before merge | ||||
fco = other file context | ||||
fca = ancestor file context | ||||
fcd = local file context for current/destination file | ||||
|
r26606 | |||
|
r27034 | Returns whether the merge is complete, the return value of the merge, and | ||
a boolean indicating whether the file was deleted from disk.""" | ||||
|
r26608 | ui = repo.ui | ||
fd = fcd.path() | ||||
|
r41651 | uipathfn = scmutil.getuipathfn(repo) | ||
fduipath = uipathfn(fd) | ||||
|
r26608 | binary = fcd.isbinary() or fco.isbinary() or fca.isbinary() | ||
|
r43347 | symlink = b'l' in fcd.flags() + fco.flags() | ||
|
r27039 | changedelete = fcd.isabsent() or fco.isabsent() | ||
tool, toolpath = _picktool(repo, ui, fd, binary, symlink, changedelete) | ||||
|
r38052 | scriptfn = None | ||
|
r43347 | if tool in internals and tool.startswith(b'internal:'): | ||
|
r26608 | # normalize to new-style names (':merge' etc) | ||
|
r43347 | tool = tool[len(b'internal') :] | ||
if toolpath and toolpath.startswith(b'python:'): | ||||
|
r38052 | invalidsyntax = False | ||
|
r43347 | if toolpath.count(b':') >= 2: | ||
script, scriptfn = toolpath[7:].rsplit(b':', 1) | ||||
|
r38052 | if not scriptfn: | ||
invalidsyntax = True | ||||
# missing :callable can lead to spliting on windows drive letter | ||||
|
r43347 | if b'\\' in scriptfn or b'/' in scriptfn: | ||
|
r38052 | invalidsyntax = True | ||
else: | ||||
invalidsyntax = True | ||||
if invalidsyntax: | ||||
|
r43347 | raise error.Abort(_(b"invalid 'python:' syntax: %s") % toolpath) | ||
|
r38052 | toolpath = script | ||
|
r43346 | ui.debug( | ||
|
r43347 | b"picked tool '%s' for %s (binary %s symlink %s changedelete %s)\n" | ||
|
r43346 | % ( | ||
tool, | ||||
fduipath, | ||||
pycompat.bytestr(binary), | ||||
pycompat.bytestr(symlink), | ||||
pycompat.bytestr(changedelete), | ||||
) | ||||
) | ||||
|
r6003 | |||
|
r26608 | if tool in internals: | ||
func = internals[tool] | ||||
mergetype = func.mergetype | ||||
onfailure = func.onfailure | ||||
precheck = func.precheck | ||||
|
r35925 | isexternal = False | ||
|
r26608 | else: | ||
|
r35479 | if wctx.isinmemory(): | ||
func = _xmergeimm | ||||
else: | ||||
func = _xmerge | ||||
|
r26608 | mergetype = fullmerge | ||
|
r43347 | onfailure = _(b"merging %s failed!\n") | ||
|
r26608 | precheck = None | ||
|
r35925 | isexternal = True | ||
|
r26512 | |||
|
r38052 | toolconf = tool, toolpath, binary, symlink, scriptfn | ||
|
r6003 | |||
|
r49429 | if not labels: | ||
labels = [b'local', b'other'] | ||||
|
r49430 | if len(labels) < 3: | ||
labels.append(b'base') | ||||
|
r49431 | local = simplemerge.MergeInput(fcd, labels[0]) | ||
other = simplemerge.MergeInput(fco, labels[1]) | ||||
base = simplemerge.MergeInput(fca, labels[2]) | ||||
|
r26608 | if mergetype == nomerge: | ||
|
r49431 | return func( | ||
repo, | ||||
mynode, | ||||
|
r49432 | local, | ||
other, | ||||
base, | ||||
|
r49431 | toolconf, | ||
) | ||||
|
r26512 | |||
|
r49260 | if orig != fco.path(): | ||
ui.status( | ||||
_(b"merging %s and %s to %s\n") | ||||
% (uipathfn(orig), uipathfn(fco.path()), fduipath) | ||||
) | ||||
else: | ||||
ui.status(_(b"merging %s\n") % fduipath) | ||||
|
r26528 | |||
|
r43347 | ui.debug(b"my %s other %s ancestor %s\n" % (fcd, fco, fca)) | ||
|
r26528 | |||
|
r49336 | if precheck and not precheck(repo, mynode, fcd, fco, fca, toolconf): | ||
|
r26608 | if onfailure: | ||
|
r35283 | if wctx.isinmemory(): | ||
|
r43346 | raise error.InMemoryMergeConflictsError( | ||
|
r43387 | b'in-memory merge does not support merge conflicts' | ||
|
r43346 | ) | ||
|
r41651 | ui.warn(onfailure % fduipath) | ||
|
r49337 | return 1, False | ||
|
r26529 | |||
|
r49631 | backup = _makebackup(repo, ui, fcd) | ||
|
r26589 | r = 1 | ||
try: | ||||
|
r43347 | internalmarkerstyle = ui.config(b'ui', b'mergemarkers') | ||
|
r35925 | if isexternal: | ||
|
r43347 | markerstyle = _toolstr(ui, tool, b'mergemarkers') | ||
|
r35925 | else: | ||
markerstyle = internalmarkerstyle | ||||
|
r49260 | if mergetype == fullmerge: | ||
|
r35925 | # conflict markers generated by premerge will use 'detailed' | ||
# settings if either ui.mergemarkers or the tool's mergemarkers | ||||
# setting is 'detailed'. This way tools can have basic labels in | ||||
# space-constrained areas of the UI, but still get full information | ||||
# in conflict markers if premerge is 'keep' or 'keep-merge3'. | ||||
labeltool = None | ||||
|
r43347 | if markerstyle != b'basic': | ||
|
r35925 | # respect 'tool's mergemarkertemplate (which defaults to | ||
|
r46352 | # command-templates.mergemarker) | ||
|
r35925 | labeltool = tool | ||
|
r43347 | if internalmarkerstyle != b'basic' or markerstyle != b'basic': | ||
|
r49432 | _populate_label_details( | ||
repo, [local, other, base], tool=labeltool | ||||
) | ||||
|
r35925 | |||
|
r43346 | r = _premerge( | ||
|
r49431 | repo, | ||
|
r49432 | local, | ||
other, | ||||
base, | ||||
|
r49431 | toolconf, | ||
|
r43346 | ) | ||
|
r49260 | # we're done if premerge was successful (r is 0) | ||
if not r: | ||||
|
r49337 | return r, False | ||
|
r26567 | |||
|
r49431 | # Reset to basic labels | ||
|
r49433 | local.label_detail = None | ||
other.label_detail = None | ||||
base.label_detail = None | ||||
|
r49431 | |||
if markerstyle != b'basic': | ||||
|
r49432 | _populate_label_details(repo, [local, other, base], tool=tool) | ||
|
r49431 | |||
|
r43346 | needcheck, r, deleted = func( | ||
repo, | ||||
mynode, | ||||
|
r49432 | local, | ||
other, | ||||
base, | ||||
|
r43346 | toolconf, | ||
|
r49335 | backup, | ||
|
r43346 | ) | ||
|
r27033 | |||
|
r26575 | if needcheck: | ||
|
r49335 | r = _check(repo, r, ui, tool, fcd, backup) | ||
|
r21519 | |||
|
r16125 | if r: | ||
if onfailure: | ||||
|
r35283 | if wctx.isinmemory(): | ||
|
r43346 | raise error.InMemoryMergeConflictsError( | ||
|
r43347 | b'in-memory merge ' | ||
b'does not support ' | ||||
b'merge conflicts' | ||||
|
r43346 | ) | ||
|
r41651 | ui.warn(onfailure % fduipath) | ||
|
r34798 | _onfilemergefailure(ui) | ||
|
r26589 | |||
|
r49337 | return r, deleted | ||
|
r26589 | finally: | ||
|
r49334 | if not r and backup is not None: | ||
backup.remove() | ||||
|
r6004 | |||
|
r43346 | |||
|
r34797 | def _haltmerge(): | ||
|
r43347 | msg = _(b'merge halted after failed merge (see hg resolve)') | ||
|
r34797 | raise error.InterventionRequired(msg) | ||
|
r43346 | |||
|
r34797 | def _onfilemergefailure(ui): | ||
|
r43347 | action = ui.config(b'merge', b'on-failure') | ||
if action == b'prompt': | ||||
|
r43387 | msg = _(b'continue merge operation (yn)?$$ &Yes $$ &No') | ||
|
r34797 | if ui.promptchoice(msg, 0) == 1: | ||
_haltmerge() | ||||
|
r43347 | if action == b'halt': | ||
|
r34797 | _haltmerge() | ||
# default action is 'continue', in which case we neither prompt nor halt | ||||
|
r43346 | |||
|
r38829 | def hasconflictmarkers(data): | ||
|
r48753 | # Detect lines starting with a string of 7 identical characters from the | ||
# subset Mercurial uses for conflict markers, followed by either the end of | ||||
# line or a space and some text. Note that using [<>=+|-]{7} would detect | ||||
# `<><><><><` as a conflict marker, which we don't want. | ||||
|
r43346 | return bool( | ||
|
r47065 | re.search( | ||
|
r48753 | br"^([<>=+|-])\1{6}( .*)$", | ||
|
r47065 | data, | ||
re.MULTILINE, | ||||
) | ||||
|
r43346 | ) | ||
|
r38829 | |||
|
r49335 | def _check(repo, r, ui, tool, fcd, backup): | ||
|
r26575 | fd = fcd.path() | ||
|
r41651 | uipathfn = scmutil.getuipathfn(repo) | ||
|
r26575 | |||
|
r43346 | if not r and ( | ||
|
r43347 | _toolbool(ui, tool, b"checkconflicts") | ||
or b'conflicts' in _toollist(ui, tool, b"check") | ||||
|
r43346 | ): | ||
|
r38829 | if hasconflictmarkers(fcd.data()): | ||
|
r26575 | r = 1 | ||
checked = False | ||||
|
r43347 | if b'prompt' in _toollist(ui, tool, b"check"): | ||
|
r26575 | checked = True | ||
|
r43346 | if ui.promptchoice( | ||
|
r43387 | _(b"was merge of '%s' successful (yn)?$$ &Yes $$ &No") | ||
|
r43346 | % uipathfn(fd), | ||
1, | ||||
): | ||||
|
r26575 | r = 1 | ||
|
r43346 | if ( | ||
not r | ||||
and not checked | ||||
and ( | ||||
|
r43347 | _toolbool(ui, tool, b"checkchanged") | ||
or b'changed' in _toollist(ui, tool, b"check") | ||||
|
r43346 | ) | ||
): | ||||
|
r49334 | if backup is not None and not fcd.cmp(backup): | ||
|
r43346 | if ui.promptchoice( | ||
_( | ||||
|
r43347 | b" output file %s appears unchanged\n" | ||
b"was merge successful (yn)?" | ||||
b"$$ &Yes $$ &No" | ||||
|
r43346 | ) | ||
% uipathfn(fd), | ||||
1, | ||||
): | ||||
|
r26575 | r = 1 | ||
|
r49334 | if backup is not None and _toolbool(ui, tool, b"fixeol"): | ||
_matcheol(_workingpath(repo, fcd), backup) | ||||
|
r26575 | |||
return r | ||||
|
r43346 | |||
|
r34036 | def _workingpath(repo, ctx): | ||
return repo.wjoin(ctx.path()) | ||||
|
r43346 | |||
|
r33663 | def loadinternalmerge(ui, extname, registrarobj): | ||
|
r46554 | """Load internal merge tool from specified registrarobj""" | ||
|
r43376 | for name, func in pycompat.iteritems(registrarobj._table): | ||
|
r43347 | fullname = b':' + name | ||
|
r33663 | internals[fullname] = func | ||
|
r43347 | internals[b'internal:' + name] = func | ||
|
r33663 | internalsdoc[fullname] = func | ||
|
r39162 | capabilities = sorted([k for k, v in func.capabilities.items() if v]) | ||
if capabilities: | ||||
|
r43347 | capdesc = b" (actual capabilities: %s)" % b', '.join( | ||
capabilities | ||||
) | ||||
func.__doc__ = func.__doc__ + pycompat.sysstr(b"\n\n%s" % capdesc) | ||||
|
r39303 | |||
# to put i18n comments into hg.pot for automatically generated texts | ||||
|
r39395 | # i18n: "binary" and "symlink" are keywords | ||
|
r39303 | # i18n: this text is added automatically | ||
|
r43347 | _(b" (actual capabilities: binary, symlink)") | ||
|
r39303 | # i18n: "binary" is keyword | ||
# i18n: this text is added automatically | ||||
|
r43347 | _(b" (actual capabilities: binary)") | ||
|
r39303 | # i18n: "symlink" is keyword | ||
# i18n: this text is added automatically | ||||
|
r43347 | _(b" (actual capabilities: symlink)") | ||
|
r39162 | |||
|
r43346 | |||
|
r33663 | # load built-in merge tools explicitly to setup internalsdoc | ||
loadinternalmerge(None, None, internaltool) | ||||
|
r16126 | # tell hggettext to extract docstrings from these functions: | ||
i18nfunctions = internals.values() | ||||