##// END OF EJS Templates
filemerge: deindent the parts of filemerge outside the try block...
Siddharth Agarwal -
r26608:ae5b60d3 default
parent child Browse files
Show More
@@ -1,582 +1,581 b''
1 # filemerge.py - file-level merge handling for Mercurial
1 # filemerge.py - file-level merge handling for Mercurial
2 #
2 #
3 # Copyright 2006, 2007, 2008 Matt Mackall <mpm@selenic.com>
3 # Copyright 2006, 2007, 2008 Matt Mackall <mpm@selenic.com>
4 #
4 #
5 # This software may be used and distributed according to the terms of the
5 # This software may be used and distributed according to the terms of the
6 # GNU General Public License version 2 or any later version.
6 # GNU General Public License version 2 or any later version.
7
7
8 from __future__ import absolute_import
8 from __future__ import absolute_import
9
9
10 import filecmp
10 import filecmp
11 import os
11 import os
12 import re
12 import re
13 import tempfile
13 import tempfile
14
14
15 from .i18n import _
15 from .i18n import _
16 from .node import short
16 from .node import short
17
17
18 from . import (
18 from . import (
19 error,
19 error,
20 match,
20 match,
21 simplemerge,
21 simplemerge,
22 tagmerge,
22 tagmerge,
23 templatekw,
23 templatekw,
24 templater,
24 templater,
25 util,
25 util,
26 )
26 )
27
27
28 def _toolstr(ui, tool, part, default=""):
28 def _toolstr(ui, tool, part, default=""):
29 return ui.config("merge-tools", tool + "." + part, default)
29 return ui.config("merge-tools", tool + "." + part, default)
30
30
31 def _toolbool(ui, tool, part, default=False):
31 def _toolbool(ui, tool, part, default=False):
32 return ui.configbool("merge-tools", tool + "." + part, default)
32 return ui.configbool("merge-tools", tool + "." + part, default)
33
33
34 def _toollist(ui, tool, part, default=[]):
34 def _toollist(ui, tool, part, default=[]):
35 return ui.configlist("merge-tools", tool + "." + part, default)
35 return ui.configlist("merge-tools", tool + "." + part, default)
36
36
37 internals = {}
37 internals = {}
38 # Merge tools to document.
38 # Merge tools to document.
39 internalsdoc = {}
39 internalsdoc = {}
40
40
41 # internal tool merge types
41 # internal tool merge types
42 nomerge = None
42 nomerge = None
43 mergeonly = 'mergeonly' # just the full merge, no premerge
43 mergeonly = 'mergeonly' # just the full merge, no premerge
44 fullmerge = 'fullmerge' # both premerge and merge
44 fullmerge = 'fullmerge' # both premerge and merge
45
45
46 def internaltool(name, mergetype, onfailure=None, precheck=None):
46 def internaltool(name, mergetype, onfailure=None, precheck=None):
47 '''return a decorator for populating internal merge tool table'''
47 '''return a decorator for populating internal merge tool table'''
48 def decorator(func):
48 def decorator(func):
49 fullname = ':' + name
49 fullname = ':' + name
50 func.__doc__ = "``%s``\n" % fullname + func.__doc__.strip()
50 func.__doc__ = "``%s``\n" % fullname + func.__doc__.strip()
51 internals[fullname] = func
51 internals[fullname] = func
52 internals['internal:' + name] = func
52 internals['internal:' + name] = func
53 internalsdoc[fullname] = func
53 internalsdoc[fullname] = func
54 func.mergetype = mergetype
54 func.mergetype = mergetype
55 func.onfailure = onfailure
55 func.onfailure = onfailure
56 func.precheck = precheck
56 func.precheck = precheck
57 return func
57 return func
58 return decorator
58 return decorator
59
59
60 def _findtool(ui, tool):
60 def _findtool(ui, tool):
61 if tool in internals:
61 if tool in internals:
62 return tool
62 return tool
63 return findexternaltool(ui, tool)
63 return findexternaltool(ui, tool)
64
64
65 def findexternaltool(ui, tool):
65 def findexternaltool(ui, tool):
66 for kn in ("regkey", "regkeyalt"):
66 for kn in ("regkey", "regkeyalt"):
67 k = _toolstr(ui, tool, kn)
67 k = _toolstr(ui, tool, kn)
68 if not k:
68 if not k:
69 continue
69 continue
70 p = util.lookupreg(k, _toolstr(ui, tool, "regname"))
70 p = util.lookupreg(k, _toolstr(ui, tool, "regname"))
71 if p:
71 if p:
72 p = util.findexe(p + _toolstr(ui, tool, "regappend"))
72 p = util.findexe(p + _toolstr(ui, tool, "regappend"))
73 if p:
73 if p:
74 return p
74 return p
75 exe = _toolstr(ui, tool, "executable", tool)
75 exe = _toolstr(ui, tool, "executable", tool)
76 return util.findexe(util.expandpath(exe))
76 return util.findexe(util.expandpath(exe))
77
77
78 def _picktool(repo, ui, path, binary, symlink):
78 def _picktool(repo, ui, path, binary, symlink):
79 def check(tool, pat, symlink, binary):
79 def check(tool, pat, symlink, binary):
80 tmsg = tool
80 tmsg = tool
81 if pat:
81 if pat:
82 tmsg += " specified for " + pat
82 tmsg += " specified for " + pat
83 if not _findtool(ui, tool):
83 if not _findtool(ui, tool):
84 if pat: # explicitly requested tool deserves a warning
84 if pat: # explicitly requested tool deserves a warning
85 ui.warn(_("couldn't find merge tool %s\n") % tmsg)
85 ui.warn(_("couldn't find merge tool %s\n") % tmsg)
86 else: # configured but non-existing tools are more silent
86 else: # configured but non-existing tools are more silent
87 ui.note(_("couldn't find merge tool %s\n") % tmsg)
87 ui.note(_("couldn't find merge tool %s\n") % tmsg)
88 elif symlink and not _toolbool(ui, tool, "symlink"):
88 elif symlink and not _toolbool(ui, tool, "symlink"):
89 ui.warn(_("tool %s can't handle symlinks\n") % tmsg)
89 ui.warn(_("tool %s can't handle symlinks\n") % tmsg)
90 elif binary and not _toolbool(ui, tool, "binary"):
90 elif binary and not _toolbool(ui, tool, "binary"):
91 ui.warn(_("tool %s can't handle binary\n") % tmsg)
91 ui.warn(_("tool %s can't handle binary\n") % tmsg)
92 elif not util.gui() and _toolbool(ui, tool, "gui"):
92 elif not util.gui() and _toolbool(ui, tool, "gui"):
93 ui.warn(_("tool %s requires a GUI\n") % tmsg)
93 ui.warn(_("tool %s requires a GUI\n") % tmsg)
94 else:
94 else:
95 return True
95 return True
96 return False
96 return False
97
97
98 # internal config: ui.forcemerge
98 # internal config: ui.forcemerge
99 # forcemerge comes from command line arguments, highest priority
99 # forcemerge comes from command line arguments, highest priority
100 force = ui.config('ui', 'forcemerge')
100 force = ui.config('ui', 'forcemerge')
101 if force:
101 if force:
102 toolpath = _findtool(ui, force)
102 toolpath = _findtool(ui, force)
103 if toolpath:
103 if toolpath:
104 return (force, util.shellquote(toolpath))
104 return (force, util.shellquote(toolpath))
105 else:
105 else:
106 # mimic HGMERGE if given tool not found
106 # mimic HGMERGE if given tool not found
107 return (force, force)
107 return (force, force)
108
108
109 # HGMERGE takes next precedence
109 # HGMERGE takes next precedence
110 hgmerge = os.environ.get("HGMERGE")
110 hgmerge = os.environ.get("HGMERGE")
111 if hgmerge:
111 if hgmerge:
112 return (hgmerge, hgmerge)
112 return (hgmerge, hgmerge)
113
113
114 # then patterns
114 # then patterns
115 for pat, tool in ui.configitems("merge-patterns"):
115 for pat, tool in ui.configitems("merge-patterns"):
116 mf = match.match(repo.root, '', [pat])
116 mf = match.match(repo.root, '', [pat])
117 if mf(path) and check(tool, pat, symlink, False):
117 if mf(path) and check(tool, pat, symlink, False):
118 toolpath = _findtool(ui, tool)
118 toolpath = _findtool(ui, tool)
119 return (tool, util.shellquote(toolpath))
119 return (tool, util.shellquote(toolpath))
120
120
121 # then merge tools
121 # then merge tools
122 tools = {}
122 tools = {}
123 for k, v in ui.configitems("merge-tools"):
123 for k, v in ui.configitems("merge-tools"):
124 t = k.split('.')[0]
124 t = k.split('.')[0]
125 if t not in tools:
125 if t not in tools:
126 tools[t] = int(_toolstr(ui, t, "priority", "0"))
126 tools[t] = int(_toolstr(ui, t, "priority", "0"))
127 names = tools.keys()
127 names = tools.keys()
128 tools = sorted([(-p, t) for t, p in tools.items()])
128 tools = sorted([(-p, t) for t, p in tools.items()])
129 uimerge = ui.config("ui", "merge")
129 uimerge = ui.config("ui", "merge")
130 if uimerge:
130 if uimerge:
131 if uimerge not in names:
131 if uimerge not in names:
132 return (uimerge, uimerge)
132 return (uimerge, uimerge)
133 tools.insert(0, (None, uimerge)) # highest priority
133 tools.insert(0, (None, uimerge)) # highest priority
134 tools.append((None, "hgmerge")) # the old default, if found
134 tools.append((None, "hgmerge")) # the old default, if found
135 for p, t in tools:
135 for p, t in tools:
136 if check(t, None, symlink, binary):
136 if check(t, None, symlink, binary):
137 toolpath = _findtool(ui, t)
137 toolpath = _findtool(ui, t)
138 return (t, util.shellquote(toolpath))
138 return (t, util.shellquote(toolpath))
139
139
140 # internal merge or prompt as last resort
140 # internal merge or prompt as last resort
141 if symlink or binary:
141 if symlink or binary:
142 return ":prompt", None
142 return ":prompt", None
143 return ":merge", None
143 return ":merge", None
144
144
145 def _eoltype(data):
145 def _eoltype(data):
146 "Guess the EOL type of a file"
146 "Guess the EOL type of a file"
147 if '\0' in data: # binary
147 if '\0' in data: # binary
148 return None
148 return None
149 if '\r\n' in data: # Windows
149 if '\r\n' in data: # Windows
150 return '\r\n'
150 return '\r\n'
151 if '\r' in data: # Old Mac
151 if '\r' in data: # Old Mac
152 return '\r'
152 return '\r'
153 if '\n' in data: # UNIX
153 if '\n' in data: # UNIX
154 return '\n'
154 return '\n'
155 return None # unknown
155 return None # unknown
156
156
157 def _matcheol(file, origfile):
157 def _matcheol(file, origfile):
158 "Convert EOL markers in a file to match origfile"
158 "Convert EOL markers in a file to match origfile"
159 tostyle = _eoltype(util.readfile(origfile))
159 tostyle = _eoltype(util.readfile(origfile))
160 if tostyle:
160 if tostyle:
161 data = util.readfile(file)
161 data = util.readfile(file)
162 style = _eoltype(data)
162 style = _eoltype(data)
163 if style:
163 if style:
164 newdata = data.replace(style, tostyle)
164 newdata = data.replace(style, tostyle)
165 if newdata != data:
165 if newdata != data:
166 util.writefile(file, newdata)
166 util.writefile(file, newdata)
167
167
168 @internaltool('prompt', nomerge)
168 @internaltool('prompt', nomerge)
169 def _iprompt(repo, mynode, orig, fcd, fco, fca, toolconf):
169 def _iprompt(repo, mynode, orig, fcd, fco, fca, toolconf):
170 """Asks the user which of the local or the other version to keep as
170 """Asks the user which of the local or the other version to keep as
171 the merged version."""
171 the merged version."""
172 ui = repo.ui
172 ui = repo.ui
173 fd = fcd.path()
173 fd = fcd.path()
174
174
175 if ui.promptchoice(_(" no tool found to merge %s\n"
175 if ui.promptchoice(_(" no tool found to merge %s\n"
176 "keep (l)ocal or take (o)ther?"
176 "keep (l)ocal or take (o)ther?"
177 "$$ &Local $$ &Other") % fd, 0):
177 "$$ &Local $$ &Other") % fd, 0):
178 return _iother(repo, mynode, orig, fcd, fco, fca, toolconf)
178 return _iother(repo, mynode, orig, fcd, fco, fca, toolconf)
179 else:
179 else:
180 return _ilocal(repo, mynode, orig, fcd, fco, fca, toolconf)
180 return _ilocal(repo, mynode, orig, fcd, fco, fca, toolconf)
181
181
182 @internaltool('local', nomerge)
182 @internaltool('local', nomerge)
183 def _ilocal(repo, mynode, orig, fcd, fco, fca, toolconf):
183 def _ilocal(repo, mynode, orig, fcd, fco, fca, toolconf):
184 """Uses the local version of files as the merged version."""
184 """Uses the local version of files as the merged version."""
185 return 0
185 return 0
186
186
187 @internaltool('other', nomerge)
187 @internaltool('other', nomerge)
188 def _iother(repo, mynode, orig, fcd, fco, fca, toolconf):
188 def _iother(repo, mynode, orig, fcd, fco, fca, toolconf):
189 """Uses the other version of files as the merged version."""
189 """Uses the other version of files as the merged version."""
190 repo.wwrite(fcd.path(), fco.data(), fco.flags())
190 repo.wwrite(fcd.path(), fco.data(), fco.flags())
191 return 0
191 return 0
192
192
193 @internaltool('fail', nomerge)
193 @internaltool('fail', nomerge)
194 def _ifail(repo, mynode, orig, fcd, fco, fca, toolconf):
194 def _ifail(repo, mynode, orig, fcd, fco, fca, toolconf):
195 """
195 """
196 Rather than attempting to merge files that were modified on both
196 Rather than attempting to merge files that were modified on both
197 branches, it marks them as unresolved. The resolve command must be
197 branches, it marks them as unresolved. The resolve command must be
198 used to resolve these conflicts."""
198 used to resolve these conflicts."""
199 return 1
199 return 1
200
200
201 def _premerge(repo, toolconf, files, labels=None):
201 def _premerge(repo, toolconf, files, labels=None):
202 tool, toolpath, binary, symlink = toolconf
202 tool, toolpath, binary, symlink = toolconf
203 if symlink:
203 if symlink:
204 return 1
204 return 1
205 a, b, c, back = files
205 a, b, c, back = files
206
206
207 ui = repo.ui
207 ui = repo.ui
208
208
209 validkeep = ['keep', 'keep-merge3']
209 validkeep = ['keep', 'keep-merge3']
210
210
211 # do we attempt to simplemerge first?
211 # do we attempt to simplemerge first?
212 try:
212 try:
213 premerge = _toolbool(ui, tool, "premerge", not binary)
213 premerge = _toolbool(ui, tool, "premerge", not binary)
214 except error.ConfigError:
214 except error.ConfigError:
215 premerge = _toolstr(ui, tool, "premerge").lower()
215 premerge = _toolstr(ui, tool, "premerge").lower()
216 if premerge not in validkeep:
216 if premerge not in validkeep:
217 _valid = ', '.join(["'" + v + "'" for v in validkeep])
217 _valid = ', '.join(["'" + v + "'" for v in validkeep])
218 raise error.ConfigError(_("%s.premerge not valid "
218 raise error.ConfigError(_("%s.premerge not valid "
219 "('%s' is neither boolean nor %s)") %
219 "('%s' is neither boolean nor %s)") %
220 (tool, premerge, _valid))
220 (tool, premerge, _valid))
221
221
222 if premerge:
222 if premerge:
223 if premerge == 'keep-merge3':
223 if premerge == 'keep-merge3':
224 if not labels:
224 if not labels:
225 labels = _defaultconflictlabels
225 labels = _defaultconflictlabels
226 if len(labels) < 3:
226 if len(labels) < 3:
227 labels.append('base')
227 labels.append('base')
228 r = simplemerge.simplemerge(ui, a, b, c, quiet=True, label=labels)
228 r = simplemerge.simplemerge(ui, a, b, c, quiet=True, label=labels)
229 if not r:
229 if not r:
230 ui.debug(" premerge successful\n")
230 ui.debug(" premerge successful\n")
231 return 0
231 return 0
232 if premerge not in validkeep:
232 if premerge not in validkeep:
233 util.copyfile(back, a) # restore from backup and try again
233 util.copyfile(back, a) # restore from backup and try again
234 return 1 # continue merging
234 return 1 # continue merging
235
235
236 def _symlinkcheck(repo, mynode, orig, fcd, fco, fca, toolconf):
236 def _symlinkcheck(repo, mynode, orig, fcd, fco, fca, toolconf):
237 tool, toolpath, binary, symlink = toolconf
237 tool, toolpath, binary, symlink = toolconf
238 if symlink:
238 if symlink:
239 repo.ui.warn(_('warning: internal %s cannot merge symlinks '
239 repo.ui.warn(_('warning: internal %s cannot merge symlinks '
240 'for %s\n') % (tool, fcd.path()))
240 'for %s\n') % (tool, fcd.path()))
241 return False
241 return False
242 return True
242 return True
243
243
244 def _merge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels, mode):
244 def _merge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels, mode):
245 """
245 """
246 Uses the internal non-interactive simple merge algorithm for merging
246 Uses the internal non-interactive simple merge algorithm for merging
247 files. It will fail if there are any conflicts and leave markers in
247 files. It will fail if there are any conflicts and leave markers in
248 the partially merged file. Markers will have two sections, one for each side
248 the partially merged file. Markers will have two sections, one for each side
249 of merge, unless mode equals 'union' which suppresses the markers."""
249 of merge, unless mode equals 'union' which suppresses the markers."""
250 a, b, c, back = files
250 a, b, c, back = files
251
251
252 ui = repo.ui
252 ui = repo.ui
253
253
254 r = simplemerge.simplemerge(ui, a, b, c, label=labels, mode=mode)
254 r = simplemerge.simplemerge(ui, a, b, c, label=labels, mode=mode)
255 return True, r
255 return True, r
256
256
257 @internaltool('union', fullmerge,
257 @internaltool('union', fullmerge,
258 _("merging %s incomplete! "
258 _("merging %s incomplete! "
259 "(edit conflicts, then use 'hg resolve --mark')\n"),
259 "(edit conflicts, then use 'hg resolve --mark')\n"),
260 precheck=_symlinkcheck)
260 precheck=_symlinkcheck)
261 def _iunion(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None):
261 def _iunion(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None):
262 """
262 """
263 Uses the internal non-interactive simple merge algorithm for merging
263 Uses the internal non-interactive simple merge algorithm for merging
264 files. It will use both left and right sides for conflict regions.
264 files. It will use both left and right sides for conflict regions.
265 No markers are inserted."""
265 No markers are inserted."""
266 return _merge(repo, mynode, orig, fcd, fco, fca, toolconf,
266 return _merge(repo, mynode, orig, fcd, fco, fca, toolconf,
267 files, labels, 'union')
267 files, labels, 'union')
268
268
269 @internaltool('merge', fullmerge,
269 @internaltool('merge', fullmerge,
270 _("merging %s incomplete! "
270 _("merging %s incomplete! "
271 "(edit conflicts, then use 'hg resolve --mark')\n"),
271 "(edit conflicts, then use 'hg resolve --mark')\n"),
272 precheck=_symlinkcheck)
272 precheck=_symlinkcheck)
273 def _imerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None):
273 def _imerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None):
274 """
274 """
275 Uses the internal non-interactive simple merge algorithm for merging
275 Uses the internal non-interactive simple merge algorithm for merging
276 files. It will fail if there are any conflicts and leave markers in
276 files. It will fail if there are any conflicts and leave markers in
277 the partially merged file. Markers will have two sections, one for each side
277 the partially merged file. Markers will have two sections, one for each side
278 of merge."""
278 of merge."""
279 return _merge(repo, mynode, orig, fcd, fco, fca, toolconf,
279 return _merge(repo, mynode, orig, fcd, fco, fca, toolconf,
280 files, labels, 'merge')
280 files, labels, 'merge')
281
281
282 @internaltool('merge3', fullmerge,
282 @internaltool('merge3', fullmerge,
283 _("merging %s incomplete! "
283 _("merging %s incomplete! "
284 "(edit conflicts, then use 'hg resolve --mark')\n"),
284 "(edit conflicts, then use 'hg resolve --mark')\n"),
285 precheck=_symlinkcheck)
285 precheck=_symlinkcheck)
286 def _imerge3(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None):
286 def _imerge3(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None):
287 """
287 """
288 Uses the internal non-interactive simple merge algorithm for merging
288 Uses the internal non-interactive simple merge algorithm for merging
289 files. It will fail if there are any conflicts and leave markers in
289 files. It will fail if there are any conflicts and leave markers in
290 the partially merged file. Marker will have three sections, one from each
290 the partially merged file. Marker will have three sections, one from each
291 side of the merge and one for the base content."""
291 side of the merge and one for the base content."""
292 if not labels:
292 if not labels:
293 labels = _defaultconflictlabels
293 labels = _defaultconflictlabels
294 if len(labels) < 3:
294 if len(labels) < 3:
295 labels.append('base')
295 labels.append('base')
296 return _imerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels)
296 return _imerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels)
297
297
298 def _imergeauto(repo, mynode, orig, fcd, fco, fca, toolconf, files,
298 def _imergeauto(repo, mynode, orig, fcd, fco, fca, toolconf, files,
299 labels=None, localorother=None):
299 labels=None, localorother=None):
300 """
300 """
301 Generic driver for _imergelocal and _imergeother
301 Generic driver for _imergelocal and _imergeother
302 """
302 """
303 assert localorother is not None
303 assert localorother is not None
304 tool, toolpath, binary, symlink = toolconf
304 tool, toolpath, binary, symlink = toolconf
305 if symlink:
305 if symlink:
306 repo.ui.warn(_('warning: :merge-%s cannot merge symlinks '
306 repo.ui.warn(_('warning: :merge-%s cannot merge symlinks '
307 'for %s\n') % (localorother, fcd.path()))
307 'for %s\n') % (localorother, fcd.path()))
308 return False, 1
308 return False, 1
309 a, b, c, back = files
309 a, b, c, back = files
310 r = simplemerge.simplemerge(repo.ui, a, b, c, label=labels,
310 r = simplemerge.simplemerge(repo.ui, a, b, c, label=labels,
311 localorother=localorother)
311 localorother=localorother)
312 return True, r
312 return True, r
313
313
314 @internaltool('merge-local', mergeonly)
314 @internaltool('merge-local', mergeonly)
315 def _imergelocal(*args, **kwargs):
315 def _imergelocal(*args, **kwargs):
316 """
316 """
317 Like :merge, but resolve all conflicts non-interactively in favor
317 Like :merge, but resolve all conflicts non-interactively in favor
318 of the local changes."""
318 of the local changes."""
319 success, status = _imergeauto(localorother='local', *args, **kwargs)
319 success, status = _imergeauto(localorother='local', *args, **kwargs)
320 return success, status
320 return success, status
321
321
322 @internaltool('merge-other', mergeonly)
322 @internaltool('merge-other', mergeonly)
323 def _imergeother(*args, **kwargs):
323 def _imergeother(*args, **kwargs):
324 """
324 """
325 Like :merge, but resolve all conflicts non-interactively in favor
325 Like :merge, but resolve all conflicts non-interactively in favor
326 of the other changes."""
326 of the other changes."""
327 success, status = _imergeauto(localorother='other', *args, **kwargs)
327 success, status = _imergeauto(localorother='other', *args, **kwargs)
328 return success, status
328 return success, status
329
329
330 @internaltool('tagmerge', mergeonly,
330 @internaltool('tagmerge', mergeonly,
331 _("automatic tag merging of %s failed! "
331 _("automatic tag merging of %s failed! "
332 "(use 'hg resolve --tool :merge' or another merge "
332 "(use 'hg resolve --tool :merge' or another merge "
333 "tool of your choice)\n"))
333 "tool of your choice)\n"))
334 def _itagmerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None):
334 def _itagmerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None):
335 """
335 """
336 Uses the internal tag merge algorithm (experimental).
336 Uses the internal tag merge algorithm (experimental).
337 """
337 """
338 return tagmerge.merge(repo, fcd, fco, fca)
338 return tagmerge.merge(repo, fcd, fco, fca)
339
339
340 @internaltool('dump', fullmerge)
340 @internaltool('dump', fullmerge)
341 def _idump(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None):
341 def _idump(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None):
342 """
342 """
343 Creates three versions of the files to merge, containing the
343 Creates three versions of the files to merge, containing the
344 contents of local, other and base. These files can then be used to
344 contents of local, other and base. These files can then be used to
345 perform a merge manually. If the file to be merged is named
345 perform a merge manually. If the file to be merged is named
346 ``a.txt``, these files will accordingly be named ``a.txt.local``,
346 ``a.txt``, these files will accordingly be named ``a.txt.local``,
347 ``a.txt.other`` and ``a.txt.base`` and they will be placed in the
347 ``a.txt.other`` and ``a.txt.base`` and they will be placed in the
348 same directory as ``a.txt``."""
348 same directory as ``a.txt``."""
349 a, b, c, back = files
349 a, b, c, back = files
350
350
351 fd = fcd.path()
351 fd = fcd.path()
352
352
353 util.copyfile(a, a + ".local")
353 util.copyfile(a, a + ".local")
354 repo.wwrite(fd + ".other", fco.data(), fco.flags())
354 repo.wwrite(fd + ".other", fco.data(), fco.flags())
355 repo.wwrite(fd + ".base", fca.data(), fca.flags())
355 repo.wwrite(fd + ".base", fca.data(), fca.flags())
356 return False, 1
356 return False, 1
357
357
358 def _xmerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None):
358 def _xmerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None):
359 tool, toolpath, binary, symlink = toolconf
359 tool, toolpath, binary, symlink = toolconf
360 a, b, c, back = files
360 a, b, c, back = files
361 out = ""
361 out = ""
362 env = {'HG_FILE': fcd.path(),
362 env = {'HG_FILE': fcd.path(),
363 'HG_MY_NODE': short(mynode),
363 'HG_MY_NODE': short(mynode),
364 'HG_OTHER_NODE': str(fco.changectx()),
364 'HG_OTHER_NODE': str(fco.changectx()),
365 'HG_BASE_NODE': str(fca.changectx()),
365 'HG_BASE_NODE': str(fca.changectx()),
366 'HG_MY_ISLINK': 'l' in fcd.flags(),
366 'HG_MY_ISLINK': 'l' in fcd.flags(),
367 'HG_OTHER_ISLINK': 'l' in fco.flags(),
367 'HG_OTHER_ISLINK': 'l' in fco.flags(),
368 'HG_BASE_ISLINK': 'l' in fca.flags(),
368 'HG_BASE_ISLINK': 'l' in fca.flags(),
369 }
369 }
370
370
371 ui = repo.ui
371 ui = repo.ui
372
372
373 args = _toolstr(ui, tool, "args", '$local $base $other')
373 args = _toolstr(ui, tool, "args", '$local $base $other')
374 if "$output" in args:
374 if "$output" in args:
375 out, a = a, back # read input from backup, write to original
375 out, a = a, back # read input from backup, write to original
376 replace = {'local': a, 'base': b, 'other': c, 'output': out}
376 replace = {'local': a, 'base': b, 'other': c, 'output': out}
377 args = util.interpolate(r'\$', replace, args,
377 args = util.interpolate(r'\$', replace, args,
378 lambda s: util.shellquote(util.localpath(s)))
378 lambda s: util.shellquote(util.localpath(s)))
379 cmd = toolpath + ' ' + args
379 cmd = toolpath + ' ' + args
380 repo.ui.debug('launching merge tool: %s\n' % cmd)
380 repo.ui.debug('launching merge tool: %s\n' % cmd)
381 r = ui.system(cmd, cwd=repo.root, environ=env)
381 r = ui.system(cmd, cwd=repo.root, environ=env)
382 repo.ui.debug('merge tool returned: %s\n' % r)
382 repo.ui.debug('merge tool returned: %s\n' % r)
383 return True, r
383 return True, r
384
384
385 def _formatconflictmarker(repo, ctx, template, label, pad):
385 def _formatconflictmarker(repo, ctx, template, label, pad):
386 """Applies the given template to the ctx, prefixed by the label.
386 """Applies the given template to the ctx, prefixed by the label.
387
387
388 Pad is the minimum width of the label prefix, so that multiple markers
388 Pad is the minimum width of the label prefix, so that multiple markers
389 can have aligned templated parts.
389 can have aligned templated parts.
390 """
390 """
391 if ctx.node() is None:
391 if ctx.node() is None:
392 ctx = ctx.p1()
392 ctx = ctx.p1()
393
393
394 props = templatekw.keywords.copy()
394 props = templatekw.keywords.copy()
395 props['templ'] = template
395 props['templ'] = template
396 props['ctx'] = ctx
396 props['ctx'] = ctx
397 props['repo'] = repo
397 props['repo'] = repo
398 templateresult = template('conflictmarker', **props)
398 templateresult = template('conflictmarker', **props)
399
399
400 label = ('%s:' % label).ljust(pad + 1)
400 label = ('%s:' % label).ljust(pad + 1)
401 mark = '%s %s' % (label, templater.stringify(templateresult))
401 mark = '%s %s' % (label, templater.stringify(templateresult))
402
402
403 if mark:
403 if mark:
404 mark = mark.splitlines()[0] # split for safety
404 mark = mark.splitlines()[0] # split for safety
405
405
406 # 8 for the prefix of conflict marker lines (e.g. '<<<<<<< ')
406 # 8 for the prefix of conflict marker lines (e.g. '<<<<<<< ')
407 return util.ellipsis(mark, 80 - 8)
407 return util.ellipsis(mark, 80 - 8)
408
408
409 _defaultconflictmarker = ('{node|short} ' +
409 _defaultconflictmarker = ('{node|short} ' +
410 '{ifeq(tags, "tip", "", "{tags} ")}' +
410 '{ifeq(tags, "tip", "", "{tags} ")}' +
411 '{if(bookmarks, "{bookmarks} ")}' +
411 '{if(bookmarks, "{bookmarks} ")}' +
412 '{ifeq(branch, "default", "", "{branch} ")}' +
412 '{ifeq(branch, "default", "", "{branch} ")}' +
413 '- {author|user}: {desc|firstline}')
413 '- {author|user}: {desc|firstline}')
414
414
415 _defaultconflictlabels = ['local', 'other']
415 _defaultconflictlabels = ['local', 'other']
416
416
417 def _formatlabels(repo, fcd, fco, fca, labels):
417 def _formatlabels(repo, fcd, fco, fca, labels):
418 """Formats the given labels using the conflict marker template.
418 """Formats the given labels using the conflict marker template.
419
419
420 Returns a list of formatted labels.
420 Returns a list of formatted labels.
421 """
421 """
422 cd = fcd.changectx()
422 cd = fcd.changectx()
423 co = fco.changectx()
423 co = fco.changectx()
424 ca = fca.changectx()
424 ca = fca.changectx()
425
425
426 ui = repo.ui
426 ui = repo.ui
427 template = ui.config('ui', 'mergemarkertemplate', _defaultconflictmarker)
427 template = ui.config('ui', 'mergemarkertemplate', _defaultconflictmarker)
428 tmpl = templater.templater(None, cache={'conflictmarker': template})
428 tmpl = templater.templater(None, cache={'conflictmarker': template})
429
429
430 pad = max(len(l) for l in labels)
430 pad = max(len(l) for l in labels)
431
431
432 newlabels = [_formatconflictmarker(repo, cd, tmpl, labels[0], pad),
432 newlabels = [_formatconflictmarker(repo, cd, tmpl, labels[0], pad),
433 _formatconflictmarker(repo, co, tmpl, labels[1], pad)]
433 _formatconflictmarker(repo, co, tmpl, labels[1], pad)]
434 if len(labels) > 2:
434 if len(labels) > 2:
435 newlabels.append(_formatconflictmarker(repo, ca, tmpl, labels[2], pad))
435 newlabels.append(_formatconflictmarker(repo, ca, tmpl, labels[2], pad))
436 return newlabels
436 return newlabels
437
437
438 def _filemerge(premerge, repo, mynode, orig, fcd, fco, fca, labels=None):
438 def _filemerge(premerge, repo, mynode, orig, fcd, fco, fca, labels=None):
439 """perform a 3-way merge in the working directory
439 """perform a 3-way merge in the working directory
440
440
441 premerge = whether this is a premerge
441 premerge = whether this is a premerge
442 mynode = parent node before merge
442 mynode = parent node before merge
443 orig = original local filename before merge
443 orig = original local filename before merge
444 fco = other file context
444 fco = other file context
445 fca = ancestor file context
445 fca = ancestor file context
446 fcd = local file context for current/destination file
446 fcd = local file context for current/destination file
447
447
448 Returns whether the merge is complete, and the return value of the merge.
448 Returns whether the merge is complete, and the return value of the merge.
449 """
449 """
450
450
451 if True:
451 def temp(prefix, ctx):
452 def temp(prefix, ctx):
452 pre = "%s~%s." % (os.path.basename(ctx.path()), prefix)
453 pre = "%s~%s." % (os.path.basename(ctx.path()), prefix)
453 (fd, name) = tempfile.mkstemp(prefix=pre)
454 (fd, name) = tempfile.mkstemp(prefix=pre)
454 data = repo.wwritedata(ctx.path(), ctx.data())
455 data = repo.wwritedata(ctx.path(), ctx.data())
455 f = os.fdopen(fd, "wb")
456 f = os.fdopen(fd, "wb")
456 f.write(data)
457 f.write(data)
457 f.close()
458 f.close()
458 return name
459 return name
460
459
461 if not fco.cmp(fcd): # files identical?
460 if not fco.cmp(fcd): # files identical?
462 return True, None
461 return True, None
463
462
464 ui = repo.ui
463 ui = repo.ui
465 fd = fcd.path()
464 fd = fcd.path()
466 binary = fcd.isbinary() or fco.isbinary() or fca.isbinary()
465 binary = fcd.isbinary() or fco.isbinary() or fca.isbinary()
467 symlink = 'l' in fcd.flags() + fco.flags()
466 symlink = 'l' in fcd.flags() + fco.flags()
468 tool, toolpath = _picktool(repo, ui, fd, binary, symlink)
467 tool, toolpath = _picktool(repo, ui, fd, binary, symlink)
469 if tool in internals and tool.startswith('internal:'):
468 if tool in internals and tool.startswith('internal:'):
470 # normalize to new-style names (':merge' etc)
469 # normalize to new-style names (':merge' etc)
471 tool = tool[len('internal'):]
470 tool = tool[len('internal'):]
472 ui.debug("picked tool '%s' for %s (binary %s symlink %s)\n" %
471 ui.debug("picked tool '%s' for %s (binary %s symlink %s)\n" %
473 (tool, fd, binary, symlink))
472 (tool, fd, binary, symlink))
474
473
475 if tool in internals:
474 if tool in internals:
476 func = internals[tool]
475 func = internals[tool]
477 mergetype = func.mergetype
476 mergetype = func.mergetype
478 onfailure = func.onfailure
477 onfailure = func.onfailure
479 precheck = func.precheck
478 precheck = func.precheck
480 else:
479 else:
481 func = _xmerge
480 func = _xmerge
482 mergetype = fullmerge
481 mergetype = fullmerge
483 onfailure = _("merging %s failed!\n")
482 onfailure = _("merging %s failed!\n")
484 precheck = None
483 precheck = None
485
484
486 toolconf = tool, toolpath, binary, symlink
485 toolconf = tool, toolpath, binary, symlink
487
486
488 if mergetype == nomerge:
487 if mergetype == nomerge:
489 return True, func(repo, mynode, orig, fcd, fco, fca, toolconf)
488 return True, func(repo, mynode, orig, fcd, fco, fca, toolconf)
490
489
491 if orig != fco.path():
490 if orig != fco.path():
492 ui.status(_("merging %s and %s to %s\n") % (orig, fco.path(), fd))
491 ui.status(_("merging %s and %s to %s\n") % (orig, fco.path(), fd))
493 else:
492 else:
494 ui.status(_("merging %s\n") % fd)
493 ui.status(_("merging %s\n") % fd)
495
494
496 ui.debug("my %s other %s ancestor %s\n" % (fcd, fco, fca))
495 ui.debug("my %s other %s ancestor %s\n" % (fcd, fco, fca))
497
496
498 if precheck and not precheck(repo, mynode, orig, fcd, fco, fca,
497 if precheck and not precheck(repo, mynode, orig, fcd, fco, fca,
499 toolconf):
498 toolconf):
500 if onfailure:
499 if onfailure:
501 ui.warn(onfailure % fd)
500 ui.warn(onfailure % fd)
502 return True, 1
501 return True, 1
503
502
504 a = repo.wjoin(fd)
503 a = repo.wjoin(fd)
505 b = temp("base", fca)
504 b = temp("base", fca)
506 c = temp("other", fco)
505 c = temp("other", fco)
507 back = a + ".orig"
506 back = a + ".orig"
508 util.copyfile(a, back)
507 util.copyfile(a, back)
509 files = (a, b, c, back)
508 files = (a, b, c, back)
510
509
511 r = 1
510 r = 1
512 try:
511 try:
513 markerstyle = ui.config('ui', 'mergemarkers', 'basic')
512 markerstyle = ui.config('ui', 'mergemarkers', 'basic')
514 if not labels:
513 if not labels:
515 labels = _defaultconflictlabels
514 labels = _defaultconflictlabels
516 if markerstyle != 'basic':
515 if markerstyle != 'basic':
517 labels = _formatlabels(repo, fcd, fco, fca, labels)
516 labels = _formatlabels(repo, fcd, fco, fca, labels)
518
517
519 if premerge and mergetype == fullmerge:
518 if premerge and mergetype == fullmerge:
520 r = _premerge(repo, toolconf, files, labels=labels)
519 r = _premerge(repo, toolconf, files, labels=labels)
521
520
522 if not r: # premerge successfully merged the file
521 if not r: # premerge successfully merged the file
523 needcheck = False
522 needcheck = False
524 else:
523 else:
525 needcheck, r = func(repo, mynode, orig, fcd, fco, fca, toolconf,
524 needcheck, r = func(repo, mynode, orig, fcd, fco, fca, toolconf,
526 files, labels=labels)
525 files, labels=labels)
527
526
528 if needcheck:
527 if needcheck:
529 r = _check(r, ui, tool, fcd, files)
528 r = _check(r, ui, tool, fcd, files)
530
529
531 if r:
530 if r:
532 if onfailure:
531 if onfailure:
533 ui.warn(onfailure % fd)
532 ui.warn(onfailure % fd)
534
533
535 return True, r
534 return True, r
536 finally:
535 finally:
537 if not r:
536 if not r:
538 util.unlink(back)
537 util.unlink(back)
539 util.unlink(b)
538 util.unlink(b)
540 util.unlink(c)
539 util.unlink(c)
541
540
542 def _check(r, ui, tool, fcd, files):
541 def _check(r, ui, tool, fcd, files):
543 fd = fcd.path()
542 fd = fcd.path()
544 a, b, c, back = files
543 a, b, c, back = files
545
544
546 if not r and (_toolbool(ui, tool, "checkconflicts") or
545 if not r and (_toolbool(ui, tool, "checkconflicts") or
547 'conflicts' in _toollist(ui, tool, "check")):
546 'conflicts' in _toollist(ui, tool, "check")):
548 if re.search("^(<<<<<<< .*|=======|>>>>>>> .*)$", fcd.data(),
547 if re.search("^(<<<<<<< .*|=======|>>>>>>> .*)$", fcd.data(),
549 re.MULTILINE):
548 re.MULTILINE):
550 r = 1
549 r = 1
551
550
552 checked = False
551 checked = False
553 if 'prompt' in _toollist(ui, tool, "check"):
552 if 'prompt' in _toollist(ui, tool, "check"):
554 checked = True
553 checked = True
555 if ui.promptchoice(_("was merge of '%s' successful (yn)?"
554 if ui.promptchoice(_("was merge of '%s' successful (yn)?"
556 "$$ &Yes $$ &No") % fd, 1):
555 "$$ &Yes $$ &No") % fd, 1):
557 r = 1
556 r = 1
558
557
559 if not r and not checked and (_toolbool(ui, tool, "checkchanged") or
558 if not r and not checked and (_toolbool(ui, tool, "checkchanged") or
560 'changed' in
559 'changed' in
561 _toollist(ui, tool, "check")):
560 _toollist(ui, tool, "check")):
562 if filecmp.cmp(a, back):
561 if filecmp.cmp(a, back):
563 if ui.promptchoice(_(" output file %s appears unchanged\n"
562 if ui.promptchoice(_(" output file %s appears unchanged\n"
564 "was merge successful (yn)?"
563 "was merge successful (yn)?"
565 "$$ &Yes $$ &No") % fd, 1):
564 "$$ &Yes $$ &No") % fd, 1):
566 r = 1
565 r = 1
567
566
568 if _toolbool(ui, tool, "fixeol"):
567 if _toolbool(ui, tool, "fixeol"):
569 _matcheol(a, back)
568 _matcheol(a, back)
570
569
571 return r
570 return r
572
571
573 def premerge(repo, mynode, orig, fcd, fco, fca, labels=None):
572 def premerge(repo, mynode, orig, fcd, fco, fca, labels=None):
574 return _filemerge(True, repo, mynode, orig, fcd, fco, fca, labels=labels)
573 return _filemerge(True, repo, mynode, orig, fcd, fco, fca, labels=labels)
575
574
576 def filemerge(repo, mynode, orig, fcd, fco, fca, labels=None):
575 def filemerge(repo, mynode, orig, fcd, fco, fca, labels=None):
577 # premerge = True is temporary -- will be changed to False once premerge
576 # premerge = True is temporary -- will be changed to False once premerge
578 # function above is ready
577 # function above is ready
579 return _filemerge(True, repo, mynode, orig, fcd, fco, fca, labels=labels)
578 return _filemerge(True, repo, mynode, orig, fcd, fco, fca, labels=labels)
580
579
581 # tell hggettext to extract docstrings from these functions:
580 # tell hggettext to extract docstrings from these functions:
582 i18nfunctions = internals.values()
581 i18nfunctions = internals.values()
General Comments 0
You need to be logged in to leave comments. Login now