##// END OF EJS Templates
histedit: fix grammar for help for safety aborts
timeless@mozdev.org -
r26096:b237a68b default
parent child Browse files
Show More
@@ -1,1180 +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 also aborted if there are ambiguous
679 outgoing revisions which may confuse users: for example, there are
679 outgoing revisions which may confuse users: for example, if there
680 multiple branches containing outgoing revisions.
680 are 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 tmpnodes, leafs = newnodestoabort(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 if repo.unfiltered().revs('parents() and (%n or %ln::)',
794 if repo.unfiltered().revs('parents() and (%n or %ln::)',
795 state.parentctxnode, leafs | tmpnodes):
795 state.parentctxnode, leafs | tmpnodes):
796 hg.clean(repo, state.topmost)
796 hg.clean(repo, state.topmost)
797 cleanupnode(ui, repo, 'created', tmpnodes)
797 cleanupnode(ui, repo, 'created', tmpnodes)
798 cleanupnode(ui, repo, 'temp', leafs)
798 cleanupnode(ui, repo, 'temp', leafs)
799 state.clear()
799 state.clear()
800 return
800 return
801 else:
801 else:
802 cmdutil.checkunfinished(repo)
802 cmdutil.checkunfinished(repo)
803 cmdutil.bailifchanged(repo)
803 cmdutil.bailifchanged(repo)
804
804
805 topmost, empty = repo.dirstate.parents()
805 topmost, empty = repo.dirstate.parents()
806 if outg:
806 if outg:
807 if freeargs:
807 if freeargs:
808 remote = freeargs[0]
808 remote = freeargs[0]
809 else:
809 else:
810 remote = None
810 remote = None
811 root = findoutgoing(ui, repo, remote, force, opts)
811 root = findoutgoing(ui, repo, remote, force, opts)
812 else:
812 else:
813 rr = list(repo.set('roots(%ld)', scmutil.revrange(repo, revs)))
813 rr = list(repo.set('roots(%ld)', scmutil.revrange(repo, revs)))
814 if len(rr) != 1:
814 if len(rr) != 1:
815 raise util.Abort(_('The specified revisions must have '
815 raise util.Abort(_('The specified revisions must have '
816 'exactly one common root'))
816 'exactly one common root'))
817 root = rr[0].node()
817 root = rr[0].node()
818
818
819 revs = between(repo, root, topmost, state.keep)
819 revs = between(repo, root, topmost, state.keep)
820 if not revs:
820 if not revs:
821 raise util.Abort(_('%s is not an ancestor of working directory') %
821 raise util.Abort(_('%s is not an ancestor of working directory') %
822 node.short(root))
822 node.short(root))
823
823
824 ctxs = [repo[r] for r in revs]
824 ctxs = [repo[r] for r in revs]
825 if not rules:
825 if not rules:
826 comment = editcomment % (node.short(root), node.short(topmost))
826 comment = editcomment % (node.short(root), node.short(topmost))
827 rules = ruleeditor(repo, ui, [['pick', c] for c in ctxs], comment)
827 rules = ruleeditor(repo, ui, [['pick', c] for c in ctxs], comment)
828 else:
828 else:
829 if rules == '-':
829 if rules == '-':
830 f = sys.stdin
830 f = sys.stdin
831 else:
831 else:
832 f = open(rules)
832 f = open(rules)
833 rules = f.read()
833 rules = f.read()
834 f.close()
834 f.close()
835 rules = [l for l in (r.strip() for r in rules.splitlines())
835 rules = [l for l in (r.strip() for r in rules.splitlines())
836 if l and not l.startswith('#')]
836 if l and not l.startswith('#')]
837 rules = verifyrules(rules, repo, ctxs)
837 rules = verifyrules(rules, repo, ctxs)
838
838
839 parentctxnode = repo[root].parents()[0].node()
839 parentctxnode = repo[root].parents()[0].node()
840
840
841 state.parentctxnode = parentctxnode
841 state.parentctxnode = parentctxnode
842 state.rules = rules
842 state.rules = rules
843 state.topmost = topmost
843 state.topmost = topmost
844 state.replacements = replacements
844 state.replacements = replacements
845
845
846 # Create a backup so we can always abort completely.
846 # Create a backup so we can always abort completely.
847 backupfile = None
847 backupfile = None
848 if not obsolete.isenabled(repo, obsolete.createmarkersopt):
848 if not obsolete.isenabled(repo, obsolete.createmarkersopt):
849 backupfile = repair._bundle(repo, [parentctxnode], [topmost], root,
849 backupfile = repair._bundle(repo, [parentctxnode], [topmost], root,
850 'histedit')
850 'histedit')
851 state.backupfile = backupfile
851 state.backupfile = backupfile
852
852
853 while state.rules:
853 while state.rules:
854 state.write()
854 state.write()
855 action, ha = state.rules.pop(0)
855 action, ha = state.rules.pop(0)
856 ui.debug('histedit: processing %s %s\n' % (action, ha[:12]))
856 ui.debug('histedit: processing %s %s\n' % (action, ha[:12]))
857 actobj = actiontable[action].fromrule(state, ha)
857 actobj = actiontable[action].fromrule(state, ha)
858 parentctx, replacement_ = actobj.run()
858 parentctx, replacement_ = actobj.run()
859 state.parentctxnode = parentctx.node()
859 state.parentctxnode = parentctx.node()
860 state.replacements.extend(replacement_)
860 state.replacements.extend(replacement_)
861 state.write()
861 state.write()
862
862
863 hg.update(repo, state.parentctxnode)
863 hg.update(repo, state.parentctxnode)
864
864
865 mapping, tmpnodes, created, ntm = processreplacement(state)
865 mapping, tmpnodes, created, ntm = processreplacement(state)
866 if mapping:
866 if mapping:
867 for prec, succs in mapping.iteritems():
867 for prec, succs in mapping.iteritems():
868 if not succs:
868 if not succs:
869 ui.debug('histedit: %s is dropped\n' % node.short(prec))
869 ui.debug('histedit: %s is dropped\n' % node.short(prec))
870 else:
870 else:
871 ui.debug('histedit: %s is replaced by %s\n' % (
871 ui.debug('histedit: %s is replaced by %s\n' % (
872 node.short(prec), node.short(succs[0])))
872 node.short(prec), node.short(succs[0])))
873 if len(succs) > 1:
873 if len(succs) > 1:
874 m = 'histedit: %s'
874 m = 'histedit: %s'
875 for n in succs[1:]:
875 for n in succs[1:]:
876 ui.debug(m % node.short(n))
876 ui.debug(m % node.short(n))
877
877
878 if not state.keep:
878 if not state.keep:
879 if mapping:
879 if mapping:
880 movebookmarks(ui, repo, mapping, state.topmost, ntm)
880 movebookmarks(ui, repo, mapping, state.topmost, ntm)
881 # TODO update mq state
881 # TODO update mq state
882 if supportsmarkers:
882 if supportsmarkers:
883 markers = []
883 markers = []
884 # sort by revision number because it sound "right"
884 # sort by revision number because it sound "right"
885 for prec in sorted(mapping, key=repo.changelog.rev):
885 for prec in sorted(mapping, key=repo.changelog.rev):
886 succs = mapping[prec]
886 succs = mapping[prec]
887 markers.append((repo[prec],
887 markers.append((repo[prec],
888 tuple(repo[s] for s in succs)))
888 tuple(repo[s] for s in succs)))
889 if markers:
889 if markers:
890 obsolete.createmarkers(repo, markers)
890 obsolete.createmarkers(repo, markers)
891 else:
891 else:
892 cleanupnode(ui, repo, 'replaced', mapping)
892 cleanupnode(ui, repo, 'replaced', mapping)
893
893
894 cleanupnode(ui, repo, 'temp', tmpnodes)
894 cleanupnode(ui, repo, 'temp', tmpnodes)
895 state.clear()
895 state.clear()
896 if os.path.exists(repo.sjoin('undo')):
896 if os.path.exists(repo.sjoin('undo')):
897 os.unlink(repo.sjoin('undo'))
897 os.unlink(repo.sjoin('undo'))
898
898
899 def bootstrapcontinue(ui, state, opts):
899 def bootstrapcontinue(ui, state, opts):
900 repo = state.repo
900 repo = state.repo
901 if state.rules:
901 if state.rules:
902 action, currentnode = state.rules.pop(0)
902 action, currentnode = state.rules.pop(0)
903
903
904 actobj = actiontable[action].fromrule(state, currentnode)
904 actobj = actiontable[action].fromrule(state, currentnode)
905
905
906 s = repo.status()
906 s = repo.status()
907 if s.modified or s.added or s.removed or s.deleted:
907 if s.modified or s.added or s.removed or s.deleted:
908 actobj.continuedirty()
908 actobj.continuedirty()
909 s = repo.status()
909 s = repo.status()
910 if s.modified or s.added or s.removed or s.deleted:
910 if s.modified or s.added or s.removed or s.deleted:
911 raise util.Abort(_("working copy still dirty"))
911 raise util.Abort(_("working copy still dirty"))
912
912
913 parentctx, replacements = actobj.continueclean()
913 parentctx, replacements = actobj.continueclean()
914
914
915 state.parentctxnode = parentctx.node()
915 state.parentctxnode = parentctx.node()
916 state.replacements.extend(replacements)
916 state.replacements.extend(replacements)
917
917
918 return state
918 return state
919
919
920 def between(repo, old, new, keep):
920 def between(repo, old, new, keep):
921 """select and validate the set of revision to edit
921 """select and validate the set of revision to edit
922
922
923 When keep is false, the specified set can't have children."""
923 When keep is false, the specified set can't have children."""
924 ctxs = list(repo.set('%n::%n', old, new))
924 ctxs = list(repo.set('%n::%n', old, new))
925 if ctxs and not keep:
925 if ctxs and not keep:
926 if (not obsolete.isenabled(repo, obsolete.allowunstableopt) and
926 if (not obsolete.isenabled(repo, obsolete.allowunstableopt) and
927 repo.revs('(%ld::) - (%ld)', ctxs, ctxs)):
927 repo.revs('(%ld::) - (%ld)', ctxs, ctxs)):
928 raise util.Abort(_('cannot edit history that would orphan nodes'))
928 raise util.Abort(_('cannot edit history that would orphan nodes'))
929 if repo.revs('(%ld) and merge()', ctxs):
929 if repo.revs('(%ld) and merge()', ctxs):
930 raise util.Abort(_('cannot edit history that contains merges'))
930 raise util.Abort(_('cannot edit history that contains merges'))
931 root = ctxs[0] # list is already sorted by repo.set
931 root = ctxs[0] # list is already sorted by repo.set
932 if not root.mutable():
932 if not root.mutable():
933 raise util.Abort(_('cannot edit public changeset: %s') % root,
933 raise util.Abort(_('cannot edit public changeset: %s') % root,
934 hint=_('see "hg help phases" for details'))
934 hint=_('see "hg help phases" for details'))
935 return [c.node() for c in ctxs]
935 return [c.node() for c in ctxs]
936
936
937 def makedesc(repo, action, rev):
937 def makedesc(repo, action, rev):
938 """build a initial action line for a ctx
938 """build a initial action line for a ctx
939
939
940 line are in the form:
940 line are in the form:
941
941
942 <action> <hash> <rev> <summary>
942 <action> <hash> <rev> <summary>
943 """
943 """
944 ctx = repo[rev]
944 ctx = repo[rev]
945 summary = ''
945 summary = ''
946 if ctx.description():
946 if ctx.description():
947 summary = ctx.description().splitlines()[0]
947 summary = ctx.description().splitlines()[0]
948 line = '%s %s %d %s' % (action, ctx, ctx.rev(), summary)
948 line = '%s %s %d %s' % (action, ctx, ctx.rev(), summary)
949 # trim to 80 columns so it's not stupidly wide in my editor
949 # trim to 80 columns so it's not stupidly wide in my editor
950 maxlen = repo.ui.configint('histedit', 'linelen', default=80)
950 maxlen = repo.ui.configint('histedit', 'linelen', default=80)
951 maxlen = max(maxlen, 22) # avoid truncating hash
951 maxlen = max(maxlen, 22) # avoid truncating hash
952 return util.ellipsis(line, maxlen)
952 return util.ellipsis(line, maxlen)
953
953
954 def ruleeditor(repo, ui, rules, editcomment=""):
954 def ruleeditor(repo, ui, rules, editcomment=""):
955 """open an editor to edit rules
955 """open an editor to edit rules
956
956
957 rules are in the format [ [act, ctx], ...] like in state.rules
957 rules are in the format [ [act, ctx], ...] like in state.rules
958 """
958 """
959 rules = '\n'.join([makedesc(repo, act, rev) for [act, rev] in rules])
959 rules = '\n'.join([makedesc(repo, act, rev) for [act, rev] in rules])
960 rules += '\n\n'
960 rules += '\n\n'
961 rules += editcomment
961 rules += editcomment
962 rules = ui.edit(rules, ui.username())
962 rules = ui.edit(rules, ui.username())
963
963
964 # Save edit rules in .hg/histedit-last-edit.txt in case
964 # Save edit rules in .hg/histedit-last-edit.txt in case
965 # the user needs to ask for help after something
965 # the user needs to ask for help after something
966 # surprising happens.
966 # surprising happens.
967 f = open(repo.join('histedit-last-edit.txt'), 'w')
967 f = open(repo.join('histedit-last-edit.txt'), 'w')
968 f.write(rules)
968 f.write(rules)
969 f.close()
969 f.close()
970
970
971 return rules
971 return rules
972
972
973 def verifyrules(rules, repo, ctxs):
973 def verifyrules(rules, repo, ctxs):
974 """Verify that there exists exactly one edit rule per given changeset.
974 """Verify that there exists exactly one edit rule per given changeset.
975
975
976 Will abort if there are to many or too few rules, a malformed rule,
976 Will abort if there are to many or too few rules, a malformed rule,
977 or a rule on a changeset outside of the user-given range.
977 or a rule on a changeset outside of the user-given range.
978 """
978 """
979 parsed = []
979 parsed = []
980 expected = set(c.hex() for c in ctxs)
980 expected = set(c.hex() for c in ctxs)
981 seen = set()
981 seen = set()
982 for r in rules:
982 for r in rules:
983 if ' ' not in r:
983 if ' ' not in r:
984 raise util.Abort(_('malformed line "%s"') % r)
984 raise util.Abort(_('malformed line "%s"') % r)
985 action, rest = r.split(' ', 1)
985 action, rest = r.split(' ', 1)
986 ha = rest.strip().split(' ', 1)[0]
986 ha = rest.strip().split(' ', 1)[0]
987 try:
987 try:
988 ha = repo[ha].hex()
988 ha = repo[ha].hex()
989 except error.RepoError:
989 except error.RepoError:
990 raise util.Abort(_('unknown changeset %s listed') % ha[:12])
990 raise util.Abort(_('unknown changeset %s listed') % ha[:12])
991 if ha not in expected:
991 if ha not in expected:
992 raise util.Abort(
992 raise util.Abort(
993 _('may not use changesets other than the ones listed'))
993 _('may not use changesets other than the ones listed'))
994 if ha in seen:
994 if ha in seen:
995 raise util.Abort(_('duplicated command for changeset %s') %
995 raise util.Abort(_('duplicated command for changeset %s') %
996 ha[:12])
996 ha[:12])
997 seen.add(ha)
997 seen.add(ha)
998 if action not in actiontable:
998 if action not in actiontable:
999 raise util.Abort(_('unknown action "%s"') % action)
999 raise util.Abort(_('unknown action "%s"') % action)
1000 parsed.append([action, ha])
1000 parsed.append([action, ha])
1001 missing = sorted(expected - seen) # sort to stabilize output
1001 missing = sorted(expected - seen) # sort to stabilize output
1002 if missing:
1002 if missing:
1003 raise util.Abort(_('missing rules for changeset %s') %
1003 raise util.Abort(_('missing rules for changeset %s') %
1004 missing[0][:12],
1004 missing[0][:12],
1005 hint=_('do you want to use the drop action?'))
1005 hint=_('do you want to use the drop action?'))
1006 return parsed
1006 return parsed
1007
1007
1008 def newnodestoabort(state):
1008 def newnodestoabort(state):
1009 """process the list of replacements to return
1009 """process the list of replacements to return
1010
1010
1011 1) the list of final node
1011 1) the list of final node
1012 2) the list of temporary node
1012 2) the list of temporary node
1013
1013
1014 This meant to be used on abort as less data are required in this case.
1014 This meant to be used on abort as less data are required in this case.
1015 """
1015 """
1016 replacements = state.replacements
1016 replacements = state.replacements
1017 allsuccs = set()
1017 allsuccs = set()
1018 replaced = set()
1018 replaced = set()
1019 for rep in replacements:
1019 for rep in replacements:
1020 allsuccs.update(rep[1])
1020 allsuccs.update(rep[1])
1021 replaced.add(rep[0])
1021 replaced.add(rep[0])
1022 newnodes = allsuccs - replaced
1022 newnodes = allsuccs - replaced
1023 tmpnodes = allsuccs & replaced
1023 tmpnodes = allsuccs & replaced
1024 return newnodes, tmpnodes
1024 return newnodes, tmpnodes
1025
1025
1026
1026
1027 def processreplacement(state):
1027 def processreplacement(state):
1028 """process the list of replacements to return
1028 """process the list of replacements to return
1029
1029
1030 1) the final mapping between original and created nodes
1030 1) the final mapping between original and created nodes
1031 2) the list of temporary node created by histedit
1031 2) the list of temporary node created by histedit
1032 3) the list of new commit created by histedit"""
1032 3) the list of new commit created by histedit"""
1033 replacements = state.replacements
1033 replacements = state.replacements
1034 allsuccs = set()
1034 allsuccs = set()
1035 replaced = set()
1035 replaced = set()
1036 fullmapping = {}
1036 fullmapping = {}
1037 # initialize basic set
1037 # initialize basic set
1038 # fullmapping records all operations recorded in replacement
1038 # fullmapping records all operations recorded in replacement
1039 for rep in replacements:
1039 for rep in replacements:
1040 allsuccs.update(rep[1])
1040 allsuccs.update(rep[1])
1041 replaced.add(rep[0])
1041 replaced.add(rep[0])
1042 fullmapping.setdefault(rep[0], set()).update(rep[1])
1042 fullmapping.setdefault(rep[0], set()).update(rep[1])
1043 new = allsuccs - replaced
1043 new = allsuccs - replaced
1044 tmpnodes = allsuccs & replaced
1044 tmpnodes = allsuccs & replaced
1045 # Reduce content fullmapping into direct relation between original nodes
1045 # Reduce content fullmapping into direct relation between original nodes
1046 # and final node created during history edition
1046 # and final node created during history edition
1047 # Dropped changeset are replaced by an empty list
1047 # Dropped changeset are replaced by an empty list
1048 toproceed = set(fullmapping)
1048 toproceed = set(fullmapping)
1049 final = {}
1049 final = {}
1050 while toproceed:
1050 while toproceed:
1051 for x in list(toproceed):
1051 for x in list(toproceed):
1052 succs = fullmapping[x]
1052 succs = fullmapping[x]
1053 for s in list(succs):
1053 for s in list(succs):
1054 if s in toproceed:
1054 if s in toproceed:
1055 # non final node with unknown closure
1055 # non final node with unknown closure
1056 # We can't process this now
1056 # We can't process this now
1057 break
1057 break
1058 elif s in final:
1058 elif s in final:
1059 # non final node, replace with closure
1059 # non final node, replace with closure
1060 succs.remove(s)
1060 succs.remove(s)
1061 succs.update(final[s])
1061 succs.update(final[s])
1062 else:
1062 else:
1063 final[x] = succs
1063 final[x] = succs
1064 toproceed.remove(x)
1064 toproceed.remove(x)
1065 # remove tmpnodes from final mapping
1065 # remove tmpnodes from final mapping
1066 for n in tmpnodes:
1066 for n in tmpnodes:
1067 del final[n]
1067 del final[n]
1068 # we expect all changes involved in final to exist in the repo
1068 # we expect all changes involved in final to exist in the repo
1069 # turn `final` into list (topologically sorted)
1069 # turn `final` into list (topologically sorted)
1070 nm = state.repo.changelog.nodemap
1070 nm = state.repo.changelog.nodemap
1071 for prec, succs in final.items():
1071 for prec, succs in final.items():
1072 final[prec] = sorted(succs, key=nm.get)
1072 final[prec] = sorted(succs, key=nm.get)
1073
1073
1074 # computed topmost element (necessary for bookmark)
1074 # computed topmost element (necessary for bookmark)
1075 if new:
1075 if new:
1076 newtopmost = sorted(new, key=state.repo.changelog.rev)[-1]
1076 newtopmost = sorted(new, key=state.repo.changelog.rev)[-1]
1077 elif not final:
1077 elif not final:
1078 # Nothing rewritten at all. we won't need `newtopmost`
1078 # Nothing rewritten at all. we won't need `newtopmost`
1079 # It is the same as `oldtopmost` and `processreplacement` know it
1079 # It is the same as `oldtopmost` and `processreplacement` know it
1080 newtopmost = None
1080 newtopmost = None
1081 else:
1081 else:
1082 # every body died. The newtopmost is the parent of the root.
1082 # every body died. The newtopmost is the parent of the root.
1083 r = state.repo.changelog.rev
1083 r = state.repo.changelog.rev
1084 newtopmost = state.repo[sorted(final, key=r)[0]].p1().node()
1084 newtopmost = state.repo[sorted(final, key=r)[0]].p1().node()
1085
1085
1086 return final, tmpnodes, new, newtopmost
1086 return final, tmpnodes, new, newtopmost
1087
1087
1088 def movebookmarks(ui, repo, mapping, oldtopmost, newtopmost):
1088 def movebookmarks(ui, repo, mapping, oldtopmost, newtopmost):
1089 """Move bookmark from old to newly created node"""
1089 """Move bookmark from old to newly created node"""
1090 if not mapping:
1090 if not mapping:
1091 # if nothing got rewritten there is not purpose for this function
1091 # if nothing got rewritten there is not purpose for this function
1092 return
1092 return
1093 moves = []
1093 moves = []
1094 for bk, old in sorted(repo._bookmarks.iteritems()):
1094 for bk, old in sorted(repo._bookmarks.iteritems()):
1095 if old == oldtopmost:
1095 if old == oldtopmost:
1096 # special case ensure bookmark stay on tip.
1096 # special case ensure bookmark stay on tip.
1097 #
1097 #
1098 # This is arguably a feature and we may only want that for the
1098 # This is arguably a feature and we may only want that for the
1099 # active bookmark. But the behavior is kept compatible with the old
1099 # active bookmark. But the behavior is kept compatible with the old
1100 # version for now.
1100 # version for now.
1101 moves.append((bk, newtopmost))
1101 moves.append((bk, newtopmost))
1102 continue
1102 continue
1103 base = old
1103 base = old
1104 new = mapping.get(base, None)
1104 new = mapping.get(base, None)
1105 if new is None:
1105 if new is None:
1106 continue
1106 continue
1107 while not new:
1107 while not new:
1108 # base is killed, trying with parent
1108 # base is killed, trying with parent
1109 base = repo[base].p1().node()
1109 base = repo[base].p1().node()
1110 new = mapping.get(base, (base,))
1110 new = mapping.get(base, (base,))
1111 # nothing to move
1111 # nothing to move
1112 moves.append((bk, new[-1]))
1112 moves.append((bk, new[-1]))
1113 if moves:
1113 if moves:
1114 marks = repo._bookmarks
1114 marks = repo._bookmarks
1115 for mark, new in moves:
1115 for mark, new in moves:
1116 old = marks[mark]
1116 old = marks[mark]
1117 ui.note(_('histedit: moving bookmarks %s from %s to %s\n')
1117 ui.note(_('histedit: moving bookmarks %s from %s to %s\n')
1118 % (mark, node.short(old), node.short(new)))
1118 % (mark, node.short(old), node.short(new)))
1119 marks[mark] = new
1119 marks[mark] = new
1120 marks.write()
1120 marks.write()
1121
1121
1122 def cleanupnode(ui, repo, name, nodes):
1122 def cleanupnode(ui, repo, name, nodes):
1123 """strip a group of nodes from the repository
1123 """strip a group of nodes from the repository
1124
1124
1125 The set of node to strip may contains unknown nodes."""
1125 The set of node to strip may contains unknown nodes."""
1126 ui.debug('should strip %s nodes %s\n' %
1126 ui.debug('should strip %s nodes %s\n' %
1127 (name, ', '.join([node.short(n) for n in nodes])))
1127 (name, ', '.join([node.short(n) for n in nodes])))
1128 lock = None
1128 lock = None
1129 try:
1129 try:
1130 lock = repo.lock()
1130 lock = repo.lock()
1131 # do not let filtering get in the way of the cleanse
1131 # do not let filtering get in the way of the cleanse
1132 # we should probably get ride of obsolescence marker created during the
1132 # we should probably get ride of obsolescence marker created during the
1133 # histedit, but we currently do not have such information.
1133 # histedit, but we currently do not have such information.
1134 repo = repo.unfiltered()
1134 repo = repo.unfiltered()
1135 # Find all node that need to be stripped
1135 # Find all node that need to be stripped
1136 # (we hg %lr instead of %ln to silently ignore unknown item
1136 # (we hg %lr instead of %ln to silently ignore unknown item
1137 nm = repo.changelog.nodemap
1137 nm = repo.changelog.nodemap
1138 nodes = sorted(n for n in nodes if n in nm)
1138 nodes = sorted(n for n in nodes if n in nm)
1139 roots = [c.node() for c in repo.set("roots(%ln)", nodes)]
1139 roots = [c.node() for c in repo.set("roots(%ln)", nodes)]
1140 for c in roots:
1140 for c in roots:
1141 # 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.
1142 # but this trigger a bug in changegroup hook.
1142 # but this trigger a bug in changegroup hook.
1143 # This would reduce bundle overhead
1143 # This would reduce bundle overhead
1144 repair.strip(ui, repo, c)
1144 repair.strip(ui, repo, c)
1145 finally:
1145 finally:
1146 release(lock)
1146 release(lock)
1147
1147
1148 def stripwrapper(orig, ui, repo, nodelist, *args, **kwargs):
1148 def stripwrapper(orig, ui, repo, nodelist, *args, **kwargs):
1149 if isinstance(nodelist, str):
1149 if isinstance(nodelist, str):
1150 nodelist = [nodelist]
1150 nodelist = [nodelist]
1151 if os.path.exists(os.path.join(repo.path, 'histedit-state')):
1151 if os.path.exists(os.path.join(repo.path, 'histedit-state')):
1152 state = histeditstate(repo)
1152 state = histeditstate(repo)
1153 state.read()
1153 state.read()
1154 histedit_nodes = set([repo[rulehash].node() for (action, rulehash)
1154 histedit_nodes = set([repo[rulehash].node() for (action, rulehash)
1155 in state.rules if rulehash in repo])
1155 in state.rules if rulehash in repo])
1156 strip_nodes = set([repo[n].node() for n in nodelist])
1156 strip_nodes = set([repo[n].node() for n in nodelist])
1157 common_nodes = histedit_nodes & strip_nodes
1157 common_nodes = histedit_nodes & strip_nodes
1158 if common_nodes:
1158 if common_nodes:
1159 raise util.Abort(_("histedit in progress, can't strip %s")
1159 raise util.Abort(_("histedit in progress, can't strip %s")
1160 % ', '.join(node.short(x) for x in common_nodes))
1160 % ', '.join(node.short(x) for x in common_nodes))
1161 return orig(ui, repo, nodelist, *args, **kwargs)
1161 return orig(ui, repo, nodelist, *args, **kwargs)
1162
1162
1163 extensions.wrapfunction(repair, 'strip', stripwrapper)
1163 extensions.wrapfunction(repair, 'strip', stripwrapper)
1164
1164
1165 def summaryhook(ui, repo):
1165 def summaryhook(ui, repo):
1166 if not os.path.exists(repo.join('histedit-state')):
1166 if not os.path.exists(repo.join('histedit-state')):
1167 return
1167 return
1168 state = histeditstate(repo)
1168 state = histeditstate(repo)
1169 state.read()
1169 state.read()
1170 if state.rules:
1170 if state.rules:
1171 # i18n: column positioning for "hg summary"
1171 # i18n: column positioning for "hg summary"
1172 ui.write(_('hist: %s (histedit --continue)\n') %
1172 ui.write(_('hist: %s (histedit --continue)\n') %
1173 (ui.label(_('%d remaining'), 'histedit.remaining') %
1173 (ui.label(_('%d remaining'), 'histedit.remaining') %
1174 len(state.rules)))
1174 len(state.rules)))
1175
1175
1176 def extsetup(ui):
1176 def extsetup(ui):
1177 cmdutil.summaryhooks.add('histedit', summaryhook)
1177 cmdutil.summaryhooks.add('histedit', summaryhook)
1178 cmdutil.unfinishedstates.append(
1178 cmdutil.unfinishedstates.append(
1179 ['histedit-state', False, True, _('histedit in progress'),
1179 ['histedit-state', False, True, _('histedit in progress'),
1180 _("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