filemerge.py
1059 lines
| 39.2 KiB
| text/x-python
|
PythonLexer
/ mercurial / filemerge.py
|
r6003 | # filemerge.py - file-level merge handling for Mercurial | ||
# | ||||
# Copyright 2006, 2007, 2008 Matt Mackall <mpm@selenic.com> | ||||
# | ||||
|
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, | ||||
nullid, | ||||
short, | ||||
) | ||||
|
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, | ||
|
r37102 | stringutil, | ||
) | ||||
|
r34827 | def _toolstr(ui, tool, part, *args): | ||
return ui.config("merge-tools", tool + "." + part, *args) | ||||
|
r6004 | |||
|
r34827 | def _toolbool(ui, tool, part,*args): | ||
return ui.configbool("merge-tools", tool + "." + part, *args) | ||||
|
r6004 | |||
|
r34827 | def _toollist(ui, tool, part): | ||
return ui.configlist("merge-tools", tool + "." + part) | ||||
|
r11148 | |||
|
r16126 | internals = {} | ||
|
r24099 | # Merge tools to document. | ||
internalsdoc = {} | ||||
|
r16125 | |||
|
r33663 | internaltool = registrar.internalmerge() | ||
|
r26525 | # internal tool merge types | ||
|
r33663 | nomerge = internaltool.nomerge | ||
mergeonly = internaltool.mergeonly # just the full merge, no premerge | ||||
fullmerge = internaltool.fullmerge # both premerge and merge | ||||
|
r26525 | |||
|
r32318 | _localchangedotherdeletedmsg = _( | ||
|
r39321 | "file '%(fd)s' was deleted in other%(o)s but was modified in local%(l)s.\n" | ||
|
r39313 | "What do you want to do?\n" | ||
|
r32318 | "use (c)hanged version, (d)elete, or leave (u)nresolved?" | ||
"$$ &Changed $$ &Delete $$ &Unresolved") | ||||
_otherchangedlocaldeletedmsg = _( | ||||
|
r39321 | "file '%(fd)s' was deleted in local%(l)s but was modified in other%(o)s.\n" | ||
|
r39313 | "What do you want to do?\n" | ||
|
r32318 | "use (c)hanged version, leave (d)eleted, or " | ||
"leave (u)nresolved?" | ||||
"$$ &Changed $$ &Deleted $$ &Unresolved") | ||||
|
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.""" | ||||
def __init__(self, ctx, f): | ||||
self._ctx = ctx | ||||
self._f = f | ||||
def path(self): | ||||
return self._f | ||||
def size(self): | ||||
return None | ||||
def data(self): | ||||
return None | ||||
def filenode(self): | ||||
return nullid | ||||
_customcmp = True | ||||
def cmp(self, fctx): | ||||
"""compare with other file context | ||||
returns True if different from fctx. | ||||
""" | ||||
return not (fctx.isabsent() and | ||||
fctx.ctx() == self.ctx() and | ||||
fctx.path() == self.path()) | ||||
def flags(self): | ||||
return '' | ||||
def changectx(self): | ||||
return self._ctx | ||||
def isbinary(self): | ||||
return False | ||||
def isabsent(self): | ||||
return True | ||||
|
r6004 | def _findtool(ui, tool): | ||
|
r16126 | if tool in internals: | ||
|
r6522 | return tool | ||
|
r38052 | cmd = _toolstr(ui, tool, "executable", tool) | ||
if cmd.startswith('python:'): | ||||
return cmd | ||||
|
r23148 | return findexternaltool(ui, tool) | ||
|
r38052 | def _quotetoolpath(cmd): | ||
if cmd.startswith('python:'): | ||||
return cmd | ||||
return procutil.shellquote(cmd) | ||||
|
r23148 | def findexternaltool(ui, tool): | ||
|
r13565 | for kn in ("regkey", "regkeyalt"): | ||
k = _toolstr(ui, tool, kn) | ||||
if not k: | ||||
continue | ||||
|
r14230 | p = util.lookupreg(k, _toolstr(ui, tool, "regname")) | ||
|
r6006 | if p: | ||
|
r37138 | p = procutil.findexe(p + _toolstr(ui, tool, "regappend", "")) | ||
|
r6006 | if p: | ||
return p | ||||
|
r15264 | exe = _toolstr(ui, tool, "executable", tool) | ||
|
r37138 | return procutil.findexe(util.expandpath(exe)) | ||
|
r6004 | |||
|
r27039 | def _picktool(repo, ui, path, binary, symlink, changedelete): | ||
|
r39161 | strictcheck = ui.configbool('merge', 'strict-capability-check') | ||
|
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: | ||||
|
r32254 | tmsg = _("%s (for pattern %s)") % (tool, pat) | ||
|
r7397 | if not _findtool(ui, tool): | ||
if pat: # explicitly requested tool deserves a warning | ||||
ui.warn(_("couldn't find merge tool %s\n") % tmsg) | ||||
else: # configured but non-existing tools are more silent | ||||
ui.note(_("couldn't find merge tool %s\n") % tmsg) | ||||
|
r39161 | elif symlink and not hascapability(tool, "symlink", strictcheck): | ||
|
r6004 | ui.warn(_("tool %s can't handle symlinks\n") % tmsg) | ||
|
r39161 | elif binary and not hascapability(tool, "binary", strictcheck): | ||
|
r6004 | ui.warn(_("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 | ||||
|
r37138 | elif not procutil.gui() and _toolbool(ui, tool, "gui"): | ||
|
r6007 | ui.warn(_("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 | ||
force = ui.config('ui', 'forcemerge') | ||||
if force: | ||||
toolpath = _findtool(ui, force) | ||||
|
r27039 | if changedelete and not supportscd(toolpath): | ||
return ":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 | ||||
|
r30636 | hgmerge = encoding.environ.get("HGMERGE") | ||
|
r6025 | if hgmerge: | ||
|
r27039 | if changedelete and not supportscd(hgmerge): | ||
return ":prompt", None | ||||
else: | ||||
return (hgmerge, hgmerge) | ||||
|
r6004 | |||
# then patterns | ||||
|
r39161 | |||
# whether binary capability should be checked strictly | ||||
binarycap = binary and strictcheck | ||||
|
r6016 | for pat, tool in ui.configitems("merge-patterns"): | ||
|
r8567 | mf = match.match(repo.root, '', [pat]) | ||
|
r39161 | if mf(path) and check(tool, pat, symlink, binarycap, changedelete): | ||
|
r39160 | if binary and not hascapability(tool, "binary", strict=True): | ||
ui.warn(_("warning: check merge-patterns configurations," | ||||
" if %r for binary file %r is unintentional\n" | ||||
"(see 'hg help merge-tools'" | ||||
" for binary files capability)\n") | ||||
% (pycompat.bytestr(tool), pycompat.bytestr(path))) | ||||
|
r10339 | toolpath = _findtool(ui, tool) | ||
|
r38052 | return (tool, _quotetoolpath(toolpath)) | ||
|
r6004 | |||
# then merge tools | ||||
tools = {} | ||||
|
r26730 | disabled = set() | ||
|
r10282 | for k, v in ui.configitems("merge-tools"): | ||
|
r6004 | t = k.split('.')[0] | ||
if t not in tools: | ||||
|
r34827 | tools[t] = int(_toolstr(ui, t, "priority")) | ||
if _toolbool(ui, t, "disabled"): | ||||
|
r26730 | disabled.add(t) | ||
|
r6076 | names = tools.keys() | ||
|
r30388 | tools = sorted([(-p, tool) for tool, p in tools.items() | ||
if tool not in disabled]) | ||||
|
r6076 | uimerge = ui.config("ui", "merge") | ||
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) | ||||
tools.insert(0, (None, uimerge)) # highest priority | ||||
|
r6004 | tools.append((None, "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 | ||||
ui.warn(_("no tool found to merge %s\n") % path) | ||||
|
r22707 | return ":prompt", None | ||
return ":merge", None | ||||
|
r6003 | |||
|
r6005 | def _eoltype(data): | ||
"Guess the EOL type of a file" | ||||
if '\0' in data: # binary | ||||
return None | ||||
if '\r\n' in data: # Windows | ||||
return '\r\n' | ||||
if '\r' in data: # Old Mac | ||||
return '\r' | ||||
if '\n' in data: # UNIX | ||||
return '\n' | ||||
return None # unknown | ||||
|
r34783 | def _matcheol(file, back): | ||
|
r6005 | "Convert EOL markers in a file to match origfile" | ||
|
r34783 | tostyle = _eoltype(back.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 | |||
|
r26526 | @internaltool('prompt', nomerge) | ||
|
r29774 | def _iprompt(repo, mynode, orig, fcd, fco, fca, toolconf, labels=None): | ||
|
r28640 | """Asks the user which of the local `p1()` or the other `p2()` version to | ||
keep as the merged version.""" | ||||
|
r16125 | ui = repo.ui | ||
fd = fcd.path() | ||||
|
r35283 | # Avoid prompting during an in-memory merge since it doesn't support merge | ||
# conflicts. | ||||
if fcd.changectx().isinmemory(): | ||||
raise error.InMemoryMergeConflictsError('in-memory merge does not ' | ||||
'support file conflicts') | ||||
|
r29774 | prompts = partextras(labels) | ||
prompts['fd'] = fd | ||||
|
r26898 | try: | ||
|
r27038 | if fco.isabsent(): | ||
index = ui.promptchoice( | ||||
|
r32318 | _localchangedotherdeletedmsg % prompts, 2) | ||
|
r27163 | choice = ['local', 'other', 'unresolved'][index] | ||
|
r27038 | elif fcd.isabsent(): | ||
index = ui.promptchoice( | ||||
|
r32318 | _otherchangedlocaldeletedmsg % prompts, 2) | ||
|
r27163 | choice = ['other', 'local', 'unresolved'][index] | ||
|
r27038 | else: | ||
|
r27162 | index = ui.promptchoice( | ||
|
r32253 | _("keep (l)ocal%(l)s, take (o)ther%(o)s, or leave (u)nresolved" | ||
" for %(fd)s?" | ||||
|
r29774 | "$$ &Local $$ &Other $$ &Unresolved") % prompts, 2) | ||
|
r27162 | choice = ['local', 'other', 'unresolved'][index] | ||
|
r26851 | |||
|
r26898 | if choice == 'other': | ||
|
r29774 | return _iother(repo, mynode, orig, fcd, fco, fca, toolconf, | ||
labels) | ||||
|
r27162 | elif choice == 'local': | ||
|
r29774 | return _ilocal(repo, mynode, orig, fcd, fco, fca, toolconf, | ||
labels) | ||||
|
r27162 | elif choice == 'unresolved': | ||
|
r29774 | return _ifail(repo, mynode, orig, fcd, fco, fca, toolconf, | ||
labels) | ||||
|
r26898 | except error.ResponseExpected: | ||
ui.write("\n") | ||||
|
r29774 | return _ifail(repo, mynode, orig, fcd, fco, fca, toolconf, | ||
labels) | ||||
|
r16125 | |||
|
r26526 | @internaltool('local', nomerge) | ||
|
r29774 | def _ilocal(repo, mynode, orig, fcd, fco, fca, toolconf, labels=None): | ||
|
r28640 | """Uses the local `p1()` version of files as the merged version.""" | ||
|
r27036 | return 0, fcd.isabsent() | ||
|
r16125 | |||
|
r26526 | @internaltool('other', nomerge) | ||
|
r29774 | def _iother(repo, mynode, orig, fcd, fco, fca, toolconf, labels=None): | ||
|
r28640 | """Uses the other `p2()` version of files as the merged version.""" | ||
|
r27037 | if fco.isabsent(): | ||
# local changed, remote deleted -- 'deleted' picked | ||||
|
r33152 | _underlyingfctxifabsent(fcd).remove() | ||
|
r27037 | deleted = True | ||
else: | ||||
|
r33152 | _underlyingfctxifabsent(fcd).write(fco.data(), fco.flags()) | ||
|
r27037 | deleted = False | ||
return 0, deleted | ||||
|
r16125 | |||
|
r26526 | @internaltool('fail', nomerge) | ||
|
r29774 | def _ifail(repo, mynode, orig, fcd, fco, fca, toolconf, labels=None): | ||
|
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 | ||
if fcd.isabsent(): | ||||
|
r33152 | _underlyingfctxifabsent(fcd).write(fco.data(), fco.flags()) | ||
|
r27032 | return 1, False | ||
|
r16125 | |||
|
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 | ||||
|
r27041 | def _premerge(repo, fcd, fco, fca, toolconf, files, labels=None): | ||
|
r38052 | tool, toolpath, binary, symlink, scriptfn = toolconf | ||
|
r27041 | if symlink or fcd.isabsent() or fco.isabsent(): | ||
|
r18257 | return 1 | ||
|
r34034 | unused, unused, unused, back = files | ||
|
r16125 | |||
ui = repo.ui | ||||
|
r22032 | validkeep = ['keep', 'keep-merge3'] | ||
|
r22031 | |||
|
r16125 | # do we attempt to simplemerge first? | ||
try: | ||||
|
r18257 | premerge = _toolbool(ui, tool, "premerge", not binary) | ||
|
r16125 | except error.ConfigError: | ||
|
r34827 | premerge = _toolstr(ui, tool, "premerge", "").lower() | ||
|
r22031 | if premerge not in validkeep: | ||
_valid = ', '.join(["'" + v + "'" for v in validkeep]) | ||||
|
r16125 | raise error.ConfigError(_("%s.premerge not valid " | ||
"('%s' is neither boolean nor %s)") % | ||||
(tool, premerge, _valid)) | ||||
if premerge: | ||||
|
r22032 | if premerge == 'keep-merge3': | ||
if not labels: | ||||
labels = _defaultconflictlabels | ||||
if len(labels) < 3: | ||||
labels.append('base') | ||||
|
r34051 | r = simplemerge.simplemerge(ui, fcd, fca, fco, quiet=True, label=labels) | ||
|
r16125 | if not r: | ||
ui.debug(" premerge successful\n") | ||||
return 0 | ||||
|
r22031 | if premerge not in validkeep: | ||
|
r34034 | # restore from backup and try again | ||
|
r34038 | _restorebackup(fcd, back) | ||
|
r16125 | return 1 # continue merging | ||
|
r26948 | def _mergecheck(repo, mynode, orig, fcd, fco, fca, toolconf): | ||
|
r38052 | tool, toolpath, binary, symlink, scriptfn = toolconf | ||
|
r26515 | if symlink: | ||
|
r26518 | repo.ui.warn(_('warning: internal %s cannot merge symlinks ' | ||
'for %s\n') % (tool, fcd.path())) | ||||
|
r26515 | return False | ||
|
r27040 | if fcd.isabsent() or fco.isabsent(): | ||
repo.ui.warn(_('warning: internal %s cannot merge change/delete ' | ||||
'conflict for %s\n') % (tool, fcd.path())) | ||||
return False | ||||
|
r26515 | return True | ||
|
r26070 | def _merge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels, 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 | |||
|
r34051 | r = simplemerge.simplemerge(ui, fcd, fca, fco, label=labels, mode=mode) | ||
|
r27033 | return True, r, False | ||
|
r16125 | |||
|
r26526 | @internaltool('union', fullmerge, | ||
|
r26614 | _("warning: conflicts while merging %s! " | ||
"(edit, then use 'hg resolve --mark')\n"), | ||||
|
r26948 | precheck=_mergecheck) | ||
|
r26071 | def _iunion(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None): | ||
""" | ||||
Uses the internal non-interactive simple merge algorithm for merging | ||||
files. It will use both left and right sides for conflict regions. | ||||
No markers are inserted.""" | ||||
return _merge(repo, mynode, orig, fcd, fco, fca, toolconf, | ||||
files, labels, 'union') | ||||
|
r26526 | @internaltool('merge', fullmerge, | ||
|
r26614 | _("warning: conflicts while merging %s! " | ||
"(edit, then use 'hg resolve --mark')\n"), | ||||
|
r26948 | precheck=_mergecheck) | ||
|
r26070 | def _imerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None): | ||
""" | ||||
Uses the internal non-interactive simple merge algorithm for merging | ||||
files. It will fail if there are any conflicts and leave markers in | ||||
the partially merged file. Markers will have two sections, one for each side | ||||
of merge.""" | ||||
return _merge(repo, mynode, orig, fcd, fco, fca, toolconf, | ||||
files, labels, 'merge') | ||||
|
r26526 | @internaltool('merge3', fullmerge, | ||
|
r26614 | _("warning: conflicts while merging %s! " | ||
"(edit, then use 'hg resolve --mark')\n"), | ||||
|
r26948 | precheck=_mergecheck) | ||
|
r22028 | def _imerge3(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None): | ||
""" | ||||
Uses the internal non-interactive simple merge algorithm for merging | ||||
files. It will fail if there are any conflicts and leave markers in | ||||
the partially merged file. Marker will have three sections, one from each | ||||
side of the merge and one for the base content.""" | ||||
if not labels: | ||||
labels = _defaultconflictlabels | ||||
if len(labels) < 3: | ||||
labels.append('base') | ||||
return _imerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels) | ||||
|
r26224 | def _imergeauto(repo, mynode, orig, fcd, fco, fca, toolconf, files, | ||
labels=None, localorother=None): | ||||
""" | ||||
Generic driver for _imergelocal and _imergeother | ||||
""" | ||||
assert localorother is not None | ||||
|
r38052 | tool, toolpath, binary, symlink, scriptfn = toolconf | ||
|
r34051 | r = simplemerge.simplemerge(repo.ui, fcd, fca, fco, label=labels, | ||
localorother=localorother) | ||||
|
r26224 | return True, r | ||
|
r26948 | @internaltool('merge-local', mergeonly, precheck=_mergecheck) | ||
|
r26224 | def _imergelocal(*args, **kwargs): | ||
""" | ||||
Like :merge, but resolve all conflicts non-interactively in favor | ||||
|
r28640 | of the local `p1()` changes.""" | ||
|
r26224 | success, status = _imergeauto(localorother='local', *args, **kwargs) | ||
|
r27033 | return success, status, False | ||
|
r26224 | |||
|
r26948 | @internaltool('merge-other', mergeonly, precheck=_mergecheck) | ||
|
r26224 | def _imergeother(*args, **kwargs): | ||
""" | ||||
Like :merge, but resolve all conflicts non-interactively in favor | ||||
|
r28640 | of the other `p2()` changes.""" | ||
|
r26224 | success, status = _imergeauto(localorother='other', *args, **kwargs) | ||
|
r27033 | return success, status, False | ||
|
r26224 | |||
|
r26526 | @internaltool('tagmerge', mergeonly, | ||
|
r21922 | _("automatic tag merging of %s failed! " | ||
|
r22707 | "(use 'hg resolve --tool :merge' or another merge " | ||
|
r21922 | "tool of your choice)\n")) | ||
def _itagmerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None): | ||||
""" | ||||
Uses the internal tag merge algorithm (experimental). | ||||
""" | ||||
|
r27033 | success, status = tagmerge.merge(repo, fcd, fco, fca) | ||
return success, status, False | ||||
|
r21922 | |||
|
r39158 | @internaltool('dump', fullmerge, binary=True, symlink=True) | ||
|
r21273 | def _idump(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None): | ||
|
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. | ||
""" | ||||
|
r34036 | a = _workingpath(repo, fcd) | ||
|
r26573 | fd = fcd.path() | ||
|
r16125 | |||
|
r34786 | from . import context | ||
if isinstance(fcd, context.overlayworkingfilectx): | ||||
|
r35283 | raise error.InMemoryMergeConflictsError('in-memory merge does not ' | ||
'support the :dump tool.') | ||||
|
r34786 | |||
|
r34078 | util.writefile(a + ".local", fcd.decodeddata()) | ||
|
r26573 | repo.wwrite(fd + ".other", fco.data(), fco.flags()) | ||
repo.wwrite(fd + ".base", fca.data(), fca.flags()) | ||||
|
r27033 | return False, 1, False | ||
|
r16125 | |||
|
r39158 | @internaltool('forcedump', mergeonly, binary=True, symlink=True) | ||
|
r32255 | def _forcedump(repo, mynode, orig, fcd, fco, fca, toolconf, files, | ||
labels=None): | ||||
""" | ||||
Creates three versions of the files as same as :dump, but omits premerge. | ||||
""" | ||||
return _idump(repo, mynode, orig, fcd, fco, fca, toolconf, files, | ||||
labels=labels) | ||||
|
r35479 | def _xmergeimm(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None): | ||
# In-memory merge simply raises an exception on all external merge tools, | ||||
# for now. | ||||
# | ||||
# It would be possible to run most tools with temporary files, but this | ||||
# raises the question of what to do if the user only partially resolves the | ||||
# 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.) | ||||
raise error.InMemoryMergeConflictsError('in-memory merge does not support ' | ||||
'external merge tools') | ||||
|
r40512 | def _describemerge(ui, repo, mynode, fcl, fcb, fco, env, toolpath, args): | ||
tmpl = ui.config('ui', 'pre-merge-tool-output-template') | ||||
if not tmpl: | ||||
return | ||||
mappingdict = templateutil.mappingdict | ||||
props = {'ctx': fcl.changectx(), | ||||
'node': hex(mynode), | ||||
'path': fcl.path(), | ||||
'local': mappingdict({'ctx': fcl.changectx(), | ||||
'fctx': fcl, | ||||
'node': hex(mynode), | ||||
'name': _('local'), | ||||
'islink': 'l' in fcl.flags(), | ||||
'label': env['HG_MY_LABEL']}), | ||||
'base': mappingdict({'ctx': fcb.changectx(), | ||||
'fctx': fcb, | ||||
'name': _('base'), | ||||
'islink': 'l' in fcb.flags(), | ||||
'label': env['HG_BASE_LABEL']}), | ||||
'other': mappingdict({'ctx': fco.changectx(), | ||||
'fctx': fco, | ||||
'name': _('other'), | ||||
'islink': 'l' in fco.flags(), | ||||
'label': env['HG_OTHER_LABEL']}), | ||||
'toolpath': toolpath, | ||||
'toolargs': args} | ||||
# 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) | ||||
t = formatter.maketemplater(ui, tmpl, defaults=templatekw.keywords, | ||||
resources=tres) | ||||
ui.status(t.renderdefault(props)) | ||||
|
r21273 | def _xmerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None): | ||
|
r38052 | tool, toolpath, binary, symlink, scriptfn = toolconf | ||
|
r27042 | if fcd.isabsent() or fco.isabsent(): | ||
repo.ui.warn(_('warning: %s cannot merge change/delete conflict ' | ||||
'for %s\n') % (tool, fcd.path())) | ||||
return False, 1, None | ||||
|
r34037 | unused, unused, unused, back = files | ||
|
r36994 | localpath = _workingpath(repo, fcd) | ||
|
r37095 | args = _toolstr(repo.ui, tool, "args") | ||
with _maketempfiles(repo, fco, fca, repo.wvfs.join(back.path()), | ||||
"$output" in args) as temppaths: | ||||
basepath, otherpath, localoutputpath = temppaths | ||||
|
r36994 | outpath = "" | ||
|
r35925 | mylabel, otherlabel = labels[:2] | ||
if len(labels) >= 3: | ||||
baselabel = labels[2] | ||||
else: | ||||
baselabel = 'base' | ||||
|
r34037 | env = {'HG_FILE': fcd.path(), | ||
'HG_MY_NODE': short(mynode), | ||||
|
r36442 | 'HG_OTHER_NODE': short(fco.changectx().node()), | ||
'HG_BASE_NODE': short(fca.changectx().node()), | ||||
|
r34037 | 'HG_MY_ISLINK': 'l' in fcd.flags(), | ||
'HG_OTHER_ISLINK': 'l' in fco.flags(), | ||||
'HG_BASE_ISLINK': 'l' in fca.flags(), | ||||
|
r35925 | 'HG_MY_LABEL': mylabel, | ||
'HG_OTHER_LABEL': otherlabel, | ||||
'HG_BASE_LABEL': baselabel, | ||||
|
r34037 | } | ||
ui = repo.ui | ||||
|
r16125 | |||
|
r34037 | if "$output" in args: | ||
|
r34783 | # read input from backup, write to original | ||
|
r36994 | outpath = localpath | ||
|
r37095 | localpath = localoutputpath | ||
|
r36994 | replace = {'local': localpath, 'base': basepath, 'other': otherpath, | ||
'output': outpath, 'labellocal': mylabel, | ||||
'labelother': otherlabel, 'labelbase': baselabel} | ||||
|
r37138 | args = util.interpolate( | ||
br'\$', replace, args, | ||||
lambda s: procutil.shellquote(util.localpath(s))) | ||||
|
r34037 | if _toolbool(ui, tool, "gui"): | ||
repo.ui.status(_('running merge tool %s for file %s\n') % | ||||
(tool, fcd.path())) | ||||
|
r38052 | if scriptfn is None: | ||
cmd = toolpath + ' ' + args | ||||
repo.ui.debug('launching merge tool: %s\n' % cmd) | ||||
|
r40512 | _describemerge(ui, repo, mynode, fcd, fca, fco, env, toolpath, args) | ||
|
r38052 | r = ui.system(cmd, cwd=repo.root, environ=env, | ||
blockedtag='mergetool') | ||||
else: | ||||
repo.ui.debug('launching python merge script: %s:%s\n' % | ||||
(toolpath, scriptfn)) | ||||
r = 0 | ||||
try: | ||||
# avoid cycle cmdutil->merge->filemerge->extensions->cmdutil | ||||
from . import extensions | ||||
|
r38176 | mod = extensions.loadpath(toolpath, 'hgmerge.%s' % tool) | ||
|
r38052 | except Exception: | ||
raise error.Abort(_("loading python merge script failed: %s") % | ||||
toolpath) | ||||
mergefn = getattr(mod, scriptfn, None) | ||||
if mergefn is None: | ||||
raise error.Abort(_("%s does not have function: %s") % | ||||
(toolpath, scriptfn)) | ||||
argslist = procutil.shellsplit(args) | ||||
# avoid cycle cmdutil->merge->filemerge->hook->extensions->cmdutil | ||||
from . import hook | ||||
ret, raised = hook.pythonhook(ui, repo, "merge", toolpath, | ||||
mergefn, {'args': argslist}, True) | ||||
if raised: | ||||
r = 1 | ||||
|
r34507 | repo.ui.debug('merge tool returned: %d\n' % r) | ||
|
r34037 | return True, r, False | ||
|
r16125 | |||
|
r35498 | def _formatconflictmarker(ctx, template, label, pad): | ||
|
r21519 | """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. | ||||
""" | ||||
if ctx.node() is None: | ||||
ctx = ctx.p1() | ||||
|
r35499 | props = {'ctx': ctx} | ||
|
r37003 | templateresult = template.renderdefault(props) | ||
|
r21519 | |||
label = ('%s:' % label).ljust(pad + 1) | ||||
|
r32873 | mark = '%s %s' % (label, templateresult) | ||
|
r21519 | |||
|
r21864 | if mark: | ||
mark = mark.splitlines()[0] # split for safety | ||||
|
r21865 | # 8 for the prefix of conflict marker lines (e.g. '<<<<<<< ') | ||
|
r37102 | return stringutil.ellipsis(mark, 80 - 8) | ||
|
r21519 | |||
|
r21524 | _defaultconflictlabels = ['local', 'other'] | ||
|
r35925 | def _formatlabels(repo, fcd, fco, fca, labels, tool=None): | ||
|
r21519 | """Formats the given labels using the conflict marker template. | ||
Returns a list of formatted labels. | ||||
""" | ||||
cd = fcd.changectx() | ||||
co = fco.changectx() | ||||
|
r22026 | ca = fca.changectx() | ||
|
r21519 | |||
ui = repo.ui | ||||
|
r33523 | template = ui.config('ui', 'mergemarkertemplate') | ||
|
r35925 | if tool is not None: | ||
template = _toolstr(ui, tool, 'mergemarkertemplate', template) | ||||
|
r32047 | template = templater.unquotestring(template) | ||
|
r35485 | tres = formatter.templateresources(ui, repo) | ||
|
r35499 | tmpl = formatter.maketemplater(ui, template, defaults=templatekw.keywords, | ||
resources=tres) | ||||
|
r21519 | |||
|
r22026 | pad = max(len(l) for l in labels) | ||
|
r21519 | |||
|
r35498 | newlabels = [_formatconflictmarker(cd, tmpl, labels[0], pad), | ||
_formatconflictmarker(co, tmpl, labels[1], pad)] | ||||
|
r22026 | if len(labels) > 2: | ||
|
r35498 | newlabels.append(_formatconflictmarker(ca, tmpl, labels[2], pad)) | ||
|
r22026 | return newlabels | ||
|
r21519 | |||
|
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 { | ||||
"l": "", | ||||
"o": "", | ||||
} | ||||
return { | ||||
"l": " [%s]" % labels[0], | ||||
"o": " [%s]" % labels[1], | ||||
} | ||||
|
r34038 | def _restorebackup(fcd, back): | ||
# TODO: Add a workingfilectx.write(otherfilectx) path so we can use | ||||
# util.copy here instead. | ||||
|
r34783 | fcd.write(back.data(), fcd.flags()) | ||
|
r34038 | |||
|
r34783 | def _makebackup(repo, ui, wctx, fcd, premerge): | ||
"""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 | |||
Backups only need to be written once (right before the premerge) 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 | ||||
|
r34036 | a = _workingpath(repo, fcd) | ||
|
r34033 | back = scmutil.origpath(ui, repo, a) | ||
|
r34785 | inworkingdir = (back.startswith(repo.wvfs.base) and not | ||
back.startswith(repo.vfs.base)) | ||||
if isinstance(fcd, context.overlayworkingfilectx) and inworkingdir: | ||||
# If the backup file is to be in the working directory, and we're | ||||
# merging in-memory, we must redirect the backup to the memory context | ||||
# so we don't disturb the working directory. | ||||
relpath = back[len(repo.wvfs.base) + 1:] | ||||
|
r35721 | if premerge: | ||
wctx[relpath].write(fcd.data(), fcd.flags()) | ||||
|
r34785 | return wctx[relpath] | ||
else: | ||||
|
r35720 | if premerge: | ||
# Otherwise, write to wherever path the user specified the backups | ||||
# should go. We still need to switch based on whether the source is | ||||
# in-memory so we can use the fast path of ``util.copy`` if both are | ||||
# on disk. | ||||
if isinstance(fcd, context.overlayworkingfilectx): | ||||
util.writefile(back, fcd.data()) | ||||
else: | ||||
util.copyfile(a, back) | ||||
|
r34785 | # A arbitraryfilectx is returned, so we can run the same functions on | ||
# the backup context regardless of where it lives. | ||||
return context.arbitraryfilectx(back, repo=repo) | ||||
|
r34033 | |||
|
r37016 | @contextlib.contextmanager | ||
|
r37095 | def _maketempfiles(repo, fco, fca, localpath, uselocalpath): | ||
"""Writes out `fco` and `fca` as temporary files, and (if uselocalpath) | ||||
copies `localpath` to another temporary file, so an external merge tool may | ||||
use them. | ||||
|
r34033 | """ | ||
|
r37017 | tmproot = None | ||
tmprootprefix = repo.ui.config('experimental', 'mergetempdirprefix') | ||||
if tmprootprefix: | ||||
|
r38183 | tmproot = pycompat.mkdtemp(prefix=tmprootprefix) | ||
|
r37017 | |||
|
r37095 | def maketempfrompath(prefix, path): | ||
fullbase, ext = os.path.splitext(path) | ||||
|
r37017 | pre = "%s~%s" % (os.path.basename(fullbase), prefix) | ||
if tmproot: | ||||
name = os.path.join(tmproot, pre) | ||||
if ext: | ||||
name += ext | ||||
f = open(name, r"wb") | ||||
else: | ||||
|
r38182 | fd, name = pycompat.mkstemp(prefix=pre + '.', suffix=ext) | ||
|
r37017 | f = os.fdopen(fd, r"wb") | ||
|
r37095 | return f, name | ||
def tempfromcontext(prefix, ctx): | ||||
f, name = maketempfrompath(prefix, ctx.path()) | ||||
|
r34033 | data = repo.wwritedata(ctx.path(), ctx.data()) | ||
f.write(data) | ||||
f.close() | ||||
return name | ||||
|
r37095 | b = tempfromcontext("base", fca) | ||
c = tempfromcontext("other", fco) | ||||
d = localpath | ||||
if uselocalpath: | ||||
# We start off with this being the backup filename, so remove the .orig | ||||
# to make syntax-highlighting more likely. | ||||
if d.endswith('.orig'): | ||||
d, _ = os.path.splitext(d) | ||||
f, d = maketempfrompath("local", d) | ||||
with open(localpath, 'rb') as src: | ||||
f.write(src.read()) | ||||
f.close() | ||||
|
r37016 | try: | ||
|
r37095 | yield b, c, d | ||
|
r37016 | finally: | ||
|
r37017 | if tmproot: | ||
shutil.rmtree(tmproot) | ||||
else: | ||||
util.unlink(b) | ||||
util.unlink(c) | ||||
|
r37095 | # if not uselocalpath, d is the 'orig'/backup file which we | ||
# shouldn't delete. | ||||
if d and uselocalpath: | ||||
util.unlink(d) | ||||
|
r34033 | |||
|
r34124 | def _filemerge(premerge, repo, wctx, mynode, orig, fcd, fco, fca, labels=None): | ||
|
r6003 | """perform a 3-way merge in the working directory | ||
|
r26607 | premerge = whether this is a premerge | ||
|
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.""" | ||||
|
r6003 | |||
|
r26608 | if not fco.cmp(fcd): # files identical? | ||
|
r27034 | return True, None, False | ||
|
r26512 | |||
|
r26608 | ui = repo.ui | ||
fd = fcd.path() | ||||
binary = fcd.isbinary() or fco.isbinary() or fca.isbinary() | ||||
symlink = '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 | ||
|
r26608 | if tool in internals and tool.startswith('internal:'): | ||
# normalize to new-style names (':merge' etc) | ||||
tool = tool[len('internal'):] | ||||
|
r38052 | if toolpath and toolpath.startswith('python:'): | ||
invalidsyntax = False | ||||
if toolpath.count(':') >= 2: | ||||
script, scriptfn = toolpath[7:].rsplit(':', 1) | ||||
if not scriptfn: | ||||
invalidsyntax = True | ||||
# missing :callable can lead to spliting on windows drive letter | ||||
if '\\' in scriptfn or '/' in scriptfn: | ||||
invalidsyntax = True | ||||
else: | ||||
invalidsyntax = True | ||||
if invalidsyntax: | ||||
raise error.Abort(_("invalid 'python:' syntax: %s") % toolpath) | ||||
toolpath = script | ||||
|
r27161 | ui.debug("picked tool '%s' for %s (binary %s symlink %s changedelete %s)\n" | ||
|
r32753 | % (tool, fd, 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 | ||
onfailure = _("merging %s failed!\n") | ||||
precheck = None | ||||
|
r35925 | isexternal = True | ||
|
r26512 | |||
|
r38052 | toolconf = tool, toolpath, binary, symlink, scriptfn | ||
|
r6003 | |||
|
r26608 | if mergetype == nomerge: | ||
|
r29774 | r, deleted = func(repo, mynode, orig, fcd, fco, fca, toolconf, labels) | ||
|
r27034 | return True, r, deleted | ||
|
r26512 | |||
|
r26609 | if premerge: | ||
if orig != fco.path(): | ||||
ui.status(_("merging %s and %s to %s\n") % (orig, fco.path(), fd)) | ||||
else: | ||||
ui.status(_("merging %s\n") % fd) | ||||
|
r26528 | |||
|
r26608 | ui.debug("my %s other %s ancestor %s\n" % (fcd, fco, fca)) | ||
|
r26528 | |||
|
r26608 | if precheck and not precheck(repo, mynode, orig, fcd, fco, fca, | ||
toolconf): | ||||
if onfailure: | ||||
|
r35283 | if wctx.isinmemory(): | ||
raise error.InMemoryMergeConflictsError('in-memory merge does ' | ||||
'not support merge ' | ||||
'conflicts') | ||||
|
r26608 | ui.warn(onfailure % fd) | ||
|
r27034 | return True, 1, False | ||
|
r26529 | |||
|
r34783 | back = _makebackup(repo, ui, wctx, fcd, premerge) | ||
|
r34037 | files = (None, None, None, back) | ||
|
r26589 | r = 1 | ||
try: | ||||
|
r35925 | internalmarkerstyle = ui.config('ui', 'mergemarkers') | ||
if isexternal: | ||||
markerstyle = _toolstr(ui, tool, 'mergemarkers') | ||||
else: | ||||
markerstyle = internalmarkerstyle | ||||
|
r26529 | if not labels: | ||
labels = _defaultconflictlabels | ||||
|
r35925 | formattedlabels = labels | ||
|
r26529 | if markerstyle != 'basic': | ||
|
r35925 | formattedlabels = _formatlabels(repo, fcd, fco, fca, labels, | ||
tool=tool) | ||||
|
r6004 | |||
|
r26607 | if premerge and 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'. | ||||
premergelabels = labels | ||||
labeltool = None | ||||
if markerstyle != 'basic': | ||||
# respect 'tool's mergemarkertemplate (which defaults to | ||||
# ui.mergemarkertemplate) | ||||
labeltool = tool | ||||
if internalmarkerstyle != 'basic' or markerstyle != 'basic': | ||||
premergelabels = _formatlabels(repo, fcd, fco, fca, | ||||
premergelabels, tool=labeltool) | ||||
r = _premerge(repo, fcd, fco, fca, toolconf, files, | ||||
labels=premergelabels) | ||||
|
r26611 | # complete if premerge successful (r is 0) | ||
|
r27034 | return not r, r, False | ||
|
r26567 | |||
|
r27033 | needcheck, r, deleted = func(repo, mynode, orig, fcd, fco, fca, | ||
|
r35925 | toolconf, files, labels=formattedlabels) | ||
|
r27033 | |||
|
r26575 | if needcheck: | ||
|
r34036 | r = _check(repo, r, ui, tool, fcd, files) | ||
|
r21519 | |||
|
r16125 | if r: | ||
if onfailure: | ||||
|
r35283 | if wctx.isinmemory(): | ||
raise error.InMemoryMergeConflictsError('in-memory merge ' | ||||
'does not support ' | ||||
'merge conflicts') | ||||
|
r16125 | ui.warn(onfailure % fd) | ||
|
r34798 | _onfilemergefailure(ui) | ||
|
r26589 | |||
|
r27034 | return True, r, deleted | ||
|
r26589 | finally: | ||
|
r27047 | if not r and back is not None: | ||
|
r34783 | back.remove() | ||
|
r6004 | |||
|
r34797 | def _haltmerge(): | ||
msg = _('merge halted after failed merge (see hg resolve)') | ||||
raise error.InterventionRequired(msg) | ||||
def _onfilemergefailure(ui): | ||||
action = ui.config('merge', 'on-failure') | ||||
if action == 'prompt': | ||||
msg = _('continue merge operation (yn)?' '$$ &Yes $$ &No') | ||||
if ui.promptchoice(msg, 0) == 1: | ||||
_haltmerge() | ||||
if action == 'halt': | ||||
_haltmerge() | ||||
# default action is 'continue', in which case we neither prompt nor halt | ||||
|
r38829 | def hasconflictmarkers(data): | ||
return bool(re.search("^(<<<<<<< .*|=======|>>>>>>> .*)$", data, | ||||
re.MULTILINE)) | ||||
|
r34036 | def _check(repo, r, ui, tool, fcd, files): | ||
|
r26575 | fd = fcd.path() | ||
|
r34036 | unused, unused, unused, back = files | ||
|
r26575 | |||
if not r and (_toolbool(ui, tool, "checkconflicts") or | ||||
'conflicts' in _toollist(ui, tool, "check")): | ||||
|
r38829 | if hasconflictmarkers(fcd.data()): | ||
|
r26575 | r = 1 | ||
checked = False | ||||
if 'prompt' in _toollist(ui, tool, "check"): | ||||
checked = True | ||||
if ui.promptchoice(_("was merge of '%s' successful (yn)?" | ||||
"$$ &Yes $$ &No") % fd, 1): | ||||
r = 1 | ||||
if not r and not checked and (_toolbool(ui, tool, "checkchanged") or | ||||
'changed' in | ||||
_toollist(ui, tool, "check")): | ||||
|
r34783 | if back is not None and not fcd.cmp(back): | ||
|
r26575 | if ui.promptchoice(_(" output file %s appears unchanged\n" | ||
"was merge successful (yn)?" | ||||
"$$ &Yes $$ &No") % fd, 1): | ||||
r = 1 | ||||
|
r27047 | if back is not None and _toolbool(ui, tool, "fixeol"): | ||
|
r34036 | _matcheol(_workingpath(repo, fcd), back) | ||
|
r26575 | |||
return r | ||||
|
r34036 | def _workingpath(repo, ctx): | ||
return repo.wjoin(ctx.path()) | ||||
|
r34124 | def premerge(repo, wctx, mynode, orig, fcd, fco, fca, labels=None): | ||
return _filemerge(True, repo, wctx, mynode, orig, fcd, fco, fca, | ||||
labels=labels) | ||||
|
r26607 | |||
|
r34124 | def filemerge(repo, wctx, mynode, orig, fcd, fco, fca, labels=None): | ||
return _filemerge(False, repo, wctx, mynode, orig, fcd, fco, fca, | ||||
labels=labels) | ||||
|
r26605 | |||
|
r33663 | def loadinternalmerge(ui, extname, registrarobj): | ||
"""Load internal merge tool from specified registrarobj | ||||
""" | ||||
for name, func in registrarobj._table.iteritems(): | ||||
fullname = ':' + name | ||||
internals[fullname] = func | ||||
internals['internal:' + name] = func | ||||
internalsdoc[fullname] = func | ||||
|
r39162 | capabilities = sorted([k for k, v in func.capabilities.items() if v]) | ||
if capabilities: | ||||
|
r39303 | capdesc = " (actual capabilities: %s)" % ', '.join(capabilities) | ||
|
r39162 | func.__doc__ = (func.__doc__ + | ||
|
r39303 | pycompat.sysstr("\n\n%s" % capdesc)) | ||
# 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 | ||
_(" (actual capabilities: binary, symlink)") | ||||
# i18n: "binary" is keyword | ||||
# i18n: this text is added automatically | ||||
_(" (actual capabilities: binary)") | ||||
# i18n: "symlink" is keyword | ||||
# i18n: this text is added automatically | ||||
_(" (actual capabilities: symlink)") | ||||
|
r39162 | |||
|
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() | ||||