5044
|
1 # Copyright (C) 2007 Brendan Cully <brendan@kublai.com>
|
|
2 # Published under the GNU GPL
|
|
3
|
|
4 '''
|
|
5 imerge - interactive merge
|
|
6 '''
|
|
7
|
|
8 from mercurial.i18n import _
|
|
9 from mercurial.node import *
|
|
10 from mercurial import commands, cmdutil, hg, merge, util
|
|
11 import os, tarfile
|
|
12
|
|
13 class InvalidStateFileException(Exception): pass
|
|
14
|
|
15 class ImergeStateFile(object):
|
|
16 def __init__(self, im):
|
|
17 self.im = im
|
|
18
|
|
19 def save(self, dest):
|
|
20 tf = tarfile.open(dest, 'w:gz')
|
|
21
|
|
22 st = os.path.join(self.im.path, 'status')
|
|
23 tf.add(st, os.path.join('.hg', 'imerge', 'status'))
|
|
24
|
|
25 for f in self.im.resolved:
|
|
26 abssrc = self.im.repo.wjoin(f)
|
|
27 tf.add(abssrc, f)
|
|
28
|
|
29 tf.close()
|
|
30
|
|
31 def load(self, source):
|
|
32 wlock = self.im.repo.wlock()
|
|
33 lock = self.im.repo.lock()
|
|
34
|
|
35 tf = tarfile.open(source, 'r')
|
|
36 contents = tf.getnames()
|
|
37 statusfile = os.path.join('.hg', 'imerge', 'status')
|
|
38 if statusfile not in contents:
|
|
39 raise InvalidStateFileException('no status file')
|
|
40
|
|
41 tf.extract(statusfile, self.im.repo.root)
|
|
42 self.im.load()
|
|
43 p1 = self.im.parents[0].node()
|
|
44 p2 = self.im.parents[1].node()
|
|
45 if self.im.repo.dirstate.parents()[0] != p1:
|
|
46 hg.clean(self.im.repo, self.im.parents[0].node())
|
|
47 self.im.start(p2)
|
|
48 tf.extractall(self.im.repo.root)
|
|
49 self.im.load()
|
|
50
|
|
51 class Imerge(object):
|
|
52 def __init__(self, ui, repo):
|
|
53 self.ui = ui
|
|
54 self.repo = repo
|
|
55
|
|
56 self.path = repo.join('imerge')
|
|
57 self.opener = util.opener(self.path)
|
|
58
|
|
59 self.parents = [self.repo.changectx(n)
|
|
60 for n in self.repo.dirstate.parents()]
|
|
61 self.conflicts = {}
|
|
62 self.resolved = []
|
|
63
|
|
64 def merging(self):
|
|
65 return self.parents[1].node() != nullid
|
|
66
|
|
67 def load(self):
|
|
68 # status format. \0-delimited file, fields are
|
|
69 # p1, p2, conflict count, conflict filenames, resolved filenames
|
|
70 # conflict filenames are pairs of localname, remotename
|
|
71
|
|
72 statusfile = self.opener('status')
|
|
73
|
|
74 status = statusfile.read().split('\0')
|
|
75 if len(status) < 3:
|
|
76 raise util.Abort('invalid imerge status file')
|
|
77
|
|
78 try:
|
|
79 self.parents = [self.repo.changectx(n) for n in status[:2]]
|
|
80 except LookupError:
|
|
81 raise util.Abort('merge parent %s not in repository' % short(p))
|
|
82
|
|
83 status = status[2:]
|
|
84 conflicts = int(status.pop(0)) * 2
|
|
85 self.resolved = status[conflicts:]
|
|
86 for i in xrange(0, conflicts, 2):
|
|
87 self.conflicts[status[i]] = status[i+1]
|
|
88
|
|
89 def save(self):
|
|
90 lock = self.repo.lock()
|
|
91
|
|
92 if not os.path.isdir(self.path):
|
|
93 os.mkdir(self.path)
|
|
94 fd = self.opener('status', 'wb')
|
|
95
|
|
96 out = [hex(n.node()) for n in self.parents]
|
|
97 out.append(str(len(self.conflicts)))
|
|
98 for f in sorted(self.conflicts):
|
|
99 out.append(f)
|
|
100 out.append(self.conflicts[f])
|
|
101 out.extend(self.resolved)
|
|
102
|
|
103 fd.write('\0'.join(out))
|
|
104
|
|
105 def remaining(self):
|
|
106 return [f for f in self.conflicts if f not in self.resolved]
|
|
107
|
|
108 def filemerge(self, fn):
|
|
109 wlock = self.repo.wlock()
|
|
110
|
|
111 fo = self.conflicts[fn]
|
|
112 return merge.filemerge(self.repo, fn, fo, self.parents[0],
|
|
113 self.parents[1])
|
|
114
|
|
115 def start(self, rev=None):
|
|
116 _filemerge = merge.filemerge
|
|
117 def filemerge(repo, fw, fo, wctx, mctx):
|
|
118 self.conflicts[fw] = fo
|
|
119
|
|
120 merge.filemerge = filemerge
|
|
121 commands.merge(self.ui, self.repo, rev=rev)
|
|
122 merge.filemerge = _filemerge
|
|
123
|
|
124 self.parents = [self.repo.changectx(n)
|
|
125 for n in self.repo.dirstate.parents()]
|
|
126 self.save()
|
|
127
|
|
128 def resume(self):
|
|
129 self.load()
|
|
130
|
|
131 dp = self.repo.dirstate.parents()
|
|
132 if self.parents[0].node() != dp[0] or self.parents[1].node() != dp[1]:
|
|
133 raise util.Abort('imerge state does not match working directory')
|
|
134
|
|
135 def status(self):
|
|
136 self.ui.write('merging %s and %s\n' % \
|
|
137 (short(self.parents[0].node()),
|
|
138 short(self.parents[1].node())))
|
|
139
|
|
140 if self.resolved:
|
|
141 self.ui.write('resolved:\n')
|
|
142 for fn in self.resolved:
|
|
143 self.ui.write(' %s\n' % fn)
|
|
144 remaining = [f for f in self.conflicts if f not in self.resolved]
|
|
145 if remaining:
|
|
146 self.ui.write('remaining:\n')
|
|
147 for fn in remaining:
|
|
148 fo = self.conflicts[fn]
|
|
149 if fn == fo:
|
|
150 self.ui.write(' %s\n' % (fn,))
|
|
151 else:
|
|
152 self.ui.write(' %s (%s)\n' % (fn, fo))
|
|
153 else:
|
|
154 self.ui.write('all conflicts resolved\n')
|
|
155
|
|
156 def next(self):
|
|
157 remaining = self.remaining()
|
|
158 return remaining and remaining[0]
|
|
159
|
|
160 def resolve(self, files):
|
|
161 resolved = dict.fromkeys(self.resolved)
|
|
162 for fn in files:
|
|
163 if fn not in self.conflicts:
|
|
164 raise util.Abort('%s is not in the merge set' % fn)
|
|
165 resolved[fn] = True
|
|
166 self.resolved = sorted(resolved)
|
|
167 self.save()
|
|
168 return 0
|
|
169
|
|
170 def unresolve(self, files):
|
|
171 resolved = dict.fromkeys(self.resolved)
|
|
172 for fn in files:
|
|
173 if fn not in resolved:
|
|
174 raise util.Abort('%s is not resolved' % fn)
|
|
175 del resolved[fn]
|
|
176 self.resolved = sorted(resolved)
|
|
177 self.save()
|
|
178 return 0
|
|
179
|
|
180 def pickle(self, dest):
|
|
181 '''write current merge state to file to be resumed elsewhere'''
|
|
182 state = ImergeStateFile(self)
|
|
183 return state.save(dest)
|
|
184
|
|
185 def unpickle(self, source):
|
|
186 '''read merge state from file'''
|
|
187 state = ImergeStateFile(self)
|
|
188 return state.load(source)
|
|
189
|
|
190 def load(im, source):
|
|
191 if im.merging():
|
|
192 raise util.Abort('there is already a merge in progress '
|
|
193 '(update -C <rev> to abort it)' )
|
|
194 m, a, r, d = im.repo.status()[:4]
|
|
195 if m or a or r or d:
|
|
196 raise util.Abort('working directory has uncommitted changes')
|
|
197
|
|
198 rc = im.unpickle(source)
|
|
199 if not rc:
|
|
200 im.status()
|
|
201 return rc
|
|
202
|
|
203 def merge_(im, filename=None):
|
|
204 if not filename:
|
|
205 filename = im.next()
|
|
206 if not filename:
|
|
207 im.ui.write('all conflicts resolved\n')
|
|
208 return 0
|
|
209
|
|
210 rc = im.filemerge(filename)
|
|
211 if not rc:
|
|
212 im.resolve([filename])
|
|
213 if not im.next():
|
|
214 im.ui.write('all conflicts resolved\n')
|
|
215 return 0
|
|
216 return rc
|
|
217
|
|
218 def next(im):
|
|
219 n = im.next()
|
|
220 if n:
|
|
221 im.ui.write('%s\n' % n)
|
|
222 else:
|
|
223 im.ui.write('all conflicts resolved\n')
|
|
224 return 0
|
|
225
|
|
226 def resolve(im, *files):
|
|
227 if not files:
|
|
228 raise util.Abort('resolve requires at least one filename')
|
|
229 return im.resolve(files)
|
|
230
|
|
231 def save(im, dest):
|
|
232 return im.pickle(dest)
|
|
233
|
|
234 def status(im):
|
|
235 im.status()
|
|
236 return 0
|
|
237
|
|
238 def unresolve(im, *files):
|
|
239 if not files:
|
|
240 raise util.Abort('unresolve requires at least one filename')
|
|
241 return im.unresolve(files)
|
|
242
|
|
243 subcmdtable = {
|
|
244 'load': load,
|
|
245 'merge': merge_,
|
|
246 'next': next,
|
|
247 'resolve': resolve,
|
|
248 'save': save,
|
|
249 'status': status,
|
|
250 'unresolve': unresolve
|
|
251 }
|
|
252
|
|
253 def dispatch(im, args, opts):
|
|
254 def complete(s, choices):
|
|
255 candidates = []
|
|
256 for choice in choices:
|
|
257 if choice.startswith(s):
|
|
258 candidates.append(choice)
|
|
259 return candidates
|
|
260
|
|
261 c, args = args[0], args[1:]
|
|
262 cmd = complete(c, subcmdtable.keys())
|
|
263 if not cmd:
|
|
264 raise cmdutil.UnknownCommand('imerge ' + c)
|
|
265 if len(cmd) > 1:
|
|
266 raise cmdutil.AmbiguousCommand('imerge ' + c, sorted(cmd))
|
|
267 cmd = cmd[0]
|
|
268
|
|
269 func = subcmdtable[cmd]
|
|
270 try:
|
|
271 return func(im, *args)
|
|
272 except TypeError:
|
|
273 raise cmdutil.ParseError('imerge', '%s: invalid arguments' % cmd)
|
|
274
|
|
275 def imerge(ui, repo, *args, **opts):
|
|
276 '''interactive merge
|
|
277
|
|
278 imerge lets you split a merge into pieces. When you start a merge
|
|
279 with imerge, the names of all files with conflicts are recorded.
|
|
280 You can then merge any of these files, and if the merge is
|
|
281 successful, they will be marked as resolved. When all files are
|
|
282 resolved, the merge is complete.
|
|
283
|
|
284 If no merge is in progress, hg imerge [rev] will merge the working
|
|
285 directory with rev (defaulting to the other head if the repository
|
|
286 only has two heads). You may also resume a saved merge with
|
|
287 hg imerge load <file>.
|
|
288
|
|
289 If a merge is in progress, hg imerge will default to merging the
|
|
290 next unresolved file.
|
|
291
|
|
292 The following subcommands are available:
|
|
293
|
|
294 status:
|
|
295 show the current state of the merge
|
|
296 next:
|
|
297 show the next unresolved file merge
|
|
298 merge [<file>]:
|
|
299 merge <file>. If the file merge is successful, the file will be
|
|
300 recorded as resolved. If no file is given, the next unresolved
|
|
301 file will be merged.
|
|
302 resolve <file>...:
|
|
303 mark files as successfully merged
|
|
304 unresolve <file>...:
|
|
305 mark files as requiring merging.
|
|
306 save <file>:
|
|
307 save the state of the merge to a file to be resumed elsewhere
|
|
308 load <file>:
|
|
309 load the state of the merge from a file created by save
|
|
310 '''
|
|
311
|
|
312 im = Imerge(ui, repo)
|
|
313
|
|
314 if im.merging():
|
|
315 im.resume()
|
|
316 else:
|
|
317 rev = opts.get('rev')
|
|
318 if rev and args:
|
|
319 raise util.Abort('please specify just one revision')
|
|
320
|
|
321 if len(args) == 2 and args[0] == 'load':
|
|
322 pass
|
|
323 else:
|
|
324 if args:
|
|
325 rev = args[0]
|
|
326 im.start(rev=rev)
|
|
327 args = ['status']
|
|
328
|
|
329 if not args:
|
|
330 args = ['merge']
|
|
331
|
|
332 return dispatch(im, args, opts)
|
|
333
|
|
334 cmdtable = {
|
|
335 '^imerge':
|
|
336 (imerge,
|
|
337 [('r', 'rev', '', _('revision to merge'))], 'hg imerge [command]')
|
|
338 }
|