##// END OF EJS Templates
histedit: extract a simpler function to process replacement on abort...
Pierre-Yves David -
r25898:4dcc9b5d default
parent child Browse files
Show More
@@ -1,1161 +1,1180 b''
1 # histedit.py - interactive history editing for mercurial
1 # histedit.py - interactive history editing for mercurial
2 #
2 #
3 # Copyright 2009 Augie Fackler <raf@durin42.com>
3 # Copyright 2009 Augie Fackler <raf@durin42.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 """interactive history editing
7 """interactive history editing
8
8
9 With this extension installed, Mercurial gains one new command: histedit. Usage
9 With this extension installed, Mercurial gains one new command: histedit. Usage
10 is as follows, assuming the following history::
10 is as follows, assuming the following history::
11
11
12 @ 3[tip] 7c2fd3b9020c 2009-04-27 18:04 -0500 durin42
12 @ 3[tip] 7c2fd3b9020c 2009-04-27 18:04 -0500 durin42
13 | Add delta
13 | Add delta
14 |
14 |
15 o 2 030b686bedc4 2009-04-27 18:04 -0500 durin42
15 o 2 030b686bedc4 2009-04-27 18:04 -0500 durin42
16 | Add gamma
16 | Add gamma
17 |
17 |
18 o 1 c561b4e977df 2009-04-27 18:04 -0500 durin42
18 o 1 c561b4e977df 2009-04-27 18:04 -0500 durin42
19 | Add beta
19 | Add beta
20 |
20 |
21 o 0 d8d2fcd0e319 2009-04-27 18:04 -0500 durin42
21 o 0 d8d2fcd0e319 2009-04-27 18:04 -0500 durin42
22 Add alpha
22 Add alpha
23
23
24 If you were to run ``hg histedit c561b4e977df``, you would see the following
24 If you were to run ``hg histedit c561b4e977df``, you would see the following
25 file open in your editor::
25 file open in your editor::
26
26
27 pick c561b4e977df Add beta
27 pick c561b4e977df Add beta
28 pick 030b686bedc4 Add gamma
28 pick 030b686bedc4 Add gamma
29 pick 7c2fd3b9020c Add delta
29 pick 7c2fd3b9020c Add delta
30
30
31 # Edit history between c561b4e977df and 7c2fd3b9020c
31 # Edit history between c561b4e977df and 7c2fd3b9020c
32 #
32 #
33 # Commits are listed from least to most recent
33 # Commits are listed from least to most recent
34 #
34 #
35 # Commands:
35 # Commands:
36 # p, pick = use commit
36 # p, pick = use commit
37 # e, edit = use commit, but stop for amending
37 # e, edit = use commit, but stop for amending
38 # f, fold = use commit, but combine it with the one above
38 # f, fold = use commit, but combine it with the one above
39 # r, roll = like fold, but discard this commit's description
39 # r, roll = like fold, but discard this commit's description
40 # d, drop = remove commit from history
40 # d, drop = remove commit from history
41 # m, mess = edit message without changing commit content
41 # m, mess = edit message without changing commit content
42 #
42 #
43
43
44 In this file, lines beginning with ``#`` are ignored. You must specify a rule
44 In this file, lines beginning with ``#`` are ignored. You must specify a rule
45 for each revision in your history. For example, if you had meant to add gamma
45 for each revision in your history. For example, if you had meant to add gamma
46 before beta, and then wanted to add delta in the same revision as beta, you
46 before beta, and then wanted to add delta in the same revision as beta, you
47 would reorganize the file to look like this::
47 would reorganize the file to look like this::
48
48
49 pick 030b686bedc4 Add gamma
49 pick 030b686bedc4 Add gamma
50 pick c561b4e977df Add beta
50 pick c561b4e977df Add beta
51 fold 7c2fd3b9020c Add delta
51 fold 7c2fd3b9020c Add delta
52
52
53 # Edit history between c561b4e977df and 7c2fd3b9020c
53 # Edit history between c561b4e977df and 7c2fd3b9020c
54 #
54 #
55 # Commits are listed from least to most recent
55 # Commits are listed from least to most recent
56 #
56 #
57 # Commands:
57 # Commands:
58 # p, pick = use commit
58 # p, pick = use commit
59 # e, edit = use commit, but stop for amending
59 # e, edit = use commit, but stop for amending
60 # f, fold = use commit, but combine it with the one above
60 # f, fold = use commit, but combine it with the one above
61 # r, roll = like fold, but discard this commit's description
61 # r, roll = like fold, but discard this commit's description
62 # d, drop = remove commit from history
62 # d, drop = remove commit from history
63 # m, mess = edit message without changing commit content
63 # m, mess = edit message without changing commit content
64 #
64 #
65
65
66 At which point you close the editor and ``histedit`` starts working. When you
66 At which point you close the editor and ``histedit`` starts working. When you
67 specify a ``fold`` operation, ``histedit`` will open an editor when it folds
67 specify a ``fold`` operation, ``histedit`` will open an editor when it folds
68 those revisions together, offering you a chance to clean up the commit message::
68 those revisions together, offering you a chance to clean up the commit message::
69
69
70 Add beta
70 Add beta
71 ***
71 ***
72 Add delta
72 Add delta
73
73
74 Edit the commit message to your liking, then close the editor. For
74 Edit the commit message to your liking, then close the editor. For
75 this example, let's assume that the commit message was changed to
75 this example, let's assume that the commit message was changed to
76 ``Add beta and delta.`` After histedit has run and had a chance to
76 ``Add beta and delta.`` After histedit has run and had a chance to
77 remove any old or temporary revisions it needed, the history looks
77 remove any old or temporary revisions it needed, the history looks
78 like this::
78 like this::
79
79
80 @ 2[tip] 989b4d060121 2009-04-27 18:04 -0500 durin42
80 @ 2[tip] 989b4d060121 2009-04-27 18:04 -0500 durin42
81 | Add beta and delta.
81 | Add beta and delta.
82 |
82 |
83 o 1 081603921c3f 2009-04-27 18:04 -0500 durin42
83 o 1 081603921c3f 2009-04-27 18:04 -0500 durin42
84 | Add gamma
84 | Add gamma
85 |
85 |
86 o 0 d8d2fcd0e319 2009-04-27 18:04 -0500 durin42
86 o 0 d8d2fcd0e319 2009-04-27 18:04 -0500 durin42
87 Add alpha
87 Add alpha
88
88
89 Note that ``histedit`` does *not* remove any revisions (even its own temporary
89 Note that ``histedit`` does *not* remove any revisions (even its own temporary
90 ones) until after it has completed all the editing operations, so it will
90 ones) until after it has completed all the editing operations, so it will
91 probably perform several strip operations when it's done. For the above example,
91 probably perform several strip operations when it's done. For the above example,
92 it had to run strip twice. Strip can be slow depending on a variety of factors,
92 it had to run strip twice. Strip can be slow depending on a variety of factors,
93 so you might need to be a little patient. You can choose to keep the original
93 so you might need to be a little patient. You can choose to keep the original
94 revisions by passing the ``--keep`` flag.
94 revisions by passing the ``--keep`` flag.
95
95
96 The ``edit`` operation will drop you back to a command prompt,
96 The ``edit`` operation will drop you back to a command prompt,
97 allowing you to edit files freely, or even use ``hg record`` to commit
97 allowing you to edit files freely, or even use ``hg record`` to commit
98 some changes as a separate commit. When you're done, any remaining
98 some changes as a separate commit. When you're done, any remaining
99 uncommitted changes will be committed as well. When done, run ``hg
99 uncommitted changes will be committed as well. When done, run ``hg
100 histedit --continue`` to finish this step. You'll be prompted for a
100 histedit --continue`` to finish this step. You'll be prompted for a
101 new commit message, but the default commit message will be the
101 new commit message, but the default commit message will be the
102 original message for the ``edit`` ed revision.
102 original message for the ``edit`` ed revision.
103
103
104 The ``message`` operation will give you a chance to revise a commit
104 The ``message`` operation will give you a chance to revise a commit
105 message without changing the contents. It's a shortcut for doing
105 message without changing the contents. It's a shortcut for doing
106 ``edit`` immediately followed by `hg histedit --continue``.
106 ``edit`` immediately followed by `hg histedit --continue``.
107
107
108 If ``histedit`` encounters a conflict when moving a revision (while
108 If ``histedit`` encounters a conflict when moving a revision (while
109 handling ``pick`` or ``fold``), it'll stop in a similar manner to
109 handling ``pick`` or ``fold``), it'll stop in a similar manner to
110 ``edit`` with the difference that it won't prompt you for a commit
110 ``edit`` with the difference that it won't prompt you for a commit
111 message when done. If you decide at this point that you don't like how
111 message when done. If you decide at this point that you don't like how
112 much work it will be to rearrange history, or that you made a mistake,
112 much work it will be to rearrange history, or that you made a mistake,
113 you can use ``hg histedit --abort`` to abandon the new changes you
113 you can use ``hg histedit --abort`` to abandon the new changes you
114 have made and return to the state before you attempted to edit your
114 have made and return to the state before you attempted to edit your
115 history.
115 history.
116
116
117 If we clone the histedit-ed example repository above and add four more
117 If we clone the histedit-ed example repository above and add four more
118 changes, such that we have the following history::
118 changes, such that we have the following history::
119
119
120 @ 6[tip] 038383181893 2009-04-27 18:04 -0500 stefan
120 @ 6[tip] 038383181893 2009-04-27 18:04 -0500 stefan
121 | Add theta
121 | Add theta
122 |
122 |
123 o 5 140988835471 2009-04-27 18:04 -0500 stefan
123 o 5 140988835471 2009-04-27 18:04 -0500 stefan
124 | Add eta
124 | Add eta
125 |
125 |
126 o 4 122930637314 2009-04-27 18:04 -0500 stefan
126 o 4 122930637314 2009-04-27 18:04 -0500 stefan
127 | Add zeta
127 | Add zeta
128 |
128 |
129 o 3 836302820282 2009-04-27 18:04 -0500 stefan
129 o 3 836302820282 2009-04-27 18:04 -0500 stefan
130 | Add epsilon
130 | Add epsilon
131 |
131 |
132 o 2 989b4d060121 2009-04-27 18:04 -0500 durin42
132 o 2 989b4d060121 2009-04-27 18:04 -0500 durin42
133 | Add beta and delta.
133 | Add beta and delta.
134 |
134 |
135 o 1 081603921c3f 2009-04-27 18:04 -0500 durin42
135 o 1 081603921c3f 2009-04-27 18:04 -0500 durin42
136 | Add gamma
136 | Add gamma
137 |
137 |
138 o 0 d8d2fcd0e319 2009-04-27 18:04 -0500 durin42
138 o 0 d8d2fcd0e319 2009-04-27 18:04 -0500 durin42
139 Add alpha
139 Add alpha
140
140
141 If you run ``hg histedit --outgoing`` on the clone then it is the same
141 If you run ``hg histedit --outgoing`` on the clone then it is the same
142 as running ``hg histedit 836302820282``. If you need plan to push to a
142 as running ``hg histedit 836302820282``. If you need plan to push to a
143 repository that Mercurial does not detect to be related to the source
143 repository that Mercurial does not detect to be related to the source
144 repo, you can add a ``--force`` option.
144 repo, you can add a ``--force`` option.
145
145
146 Histedit rule lines are truncated to 80 characters by default. You
146 Histedit rule lines are truncated to 80 characters by default. You
147 can customise this behaviour by setting a different length in your
147 can customise this behaviour by setting a different length in your
148 configuration file::
148 configuration file::
149
149
150 [histedit]
150 [histedit]
151 linelen = 120 # truncate rule lines at 120 characters
151 linelen = 120 # truncate rule lines at 120 characters
152 """
152 """
153
153
154 try:
154 try:
155 import cPickle as pickle
155 import cPickle as pickle
156 pickle.dump # import now
156 pickle.dump # import now
157 except ImportError:
157 except ImportError:
158 import pickle
158 import pickle
159 import errno
159 import errno
160 import os
160 import os
161 import sys
161 import sys
162
162
163 from mercurial import cmdutil
163 from mercurial import cmdutil
164 from mercurial import discovery
164 from mercurial import discovery
165 from mercurial import error
165 from mercurial import error
166 from mercurial import changegroup
166 from mercurial import changegroup
167 from mercurial import copies
167 from mercurial import copies
168 from mercurial import context
168 from mercurial import context
169 from mercurial import exchange
169 from mercurial import exchange
170 from mercurial import extensions
170 from mercurial import extensions
171 from mercurial import hg
171 from mercurial import hg
172 from mercurial import node
172 from mercurial import node
173 from mercurial import repair
173 from mercurial import repair
174 from mercurial import scmutil
174 from mercurial import scmutil
175 from mercurial import util
175 from mercurial import util
176 from mercurial import obsolete
176 from mercurial import obsolete
177 from mercurial import merge as mergemod
177 from mercurial import merge as mergemod
178 from mercurial.lock import release
178 from mercurial.lock import release
179 from mercurial.i18n import _
179 from mercurial.i18n import _
180
180
181 cmdtable = {}
181 cmdtable = {}
182 command = cmdutil.command(cmdtable)
182 command = cmdutil.command(cmdtable)
183
183
184 # Note for extension authors: ONLY specify testedwith = 'internal' for
184 # Note for extension authors: ONLY specify testedwith = 'internal' for
185 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
185 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
186 # be specifying the version(s) of Mercurial they are tested with, or
186 # be specifying the version(s) of Mercurial they are tested with, or
187 # leave the attribute unspecified.
187 # leave the attribute unspecified.
188 testedwith = 'internal'
188 testedwith = 'internal'
189
189
190 # i18n: command names and abbreviations must remain untranslated
190 # i18n: command names and abbreviations must remain untranslated
191 editcomment = _("""# Edit history between %s and %s
191 editcomment = _("""# Edit history between %s and %s
192 #
192 #
193 # Commits are listed from least to most recent
193 # Commits are listed from least to most recent
194 #
194 #
195 # Commands:
195 # Commands:
196 # p, pick = use commit
196 # p, pick = use commit
197 # e, edit = use commit, but stop for amending
197 # e, edit = use commit, but stop for amending
198 # f, fold = use commit, but combine it with the one above
198 # f, fold = use commit, but combine it with the one above
199 # r, roll = like fold, but discard this commit's description
199 # r, roll = like fold, but discard this commit's description
200 # d, drop = remove commit from history
200 # d, drop = remove commit from history
201 # m, mess = edit message without changing commit content
201 # m, mess = edit message without changing commit content
202 #
202 #
203 """)
203 """)
204
204
205 class histeditstate(object):
205 class histeditstate(object):
206 def __init__(self, repo, parentctxnode=None, rules=None, keep=None,
206 def __init__(self, repo, parentctxnode=None, rules=None, keep=None,
207 topmost=None, replacements=None, lock=None, wlock=None):
207 topmost=None, replacements=None, lock=None, wlock=None):
208 self.repo = repo
208 self.repo = repo
209 self.rules = rules
209 self.rules = rules
210 self.keep = keep
210 self.keep = keep
211 self.topmost = topmost
211 self.topmost = topmost
212 self.parentctxnode = parentctxnode
212 self.parentctxnode = parentctxnode
213 self.lock = lock
213 self.lock = lock
214 self.wlock = wlock
214 self.wlock = wlock
215 self.backupfile = None
215 self.backupfile = None
216 if replacements is None:
216 if replacements is None:
217 self.replacements = []
217 self.replacements = []
218 else:
218 else:
219 self.replacements = replacements
219 self.replacements = replacements
220
220
221 def read(self):
221 def read(self):
222 """Load histedit state from disk and set fields appropriately."""
222 """Load histedit state from disk and set fields appropriately."""
223 try:
223 try:
224 fp = self.repo.vfs('histedit-state', 'r')
224 fp = self.repo.vfs('histedit-state', 'r')
225 except IOError as err:
225 except IOError as err:
226 if err.errno != errno.ENOENT:
226 if err.errno != errno.ENOENT:
227 raise
227 raise
228 raise util.Abort(_('no histedit in progress'))
228 raise util.Abort(_('no histedit in progress'))
229
229
230 try:
230 try:
231 data = pickle.load(fp)
231 data = pickle.load(fp)
232 parentctxnode, rules, keep, topmost, replacements = data
232 parentctxnode, rules, keep, topmost, replacements = data
233 backupfile = None
233 backupfile = None
234 except pickle.UnpicklingError:
234 except pickle.UnpicklingError:
235 data = self._load()
235 data = self._load()
236 parentctxnode, rules, keep, topmost, replacements, backupfile = data
236 parentctxnode, rules, keep, topmost, replacements, backupfile = data
237
237
238 self.parentctxnode = parentctxnode
238 self.parentctxnode = parentctxnode
239 self.rules = rules
239 self.rules = rules
240 self.keep = keep
240 self.keep = keep
241 self.topmost = topmost
241 self.topmost = topmost
242 self.replacements = replacements
242 self.replacements = replacements
243 self.backupfile = backupfile
243 self.backupfile = backupfile
244
244
245 def write(self):
245 def write(self):
246 fp = self.repo.vfs('histedit-state', 'w')
246 fp = self.repo.vfs('histedit-state', 'w')
247 fp.write('v1\n')
247 fp.write('v1\n')
248 fp.write('%s\n' % node.hex(self.parentctxnode))
248 fp.write('%s\n' % node.hex(self.parentctxnode))
249 fp.write('%s\n' % node.hex(self.topmost))
249 fp.write('%s\n' % node.hex(self.topmost))
250 fp.write('%s\n' % self.keep)
250 fp.write('%s\n' % self.keep)
251 fp.write('%d\n' % len(self.rules))
251 fp.write('%d\n' % len(self.rules))
252 for rule in self.rules:
252 for rule in self.rules:
253 fp.write('%s\n' % rule[0]) # action
253 fp.write('%s\n' % rule[0]) # action
254 fp.write('%s\n' % rule[1]) # remainder
254 fp.write('%s\n' % rule[1]) # remainder
255 fp.write('%d\n' % len(self.replacements))
255 fp.write('%d\n' % len(self.replacements))
256 for replacement in self.replacements:
256 for replacement in self.replacements:
257 fp.write('%s%s\n' % (node.hex(replacement[0]), ''.join(node.hex(r)
257 fp.write('%s%s\n' % (node.hex(replacement[0]), ''.join(node.hex(r)
258 for r in replacement[1])))
258 for r in replacement[1])))
259 backupfile = self.backupfile
259 backupfile = self.backupfile
260 if not backupfile:
260 if not backupfile:
261 backupfile = ''
261 backupfile = ''
262 fp.write('%s\n' % backupfile)
262 fp.write('%s\n' % backupfile)
263 fp.close()
263 fp.close()
264
264
265 def _load(self):
265 def _load(self):
266 fp = self.repo.vfs('histedit-state', 'r')
266 fp = self.repo.vfs('histedit-state', 'r')
267 lines = [l[:-1] for l in fp.readlines()]
267 lines = [l[:-1] for l in fp.readlines()]
268
268
269 index = 0
269 index = 0
270 lines[index] # version number
270 lines[index] # version number
271 index += 1
271 index += 1
272
272
273 parentctxnode = node.bin(lines[index])
273 parentctxnode = node.bin(lines[index])
274 index += 1
274 index += 1
275
275
276 topmost = node.bin(lines[index])
276 topmost = node.bin(lines[index])
277 index += 1
277 index += 1
278
278
279 keep = lines[index] == 'True'
279 keep = lines[index] == 'True'
280 index += 1
280 index += 1
281
281
282 # Rules
282 # Rules
283 rules = []
283 rules = []
284 rulelen = int(lines[index])
284 rulelen = int(lines[index])
285 index += 1
285 index += 1
286 for i in xrange(rulelen):
286 for i in xrange(rulelen):
287 ruleaction = lines[index]
287 ruleaction = lines[index]
288 index += 1
288 index += 1
289 rule = lines[index]
289 rule = lines[index]
290 index += 1
290 index += 1
291 rules.append((ruleaction, rule))
291 rules.append((ruleaction, rule))
292
292
293 # Replacements
293 # Replacements
294 replacements = []
294 replacements = []
295 replacementlen = int(lines[index])
295 replacementlen = int(lines[index])
296 index += 1
296 index += 1
297 for i in xrange(replacementlen):
297 for i in xrange(replacementlen):
298 replacement = lines[index]
298 replacement = lines[index]
299 original = node.bin(replacement[:40])
299 original = node.bin(replacement[:40])
300 succ = [node.bin(replacement[i:i + 40]) for i in
300 succ = [node.bin(replacement[i:i + 40]) for i in
301 range(40, len(replacement), 40)]
301 range(40, len(replacement), 40)]
302 replacements.append((original, succ))
302 replacements.append((original, succ))
303 index += 1
303 index += 1
304
304
305 backupfile = lines[index]
305 backupfile = lines[index]
306 index += 1
306 index += 1
307
307
308 fp.close()
308 fp.close()
309
309
310 return parentctxnode, rules, keep, topmost, replacements, backupfile
310 return parentctxnode, rules, keep, topmost, replacements, backupfile
311
311
312 def clear(self):
312 def clear(self):
313 self.repo.vfs.unlink('histedit-state')
313 self.repo.vfs.unlink('histedit-state')
314
314
315 class histeditaction(object):
315 class histeditaction(object):
316 def __init__(self, state, node):
316 def __init__(self, state, node):
317 self.state = state
317 self.state = state
318 self.repo = state.repo
318 self.repo = state.repo
319 self.node = node
319 self.node = node
320
320
321 @classmethod
321 @classmethod
322 def fromrule(cls, state, rule):
322 def fromrule(cls, state, rule):
323 """Parses the given rule, returning an instance of the histeditaction.
323 """Parses the given rule, returning an instance of the histeditaction.
324 """
324 """
325 repo = state.repo
325 repo = state.repo
326 rulehash = rule.strip().split(' ', 1)[0]
326 rulehash = rule.strip().split(' ', 1)[0]
327 try:
327 try:
328 node = repo[rulehash].node()
328 node = repo[rulehash].node()
329 except error.RepoError:
329 except error.RepoError:
330 raise util.Abort(_('unknown changeset %s listed') % rulehash[:12])
330 raise util.Abort(_('unknown changeset %s listed') % rulehash[:12])
331 return cls(state, node)
331 return cls(state, node)
332
332
333 def run(self):
333 def run(self):
334 """Runs the action. The default behavior is simply apply the action's
334 """Runs the action. The default behavior is simply apply the action's
335 rulectx onto the current parentctx."""
335 rulectx onto the current parentctx."""
336 self.applychange()
336 self.applychange()
337 self.continuedirty()
337 self.continuedirty()
338 return self.continueclean()
338 return self.continueclean()
339
339
340 def applychange(self):
340 def applychange(self):
341 """Applies the changes from this action's rulectx onto the current
341 """Applies the changes from this action's rulectx onto the current
342 parentctx, but does not commit them."""
342 parentctx, but does not commit them."""
343 repo = self.repo
343 repo = self.repo
344 rulectx = repo[self.node]
344 rulectx = repo[self.node]
345 hg.update(repo, self.state.parentctxnode)
345 hg.update(repo, self.state.parentctxnode)
346 stats = applychanges(repo.ui, repo, rulectx, {})
346 stats = applychanges(repo.ui, repo, rulectx, {})
347 if stats and stats[3] > 0:
347 if stats and stats[3] > 0:
348 raise error.InterventionRequired(_('Fix up the change and run '
348 raise error.InterventionRequired(_('Fix up the change and run '
349 'hg histedit --continue'))
349 'hg histedit --continue'))
350
350
351 def continuedirty(self):
351 def continuedirty(self):
352 """Continues the action when changes have been applied to the working
352 """Continues the action when changes have been applied to the working
353 copy. The default behavior is to commit the dirty changes."""
353 copy. The default behavior is to commit the dirty changes."""
354 repo = self.repo
354 repo = self.repo
355 rulectx = repo[self.node]
355 rulectx = repo[self.node]
356
356
357 editor = self.commiteditor()
357 editor = self.commiteditor()
358 commit = commitfuncfor(repo, rulectx)
358 commit = commitfuncfor(repo, rulectx)
359
359
360 commit(text=rulectx.description(), user=rulectx.user(),
360 commit(text=rulectx.description(), user=rulectx.user(),
361 date=rulectx.date(), extra=rulectx.extra(), editor=editor)
361 date=rulectx.date(), extra=rulectx.extra(), editor=editor)
362
362
363 def commiteditor(self):
363 def commiteditor(self):
364 """The editor to be used to edit the commit message."""
364 """The editor to be used to edit the commit message."""
365 return False
365 return False
366
366
367 def continueclean(self):
367 def continueclean(self):
368 """Continues the action when the working copy is clean. The default
368 """Continues the action when the working copy is clean. The default
369 behavior is to accept the current commit as the new version of the
369 behavior is to accept the current commit as the new version of the
370 rulectx."""
370 rulectx."""
371 ctx = self.repo['.']
371 ctx = self.repo['.']
372 if ctx.node() == self.state.parentctxnode:
372 if ctx.node() == self.state.parentctxnode:
373 self.repo.ui.warn(_('%s: empty changeset\n') %
373 self.repo.ui.warn(_('%s: empty changeset\n') %
374 node.short(self.node))
374 node.short(self.node))
375 return ctx, [(self.node, tuple())]
375 return ctx, [(self.node, tuple())]
376 if ctx.node() == self.node:
376 if ctx.node() == self.node:
377 # Nothing changed
377 # Nothing changed
378 return ctx, []
378 return ctx, []
379 return ctx, [(self.node, (ctx.node(),))]
379 return ctx, [(self.node, (ctx.node(),))]
380
380
381 def commitfuncfor(repo, src):
381 def commitfuncfor(repo, src):
382 """Build a commit function for the replacement of <src>
382 """Build a commit function for the replacement of <src>
383
383
384 This function ensure we apply the same treatment to all changesets.
384 This function ensure we apply the same treatment to all changesets.
385
385
386 - Add a 'histedit_source' entry in extra.
386 - Add a 'histedit_source' entry in extra.
387
387
388 Note that fold has its own separated logic because its handling is a bit
388 Note that fold has its own separated logic because its handling is a bit
389 different and not easily factored out of the fold method.
389 different and not easily factored out of the fold method.
390 """
390 """
391 phasemin = src.phase()
391 phasemin = src.phase()
392 def commitfunc(**kwargs):
392 def commitfunc(**kwargs):
393 phasebackup = repo.ui.backupconfig('phases', 'new-commit')
393 phasebackup = repo.ui.backupconfig('phases', 'new-commit')
394 try:
394 try:
395 repo.ui.setconfig('phases', 'new-commit', phasemin,
395 repo.ui.setconfig('phases', 'new-commit', phasemin,
396 'histedit')
396 'histedit')
397 extra = kwargs.get('extra', {}).copy()
397 extra = kwargs.get('extra', {}).copy()
398 extra['histedit_source'] = src.hex()
398 extra['histedit_source'] = src.hex()
399 kwargs['extra'] = extra
399 kwargs['extra'] = extra
400 return repo.commit(**kwargs)
400 return repo.commit(**kwargs)
401 finally:
401 finally:
402 repo.ui.restoreconfig(phasebackup)
402 repo.ui.restoreconfig(phasebackup)
403 return commitfunc
403 return commitfunc
404
404
405 def applychanges(ui, repo, ctx, opts):
405 def applychanges(ui, repo, ctx, opts):
406 """Merge changeset from ctx (only) in the current working directory"""
406 """Merge changeset from ctx (only) in the current working directory"""
407 wcpar = repo.dirstate.parents()[0]
407 wcpar = repo.dirstate.parents()[0]
408 if ctx.p1().node() == wcpar:
408 if ctx.p1().node() == wcpar:
409 # edition ar "in place" we do not need to make any merge,
409 # edition ar "in place" we do not need to make any merge,
410 # just applies changes on parent for edition
410 # just applies changes on parent for edition
411 cmdutil.revert(ui, repo, ctx, (wcpar, node.nullid), all=True)
411 cmdutil.revert(ui, repo, ctx, (wcpar, node.nullid), all=True)
412 stats = None
412 stats = None
413 else:
413 else:
414 try:
414 try:
415 # ui.forcemerge is an internal variable, do not document
415 # ui.forcemerge is an internal variable, do not document
416 repo.ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
416 repo.ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
417 'histedit')
417 'histedit')
418 stats = mergemod.graft(repo, ctx, ctx.p1(), ['local', 'histedit'])
418 stats = mergemod.graft(repo, ctx, ctx.p1(), ['local', 'histedit'])
419 finally:
419 finally:
420 repo.ui.setconfig('ui', 'forcemerge', '', 'histedit')
420 repo.ui.setconfig('ui', 'forcemerge', '', 'histedit')
421 return stats
421 return stats
422
422
423 def collapse(repo, first, last, commitopts, skipprompt=False):
423 def collapse(repo, first, last, commitopts, skipprompt=False):
424 """collapse the set of revisions from first to last as new one.
424 """collapse the set of revisions from first to last as new one.
425
425
426 Expected commit options are:
426 Expected commit options are:
427 - message
427 - message
428 - date
428 - date
429 - username
429 - username
430 Commit message is edited in all cases.
430 Commit message is edited in all cases.
431
431
432 This function works in memory."""
432 This function works in memory."""
433 ctxs = list(repo.set('%d::%d', first, last))
433 ctxs = list(repo.set('%d::%d', first, last))
434 if not ctxs:
434 if not ctxs:
435 return None
435 return None
436 for c in ctxs:
436 for c in ctxs:
437 if not c.mutable():
437 if not c.mutable():
438 raise util.Abort(
438 raise util.Abort(
439 _("cannot fold into public change %s") % node.short(c.node()))
439 _("cannot fold into public change %s") % node.short(c.node()))
440 base = first.parents()[0]
440 base = first.parents()[0]
441
441
442 # commit a new version of the old changeset, including the update
442 # commit a new version of the old changeset, including the update
443 # collect all files which might be affected
443 # collect all files which might be affected
444 files = set()
444 files = set()
445 for ctx in ctxs:
445 for ctx in ctxs:
446 files.update(ctx.files())
446 files.update(ctx.files())
447
447
448 # Recompute copies (avoid recording a -> b -> a)
448 # Recompute copies (avoid recording a -> b -> a)
449 copied = copies.pathcopies(base, last)
449 copied = copies.pathcopies(base, last)
450
450
451 # prune files which were reverted by the updates
451 # prune files which were reverted by the updates
452 def samefile(f):
452 def samefile(f):
453 if f in last.manifest():
453 if f in last.manifest():
454 a = last.filectx(f)
454 a = last.filectx(f)
455 if f in base.manifest():
455 if f in base.manifest():
456 b = base.filectx(f)
456 b = base.filectx(f)
457 return (a.data() == b.data()
457 return (a.data() == b.data()
458 and a.flags() == b.flags())
458 and a.flags() == b.flags())
459 else:
459 else:
460 return False
460 return False
461 else:
461 else:
462 return f not in base.manifest()
462 return f not in base.manifest()
463 files = [f for f in files if not samefile(f)]
463 files = [f for f in files if not samefile(f)]
464 # commit version of these files as defined by head
464 # commit version of these files as defined by head
465 headmf = last.manifest()
465 headmf = last.manifest()
466 def filectxfn(repo, ctx, path):
466 def filectxfn(repo, ctx, path):
467 if path in headmf:
467 if path in headmf:
468 fctx = last[path]
468 fctx = last[path]
469 flags = fctx.flags()
469 flags = fctx.flags()
470 mctx = context.memfilectx(repo,
470 mctx = context.memfilectx(repo,
471 fctx.path(), fctx.data(),
471 fctx.path(), fctx.data(),
472 islink='l' in flags,
472 islink='l' in flags,
473 isexec='x' in flags,
473 isexec='x' in flags,
474 copied=copied.get(path))
474 copied=copied.get(path))
475 return mctx
475 return mctx
476 return None
476 return None
477
477
478 if commitopts.get('message'):
478 if commitopts.get('message'):
479 message = commitopts['message']
479 message = commitopts['message']
480 else:
480 else:
481 message = first.description()
481 message = first.description()
482 user = commitopts.get('user')
482 user = commitopts.get('user')
483 date = commitopts.get('date')
483 date = commitopts.get('date')
484 extra = commitopts.get('extra')
484 extra = commitopts.get('extra')
485
485
486 parents = (first.p1().node(), first.p2().node())
486 parents = (first.p1().node(), first.p2().node())
487 editor = None
487 editor = None
488 if not skipprompt:
488 if not skipprompt:
489 editor = cmdutil.getcommiteditor(edit=True, editform='histedit.fold')
489 editor = cmdutil.getcommiteditor(edit=True, editform='histedit.fold')
490 new = context.memctx(repo,
490 new = context.memctx(repo,
491 parents=parents,
491 parents=parents,
492 text=message,
492 text=message,
493 files=files,
493 files=files,
494 filectxfn=filectxfn,
494 filectxfn=filectxfn,
495 user=user,
495 user=user,
496 date=date,
496 date=date,
497 extra=extra,
497 extra=extra,
498 editor=editor)
498 editor=editor)
499 return repo.commitctx(new)
499 return repo.commitctx(new)
500
500
501 class pick(histeditaction):
501 class pick(histeditaction):
502 def run(self):
502 def run(self):
503 rulectx = self.repo[self.node]
503 rulectx = self.repo[self.node]
504 if rulectx.parents()[0].node() == self.state.parentctxnode:
504 if rulectx.parents()[0].node() == self.state.parentctxnode:
505 self.repo.ui.debug('node %s unchanged\n' % node.short(self.node))
505 self.repo.ui.debug('node %s unchanged\n' % node.short(self.node))
506 return rulectx, []
506 return rulectx, []
507
507
508 return super(pick, self).run()
508 return super(pick, self).run()
509
509
510 class edit(histeditaction):
510 class edit(histeditaction):
511 def run(self):
511 def run(self):
512 repo = self.repo
512 repo = self.repo
513 rulectx = repo[self.node]
513 rulectx = repo[self.node]
514 hg.update(repo, self.state.parentctxnode)
514 hg.update(repo, self.state.parentctxnode)
515 applychanges(repo.ui, repo, rulectx, {})
515 applychanges(repo.ui, repo, rulectx, {})
516 raise error.InterventionRequired(
516 raise error.InterventionRequired(
517 _('Make changes as needed, you may commit or record as needed '
517 _('Make changes as needed, you may commit or record as needed '
518 'now.\nWhen you are finished, run hg histedit --continue to '
518 'now.\nWhen you are finished, run hg histedit --continue to '
519 'resume.'))
519 'resume.'))
520
520
521 def commiteditor(self):
521 def commiteditor(self):
522 return cmdutil.getcommiteditor(edit=True, editform='histedit.edit')
522 return cmdutil.getcommiteditor(edit=True, editform='histedit.edit')
523
523
524 class fold(histeditaction):
524 class fold(histeditaction):
525 def continuedirty(self):
525 def continuedirty(self):
526 repo = self.repo
526 repo = self.repo
527 rulectx = repo[self.node]
527 rulectx = repo[self.node]
528
528
529 commit = commitfuncfor(repo, rulectx)
529 commit = commitfuncfor(repo, rulectx)
530 commit(text='fold-temp-revision %s' % node.short(self.node),
530 commit(text='fold-temp-revision %s' % node.short(self.node),
531 user=rulectx.user(), date=rulectx.date(),
531 user=rulectx.user(), date=rulectx.date(),
532 extra=rulectx.extra())
532 extra=rulectx.extra())
533
533
534 def continueclean(self):
534 def continueclean(self):
535 repo = self.repo
535 repo = self.repo
536 ctx = repo['.']
536 ctx = repo['.']
537 rulectx = repo[self.node]
537 rulectx = repo[self.node]
538 parentctxnode = self.state.parentctxnode
538 parentctxnode = self.state.parentctxnode
539 if ctx.node() == parentctxnode:
539 if ctx.node() == parentctxnode:
540 repo.ui.warn(_('%s: empty changeset\n') %
540 repo.ui.warn(_('%s: empty changeset\n') %
541 node.short(self.node))
541 node.short(self.node))
542 return ctx, [(self.node, (parentctxnode,))]
542 return ctx, [(self.node, (parentctxnode,))]
543
543
544 parentctx = repo[parentctxnode]
544 parentctx = repo[parentctxnode]
545 newcommits = set(c.node() for c in repo.set('(%d::. - %d)', parentctx,
545 newcommits = set(c.node() for c in repo.set('(%d::. - %d)', parentctx,
546 parentctx))
546 parentctx))
547 if not newcommits:
547 if not newcommits:
548 repo.ui.warn(_('%s: cannot fold - working copy is not a '
548 repo.ui.warn(_('%s: cannot fold - working copy is not a '
549 'descendant of previous commit %s\n') %
549 'descendant of previous commit %s\n') %
550 (node.short(self.node), node.short(parentctxnode)))
550 (node.short(self.node), node.short(parentctxnode)))
551 return ctx, [(self.node, (ctx.node(),))]
551 return ctx, [(self.node, (ctx.node(),))]
552
552
553 middlecommits = newcommits.copy()
553 middlecommits = newcommits.copy()
554 middlecommits.discard(ctx.node())
554 middlecommits.discard(ctx.node())
555
555
556 return self.finishfold(repo.ui, repo, parentctx, rulectx, ctx.node(),
556 return self.finishfold(repo.ui, repo, parentctx, rulectx, ctx.node(),
557 middlecommits)
557 middlecommits)
558
558
559 def skipprompt(self):
559 def skipprompt(self):
560 return False
560 return False
561
561
562 def finishfold(self, ui, repo, ctx, oldctx, newnode, internalchanges):
562 def finishfold(self, ui, repo, ctx, oldctx, newnode, internalchanges):
563 parent = ctx.parents()[0].node()
563 parent = ctx.parents()[0].node()
564 hg.update(repo, parent)
564 hg.update(repo, parent)
565 ### prepare new commit data
565 ### prepare new commit data
566 commitopts = {}
566 commitopts = {}
567 commitopts['user'] = ctx.user()
567 commitopts['user'] = ctx.user()
568 # commit message
568 # commit message
569 if self.skipprompt():
569 if self.skipprompt():
570 newmessage = ctx.description()
570 newmessage = ctx.description()
571 else:
571 else:
572 newmessage = '\n***\n'.join(
572 newmessage = '\n***\n'.join(
573 [ctx.description()] +
573 [ctx.description()] +
574 [repo[r].description() for r in internalchanges] +
574 [repo[r].description() for r in internalchanges] +
575 [oldctx.description()]) + '\n'
575 [oldctx.description()]) + '\n'
576 commitopts['message'] = newmessage
576 commitopts['message'] = newmessage
577 # date
577 # date
578 commitopts['date'] = max(ctx.date(), oldctx.date())
578 commitopts['date'] = max(ctx.date(), oldctx.date())
579 extra = ctx.extra().copy()
579 extra = ctx.extra().copy()
580 # histedit_source
580 # histedit_source
581 # note: ctx is likely a temporary commit but that the best we can do
581 # note: ctx is likely a temporary commit but that the best we can do
582 # here. This is sufficient to solve issue3681 anyway.
582 # here. This is sufficient to solve issue3681 anyway.
583 extra['histedit_source'] = '%s,%s' % (ctx.hex(), oldctx.hex())
583 extra['histedit_source'] = '%s,%s' % (ctx.hex(), oldctx.hex())
584 commitopts['extra'] = extra
584 commitopts['extra'] = extra
585 phasebackup = repo.ui.backupconfig('phases', 'new-commit')
585 phasebackup = repo.ui.backupconfig('phases', 'new-commit')
586 try:
586 try:
587 phasemin = max(ctx.phase(), oldctx.phase())
587 phasemin = max(ctx.phase(), oldctx.phase())
588 repo.ui.setconfig('phases', 'new-commit', phasemin, 'histedit')
588 repo.ui.setconfig('phases', 'new-commit', phasemin, 'histedit')
589 n = collapse(repo, ctx, repo[newnode], commitopts,
589 n = collapse(repo, ctx, repo[newnode], commitopts,
590 skipprompt=self.skipprompt())
590 skipprompt=self.skipprompt())
591 finally:
591 finally:
592 repo.ui.restoreconfig(phasebackup)
592 repo.ui.restoreconfig(phasebackup)
593 if n is None:
593 if n is None:
594 return ctx, []
594 return ctx, []
595 hg.update(repo, n)
595 hg.update(repo, n)
596 replacements = [(oldctx.node(), (newnode,)),
596 replacements = [(oldctx.node(), (newnode,)),
597 (ctx.node(), (n,)),
597 (ctx.node(), (n,)),
598 (newnode, (n,)),
598 (newnode, (n,)),
599 ]
599 ]
600 for ich in internalchanges:
600 for ich in internalchanges:
601 replacements.append((ich, (n,)))
601 replacements.append((ich, (n,)))
602 return repo[n], replacements
602 return repo[n], replacements
603
603
604 class rollup(fold):
604 class rollup(fold):
605 def skipprompt(self):
605 def skipprompt(self):
606 return True
606 return True
607
607
608 class drop(histeditaction):
608 class drop(histeditaction):
609 def run(self):
609 def run(self):
610 parentctx = self.repo[self.state.parentctxnode]
610 parentctx = self.repo[self.state.parentctxnode]
611 return parentctx, [(self.node, tuple())]
611 return parentctx, [(self.node, tuple())]
612
612
613 class message(histeditaction):
613 class message(histeditaction):
614 def commiteditor(self):
614 def commiteditor(self):
615 return cmdutil.getcommiteditor(edit=True, editform='histedit.mess')
615 return cmdutil.getcommiteditor(edit=True, editform='histedit.mess')
616
616
617 def findoutgoing(ui, repo, remote=None, force=False, opts={}):
617 def findoutgoing(ui, repo, remote=None, force=False, opts={}):
618 """utility function to find the first outgoing changeset
618 """utility function to find the first outgoing changeset
619
619
620 Used by initialisation code"""
620 Used by initialisation code"""
621 dest = ui.expandpath(remote or 'default-push', remote or 'default')
621 dest = ui.expandpath(remote or 'default-push', remote or 'default')
622 dest, revs = hg.parseurl(dest, None)[:2]
622 dest, revs = hg.parseurl(dest, None)[:2]
623 ui.status(_('comparing with %s\n') % util.hidepassword(dest))
623 ui.status(_('comparing with %s\n') % util.hidepassword(dest))
624
624
625 revs, checkout = hg.addbranchrevs(repo, repo, revs, None)
625 revs, checkout = hg.addbranchrevs(repo, repo, revs, None)
626 other = hg.peer(repo, opts, dest)
626 other = hg.peer(repo, opts, dest)
627
627
628 if revs:
628 if revs:
629 revs = [repo.lookup(rev) for rev in revs]
629 revs = [repo.lookup(rev) for rev in revs]
630
630
631 outgoing = discovery.findcommonoutgoing(repo, other, revs, force=force)
631 outgoing = discovery.findcommonoutgoing(repo, other, revs, force=force)
632 if not outgoing.missing:
632 if not outgoing.missing:
633 raise util.Abort(_('no outgoing ancestors'))
633 raise util.Abort(_('no outgoing ancestors'))
634 roots = list(repo.revs("roots(%ln)", outgoing.missing))
634 roots = list(repo.revs("roots(%ln)", outgoing.missing))
635 if 1 < len(roots):
635 if 1 < len(roots):
636 msg = _('there are ambiguous outgoing revisions')
636 msg = _('there are ambiguous outgoing revisions')
637 hint = _('see "hg help histedit" for more detail')
637 hint = _('see "hg help histedit" for more detail')
638 raise util.Abort(msg, hint=hint)
638 raise util.Abort(msg, hint=hint)
639 return repo.lookup(roots[0])
639 return repo.lookup(roots[0])
640
640
641 actiontable = {'p': pick,
641 actiontable = {'p': pick,
642 'pick': pick,
642 'pick': pick,
643 'e': edit,
643 'e': edit,
644 'edit': edit,
644 'edit': edit,
645 'f': fold,
645 'f': fold,
646 'fold': fold,
646 'fold': fold,
647 'r': rollup,
647 'r': rollup,
648 'roll': rollup,
648 'roll': rollup,
649 'd': drop,
649 'd': drop,
650 'drop': drop,
650 'drop': drop,
651 'm': message,
651 'm': message,
652 'mess': message,
652 'mess': message,
653 }
653 }
654
654
655 @command('histedit',
655 @command('histedit',
656 [('', 'commands', '',
656 [('', 'commands', '',
657 _('read history edits from the specified file'), _('FILE')),
657 _('read history edits from the specified file'), _('FILE')),
658 ('c', 'continue', False, _('continue an edit already in progress')),
658 ('c', 'continue', False, _('continue an edit already in progress')),
659 ('', 'edit-plan', False, _('edit remaining actions list')),
659 ('', 'edit-plan', False, _('edit remaining actions list')),
660 ('k', 'keep', False,
660 ('k', 'keep', False,
661 _("don't strip old nodes after edit is complete")),
661 _("don't strip old nodes after edit is complete")),
662 ('', 'abort', False, _('abort an edit in progress')),
662 ('', 'abort', False, _('abort an edit in progress')),
663 ('o', 'outgoing', False, _('changesets not found in destination')),
663 ('o', 'outgoing', False, _('changesets not found in destination')),
664 ('f', 'force', False,
664 ('f', 'force', False,
665 _('force outgoing even for unrelated repositories')),
665 _('force outgoing even for unrelated repositories')),
666 ('r', 'rev', [], _('first revision to be edited'), _('REV'))],
666 ('r', 'rev', [], _('first revision to be edited'), _('REV'))],
667 _("ANCESTOR | --outgoing [URL]"))
667 _("ANCESTOR | --outgoing [URL]"))
668 def histedit(ui, repo, *freeargs, **opts):
668 def histedit(ui, repo, *freeargs, **opts):
669 """interactively edit changeset history
669 """interactively edit changeset history
670
670
671 This command edits changesets between ANCESTOR and the parent of
671 This command edits changesets between ANCESTOR and the parent of
672 the working directory.
672 the working directory.
673
673
674 With --outgoing, this edits changesets not found in the
674 With --outgoing, this edits changesets not found in the
675 destination repository. If URL of the destination is omitted, the
675 destination repository. If URL of the destination is omitted, the
676 'default-push' (or 'default') path will be used.
676 'default-push' (or 'default') path will be used.
677
677
678 For safety, this command is aborted, also if there are ambiguous
678 For safety, this command is aborted, also if there are ambiguous
679 outgoing revisions which may confuse users: for example, there are
679 outgoing revisions which may confuse users: for example, there are
680 multiple branches containing outgoing revisions.
680 multiple branches containing outgoing revisions.
681
681
682 Use "min(outgoing() and ::.)" or similar revset specification
682 Use "min(outgoing() and ::.)" or similar revset specification
683 instead of --outgoing to specify edit target revision exactly in
683 instead of --outgoing to specify edit target revision exactly in
684 such ambiguous situation. See :hg:`help revsets` for detail about
684 such ambiguous situation. See :hg:`help revsets` for detail about
685 selecting revisions.
685 selecting revisions.
686
686
687 Returns 0 on success, 1 if user intervention is required (not only
687 Returns 0 on success, 1 if user intervention is required (not only
688 for intentional "edit" command, but also for resolving unexpected
688 for intentional "edit" command, but also for resolving unexpected
689 conflicts).
689 conflicts).
690 """
690 """
691 state = histeditstate(repo)
691 state = histeditstate(repo)
692 try:
692 try:
693 state.wlock = repo.wlock()
693 state.wlock = repo.wlock()
694 state.lock = repo.lock()
694 state.lock = repo.lock()
695 _histedit(ui, repo, state, *freeargs, **opts)
695 _histedit(ui, repo, state, *freeargs, **opts)
696 finally:
696 finally:
697 release(state.lock, state.wlock)
697 release(state.lock, state.wlock)
698
698
699 def _histedit(ui, repo, state, *freeargs, **opts):
699 def _histedit(ui, repo, state, *freeargs, **opts):
700 # TODO only abort if we try and histedit mq patches, not just
700 # TODO only abort if we try and histedit mq patches, not just
701 # blanket if mq patches are applied somewhere
701 # blanket if mq patches are applied somewhere
702 mq = getattr(repo, 'mq', None)
702 mq = getattr(repo, 'mq', None)
703 if mq and mq.applied:
703 if mq and mq.applied:
704 raise util.Abort(_('source has mq patches applied'))
704 raise util.Abort(_('source has mq patches applied'))
705
705
706 # basic argument incompatibility processing
706 # basic argument incompatibility processing
707 outg = opts.get('outgoing')
707 outg = opts.get('outgoing')
708 cont = opts.get('continue')
708 cont = opts.get('continue')
709 editplan = opts.get('edit_plan')
709 editplan = opts.get('edit_plan')
710 abort = opts.get('abort')
710 abort = opts.get('abort')
711 force = opts.get('force')
711 force = opts.get('force')
712 rules = opts.get('commands', '')
712 rules = opts.get('commands', '')
713 revs = opts.get('rev', [])
713 revs = opts.get('rev', [])
714 goal = 'new' # This invocation goal, in new, continue, abort
714 goal = 'new' # This invocation goal, in new, continue, abort
715 if force and not outg:
715 if force and not outg:
716 raise util.Abort(_('--force only allowed with --outgoing'))
716 raise util.Abort(_('--force only allowed with --outgoing'))
717 if cont:
717 if cont:
718 if any((outg, abort, revs, freeargs, rules, editplan)):
718 if any((outg, abort, revs, freeargs, rules, editplan)):
719 raise util.Abort(_('no arguments allowed with --continue'))
719 raise util.Abort(_('no arguments allowed with --continue'))
720 goal = 'continue'
720 goal = 'continue'
721 elif abort:
721 elif abort:
722 if any((outg, revs, freeargs, rules, editplan)):
722 if any((outg, revs, freeargs, rules, editplan)):
723 raise util.Abort(_('no arguments allowed with --abort'))
723 raise util.Abort(_('no arguments allowed with --abort'))
724 goal = 'abort'
724 goal = 'abort'
725 elif editplan:
725 elif editplan:
726 if any((outg, revs, freeargs)):
726 if any((outg, revs, freeargs)):
727 raise util.Abort(_('only --commands argument allowed with '
727 raise util.Abort(_('only --commands argument allowed with '
728 '--edit-plan'))
728 '--edit-plan'))
729 goal = 'edit-plan'
729 goal = 'edit-plan'
730 else:
730 else:
731 if os.path.exists(os.path.join(repo.path, 'histedit-state')):
731 if os.path.exists(os.path.join(repo.path, 'histedit-state')):
732 raise util.Abort(_('history edit already in progress, try '
732 raise util.Abort(_('history edit already in progress, try '
733 '--continue or --abort'))
733 '--continue or --abort'))
734 if outg:
734 if outg:
735 if revs:
735 if revs:
736 raise util.Abort(_('no revisions allowed with --outgoing'))
736 raise util.Abort(_('no revisions allowed with --outgoing'))
737 if len(freeargs) > 1:
737 if len(freeargs) > 1:
738 raise util.Abort(
738 raise util.Abort(
739 _('only one repo argument allowed with --outgoing'))
739 _('only one repo argument allowed with --outgoing'))
740 else:
740 else:
741 revs.extend(freeargs)
741 revs.extend(freeargs)
742 if len(revs) == 0:
742 if len(revs) == 0:
743 # experimental config: histedit.defaultrev
743 # experimental config: histedit.defaultrev
744 histeditdefault = ui.config('histedit', 'defaultrev')
744 histeditdefault = ui.config('histedit', 'defaultrev')
745 if histeditdefault:
745 if histeditdefault:
746 revs.append(histeditdefault)
746 revs.append(histeditdefault)
747 if len(revs) != 1:
747 if len(revs) != 1:
748 raise util.Abort(
748 raise util.Abort(
749 _('histedit requires exactly one ancestor revision'))
749 _('histedit requires exactly one ancestor revision'))
750
750
751
751
752 replacements = []
752 replacements = []
753 state.keep = opts.get('keep', False)
753 state.keep = opts.get('keep', False)
754 supportsmarkers = obsolete.isenabled(repo, obsolete.createmarkersopt)
754 supportsmarkers = obsolete.isenabled(repo, obsolete.createmarkersopt)
755
755
756 # rebuild state
756 # rebuild state
757 if goal == 'continue':
757 if goal == 'continue':
758 state.read()
758 state.read()
759 state = bootstrapcontinue(ui, state, opts)
759 state = bootstrapcontinue(ui, state, opts)
760 elif goal == 'edit-plan':
760 elif goal == 'edit-plan':
761 state.read()
761 state.read()
762 if not rules:
762 if not rules:
763 comment = editcomment % (node.short(state.parentctxnode),
763 comment = editcomment % (node.short(state.parentctxnode),
764 node.short(state.topmost))
764 node.short(state.topmost))
765 rules = ruleeditor(repo, ui, state.rules, comment)
765 rules = ruleeditor(repo, ui, state.rules, comment)
766 else:
766 else:
767 if rules == '-':
767 if rules == '-':
768 f = sys.stdin
768 f = sys.stdin
769 else:
769 else:
770 f = open(rules)
770 f = open(rules)
771 rules = f.read()
771 rules = f.read()
772 f.close()
772 f.close()
773 rules = [l for l in (r.strip() for r in rules.splitlines())
773 rules = [l for l in (r.strip() for r in rules.splitlines())
774 if l and not l.startswith('#')]
774 if l and not l.startswith('#')]
775 rules = verifyrules(rules, repo, [repo[c] for [_a, c] in state.rules])
775 rules = verifyrules(rules, repo, [repo[c] for [_a, c] in state.rules])
776 state.rules = rules
776 state.rules = rules
777 state.write()
777 state.write()
778 return
778 return
779 elif goal == 'abort':
779 elif goal == 'abort':
780 state.read()
780 state.read()
781 mapping, tmpnodes, leafs, _ntm = processreplacement(state)
781 tmpnodes, leafs = newnodestoabort(state)
782 ui.debug('restore wc to old parent %s\n' % node.short(state.topmost))
782 ui.debug('restore wc to old parent %s\n' % node.short(state.topmost))
783
783
784 # Recover our old commits if necessary
784 # Recover our old commits if necessary
785 if not state.topmost in repo and state.backupfile:
785 if not state.topmost in repo and state.backupfile:
786 backupfile = repo.join(state.backupfile)
786 backupfile = repo.join(state.backupfile)
787 f = hg.openpath(ui, backupfile)
787 f = hg.openpath(ui, backupfile)
788 gen = exchange.readbundle(ui, f, backupfile)
788 gen = exchange.readbundle(ui, f, backupfile)
789 changegroup.addchangegroup(repo, gen, 'histedit',
789 changegroup.addchangegroup(repo, gen, 'histedit',
790 'bundle:' + backupfile)
790 'bundle:' + backupfile)
791 os.remove(backupfile)
791 os.remove(backupfile)
792
792
793 # check whether we should update away
793 # check whether we should update away
794 parentnodes = [c.node() for c in repo[None].parents()]
794 parentnodes = [c.node() for c in repo[None].parents()]
795 for n in leafs | set([state.parentctxnode]):
795 for n in leafs | set([state.parentctxnode]):
796 if n in parentnodes:
796 if n in parentnodes:
797 hg.clean(repo, state.topmost)
797 hg.clean(repo, state.topmost)
798 break
798 break
799 else:
799 else:
800 pass
800 pass
801 cleanupnode(ui, repo, 'created', tmpnodes)
801 cleanupnode(ui, repo, 'created', tmpnodes)
802 cleanupnode(ui, repo, 'temp', leafs)
802 cleanupnode(ui, repo, 'temp', leafs)
803 state.clear()
803 state.clear()
804 return
804 return
805 else:
805 else:
806 cmdutil.checkunfinished(repo)
806 cmdutil.checkunfinished(repo)
807 cmdutil.bailifchanged(repo)
807 cmdutil.bailifchanged(repo)
808
808
809 topmost, empty = repo.dirstate.parents()
809 topmost, empty = repo.dirstate.parents()
810 if outg:
810 if outg:
811 if freeargs:
811 if freeargs:
812 remote = freeargs[0]
812 remote = freeargs[0]
813 else:
813 else:
814 remote = None
814 remote = None
815 root = findoutgoing(ui, repo, remote, force, opts)
815 root = findoutgoing(ui, repo, remote, force, opts)
816 else:
816 else:
817 rr = list(repo.set('roots(%ld)', scmutil.revrange(repo, revs)))
817 rr = list(repo.set('roots(%ld)', scmutil.revrange(repo, revs)))
818 if len(rr) != 1:
818 if len(rr) != 1:
819 raise util.Abort(_('The specified revisions must have '
819 raise util.Abort(_('The specified revisions must have '
820 'exactly one common root'))
820 'exactly one common root'))
821 root = rr[0].node()
821 root = rr[0].node()
822
822
823 revs = between(repo, root, topmost, state.keep)
823 revs = between(repo, root, topmost, state.keep)
824 if not revs:
824 if not revs:
825 raise util.Abort(_('%s is not an ancestor of working directory') %
825 raise util.Abort(_('%s is not an ancestor of working directory') %
826 node.short(root))
826 node.short(root))
827
827
828 ctxs = [repo[r] for r in revs]
828 ctxs = [repo[r] for r in revs]
829 if not rules:
829 if not rules:
830 comment = editcomment % (node.short(root), node.short(topmost))
830 comment = editcomment % (node.short(root), node.short(topmost))
831 rules = ruleeditor(repo, ui, [['pick', c] for c in ctxs], comment)
831 rules = ruleeditor(repo, ui, [['pick', c] for c in ctxs], comment)
832 else:
832 else:
833 if rules == '-':
833 if rules == '-':
834 f = sys.stdin
834 f = sys.stdin
835 else:
835 else:
836 f = open(rules)
836 f = open(rules)
837 rules = f.read()
837 rules = f.read()
838 f.close()
838 f.close()
839 rules = [l for l in (r.strip() for r in rules.splitlines())
839 rules = [l for l in (r.strip() for r in rules.splitlines())
840 if l and not l.startswith('#')]
840 if l and not l.startswith('#')]
841 rules = verifyrules(rules, repo, ctxs)
841 rules = verifyrules(rules, repo, ctxs)
842
842
843 parentctxnode = repo[root].parents()[0].node()
843 parentctxnode = repo[root].parents()[0].node()
844
844
845 state.parentctxnode = parentctxnode
845 state.parentctxnode = parentctxnode
846 state.rules = rules
846 state.rules = rules
847 state.topmost = topmost
847 state.topmost = topmost
848 state.replacements = replacements
848 state.replacements = replacements
849
849
850 # Create a backup so we can always abort completely.
850 # Create a backup so we can always abort completely.
851 backupfile = None
851 backupfile = None
852 if not obsolete.isenabled(repo, obsolete.createmarkersopt):
852 if not obsolete.isenabled(repo, obsolete.createmarkersopt):
853 backupfile = repair._bundle(repo, [parentctxnode], [topmost], root,
853 backupfile = repair._bundle(repo, [parentctxnode], [topmost], root,
854 'histedit')
854 'histedit')
855 state.backupfile = backupfile
855 state.backupfile = backupfile
856
856
857 while state.rules:
857 while state.rules:
858 state.write()
858 state.write()
859 action, ha = state.rules.pop(0)
859 action, ha = state.rules.pop(0)
860 ui.debug('histedit: processing %s %s\n' % (action, ha[:12]))
860 ui.debug('histedit: processing %s %s\n' % (action, ha[:12]))
861 actobj = actiontable[action].fromrule(state, ha)
861 actobj = actiontable[action].fromrule(state, ha)
862 parentctx, replacement_ = actobj.run()
862 parentctx, replacement_ = actobj.run()
863 state.parentctxnode = parentctx.node()
863 state.parentctxnode = parentctx.node()
864 state.replacements.extend(replacement_)
864 state.replacements.extend(replacement_)
865 state.write()
865 state.write()
866
866
867 hg.update(repo, state.parentctxnode)
867 hg.update(repo, state.parentctxnode)
868
868
869 mapping, tmpnodes, created, ntm = processreplacement(state)
869 mapping, tmpnodes, created, ntm = processreplacement(state)
870 if mapping:
870 if mapping:
871 for prec, succs in mapping.iteritems():
871 for prec, succs in mapping.iteritems():
872 if not succs:
872 if not succs:
873 ui.debug('histedit: %s is dropped\n' % node.short(prec))
873 ui.debug('histedit: %s is dropped\n' % node.short(prec))
874 else:
874 else:
875 ui.debug('histedit: %s is replaced by %s\n' % (
875 ui.debug('histedit: %s is replaced by %s\n' % (
876 node.short(prec), node.short(succs[0])))
876 node.short(prec), node.short(succs[0])))
877 if len(succs) > 1:
877 if len(succs) > 1:
878 m = 'histedit: %s'
878 m = 'histedit: %s'
879 for n in succs[1:]:
879 for n in succs[1:]:
880 ui.debug(m % node.short(n))
880 ui.debug(m % node.short(n))
881
881
882 if not state.keep:
882 if not state.keep:
883 if mapping:
883 if mapping:
884 movebookmarks(ui, repo, mapping, state.topmost, ntm)
884 movebookmarks(ui, repo, mapping, state.topmost, ntm)
885 # TODO update mq state
885 # TODO update mq state
886 if supportsmarkers:
886 if supportsmarkers:
887 markers = []
887 markers = []
888 # sort by revision number because it sound "right"
888 # sort by revision number because it sound "right"
889 for prec in sorted(mapping, key=repo.changelog.rev):
889 for prec in sorted(mapping, key=repo.changelog.rev):
890 succs = mapping[prec]
890 succs = mapping[prec]
891 markers.append((repo[prec],
891 markers.append((repo[prec],
892 tuple(repo[s] for s in succs)))
892 tuple(repo[s] for s in succs)))
893 if markers:
893 if markers:
894 obsolete.createmarkers(repo, markers)
894 obsolete.createmarkers(repo, markers)
895 else:
895 else:
896 cleanupnode(ui, repo, 'replaced', mapping)
896 cleanupnode(ui, repo, 'replaced', mapping)
897
897
898 cleanupnode(ui, repo, 'temp', tmpnodes)
898 cleanupnode(ui, repo, 'temp', tmpnodes)
899 state.clear()
899 state.clear()
900 if os.path.exists(repo.sjoin('undo')):
900 if os.path.exists(repo.sjoin('undo')):
901 os.unlink(repo.sjoin('undo'))
901 os.unlink(repo.sjoin('undo'))
902
902
903 def bootstrapcontinue(ui, state, opts):
903 def bootstrapcontinue(ui, state, opts):
904 repo = state.repo
904 repo = state.repo
905 if state.rules:
905 if state.rules:
906 action, currentnode = state.rules.pop(0)
906 action, currentnode = state.rules.pop(0)
907
907
908 actobj = actiontable[action].fromrule(state, currentnode)
908 actobj = actiontable[action].fromrule(state, currentnode)
909
909
910 s = repo.status()
910 s = repo.status()
911 if s.modified or s.added or s.removed or s.deleted:
911 if s.modified or s.added or s.removed or s.deleted:
912 actobj.continuedirty()
912 actobj.continuedirty()
913 s = repo.status()
913 s = repo.status()
914 if s.modified or s.added or s.removed or s.deleted:
914 if s.modified or s.added or s.removed or s.deleted:
915 raise util.Abort(_("working copy still dirty"))
915 raise util.Abort(_("working copy still dirty"))
916
916
917 parentctx, replacements = actobj.continueclean()
917 parentctx, replacements = actobj.continueclean()
918
918
919 state.parentctxnode = parentctx.node()
919 state.parentctxnode = parentctx.node()
920 state.replacements.extend(replacements)
920 state.replacements.extend(replacements)
921
921
922 return state
922 return state
923
923
924 def between(repo, old, new, keep):
924 def between(repo, old, new, keep):
925 """select and validate the set of revision to edit
925 """select and validate the set of revision to edit
926
926
927 When keep is false, the specified set can't have children."""
927 When keep is false, the specified set can't have children."""
928 ctxs = list(repo.set('%n::%n', old, new))
928 ctxs = list(repo.set('%n::%n', old, new))
929 if ctxs and not keep:
929 if ctxs and not keep:
930 if (not obsolete.isenabled(repo, obsolete.allowunstableopt) and
930 if (not obsolete.isenabled(repo, obsolete.allowunstableopt) and
931 repo.revs('(%ld::) - (%ld)', ctxs, ctxs)):
931 repo.revs('(%ld::) - (%ld)', ctxs, ctxs)):
932 raise util.Abort(_('cannot edit history that would orphan nodes'))
932 raise util.Abort(_('cannot edit history that would orphan nodes'))
933 if repo.revs('(%ld) and merge()', ctxs):
933 if repo.revs('(%ld) and merge()', ctxs):
934 raise util.Abort(_('cannot edit history that contains merges'))
934 raise util.Abort(_('cannot edit history that contains merges'))
935 root = ctxs[0] # list is already sorted by repo.set
935 root = ctxs[0] # list is already sorted by repo.set
936 if not root.mutable():
936 if not root.mutable():
937 raise util.Abort(_('cannot edit public changeset: %s') % root,
937 raise util.Abort(_('cannot edit public changeset: %s') % root,
938 hint=_('see "hg help phases" for details'))
938 hint=_('see "hg help phases" for details'))
939 return [c.node() for c in ctxs]
939 return [c.node() for c in ctxs]
940
940
941 def makedesc(repo, action, rev):
941 def makedesc(repo, action, rev):
942 """build a initial action line for a ctx
942 """build a initial action line for a ctx
943
943
944 line are in the form:
944 line are in the form:
945
945
946 <action> <hash> <rev> <summary>
946 <action> <hash> <rev> <summary>
947 """
947 """
948 ctx = repo[rev]
948 ctx = repo[rev]
949 summary = ''
949 summary = ''
950 if ctx.description():
950 if ctx.description():
951 summary = ctx.description().splitlines()[0]
951 summary = ctx.description().splitlines()[0]
952 line = '%s %s %d %s' % (action, ctx, ctx.rev(), summary)
952 line = '%s %s %d %s' % (action, ctx, ctx.rev(), summary)
953 # trim to 80 columns so it's not stupidly wide in my editor
953 # trim to 80 columns so it's not stupidly wide in my editor
954 maxlen = repo.ui.configint('histedit', 'linelen', default=80)
954 maxlen = repo.ui.configint('histedit', 'linelen', default=80)
955 maxlen = max(maxlen, 22) # avoid truncating hash
955 maxlen = max(maxlen, 22) # avoid truncating hash
956 return util.ellipsis(line, maxlen)
956 return util.ellipsis(line, maxlen)
957
957
958 def ruleeditor(repo, ui, rules, editcomment=""):
958 def ruleeditor(repo, ui, rules, editcomment=""):
959 """open an editor to edit rules
959 """open an editor to edit rules
960
960
961 rules are in the format [ [act, ctx], ...] like in state.rules
961 rules are in the format [ [act, ctx], ...] like in state.rules
962 """
962 """
963 rules = '\n'.join([makedesc(repo, act, rev) for [act, rev] in rules])
963 rules = '\n'.join([makedesc(repo, act, rev) for [act, rev] in rules])
964 rules += '\n\n'
964 rules += '\n\n'
965 rules += editcomment
965 rules += editcomment
966 rules = ui.edit(rules, ui.username())
966 rules = ui.edit(rules, ui.username())
967
967
968 # Save edit rules in .hg/histedit-last-edit.txt in case
968 # Save edit rules in .hg/histedit-last-edit.txt in case
969 # the user needs to ask for help after something
969 # the user needs to ask for help after something
970 # surprising happens.
970 # surprising happens.
971 f = open(repo.join('histedit-last-edit.txt'), 'w')
971 f = open(repo.join('histedit-last-edit.txt'), 'w')
972 f.write(rules)
972 f.write(rules)
973 f.close()
973 f.close()
974
974
975 return rules
975 return rules
976
976
977 def verifyrules(rules, repo, ctxs):
977 def verifyrules(rules, repo, ctxs):
978 """Verify that there exists exactly one edit rule per given changeset.
978 """Verify that there exists exactly one edit rule per given changeset.
979
979
980 Will abort if there are to many or too few rules, a malformed rule,
980 Will abort if there are to many or too few rules, a malformed rule,
981 or a rule on a changeset outside of the user-given range.
981 or a rule on a changeset outside of the user-given range.
982 """
982 """
983 parsed = []
983 parsed = []
984 expected = set(c.hex() for c in ctxs)
984 expected = set(c.hex() for c in ctxs)
985 seen = set()
985 seen = set()
986 for r in rules:
986 for r in rules:
987 if ' ' not in r:
987 if ' ' not in r:
988 raise util.Abort(_('malformed line "%s"') % r)
988 raise util.Abort(_('malformed line "%s"') % r)
989 action, rest = r.split(' ', 1)
989 action, rest = r.split(' ', 1)
990 ha = rest.strip().split(' ', 1)[0]
990 ha = rest.strip().split(' ', 1)[0]
991 try:
991 try:
992 ha = repo[ha].hex()
992 ha = repo[ha].hex()
993 except error.RepoError:
993 except error.RepoError:
994 raise util.Abort(_('unknown changeset %s listed') % ha[:12])
994 raise util.Abort(_('unknown changeset %s listed') % ha[:12])
995 if ha not in expected:
995 if ha not in expected:
996 raise util.Abort(
996 raise util.Abort(
997 _('may not use changesets other than the ones listed'))
997 _('may not use changesets other than the ones listed'))
998 if ha in seen:
998 if ha in seen:
999 raise util.Abort(_('duplicated command for changeset %s') %
999 raise util.Abort(_('duplicated command for changeset %s') %
1000 ha[:12])
1000 ha[:12])
1001 seen.add(ha)
1001 seen.add(ha)
1002 if action not in actiontable:
1002 if action not in actiontable:
1003 raise util.Abort(_('unknown action "%s"') % action)
1003 raise util.Abort(_('unknown action "%s"') % action)
1004 parsed.append([action, ha])
1004 parsed.append([action, ha])
1005 missing = sorted(expected - seen) # sort to stabilize output
1005 missing = sorted(expected - seen) # sort to stabilize output
1006 if missing:
1006 if missing:
1007 raise util.Abort(_('missing rules for changeset %s') %
1007 raise util.Abort(_('missing rules for changeset %s') %
1008 missing[0][:12],
1008 missing[0][:12],
1009 hint=_('do you want to use the drop action?'))
1009 hint=_('do you want to use the drop action?'))
1010 return parsed
1010 return parsed
1011
1011
1012 def newnodestoabort(state):
1013 """process the list of replacements to return
1014
1015 1) the list of final node
1016 2) the list of temporary node
1017
1018 This meant to be used on abort as less data are required in this case.
1019 """
1020 replacements = state.replacements
1021 allsuccs = set()
1022 replaced = set()
1023 for rep in replacements:
1024 allsuccs.update(rep[1])
1025 replaced.add(rep[0])
1026 newnodes = allsuccs - replaced
1027 tmpnodes = allsuccs & replaced
1028 return newnodes, tmpnodes
1029
1030
1012 def processreplacement(state):
1031 def processreplacement(state):
1013 """process the list of replacements to return
1032 """process the list of replacements to return
1014
1033
1015 1) the final mapping between original and created nodes
1034 1) the final mapping between original and created nodes
1016 2) the list of temporary node created by histedit
1035 2) the list of temporary node created by histedit
1017 3) the list of new commit created by histedit"""
1036 3) the list of new commit created by histedit"""
1018 replacements = state.replacements
1037 replacements = state.replacements
1019 allsuccs = set()
1038 allsuccs = set()
1020 replaced = set()
1039 replaced = set()
1021 fullmapping = {}
1040 fullmapping = {}
1022 # initialise basic set
1041 # initialise basic set
1023 # fullmapping record all operation recorded in replacement
1042 # fullmapping record all operation recorded in replacement
1024 for rep in replacements:
1043 for rep in replacements:
1025 allsuccs.update(rep[1])
1044 allsuccs.update(rep[1])
1026 replaced.add(rep[0])
1045 replaced.add(rep[0])
1027 fullmapping.setdefault(rep[0], set()).update(rep[1])
1046 fullmapping.setdefault(rep[0], set()).update(rep[1])
1028 new = allsuccs - replaced
1047 new = allsuccs - replaced
1029 tmpnodes = allsuccs & replaced
1048 tmpnodes = allsuccs & replaced
1030 # Reduce content fullmapping into direct relation between original nodes
1049 # Reduce content fullmapping into direct relation between original nodes
1031 # and final node created during history edition
1050 # and final node created during history edition
1032 # Dropped changeset are replaced by an empty list
1051 # Dropped changeset are replaced by an empty list
1033 toproceed = set(fullmapping)
1052 toproceed = set(fullmapping)
1034 final = {}
1053 final = {}
1035 while toproceed:
1054 while toproceed:
1036 for x in list(toproceed):
1055 for x in list(toproceed):
1037 succs = fullmapping[x]
1056 succs = fullmapping[x]
1038 for s in list(succs):
1057 for s in list(succs):
1039 if s in toproceed:
1058 if s in toproceed:
1040 # non final node with unknown closure
1059 # non final node with unknown closure
1041 # We can't process this now
1060 # We can't process this now
1042 break
1061 break
1043 elif s in final:
1062 elif s in final:
1044 # non final node, replace with closure
1063 # non final node, replace with closure
1045 succs.remove(s)
1064 succs.remove(s)
1046 succs.update(final[s])
1065 succs.update(final[s])
1047 else:
1066 else:
1048 final[x] = succs
1067 final[x] = succs
1049 toproceed.remove(x)
1068 toproceed.remove(x)
1050 # remove tmpnodes from final mapping
1069 # remove tmpnodes from final mapping
1051 for n in tmpnodes:
1070 for n in tmpnodes:
1052 del final[n]
1071 del final[n]
1053 # we expect all changes involved in final to exist in the repo
1072 # we expect all changes involved in final to exist in the repo
1054 # turn `final` into list (topologically sorted)
1073 # turn `final` into list (topologically sorted)
1055 nm = state.repo.changelog.nodemap
1074 nm = state.repo.changelog.nodemap
1056 for prec, succs in final.items():
1075 for prec, succs in final.items():
1057 final[prec] = sorted(succs, key=nm.get)
1076 final[prec] = sorted(succs, key=nm.get)
1058
1077
1059 # computed topmost element (necessary for bookmark)
1078 # computed topmost element (necessary for bookmark)
1060 if new:
1079 if new:
1061 newtopmost = sorted(new, key=state.repo.changelog.rev)[-1]
1080 newtopmost = sorted(new, key=state.repo.changelog.rev)[-1]
1062 elif not final:
1081 elif not final:
1063 # Nothing rewritten at all. we won't need `newtopmost`
1082 # Nothing rewritten at all. we won't need `newtopmost`
1064 # It is the same as `oldtopmost` and `processreplacement` know it
1083 # It is the same as `oldtopmost` and `processreplacement` know it
1065 newtopmost = None
1084 newtopmost = None
1066 else:
1085 else:
1067 # every body died. The newtopmost is the parent of the root.
1086 # every body died. The newtopmost is the parent of the root.
1068 r = state.repo.changelog.rev
1087 r = state.repo.changelog.rev
1069 newtopmost = state.repo[sorted(final, key=r)[0]].p1().node()
1088 newtopmost = state.repo[sorted(final, key=r)[0]].p1().node()
1070
1089
1071 return final, tmpnodes, new, newtopmost
1090 return final, tmpnodes, new, newtopmost
1072
1091
1073 def movebookmarks(ui, repo, mapping, oldtopmost, newtopmost):
1092 def movebookmarks(ui, repo, mapping, oldtopmost, newtopmost):
1074 """Move bookmark from old to newly created node"""
1093 """Move bookmark from old to newly created node"""
1075 if not mapping:
1094 if not mapping:
1076 # if nothing got rewritten there is not purpose for this function
1095 # if nothing got rewritten there is not purpose for this function
1077 return
1096 return
1078 moves = []
1097 moves = []
1079 for bk, old in sorted(repo._bookmarks.iteritems()):
1098 for bk, old in sorted(repo._bookmarks.iteritems()):
1080 if old == oldtopmost:
1099 if old == oldtopmost:
1081 # special case ensure bookmark stay on tip.
1100 # special case ensure bookmark stay on tip.
1082 #
1101 #
1083 # This is arguably a feature and we may only want that for the
1102 # This is arguably a feature and we may only want that for the
1084 # active bookmark. But the behavior is kept compatible with the old
1103 # active bookmark. But the behavior is kept compatible with the old
1085 # version for now.
1104 # version for now.
1086 moves.append((bk, newtopmost))
1105 moves.append((bk, newtopmost))
1087 continue
1106 continue
1088 base = old
1107 base = old
1089 new = mapping.get(base, None)
1108 new = mapping.get(base, None)
1090 if new is None:
1109 if new is None:
1091 continue
1110 continue
1092 while not new:
1111 while not new:
1093 # base is killed, trying with parent
1112 # base is killed, trying with parent
1094 base = repo[base].p1().node()
1113 base = repo[base].p1().node()
1095 new = mapping.get(base, (base,))
1114 new = mapping.get(base, (base,))
1096 # nothing to move
1115 # nothing to move
1097 moves.append((bk, new[-1]))
1116 moves.append((bk, new[-1]))
1098 if moves:
1117 if moves:
1099 marks = repo._bookmarks
1118 marks = repo._bookmarks
1100 for mark, new in moves:
1119 for mark, new in moves:
1101 old = marks[mark]
1120 old = marks[mark]
1102 ui.note(_('histedit: moving bookmarks %s from %s to %s\n')
1121 ui.note(_('histedit: moving bookmarks %s from %s to %s\n')
1103 % (mark, node.short(old), node.short(new)))
1122 % (mark, node.short(old), node.short(new)))
1104 marks[mark] = new
1123 marks[mark] = new
1105 marks.write()
1124 marks.write()
1106
1125
1107 def cleanupnode(ui, repo, name, nodes):
1126 def cleanupnode(ui, repo, name, nodes):
1108 """strip a group of nodes from the repository
1127 """strip a group of nodes from the repository
1109
1128
1110 The set of node to strip may contains unknown nodes."""
1129 The set of node to strip may contains unknown nodes."""
1111 ui.debug('should strip %s nodes %s\n' %
1130 ui.debug('should strip %s nodes %s\n' %
1112 (name, ', '.join([node.short(n) for n in nodes])))
1131 (name, ', '.join([node.short(n) for n in nodes])))
1113 lock = None
1132 lock = None
1114 try:
1133 try:
1115 lock = repo.lock()
1134 lock = repo.lock()
1116 # Find all node that need to be stripped
1135 # Find all node that need to be stripped
1117 # (we hg %lr instead of %ln to silently ignore unknown item
1136 # (we hg %lr instead of %ln to silently ignore unknown item
1118 nm = repo.changelog.nodemap
1137 nm = repo.changelog.nodemap
1119 nodes = sorted(n for n in nodes if n in nm)
1138 nodes = sorted(n for n in nodes if n in nm)
1120 roots = [c.node() for c in repo.set("roots(%ln)", nodes)]
1139 roots = [c.node() for c in repo.set("roots(%ln)", nodes)]
1121 for c in roots:
1140 for c in roots:
1122 # We should process node in reverse order to strip tip most first.
1141 # We should process node in reverse order to strip tip most first.
1123 # but this trigger a bug in changegroup hook.
1142 # but this trigger a bug in changegroup hook.
1124 # This would reduce bundle overhead
1143 # This would reduce bundle overhead
1125 repair.strip(ui, repo, c)
1144 repair.strip(ui, repo, c)
1126 finally:
1145 finally:
1127 release(lock)
1146 release(lock)
1128
1147
1129 def stripwrapper(orig, ui, repo, nodelist, *args, **kwargs):
1148 def stripwrapper(orig, ui, repo, nodelist, *args, **kwargs):
1130 if isinstance(nodelist, str):
1149 if isinstance(nodelist, str):
1131 nodelist = [nodelist]
1150 nodelist = [nodelist]
1132 if os.path.exists(os.path.join(repo.path, 'histedit-state')):
1151 if os.path.exists(os.path.join(repo.path, 'histedit-state')):
1133 state = histeditstate(repo)
1152 state = histeditstate(repo)
1134 state.read()
1153 state.read()
1135 histedit_nodes = set([repo[rulehash].node() for (action, rulehash)
1154 histedit_nodes = set([repo[rulehash].node() for (action, rulehash)
1136 in state.rules if rulehash in repo])
1155 in state.rules if rulehash in repo])
1137 strip_nodes = set([repo[n].node() for n in nodelist])
1156 strip_nodes = set([repo[n].node() for n in nodelist])
1138 common_nodes = histedit_nodes & strip_nodes
1157 common_nodes = histedit_nodes & strip_nodes
1139 if common_nodes:
1158 if common_nodes:
1140 raise util.Abort(_("histedit in progress, can't strip %s")
1159 raise util.Abort(_("histedit in progress, can't strip %s")
1141 % ', '.join(node.short(x) for x in common_nodes))
1160 % ', '.join(node.short(x) for x in common_nodes))
1142 return orig(ui, repo, nodelist, *args, **kwargs)
1161 return orig(ui, repo, nodelist, *args, **kwargs)
1143
1162
1144 extensions.wrapfunction(repair, 'strip', stripwrapper)
1163 extensions.wrapfunction(repair, 'strip', stripwrapper)
1145
1164
1146 def summaryhook(ui, repo):
1165 def summaryhook(ui, repo):
1147 if not os.path.exists(repo.join('histedit-state')):
1166 if not os.path.exists(repo.join('histedit-state')):
1148 return
1167 return
1149 state = histeditstate(repo)
1168 state = histeditstate(repo)
1150 state.read()
1169 state.read()
1151 if state.rules:
1170 if state.rules:
1152 # i18n: column positioning for "hg summary"
1171 # i18n: column positioning for "hg summary"
1153 ui.write(_('hist: %s (histedit --continue)\n') %
1172 ui.write(_('hist: %s (histedit --continue)\n') %
1154 (ui.label(_('%d remaining'), 'histedit.remaining') %
1173 (ui.label(_('%d remaining'), 'histedit.remaining') %
1155 len(state.rules)))
1174 len(state.rules)))
1156
1175
1157 def extsetup(ui):
1176 def extsetup(ui):
1158 cmdutil.summaryhooks.add('histedit', summaryhook)
1177 cmdutil.summaryhooks.add('histedit', summaryhook)
1159 cmdutil.unfinishedstates.append(
1178 cmdutil.unfinishedstates.append(
1160 ['histedit-state', False, True, _('histedit in progress'),
1179 ['histedit-state', False, True, _('histedit in progress'),
1161 _("use 'hg histedit --continue' or 'hg histedit --abort'")])
1180 _("use 'hg histedit --continue' or 'hg histedit --abort'")])
General Comments 0
You need to be logged in to leave comments. Login now