# filemerge.py - file-level merge handling for Mercurial
#
# Copyright 2006, 2007, 2008 Matt Mackall <mpm@selenic.com>
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.
from node import short
from i18n import _
import util, simplemerge, match, error
import os, tempfile, re, filecmp
def _toolstr(ui, tool, part, default=""):
return ui.config("merge-tools", tool + "." + part, default)
def _toolbool(ui, tool, part, default=False):
return ui.configbool("merge-tools", tool + "." + part, default)
def _toollist(ui, tool, part, default=[]):
return ui.configlist("merge-tools", tool + "." + part, default)
internals = {}
def internaltool(name, trymerge, onfailure=None):
'''return a decorator for populating internal merge tool table'''
def decorator(func):
fullname = 'internal:' + name
func.__doc__ = "``%s``\n" % fullname + func.__doc__.strip()
internals[fullname] = func
func.trymerge = trymerge
func.onfailure = onfailure
return func
return decorator
def _findtool(ui, tool):
if tool in internals:
return tool
for kn in ("regkey", "regkeyalt"):
k = _toolstr(ui, tool, kn)
if not k:
continue
p = util.lookupreg(k, _toolstr(ui, tool, "regname"))
if p:
p = util.findexe(p + _toolstr(ui, tool, "regappend"))
if p:
return p
exe = _toolstr(ui, tool, "executable", tool)
return util.findexe(util.expandpath(exe))
def _picktool(repo, ui, path, binary, symlink):
def check(tool, pat, symlink, binary):
tmsg = tool
if pat:
tmsg += " specified for " + pat
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)
elif symlink and not _toolbool(ui, tool, "symlink"):
ui.warn(_("tool %s can't handle symlinks\n") % tmsg)
elif binary and not _toolbool(ui, tool, "binary"):
ui.warn(_("tool %s can't handle binary\n") % tmsg)
elif not util.gui() and _toolbool(ui, tool, "gui"):
ui.warn(_("tool %s requires a GUI\n") % tmsg)
else:
return True
return False
# forcemerge comes from command line arguments, highest priority
force = ui.config('ui', 'forcemerge')
if force:
toolpath = _findtool(ui, force)
if toolpath:
return (force, util.shellquote(toolpath))
else:
# mimic HGMERGE if given tool not found
return (force, force)
# HGMERGE takes next precedence
hgmerge = os.environ.get("HGMERGE")
if hgmerge:
return (hgmerge, hgmerge)
# then patterns
for pat, tool in ui.configitems("merge-patterns"):
mf = match.match(repo.root, '', [pat])
if mf(path) and check(tool, pat, symlink, False):
toolpath = _findtool(ui, tool)
return (tool, util.shellquote(toolpath))
# then merge tools
tools = {}
for k, v in ui.configitems("merge-tools"):
t = k.split('.')[0]
if t not in tools:
tools[t] = int(_toolstr(ui, t, "priority", "0"))
names = tools.keys()
tools = sorted([(-p, t) for t, p in tools.items()])
uimerge = ui.config("ui", "merge")
if uimerge:
if uimerge not in names:
return (uimerge, uimerge)
tools.insert(0, (None, uimerge)) # highest priority
tools.append((None, "hgmerge")) # the old default, if found
for p, t in tools:
if check(t, None, symlink, binary):
toolpath = _findtool(ui, t)
return (t, util.shellquote(toolpath))
# internal merge or prompt as last resort
if symlink or binary:
return "internal:prompt", None
return "internal:merge", None
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
def _matcheol(file, origfile):
"Convert EOL markers in a file to match origfile"
tostyle = _eoltype(util.readfile(origfile))
if tostyle:
data = util.readfile(file)
style = _eoltype(data)
if style:
newdata = data.replace(style, tostyle)
if newdata != data:
util.writefile(file, newdata)
@internaltool('prompt', False)
def _iprompt(repo, mynode, orig, fcd, fco, fca, toolconf):
"""Asks the user which of the local or the other version to keep as
the merged version."""
ui = repo.ui
fd = fcd.path()
if ui.promptchoice(_(" no tool found to merge %s\n"
"keep (l)ocal or take (o)ther?"
"$$ &Local $$ &Other") % fd, 0):
return _iother(repo, mynode, orig, fcd, fco, fca, toolconf)
else:
return _ilocal(repo, mynode, orig, fcd, fco, fca, toolconf)
@internaltool('local', False)
def _ilocal(repo, mynode, orig, fcd, fco, fca, toolconf):
"""Uses the local version of files as the merged version."""
return 0
@internaltool('other', False)
def _iother(repo, mynode, orig, fcd, fco, fca, toolconf):
"""Uses the other version of files as the merged version."""
repo.wwrite(fcd.path(), fco.data(), fco.flags())
return 0
@internaltool('fail', False)
def _ifail(repo, mynode, orig, fcd, fco, fca, 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."""
return 1
def _premerge(repo, toolconf, files):
tool, toolpath, binary, symlink = toolconf
if symlink:
return 1
a, b, c, back = files
ui = repo.ui
# do we attempt to simplemerge first?
try:
premerge = _toolbool(ui, tool, "premerge", not binary)
except error.ConfigError:
premerge = _toolstr(ui, tool, "premerge").lower()
valid = 'keep'.split()
if premerge not in valid:
_valid = ', '.join(["'" + v + "'" for v in valid])
raise error.ConfigError(_("%s.premerge not valid "
"('%s' is neither boolean nor %s)") %
(tool, premerge, _valid))
if premerge:
r = simplemerge.simplemerge(ui, a, b, c, quiet=True)
if not r:
ui.debug(" premerge successful\n")
return 0
if premerge != 'keep':
util.copyfile(back, a) # restore from backup and try again
return 1 # continue merging
@internaltool('merge', True,
_("merging %s incomplete! "
"(edit conflicts, then use 'hg resolve --mark')\n"))
def _imerge(repo, mynode, orig, fcd, fco, fca, toolconf, files):
"""
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."""
tool, toolpath, binary, symlink = toolconf
if symlink:
repo.ui.warn(_('warning: internal:merge cannot merge symlinks '
'for %s\n') % fcd.path())
return False, 1
r = _premerge(repo, toolconf, files)
if r:
a, b, c, back = files
ui = repo.ui
r = simplemerge.simplemerge(ui, a, b, c, label=['local', 'other'])
return True, r
return False, 0
@internaltool('dump', True)
def _idump(repo, mynode, orig, fcd, fco, fca, toolconf, files):
"""
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
same directory as ``a.txt``."""
r = _premerge(repo, toolconf, files)
if r:
a, b, c, back = files
fd = fcd.path()
util.copyfile(a, a + ".local")
repo.wwrite(fd + ".other", fco.data(), fco.flags())
repo.wwrite(fd + ".base", fca.data(), fca.flags())
return False, r
def _xmerge(repo, mynode, orig, fcd, fco, fca, toolconf, files):
r = _premerge(repo, toolconf, files)
if r:
tool, toolpath, binary, symlink = toolconf
a, b, c, back = files
out = ""
env = dict(HG_FILE=fcd.path(),
HG_MY_NODE=short(mynode),
HG_OTHER_NODE=str(fco.changectx()),
HG_BASE_NODE=str(fca.changectx()),
HG_MY_ISLINK='l' in fcd.flags(),
HG_OTHER_ISLINK='l' in fco.flags(),
HG_BASE_ISLINK='l' in fca.flags())
ui = repo.ui
args = _toolstr(ui, tool, "args", '$local $base $other')
if "$output" in args:
out, a = a, back # read input from backup, write to original
replace = dict(local=a, base=b, other=c, output=out)
args = util.interpolate(r'\$', replace, args,
lambda s: util.shellquote(util.localpath(s)))
r = util.system(toolpath + ' ' + args, cwd=repo.root, environ=env,
out=ui.fout)
return True, r
return False, 0
def filemerge(repo, mynode, orig, fcd, fco, fca):
"""perform a 3-way merge in the working directory
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
"""
def temp(prefix, ctx):
pre = "%s~%s." % (os.path.basename(ctx.path()), prefix)
(fd, name) = tempfile.mkstemp(prefix=pre)
data = repo.wwritedata(ctx.path(), ctx.data())
f = os.fdopen(fd, "wb")
f.write(data)
f.close()
return name
if not fco.cmp(fcd): # files identical?
return None
ui = repo.ui
fd = fcd.path()
binary = fcd.isbinary() or fco.isbinary() or fca.isbinary()
symlink = 'l' in fcd.flags() + fco.flags()
tool, toolpath = _picktool(repo, ui, fd, binary, symlink)
ui.debug("picked tool '%s' for %s (binary %s symlink %s)\n" %
(tool, fd, binary, symlink))
if tool in internals:
func = internals[tool]
trymerge = func.trymerge
onfailure = func.onfailure
else:
func = _xmerge
trymerge = True
onfailure = _("merging %s failed!\n")
toolconf = tool, toolpath, binary, symlink
if not trymerge:
return func(repo, mynode, orig, fcd, fco, fca, toolconf)
a = repo.wjoin(fd)
b = temp("base", fca)
c = temp("other", fco)
back = a + ".orig"
util.copyfile(a, back)
if orig != fco.path():
ui.status(_("merging %s and %s to %s\n") % (orig, fco.path(), fd))
else:
ui.status(_("merging %s\n") % fd)
ui.debug("my %s other %s ancestor %s\n" % (fcd, fco, fca))
needcheck, r = func(repo, mynode, orig, fcd, fco, fca, toolconf,
(a, b, c, back))
if not needcheck:
if r:
if onfailure:
ui.warn(onfailure % fd)
else:
os.unlink(back)
os.unlink(b)
os.unlink(c)
return r
if not r and (_toolbool(ui, tool, "checkconflicts") or
'conflicts' in _toollist(ui, tool, "check")):
if re.search("^(<<<<<<< .*|=======|>>>>>>> .*)$", fcd.data(),
re.MULTILINE):
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")):
if filecmp.cmp(a, back):
if ui.promptchoice(_(" output file %s appears unchanged\n"
"was merge successful (yn)?"
"$$ &Yes $$ &No") % fd, 1):
r = 1
if _toolbool(ui, tool, "fixeol"):
_matcheol(a, back)
if r:
if onfailure:
ui.warn(onfailure % fd)
else:
os.unlink(back)
os.unlink(b)
os.unlink(c)
return r
# tell hggettext to extract docstrings from these functions:
i18nfunctions = internals.values()