|
3714
|
1 # Patch transplanting extension for Mercurial
|
|
|
2 #
|
|
|
3 # Copyright 2006 Brendan Cully <brendan@kublai.com>
|
|
|
4 #
|
|
|
5 # This software may be used and distributed according to the terms
|
|
|
6 # of the GNU General Public License, incorporated herein by reference.
|
|
|
7
|
|
|
8 from mercurial.demandload import *
|
|
|
9 from mercurial.i18n import gettext as _
|
|
|
10 demandload(globals(), 'os tempfile')
|
|
|
11 demandload(globals(), 'mercurial:bundlerepo,cmdutil,commands,hg,merge,patch')
|
|
|
12 demandload(globals(), 'mercurial:revlog,util')
|
|
|
13
|
|
|
14 '''patch transplanting tool
|
|
|
15
|
|
|
16 This extension allows you to transplant patches from another branch.
|
|
|
17
|
|
|
18 Transplanted patches are recorded in .hg/transplant/transplants, as a map
|
|
|
19 from a changeset hash to its hash in the source repository.
|
|
|
20 '''
|
|
|
21
|
|
|
22 class transplantentry:
|
|
|
23 def __init__(self, lnode, rnode):
|
|
|
24 self.lnode = lnode
|
|
|
25 self.rnode = rnode
|
|
|
26
|
|
|
27 class transplants:
|
|
|
28 def __init__(self, path=None, transplantfile=None, opener=None):
|
|
|
29 self.path = path
|
|
|
30 self.transplantfile = transplantfile
|
|
|
31 self.opener = opener
|
|
|
32
|
|
|
33 if not opener:
|
|
|
34 self.opener = util.opener(self.path)
|
|
|
35 self.transplants = []
|
|
|
36 self.dirty = False
|
|
|
37 self.read()
|
|
|
38
|
|
|
39 def read(self):
|
|
|
40 abspath = os.path.join(self.path, self.transplantfile)
|
|
|
41 if self.transplantfile and os.path.exists(abspath):
|
|
|
42 for line in self.opener(self.transplantfile).read().splitlines():
|
|
|
43 lnode, rnode = map(revlog.bin, line.split(':'))
|
|
|
44 self.transplants.append(transplantentry(lnode, rnode))
|
|
|
45
|
|
|
46 def write(self):
|
|
|
47 if self.dirty and self.transplantfile:
|
|
|
48 if not os.path.isdir(self.path):
|
|
|
49 os.mkdir(self.path)
|
|
|
50 fp = self.opener(self.transplantfile, 'w')
|
|
|
51 for c in self.transplants:
|
|
|
52 l, r = map(revlog.hex, (c.lnode, c.rnode))
|
|
|
53 fp.write(l + ':' + r + '\n')
|
|
|
54 fp.close()
|
|
|
55 self.dirty = False
|
|
|
56
|
|
|
57 def get(self, rnode):
|
|
|
58 return [t for t in self.transplants if t.rnode == rnode]
|
|
|
59
|
|
|
60 def set(self, lnode, rnode):
|
|
|
61 self.transplants.append(transplantentry(lnode, rnode))
|
|
|
62 self.dirty = True
|
|
|
63
|
|
|
64 def remove(self, transplant):
|
|
|
65 del self.transplants[self.transplants.index(transplant)]
|
|
|
66 self.dirty = True
|
|
|
67
|
|
|
68 class transplanter:
|
|
|
69 def __init__(self, ui, repo):
|
|
|
70 self.ui = ui
|
|
|
71 self.path = repo.join('transplant')
|
|
|
72 self.opener = util.opener(self.path)
|
|
|
73 self.transplants = transplants(self.path, 'transplants', opener=self.opener)
|
|
|
74
|
|
|
75 def applied(self, repo, node, parent):
|
|
|
76 '''returns True if a node is already an ancestor of parent
|
|
|
77 or has already been transplanted'''
|
|
|
78 if hasnode(repo, node):
|
|
|
79 if node in repo.changelog.reachable(parent, stop=node):
|
|
|
80 return True
|
|
|
81 for t in self.transplants.get(node):
|
|
|
82 # it might have been stripped
|
|
|
83 if not hasnode(repo, t.lnode):
|
|
|
84 self.transplants.remove(t)
|
|
|
85 return False
|
|
|
86 if t.lnode in repo.changelog.reachable(parent, stop=t.lnode):
|
|
|
87 return True
|
|
|
88 return False
|
|
|
89
|
|
|
90 def apply(self, repo, source, revmap, merges, opts={}):
|
|
|
91 '''apply the revisions in revmap one by one in revision order'''
|
|
|
92 revs = revmap.keys()
|
|
|
93 revs.sort()
|
|
|
94
|
|
|
95 p1, p2 = repo.dirstate.parents()
|
|
|
96 pulls = []
|
|
|
97 diffopts = patch.diffopts(self.ui, opts)
|
|
|
98 diffopts.git = True
|
|
|
99
|
|
|
100 lock = repo.lock()
|
|
|
101 wlock = repo.wlock()
|
|
|
102 try:
|
|
|
103 for rev in revs:
|
|
|
104 node = revmap[rev]
|
|
|
105 revstr = '%s:%s' % (rev, revlog.short(node))
|
|
|
106
|
|
|
107 if self.applied(repo, node, p1):
|
|
|
108 self.ui.warn(_('skipping already applied revision %s\n') %
|
|
|
109 revstr)
|
|
|
110 continue
|
|
|
111
|
|
|
112 parents = source.changelog.parents(node)
|
|
|
113 if not opts.get('filter'):
|
|
|
114 # If the changeset parent is the same as the wdir's parent,
|
|
|
115 # just pull it.
|
|
|
116 if parents[0] == p1:
|
|
|
117 pulls.append(node)
|
|
|
118 p1 = node
|
|
|
119 continue
|
|
|
120 if pulls:
|
|
|
121 if source != repo:
|
|
|
122 repo.pull(source, heads=pulls, lock=lock)
|
|
|
123 merge.update(repo, pulls[-1], wlock=wlock)
|
|
|
124 p1, p2 = repo.dirstate.parents()
|
|
|
125 pulls = []
|
|
|
126
|
|
|
127 domerge = False
|
|
|
128 if node in merges:
|
|
|
129 # pulling all the merge revs at once would mean we couldn't
|
|
|
130 # transplant after the latest even if transplants before them
|
|
|
131 # fail.
|
|
|
132 domerge = True
|
|
|
133 if not hasnode(repo, node):
|
|
|
134 repo.pull(source, heads=[node], lock=lock)
|
|
|
135
|
|
|
136 if parents[1] != revlog.nullid:
|
|
|
137 self.ui.note(_('skipping merge changeset %s:%s\n')
|
|
|
138 % (rev, revlog.short(node)))
|
|
|
139 patchfile = None
|
|
|
140 else:
|
|
|
141 fd, patchfile = tempfile.mkstemp(prefix='hg-transplant-')
|
|
|
142 fp = os.fdopen(fd, 'w')
|
|
|
143 patch.export(source, [node], fp=fp, opts=diffopts)
|
|
|
144 fp.close()
|
|
|
145
|
|
|
146 del revmap[rev]
|
|
|
147 if patchfile or domerge:
|
|
|
148 try:
|
|
|
149 n = self.applyone(repo, node, source.changelog.read(node),
|
|
|
150 patchfile, merge=domerge,
|
|
|
151 log=opts.get('log'),
|
|
|
152 filter=opts.get('filter'),
|
|
|
153 lock=lock, wlock=wlock)
|
|
|
154 if domerge:
|
|
|
155 self.ui.status(_('%s merged at %s\n') % (revstr,
|
|
|
156 revlog.short(n)))
|
|
|
157 else:
|
|
|
158 self.ui.status(_('%s transplanted to %s\n') % (revlog.short(node),
|
|
|
159 revlog.short(n)))
|
|
|
160 finally:
|
|
|
161 if patchfile:
|
|
|
162 os.unlink(patchfile)
|
|
|
163 if pulls:
|
|
|
164 repo.pull(source, heads=pulls, lock=lock)
|
|
|
165 merge.update(repo, pulls[-1], wlock=wlock)
|
|
|
166 finally:
|
|
|
167 self.saveseries(revmap, merges)
|
|
|
168 self.transplants.write()
|
|
|
169
|
|
|
170 def filter(self, filter, changelog, patchfile):
|
|
|
171 '''arbitrarily rewrite changeset before applying it'''
|
|
|
172
|
|
|
173 self.ui.status('filtering %s' % patchfile)
|
|
|
174 util.system('%s %s' % (filter, util.shellquote(patchfile)),
|
|
|
175 environ={'HGUSER': changelog[1]},
|
|
|
176 onerr=util.Abort, errprefix=_('filter failed'))
|
|
|
177
|
|
|
178 def applyone(self, repo, node, cl, patchfile, merge=False, log=False,
|
|
|
179 filter=None, lock=None, wlock=None):
|
|
|
180 '''apply the patch in patchfile to the repository as a transplant'''
|
|
|
181 (manifest, user, (time, timezone), files, message) = cl[:5]
|
|
|
182 date = "%d %d" % (time, timezone)
|
|
|
183 extra = {'transplant_source': node}
|
|
|
184 if filter:
|
|
|
185 self.filter(filter, cl, patchfile)
|
|
|
186 patchfile, message, user, date = patch.extract(self.ui, file(patchfile))
|
|
|
187
|
|
|
188 if log:
|
|
|
189 message += '\n(transplanted from %s)' % revlog.hex(node)
|
|
|
190 cl = list(cl)
|
|
|
191 cl[4] = message
|
|
|
192
|
|
|
193 self.ui.status(_('applying %s\n') % revlog.short(node))
|
|
|
194 self.ui.note('%s %s\n%s\n' % (user, date, message))
|
|
|
195
|
|
|
196 if not patchfile and not merge:
|
|
|
197 raise util.Abort(_('can only omit patchfile if merging'))
|
|
|
198 if patchfile:
|
|
|
199 try:
|
|
|
200 files = {}
|
|
|
201 fuzz = patch.patch(patchfile, self.ui, cwd=repo.root,
|
|
|
202 files=files)
|
|
|
203 if not files:
|
|
|
204 self.ui.warn(_('%s: empty changeset') % revlog.hex(node))
|
|
|
205 return
|
|
|
206 files = patch.updatedir(self.ui, repo, files, wlock=wlock)
|
|
|
207 if filter:
|
|
|
208 os.unlink(patchfile)
|
|
|
209 except Exception, inst:
|
|
|
210 if filter:
|
|
|
211 os.unlink(patchfile)
|
|
|
212 p1 = repo.dirstate.parents()[0]
|
|
|
213 p2 = node
|
|
|
214 self.log(cl, p1, p2, merge=merge)
|
|
|
215 self.ui.write(str(inst) + '\n')
|
|
|
216 raise util.Abort(_('Fix up the merge and run hg transplant --continue'))
|
|
|
217 else:
|
|
|
218 files = None
|
|
|
219 if merge:
|
|
|
220 p1, p2 = repo.dirstate.parents()
|
|
|
221 repo.dirstate.setparents(p1, node)
|
|
|
222
|
|
|
223 n = repo.commit(files, message, user, date, lock=lock, wlock=wlock,
|
|
|
224 extra=extra)
|
|
|
225 if not merge:
|
|
|
226 self.transplants.set(n, node)
|
|
|
227
|
|
|
228 return n
|
|
|
229
|
|
|
230 def resume(self, repo, source, opts=None):
|
|
|
231 '''recover last transaction and apply remaining changesets'''
|
|
|
232 if os.path.exists(os.path.join(self.path, 'journal')):
|
|
|
233 n, node = self.recover(repo)
|
|
|
234 self.ui.status(_('%s transplanted as %s\n') % (revlog.short(node),
|
|
|
235 revlog.short(n)))
|
|
|
236 seriespath = os.path.join(self.path, 'series')
|
|
|
237 if not os.path.exists(seriespath):
|
|
|
238 return
|
|
|
239 nodes, merges = self.readseries()
|
|
|
240 revmap = {}
|
|
|
241 for n in nodes:
|
|
|
242 revmap[source.changelog.rev(n)] = n
|
|
|
243 os.unlink(seriespath)
|
|
|
244
|
|
|
245 self.apply(repo, source, revmap, merges, opts)
|
|
|
246
|
|
|
247 def recover(self, repo):
|
|
|
248 '''commit working directory using journal metadata'''
|
|
|
249 node, user, date, message, parents = self.readlog()
|
|
|
250 merge = len(parents) == 2
|
|
|
251
|
|
|
252 if not user or not date or not message or not parents[0]:
|
|
|
253 raise util.Abort(_('transplant log file is corrupt'))
|
|
|
254
|
|
|
255 wlock = repo.wlock()
|
|
|
256 p1, p2 = repo.dirstate.parents()
|
|
|
257 if p1 != parents[0]:
|
|
|
258 raise util.Abort(_('working dir not at transplant parent %s') %
|
|
|
259 revlog.hex(parents[0]))
|
|
|
260 if merge:
|
|
|
261 repo.dirstate.setparents(p1, parents[1])
|
|
|
262 n = repo.commit(None, message, user, date, wlock=wlock)
|
|
|
263 if not n:
|
|
|
264 raise util.Abort(_('commit failed'))
|
|
|
265 if not merge:
|
|
|
266 self.transplants.set(n, node)
|
|
|
267 self.unlog()
|
|
|
268
|
|
|
269 return n, node
|
|
|
270
|
|
|
271 def readseries(self):
|
|
|
272 nodes = []
|
|
|
273 merges = []
|
|
|
274 cur = nodes
|
|
|
275 for line in self.opener('series').read().splitlines():
|
|
|
276 if line.startswith('# Merges'):
|
|
|
277 cur = merges
|
|
|
278 continue
|
|
|
279 cur.append(revlog.bin(line))
|
|
|
280
|
|
|
281 return (nodes, merges)
|
|
|
282
|
|
|
283 def saveseries(self, revmap, merges):
|
|
|
284 if not revmap:
|
|
|
285 return
|
|
|
286
|
|
|
287 if not os.path.isdir(self.path):
|
|
|
288 os.mkdir(self.path)
|
|
|
289 series = self.opener('series', 'w')
|
|
|
290 revs = revmap.keys()
|
|
|
291 revs.sort()
|
|
|
292 for rev in revs:
|
|
|
293 series.write(revlog.hex(revmap[rev]) + '\n')
|
|
|
294 if merges:
|
|
|
295 series.write('# Merges\n')
|
|
|
296 for m in merges:
|
|
|
297 series.write(revlog.hex(m) + '\n')
|
|
|
298 series.close()
|
|
|
299
|
|
|
300 def log(self, changelog, p1, p2, merge=False):
|
|
|
301 '''journal changelog metadata for later recover'''
|
|
|
302
|
|
|
303 if not os.path.isdir(self.path):
|
|
|
304 os.mkdir(self.path)
|
|
|
305 fp = self.opener('journal', 'w')
|
|
|
306 fp.write('# User %s\n' % changelog[1])
|
|
|
307 fp.write('# Date %d %d\n' % changelog[2])
|
|
|
308 fp.write('# Node ID %s\n' % revlog.hex(p2))
|
|
|
309 fp.write('# Parent ' + revlog.hex(p1) + '\n')
|
|
|
310 if merge:
|
|
|
311 fp.write('# Parent ' + revlog.hex(p2) + '\n')
|
|
|
312 fp.write(changelog[4].rstrip() + '\n')
|
|
|
313 fp.close()
|
|
|
314
|
|
|
315 def readlog(self):
|
|
|
316 parents = []
|
|
|
317 message = []
|
|
|
318 for line in self.opener('journal').read().splitlines():
|
|
|
319 if line.startswith('# User '):
|
|
|
320 user = line[7:]
|
|
|
321 elif line.startswith('# Date '):
|
|
|
322 date = line[7:]
|
|
|
323 elif line.startswith('# Node ID '):
|
|
|
324 node = revlog.bin(line[10:])
|
|
|
325 elif line.startswith('# Parent '):
|
|
|
326 parents.append(revlog.bin(line[9:]))
|
|
|
327 else:
|
|
|
328 message.append(line)
|
|
|
329 return (node, user, date, '\n'.join(message), parents)
|
|
|
330
|
|
|
331 def unlog(self):
|
|
|
332 '''remove changelog journal'''
|
|
|
333 absdst = os.path.join(self.path, 'journal')
|
|
|
334 if os.path.exists(absdst):
|
|
|
335 os.unlink(absdst)
|
|
|
336
|
|
|
337 def transplantfilter(self, repo, source, root):
|
|
|
338 def matchfn(node):
|
|
|
339 if self.applied(repo, node, root):
|
|
|
340 return False
|
|
|
341 if source.changelog.parents(node)[1] != revlog.nullid:
|
|
|
342 return False
|
|
|
343 extra = source.changelog.read(node)[5]
|
|
|
344 cnode = extra.get('transplant_source')
|
|
|
345 if cnode and self.applied(repo, cnode, root):
|
|
|
346 return False
|
|
|
347 return True
|
|
|
348
|
|
|
349 return matchfn
|
|
|
350
|
|
|
351 def hasnode(repo, node):
|
|
|
352 try:
|
|
|
353 return repo.changelog.rev(node) != None
|
|
|
354 except revlog.RevlogError:
|
|
|
355 return False
|
|
|
356
|
|
|
357 def browserevs(ui, repo, nodes, opts):
|
|
|
358 '''interactively transplant changesets'''
|
|
|
359 def browsehelp(ui):
|
|
|
360 ui.write('y: transplant this changeset\n'
|
|
|
361 'n: skip this changeset\n'
|
|
|
362 'm: merge at this changeset\n'
|
|
|
363 'p: show patch\n'
|
|
|
364 'c: commit selected changesets\n'
|
|
|
365 'q: cancel transplant\n'
|
|
|
366 '?: show this help\n')
|
|
|
367
|
|
|
368 displayer = commands.show_changeset(ui, repo, opts)
|
|
|
369 transplants = []
|
|
|
370 merges = []
|
|
|
371 for node in nodes:
|
|
|
372 displayer.show(changenode=node)
|
|
|
373 action = None
|
|
|
374 while not action:
|
|
|
375 action = ui.prompt(_('apply changeset? [ynmpcq?]:'))
|
|
|
376 if action == '?':
|
|
|
377 browsehelp(ui)
|
|
|
378 action = None
|
|
|
379 elif action == 'p':
|
|
|
380 parent = repo.changelog.parents(node)[0]
|
|
|
381 patch.diff(repo, parent, node)
|
|
|
382 action = None
|
|
|
383 elif action not in ('y', 'n', 'm', 'c', 'q'):
|
|
|
384 ui.write('no such option\n')
|
|
|
385 action = None
|
|
|
386 if action == 'y':
|
|
|
387 transplants.append(node)
|
|
|
388 elif action == 'm':
|
|
|
389 merges.append(node)
|
|
|
390 elif action == 'c':
|
|
|
391 break
|
|
|
392 elif action == 'q':
|
|
|
393 transplants = ()
|
|
|
394 merges = ()
|
|
|
395 break
|
|
|
396 return (transplants, merges)
|
|
|
397
|
|
|
398 def transplant(ui, repo, *revs, **opts):
|
|
|
399 '''transplant changesets from another branch
|
|
|
400
|
|
|
401 Selected changesets will be applied on top of the current working
|
|
|
402 directory with the log of the original changeset. If --log is
|
|
|
403 specified, log messages will have a comment appended of the form:
|
|
|
404
|
|
|
405 (transplanted from CHANGESETHASH)
|
|
|
406
|
|
|
407 You can rewrite the changelog message with the --filter option.
|
|
|
408 Its argument will be invoked with the current changelog message
|
|
|
409 as $1 and the patch as $2.
|
|
|
410
|
|
|
411 If --source is specified, selects changesets from the named
|
|
|
412 repository. If --branch is specified, selects changesets from the
|
|
|
413 branch holding the named revision, up to that revision. If --all
|
|
|
414 is specified, all changesets on the branch will be transplanted,
|
|
|
415 otherwise you will be prompted to select the changesets you want.
|
|
|
416
|
|
|
417 hg transplant --branch REVISION --all will rebase the selected branch
|
|
|
418 (up to the named revision) onto your current working directory.
|
|
|
419
|
|
|
420 You can optionally mark selected transplanted changesets as
|
|
|
421 merge changesets. You will not be prompted to transplant any
|
|
|
422 ancestors of a merged transplant, and you can merge descendants
|
|
|
423 of them normally instead of transplanting them.
|
|
|
424
|
|
|
425 If no merges or revisions are provided, hg transplant will start
|
|
|
426 an interactive changeset browser.
|
|
|
427
|
|
|
428 If a changeset application fails, you can fix the merge by hand and
|
|
|
429 then resume where you left off by calling hg transplant --continue.
|
|
|
430 '''
|
|
|
431 def getoneitem(opts, item, errmsg):
|
|
|
432 val = opts.get(item)
|
|
|
433 if val:
|
|
|
434 if len(val) > 1:
|
|
|
435 raise util.Abort(errmsg)
|
|
|
436 else:
|
|
|
437 return val[0]
|
|
|
438
|
|
|
439 def getremotechanges(repo, url):
|
|
|
440 sourcerepo = ui.expandpath(url)
|
|
|
441 source = hg.repository(ui, sourcerepo)
|
|
|
442 incoming = repo.findincoming(source, force=True)
|
|
|
443 if not incoming:
|
|
|
444 return (source, None, None)
|
|
|
445
|
|
|
446 bundle = None
|
|
|
447 if not source.local():
|
|
|
448 cg = source.changegroup(incoming, 'incoming')
|
|
|
449 bundle = commands.write_bundle(cg, compress=False)
|
|
|
450 source = bundlerepo.bundlerepository(ui, repo.root, bundle)
|
|
|
451
|
|
|
452 return (source, incoming, bundle)
|
|
|
453
|
|
|
454 def incwalk(repo, incoming, branches, match=util.always):
|
|
|
455 if not branches:
|
|
|
456 branches=None
|
|
|
457 for node in repo.changelog.nodesbetween(incoming, branches)[0]:
|
|
|
458 if match(node):
|
|
|
459 yield node
|
|
|
460
|
|
|
461 def transplantwalk(repo, root, branches, match=util.always):
|
|
|
462 if not branches:
|
|
|
463 branches = repo.heads()
|
|
|
464 ancestors = []
|
|
|
465 for branch in branches:
|
|
|
466 ancestors.append(repo.changelog.ancestor(root, branch))
|
|
|
467 for node in repo.changelog.nodesbetween(ancestors, branches)[0]:
|
|
|
468 if match(node):
|
|
|
469 yield node
|
|
|
470
|
|
|
471 def checkopts(opts, revs):
|
|
|
472 if opts.get('continue'):
|
|
|
473 if filter(lambda opt: opts.get(opt), ('branch', 'all', 'merge')):
|
|
|
474 raise util.Abort(_('--continue is incompatible with branch, all or merge'))
|
|
|
475 return
|
|
|
476 if not (opts.get('source') or revs or
|
|
|
477 opts.get('merge') or opts.get('branch')):
|
|
|
478 raise util.Abort(_('no source URL, branch tag or revision list provided'))
|
|
|
479 if opts.get('all'):
|
|
|
480 if not opts.get('branch'):
|
|
|
481 raise util.Abort(_('--all requires a branch revision'))
|
|
|
482 if revs:
|
|
|
483 raise util.Abort(_('--all is incompatible with a revision list'))
|
|
|
484
|
|
|
485 checkopts(opts, revs)
|
|
|
486
|
|
|
487 if not opts.get('log'):
|
|
|
488 opts['log'] = ui.config('transplant', 'log')
|
|
|
489 if not opts.get('filter'):
|
|
|
490 opts['filter'] = ui.config('transplant', 'filter')
|
|
|
491
|
|
|
492 tp = transplanter(ui, repo)
|
|
|
493
|
|
|
494 p1, p2 = repo.dirstate.parents()
|
|
|
495 if p1 == revlog.nullid:
|
|
|
496 raise util.Abort(_('no revision checked out'))
|
|
|
497 if not opts.get('continue'):
|
|
|
498 if p2 != revlog.nullid:
|
|
|
499 raise util.Abort(_('outstanding uncommitted merges'))
|
|
|
500 m, a, r, d = repo.status()[:4]
|
|
|
501 if m or a or r or d:
|
|
|
502 raise util.Abort(_('outstanding local changes'))
|
|
|
503
|
|
|
504 bundle = None
|
|
|
505 source = opts.get('source')
|
|
|
506 if source:
|
|
|
507 (source, incoming, bundle) = getremotechanges(repo, source)
|
|
|
508 else:
|
|
|
509 source = repo
|
|
|
510
|
|
|
511 try:
|
|
|
512 if opts.get('continue'):
|
|
|
513 n, node = tp.resume(repo, source, opts)
|
|
|
514 return
|
|
|
515
|
|
|
516 tf=tp.transplantfilter(repo, source, p1)
|
|
|
517 if opts.get('prune'):
|
|
|
518 prune = [source.lookup(r)
|
|
|
519 for r in cmdutil.revrange(source, opts.get('prune'))]
|
|
|
520 matchfn = lambda x: tf(x) and x not in prune
|
|
|
521 else:
|
|
|
522 matchfn = tf
|
|
|
523 branches = map(source.lookup, opts.get('branch', ()))
|
|
|
524 merges = map(source.lookup, opts.get('merge', ()))
|
|
|
525 revmap = {}
|
|
|
526 if revs:
|
|
|
527 for r in cmdutil.revrange(source, revs):
|
|
|
528 revmap[int(r)] = source.lookup(r)
|
|
|
529 elif opts.get('all') or not merges:
|
|
|
530 if source != repo:
|
|
|
531 alltransplants = incwalk(source, incoming, branches, match=matchfn)
|
|
|
532 else:
|
|
|
533 alltransplants = transplantwalk(source, p1, branches, match=matchfn)
|
|
|
534 if opts.get('all'):
|
|
|
535 revs = alltransplants
|
|
|
536 else:
|
|
|
537 revs, newmerges = browserevs(ui, source, alltransplants, opts)
|
|
|
538 merges.extend(newmerges)
|
|
|
539 for r in revs:
|
|
|
540 revmap[source.changelog.rev(r)] = r
|
|
|
541 for r in merges:
|
|
|
542 revmap[source.changelog.rev(r)] = r
|
|
|
543
|
|
|
544 revs = revmap.keys()
|
|
|
545 revs.sort()
|
|
|
546 pulls = []
|
|
|
547
|
|
|
548 tp.apply(repo, source, revmap, merges, opts)
|
|
|
549 finally:
|
|
|
550 if bundle:
|
|
|
551 os.unlink(bundle)
|
|
|
552
|
|
|
553 cmdtable = {
|
|
|
554 "transplant":
|
|
|
555 (transplant,
|
|
|
556 [('s', 'source', '', _('pull patches from REPOSITORY')),
|
|
|
557 ('b', 'branch', [], _('pull patches from branch BRANCH')),
|
|
|
558 ('a', 'all', None, _('pull all changesets up to BRANCH')),
|
|
|
559 ('p', 'prune', [], _('skip over REV')),
|
|
|
560 ('m', 'merge', [], _('merge at REV')),
|
|
|
561 ('', 'log', None, _('append transplant info to log message')),
|
|
|
562 ('c', 'continue', None, _('continue last transplant session after repair')),
|
|
|
563 ('', 'filter', '', _('filter changesets through FILTER'))],
|
|
|
564 _('hg transplant [-s REPOSITORY] [-b BRANCH] [-p REV] [-m REV] [-n] REV...'))
|
|
|
565 }
|
