##// END OF EJS Templates
mq/qqueue: add --purge option to delete a queue and its patch dir...
"Yann E. MORIN" -
r11967:6e3875a8 default
parent child Browse files
Show More
@@ -1,3102 +1,3109 b''
1 # mq.py - patch queues for mercurial
1 # mq.py - patch queues for mercurial
2 #
2 #
3 # Copyright 2005, 2006 Chris Mason <mason@suse.com>
3 # Copyright 2005, 2006 Chris Mason <mason@suse.com>
4 #
4 #
5 # This software may be used and distributed according to the terms of the
5 # This software may be used and distributed according to the terms of the
6 # GNU General Public License version 2 or any later version.
6 # GNU General Public License version 2 or any later version.
7
7
8 '''manage a stack of patches
8 '''manage a stack of patches
9
9
10 This extension lets you work with a stack of patches in a Mercurial
10 This extension lets you work with a stack of patches in a Mercurial
11 repository. It manages two stacks of patches - all known patches, and
11 repository. It manages two stacks of patches - all known patches, and
12 applied patches (subset of known patches).
12 applied patches (subset of known patches).
13
13
14 Known patches are represented as patch files in the .hg/patches
14 Known patches are represented as patch files in the .hg/patches
15 directory. Applied patches are both patch files and changesets.
15 directory. Applied patches are both patch files and changesets.
16
16
17 Common tasks (use :hg:`help command` for more details)::
17 Common tasks (use :hg:`help command` for more details)::
18
18
19 create new patch qnew
19 create new patch qnew
20 import existing patch qimport
20 import existing patch qimport
21
21
22 print patch series qseries
22 print patch series qseries
23 print applied patches qapplied
23 print applied patches qapplied
24
24
25 add known patch to applied stack qpush
25 add known patch to applied stack qpush
26 remove patch from applied stack qpop
26 remove patch from applied stack qpop
27 refresh contents of top applied patch qrefresh
27 refresh contents of top applied patch qrefresh
28
28
29 By default, mq will automatically use git patches when required to
29 By default, mq will automatically use git patches when required to
30 avoid losing file mode changes, copy records, binary files or empty
30 avoid losing file mode changes, copy records, binary files or empty
31 files creations or deletions. This behaviour can be configured with::
31 files creations or deletions. This behaviour can be configured with::
32
32
33 [mq]
33 [mq]
34 git = auto/keep/yes/no
34 git = auto/keep/yes/no
35
35
36 If set to 'keep', mq will obey the [diff] section configuration while
36 If set to 'keep', mq will obey the [diff] section configuration while
37 preserving existing git patches upon qrefresh. If set to 'yes' or
37 preserving existing git patches upon qrefresh. If set to 'yes' or
38 'no', mq will override the [diff] section and always generate git or
38 'no', mq will override the [diff] section and always generate git or
39 regular patches, possibly losing data in the second case.
39 regular patches, possibly losing data in the second case.
40
40
41 You will by default be managing a patch queue named "patches". You can
41 You will by default be managing a patch queue named "patches". You can
42 create other, independent patch queues with the :hg:`qqueue` command.
42 create other, independent patch queues with the :hg:`qqueue` command.
43 '''
43 '''
44
44
45 from mercurial.i18n import _
45 from mercurial.i18n import _
46 from mercurial.node import bin, hex, short, nullid, nullrev
46 from mercurial.node import bin, hex, short, nullid, nullrev
47 from mercurial.lock import release
47 from mercurial.lock import release
48 from mercurial import commands, cmdutil, hg, patch, util
48 from mercurial import commands, cmdutil, hg, patch, util
49 from mercurial import repair, extensions, url, error
49 from mercurial import repair, extensions, url, error
50 import os, sys, re, errno
50 import os, sys, re, errno, shutil
51
51
52 commands.norepo += " qclone"
52 commands.norepo += " qclone"
53
53
54 # Patch names looks like unix-file names.
54 # Patch names looks like unix-file names.
55 # They must be joinable with queue directory and result in the patch path.
55 # They must be joinable with queue directory and result in the patch path.
56 normname = util.normpath
56 normname = util.normpath
57
57
58 class statusentry(object):
58 class statusentry(object):
59 def __init__(self, node, name):
59 def __init__(self, node, name):
60 self.node, self.name = node, name
60 self.node, self.name = node, name
61 def __repr__(self):
61 def __repr__(self):
62 return hex(self.node) + ':' + self.name
62 return hex(self.node) + ':' + self.name
63
63
64 class patchheader(object):
64 class patchheader(object):
65 def __init__(self, pf, plainmode=False):
65 def __init__(self, pf, plainmode=False):
66 def eatdiff(lines):
66 def eatdiff(lines):
67 while lines:
67 while lines:
68 l = lines[-1]
68 l = lines[-1]
69 if (l.startswith("diff -") or
69 if (l.startswith("diff -") or
70 l.startswith("Index:") or
70 l.startswith("Index:") or
71 l.startswith("===========")):
71 l.startswith("===========")):
72 del lines[-1]
72 del lines[-1]
73 else:
73 else:
74 break
74 break
75 def eatempty(lines):
75 def eatempty(lines):
76 while lines:
76 while lines:
77 if not lines[-1].strip():
77 if not lines[-1].strip():
78 del lines[-1]
78 del lines[-1]
79 else:
79 else:
80 break
80 break
81
81
82 message = []
82 message = []
83 comments = []
83 comments = []
84 user = None
84 user = None
85 date = None
85 date = None
86 parent = None
86 parent = None
87 format = None
87 format = None
88 subject = None
88 subject = None
89 diffstart = 0
89 diffstart = 0
90
90
91 for line in file(pf):
91 for line in file(pf):
92 line = line.rstrip()
92 line = line.rstrip()
93 if (line.startswith('diff --git')
93 if (line.startswith('diff --git')
94 or (diffstart and line.startswith('+++ '))):
94 or (diffstart and line.startswith('+++ '))):
95 diffstart = 2
95 diffstart = 2
96 break
96 break
97 diffstart = 0 # reset
97 diffstart = 0 # reset
98 if line.startswith("--- "):
98 if line.startswith("--- "):
99 diffstart = 1
99 diffstart = 1
100 continue
100 continue
101 elif format == "hgpatch":
101 elif format == "hgpatch":
102 # parse values when importing the result of an hg export
102 # parse values when importing the result of an hg export
103 if line.startswith("# User "):
103 if line.startswith("# User "):
104 user = line[7:]
104 user = line[7:]
105 elif line.startswith("# Date "):
105 elif line.startswith("# Date "):
106 date = line[7:]
106 date = line[7:]
107 elif line.startswith("# Parent "):
107 elif line.startswith("# Parent "):
108 parent = line[9:]
108 parent = line[9:]
109 elif not line.startswith("# ") and line:
109 elif not line.startswith("# ") and line:
110 message.append(line)
110 message.append(line)
111 format = None
111 format = None
112 elif line == '# HG changeset patch':
112 elif line == '# HG changeset patch':
113 message = []
113 message = []
114 format = "hgpatch"
114 format = "hgpatch"
115 elif (format != "tagdone" and (line.startswith("Subject: ") or
115 elif (format != "tagdone" and (line.startswith("Subject: ") or
116 line.startswith("subject: "))):
116 line.startswith("subject: "))):
117 subject = line[9:]
117 subject = line[9:]
118 format = "tag"
118 format = "tag"
119 elif (format != "tagdone" and (line.startswith("From: ") or
119 elif (format != "tagdone" and (line.startswith("From: ") or
120 line.startswith("from: "))):
120 line.startswith("from: "))):
121 user = line[6:]
121 user = line[6:]
122 format = "tag"
122 format = "tag"
123 elif (format != "tagdone" and (line.startswith("Date: ") or
123 elif (format != "tagdone" and (line.startswith("Date: ") or
124 line.startswith("date: "))):
124 line.startswith("date: "))):
125 date = line[6:]
125 date = line[6:]
126 format = "tag"
126 format = "tag"
127 elif format == "tag" and line == "":
127 elif format == "tag" and line == "":
128 # when looking for tags (subject: from: etc) they
128 # when looking for tags (subject: from: etc) they
129 # end once you find a blank line in the source
129 # end once you find a blank line in the source
130 format = "tagdone"
130 format = "tagdone"
131 elif message or line:
131 elif message or line:
132 message.append(line)
132 message.append(line)
133 comments.append(line)
133 comments.append(line)
134
134
135 eatdiff(message)
135 eatdiff(message)
136 eatdiff(comments)
136 eatdiff(comments)
137 eatempty(message)
137 eatempty(message)
138 eatempty(comments)
138 eatempty(comments)
139
139
140 # make sure message isn't empty
140 # make sure message isn't empty
141 if format and format.startswith("tag") and subject:
141 if format and format.startswith("tag") and subject:
142 message.insert(0, "")
142 message.insert(0, "")
143 message.insert(0, subject)
143 message.insert(0, subject)
144
144
145 self.message = message
145 self.message = message
146 self.comments = comments
146 self.comments = comments
147 self.user = user
147 self.user = user
148 self.date = date
148 self.date = date
149 self.parent = parent
149 self.parent = parent
150 self.haspatch = diffstart > 1
150 self.haspatch = diffstart > 1
151 self.plainmode = plainmode
151 self.plainmode = plainmode
152
152
153 def setuser(self, user):
153 def setuser(self, user):
154 if not self.updateheader(['From: ', '# User '], user):
154 if not self.updateheader(['From: ', '# User '], user):
155 try:
155 try:
156 patchheaderat = self.comments.index('# HG changeset patch')
156 patchheaderat = self.comments.index('# HG changeset patch')
157 self.comments.insert(patchheaderat + 1, '# User ' + user)
157 self.comments.insert(patchheaderat + 1, '# User ' + user)
158 except ValueError:
158 except ValueError:
159 if self.plainmode or self._hasheader(['Date: ']):
159 if self.plainmode or self._hasheader(['Date: ']):
160 self.comments = ['From: ' + user] + self.comments
160 self.comments = ['From: ' + user] + self.comments
161 else:
161 else:
162 tmp = ['# HG changeset patch', '# User ' + user, '']
162 tmp = ['# HG changeset patch', '# User ' + user, '']
163 self.comments = tmp + self.comments
163 self.comments = tmp + self.comments
164 self.user = user
164 self.user = user
165
165
166 def setdate(self, date):
166 def setdate(self, date):
167 if not self.updateheader(['Date: ', '# Date '], date):
167 if not self.updateheader(['Date: ', '# Date '], date):
168 try:
168 try:
169 patchheaderat = self.comments.index('# HG changeset patch')
169 patchheaderat = self.comments.index('# HG changeset patch')
170 self.comments.insert(patchheaderat + 1, '# Date ' + date)
170 self.comments.insert(patchheaderat + 1, '# Date ' + date)
171 except ValueError:
171 except ValueError:
172 if self.plainmode or self._hasheader(['From: ']):
172 if self.plainmode or self._hasheader(['From: ']):
173 self.comments = ['Date: ' + date] + self.comments
173 self.comments = ['Date: ' + date] + self.comments
174 else:
174 else:
175 tmp = ['# HG changeset patch', '# Date ' + date, '']
175 tmp = ['# HG changeset patch', '# Date ' + date, '']
176 self.comments = tmp + self.comments
176 self.comments = tmp + self.comments
177 self.date = date
177 self.date = date
178
178
179 def setparent(self, parent):
179 def setparent(self, parent):
180 if not self.updateheader(['# Parent '], parent):
180 if not self.updateheader(['# Parent '], parent):
181 try:
181 try:
182 patchheaderat = self.comments.index('# HG changeset patch')
182 patchheaderat = self.comments.index('# HG changeset patch')
183 self.comments.insert(patchheaderat + 1, '# Parent ' + parent)
183 self.comments.insert(patchheaderat + 1, '# Parent ' + parent)
184 except ValueError:
184 except ValueError:
185 pass
185 pass
186 self.parent = parent
186 self.parent = parent
187
187
188 def setmessage(self, message):
188 def setmessage(self, message):
189 if self.comments:
189 if self.comments:
190 self._delmsg()
190 self._delmsg()
191 self.message = [message]
191 self.message = [message]
192 self.comments += self.message
192 self.comments += self.message
193
193
194 def updateheader(self, prefixes, new):
194 def updateheader(self, prefixes, new):
195 '''Update all references to a field in the patch header.
195 '''Update all references to a field in the patch header.
196 Return whether the field is present.'''
196 Return whether the field is present.'''
197 res = False
197 res = False
198 for prefix in prefixes:
198 for prefix in prefixes:
199 for i in xrange(len(self.comments)):
199 for i in xrange(len(self.comments)):
200 if self.comments[i].startswith(prefix):
200 if self.comments[i].startswith(prefix):
201 self.comments[i] = prefix + new
201 self.comments[i] = prefix + new
202 res = True
202 res = True
203 break
203 break
204 return res
204 return res
205
205
206 def _hasheader(self, prefixes):
206 def _hasheader(self, prefixes):
207 '''Check if a header starts with any of the given prefixes.'''
207 '''Check if a header starts with any of the given prefixes.'''
208 for prefix in prefixes:
208 for prefix in prefixes:
209 for comment in self.comments:
209 for comment in self.comments:
210 if comment.startswith(prefix):
210 if comment.startswith(prefix):
211 return True
211 return True
212 return False
212 return False
213
213
214 def __str__(self):
214 def __str__(self):
215 if not self.comments:
215 if not self.comments:
216 return ''
216 return ''
217 return '\n'.join(self.comments) + '\n\n'
217 return '\n'.join(self.comments) + '\n\n'
218
218
219 def _delmsg(self):
219 def _delmsg(self):
220 '''Remove existing message, keeping the rest of the comments fields.
220 '''Remove existing message, keeping the rest of the comments fields.
221 If comments contains 'subject: ', message will prepend
221 If comments contains 'subject: ', message will prepend
222 the field and a blank line.'''
222 the field and a blank line.'''
223 if self.message:
223 if self.message:
224 subj = 'subject: ' + self.message[0].lower()
224 subj = 'subject: ' + self.message[0].lower()
225 for i in xrange(len(self.comments)):
225 for i in xrange(len(self.comments)):
226 if subj == self.comments[i].lower():
226 if subj == self.comments[i].lower():
227 del self.comments[i]
227 del self.comments[i]
228 self.message = self.message[2:]
228 self.message = self.message[2:]
229 break
229 break
230 ci = 0
230 ci = 0
231 for mi in self.message:
231 for mi in self.message:
232 while mi != self.comments[ci]:
232 while mi != self.comments[ci]:
233 ci += 1
233 ci += 1
234 del self.comments[ci]
234 del self.comments[ci]
235
235
236 class queue(object):
236 class queue(object):
237 def __init__(self, ui, path, patchdir=None):
237 def __init__(self, ui, path, patchdir=None):
238 self.basepath = path
238 self.basepath = path
239 try:
239 try:
240 fh = open(os.path.join(path, 'patches.queue'))
240 fh = open(os.path.join(path, 'patches.queue'))
241 cur = fh.read().rstrip()
241 cur = fh.read().rstrip()
242 if not cur:
242 if not cur:
243 curpath = os.path.join(path, 'patches')
243 curpath = os.path.join(path, 'patches')
244 else:
244 else:
245 curpath = os.path.join(path, 'patches-' + cur)
245 curpath = os.path.join(path, 'patches-' + cur)
246 except IOError:
246 except IOError:
247 curpath = os.path.join(path, 'patches')
247 curpath = os.path.join(path, 'patches')
248 self.path = patchdir or curpath
248 self.path = patchdir or curpath
249 self.opener = util.opener(self.path)
249 self.opener = util.opener(self.path)
250 self.ui = ui
250 self.ui = ui
251 self.applied_dirty = 0
251 self.applied_dirty = 0
252 self.series_dirty = 0
252 self.series_dirty = 0
253 self.added = []
253 self.added = []
254 self.series_path = "series"
254 self.series_path = "series"
255 self.status_path = "status"
255 self.status_path = "status"
256 self.guards_path = "guards"
256 self.guards_path = "guards"
257 self.active_guards = None
257 self.active_guards = None
258 self.guards_dirty = False
258 self.guards_dirty = False
259 # Handle mq.git as a bool with extended values
259 # Handle mq.git as a bool with extended values
260 try:
260 try:
261 gitmode = ui.configbool('mq', 'git', None)
261 gitmode = ui.configbool('mq', 'git', None)
262 if gitmode is None:
262 if gitmode is None:
263 raise error.ConfigError()
263 raise error.ConfigError()
264 self.gitmode = gitmode and 'yes' or 'no'
264 self.gitmode = gitmode and 'yes' or 'no'
265 except error.ConfigError:
265 except error.ConfigError:
266 self.gitmode = ui.config('mq', 'git', 'auto').lower()
266 self.gitmode = ui.config('mq', 'git', 'auto').lower()
267 self.plainmode = ui.configbool('mq', 'plain', False)
267 self.plainmode = ui.configbool('mq', 'plain', False)
268
268
269 @util.propertycache
269 @util.propertycache
270 def applied(self):
270 def applied(self):
271 if os.path.exists(self.join(self.status_path)):
271 if os.path.exists(self.join(self.status_path)):
272 def parse(l):
272 def parse(l):
273 n, name = l.split(':', 1)
273 n, name = l.split(':', 1)
274 return statusentry(bin(n), name)
274 return statusentry(bin(n), name)
275 lines = self.opener(self.status_path).read().splitlines()
275 lines = self.opener(self.status_path).read().splitlines()
276 return [parse(l) for l in lines]
276 return [parse(l) for l in lines]
277 return []
277 return []
278
278
279 @util.propertycache
279 @util.propertycache
280 def full_series(self):
280 def full_series(self):
281 if os.path.exists(self.join(self.series_path)):
281 if os.path.exists(self.join(self.series_path)):
282 return self.opener(self.series_path).read().splitlines()
282 return self.opener(self.series_path).read().splitlines()
283 return []
283 return []
284
284
285 @util.propertycache
285 @util.propertycache
286 def series(self):
286 def series(self):
287 self.parse_series()
287 self.parse_series()
288 return self.series
288 return self.series
289
289
290 @util.propertycache
290 @util.propertycache
291 def series_guards(self):
291 def series_guards(self):
292 self.parse_series()
292 self.parse_series()
293 return self.series_guards
293 return self.series_guards
294
294
295 def invalidate(self):
295 def invalidate(self):
296 for a in 'applied full_series series series_guards'.split():
296 for a in 'applied full_series series series_guards'.split():
297 if a in self.__dict__:
297 if a in self.__dict__:
298 delattr(self, a)
298 delattr(self, a)
299 self.applied_dirty = 0
299 self.applied_dirty = 0
300 self.series_dirty = 0
300 self.series_dirty = 0
301 self.guards_dirty = False
301 self.guards_dirty = False
302 self.active_guards = None
302 self.active_guards = None
303
303
304 def diffopts(self, opts={}, patchfn=None):
304 def diffopts(self, opts={}, patchfn=None):
305 diffopts = patch.diffopts(self.ui, opts)
305 diffopts = patch.diffopts(self.ui, opts)
306 if self.gitmode == 'auto':
306 if self.gitmode == 'auto':
307 diffopts.upgrade = True
307 diffopts.upgrade = True
308 elif self.gitmode == 'keep':
308 elif self.gitmode == 'keep':
309 pass
309 pass
310 elif self.gitmode in ('yes', 'no'):
310 elif self.gitmode in ('yes', 'no'):
311 diffopts.git = self.gitmode == 'yes'
311 diffopts.git = self.gitmode == 'yes'
312 else:
312 else:
313 raise util.Abort(_('mq.git option can be auto/keep/yes/no'
313 raise util.Abort(_('mq.git option can be auto/keep/yes/no'
314 ' got %s') % self.gitmode)
314 ' got %s') % self.gitmode)
315 if patchfn:
315 if patchfn:
316 diffopts = self.patchopts(diffopts, patchfn)
316 diffopts = self.patchopts(diffopts, patchfn)
317 return diffopts
317 return diffopts
318
318
319 def patchopts(self, diffopts, *patches):
319 def patchopts(self, diffopts, *patches):
320 """Return a copy of input diff options with git set to true if
320 """Return a copy of input diff options with git set to true if
321 referenced patch is a git patch and should be preserved as such.
321 referenced patch is a git patch and should be preserved as such.
322 """
322 """
323 diffopts = diffopts.copy()
323 diffopts = diffopts.copy()
324 if not diffopts.git and self.gitmode == 'keep':
324 if not diffopts.git and self.gitmode == 'keep':
325 for patchfn in patches:
325 for patchfn in patches:
326 patchf = self.opener(patchfn, 'r')
326 patchf = self.opener(patchfn, 'r')
327 # if the patch was a git patch, refresh it as a git patch
327 # if the patch was a git patch, refresh it as a git patch
328 for line in patchf:
328 for line in patchf:
329 if line.startswith('diff --git'):
329 if line.startswith('diff --git'):
330 diffopts.git = True
330 diffopts.git = True
331 break
331 break
332 patchf.close()
332 patchf.close()
333 return diffopts
333 return diffopts
334
334
335 def join(self, *p):
335 def join(self, *p):
336 return os.path.join(self.path, *p)
336 return os.path.join(self.path, *p)
337
337
338 def find_series(self, patch):
338 def find_series(self, patch):
339 def matchpatch(l):
339 def matchpatch(l):
340 l = l.split('#', 1)[0]
340 l = l.split('#', 1)[0]
341 return l.strip() == patch
341 return l.strip() == patch
342 for index, l in enumerate(self.full_series):
342 for index, l in enumerate(self.full_series):
343 if matchpatch(l):
343 if matchpatch(l):
344 return index
344 return index
345 return None
345 return None
346
346
347 guard_re = re.compile(r'\s?#([-+][^-+# \t\r\n\f][^# \t\r\n\f]*)')
347 guard_re = re.compile(r'\s?#([-+][^-+# \t\r\n\f][^# \t\r\n\f]*)')
348
348
349 def parse_series(self):
349 def parse_series(self):
350 self.series = []
350 self.series = []
351 self.series_guards = []
351 self.series_guards = []
352 for l in self.full_series:
352 for l in self.full_series:
353 h = l.find('#')
353 h = l.find('#')
354 if h == -1:
354 if h == -1:
355 patch = l
355 patch = l
356 comment = ''
356 comment = ''
357 elif h == 0:
357 elif h == 0:
358 continue
358 continue
359 else:
359 else:
360 patch = l[:h]
360 patch = l[:h]
361 comment = l[h:]
361 comment = l[h:]
362 patch = patch.strip()
362 patch = patch.strip()
363 if patch:
363 if patch:
364 if patch in self.series:
364 if patch in self.series:
365 raise util.Abort(_('%s appears more than once in %s') %
365 raise util.Abort(_('%s appears more than once in %s') %
366 (patch, self.join(self.series_path)))
366 (patch, self.join(self.series_path)))
367 self.series.append(patch)
367 self.series.append(patch)
368 self.series_guards.append(self.guard_re.findall(comment))
368 self.series_guards.append(self.guard_re.findall(comment))
369
369
370 def check_guard(self, guard):
370 def check_guard(self, guard):
371 if not guard:
371 if not guard:
372 return _('guard cannot be an empty string')
372 return _('guard cannot be an empty string')
373 bad_chars = '# \t\r\n\f'
373 bad_chars = '# \t\r\n\f'
374 first = guard[0]
374 first = guard[0]
375 if first in '-+':
375 if first in '-+':
376 return (_('guard %r starts with invalid character: %r') %
376 return (_('guard %r starts with invalid character: %r') %
377 (guard, first))
377 (guard, first))
378 for c in bad_chars:
378 for c in bad_chars:
379 if c in guard:
379 if c in guard:
380 return _('invalid character in guard %r: %r') % (guard, c)
380 return _('invalid character in guard %r: %r') % (guard, c)
381
381
382 def set_active(self, guards):
382 def set_active(self, guards):
383 for guard in guards:
383 for guard in guards:
384 bad = self.check_guard(guard)
384 bad = self.check_guard(guard)
385 if bad:
385 if bad:
386 raise util.Abort(bad)
386 raise util.Abort(bad)
387 guards = sorted(set(guards))
387 guards = sorted(set(guards))
388 self.ui.debug('active guards: %s\n' % ' '.join(guards))
388 self.ui.debug('active guards: %s\n' % ' '.join(guards))
389 self.active_guards = guards
389 self.active_guards = guards
390 self.guards_dirty = True
390 self.guards_dirty = True
391
391
392 def active(self):
392 def active(self):
393 if self.active_guards is None:
393 if self.active_guards is None:
394 self.active_guards = []
394 self.active_guards = []
395 try:
395 try:
396 guards = self.opener(self.guards_path).read().split()
396 guards = self.opener(self.guards_path).read().split()
397 except IOError, err:
397 except IOError, err:
398 if err.errno != errno.ENOENT:
398 if err.errno != errno.ENOENT:
399 raise
399 raise
400 guards = []
400 guards = []
401 for i, guard in enumerate(guards):
401 for i, guard in enumerate(guards):
402 bad = self.check_guard(guard)
402 bad = self.check_guard(guard)
403 if bad:
403 if bad:
404 self.ui.warn('%s:%d: %s\n' %
404 self.ui.warn('%s:%d: %s\n' %
405 (self.join(self.guards_path), i + 1, bad))
405 (self.join(self.guards_path), i + 1, bad))
406 else:
406 else:
407 self.active_guards.append(guard)
407 self.active_guards.append(guard)
408 return self.active_guards
408 return self.active_guards
409
409
410 def set_guards(self, idx, guards):
410 def set_guards(self, idx, guards):
411 for g in guards:
411 for g in guards:
412 if len(g) < 2:
412 if len(g) < 2:
413 raise util.Abort(_('guard %r too short') % g)
413 raise util.Abort(_('guard %r too short') % g)
414 if g[0] not in '-+':
414 if g[0] not in '-+':
415 raise util.Abort(_('guard %r starts with invalid char') % g)
415 raise util.Abort(_('guard %r starts with invalid char') % g)
416 bad = self.check_guard(g[1:])
416 bad = self.check_guard(g[1:])
417 if bad:
417 if bad:
418 raise util.Abort(bad)
418 raise util.Abort(bad)
419 drop = self.guard_re.sub('', self.full_series[idx])
419 drop = self.guard_re.sub('', self.full_series[idx])
420 self.full_series[idx] = drop + ''.join([' #' + g for g in guards])
420 self.full_series[idx] = drop + ''.join([' #' + g for g in guards])
421 self.parse_series()
421 self.parse_series()
422 self.series_dirty = True
422 self.series_dirty = True
423
423
424 def pushable(self, idx):
424 def pushable(self, idx):
425 if isinstance(idx, str):
425 if isinstance(idx, str):
426 idx = self.series.index(idx)
426 idx = self.series.index(idx)
427 patchguards = self.series_guards[idx]
427 patchguards = self.series_guards[idx]
428 if not patchguards:
428 if not patchguards:
429 return True, None
429 return True, None
430 guards = self.active()
430 guards = self.active()
431 exactneg = [g for g in patchguards if g[0] == '-' and g[1:] in guards]
431 exactneg = [g for g in patchguards if g[0] == '-' and g[1:] in guards]
432 if exactneg:
432 if exactneg:
433 return False, exactneg[0]
433 return False, exactneg[0]
434 pos = [g for g in patchguards if g[0] == '+']
434 pos = [g for g in patchguards if g[0] == '+']
435 exactpos = [g for g in pos if g[1:] in guards]
435 exactpos = [g for g in pos if g[1:] in guards]
436 if pos:
436 if pos:
437 if exactpos:
437 if exactpos:
438 return True, exactpos[0]
438 return True, exactpos[0]
439 return False, pos
439 return False, pos
440 return True, ''
440 return True, ''
441
441
442 def explain_pushable(self, idx, all_patches=False):
442 def explain_pushable(self, idx, all_patches=False):
443 write = all_patches and self.ui.write or self.ui.warn
443 write = all_patches and self.ui.write or self.ui.warn
444 if all_patches or self.ui.verbose:
444 if all_patches or self.ui.verbose:
445 if isinstance(idx, str):
445 if isinstance(idx, str):
446 idx = self.series.index(idx)
446 idx = self.series.index(idx)
447 pushable, why = self.pushable(idx)
447 pushable, why = self.pushable(idx)
448 if all_patches and pushable:
448 if all_patches and pushable:
449 if why is None:
449 if why is None:
450 write(_('allowing %s - no guards in effect\n') %
450 write(_('allowing %s - no guards in effect\n') %
451 self.series[idx])
451 self.series[idx])
452 else:
452 else:
453 if not why:
453 if not why:
454 write(_('allowing %s - no matching negative guards\n') %
454 write(_('allowing %s - no matching negative guards\n') %
455 self.series[idx])
455 self.series[idx])
456 else:
456 else:
457 write(_('allowing %s - guarded by %r\n') %
457 write(_('allowing %s - guarded by %r\n') %
458 (self.series[idx], why))
458 (self.series[idx], why))
459 if not pushable:
459 if not pushable:
460 if why:
460 if why:
461 write(_('skipping %s - guarded by %r\n') %
461 write(_('skipping %s - guarded by %r\n') %
462 (self.series[idx], why))
462 (self.series[idx], why))
463 else:
463 else:
464 write(_('skipping %s - no matching guards\n') %
464 write(_('skipping %s - no matching guards\n') %
465 self.series[idx])
465 self.series[idx])
466
466
467 def save_dirty(self):
467 def save_dirty(self):
468 def write_list(items, path):
468 def write_list(items, path):
469 fp = self.opener(path, 'w')
469 fp = self.opener(path, 'w')
470 for i in items:
470 for i in items:
471 fp.write("%s\n" % i)
471 fp.write("%s\n" % i)
472 fp.close()
472 fp.close()
473 if self.applied_dirty:
473 if self.applied_dirty:
474 write_list(map(str, self.applied), self.status_path)
474 write_list(map(str, self.applied), self.status_path)
475 if self.series_dirty:
475 if self.series_dirty:
476 write_list(self.full_series, self.series_path)
476 write_list(self.full_series, self.series_path)
477 if self.guards_dirty:
477 if self.guards_dirty:
478 write_list(self.active_guards, self.guards_path)
478 write_list(self.active_guards, self.guards_path)
479 if self.added:
479 if self.added:
480 qrepo = self.qrepo()
480 qrepo = self.qrepo()
481 if qrepo:
481 if qrepo:
482 qrepo[None].add(self.added)
482 qrepo[None].add(self.added)
483 self.added = []
483 self.added = []
484
484
485 def removeundo(self, repo):
485 def removeundo(self, repo):
486 undo = repo.sjoin('undo')
486 undo = repo.sjoin('undo')
487 if not os.path.exists(undo):
487 if not os.path.exists(undo):
488 return
488 return
489 try:
489 try:
490 os.unlink(undo)
490 os.unlink(undo)
491 except OSError, inst:
491 except OSError, inst:
492 self.ui.warn(_('error removing undo: %s\n') % str(inst))
492 self.ui.warn(_('error removing undo: %s\n') % str(inst))
493
493
494 def printdiff(self, repo, diffopts, node1, node2=None, files=None,
494 def printdiff(self, repo, diffopts, node1, node2=None, files=None,
495 fp=None, changes=None, opts={}):
495 fp=None, changes=None, opts={}):
496 stat = opts.get('stat')
496 stat = opts.get('stat')
497 m = cmdutil.match(repo, files, opts)
497 m = cmdutil.match(repo, files, opts)
498 cmdutil.diffordiffstat(self.ui, repo, diffopts, node1, node2, m,
498 cmdutil.diffordiffstat(self.ui, repo, diffopts, node1, node2, m,
499 changes, stat, fp)
499 changes, stat, fp)
500
500
501 def mergeone(self, repo, mergeq, head, patch, rev, diffopts):
501 def mergeone(self, repo, mergeq, head, patch, rev, diffopts):
502 # first try just applying the patch
502 # first try just applying the patch
503 (err, n) = self.apply(repo, [patch], update_status=False,
503 (err, n) = self.apply(repo, [patch], update_status=False,
504 strict=True, merge=rev)
504 strict=True, merge=rev)
505
505
506 if err == 0:
506 if err == 0:
507 return (err, n)
507 return (err, n)
508
508
509 if n is None:
509 if n is None:
510 raise util.Abort(_("apply failed for patch %s") % patch)
510 raise util.Abort(_("apply failed for patch %s") % patch)
511
511
512 self.ui.warn(_("patch didn't work out, merging %s\n") % patch)
512 self.ui.warn(_("patch didn't work out, merging %s\n") % patch)
513
513
514 # apply failed, strip away that rev and merge.
514 # apply failed, strip away that rev and merge.
515 hg.clean(repo, head)
515 hg.clean(repo, head)
516 self.strip(repo, [n], update=False, backup='strip')
516 self.strip(repo, [n], update=False, backup='strip')
517
517
518 ctx = repo[rev]
518 ctx = repo[rev]
519 ret = hg.merge(repo, rev)
519 ret = hg.merge(repo, rev)
520 if ret:
520 if ret:
521 raise util.Abort(_("update returned %d") % ret)
521 raise util.Abort(_("update returned %d") % ret)
522 n = repo.commit(ctx.description(), ctx.user(), force=True)
522 n = repo.commit(ctx.description(), ctx.user(), force=True)
523 if n is None:
523 if n is None:
524 raise util.Abort(_("repo commit failed"))
524 raise util.Abort(_("repo commit failed"))
525 try:
525 try:
526 ph = patchheader(mergeq.join(patch), self.plainmode)
526 ph = patchheader(mergeq.join(patch), self.plainmode)
527 except:
527 except:
528 raise util.Abort(_("unable to read %s") % patch)
528 raise util.Abort(_("unable to read %s") % patch)
529
529
530 diffopts = self.patchopts(diffopts, patch)
530 diffopts = self.patchopts(diffopts, patch)
531 patchf = self.opener(patch, "w")
531 patchf = self.opener(patch, "w")
532 comments = str(ph)
532 comments = str(ph)
533 if comments:
533 if comments:
534 patchf.write(comments)
534 patchf.write(comments)
535 self.printdiff(repo, diffopts, head, n, fp=patchf)
535 self.printdiff(repo, diffopts, head, n, fp=patchf)
536 patchf.close()
536 patchf.close()
537 self.removeundo(repo)
537 self.removeundo(repo)
538 return (0, n)
538 return (0, n)
539
539
540 def qparents(self, repo, rev=None):
540 def qparents(self, repo, rev=None):
541 if rev is None:
541 if rev is None:
542 (p1, p2) = repo.dirstate.parents()
542 (p1, p2) = repo.dirstate.parents()
543 if p2 == nullid:
543 if p2 == nullid:
544 return p1
544 return p1
545 if not self.applied:
545 if not self.applied:
546 return None
546 return None
547 return self.applied[-1].node
547 return self.applied[-1].node
548 p1, p2 = repo.changelog.parents(rev)
548 p1, p2 = repo.changelog.parents(rev)
549 if p2 != nullid and p2 in [x.node for x in self.applied]:
549 if p2 != nullid and p2 in [x.node for x in self.applied]:
550 return p2
550 return p2
551 return p1
551 return p1
552
552
553 def mergepatch(self, repo, mergeq, series, diffopts):
553 def mergepatch(self, repo, mergeq, series, diffopts):
554 if not self.applied:
554 if not self.applied:
555 # each of the patches merged in will have two parents. This
555 # each of the patches merged in will have two parents. This
556 # can confuse the qrefresh, qdiff, and strip code because it
556 # can confuse the qrefresh, qdiff, and strip code because it
557 # needs to know which parent is actually in the patch queue.
557 # needs to know which parent is actually in the patch queue.
558 # so, we insert a merge marker with only one parent. This way
558 # so, we insert a merge marker with only one parent. This way
559 # the first patch in the queue is never a merge patch
559 # the first patch in the queue is never a merge patch
560 #
560 #
561 pname = ".hg.patches.merge.marker"
561 pname = ".hg.patches.merge.marker"
562 n = repo.commit('[mq]: merge marker', force=True)
562 n = repo.commit('[mq]: merge marker', force=True)
563 self.removeundo(repo)
563 self.removeundo(repo)
564 self.applied.append(statusentry(n, pname))
564 self.applied.append(statusentry(n, pname))
565 self.applied_dirty = 1
565 self.applied_dirty = 1
566
566
567 head = self.qparents(repo)
567 head = self.qparents(repo)
568
568
569 for patch in series:
569 for patch in series:
570 patch = mergeq.lookup(patch, strict=True)
570 patch = mergeq.lookup(patch, strict=True)
571 if not patch:
571 if not patch:
572 self.ui.warn(_("patch %s does not exist\n") % patch)
572 self.ui.warn(_("patch %s does not exist\n") % patch)
573 return (1, None)
573 return (1, None)
574 pushable, reason = self.pushable(patch)
574 pushable, reason = self.pushable(patch)
575 if not pushable:
575 if not pushable:
576 self.explain_pushable(patch, all_patches=True)
576 self.explain_pushable(patch, all_patches=True)
577 continue
577 continue
578 info = mergeq.isapplied(patch)
578 info = mergeq.isapplied(patch)
579 if not info:
579 if not info:
580 self.ui.warn(_("patch %s is not applied\n") % patch)
580 self.ui.warn(_("patch %s is not applied\n") % patch)
581 return (1, None)
581 return (1, None)
582 rev = info[1]
582 rev = info[1]
583 err, head = self.mergeone(repo, mergeq, head, patch, rev, diffopts)
583 err, head = self.mergeone(repo, mergeq, head, patch, rev, diffopts)
584 if head:
584 if head:
585 self.applied.append(statusentry(head, patch))
585 self.applied.append(statusentry(head, patch))
586 self.applied_dirty = 1
586 self.applied_dirty = 1
587 if err:
587 if err:
588 return (err, head)
588 return (err, head)
589 self.save_dirty()
589 self.save_dirty()
590 return (0, head)
590 return (0, head)
591
591
592 def patch(self, repo, patchfile):
592 def patch(self, repo, patchfile):
593 '''Apply patchfile to the working directory.
593 '''Apply patchfile to the working directory.
594 patchfile: name of patch file'''
594 patchfile: name of patch file'''
595 files = {}
595 files = {}
596 try:
596 try:
597 fuzz = patch.patch(patchfile, self.ui, strip=1, cwd=repo.root,
597 fuzz = patch.patch(patchfile, self.ui, strip=1, cwd=repo.root,
598 files=files, eolmode=None)
598 files=files, eolmode=None)
599 except Exception, inst:
599 except Exception, inst:
600 self.ui.note(str(inst) + '\n')
600 self.ui.note(str(inst) + '\n')
601 if not self.ui.verbose:
601 if not self.ui.verbose:
602 self.ui.warn(_("patch failed, unable to continue (try -v)\n"))
602 self.ui.warn(_("patch failed, unable to continue (try -v)\n"))
603 return (False, files, False)
603 return (False, files, False)
604
604
605 return (True, files, fuzz)
605 return (True, files, fuzz)
606
606
607 def apply(self, repo, series, list=False, update_status=True,
607 def apply(self, repo, series, list=False, update_status=True,
608 strict=False, patchdir=None, merge=None, all_files=None):
608 strict=False, patchdir=None, merge=None, all_files=None):
609 wlock = lock = tr = None
609 wlock = lock = tr = None
610 try:
610 try:
611 wlock = repo.wlock()
611 wlock = repo.wlock()
612 lock = repo.lock()
612 lock = repo.lock()
613 tr = repo.transaction("qpush")
613 tr = repo.transaction("qpush")
614 try:
614 try:
615 ret = self._apply(repo, series, list, update_status,
615 ret = self._apply(repo, series, list, update_status,
616 strict, patchdir, merge, all_files=all_files)
616 strict, patchdir, merge, all_files=all_files)
617 tr.close()
617 tr.close()
618 self.save_dirty()
618 self.save_dirty()
619 return ret
619 return ret
620 except:
620 except:
621 try:
621 try:
622 tr.abort()
622 tr.abort()
623 finally:
623 finally:
624 repo.invalidate()
624 repo.invalidate()
625 repo.dirstate.invalidate()
625 repo.dirstate.invalidate()
626 raise
626 raise
627 finally:
627 finally:
628 release(tr, lock, wlock)
628 release(tr, lock, wlock)
629 self.removeundo(repo)
629 self.removeundo(repo)
630
630
631 def _apply(self, repo, series, list=False, update_status=True,
631 def _apply(self, repo, series, list=False, update_status=True,
632 strict=False, patchdir=None, merge=None, all_files=None):
632 strict=False, patchdir=None, merge=None, all_files=None):
633 '''returns (error, hash)
633 '''returns (error, hash)
634 error = 1 for unable to read, 2 for patch failed, 3 for patch fuzz'''
634 error = 1 for unable to read, 2 for patch failed, 3 for patch fuzz'''
635 # TODO unify with commands.py
635 # TODO unify with commands.py
636 if not patchdir:
636 if not patchdir:
637 patchdir = self.path
637 patchdir = self.path
638 err = 0
638 err = 0
639 n = None
639 n = None
640 for patchname in series:
640 for patchname in series:
641 pushable, reason = self.pushable(patchname)
641 pushable, reason = self.pushable(patchname)
642 if not pushable:
642 if not pushable:
643 self.explain_pushable(patchname, all_patches=True)
643 self.explain_pushable(patchname, all_patches=True)
644 continue
644 continue
645 self.ui.status(_("applying %s\n") % patchname)
645 self.ui.status(_("applying %s\n") % patchname)
646 pf = os.path.join(patchdir, patchname)
646 pf = os.path.join(patchdir, patchname)
647
647
648 try:
648 try:
649 ph = patchheader(self.join(patchname), self.plainmode)
649 ph = patchheader(self.join(patchname), self.plainmode)
650 except:
650 except:
651 self.ui.warn(_("unable to read %s\n") % patchname)
651 self.ui.warn(_("unable to read %s\n") % patchname)
652 err = 1
652 err = 1
653 break
653 break
654
654
655 message = ph.message
655 message = ph.message
656 if not message:
656 if not message:
657 message = "imported patch %s\n" % patchname
657 message = "imported patch %s\n" % patchname
658 else:
658 else:
659 if list:
659 if list:
660 message.append("\nimported patch %s" % patchname)
660 message.append("\nimported patch %s" % patchname)
661 message = '\n'.join(message)
661 message = '\n'.join(message)
662
662
663 if ph.haspatch:
663 if ph.haspatch:
664 (patcherr, files, fuzz) = self.patch(repo, pf)
664 (patcherr, files, fuzz) = self.patch(repo, pf)
665 if all_files is not None:
665 if all_files is not None:
666 all_files.update(files)
666 all_files.update(files)
667 patcherr = not patcherr
667 patcherr = not patcherr
668 else:
668 else:
669 self.ui.warn(_("patch %s is empty\n") % patchname)
669 self.ui.warn(_("patch %s is empty\n") % patchname)
670 patcherr, files, fuzz = 0, [], 0
670 patcherr, files, fuzz = 0, [], 0
671
671
672 if merge and files:
672 if merge and files:
673 # Mark as removed/merged and update dirstate parent info
673 # Mark as removed/merged and update dirstate parent info
674 removed = []
674 removed = []
675 merged = []
675 merged = []
676 for f in files:
676 for f in files:
677 if os.path.exists(repo.wjoin(f)):
677 if os.path.exists(repo.wjoin(f)):
678 merged.append(f)
678 merged.append(f)
679 else:
679 else:
680 removed.append(f)
680 removed.append(f)
681 for f in removed:
681 for f in removed:
682 repo.dirstate.remove(f)
682 repo.dirstate.remove(f)
683 for f in merged:
683 for f in merged:
684 repo.dirstate.merge(f)
684 repo.dirstate.merge(f)
685 p1, p2 = repo.dirstate.parents()
685 p1, p2 = repo.dirstate.parents()
686 repo.dirstate.setparents(p1, merge)
686 repo.dirstate.setparents(p1, merge)
687
687
688 files = patch.updatedir(self.ui, repo, files)
688 files = patch.updatedir(self.ui, repo, files)
689 match = cmdutil.matchfiles(repo, files or [])
689 match = cmdutil.matchfiles(repo, files or [])
690 n = repo.commit(message, ph.user, ph.date, match=match, force=True)
690 n = repo.commit(message, ph.user, ph.date, match=match, force=True)
691
691
692 if n is None:
692 if n is None:
693 raise util.Abort(_("repo commit failed"))
693 raise util.Abort(_("repo commit failed"))
694
694
695 if update_status:
695 if update_status:
696 self.applied.append(statusentry(n, patchname))
696 self.applied.append(statusentry(n, patchname))
697
697
698 if patcherr:
698 if patcherr:
699 self.ui.warn(_("patch failed, rejects left in working dir\n"))
699 self.ui.warn(_("patch failed, rejects left in working dir\n"))
700 err = 2
700 err = 2
701 break
701 break
702
702
703 if fuzz and strict:
703 if fuzz and strict:
704 self.ui.warn(_("fuzz found when applying patch, stopping\n"))
704 self.ui.warn(_("fuzz found when applying patch, stopping\n"))
705 err = 3
705 err = 3
706 break
706 break
707 return (err, n)
707 return (err, n)
708
708
709 def _cleanup(self, patches, numrevs, keep=False):
709 def _cleanup(self, patches, numrevs, keep=False):
710 if not keep:
710 if not keep:
711 r = self.qrepo()
711 r = self.qrepo()
712 if r:
712 if r:
713 r[None].remove(patches, True)
713 r[None].remove(patches, True)
714 else:
714 else:
715 for p in patches:
715 for p in patches:
716 os.unlink(self.join(p))
716 os.unlink(self.join(p))
717
717
718 if numrevs:
718 if numrevs:
719 del self.applied[:numrevs]
719 del self.applied[:numrevs]
720 self.applied_dirty = 1
720 self.applied_dirty = 1
721
721
722 for i in sorted([self.find_series(p) for p in patches], reverse=True):
722 for i in sorted([self.find_series(p) for p in patches], reverse=True):
723 del self.full_series[i]
723 del self.full_series[i]
724 self.parse_series()
724 self.parse_series()
725 self.series_dirty = 1
725 self.series_dirty = 1
726
726
727 def _revpatches(self, repo, revs):
727 def _revpatches(self, repo, revs):
728 firstrev = repo[self.applied[0].node].rev()
728 firstrev = repo[self.applied[0].node].rev()
729 patches = []
729 patches = []
730 for i, rev in enumerate(revs):
730 for i, rev in enumerate(revs):
731
731
732 if rev < firstrev:
732 if rev < firstrev:
733 raise util.Abort(_('revision %d is not managed') % rev)
733 raise util.Abort(_('revision %d is not managed') % rev)
734
734
735 ctx = repo[rev]
735 ctx = repo[rev]
736 base = self.applied[i].node
736 base = self.applied[i].node
737 if ctx.node() != base:
737 if ctx.node() != base:
738 msg = _('cannot delete revision %d above applied patches')
738 msg = _('cannot delete revision %d above applied patches')
739 raise util.Abort(msg % rev)
739 raise util.Abort(msg % rev)
740
740
741 patch = self.applied[i].name
741 patch = self.applied[i].name
742 for fmt in ('[mq]: %s', 'imported patch %s'):
742 for fmt in ('[mq]: %s', 'imported patch %s'):
743 if ctx.description() == fmt % patch:
743 if ctx.description() == fmt % patch:
744 msg = _('patch %s finalized without changeset message\n')
744 msg = _('patch %s finalized without changeset message\n')
745 repo.ui.status(msg % patch)
745 repo.ui.status(msg % patch)
746 break
746 break
747
747
748 patches.append(patch)
748 patches.append(patch)
749 return patches
749 return patches
750
750
751 def finish(self, repo, revs):
751 def finish(self, repo, revs):
752 patches = self._revpatches(repo, sorted(revs))
752 patches = self._revpatches(repo, sorted(revs))
753 self._cleanup(patches, len(patches))
753 self._cleanup(patches, len(patches))
754
754
755 def delete(self, repo, patches, opts):
755 def delete(self, repo, patches, opts):
756 if not patches and not opts.get('rev'):
756 if not patches and not opts.get('rev'):
757 raise util.Abort(_('qdelete requires at least one revision or '
757 raise util.Abort(_('qdelete requires at least one revision or '
758 'patch name'))
758 'patch name'))
759
759
760 realpatches = []
760 realpatches = []
761 for patch in patches:
761 for patch in patches:
762 patch = self.lookup(patch, strict=True)
762 patch = self.lookup(patch, strict=True)
763 info = self.isapplied(patch)
763 info = self.isapplied(patch)
764 if info:
764 if info:
765 raise util.Abort(_("cannot delete applied patch %s") % patch)
765 raise util.Abort(_("cannot delete applied patch %s") % patch)
766 if patch not in self.series:
766 if patch not in self.series:
767 raise util.Abort(_("patch %s not in series file") % patch)
767 raise util.Abort(_("patch %s not in series file") % patch)
768 realpatches.append(patch)
768 realpatches.append(patch)
769
769
770 numrevs = 0
770 numrevs = 0
771 if opts.get('rev'):
771 if opts.get('rev'):
772 if not self.applied:
772 if not self.applied:
773 raise util.Abort(_('no patches applied'))
773 raise util.Abort(_('no patches applied'))
774 revs = cmdutil.revrange(repo, opts['rev'])
774 revs = cmdutil.revrange(repo, opts['rev'])
775 if len(revs) > 1 and revs[0] > revs[1]:
775 if len(revs) > 1 and revs[0] > revs[1]:
776 revs.reverse()
776 revs.reverse()
777 revpatches = self._revpatches(repo, revs)
777 revpatches = self._revpatches(repo, revs)
778 realpatches += revpatches
778 realpatches += revpatches
779 numrevs = len(revpatches)
779 numrevs = len(revpatches)
780
780
781 self._cleanup(realpatches, numrevs, opts.get('keep'))
781 self._cleanup(realpatches, numrevs, opts.get('keep'))
782
782
783 def check_toppatch(self, repo):
783 def check_toppatch(self, repo):
784 if self.applied:
784 if self.applied:
785 top = self.applied[-1].node
785 top = self.applied[-1].node
786 patch = self.applied[-1].name
786 patch = self.applied[-1].name
787 pp = repo.dirstate.parents()
787 pp = repo.dirstate.parents()
788 if top not in pp:
788 if top not in pp:
789 raise util.Abort(_("working directory revision is not qtip"))
789 raise util.Abort(_("working directory revision is not qtip"))
790 return top, patch
790 return top, patch
791 return None, None
791 return None, None
792
792
793 def check_localchanges(self, repo, force=False, refresh=True):
793 def check_localchanges(self, repo, force=False, refresh=True):
794 m, a, r, d = repo.status()[:4]
794 m, a, r, d = repo.status()[:4]
795 if (m or a or r or d) and not force:
795 if (m or a or r or d) and not force:
796 if refresh:
796 if refresh:
797 raise util.Abort(_("local changes found, refresh first"))
797 raise util.Abort(_("local changes found, refresh first"))
798 else:
798 else:
799 raise util.Abort(_("local changes found"))
799 raise util.Abort(_("local changes found"))
800 return m, a, r, d
800 return m, a, r, d
801
801
802 _reserved = ('series', 'status', 'guards')
802 _reserved = ('series', 'status', 'guards')
803 def check_reserved_name(self, name):
803 def check_reserved_name(self, name):
804 if (name in self._reserved or name.startswith('.hg')
804 if (name in self._reserved or name.startswith('.hg')
805 or name.startswith('.mq') or '#' in name or ':' in name):
805 or name.startswith('.mq') or '#' in name or ':' in name):
806 raise util.Abort(_('"%s" cannot be used as the name of a patch')
806 raise util.Abort(_('"%s" cannot be used as the name of a patch')
807 % name)
807 % name)
808
808
809 def new(self, repo, patchfn, *pats, **opts):
809 def new(self, repo, patchfn, *pats, **opts):
810 """options:
810 """options:
811 msg: a string or a no-argument function returning a string
811 msg: a string or a no-argument function returning a string
812 """
812 """
813 msg = opts.get('msg')
813 msg = opts.get('msg')
814 user = opts.get('user')
814 user = opts.get('user')
815 date = opts.get('date')
815 date = opts.get('date')
816 if date:
816 if date:
817 date = util.parsedate(date)
817 date = util.parsedate(date)
818 diffopts = self.diffopts({'git': opts.get('git')})
818 diffopts = self.diffopts({'git': opts.get('git')})
819 self.check_reserved_name(patchfn)
819 self.check_reserved_name(patchfn)
820 if os.path.exists(self.join(patchfn)):
820 if os.path.exists(self.join(patchfn)):
821 raise util.Abort(_('patch "%s" already exists') % patchfn)
821 raise util.Abort(_('patch "%s" already exists') % patchfn)
822 if opts.get('include') or opts.get('exclude') or pats:
822 if opts.get('include') or opts.get('exclude') or pats:
823 match = cmdutil.match(repo, pats, opts)
823 match = cmdutil.match(repo, pats, opts)
824 # detect missing files in pats
824 # detect missing files in pats
825 def badfn(f, msg):
825 def badfn(f, msg):
826 raise util.Abort('%s: %s' % (f, msg))
826 raise util.Abort('%s: %s' % (f, msg))
827 match.bad = badfn
827 match.bad = badfn
828 m, a, r, d = repo.status(match=match)[:4]
828 m, a, r, d = repo.status(match=match)[:4]
829 else:
829 else:
830 m, a, r, d = self.check_localchanges(repo, force=True)
830 m, a, r, d = self.check_localchanges(repo, force=True)
831 match = cmdutil.matchfiles(repo, m + a + r)
831 match = cmdutil.matchfiles(repo, m + a + r)
832 if len(repo[None].parents()) > 1:
832 if len(repo[None].parents()) > 1:
833 raise util.Abort(_('cannot manage merge changesets'))
833 raise util.Abort(_('cannot manage merge changesets'))
834 commitfiles = m + a + r
834 commitfiles = m + a + r
835 self.check_toppatch(repo)
835 self.check_toppatch(repo)
836 insert = self.full_series_end()
836 insert = self.full_series_end()
837 wlock = repo.wlock()
837 wlock = repo.wlock()
838 try:
838 try:
839 # if patch file write fails, abort early
839 # if patch file write fails, abort early
840 p = self.opener(patchfn, "w")
840 p = self.opener(patchfn, "w")
841 try:
841 try:
842 if self.plainmode:
842 if self.plainmode:
843 if user:
843 if user:
844 p.write("From: " + user + "\n")
844 p.write("From: " + user + "\n")
845 if not date:
845 if not date:
846 p.write("\n")
846 p.write("\n")
847 if date:
847 if date:
848 p.write("Date: %d %d\n\n" % date)
848 p.write("Date: %d %d\n\n" % date)
849 else:
849 else:
850 p.write("# HG changeset patch\n")
850 p.write("# HG changeset patch\n")
851 p.write("# Parent "
851 p.write("# Parent "
852 + hex(repo[None].parents()[0].node()) + "\n")
852 + hex(repo[None].parents()[0].node()) + "\n")
853 if user:
853 if user:
854 p.write("# User " + user + "\n")
854 p.write("# User " + user + "\n")
855 if date:
855 if date:
856 p.write("# Date %s %s\n\n" % date)
856 p.write("# Date %s %s\n\n" % date)
857 if hasattr(msg, '__call__'):
857 if hasattr(msg, '__call__'):
858 msg = msg()
858 msg = msg()
859 commitmsg = msg and msg or ("[mq]: %s" % patchfn)
859 commitmsg = msg and msg or ("[mq]: %s" % patchfn)
860 n = repo.commit(commitmsg, user, date, match=match, force=True)
860 n = repo.commit(commitmsg, user, date, match=match, force=True)
861 if n is None:
861 if n is None:
862 raise util.Abort(_("repo commit failed"))
862 raise util.Abort(_("repo commit failed"))
863 try:
863 try:
864 self.full_series[insert:insert] = [patchfn]
864 self.full_series[insert:insert] = [patchfn]
865 self.applied.append(statusentry(n, patchfn))
865 self.applied.append(statusentry(n, patchfn))
866 self.parse_series()
866 self.parse_series()
867 self.series_dirty = 1
867 self.series_dirty = 1
868 self.applied_dirty = 1
868 self.applied_dirty = 1
869 if msg:
869 if msg:
870 msg = msg + "\n\n"
870 msg = msg + "\n\n"
871 p.write(msg)
871 p.write(msg)
872 if commitfiles:
872 if commitfiles:
873 parent = self.qparents(repo, n)
873 parent = self.qparents(repo, n)
874 chunks = patch.diff(repo, node1=parent, node2=n,
874 chunks = patch.diff(repo, node1=parent, node2=n,
875 match=match, opts=diffopts)
875 match=match, opts=diffopts)
876 for chunk in chunks:
876 for chunk in chunks:
877 p.write(chunk)
877 p.write(chunk)
878 p.close()
878 p.close()
879 wlock.release()
879 wlock.release()
880 wlock = None
880 wlock = None
881 r = self.qrepo()
881 r = self.qrepo()
882 if r:
882 if r:
883 r[None].add([patchfn])
883 r[None].add([patchfn])
884 except:
884 except:
885 repo.rollback()
885 repo.rollback()
886 raise
886 raise
887 except Exception:
887 except Exception:
888 patchpath = self.join(patchfn)
888 patchpath = self.join(patchfn)
889 try:
889 try:
890 os.unlink(patchpath)
890 os.unlink(patchpath)
891 except:
891 except:
892 self.ui.warn(_('error unlinking %s\n') % patchpath)
892 self.ui.warn(_('error unlinking %s\n') % patchpath)
893 raise
893 raise
894 self.removeundo(repo)
894 self.removeundo(repo)
895 finally:
895 finally:
896 release(wlock)
896 release(wlock)
897
897
898 def strip(self, repo, revs, update=True, backup="all", force=None):
898 def strip(self, repo, revs, update=True, backup="all", force=None):
899 wlock = lock = None
899 wlock = lock = None
900 try:
900 try:
901 wlock = repo.wlock()
901 wlock = repo.wlock()
902 lock = repo.lock()
902 lock = repo.lock()
903
903
904 if update:
904 if update:
905 self.check_localchanges(repo, force=force, refresh=False)
905 self.check_localchanges(repo, force=force, refresh=False)
906 urev = self.qparents(repo, revs[0])
906 urev = self.qparents(repo, revs[0])
907 hg.clean(repo, urev)
907 hg.clean(repo, urev)
908 repo.dirstate.write()
908 repo.dirstate.write()
909
909
910 self.removeundo(repo)
910 self.removeundo(repo)
911 for rev in revs:
911 for rev in revs:
912 repair.strip(self.ui, repo, rev, backup)
912 repair.strip(self.ui, repo, rev, backup)
913 # strip may have unbundled a set of backed up revisions after
913 # strip may have unbundled a set of backed up revisions after
914 # the actual strip
914 # the actual strip
915 self.removeundo(repo)
915 self.removeundo(repo)
916 finally:
916 finally:
917 release(lock, wlock)
917 release(lock, wlock)
918
918
919 def isapplied(self, patch):
919 def isapplied(self, patch):
920 """returns (index, rev, patch)"""
920 """returns (index, rev, patch)"""
921 for i, a in enumerate(self.applied):
921 for i, a in enumerate(self.applied):
922 if a.name == patch:
922 if a.name == patch:
923 return (i, a.node, a.name)
923 return (i, a.node, a.name)
924 return None
924 return None
925
925
926 # if the exact patch name does not exist, we try a few
926 # if the exact patch name does not exist, we try a few
927 # variations. If strict is passed, we try only #1
927 # variations. If strict is passed, we try only #1
928 #
928 #
929 # 1) a number to indicate an offset in the series file
929 # 1) a number to indicate an offset in the series file
930 # 2) a unique substring of the patch name was given
930 # 2) a unique substring of the patch name was given
931 # 3) patchname[-+]num to indicate an offset in the series file
931 # 3) patchname[-+]num to indicate an offset in the series file
932 def lookup(self, patch, strict=False):
932 def lookup(self, patch, strict=False):
933 patch = patch and str(patch)
933 patch = patch and str(patch)
934
934
935 def partial_name(s):
935 def partial_name(s):
936 if s in self.series:
936 if s in self.series:
937 return s
937 return s
938 matches = [x for x in self.series if s in x]
938 matches = [x for x in self.series if s in x]
939 if len(matches) > 1:
939 if len(matches) > 1:
940 self.ui.warn(_('patch name "%s" is ambiguous:\n') % s)
940 self.ui.warn(_('patch name "%s" is ambiguous:\n') % s)
941 for m in matches:
941 for m in matches:
942 self.ui.warn(' %s\n' % m)
942 self.ui.warn(' %s\n' % m)
943 return None
943 return None
944 if matches:
944 if matches:
945 return matches[0]
945 return matches[0]
946 if self.series and self.applied:
946 if self.series and self.applied:
947 if s == 'qtip':
947 if s == 'qtip':
948 return self.series[self.series_end(True)-1]
948 return self.series[self.series_end(True)-1]
949 if s == 'qbase':
949 if s == 'qbase':
950 return self.series[0]
950 return self.series[0]
951 return None
951 return None
952
952
953 if patch is None:
953 if patch is None:
954 return None
954 return None
955 if patch in self.series:
955 if patch in self.series:
956 return patch
956 return patch
957
957
958 if not os.path.isfile(self.join(patch)):
958 if not os.path.isfile(self.join(patch)):
959 try:
959 try:
960 sno = int(patch)
960 sno = int(patch)
961 except (ValueError, OverflowError):
961 except (ValueError, OverflowError):
962 pass
962 pass
963 else:
963 else:
964 if -len(self.series) <= sno < len(self.series):
964 if -len(self.series) <= sno < len(self.series):
965 return self.series[sno]
965 return self.series[sno]
966
966
967 if not strict:
967 if not strict:
968 res = partial_name(patch)
968 res = partial_name(patch)
969 if res:
969 if res:
970 return res
970 return res
971 minus = patch.rfind('-')
971 minus = patch.rfind('-')
972 if minus >= 0:
972 if minus >= 0:
973 res = partial_name(patch[:minus])
973 res = partial_name(patch[:minus])
974 if res:
974 if res:
975 i = self.series.index(res)
975 i = self.series.index(res)
976 try:
976 try:
977 off = int(patch[minus + 1:] or 1)
977 off = int(patch[minus + 1:] or 1)
978 except (ValueError, OverflowError):
978 except (ValueError, OverflowError):
979 pass
979 pass
980 else:
980 else:
981 if i - off >= 0:
981 if i - off >= 0:
982 return self.series[i - off]
982 return self.series[i - off]
983 plus = patch.rfind('+')
983 plus = patch.rfind('+')
984 if plus >= 0:
984 if plus >= 0:
985 res = partial_name(patch[:plus])
985 res = partial_name(patch[:plus])
986 if res:
986 if res:
987 i = self.series.index(res)
987 i = self.series.index(res)
988 try:
988 try:
989 off = int(patch[plus + 1:] or 1)
989 off = int(patch[plus + 1:] or 1)
990 except (ValueError, OverflowError):
990 except (ValueError, OverflowError):
991 pass
991 pass
992 else:
992 else:
993 if i + off < len(self.series):
993 if i + off < len(self.series):
994 return self.series[i + off]
994 return self.series[i + off]
995 raise util.Abort(_("patch %s not in series") % patch)
995 raise util.Abort(_("patch %s not in series") % patch)
996
996
997 def push(self, repo, patch=None, force=False, list=False,
997 def push(self, repo, patch=None, force=False, list=False,
998 mergeq=None, all=False, move=False):
998 mergeq=None, all=False, move=False):
999 diffopts = self.diffopts()
999 diffopts = self.diffopts()
1000 wlock = repo.wlock()
1000 wlock = repo.wlock()
1001 try:
1001 try:
1002 heads = []
1002 heads = []
1003 for b, ls in repo.branchmap().iteritems():
1003 for b, ls in repo.branchmap().iteritems():
1004 heads += ls
1004 heads += ls
1005 if not heads:
1005 if not heads:
1006 heads = [nullid]
1006 heads = [nullid]
1007 if repo.dirstate.parents()[0] not in heads:
1007 if repo.dirstate.parents()[0] not in heads:
1008 self.ui.status(_("(working directory not at a head)\n"))
1008 self.ui.status(_("(working directory not at a head)\n"))
1009
1009
1010 if not self.series:
1010 if not self.series:
1011 self.ui.warn(_('no patches in series\n'))
1011 self.ui.warn(_('no patches in series\n'))
1012 return 0
1012 return 0
1013
1013
1014 patch = self.lookup(patch)
1014 patch = self.lookup(patch)
1015 # Suppose our series file is: A B C and the current 'top'
1015 # Suppose our series file is: A B C and the current 'top'
1016 # patch is B. qpush C should be performed (moving forward)
1016 # patch is B. qpush C should be performed (moving forward)
1017 # qpush B is a NOP (no change) qpush A is an error (can't
1017 # qpush B is a NOP (no change) qpush A is an error (can't
1018 # go backwards with qpush)
1018 # go backwards with qpush)
1019 if patch:
1019 if patch:
1020 info = self.isapplied(patch)
1020 info = self.isapplied(patch)
1021 if info:
1021 if info:
1022 if info[0] < len(self.applied) - 1:
1022 if info[0] < len(self.applied) - 1:
1023 raise util.Abort(
1023 raise util.Abort(
1024 _("cannot push to a previous patch: %s") % patch)
1024 _("cannot push to a previous patch: %s") % patch)
1025 self.ui.warn(
1025 self.ui.warn(
1026 _('qpush: %s is already at the top\n') % patch)
1026 _('qpush: %s is already at the top\n') % patch)
1027 return 0
1027 return 0
1028 pushable, reason = self.pushable(patch)
1028 pushable, reason = self.pushable(patch)
1029 if not pushable:
1029 if not pushable:
1030 if reason:
1030 if reason:
1031 reason = _('guarded by %r') % reason
1031 reason = _('guarded by %r') % reason
1032 else:
1032 else:
1033 reason = _('no matching guards')
1033 reason = _('no matching guards')
1034 self.ui.warn(_("cannot push '%s' - %s\n") % (patch, reason))
1034 self.ui.warn(_("cannot push '%s' - %s\n") % (patch, reason))
1035 return 1
1035 return 1
1036 elif all:
1036 elif all:
1037 patch = self.series[-1]
1037 patch = self.series[-1]
1038 if self.isapplied(patch):
1038 if self.isapplied(patch):
1039 self.ui.warn(_('all patches are currently applied\n'))
1039 self.ui.warn(_('all patches are currently applied\n'))
1040 return 0
1040 return 0
1041
1041
1042 # Following the above example, starting at 'top' of B:
1042 # Following the above example, starting at 'top' of B:
1043 # qpush should be performed (pushes C), but a subsequent
1043 # qpush should be performed (pushes C), but a subsequent
1044 # qpush without an argument is an error (nothing to
1044 # qpush without an argument is an error (nothing to
1045 # apply). This allows a loop of "...while hg qpush..." to
1045 # apply). This allows a loop of "...while hg qpush..." to
1046 # work as it detects an error when done
1046 # work as it detects an error when done
1047 start = self.series_end()
1047 start = self.series_end()
1048 if start == len(self.series):
1048 if start == len(self.series):
1049 self.ui.warn(_('patch series already fully applied\n'))
1049 self.ui.warn(_('patch series already fully applied\n'))
1050 return 1
1050 return 1
1051 if not force:
1051 if not force:
1052 self.check_localchanges(repo)
1052 self.check_localchanges(repo)
1053
1053
1054 if move:
1054 if move:
1055 if not patch:
1055 if not patch:
1056 raise util.Abort(_("please specify the patch to move"))
1056 raise util.Abort(_("please specify the patch to move"))
1057 for i, rpn in enumerate(self.full_series[start:]):
1057 for i, rpn in enumerate(self.full_series[start:]):
1058 # strip markers for patch guards
1058 # strip markers for patch guards
1059 if self.guard_re.split(rpn, 1)[0] == patch:
1059 if self.guard_re.split(rpn, 1)[0] == patch:
1060 break
1060 break
1061 index = start + i
1061 index = start + i
1062 assert index < len(self.full_series)
1062 assert index < len(self.full_series)
1063 fullpatch = self.full_series[index]
1063 fullpatch = self.full_series[index]
1064 del self.full_series[index]
1064 del self.full_series[index]
1065 self.full_series.insert(start, fullpatch)
1065 self.full_series.insert(start, fullpatch)
1066 self.parse_series()
1066 self.parse_series()
1067 self.series_dirty = 1
1067 self.series_dirty = 1
1068
1068
1069 self.applied_dirty = 1
1069 self.applied_dirty = 1
1070 if start > 0:
1070 if start > 0:
1071 self.check_toppatch(repo)
1071 self.check_toppatch(repo)
1072 if not patch:
1072 if not patch:
1073 patch = self.series[start]
1073 patch = self.series[start]
1074 end = start + 1
1074 end = start + 1
1075 else:
1075 else:
1076 end = self.series.index(patch, start) + 1
1076 end = self.series.index(patch, start) + 1
1077
1077
1078 s = self.series[start:end]
1078 s = self.series[start:end]
1079 all_files = set()
1079 all_files = set()
1080 try:
1080 try:
1081 if mergeq:
1081 if mergeq:
1082 ret = self.mergepatch(repo, mergeq, s, diffopts)
1082 ret = self.mergepatch(repo, mergeq, s, diffopts)
1083 else:
1083 else:
1084 ret = self.apply(repo, s, list, all_files=all_files)
1084 ret = self.apply(repo, s, list, all_files=all_files)
1085 except:
1085 except:
1086 self.ui.warn(_('cleaning up working directory...'))
1086 self.ui.warn(_('cleaning up working directory...'))
1087 node = repo.dirstate.parents()[0]
1087 node = repo.dirstate.parents()[0]
1088 hg.revert(repo, node, None)
1088 hg.revert(repo, node, None)
1089 # only remove unknown files that we know we touched or
1089 # only remove unknown files that we know we touched or
1090 # created while patching
1090 # created while patching
1091 for f in all_files:
1091 for f in all_files:
1092 if f not in repo.dirstate:
1092 if f not in repo.dirstate:
1093 try:
1093 try:
1094 util.unlink(repo.wjoin(f))
1094 util.unlink(repo.wjoin(f))
1095 except OSError, inst:
1095 except OSError, inst:
1096 if inst.errno != errno.ENOENT:
1096 if inst.errno != errno.ENOENT:
1097 raise
1097 raise
1098 self.ui.warn(_('done\n'))
1098 self.ui.warn(_('done\n'))
1099 raise
1099 raise
1100
1100
1101 if not self.applied:
1101 if not self.applied:
1102 return ret[0]
1102 return ret[0]
1103 top = self.applied[-1].name
1103 top = self.applied[-1].name
1104 if ret[0] and ret[0] > 1:
1104 if ret[0] and ret[0] > 1:
1105 msg = _("errors during apply, please fix and refresh %s\n")
1105 msg = _("errors during apply, please fix and refresh %s\n")
1106 self.ui.write(msg % top)
1106 self.ui.write(msg % top)
1107 else:
1107 else:
1108 self.ui.write(_("now at: %s\n") % top)
1108 self.ui.write(_("now at: %s\n") % top)
1109 return ret[0]
1109 return ret[0]
1110
1110
1111 finally:
1111 finally:
1112 wlock.release()
1112 wlock.release()
1113
1113
1114 def pop(self, repo, patch=None, force=False, update=True, all=False):
1114 def pop(self, repo, patch=None, force=False, update=True, all=False):
1115 wlock = repo.wlock()
1115 wlock = repo.wlock()
1116 try:
1116 try:
1117 if patch:
1117 if patch:
1118 # index, rev, patch
1118 # index, rev, patch
1119 info = self.isapplied(patch)
1119 info = self.isapplied(patch)
1120 if not info:
1120 if not info:
1121 patch = self.lookup(patch)
1121 patch = self.lookup(patch)
1122 info = self.isapplied(patch)
1122 info = self.isapplied(patch)
1123 if not info:
1123 if not info:
1124 raise util.Abort(_("patch %s is not applied") % patch)
1124 raise util.Abort(_("patch %s is not applied") % patch)
1125
1125
1126 if not self.applied:
1126 if not self.applied:
1127 # Allow qpop -a to work repeatedly,
1127 # Allow qpop -a to work repeatedly,
1128 # but not qpop without an argument
1128 # but not qpop without an argument
1129 self.ui.warn(_("no patches applied\n"))
1129 self.ui.warn(_("no patches applied\n"))
1130 return not all
1130 return not all
1131
1131
1132 if all:
1132 if all:
1133 start = 0
1133 start = 0
1134 elif patch:
1134 elif patch:
1135 start = info[0] + 1
1135 start = info[0] + 1
1136 else:
1136 else:
1137 start = len(self.applied) - 1
1137 start = len(self.applied) - 1
1138
1138
1139 if start >= len(self.applied):
1139 if start >= len(self.applied):
1140 self.ui.warn(_("qpop: %s is already at the top\n") % patch)
1140 self.ui.warn(_("qpop: %s is already at the top\n") % patch)
1141 return
1141 return
1142
1142
1143 if not update:
1143 if not update:
1144 parents = repo.dirstate.parents()
1144 parents = repo.dirstate.parents()
1145 rr = [x.node for x in self.applied]
1145 rr = [x.node for x in self.applied]
1146 for p in parents:
1146 for p in parents:
1147 if p in rr:
1147 if p in rr:
1148 self.ui.warn(_("qpop: forcing dirstate update\n"))
1148 self.ui.warn(_("qpop: forcing dirstate update\n"))
1149 update = True
1149 update = True
1150 else:
1150 else:
1151 parents = [p.node() for p in repo[None].parents()]
1151 parents = [p.node() for p in repo[None].parents()]
1152 needupdate = False
1152 needupdate = False
1153 for entry in self.applied[start:]:
1153 for entry in self.applied[start:]:
1154 if entry.node in parents:
1154 if entry.node in parents:
1155 needupdate = True
1155 needupdate = True
1156 break
1156 break
1157 update = needupdate
1157 update = needupdate
1158
1158
1159 if not force and update:
1159 if not force and update:
1160 self.check_localchanges(repo)
1160 self.check_localchanges(repo)
1161
1161
1162 self.applied_dirty = 1
1162 self.applied_dirty = 1
1163 end = len(self.applied)
1163 end = len(self.applied)
1164 rev = self.applied[start].node
1164 rev = self.applied[start].node
1165 if update:
1165 if update:
1166 top = self.check_toppatch(repo)[0]
1166 top = self.check_toppatch(repo)[0]
1167
1167
1168 try:
1168 try:
1169 heads = repo.changelog.heads(rev)
1169 heads = repo.changelog.heads(rev)
1170 except error.LookupError:
1170 except error.LookupError:
1171 node = short(rev)
1171 node = short(rev)
1172 raise util.Abort(_('trying to pop unknown node %s') % node)
1172 raise util.Abort(_('trying to pop unknown node %s') % node)
1173
1173
1174 if heads != [self.applied[-1].node]:
1174 if heads != [self.applied[-1].node]:
1175 raise util.Abort(_("popping would remove a revision not "
1175 raise util.Abort(_("popping would remove a revision not "
1176 "managed by this patch queue"))
1176 "managed by this patch queue"))
1177
1177
1178 # we know there are no local changes, so we can make a simplified
1178 # we know there are no local changes, so we can make a simplified
1179 # form of hg.update.
1179 # form of hg.update.
1180 if update:
1180 if update:
1181 qp = self.qparents(repo, rev)
1181 qp = self.qparents(repo, rev)
1182 ctx = repo[qp]
1182 ctx = repo[qp]
1183 m, a, r, d = repo.status(qp, top)[:4]
1183 m, a, r, d = repo.status(qp, top)[:4]
1184 if d:
1184 if d:
1185 raise util.Abort(_("deletions found between repo revs"))
1185 raise util.Abort(_("deletions found between repo revs"))
1186 for f in a:
1186 for f in a:
1187 try:
1187 try:
1188 util.unlink(repo.wjoin(f))
1188 util.unlink(repo.wjoin(f))
1189 except OSError, e:
1189 except OSError, e:
1190 if e.errno != errno.ENOENT:
1190 if e.errno != errno.ENOENT:
1191 raise
1191 raise
1192 repo.dirstate.forget(f)
1192 repo.dirstate.forget(f)
1193 for f in m + r:
1193 for f in m + r:
1194 fctx = ctx[f]
1194 fctx = ctx[f]
1195 repo.wwrite(f, fctx.data(), fctx.flags())
1195 repo.wwrite(f, fctx.data(), fctx.flags())
1196 repo.dirstate.normal(f)
1196 repo.dirstate.normal(f)
1197 repo.dirstate.setparents(qp, nullid)
1197 repo.dirstate.setparents(qp, nullid)
1198 for patch in reversed(self.applied[start:end]):
1198 for patch in reversed(self.applied[start:end]):
1199 self.ui.status(_("popping %s\n") % patch.name)
1199 self.ui.status(_("popping %s\n") % patch.name)
1200 del self.applied[start:end]
1200 del self.applied[start:end]
1201 self.strip(repo, [rev], update=False, backup='strip')
1201 self.strip(repo, [rev], update=False, backup='strip')
1202 if self.applied:
1202 if self.applied:
1203 self.ui.write(_("now at: %s\n") % self.applied[-1].name)
1203 self.ui.write(_("now at: %s\n") % self.applied[-1].name)
1204 else:
1204 else:
1205 self.ui.write(_("patch queue now empty\n"))
1205 self.ui.write(_("patch queue now empty\n"))
1206 finally:
1206 finally:
1207 wlock.release()
1207 wlock.release()
1208
1208
1209 def diff(self, repo, pats, opts):
1209 def diff(self, repo, pats, opts):
1210 top, patch = self.check_toppatch(repo)
1210 top, patch = self.check_toppatch(repo)
1211 if not top:
1211 if not top:
1212 self.ui.write(_("no patches applied\n"))
1212 self.ui.write(_("no patches applied\n"))
1213 return
1213 return
1214 qp = self.qparents(repo, top)
1214 qp = self.qparents(repo, top)
1215 if opts.get('reverse'):
1215 if opts.get('reverse'):
1216 node1, node2 = None, qp
1216 node1, node2 = None, qp
1217 else:
1217 else:
1218 node1, node2 = qp, None
1218 node1, node2 = qp, None
1219 diffopts = self.diffopts(opts, patch)
1219 diffopts = self.diffopts(opts, patch)
1220 self.printdiff(repo, diffopts, node1, node2, files=pats, opts=opts)
1220 self.printdiff(repo, diffopts, node1, node2, files=pats, opts=opts)
1221
1221
1222 def refresh(self, repo, pats=None, **opts):
1222 def refresh(self, repo, pats=None, **opts):
1223 if not self.applied:
1223 if not self.applied:
1224 self.ui.write(_("no patches applied\n"))
1224 self.ui.write(_("no patches applied\n"))
1225 return 1
1225 return 1
1226 msg = opts.get('msg', '').rstrip()
1226 msg = opts.get('msg', '').rstrip()
1227 newuser = opts.get('user')
1227 newuser = opts.get('user')
1228 newdate = opts.get('date')
1228 newdate = opts.get('date')
1229 if newdate:
1229 if newdate:
1230 newdate = '%d %d' % util.parsedate(newdate)
1230 newdate = '%d %d' % util.parsedate(newdate)
1231 wlock = repo.wlock()
1231 wlock = repo.wlock()
1232
1232
1233 try:
1233 try:
1234 self.check_toppatch(repo)
1234 self.check_toppatch(repo)
1235 (top, patchfn) = (self.applied[-1].node, self.applied[-1].name)
1235 (top, patchfn) = (self.applied[-1].node, self.applied[-1].name)
1236 if repo.changelog.heads(top) != [top]:
1236 if repo.changelog.heads(top) != [top]:
1237 raise util.Abort(_("cannot refresh a revision with children"))
1237 raise util.Abort(_("cannot refresh a revision with children"))
1238
1238
1239 cparents = repo.changelog.parents(top)
1239 cparents = repo.changelog.parents(top)
1240 patchparent = self.qparents(repo, top)
1240 patchparent = self.qparents(repo, top)
1241 ph = patchheader(self.join(patchfn), self.plainmode)
1241 ph = patchheader(self.join(patchfn), self.plainmode)
1242 diffopts = self.diffopts({'git': opts.get('git')}, patchfn)
1242 diffopts = self.diffopts({'git': opts.get('git')}, patchfn)
1243 if msg:
1243 if msg:
1244 ph.setmessage(msg)
1244 ph.setmessage(msg)
1245 if newuser:
1245 if newuser:
1246 ph.setuser(newuser)
1246 ph.setuser(newuser)
1247 if newdate:
1247 if newdate:
1248 ph.setdate(newdate)
1248 ph.setdate(newdate)
1249 ph.setparent(hex(patchparent))
1249 ph.setparent(hex(patchparent))
1250
1250
1251 # only commit new patch when write is complete
1251 # only commit new patch when write is complete
1252 patchf = self.opener(patchfn, 'w', atomictemp=True)
1252 patchf = self.opener(patchfn, 'w', atomictemp=True)
1253
1253
1254 comments = str(ph)
1254 comments = str(ph)
1255 if comments:
1255 if comments:
1256 patchf.write(comments)
1256 patchf.write(comments)
1257
1257
1258 # update the dirstate in place, strip off the qtip commit
1258 # update the dirstate in place, strip off the qtip commit
1259 # and then commit.
1259 # and then commit.
1260 #
1260 #
1261 # this should really read:
1261 # this should really read:
1262 # mm, dd, aa, aa2 = repo.status(tip, patchparent)[:4]
1262 # mm, dd, aa, aa2 = repo.status(tip, patchparent)[:4]
1263 # but we do it backwards to take advantage of manifest/chlog
1263 # but we do it backwards to take advantage of manifest/chlog
1264 # caching against the next repo.status call
1264 # caching against the next repo.status call
1265 mm, aa, dd, aa2 = repo.status(patchparent, top)[:4]
1265 mm, aa, dd, aa2 = repo.status(patchparent, top)[:4]
1266 changes = repo.changelog.read(top)
1266 changes = repo.changelog.read(top)
1267 man = repo.manifest.read(changes[0])
1267 man = repo.manifest.read(changes[0])
1268 aaa = aa[:]
1268 aaa = aa[:]
1269 matchfn = cmdutil.match(repo, pats, opts)
1269 matchfn = cmdutil.match(repo, pats, opts)
1270 # in short mode, we only diff the files included in the
1270 # in short mode, we only diff the files included in the
1271 # patch already plus specified files
1271 # patch already plus specified files
1272 if opts.get('short'):
1272 if opts.get('short'):
1273 # if amending a patch, we start with existing
1273 # if amending a patch, we start with existing
1274 # files plus specified files - unfiltered
1274 # files plus specified files - unfiltered
1275 match = cmdutil.matchfiles(repo, mm + aa + dd + matchfn.files())
1275 match = cmdutil.matchfiles(repo, mm + aa + dd + matchfn.files())
1276 # filter with inc/exl options
1276 # filter with inc/exl options
1277 matchfn = cmdutil.match(repo, opts=opts)
1277 matchfn = cmdutil.match(repo, opts=opts)
1278 else:
1278 else:
1279 match = cmdutil.matchall(repo)
1279 match = cmdutil.matchall(repo)
1280 m, a, r, d = repo.status(match=match)[:4]
1280 m, a, r, d = repo.status(match=match)[:4]
1281
1281
1282 # we might end up with files that were added between
1282 # we might end up with files that were added between
1283 # qtip and the dirstate parent, but then changed in the
1283 # qtip and the dirstate parent, but then changed in the
1284 # local dirstate. in this case, we want them to only
1284 # local dirstate. in this case, we want them to only
1285 # show up in the added section
1285 # show up in the added section
1286 for x in m:
1286 for x in m:
1287 if x not in aa:
1287 if x not in aa:
1288 mm.append(x)
1288 mm.append(x)
1289 # we might end up with files added by the local dirstate that
1289 # we might end up with files added by the local dirstate that
1290 # were deleted by the patch. In this case, they should only
1290 # were deleted by the patch. In this case, they should only
1291 # show up in the changed section.
1291 # show up in the changed section.
1292 for x in a:
1292 for x in a:
1293 if x in dd:
1293 if x in dd:
1294 del dd[dd.index(x)]
1294 del dd[dd.index(x)]
1295 mm.append(x)
1295 mm.append(x)
1296 else:
1296 else:
1297 aa.append(x)
1297 aa.append(x)
1298 # make sure any files deleted in the local dirstate
1298 # make sure any files deleted in the local dirstate
1299 # are not in the add or change column of the patch
1299 # are not in the add or change column of the patch
1300 forget = []
1300 forget = []
1301 for x in d + r:
1301 for x in d + r:
1302 if x in aa:
1302 if x in aa:
1303 del aa[aa.index(x)]
1303 del aa[aa.index(x)]
1304 forget.append(x)
1304 forget.append(x)
1305 continue
1305 continue
1306 elif x in mm:
1306 elif x in mm:
1307 del mm[mm.index(x)]
1307 del mm[mm.index(x)]
1308 dd.append(x)
1308 dd.append(x)
1309
1309
1310 m = list(set(mm))
1310 m = list(set(mm))
1311 r = list(set(dd))
1311 r = list(set(dd))
1312 a = list(set(aa))
1312 a = list(set(aa))
1313 c = [filter(matchfn, l) for l in (m, a, r)]
1313 c = [filter(matchfn, l) for l in (m, a, r)]
1314 match = cmdutil.matchfiles(repo, set(c[0] + c[1] + c[2]))
1314 match = cmdutil.matchfiles(repo, set(c[0] + c[1] + c[2]))
1315 chunks = patch.diff(repo, patchparent, match=match,
1315 chunks = patch.diff(repo, patchparent, match=match,
1316 changes=c, opts=diffopts)
1316 changes=c, opts=diffopts)
1317 for chunk in chunks:
1317 for chunk in chunks:
1318 patchf.write(chunk)
1318 patchf.write(chunk)
1319
1319
1320 try:
1320 try:
1321 if diffopts.git or diffopts.upgrade:
1321 if diffopts.git or diffopts.upgrade:
1322 copies = {}
1322 copies = {}
1323 for dst in a:
1323 for dst in a:
1324 src = repo.dirstate.copied(dst)
1324 src = repo.dirstate.copied(dst)
1325 # during qfold, the source file for copies may
1325 # during qfold, the source file for copies may
1326 # be removed. Treat this as a simple add.
1326 # be removed. Treat this as a simple add.
1327 if src is not None and src in repo.dirstate:
1327 if src is not None and src in repo.dirstate:
1328 copies.setdefault(src, []).append(dst)
1328 copies.setdefault(src, []).append(dst)
1329 repo.dirstate.add(dst)
1329 repo.dirstate.add(dst)
1330 # remember the copies between patchparent and qtip
1330 # remember the copies between patchparent and qtip
1331 for dst in aaa:
1331 for dst in aaa:
1332 f = repo.file(dst)
1332 f = repo.file(dst)
1333 src = f.renamed(man[dst])
1333 src = f.renamed(man[dst])
1334 if src:
1334 if src:
1335 copies.setdefault(src[0], []).extend(
1335 copies.setdefault(src[0], []).extend(
1336 copies.get(dst, []))
1336 copies.get(dst, []))
1337 if dst in a:
1337 if dst in a:
1338 copies[src[0]].append(dst)
1338 copies[src[0]].append(dst)
1339 # we can't copy a file created by the patch itself
1339 # we can't copy a file created by the patch itself
1340 if dst in copies:
1340 if dst in copies:
1341 del copies[dst]
1341 del copies[dst]
1342 for src, dsts in copies.iteritems():
1342 for src, dsts in copies.iteritems():
1343 for dst in dsts:
1343 for dst in dsts:
1344 repo.dirstate.copy(src, dst)
1344 repo.dirstate.copy(src, dst)
1345 else:
1345 else:
1346 for dst in a:
1346 for dst in a:
1347 repo.dirstate.add(dst)
1347 repo.dirstate.add(dst)
1348 # Drop useless copy information
1348 # Drop useless copy information
1349 for f in list(repo.dirstate.copies()):
1349 for f in list(repo.dirstate.copies()):
1350 repo.dirstate.copy(None, f)
1350 repo.dirstate.copy(None, f)
1351 for f in r:
1351 for f in r:
1352 repo.dirstate.remove(f)
1352 repo.dirstate.remove(f)
1353 # if the patch excludes a modified file, mark that
1353 # if the patch excludes a modified file, mark that
1354 # file with mtime=0 so status can see it.
1354 # file with mtime=0 so status can see it.
1355 mm = []
1355 mm = []
1356 for i in xrange(len(m)-1, -1, -1):
1356 for i in xrange(len(m)-1, -1, -1):
1357 if not matchfn(m[i]):
1357 if not matchfn(m[i]):
1358 mm.append(m[i])
1358 mm.append(m[i])
1359 del m[i]
1359 del m[i]
1360 for f in m:
1360 for f in m:
1361 repo.dirstate.normal(f)
1361 repo.dirstate.normal(f)
1362 for f in mm:
1362 for f in mm:
1363 repo.dirstate.normallookup(f)
1363 repo.dirstate.normallookup(f)
1364 for f in forget:
1364 for f in forget:
1365 repo.dirstate.forget(f)
1365 repo.dirstate.forget(f)
1366
1366
1367 if not msg:
1367 if not msg:
1368 if not ph.message:
1368 if not ph.message:
1369 message = "[mq]: %s\n" % patchfn
1369 message = "[mq]: %s\n" % patchfn
1370 else:
1370 else:
1371 message = "\n".join(ph.message)
1371 message = "\n".join(ph.message)
1372 else:
1372 else:
1373 message = msg
1373 message = msg
1374
1374
1375 user = ph.user or changes[1]
1375 user = ph.user or changes[1]
1376
1376
1377 # assumes strip can roll itself back if interrupted
1377 # assumes strip can roll itself back if interrupted
1378 repo.dirstate.setparents(*cparents)
1378 repo.dirstate.setparents(*cparents)
1379 self.applied.pop()
1379 self.applied.pop()
1380 self.applied_dirty = 1
1380 self.applied_dirty = 1
1381 self.strip(repo, [top], update=False,
1381 self.strip(repo, [top], update=False,
1382 backup='strip')
1382 backup='strip')
1383 except:
1383 except:
1384 repo.dirstate.invalidate()
1384 repo.dirstate.invalidate()
1385 raise
1385 raise
1386
1386
1387 try:
1387 try:
1388 # might be nice to attempt to roll back strip after this
1388 # might be nice to attempt to roll back strip after this
1389 patchf.rename()
1389 patchf.rename()
1390 n = repo.commit(message, user, ph.date, match=match,
1390 n = repo.commit(message, user, ph.date, match=match,
1391 force=True)
1391 force=True)
1392 self.applied.append(statusentry(n, patchfn))
1392 self.applied.append(statusentry(n, patchfn))
1393 except:
1393 except:
1394 ctx = repo[cparents[0]]
1394 ctx = repo[cparents[0]]
1395 repo.dirstate.rebuild(ctx.node(), ctx.manifest())
1395 repo.dirstate.rebuild(ctx.node(), ctx.manifest())
1396 self.save_dirty()
1396 self.save_dirty()
1397 self.ui.warn(_('refresh interrupted while patch was popped! '
1397 self.ui.warn(_('refresh interrupted while patch was popped! '
1398 '(revert --all, qpush to recover)\n'))
1398 '(revert --all, qpush to recover)\n'))
1399 raise
1399 raise
1400 finally:
1400 finally:
1401 wlock.release()
1401 wlock.release()
1402 self.removeundo(repo)
1402 self.removeundo(repo)
1403
1403
1404 def init(self, repo, create=False):
1404 def init(self, repo, create=False):
1405 if not create and os.path.isdir(self.path):
1405 if not create and os.path.isdir(self.path):
1406 raise util.Abort(_("patch queue directory already exists"))
1406 raise util.Abort(_("patch queue directory already exists"))
1407 try:
1407 try:
1408 os.mkdir(self.path)
1408 os.mkdir(self.path)
1409 except OSError, inst:
1409 except OSError, inst:
1410 if inst.errno != errno.EEXIST or not create:
1410 if inst.errno != errno.EEXIST or not create:
1411 raise
1411 raise
1412 if create:
1412 if create:
1413 return self.qrepo(create=True)
1413 return self.qrepo(create=True)
1414
1414
1415 def unapplied(self, repo, patch=None):
1415 def unapplied(self, repo, patch=None):
1416 if patch and patch not in self.series:
1416 if patch and patch not in self.series:
1417 raise util.Abort(_("patch %s is not in series file") % patch)
1417 raise util.Abort(_("patch %s is not in series file") % patch)
1418 if not patch:
1418 if not patch:
1419 start = self.series_end()
1419 start = self.series_end()
1420 else:
1420 else:
1421 start = self.series.index(patch) + 1
1421 start = self.series.index(patch) + 1
1422 unapplied = []
1422 unapplied = []
1423 for i in xrange(start, len(self.series)):
1423 for i in xrange(start, len(self.series)):
1424 pushable, reason = self.pushable(i)
1424 pushable, reason = self.pushable(i)
1425 if pushable:
1425 if pushable:
1426 unapplied.append((i, self.series[i]))
1426 unapplied.append((i, self.series[i]))
1427 self.explain_pushable(i)
1427 self.explain_pushable(i)
1428 return unapplied
1428 return unapplied
1429
1429
1430 def qseries(self, repo, missing=None, start=0, length=None, status=None,
1430 def qseries(self, repo, missing=None, start=0, length=None, status=None,
1431 summary=False):
1431 summary=False):
1432 def displayname(pfx, patchname, state):
1432 def displayname(pfx, patchname, state):
1433 if pfx:
1433 if pfx:
1434 self.ui.write(pfx)
1434 self.ui.write(pfx)
1435 if summary:
1435 if summary:
1436 ph = patchheader(self.join(patchname), self.plainmode)
1436 ph = patchheader(self.join(patchname), self.plainmode)
1437 msg = ph.message and ph.message[0] or ''
1437 msg = ph.message and ph.message[0] or ''
1438 if self.ui.formatted():
1438 if self.ui.formatted():
1439 width = util.termwidth() - len(pfx) - len(patchname) - 2
1439 width = util.termwidth() - len(pfx) - len(patchname) - 2
1440 if width > 0:
1440 if width > 0:
1441 msg = util.ellipsis(msg, width)
1441 msg = util.ellipsis(msg, width)
1442 else:
1442 else:
1443 msg = ''
1443 msg = ''
1444 self.ui.write(patchname, label='qseries.' + state)
1444 self.ui.write(patchname, label='qseries.' + state)
1445 self.ui.write(': ')
1445 self.ui.write(': ')
1446 self.ui.write(msg, label='qseries.message.' + state)
1446 self.ui.write(msg, label='qseries.message.' + state)
1447 else:
1447 else:
1448 self.ui.write(patchname, label='qseries.' + state)
1448 self.ui.write(patchname, label='qseries.' + state)
1449 self.ui.write('\n')
1449 self.ui.write('\n')
1450
1450
1451 applied = set([p.name for p in self.applied])
1451 applied = set([p.name for p in self.applied])
1452 if length is None:
1452 if length is None:
1453 length = len(self.series) - start
1453 length = len(self.series) - start
1454 if not missing:
1454 if not missing:
1455 if self.ui.verbose:
1455 if self.ui.verbose:
1456 idxwidth = len(str(start + length - 1))
1456 idxwidth = len(str(start + length - 1))
1457 for i in xrange(start, start + length):
1457 for i in xrange(start, start + length):
1458 patch = self.series[i]
1458 patch = self.series[i]
1459 if patch in applied:
1459 if patch in applied:
1460 char, state = 'A', 'applied'
1460 char, state = 'A', 'applied'
1461 elif self.pushable(i)[0]:
1461 elif self.pushable(i)[0]:
1462 char, state = 'U', 'unapplied'
1462 char, state = 'U', 'unapplied'
1463 else:
1463 else:
1464 char, state = 'G', 'guarded'
1464 char, state = 'G', 'guarded'
1465 pfx = ''
1465 pfx = ''
1466 if self.ui.verbose:
1466 if self.ui.verbose:
1467 pfx = '%*d %s ' % (idxwidth, i, char)
1467 pfx = '%*d %s ' % (idxwidth, i, char)
1468 elif status and status != char:
1468 elif status and status != char:
1469 continue
1469 continue
1470 displayname(pfx, patch, state)
1470 displayname(pfx, patch, state)
1471 else:
1471 else:
1472 msng_list = []
1472 msng_list = []
1473 for root, dirs, files in os.walk(self.path):
1473 for root, dirs, files in os.walk(self.path):
1474 d = root[len(self.path) + 1:]
1474 d = root[len(self.path) + 1:]
1475 for f in files:
1475 for f in files:
1476 fl = os.path.join(d, f)
1476 fl = os.path.join(d, f)
1477 if (fl not in self.series and
1477 if (fl not in self.series and
1478 fl not in (self.status_path, self.series_path,
1478 fl not in (self.status_path, self.series_path,
1479 self.guards_path)
1479 self.guards_path)
1480 and not fl.startswith('.')):
1480 and not fl.startswith('.')):
1481 msng_list.append(fl)
1481 msng_list.append(fl)
1482 for x in sorted(msng_list):
1482 for x in sorted(msng_list):
1483 pfx = self.ui.verbose and ('D ') or ''
1483 pfx = self.ui.verbose and ('D ') or ''
1484 displayname(pfx, x, 'missing')
1484 displayname(pfx, x, 'missing')
1485
1485
1486 def issaveline(self, l):
1486 def issaveline(self, l):
1487 if l.name == '.hg.patches.save.line':
1487 if l.name == '.hg.patches.save.line':
1488 return True
1488 return True
1489
1489
1490 def qrepo(self, create=False):
1490 def qrepo(self, create=False):
1491 if create or os.path.isdir(self.join(".hg")):
1491 if create or os.path.isdir(self.join(".hg")):
1492 return hg.repository(self.ui, path=self.path, create=create)
1492 return hg.repository(self.ui, path=self.path, create=create)
1493
1493
1494 def restore(self, repo, rev, delete=None, qupdate=None):
1494 def restore(self, repo, rev, delete=None, qupdate=None):
1495 desc = repo[rev].description().strip()
1495 desc = repo[rev].description().strip()
1496 lines = desc.splitlines()
1496 lines = desc.splitlines()
1497 i = 0
1497 i = 0
1498 datastart = None
1498 datastart = None
1499 series = []
1499 series = []
1500 applied = []
1500 applied = []
1501 qpp = None
1501 qpp = None
1502 for i, line in enumerate(lines):
1502 for i, line in enumerate(lines):
1503 if line == 'Patch Data:':
1503 if line == 'Patch Data:':
1504 datastart = i + 1
1504 datastart = i + 1
1505 elif line.startswith('Dirstate:'):
1505 elif line.startswith('Dirstate:'):
1506 l = line.rstrip()
1506 l = line.rstrip()
1507 l = l[10:].split(' ')
1507 l = l[10:].split(' ')
1508 qpp = [bin(x) for x in l]
1508 qpp = [bin(x) for x in l]
1509 elif datastart != None:
1509 elif datastart != None:
1510 l = line.rstrip()
1510 l = line.rstrip()
1511 n, name = l.split(':', 1)
1511 n, name = l.split(':', 1)
1512 if n:
1512 if n:
1513 applied.append(statusentry(bin(n), name))
1513 applied.append(statusentry(bin(n), name))
1514 else:
1514 else:
1515 series.append(l)
1515 series.append(l)
1516 if datastart is None:
1516 if datastart is None:
1517 self.ui.warn(_("No saved patch data found\n"))
1517 self.ui.warn(_("No saved patch data found\n"))
1518 return 1
1518 return 1
1519 self.ui.warn(_("restoring status: %s\n") % lines[0])
1519 self.ui.warn(_("restoring status: %s\n") % lines[0])
1520 self.full_series = series
1520 self.full_series = series
1521 self.applied = applied
1521 self.applied = applied
1522 self.parse_series()
1522 self.parse_series()
1523 self.series_dirty = 1
1523 self.series_dirty = 1
1524 self.applied_dirty = 1
1524 self.applied_dirty = 1
1525 heads = repo.changelog.heads()
1525 heads = repo.changelog.heads()
1526 if delete:
1526 if delete:
1527 if rev not in heads:
1527 if rev not in heads:
1528 self.ui.warn(_("save entry has children, leaving it alone\n"))
1528 self.ui.warn(_("save entry has children, leaving it alone\n"))
1529 else:
1529 else:
1530 self.ui.warn(_("removing save entry %s\n") % short(rev))
1530 self.ui.warn(_("removing save entry %s\n") % short(rev))
1531 pp = repo.dirstate.parents()
1531 pp = repo.dirstate.parents()
1532 if rev in pp:
1532 if rev in pp:
1533 update = True
1533 update = True
1534 else:
1534 else:
1535 update = False
1535 update = False
1536 self.strip(repo, [rev], update=update, backup='strip')
1536 self.strip(repo, [rev], update=update, backup='strip')
1537 if qpp:
1537 if qpp:
1538 self.ui.warn(_("saved queue repository parents: %s %s\n") %
1538 self.ui.warn(_("saved queue repository parents: %s %s\n") %
1539 (short(qpp[0]), short(qpp[1])))
1539 (short(qpp[0]), short(qpp[1])))
1540 if qupdate:
1540 if qupdate:
1541 self.ui.status(_("queue directory updating\n"))
1541 self.ui.status(_("queue directory updating\n"))
1542 r = self.qrepo()
1542 r = self.qrepo()
1543 if not r:
1543 if not r:
1544 self.ui.warn(_("Unable to load queue repository\n"))
1544 self.ui.warn(_("Unable to load queue repository\n"))
1545 return 1
1545 return 1
1546 hg.clean(r, qpp[0])
1546 hg.clean(r, qpp[0])
1547
1547
1548 def save(self, repo, msg=None):
1548 def save(self, repo, msg=None):
1549 if not self.applied:
1549 if not self.applied:
1550 self.ui.warn(_("save: no patches applied, exiting\n"))
1550 self.ui.warn(_("save: no patches applied, exiting\n"))
1551 return 1
1551 return 1
1552 if self.issaveline(self.applied[-1]):
1552 if self.issaveline(self.applied[-1]):
1553 self.ui.warn(_("status is already saved\n"))
1553 self.ui.warn(_("status is already saved\n"))
1554 return 1
1554 return 1
1555
1555
1556 if not msg:
1556 if not msg:
1557 msg = _("hg patches saved state")
1557 msg = _("hg patches saved state")
1558 else:
1558 else:
1559 msg = "hg patches: " + msg.rstrip('\r\n')
1559 msg = "hg patches: " + msg.rstrip('\r\n')
1560 r = self.qrepo()
1560 r = self.qrepo()
1561 if r:
1561 if r:
1562 pp = r.dirstate.parents()
1562 pp = r.dirstate.parents()
1563 msg += "\nDirstate: %s %s" % (hex(pp[0]), hex(pp[1]))
1563 msg += "\nDirstate: %s %s" % (hex(pp[0]), hex(pp[1]))
1564 msg += "\n\nPatch Data:\n"
1564 msg += "\n\nPatch Data:\n"
1565 msg += ''.join('%s\n' % x for x in self.applied)
1565 msg += ''.join('%s\n' % x for x in self.applied)
1566 msg += ''.join(':%s\n' % x for x in self.full_series)
1566 msg += ''.join(':%s\n' % x for x in self.full_series)
1567 n = repo.commit(msg, force=True)
1567 n = repo.commit(msg, force=True)
1568 if not n:
1568 if not n:
1569 self.ui.warn(_("repo commit failed\n"))
1569 self.ui.warn(_("repo commit failed\n"))
1570 return 1
1570 return 1
1571 self.applied.append(statusentry(n, '.hg.patches.save.line'))
1571 self.applied.append(statusentry(n, '.hg.patches.save.line'))
1572 self.applied_dirty = 1
1572 self.applied_dirty = 1
1573 self.removeundo(repo)
1573 self.removeundo(repo)
1574
1574
1575 def full_series_end(self):
1575 def full_series_end(self):
1576 if self.applied:
1576 if self.applied:
1577 p = self.applied[-1].name
1577 p = self.applied[-1].name
1578 end = self.find_series(p)
1578 end = self.find_series(p)
1579 if end is None:
1579 if end is None:
1580 return len(self.full_series)
1580 return len(self.full_series)
1581 return end + 1
1581 return end + 1
1582 return 0
1582 return 0
1583
1583
1584 def series_end(self, all_patches=False):
1584 def series_end(self, all_patches=False):
1585 """If all_patches is False, return the index of the next pushable patch
1585 """If all_patches is False, return the index of the next pushable patch
1586 in the series, or the series length. If all_patches is True, return the
1586 in the series, or the series length. If all_patches is True, return the
1587 index of the first patch past the last applied one.
1587 index of the first patch past the last applied one.
1588 """
1588 """
1589 end = 0
1589 end = 0
1590 def next(start):
1590 def next(start):
1591 if all_patches or start >= len(self.series):
1591 if all_patches or start >= len(self.series):
1592 return start
1592 return start
1593 for i in xrange(start, len(self.series)):
1593 for i in xrange(start, len(self.series)):
1594 p, reason = self.pushable(i)
1594 p, reason = self.pushable(i)
1595 if p:
1595 if p:
1596 break
1596 break
1597 self.explain_pushable(i)
1597 self.explain_pushable(i)
1598 return i
1598 return i
1599 if self.applied:
1599 if self.applied:
1600 p = self.applied[-1].name
1600 p = self.applied[-1].name
1601 try:
1601 try:
1602 end = self.series.index(p)
1602 end = self.series.index(p)
1603 except ValueError:
1603 except ValueError:
1604 return 0
1604 return 0
1605 return next(end + 1)
1605 return next(end + 1)
1606 return next(end)
1606 return next(end)
1607
1607
1608 def appliedname(self, index):
1608 def appliedname(self, index):
1609 pname = self.applied[index].name
1609 pname = self.applied[index].name
1610 if not self.ui.verbose:
1610 if not self.ui.verbose:
1611 p = pname
1611 p = pname
1612 else:
1612 else:
1613 p = str(self.series.index(pname)) + " " + pname
1613 p = str(self.series.index(pname)) + " " + pname
1614 return p
1614 return p
1615
1615
1616 def qimport(self, repo, files, patchname=None, rev=None, existing=None,
1616 def qimport(self, repo, files, patchname=None, rev=None, existing=None,
1617 force=None, git=False):
1617 force=None, git=False):
1618 def checkseries(patchname):
1618 def checkseries(patchname):
1619 if patchname in self.series:
1619 if patchname in self.series:
1620 raise util.Abort(_('patch %s is already in the series file')
1620 raise util.Abort(_('patch %s is already in the series file')
1621 % patchname)
1621 % patchname)
1622 def checkfile(patchname):
1622 def checkfile(patchname):
1623 if not force and os.path.exists(self.join(patchname)):
1623 if not force and os.path.exists(self.join(patchname)):
1624 raise util.Abort(_('patch "%s" already exists')
1624 raise util.Abort(_('patch "%s" already exists')
1625 % patchname)
1625 % patchname)
1626
1626
1627 if rev:
1627 if rev:
1628 if files:
1628 if files:
1629 raise util.Abort(_('option "-r" not valid when importing '
1629 raise util.Abort(_('option "-r" not valid when importing '
1630 'files'))
1630 'files'))
1631 rev = cmdutil.revrange(repo, rev)
1631 rev = cmdutil.revrange(repo, rev)
1632 rev.sort(reverse=True)
1632 rev.sort(reverse=True)
1633 if (len(files) > 1 or len(rev) > 1) and patchname:
1633 if (len(files) > 1 or len(rev) > 1) and patchname:
1634 raise util.Abort(_('option "-n" not valid when importing multiple '
1634 raise util.Abort(_('option "-n" not valid when importing multiple '
1635 'patches'))
1635 'patches'))
1636 if rev:
1636 if rev:
1637 # If mq patches are applied, we can only import revisions
1637 # If mq patches are applied, we can only import revisions
1638 # that form a linear path to qbase.
1638 # that form a linear path to qbase.
1639 # Otherwise, they should form a linear path to a head.
1639 # Otherwise, they should form a linear path to a head.
1640 heads = repo.changelog.heads(repo.changelog.node(rev[-1]))
1640 heads = repo.changelog.heads(repo.changelog.node(rev[-1]))
1641 if len(heads) > 1:
1641 if len(heads) > 1:
1642 raise util.Abort(_('revision %d is the root of more than one '
1642 raise util.Abort(_('revision %d is the root of more than one '
1643 'branch') % rev[-1])
1643 'branch') % rev[-1])
1644 if self.applied:
1644 if self.applied:
1645 base = repo.changelog.node(rev[0])
1645 base = repo.changelog.node(rev[0])
1646 if base in [n.node for n in self.applied]:
1646 if base in [n.node for n in self.applied]:
1647 raise util.Abort(_('revision %d is already managed')
1647 raise util.Abort(_('revision %d is already managed')
1648 % rev[0])
1648 % rev[0])
1649 if heads != [self.applied[-1].node]:
1649 if heads != [self.applied[-1].node]:
1650 raise util.Abort(_('revision %d is not the parent of '
1650 raise util.Abort(_('revision %d is not the parent of '
1651 'the queue') % rev[0])
1651 'the queue') % rev[0])
1652 base = repo.changelog.rev(self.applied[0].node)
1652 base = repo.changelog.rev(self.applied[0].node)
1653 lastparent = repo.changelog.parentrevs(base)[0]
1653 lastparent = repo.changelog.parentrevs(base)[0]
1654 else:
1654 else:
1655 if heads != [repo.changelog.node(rev[0])]:
1655 if heads != [repo.changelog.node(rev[0])]:
1656 raise util.Abort(_('revision %d has unmanaged children')
1656 raise util.Abort(_('revision %d has unmanaged children')
1657 % rev[0])
1657 % rev[0])
1658 lastparent = None
1658 lastparent = None
1659
1659
1660 diffopts = self.diffopts({'git': git})
1660 diffopts = self.diffopts({'git': git})
1661 for r in rev:
1661 for r in rev:
1662 p1, p2 = repo.changelog.parentrevs(r)
1662 p1, p2 = repo.changelog.parentrevs(r)
1663 n = repo.changelog.node(r)
1663 n = repo.changelog.node(r)
1664 if p2 != nullrev:
1664 if p2 != nullrev:
1665 raise util.Abort(_('cannot import merge revision %d') % r)
1665 raise util.Abort(_('cannot import merge revision %d') % r)
1666 if lastparent and lastparent != r:
1666 if lastparent and lastparent != r:
1667 raise util.Abort(_('revision %d is not the parent of %d')
1667 raise util.Abort(_('revision %d is not the parent of %d')
1668 % (r, lastparent))
1668 % (r, lastparent))
1669 lastparent = p1
1669 lastparent = p1
1670
1670
1671 if not patchname:
1671 if not patchname:
1672 patchname = normname('%d.diff' % r)
1672 patchname = normname('%d.diff' % r)
1673 self.check_reserved_name(patchname)
1673 self.check_reserved_name(patchname)
1674 checkseries(patchname)
1674 checkseries(patchname)
1675 checkfile(patchname)
1675 checkfile(patchname)
1676 self.full_series.insert(0, patchname)
1676 self.full_series.insert(0, patchname)
1677
1677
1678 patchf = self.opener(patchname, "w")
1678 patchf = self.opener(patchname, "w")
1679 cmdutil.export(repo, [n], fp=patchf, opts=diffopts)
1679 cmdutil.export(repo, [n], fp=patchf, opts=diffopts)
1680 patchf.close()
1680 patchf.close()
1681
1681
1682 se = statusentry(n, patchname)
1682 se = statusentry(n, patchname)
1683 self.applied.insert(0, se)
1683 self.applied.insert(0, se)
1684
1684
1685 self.added.append(patchname)
1685 self.added.append(patchname)
1686 patchname = None
1686 patchname = None
1687 self.parse_series()
1687 self.parse_series()
1688 self.applied_dirty = 1
1688 self.applied_dirty = 1
1689 self.series_dirty = True
1689 self.series_dirty = True
1690
1690
1691 for i, filename in enumerate(files):
1691 for i, filename in enumerate(files):
1692 if existing:
1692 if existing:
1693 if filename == '-':
1693 if filename == '-':
1694 raise util.Abort(_('-e is incompatible with import from -'))
1694 raise util.Abort(_('-e is incompatible with import from -'))
1695 filename = normname(filename)
1695 filename = normname(filename)
1696 self.check_reserved_name(filename)
1696 self.check_reserved_name(filename)
1697 originpath = self.join(filename)
1697 originpath = self.join(filename)
1698 if not os.path.isfile(originpath):
1698 if not os.path.isfile(originpath):
1699 raise util.Abort(_("patch %s does not exist") % filename)
1699 raise util.Abort(_("patch %s does not exist") % filename)
1700
1700
1701 if patchname:
1701 if patchname:
1702 self.check_reserved_name(patchname)
1702 self.check_reserved_name(patchname)
1703 checkfile(patchname)
1703 checkfile(patchname)
1704
1704
1705 self.ui.write(_('renaming %s to %s\n')
1705 self.ui.write(_('renaming %s to %s\n')
1706 % (filename, patchname))
1706 % (filename, patchname))
1707 util.rename(originpath, self.join(patchname))
1707 util.rename(originpath, self.join(patchname))
1708 else:
1708 else:
1709 patchname = filename
1709 patchname = filename
1710
1710
1711 else:
1711 else:
1712 try:
1712 try:
1713 if filename == '-':
1713 if filename == '-':
1714 if not patchname:
1714 if not patchname:
1715 raise util.Abort(
1715 raise util.Abort(
1716 _('need --name to import a patch from -'))
1716 _('need --name to import a patch from -'))
1717 text = sys.stdin.read()
1717 text = sys.stdin.read()
1718 else:
1718 else:
1719 text = url.open(self.ui, filename).read()
1719 text = url.open(self.ui, filename).read()
1720 except (OSError, IOError):
1720 except (OSError, IOError):
1721 raise util.Abort(_("unable to read file %s") % filename)
1721 raise util.Abort(_("unable to read file %s") % filename)
1722 if not patchname:
1722 if not patchname:
1723 patchname = normname(os.path.basename(filename))
1723 patchname = normname(os.path.basename(filename))
1724 self.check_reserved_name(patchname)
1724 self.check_reserved_name(patchname)
1725 checkfile(patchname)
1725 checkfile(patchname)
1726 patchf = self.opener(patchname, "w")
1726 patchf = self.opener(patchname, "w")
1727 patchf.write(text)
1727 patchf.write(text)
1728 if not force:
1728 if not force:
1729 checkseries(patchname)
1729 checkseries(patchname)
1730 if patchname not in self.series:
1730 if patchname not in self.series:
1731 index = self.full_series_end() + i
1731 index = self.full_series_end() + i
1732 self.full_series[index:index] = [patchname]
1732 self.full_series[index:index] = [patchname]
1733 self.parse_series()
1733 self.parse_series()
1734 self.series_dirty = True
1734 self.series_dirty = True
1735 self.ui.warn(_("adding %s to series file\n") % patchname)
1735 self.ui.warn(_("adding %s to series file\n") % patchname)
1736 self.added.append(patchname)
1736 self.added.append(patchname)
1737 patchname = None
1737 patchname = None
1738
1738
1739 def delete(ui, repo, *patches, **opts):
1739 def delete(ui, repo, *patches, **opts):
1740 """remove patches from queue
1740 """remove patches from queue
1741
1741
1742 The patches must not be applied, and at least one patch is required. With
1742 The patches must not be applied, and at least one patch is required. With
1743 -k/--keep, the patch files are preserved in the patch directory.
1743 -k/--keep, the patch files are preserved in the patch directory.
1744
1744
1745 To stop managing a patch and move it into permanent history,
1745 To stop managing a patch and move it into permanent history,
1746 use the :hg:`qfinish` command."""
1746 use the :hg:`qfinish` command."""
1747 q = repo.mq
1747 q = repo.mq
1748 q.delete(repo, patches, opts)
1748 q.delete(repo, patches, opts)
1749 q.save_dirty()
1749 q.save_dirty()
1750 return 0
1750 return 0
1751
1751
1752 def applied(ui, repo, patch=None, **opts):
1752 def applied(ui, repo, patch=None, **opts):
1753 """print the patches already applied"""
1753 """print the patches already applied"""
1754
1754
1755 q = repo.mq
1755 q = repo.mq
1756 l = len(q.applied)
1756 l = len(q.applied)
1757
1757
1758 if patch:
1758 if patch:
1759 if patch not in q.series:
1759 if patch not in q.series:
1760 raise util.Abort(_("patch %s is not in series file") % patch)
1760 raise util.Abort(_("patch %s is not in series file") % patch)
1761 end = q.series.index(patch) + 1
1761 end = q.series.index(patch) + 1
1762 else:
1762 else:
1763 end = q.series_end(True)
1763 end = q.series_end(True)
1764
1764
1765 if opts.get('last') and not end:
1765 if opts.get('last') and not end:
1766 ui.write(_("no patches applied\n"))
1766 ui.write(_("no patches applied\n"))
1767 return 1
1767 return 1
1768 elif opts.get('last') and end == 1:
1768 elif opts.get('last') and end == 1:
1769 ui.write(_("only one patch applied\n"))
1769 ui.write(_("only one patch applied\n"))
1770 return 1
1770 return 1
1771 elif opts.get('last'):
1771 elif opts.get('last'):
1772 start = end - 2
1772 start = end - 2
1773 end = 1
1773 end = 1
1774 else:
1774 else:
1775 start = 0
1775 start = 0
1776
1776
1777 return q.qseries(repo, length=end, start=start, status='A',
1777 return q.qseries(repo, length=end, start=start, status='A',
1778 summary=opts.get('summary'))
1778 summary=opts.get('summary'))
1779
1779
1780 def unapplied(ui, repo, patch=None, **opts):
1780 def unapplied(ui, repo, patch=None, **opts):
1781 """print the patches not yet applied"""
1781 """print the patches not yet applied"""
1782
1782
1783 q = repo.mq
1783 q = repo.mq
1784 if patch:
1784 if patch:
1785 if patch not in q.series:
1785 if patch not in q.series:
1786 raise util.Abort(_("patch %s is not in series file") % patch)
1786 raise util.Abort(_("patch %s is not in series file") % patch)
1787 start = q.series.index(patch) + 1
1787 start = q.series.index(patch) + 1
1788 else:
1788 else:
1789 start = q.series_end(True)
1789 start = q.series_end(True)
1790
1790
1791 if start == len(q.series) and opts.get('first'):
1791 if start == len(q.series) and opts.get('first'):
1792 ui.write(_("all patches applied\n"))
1792 ui.write(_("all patches applied\n"))
1793 return 1
1793 return 1
1794
1794
1795 length = opts.get('first') and 1 or None
1795 length = opts.get('first') and 1 or None
1796 return q.qseries(repo, start=start, length=length, status='U',
1796 return q.qseries(repo, start=start, length=length, status='U',
1797 summary=opts.get('summary'))
1797 summary=opts.get('summary'))
1798
1798
1799 def qimport(ui, repo, *filename, **opts):
1799 def qimport(ui, repo, *filename, **opts):
1800 """import a patch
1800 """import a patch
1801
1801
1802 The patch is inserted into the series after the last applied
1802 The patch is inserted into the series after the last applied
1803 patch. If no patches have been applied, qimport prepends the patch
1803 patch. If no patches have been applied, qimport prepends the patch
1804 to the series.
1804 to the series.
1805
1805
1806 The patch will have the same name as its source file unless you
1806 The patch will have the same name as its source file unless you
1807 give it a new one with -n/--name.
1807 give it a new one with -n/--name.
1808
1808
1809 You can register an existing patch inside the patch directory with
1809 You can register an existing patch inside the patch directory with
1810 the -e/--existing flag.
1810 the -e/--existing flag.
1811
1811
1812 With -f/--force, an existing patch of the same name will be
1812 With -f/--force, an existing patch of the same name will be
1813 overwritten.
1813 overwritten.
1814
1814
1815 An existing changeset may be placed under mq control with -r/--rev
1815 An existing changeset may be placed under mq control with -r/--rev
1816 (e.g. qimport --rev tip -n patch will place tip under mq control).
1816 (e.g. qimport --rev tip -n patch will place tip under mq control).
1817 With -g/--git, patches imported with --rev will use the git diff
1817 With -g/--git, patches imported with --rev will use the git diff
1818 format. See the diffs help topic for information on why this is
1818 format. See the diffs help topic for information on why this is
1819 important for preserving rename/copy information and permission
1819 important for preserving rename/copy information and permission
1820 changes.
1820 changes.
1821
1821
1822 To import a patch from standard input, pass - as the patch file.
1822 To import a patch from standard input, pass - as the patch file.
1823 When importing from standard input, a patch name must be specified
1823 When importing from standard input, a patch name must be specified
1824 using the --name flag.
1824 using the --name flag.
1825
1825
1826 To import an existing patch while renaming it::
1826 To import an existing patch while renaming it::
1827
1827
1828 hg qimport -e existing-patch -n new-name
1828 hg qimport -e existing-patch -n new-name
1829 """
1829 """
1830 q = repo.mq
1830 q = repo.mq
1831 try:
1831 try:
1832 q.qimport(repo, filename, patchname=opts['name'],
1832 q.qimport(repo, filename, patchname=opts['name'],
1833 existing=opts['existing'], force=opts['force'], rev=opts['rev'],
1833 existing=opts['existing'], force=opts['force'], rev=opts['rev'],
1834 git=opts['git'])
1834 git=opts['git'])
1835 finally:
1835 finally:
1836 q.save_dirty()
1836 q.save_dirty()
1837
1837
1838 if opts.get('push') and not opts.get('rev'):
1838 if opts.get('push') and not opts.get('rev'):
1839 return q.push(repo, None)
1839 return q.push(repo, None)
1840 return 0
1840 return 0
1841
1841
1842 def qinit(ui, repo, create):
1842 def qinit(ui, repo, create):
1843 """initialize a new queue repository
1843 """initialize a new queue repository
1844
1844
1845 This command also creates a series file for ordering patches, and
1845 This command also creates a series file for ordering patches, and
1846 an mq-specific .hgignore file in the queue repository, to exclude
1846 an mq-specific .hgignore file in the queue repository, to exclude
1847 the status and guards files (these contain mostly transient state)."""
1847 the status and guards files (these contain mostly transient state)."""
1848 q = repo.mq
1848 q = repo.mq
1849 r = q.init(repo, create)
1849 r = q.init(repo, create)
1850 q.save_dirty()
1850 q.save_dirty()
1851 if r:
1851 if r:
1852 if not os.path.exists(r.wjoin('.hgignore')):
1852 if not os.path.exists(r.wjoin('.hgignore')):
1853 fp = r.wopener('.hgignore', 'w')
1853 fp = r.wopener('.hgignore', 'w')
1854 fp.write('^\\.hg\n')
1854 fp.write('^\\.hg\n')
1855 fp.write('^\\.mq\n')
1855 fp.write('^\\.mq\n')
1856 fp.write('syntax: glob\n')
1856 fp.write('syntax: glob\n')
1857 fp.write('status\n')
1857 fp.write('status\n')
1858 fp.write('guards\n')
1858 fp.write('guards\n')
1859 fp.close()
1859 fp.close()
1860 if not os.path.exists(r.wjoin('series')):
1860 if not os.path.exists(r.wjoin('series')):
1861 r.wopener('series', 'w').close()
1861 r.wopener('series', 'w').close()
1862 r[None].add(['.hgignore', 'series'])
1862 r[None].add(['.hgignore', 'series'])
1863 commands.add(ui, r)
1863 commands.add(ui, r)
1864 return 0
1864 return 0
1865
1865
1866 def init(ui, repo, **opts):
1866 def init(ui, repo, **opts):
1867 """init a new queue repository (DEPRECATED)
1867 """init a new queue repository (DEPRECATED)
1868
1868
1869 The queue repository is unversioned by default. If
1869 The queue repository is unversioned by default. If
1870 -c/--create-repo is specified, qinit will create a separate nested
1870 -c/--create-repo is specified, qinit will create a separate nested
1871 repository for patches (qinit -c may also be run later to convert
1871 repository for patches (qinit -c may also be run later to convert
1872 an unversioned patch repository into a versioned one). You can use
1872 an unversioned patch repository into a versioned one). You can use
1873 qcommit to commit changes to this queue repository.
1873 qcommit to commit changes to this queue repository.
1874
1874
1875 This command is deprecated. Without -c, it's implied by other relevant
1875 This command is deprecated. Without -c, it's implied by other relevant
1876 commands. With -c, use :hg:`init --mq` instead."""
1876 commands. With -c, use :hg:`init --mq` instead."""
1877 return qinit(ui, repo, create=opts['create_repo'])
1877 return qinit(ui, repo, create=opts['create_repo'])
1878
1878
1879 def clone(ui, source, dest=None, **opts):
1879 def clone(ui, source, dest=None, **opts):
1880 '''clone main and patch repository at same time
1880 '''clone main and patch repository at same time
1881
1881
1882 If source is local, destination will have no patches applied. If
1882 If source is local, destination will have no patches applied. If
1883 source is remote, this command can not check if patches are
1883 source is remote, this command can not check if patches are
1884 applied in source, so cannot guarantee that patches are not
1884 applied in source, so cannot guarantee that patches are not
1885 applied in destination. If you clone remote repository, be sure
1885 applied in destination. If you clone remote repository, be sure
1886 before that it has no patches applied.
1886 before that it has no patches applied.
1887
1887
1888 Source patch repository is looked for in <src>/.hg/patches by
1888 Source patch repository is looked for in <src>/.hg/patches by
1889 default. Use -p <url> to change.
1889 default. Use -p <url> to change.
1890
1890
1891 The patch directory must be a nested Mercurial repository, as
1891 The patch directory must be a nested Mercurial repository, as
1892 would be created by :hg:`init --mq`.
1892 would be created by :hg:`init --mq`.
1893 '''
1893 '''
1894 def patchdir(repo):
1894 def patchdir(repo):
1895 url = repo.url()
1895 url = repo.url()
1896 if url.endswith('/'):
1896 if url.endswith('/'):
1897 url = url[:-1]
1897 url = url[:-1]
1898 return url + '/.hg/patches'
1898 return url + '/.hg/patches'
1899 if dest is None:
1899 if dest is None:
1900 dest = hg.defaultdest(source)
1900 dest = hg.defaultdest(source)
1901 sr = hg.repository(hg.remoteui(ui, opts), ui.expandpath(source))
1901 sr = hg.repository(hg.remoteui(ui, opts), ui.expandpath(source))
1902 if opts['patches']:
1902 if opts['patches']:
1903 patchespath = ui.expandpath(opts['patches'])
1903 patchespath = ui.expandpath(opts['patches'])
1904 else:
1904 else:
1905 patchespath = patchdir(sr)
1905 patchespath = patchdir(sr)
1906 try:
1906 try:
1907 hg.repository(ui, patchespath)
1907 hg.repository(ui, patchespath)
1908 except error.RepoError:
1908 except error.RepoError:
1909 raise util.Abort(_('versioned patch repository not found'
1909 raise util.Abort(_('versioned patch repository not found'
1910 ' (see init --mq)'))
1910 ' (see init --mq)'))
1911 qbase, destrev = None, None
1911 qbase, destrev = None, None
1912 if sr.local():
1912 if sr.local():
1913 if sr.mq.applied:
1913 if sr.mq.applied:
1914 qbase = sr.mq.applied[0].node
1914 qbase = sr.mq.applied[0].node
1915 if not hg.islocal(dest):
1915 if not hg.islocal(dest):
1916 heads = set(sr.heads())
1916 heads = set(sr.heads())
1917 destrev = list(heads.difference(sr.heads(qbase)))
1917 destrev = list(heads.difference(sr.heads(qbase)))
1918 destrev.append(sr.changelog.parents(qbase)[0])
1918 destrev.append(sr.changelog.parents(qbase)[0])
1919 elif sr.capable('lookup'):
1919 elif sr.capable('lookup'):
1920 try:
1920 try:
1921 qbase = sr.lookup('qbase')
1921 qbase = sr.lookup('qbase')
1922 except error.RepoError:
1922 except error.RepoError:
1923 pass
1923 pass
1924 ui.note(_('cloning main repository\n'))
1924 ui.note(_('cloning main repository\n'))
1925 sr, dr = hg.clone(ui, sr.url(), dest,
1925 sr, dr = hg.clone(ui, sr.url(), dest,
1926 pull=opts['pull'],
1926 pull=opts['pull'],
1927 rev=destrev,
1927 rev=destrev,
1928 update=False,
1928 update=False,
1929 stream=opts['uncompressed'])
1929 stream=opts['uncompressed'])
1930 ui.note(_('cloning patch repository\n'))
1930 ui.note(_('cloning patch repository\n'))
1931 hg.clone(ui, opts['patches'] or patchdir(sr), patchdir(dr),
1931 hg.clone(ui, opts['patches'] or patchdir(sr), patchdir(dr),
1932 pull=opts['pull'], update=not opts['noupdate'],
1932 pull=opts['pull'], update=not opts['noupdate'],
1933 stream=opts['uncompressed'])
1933 stream=opts['uncompressed'])
1934 if dr.local():
1934 if dr.local():
1935 if qbase:
1935 if qbase:
1936 ui.note(_('stripping applied patches from destination '
1936 ui.note(_('stripping applied patches from destination '
1937 'repository\n'))
1937 'repository\n'))
1938 dr.mq.strip(dr, [qbase], update=False, backup=None)
1938 dr.mq.strip(dr, [qbase], update=False, backup=None)
1939 if not opts['noupdate']:
1939 if not opts['noupdate']:
1940 ui.note(_('updating destination repository\n'))
1940 ui.note(_('updating destination repository\n'))
1941 hg.update(dr, dr.changelog.tip())
1941 hg.update(dr, dr.changelog.tip())
1942
1942
1943 def commit(ui, repo, *pats, **opts):
1943 def commit(ui, repo, *pats, **opts):
1944 """commit changes in the queue repository (DEPRECATED)
1944 """commit changes in the queue repository (DEPRECATED)
1945
1945
1946 This command is deprecated; use :hg:`commit --mq` instead."""
1946 This command is deprecated; use :hg:`commit --mq` instead."""
1947 q = repo.mq
1947 q = repo.mq
1948 r = q.qrepo()
1948 r = q.qrepo()
1949 if not r:
1949 if not r:
1950 raise util.Abort('no queue repository')
1950 raise util.Abort('no queue repository')
1951 commands.commit(r.ui, r, *pats, **opts)
1951 commands.commit(r.ui, r, *pats, **opts)
1952
1952
1953 def series(ui, repo, **opts):
1953 def series(ui, repo, **opts):
1954 """print the entire series file"""
1954 """print the entire series file"""
1955 repo.mq.qseries(repo, missing=opts['missing'], summary=opts['summary'])
1955 repo.mq.qseries(repo, missing=opts['missing'], summary=opts['summary'])
1956 return 0
1956 return 0
1957
1957
1958 def top(ui, repo, **opts):
1958 def top(ui, repo, **opts):
1959 """print the name of the current patch"""
1959 """print the name of the current patch"""
1960 q = repo.mq
1960 q = repo.mq
1961 t = q.applied and q.series_end(True) or 0
1961 t = q.applied and q.series_end(True) or 0
1962 if t:
1962 if t:
1963 return q.qseries(repo, start=t - 1, length=1, status='A',
1963 return q.qseries(repo, start=t - 1, length=1, status='A',
1964 summary=opts.get('summary'))
1964 summary=opts.get('summary'))
1965 else:
1965 else:
1966 ui.write(_("no patches applied\n"))
1966 ui.write(_("no patches applied\n"))
1967 return 1
1967 return 1
1968
1968
1969 def next(ui, repo, **opts):
1969 def next(ui, repo, **opts):
1970 """print the name of the next patch"""
1970 """print the name of the next patch"""
1971 q = repo.mq
1971 q = repo.mq
1972 end = q.series_end()
1972 end = q.series_end()
1973 if end == len(q.series):
1973 if end == len(q.series):
1974 ui.write(_("all patches applied\n"))
1974 ui.write(_("all patches applied\n"))
1975 return 1
1975 return 1
1976 return q.qseries(repo, start=end, length=1, summary=opts.get('summary'))
1976 return q.qseries(repo, start=end, length=1, summary=opts.get('summary'))
1977
1977
1978 def prev(ui, repo, **opts):
1978 def prev(ui, repo, **opts):
1979 """print the name of the previous patch"""
1979 """print the name of the previous patch"""
1980 q = repo.mq
1980 q = repo.mq
1981 l = len(q.applied)
1981 l = len(q.applied)
1982 if l == 1:
1982 if l == 1:
1983 ui.write(_("only one patch applied\n"))
1983 ui.write(_("only one patch applied\n"))
1984 return 1
1984 return 1
1985 if not l:
1985 if not l:
1986 ui.write(_("no patches applied\n"))
1986 ui.write(_("no patches applied\n"))
1987 return 1
1987 return 1
1988 return q.qseries(repo, start=l - 2, length=1, status='A',
1988 return q.qseries(repo, start=l - 2, length=1, status='A',
1989 summary=opts.get('summary'))
1989 summary=opts.get('summary'))
1990
1990
1991 def setupheaderopts(ui, opts):
1991 def setupheaderopts(ui, opts):
1992 if not opts.get('user') and opts.get('currentuser'):
1992 if not opts.get('user') and opts.get('currentuser'):
1993 opts['user'] = ui.username()
1993 opts['user'] = ui.username()
1994 if not opts.get('date') and opts.get('currentdate'):
1994 if not opts.get('date') and opts.get('currentdate'):
1995 opts['date'] = "%d %d" % util.makedate()
1995 opts['date'] = "%d %d" % util.makedate()
1996
1996
1997 def new(ui, repo, patch, *args, **opts):
1997 def new(ui, repo, patch, *args, **opts):
1998 """create a new patch
1998 """create a new patch
1999
1999
2000 qnew creates a new patch on top of the currently-applied patch (if
2000 qnew creates a new patch on top of the currently-applied patch (if
2001 any). The patch will be initialized with any outstanding changes
2001 any). The patch will be initialized with any outstanding changes
2002 in the working directory. You may also use -I/--include,
2002 in the working directory. You may also use -I/--include,
2003 -X/--exclude, and/or a list of files after the patch name to add
2003 -X/--exclude, and/or a list of files after the patch name to add
2004 only changes to matching files to the new patch, leaving the rest
2004 only changes to matching files to the new patch, leaving the rest
2005 as uncommitted modifications.
2005 as uncommitted modifications.
2006
2006
2007 -u/--user and -d/--date can be used to set the (given) user and
2007 -u/--user and -d/--date can be used to set the (given) user and
2008 date, respectively. -U/--currentuser and -D/--currentdate set user
2008 date, respectively. -U/--currentuser and -D/--currentdate set user
2009 to current user and date to current date.
2009 to current user and date to current date.
2010
2010
2011 -e/--edit, -m/--message or -l/--logfile set the patch header as
2011 -e/--edit, -m/--message or -l/--logfile set the patch header as
2012 well as the commit message. If none is specified, the header is
2012 well as the commit message. If none is specified, the header is
2013 empty and the commit message is '[mq]: PATCH'.
2013 empty and the commit message is '[mq]: PATCH'.
2014
2014
2015 Use the -g/--git option to keep the patch in the git extended diff
2015 Use the -g/--git option to keep the patch in the git extended diff
2016 format. Read the diffs help topic for more information on why this
2016 format. Read the diffs help topic for more information on why this
2017 is important for preserving permission changes and copy/rename
2017 is important for preserving permission changes and copy/rename
2018 information.
2018 information.
2019 """
2019 """
2020 msg = cmdutil.logmessage(opts)
2020 msg = cmdutil.logmessage(opts)
2021 def getmsg():
2021 def getmsg():
2022 return ui.edit(msg, opts['user'] or ui.username())
2022 return ui.edit(msg, opts['user'] or ui.username())
2023 q = repo.mq
2023 q = repo.mq
2024 opts['msg'] = msg
2024 opts['msg'] = msg
2025 if opts.get('edit'):
2025 if opts.get('edit'):
2026 opts['msg'] = getmsg
2026 opts['msg'] = getmsg
2027 else:
2027 else:
2028 opts['msg'] = msg
2028 opts['msg'] = msg
2029 setupheaderopts(ui, opts)
2029 setupheaderopts(ui, opts)
2030 q.new(repo, patch, *args, **opts)
2030 q.new(repo, patch, *args, **opts)
2031 q.save_dirty()
2031 q.save_dirty()
2032 return 0
2032 return 0
2033
2033
2034 def refresh(ui, repo, *pats, **opts):
2034 def refresh(ui, repo, *pats, **opts):
2035 """update the current patch
2035 """update the current patch
2036
2036
2037 If any file patterns are provided, the refreshed patch will
2037 If any file patterns are provided, the refreshed patch will
2038 contain only the modifications that match those patterns; the
2038 contain only the modifications that match those patterns; the
2039 remaining modifications will remain in the working directory.
2039 remaining modifications will remain in the working directory.
2040
2040
2041 If -s/--short is specified, files currently included in the patch
2041 If -s/--short is specified, files currently included in the patch
2042 will be refreshed just like matched files and remain in the patch.
2042 will be refreshed just like matched files and remain in the patch.
2043
2043
2044 If -e/--edit is specified, Mercurial will start your configured editor for
2044 If -e/--edit is specified, Mercurial will start your configured editor for
2045 you to enter a message. In case qrefresh fails, you will find a backup of
2045 you to enter a message. In case qrefresh fails, you will find a backup of
2046 your message in ``.hg/last-message.txt``.
2046 your message in ``.hg/last-message.txt``.
2047
2047
2048 hg add/remove/copy/rename work as usual, though you might want to
2048 hg add/remove/copy/rename work as usual, though you might want to
2049 use git-style patches (-g/--git or [diff] git=1) to track copies
2049 use git-style patches (-g/--git or [diff] git=1) to track copies
2050 and renames. See the diffs help topic for more information on the
2050 and renames. See the diffs help topic for more information on the
2051 git diff format.
2051 git diff format.
2052 """
2052 """
2053 q = repo.mq
2053 q = repo.mq
2054 message = cmdutil.logmessage(opts)
2054 message = cmdutil.logmessage(opts)
2055 if opts['edit']:
2055 if opts['edit']:
2056 if not q.applied:
2056 if not q.applied:
2057 ui.write(_("no patches applied\n"))
2057 ui.write(_("no patches applied\n"))
2058 return 1
2058 return 1
2059 if message:
2059 if message:
2060 raise util.Abort(_('option "-e" incompatible with "-m" or "-l"'))
2060 raise util.Abort(_('option "-e" incompatible with "-m" or "-l"'))
2061 patch = q.applied[-1].name
2061 patch = q.applied[-1].name
2062 ph = patchheader(q.join(patch), q.plainmode)
2062 ph = patchheader(q.join(patch), q.plainmode)
2063 message = ui.edit('\n'.join(ph.message), ph.user or ui.username())
2063 message = ui.edit('\n'.join(ph.message), ph.user or ui.username())
2064 # We don't want to lose the patch message if qrefresh fails (issue2062)
2064 # We don't want to lose the patch message if qrefresh fails (issue2062)
2065 msgfile = repo.opener('last-message.txt', 'wb')
2065 msgfile = repo.opener('last-message.txt', 'wb')
2066 msgfile.write(message)
2066 msgfile.write(message)
2067 msgfile.close()
2067 msgfile.close()
2068 setupheaderopts(ui, opts)
2068 setupheaderopts(ui, opts)
2069 ret = q.refresh(repo, pats, msg=message, **opts)
2069 ret = q.refresh(repo, pats, msg=message, **opts)
2070 q.save_dirty()
2070 q.save_dirty()
2071 return ret
2071 return ret
2072
2072
2073 def diff(ui, repo, *pats, **opts):
2073 def diff(ui, repo, *pats, **opts):
2074 """diff of the current patch and subsequent modifications
2074 """diff of the current patch and subsequent modifications
2075
2075
2076 Shows a diff which includes the current patch as well as any
2076 Shows a diff which includes the current patch as well as any
2077 changes which have been made in the working directory since the
2077 changes which have been made in the working directory since the
2078 last refresh (thus showing what the current patch would become
2078 last refresh (thus showing what the current patch would become
2079 after a qrefresh).
2079 after a qrefresh).
2080
2080
2081 Use :hg:`diff` if you only want to see the changes made since the
2081 Use :hg:`diff` if you only want to see the changes made since the
2082 last qrefresh, or :hg:`export qtip` if you want to see changes
2082 last qrefresh, or :hg:`export qtip` if you want to see changes
2083 made by the current patch without including changes made since the
2083 made by the current patch without including changes made since the
2084 qrefresh.
2084 qrefresh.
2085 """
2085 """
2086 repo.mq.diff(repo, pats, opts)
2086 repo.mq.diff(repo, pats, opts)
2087 return 0
2087 return 0
2088
2088
2089 def fold(ui, repo, *files, **opts):
2089 def fold(ui, repo, *files, **opts):
2090 """fold the named patches into the current patch
2090 """fold the named patches into the current patch
2091
2091
2092 Patches must not yet be applied. Each patch will be successively
2092 Patches must not yet be applied. Each patch will be successively
2093 applied to the current patch in the order given. If all the
2093 applied to the current patch in the order given. If all the
2094 patches apply successfully, the current patch will be refreshed
2094 patches apply successfully, the current patch will be refreshed
2095 with the new cumulative patch, and the folded patches will be
2095 with the new cumulative patch, and the folded patches will be
2096 deleted. With -k/--keep, the folded patch files will not be
2096 deleted. With -k/--keep, the folded patch files will not be
2097 removed afterwards.
2097 removed afterwards.
2098
2098
2099 The header for each folded patch will be concatenated with the
2099 The header for each folded patch will be concatenated with the
2100 current patch header, separated by a line of '* * *'."""
2100 current patch header, separated by a line of '* * *'."""
2101
2101
2102 q = repo.mq
2102 q = repo.mq
2103
2103
2104 if not files:
2104 if not files:
2105 raise util.Abort(_('qfold requires at least one patch name'))
2105 raise util.Abort(_('qfold requires at least one patch name'))
2106 if not q.check_toppatch(repo)[0]:
2106 if not q.check_toppatch(repo)[0]:
2107 raise util.Abort(_('No patches applied'))
2107 raise util.Abort(_('No patches applied'))
2108 q.check_localchanges(repo)
2108 q.check_localchanges(repo)
2109
2109
2110 message = cmdutil.logmessage(opts)
2110 message = cmdutil.logmessage(opts)
2111 if opts['edit']:
2111 if opts['edit']:
2112 if message:
2112 if message:
2113 raise util.Abort(_('option "-e" incompatible with "-m" or "-l"'))
2113 raise util.Abort(_('option "-e" incompatible with "-m" or "-l"'))
2114
2114
2115 parent = q.lookup('qtip')
2115 parent = q.lookup('qtip')
2116 patches = []
2116 patches = []
2117 messages = []
2117 messages = []
2118 for f in files:
2118 for f in files:
2119 p = q.lookup(f)
2119 p = q.lookup(f)
2120 if p in patches or p == parent:
2120 if p in patches or p == parent:
2121 ui.warn(_('Skipping already folded patch %s') % p)
2121 ui.warn(_('Skipping already folded patch %s') % p)
2122 if q.isapplied(p):
2122 if q.isapplied(p):
2123 raise util.Abort(_('qfold cannot fold already applied patch %s') % p)
2123 raise util.Abort(_('qfold cannot fold already applied patch %s') % p)
2124 patches.append(p)
2124 patches.append(p)
2125
2125
2126 for p in patches:
2126 for p in patches:
2127 if not message:
2127 if not message:
2128 ph = patchheader(q.join(p), q.plainmode)
2128 ph = patchheader(q.join(p), q.plainmode)
2129 if ph.message:
2129 if ph.message:
2130 messages.append(ph.message)
2130 messages.append(ph.message)
2131 pf = q.join(p)
2131 pf = q.join(p)
2132 (patchsuccess, files, fuzz) = q.patch(repo, pf)
2132 (patchsuccess, files, fuzz) = q.patch(repo, pf)
2133 if not patchsuccess:
2133 if not patchsuccess:
2134 raise util.Abort(_('Error folding patch %s') % p)
2134 raise util.Abort(_('Error folding patch %s') % p)
2135 patch.updatedir(ui, repo, files)
2135 patch.updatedir(ui, repo, files)
2136
2136
2137 if not message:
2137 if not message:
2138 ph = patchheader(q.join(parent), q.plainmode)
2138 ph = patchheader(q.join(parent), q.plainmode)
2139 message, user = ph.message, ph.user
2139 message, user = ph.message, ph.user
2140 for msg in messages:
2140 for msg in messages:
2141 message.append('* * *')
2141 message.append('* * *')
2142 message.extend(msg)
2142 message.extend(msg)
2143 message = '\n'.join(message)
2143 message = '\n'.join(message)
2144
2144
2145 if opts['edit']:
2145 if opts['edit']:
2146 message = ui.edit(message, user or ui.username())
2146 message = ui.edit(message, user or ui.username())
2147
2147
2148 diffopts = q.patchopts(q.diffopts(), *patches)
2148 diffopts = q.patchopts(q.diffopts(), *patches)
2149 q.refresh(repo, msg=message, git=diffopts.git)
2149 q.refresh(repo, msg=message, git=diffopts.git)
2150 q.delete(repo, patches, opts)
2150 q.delete(repo, patches, opts)
2151 q.save_dirty()
2151 q.save_dirty()
2152
2152
2153 def goto(ui, repo, patch, **opts):
2153 def goto(ui, repo, patch, **opts):
2154 '''push or pop patches until named patch is at top of stack'''
2154 '''push or pop patches until named patch is at top of stack'''
2155 q = repo.mq
2155 q = repo.mq
2156 patch = q.lookup(patch)
2156 patch = q.lookup(patch)
2157 if q.isapplied(patch):
2157 if q.isapplied(patch):
2158 ret = q.pop(repo, patch, force=opts['force'])
2158 ret = q.pop(repo, patch, force=opts['force'])
2159 else:
2159 else:
2160 ret = q.push(repo, patch, force=opts['force'])
2160 ret = q.push(repo, patch, force=opts['force'])
2161 q.save_dirty()
2161 q.save_dirty()
2162 return ret
2162 return ret
2163
2163
2164 def guard(ui, repo, *args, **opts):
2164 def guard(ui, repo, *args, **opts):
2165 '''set or print guards for a patch
2165 '''set or print guards for a patch
2166
2166
2167 Guards control whether a patch can be pushed. A patch with no
2167 Guards control whether a patch can be pushed. A patch with no
2168 guards is always pushed. A patch with a positive guard ("+foo") is
2168 guards is always pushed. A patch with a positive guard ("+foo") is
2169 pushed only if the :hg:`qselect` command has activated it. A patch with
2169 pushed only if the :hg:`qselect` command has activated it. A patch with
2170 a negative guard ("-foo") is never pushed if the :hg:`qselect` command
2170 a negative guard ("-foo") is never pushed if the :hg:`qselect` command
2171 has activated it.
2171 has activated it.
2172
2172
2173 With no arguments, print the currently active guards.
2173 With no arguments, print the currently active guards.
2174 With arguments, set guards for the named patch.
2174 With arguments, set guards for the named patch.
2175 NOTE: Specifying negative guards now requires '--'.
2175 NOTE: Specifying negative guards now requires '--'.
2176
2176
2177 To set guards on another patch::
2177 To set guards on another patch::
2178
2178
2179 hg qguard other.patch -- +2.6.17 -stable
2179 hg qguard other.patch -- +2.6.17 -stable
2180 '''
2180 '''
2181 def status(idx):
2181 def status(idx):
2182 guards = q.series_guards[idx] or ['unguarded']
2182 guards = q.series_guards[idx] or ['unguarded']
2183 if q.series[idx] in applied:
2183 if q.series[idx] in applied:
2184 state = 'applied'
2184 state = 'applied'
2185 elif q.pushable(idx)[0]:
2185 elif q.pushable(idx)[0]:
2186 state = 'unapplied'
2186 state = 'unapplied'
2187 else:
2187 else:
2188 state = 'guarded'
2188 state = 'guarded'
2189 label = 'qguard.patch qguard.%s qseries.%s' % (state, state)
2189 label = 'qguard.patch qguard.%s qseries.%s' % (state, state)
2190 ui.write('%s: ' % ui.label(q.series[idx], label))
2190 ui.write('%s: ' % ui.label(q.series[idx], label))
2191
2191
2192 for i, guard in enumerate(guards):
2192 for i, guard in enumerate(guards):
2193 if guard.startswith('+'):
2193 if guard.startswith('+'):
2194 ui.write(guard, label='qguard.positive')
2194 ui.write(guard, label='qguard.positive')
2195 elif guard.startswith('-'):
2195 elif guard.startswith('-'):
2196 ui.write(guard, label='qguard.negative')
2196 ui.write(guard, label='qguard.negative')
2197 else:
2197 else:
2198 ui.write(guard, label='qguard.unguarded')
2198 ui.write(guard, label='qguard.unguarded')
2199 if i != len(guards) - 1:
2199 if i != len(guards) - 1:
2200 ui.write(' ')
2200 ui.write(' ')
2201 ui.write('\n')
2201 ui.write('\n')
2202 q = repo.mq
2202 q = repo.mq
2203 applied = set(p.name for p in q.applied)
2203 applied = set(p.name for p in q.applied)
2204 patch = None
2204 patch = None
2205 args = list(args)
2205 args = list(args)
2206 if opts['list']:
2206 if opts['list']:
2207 if args or opts['none']:
2207 if args or opts['none']:
2208 raise util.Abort(_('cannot mix -l/--list with options or arguments'))
2208 raise util.Abort(_('cannot mix -l/--list with options or arguments'))
2209 for i in xrange(len(q.series)):
2209 for i in xrange(len(q.series)):
2210 status(i)
2210 status(i)
2211 return
2211 return
2212 if not args or args[0][0:1] in '-+':
2212 if not args or args[0][0:1] in '-+':
2213 if not q.applied:
2213 if not q.applied:
2214 raise util.Abort(_('no patches applied'))
2214 raise util.Abort(_('no patches applied'))
2215 patch = q.applied[-1].name
2215 patch = q.applied[-1].name
2216 if patch is None and args[0][0:1] not in '-+':
2216 if patch is None and args[0][0:1] not in '-+':
2217 patch = args.pop(0)
2217 patch = args.pop(0)
2218 if patch is None:
2218 if patch is None:
2219 raise util.Abort(_('no patch to work with'))
2219 raise util.Abort(_('no patch to work with'))
2220 if args or opts['none']:
2220 if args or opts['none']:
2221 idx = q.find_series(patch)
2221 idx = q.find_series(patch)
2222 if idx is None:
2222 if idx is None:
2223 raise util.Abort(_('no patch named %s') % patch)
2223 raise util.Abort(_('no patch named %s') % patch)
2224 q.set_guards(idx, args)
2224 q.set_guards(idx, args)
2225 q.save_dirty()
2225 q.save_dirty()
2226 else:
2226 else:
2227 status(q.series.index(q.lookup(patch)))
2227 status(q.series.index(q.lookup(patch)))
2228
2228
2229 def header(ui, repo, patch=None):
2229 def header(ui, repo, patch=None):
2230 """print the header of the topmost or specified patch"""
2230 """print the header of the topmost or specified patch"""
2231 q = repo.mq
2231 q = repo.mq
2232
2232
2233 if patch:
2233 if patch:
2234 patch = q.lookup(patch)
2234 patch = q.lookup(patch)
2235 else:
2235 else:
2236 if not q.applied:
2236 if not q.applied:
2237 ui.write(_('no patches applied\n'))
2237 ui.write(_('no patches applied\n'))
2238 return 1
2238 return 1
2239 patch = q.lookup('qtip')
2239 patch = q.lookup('qtip')
2240 ph = patchheader(q.join(patch), q.plainmode)
2240 ph = patchheader(q.join(patch), q.plainmode)
2241
2241
2242 ui.write('\n'.join(ph.message) + '\n')
2242 ui.write('\n'.join(ph.message) + '\n')
2243
2243
2244 def lastsavename(path):
2244 def lastsavename(path):
2245 (directory, base) = os.path.split(path)
2245 (directory, base) = os.path.split(path)
2246 names = os.listdir(directory)
2246 names = os.listdir(directory)
2247 namere = re.compile("%s.([0-9]+)" % base)
2247 namere = re.compile("%s.([0-9]+)" % base)
2248 maxindex = None
2248 maxindex = None
2249 maxname = None
2249 maxname = None
2250 for f in names:
2250 for f in names:
2251 m = namere.match(f)
2251 m = namere.match(f)
2252 if m:
2252 if m:
2253 index = int(m.group(1))
2253 index = int(m.group(1))
2254 if maxindex is None or index > maxindex:
2254 if maxindex is None or index > maxindex:
2255 maxindex = index
2255 maxindex = index
2256 maxname = f
2256 maxname = f
2257 if maxname:
2257 if maxname:
2258 return (os.path.join(directory, maxname), maxindex)
2258 return (os.path.join(directory, maxname), maxindex)
2259 return (None, None)
2259 return (None, None)
2260
2260
2261 def savename(path):
2261 def savename(path):
2262 (last, index) = lastsavename(path)
2262 (last, index) = lastsavename(path)
2263 if last is None:
2263 if last is None:
2264 index = 0
2264 index = 0
2265 newpath = path + ".%d" % (index + 1)
2265 newpath = path + ".%d" % (index + 1)
2266 return newpath
2266 return newpath
2267
2267
2268 def push(ui, repo, patch=None, **opts):
2268 def push(ui, repo, patch=None, **opts):
2269 """push the next patch onto the stack
2269 """push the next patch onto the stack
2270
2270
2271 When -f/--force is applied, all local changes in patched files
2271 When -f/--force is applied, all local changes in patched files
2272 will be lost.
2272 will be lost.
2273 """
2273 """
2274 q = repo.mq
2274 q = repo.mq
2275 mergeq = None
2275 mergeq = None
2276
2276
2277 if opts['merge']:
2277 if opts['merge']:
2278 if opts['name']:
2278 if opts['name']:
2279 newpath = repo.join(opts['name'])
2279 newpath = repo.join(opts['name'])
2280 else:
2280 else:
2281 newpath, i = lastsavename(q.path)
2281 newpath, i = lastsavename(q.path)
2282 if not newpath:
2282 if not newpath:
2283 ui.warn(_("no saved queues found, please use -n\n"))
2283 ui.warn(_("no saved queues found, please use -n\n"))
2284 return 1
2284 return 1
2285 mergeq = queue(ui, repo.join(""), newpath)
2285 mergeq = queue(ui, repo.join(""), newpath)
2286 ui.warn(_("merging with queue at: %s\n") % mergeq.path)
2286 ui.warn(_("merging with queue at: %s\n") % mergeq.path)
2287 ret = q.push(repo, patch, force=opts['force'], list=opts['list'],
2287 ret = q.push(repo, patch, force=opts['force'], list=opts['list'],
2288 mergeq=mergeq, all=opts.get('all'), move=opts.get('move'))
2288 mergeq=mergeq, all=opts.get('all'), move=opts.get('move'))
2289 return ret
2289 return ret
2290
2290
2291 def pop(ui, repo, patch=None, **opts):
2291 def pop(ui, repo, patch=None, **opts):
2292 """pop the current patch off the stack
2292 """pop the current patch off the stack
2293
2293
2294 By default, pops off the top of the patch stack. If given a patch
2294 By default, pops off the top of the patch stack. If given a patch
2295 name, keeps popping off patches until the named patch is at the
2295 name, keeps popping off patches until the named patch is at the
2296 top of the stack.
2296 top of the stack.
2297 """
2297 """
2298 localupdate = True
2298 localupdate = True
2299 if opts['name']:
2299 if opts['name']:
2300 q = queue(ui, repo.join(""), repo.join(opts['name']))
2300 q = queue(ui, repo.join(""), repo.join(opts['name']))
2301 ui.warn(_('using patch queue: %s\n') % q.path)
2301 ui.warn(_('using patch queue: %s\n') % q.path)
2302 localupdate = False
2302 localupdate = False
2303 else:
2303 else:
2304 q = repo.mq
2304 q = repo.mq
2305 ret = q.pop(repo, patch, force=opts['force'], update=localupdate,
2305 ret = q.pop(repo, patch, force=opts['force'], update=localupdate,
2306 all=opts['all'])
2306 all=opts['all'])
2307 q.save_dirty()
2307 q.save_dirty()
2308 return ret
2308 return ret
2309
2309
2310 def rename(ui, repo, patch, name=None, **opts):
2310 def rename(ui, repo, patch, name=None, **opts):
2311 """rename a patch
2311 """rename a patch
2312
2312
2313 With one argument, renames the current patch to PATCH1.
2313 With one argument, renames the current patch to PATCH1.
2314 With two arguments, renames PATCH1 to PATCH2."""
2314 With two arguments, renames PATCH1 to PATCH2."""
2315
2315
2316 q = repo.mq
2316 q = repo.mq
2317
2317
2318 if not name:
2318 if not name:
2319 name = patch
2319 name = patch
2320 patch = None
2320 patch = None
2321
2321
2322 if patch:
2322 if patch:
2323 patch = q.lookup(patch)
2323 patch = q.lookup(patch)
2324 else:
2324 else:
2325 if not q.applied:
2325 if not q.applied:
2326 ui.write(_('no patches applied\n'))
2326 ui.write(_('no patches applied\n'))
2327 return
2327 return
2328 patch = q.lookup('qtip')
2328 patch = q.lookup('qtip')
2329 absdest = q.join(name)
2329 absdest = q.join(name)
2330 if os.path.isdir(absdest):
2330 if os.path.isdir(absdest):
2331 name = normname(os.path.join(name, os.path.basename(patch)))
2331 name = normname(os.path.join(name, os.path.basename(patch)))
2332 absdest = q.join(name)
2332 absdest = q.join(name)
2333 if os.path.exists(absdest):
2333 if os.path.exists(absdest):
2334 raise util.Abort(_('%s already exists') % absdest)
2334 raise util.Abort(_('%s already exists') % absdest)
2335
2335
2336 if name in q.series:
2336 if name in q.series:
2337 raise util.Abort(
2337 raise util.Abort(
2338 _('A patch named %s already exists in the series file') % name)
2338 _('A patch named %s already exists in the series file') % name)
2339
2339
2340 ui.note(_('renaming %s to %s\n') % (patch, name))
2340 ui.note(_('renaming %s to %s\n') % (patch, name))
2341 i = q.find_series(patch)
2341 i = q.find_series(patch)
2342 guards = q.guard_re.findall(q.full_series[i])
2342 guards = q.guard_re.findall(q.full_series[i])
2343 q.full_series[i] = name + ''.join([' #' + g for g in guards])
2343 q.full_series[i] = name + ''.join([' #' + g for g in guards])
2344 q.parse_series()
2344 q.parse_series()
2345 q.series_dirty = 1
2345 q.series_dirty = 1
2346
2346
2347 info = q.isapplied(patch)
2347 info = q.isapplied(patch)
2348 if info:
2348 if info:
2349 q.applied[info[0]] = statusentry(info[1], name)
2349 q.applied[info[0]] = statusentry(info[1], name)
2350 q.applied_dirty = 1
2350 q.applied_dirty = 1
2351
2351
2352 destdir = os.path.dirname(absdest)
2352 destdir = os.path.dirname(absdest)
2353 if not os.path.isdir(destdir):
2353 if not os.path.isdir(destdir):
2354 os.makedirs(destdir)
2354 os.makedirs(destdir)
2355 util.rename(q.join(patch), absdest)
2355 util.rename(q.join(patch), absdest)
2356 r = q.qrepo()
2356 r = q.qrepo()
2357 if r:
2357 if r:
2358 wctx = r[None]
2358 wctx = r[None]
2359 wlock = r.wlock()
2359 wlock = r.wlock()
2360 try:
2360 try:
2361 if r.dirstate[patch] == 'a':
2361 if r.dirstate[patch] == 'a':
2362 r.dirstate.forget(patch)
2362 r.dirstate.forget(patch)
2363 r.dirstate.add(name)
2363 r.dirstate.add(name)
2364 else:
2364 else:
2365 if r.dirstate[name] == 'r':
2365 if r.dirstate[name] == 'r':
2366 wctx.undelete([name])
2366 wctx.undelete([name])
2367 wctx.copy(patch, name)
2367 wctx.copy(patch, name)
2368 wctx.remove([patch], False)
2368 wctx.remove([patch], False)
2369 finally:
2369 finally:
2370 wlock.release()
2370 wlock.release()
2371
2371
2372 q.save_dirty()
2372 q.save_dirty()
2373
2373
2374 def restore(ui, repo, rev, **opts):
2374 def restore(ui, repo, rev, **opts):
2375 """restore the queue state saved by a revision (DEPRECATED)
2375 """restore the queue state saved by a revision (DEPRECATED)
2376
2376
2377 This command is deprecated, use rebase --mq instead."""
2377 This command is deprecated, use rebase --mq instead."""
2378 rev = repo.lookup(rev)
2378 rev = repo.lookup(rev)
2379 q = repo.mq
2379 q = repo.mq
2380 q.restore(repo, rev, delete=opts['delete'],
2380 q.restore(repo, rev, delete=opts['delete'],
2381 qupdate=opts['update'])
2381 qupdate=opts['update'])
2382 q.save_dirty()
2382 q.save_dirty()
2383 return 0
2383 return 0
2384
2384
2385 def save(ui, repo, **opts):
2385 def save(ui, repo, **opts):
2386 """save current queue state (DEPRECATED)
2386 """save current queue state (DEPRECATED)
2387
2387
2388 This command is deprecated, use rebase --mq instead."""
2388 This command is deprecated, use rebase --mq instead."""
2389 q = repo.mq
2389 q = repo.mq
2390 message = cmdutil.logmessage(opts)
2390 message = cmdutil.logmessage(opts)
2391 ret = q.save(repo, msg=message)
2391 ret = q.save(repo, msg=message)
2392 if ret:
2392 if ret:
2393 return ret
2393 return ret
2394 q.save_dirty()
2394 q.save_dirty()
2395 if opts['copy']:
2395 if opts['copy']:
2396 path = q.path
2396 path = q.path
2397 if opts['name']:
2397 if opts['name']:
2398 newpath = os.path.join(q.basepath, opts['name'])
2398 newpath = os.path.join(q.basepath, opts['name'])
2399 if os.path.exists(newpath):
2399 if os.path.exists(newpath):
2400 if not os.path.isdir(newpath):
2400 if not os.path.isdir(newpath):
2401 raise util.Abort(_('destination %s exists and is not '
2401 raise util.Abort(_('destination %s exists and is not '
2402 'a directory') % newpath)
2402 'a directory') % newpath)
2403 if not opts['force']:
2403 if not opts['force']:
2404 raise util.Abort(_('destination %s exists, '
2404 raise util.Abort(_('destination %s exists, '
2405 'use -f to force') % newpath)
2405 'use -f to force') % newpath)
2406 else:
2406 else:
2407 newpath = savename(path)
2407 newpath = savename(path)
2408 ui.warn(_("copy %s to %s\n") % (path, newpath))
2408 ui.warn(_("copy %s to %s\n") % (path, newpath))
2409 util.copyfiles(path, newpath)
2409 util.copyfiles(path, newpath)
2410 if opts['empty']:
2410 if opts['empty']:
2411 try:
2411 try:
2412 os.unlink(q.join(q.status_path))
2412 os.unlink(q.join(q.status_path))
2413 except:
2413 except:
2414 pass
2414 pass
2415 return 0
2415 return 0
2416
2416
2417 def strip(ui, repo, *revs, **opts):
2417 def strip(ui, repo, *revs, **opts):
2418 """strip changesets and all their descendants from the repository
2418 """strip changesets and all their descendants from the repository
2419
2419
2420 The strip command removes the specified changesets and all their
2420 The strip command removes the specified changesets and all their
2421 descendants. If the working directory has uncommitted changes,
2421 descendants. If the working directory has uncommitted changes,
2422 the operation is aborted unless the --force flag is supplied.
2422 the operation is aborted unless the --force flag is supplied.
2423
2423
2424 If a parent of the working directory is stripped, then the working
2424 If a parent of the working directory is stripped, then the working
2425 directory will automatically be updated to the most recent
2425 directory will automatically be updated to the most recent
2426 available ancestor of the stripped parent after the operation
2426 available ancestor of the stripped parent after the operation
2427 completes.
2427 completes.
2428
2428
2429 Any stripped changesets are stored in ``.hg/strip-backup`` as a
2429 Any stripped changesets are stored in ``.hg/strip-backup`` as a
2430 bundle (see :hg:`help bundle` and :hg:`help unbundle`). They can
2430 bundle (see :hg:`help bundle` and :hg:`help unbundle`). They can
2431 be restored by running :hg:`unbundle .hg/strip-backup/BUNDLE`,
2431 be restored by running :hg:`unbundle .hg/strip-backup/BUNDLE`,
2432 where BUNDLE is the bundle file created by the strip. Note that
2432 where BUNDLE is the bundle file created by the strip. Note that
2433 the local revision numbers will in general be different after the
2433 the local revision numbers will in general be different after the
2434 restore.
2434 restore.
2435
2435
2436 Use the --nobackup option to discard the backup bundle once the
2436 Use the --nobackup option to discard the backup bundle once the
2437 operation completes.
2437 operation completes.
2438 """
2438 """
2439 backup = 'all'
2439 backup = 'all'
2440 if opts['backup']:
2440 if opts['backup']:
2441 backup = 'strip'
2441 backup = 'strip'
2442 elif opts['nobackup']:
2442 elif opts['nobackup']:
2443 backup = 'none'
2443 backup = 'none'
2444
2444
2445 cl = repo.changelog
2445 cl = repo.changelog
2446 revs = set(cl.rev(repo.lookup(r)) for r in revs)
2446 revs = set(cl.rev(repo.lookup(r)) for r in revs)
2447
2447
2448 descendants = set(cl.descendants(*revs))
2448 descendants = set(cl.descendants(*revs))
2449 strippedrevs = revs.union(descendants)
2449 strippedrevs = revs.union(descendants)
2450 roots = revs.difference(descendants)
2450 roots = revs.difference(descendants)
2451
2451
2452 update = False
2452 update = False
2453 # if one of the wdir parent is stripped we'll need
2453 # if one of the wdir parent is stripped we'll need
2454 # to update away to an earlier revision
2454 # to update away to an earlier revision
2455 for p in repo.dirstate.parents():
2455 for p in repo.dirstate.parents():
2456 if p != nullid and cl.rev(p) in strippedrevs:
2456 if p != nullid and cl.rev(p) in strippedrevs:
2457 update = True
2457 update = True
2458 break
2458 break
2459
2459
2460 rootnodes = set(cl.node(r) for r in roots)
2460 rootnodes = set(cl.node(r) for r in roots)
2461
2461
2462 q = repo.mq
2462 q = repo.mq
2463 if q.applied:
2463 if q.applied:
2464 # refresh queue state if we're about to strip
2464 # refresh queue state if we're about to strip
2465 # applied patches
2465 # applied patches
2466 if cl.rev(repo.lookup('qtip')) in strippedrevs:
2466 if cl.rev(repo.lookup('qtip')) in strippedrevs:
2467 q.applied_dirty = True
2467 q.applied_dirty = True
2468 start = 0
2468 start = 0
2469 end = len(q.applied)
2469 end = len(q.applied)
2470 for i, statusentry in enumerate(q.applied):
2470 for i, statusentry in enumerate(q.applied):
2471 if statusentry.node in rootnodes:
2471 if statusentry.node in rootnodes:
2472 # if one of the stripped roots is an applied
2472 # if one of the stripped roots is an applied
2473 # patch, only part of the queue is stripped
2473 # patch, only part of the queue is stripped
2474 start = i
2474 start = i
2475 break
2475 break
2476 del q.applied[start:end]
2476 del q.applied[start:end]
2477 q.save_dirty()
2477 q.save_dirty()
2478
2478
2479 repo.mq.strip(repo, list(rootnodes), backup=backup, update=update,
2479 repo.mq.strip(repo, list(rootnodes), backup=backup, update=update,
2480 force=opts['force'])
2480 force=opts['force'])
2481 return 0
2481 return 0
2482
2482
2483 def select(ui, repo, *args, **opts):
2483 def select(ui, repo, *args, **opts):
2484 '''set or print guarded patches to push
2484 '''set or print guarded patches to push
2485
2485
2486 Use the :hg:`qguard` command to set or print guards on patch, then use
2486 Use the :hg:`qguard` command to set or print guards on patch, then use
2487 qselect to tell mq which guards to use. A patch will be pushed if
2487 qselect to tell mq which guards to use. A patch will be pushed if
2488 it has no guards or any positive guards match the currently
2488 it has no guards or any positive guards match the currently
2489 selected guard, but will not be pushed if any negative guards
2489 selected guard, but will not be pushed if any negative guards
2490 match the current guard. For example::
2490 match the current guard. For example::
2491
2491
2492 qguard foo.patch -stable (negative guard)
2492 qguard foo.patch -stable (negative guard)
2493 qguard bar.patch +stable (positive guard)
2493 qguard bar.patch +stable (positive guard)
2494 qselect stable
2494 qselect stable
2495
2495
2496 This activates the "stable" guard. mq will skip foo.patch (because
2496 This activates the "stable" guard. mq will skip foo.patch (because
2497 it has a negative match) but push bar.patch (because it has a
2497 it has a negative match) but push bar.patch (because it has a
2498 positive match).
2498 positive match).
2499
2499
2500 With no arguments, prints the currently active guards.
2500 With no arguments, prints the currently active guards.
2501 With one argument, sets the active guard.
2501 With one argument, sets the active guard.
2502
2502
2503 Use -n/--none to deactivate guards (no other arguments needed).
2503 Use -n/--none to deactivate guards (no other arguments needed).
2504 When no guards are active, patches with positive guards are
2504 When no guards are active, patches with positive guards are
2505 skipped and patches with negative guards are pushed.
2505 skipped and patches with negative guards are pushed.
2506
2506
2507 qselect can change the guards on applied patches. It does not pop
2507 qselect can change the guards on applied patches. It does not pop
2508 guarded patches by default. Use --pop to pop back to the last
2508 guarded patches by default. Use --pop to pop back to the last
2509 applied patch that is not guarded. Use --reapply (which implies
2509 applied patch that is not guarded. Use --reapply (which implies
2510 --pop) to push back to the current patch afterwards, but skip
2510 --pop) to push back to the current patch afterwards, but skip
2511 guarded patches.
2511 guarded patches.
2512
2512
2513 Use -s/--series to print a list of all guards in the series file
2513 Use -s/--series to print a list of all guards in the series file
2514 (no other arguments needed). Use -v for more information.'''
2514 (no other arguments needed). Use -v for more information.'''
2515
2515
2516 q = repo.mq
2516 q = repo.mq
2517 guards = q.active()
2517 guards = q.active()
2518 if args or opts['none']:
2518 if args or opts['none']:
2519 old_unapplied = q.unapplied(repo)
2519 old_unapplied = q.unapplied(repo)
2520 old_guarded = [i for i in xrange(len(q.applied)) if
2520 old_guarded = [i for i in xrange(len(q.applied)) if
2521 not q.pushable(i)[0]]
2521 not q.pushable(i)[0]]
2522 q.set_active(args)
2522 q.set_active(args)
2523 q.save_dirty()
2523 q.save_dirty()
2524 if not args:
2524 if not args:
2525 ui.status(_('guards deactivated\n'))
2525 ui.status(_('guards deactivated\n'))
2526 if not opts['pop'] and not opts['reapply']:
2526 if not opts['pop'] and not opts['reapply']:
2527 unapplied = q.unapplied(repo)
2527 unapplied = q.unapplied(repo)
2528 guarded = [i for i in xrange(len(q.applied))
2528 guarded = [i for i in xrange(len(q.applied))
2529 if not q.pushable(i)[0]]
2529 if not q.pushable(i)[0]]
2530 if len(unapplied) != len(old_unapplied):
2530 if len(unapplied) != len(old_unapplied):
2531 ui.status(_('number of unguarded, unapplied patches has '
2531 ui.status(_('number of unguarded, unapplied patches has '
2532 'changed from %d to %d\n') %
2532 'changed from %d to %d\n') %
2533 (len(old_unapplied), len(unapplied)))
2533 (len(old_unapplied), len(unapplied)))
2534 if len(guarded) != len(old_guarded):
2534 if len(guarded) != len(old_guarded):
2535 ui.status(_('number of guarded, applied patches has changed '
2535 ui.status(_('number of guarded, applied patches has changed '
2536 'from %d to %d\n') %
2536 'from %d to %d\n') %
2537 (len(old_guarded), len(guarded)))
2537 (len(old_guarded), len(guarded)))
2538 elif opts['series']:
2538 elif opts['series']:
2539 guards = {}
2539 guards = {}
2540 noguards = 0
2540 noguards = 0
2541 for gs in q.series_guards:
2541 for gs in q.series_guards:
2542 if not gs:
2542 if not gs:
2543 noguards += 1
2543 noguards += 1
2544 for g in gs:
2544 for g in gs:
2545 guards.setdefault(g, 0)
2545 guards.setdefault(g, 0)
2546 guards[g] += 1
2546 guards[g] += 1
2547 if ui.verbose:
2547 if ui.verbose:
2548 guards['NONE'] = noguards
2548 guards['NONE'] = noguards
2549 guards = guards.items()
2549 guards = guards.items()
2550 guards.sort(key=lambda x: x[0][1:])
2550 guards.sort(key=lambda x: x[0][1:])
2551 if guards:
2551 if guards:
2552 ui.note(_('guards in series file:\n'))
2552 ui.note(_('guards in series file:\n'))
2553 for guard, count in guards:
2553 for guard, count in guards:
2554 ui.note('%2d ' % count)
2554 ui.note('%2d ' % count)
2555 ui.write(guard, '\n')
2555 ui.write(guard, '\n')
2556 else:
2556 else:
2557 ui.note(_('no guards in series file\n'))
2557 ui.note(_('no guards in series file\n'))
2558 else:
2558 else:
2559 if guards:
2559 if guards:
2560 ui.note(_('active guards:\n'))
2560 ui.note(_('active guards:\n'))
2561 for g in guards:
2561 for g in guards:
2562 ui.write(g, '\n')
2562 ui.write(g, '\n')
2563 else:
2563 else:
2564 ui.write(_('no active guards\n'))
2564 ui.write(_('no active guards\n'))
2565 reapply = opts['reapply'] and q.applied and q.appliedname(-1)
2565 reapply = opts['reapply'] and q.applied and q.appliedname(-1)
2566 popped = False
2566 popped = False
2567 if opts['pop'] or opts['reapply']:
2567 if opts['pop'] or opts['reapply']:
2568 for i in xrange(len(q.applied)):
2568 for i in xrange(len(q.applied)):
2569 pushable, reason = q.pushable(i)
2569 pushable, reason = q.pushable(i)
2570 if not pushable:
2570 if not pushable:
2571 ui.status(_('popping guarded patches\n'))
2571 ui.status(_('popping guarded patches\n'))
2572 popped = True
2572 popped = True
2573 if i == 0:
2573 if i == 0:
2574 q.pop(repo, all=True)
2574 q.pop(repo, all=True)
2575 else:
2575 else:
2576 q.pop(repo, i - 1)
2576 q.pop(repo, i - 1)
2577 break
2577 break
2578 if popped:
2578 if popped:
2579 try:
2579 try:
2580 if reapply:
2580 if reapply:
2581 ui.status(_('reapplying unguarded patches\n'))
2581 ui.status(_('reapplying unguarded patches\n'))
2582 q.push(repo, reapply)
2582 q.push(repo, reapply)
2583 finally:
2583 finally:
2584 q.save_dirty()
2584 q.save_dirty()
2585
2585
2586 def finish(ui, repo, *revrange, **opts):
2586 def finish(ui, repo, *revrange, **opts):
2587 """move applied patches into repository history
2587 """move applied patches into repository history
2588
2588
2589 Finishes the specified revisions (corresponding to applied
2589 Finishes the specified revisions (corresponding to applied
2590 patches) by moving them out of mq control into regular repository
2590 patches) by moving them out of mq control into regular repository
2591 history.
2591 history.
2592
2592
2593 Accepts a revision range or the -a/--applied option. If --applied
2593 Accepts a revision range or the -a/--applied option. If --applied
2594 is specified, all applied mq revisions are removed from mq
2594 is specified, all applied mq revisions are removed from mq
2595 control. Otherwise, the given revisions must be at the base of the
2595 control. Otherwise, the given revisions must be at the base of the
2596 stack of applied patches.
2596 stack of applied patches.
2597
2597
2598 This can be especially useful if your changes have been applied to
2598 This can be especially useful if your changes have been applied to
2599 an upstream repository, or if you are about to push your changes
2599 an upstream repository, or if you are about to push your changes
2600 to upstream.
2600 to upstream.
2601 """
2601 """
2602 if not opts['applied'] and not revrange:
2602 if not opts['applied'] and not revrange:
2603 raise util.Abort(_('no revisions specified'))
2603 raise util.Abort(_('no revisions specified'))
2604 elif opts['applied']:
2604 elif opts['applied']:
2605 revrange = ('qbase::qtip',) + revrange
2605 revrange = ('qbase::qtip',) + revrange
2606
2606
2607 q = repo.mq
2607 q = repo.mq
2608 if not q.applied:
2608 if not q.applied:
2609 ui.status(_('no patches applied\n'))
2609 ui.status(_('no patches applied\n'))
2610 return 0
2610 return 0
2611
2611
2612 revs = cmdutil.revrange(repo, revrange)
2612 revs = cmdutil.revrange(repo, revrange)
2613 q.finish(repo, revs)
2613 q.finish(repo, revs)
2614 q.save_dirty()
2614 q.save_dirty()
2615 return 0
2615 return 0
2616
2616
2617 def qqueue(ui, repo, name=None, **opts):
2617 def qqueue(ui, repo, name=None, **opts):
2618 '''manage multiple patch queues
2618 '''manage multiple patch queues
2619
2619
2620 Supports switching between different patch queues, as well as creating
2620 Supports switching between different patch queues, as well as creating
2621 new patch queues and deleting existing ones.
2621 new patch queues and deleting existing ones.
2622
2622
2623 Omitting a queue name or specifying -l/--list will show you the registered
2623 Omitting a queue name or specifying -l/--list will show you the registered
2624 queues - by default the "normal" patches queue is registered. The currently
2624 queues - by default the "normal" patches queue is registered. The currently
2625 active queue will be marked with "(active)".
2625 active queue will be marked with "(active)".
2626
2626
2627 To create a new queue, use -c/--create. The queue is automatically made
2627 To create a new queue, use -c/--create. The queue is automatically made
2628 active, except in the case where there are applied patches from the
2628 active, except in the case where there are applied patches from the
2629 currently active queue in the repository. Then the queue will only be
2629 currently active queue in the repository. Then the queue will only be
2630 created and switching will fail.
2630 created and switching will fail.
2631
2631
2632 To delete an existing queue, use --delete. You cannot delete the currently
2632 To delete an existing queue, use --delete. You cannot delete the currently
2633 active queue.
2633 active queue.
2634 '''
2634 '''
2635
2635
2636 q = repo.mq
2636 q = repo.mq
2637
2637
2638 _defaultqueue = 'patches'
2638 _defaultqueue = 'patches'
2639 _allqueues = 'patches.queues'
2639 _allqueues = 'patches.queues'
2640 _activequeue = 'patches.queue'
2640 _activequeue = 'patches.queue'
2641
2641
2642 def _getcurrent():
2642 def _getcurrent():
2643 cur = os.path.basename(q.path)
2643 cur = os.path.basename(q.path)
2644 if cur.startswith('patches-'):
2644 if cur.startswith('patches-'):
2645 cur = cur[8:]
2645 cur = cur[8:]
2646 return cur
2646 return cur
2647
2647
2648 def _noqueues():
2648 def _noqueues():
2649 try:
2649 try:
2650 fh = repo.opener(_allqueues, 'r')
2650 fh = repo.opener(_allqueues, 'r')
2651 fh.close()
2651 fh.close()
2652 except IOError:
2652 except IOError:
2653 return True
2653 return True
2654
2654
2655 return False
2655 return False
2656
2656
2657 def _getqueues():
2657 def _getqueues():
2658 current = _getcurrent()
2658 current = _getcurrent()
2659
2659
2660 try:
2660 try:
2661 fh = repo.opener(_allqueues, 'r')
2661 fh = repo.opener(_allqueues, 'r')
2662 queues = [queue.strip() for queue in fh if queue.strip()]
2662 queues = [queue.strip() for queue in fh if queue.strip()]
2663 if current not in queues:
2663 if current not in queues:
2664 queues.append(current)
2664 queues.append(current)
2665 except IOError:
2665 except IOError:
2666 queues = [_defaultqueue]
2666 queues = [_defaultqueue]
2667
2667
2668 return sorted(queues)
2668 return sorted(queues)
2669
2669
2670 def _setactive(name):
2670 def _setactive(name):
2671 if q.applied:
2671 if q.applied:
2672 raise util.Abort(_('patches applied - cannot set new queue active'))
2672 raise util.Abort(_('patches applied - cannot set new queue active'))
2673 _setactivenocheck(name)
2673 _setactivenocheck(name)
2674
2674
2675 def _setactivenocheck(name):
2675 def _setactivenocheck(name):
2676 fh = repo.opener(_activequeue, 'w')
2676 fh = repo.opener(_activequeue, 'w')
2677 if name != 'patches':
2677 if name != 'patches':
2678 fh.write(name)
2678 fh.write(name)
2679 fh.close()
2679 fh.close()
2680
2680
2681 def _addqueue(name):
2681 def _addqueue(name):
2682 fh = repo.opener(_allqueues, 'a')
2682 fh = repo.opener(_allqueues, 'a')
2683 fh.write('%s\n' % (name,))
2683 fh.write('%s\n' % (name,))
2684 fh.close()
2684 fh.close()
2685
2685
2686 def _queuedir(name):
2686 def _queuedir(name):
2687 if name == 'patches':
2687 if name == 'patches':
2688 return repo.join('patches')
2688 return repo.join('patches')
2689 else:
2689 else:
2690 return repo.join('patches-' + name)
2690 return repo.join('patches-' + name)
2691
2691
2692 def _validname(name):
2692 def _validname(name):
2693 for n in name:
2693 for n in name:
2694 if n in ':\\/.':
2694 if n in ':\\/.':
2695 return False
2695 return False
2696 return True
2696 return True
2697
2697
2698 def _delete(name):
2698 def _delete(name):
2699 if name not in existing:
2699 if name not in existing:
2700 raise util.Abort(_('cannot delete queue that does not exist'))
2700 raise util.Abort(_('cannot delete queue that does not exist'))
2701
2701
2702 current = _getcurrent()
2702 current = _getcurrent()
2703
2703
2704 if name == current:
2704 if name == current:
2705 raise util.Abort(_('cannot delete currently active queue'))
2705 raise util.Abort(_('cannot delete currently active queue'))
2706
2706
2707 fh = repo.opener('patches.queues.new', 'w')
2707 fh = repo.opener('patches.queues.new', 'w')
2708 for queue in existing:
2708 for queue in existing:
2709 if queue == name:
2709 if queue == name:
2710 continue
2710 continue
2711 fh.write('%s\n' % (queue,))
2711 fh.write('%s\n' % (queue,))
2712 fh.close()
2712 fh.close()
2713 util.rename(repo.join('patches.queues.new'), repo.join(_allqueues))
2713 util.rename(repo.join('patches.queues.new'), repo.join(_allqueues))
2714
2714
2715 if not name or opts.get('list'):
2715 if not name or opts.get('list'):
2716 current = _getcurrent()
2716 current = _getcurrent()
2717 for queue in _getqueues():
2717 for queue in _getqueues():
2718 ui.write('%s' % (queue,))
2718 ui.write('%s' % (queue,))
2719 if queue == current and not ui.quiet:
2719 if queue == current and not ui.quiet:
2720 ui.write(_(' (active)\n'))
2720 ui.write(_(' (active)\n'))
2721 else:
2721 else:
2722 ui.write('\n')
2722 ui.write('\n')
2723 return
2723 return
2724
2724
2725 if not _validname(name):
2725 if not _validname(name):
2726 raise util.Abort(
2726 raise util.Abort(
2727 _('invalid queue name, may not contain the characters ":\\/."'))
2727 _('invalid queue name, may not contain the characters ":\\/."'))
2728
2728
2729 existing = _getqueues()
2729 existing = _getqueues()
2730
2730
2731 if opts.get('create'):
2731 if opts.get('create'):
2732 if name in existing:
2732 if name in existing:
2733 raise util.Abort(_('queue "%s" already exists') % name)
2733 raise util.Abort(_('queue "%s" already exists') % name)
2734 if _noqueues():
2734 if _noqueues():
2735 _addqueue(_defaultqueue)
2735 _addqueue(_defaultqueue)
2736 _addqueue(name)
2736 _addqueue(name)
2737 _setactive(name)
2737 _setactive(name)
2738 elif opts.get('rename'):
2738 elif opts.get('rename'):
2739 current = _getcurrent()
2739 current = _getcurrent()
2740 if name == current:
2740 if name == current:
2741 raise util.Abort(_('can\'t rename "%s" to its current name') % name)
2741 raise util.Abort(_('can\'t rename "%s" to its current name') % name)
2742 if name in existing:
2742 if name in existing:
2743 raise util.Abort(_('queue "%s" already exists') % name)
2743 raise util.Abort(_('queue "%s" already exists') % name)
2744
2744
2745 olddir = _queuedir(current)
2745 olddir = _queuedir(current)
2746 newdir = _queuedir(name)
2746 newdir = _queuedir(name)
2747
2747
2748 if os.path.exists(newdir):
2748 if os.path.exists(newdir):
2749 raise util.Abort(_('non-queue directory "%s" already exists') %
2749 raise util.Abort(_('non-queue directory "%s" already exists') %
2750 newdir)
2750 newdir)
2751
2751
2752 fh = repo.opener('patches.queues.new', 'w')
2752 fh = repo.opener('patches.queues.new', 'w')
2753 for queue in existing:
2753 for queue in existing:
2754 if queue == current:
2754 if queue == current:
2755 fh.write('%s\n' % (name,))
2755 fh.write('%s\n' % (name,))
2756 if os.path.exists(olddir):
2756 if os.path.exists(olddir):
2757 util.rename(olddir, newdir)
2757 util.rename(olddir, newdir)
2758 else:
2758 else:
2759 fh.write('%s\n' % (queue,))
2759 fh.write('%s\n' % (queue,))
2760 fh.close()
2760 fh.close()
2761 util.rename(repo.join('patches.queues.new'), repo.join(_allqueues))
2761 util.rename(repo.join('patches.queues.new'), repo.join(_allqueues))
2762 _setactivenocheck(name)
2762 _setactivenocheck(name)
2763 elif opts.get('delete'):
2763 elif opts.get('delete'):
2764 _delete(name)
2764 _delete(name)
2765 elif opts.get('purge'):
2766 if name in existing:
2767 _delete(name)
2768 qdir = _queuedir(name)
2769 if os.path.exists(qdir):
2770 shutil.rmtree(qdir)
2765 else:
2771 else:
2766 if name not in existing:
2772 if name not in existing:
2767 raise util.Abort(_('use --create to create a new queue'))
2773 raise util.Abort(_('use --create to create a new queue'))
2768 _setactive(name)
2774 _setactive(name)
2769
2775
2770 def reposetup(ui, repo):
2776 def reposetup(ui, repo):
2771 class mqrepo(repo.__class__):
2777 class mqrepo(repo.__class__):
2772 @util.propertycache
2778 @util.propertycache
2773 def mq(self):
2779 def mq(self):
2774 return queue(self.ui, self.join(""))
2780 return queue(self.ui, self.join(""))
2775
2781
2776 def abort_if_wdir_patched(self, errmsg, force=False):
2782 def abort_if_wdir_patched(self, errmsg, force=False):
2777 if self.mq.applied and not force:
2783 if self.mq.applied and not force:
2778 parent = self.dirstate.parents()[0]
2784 parent = self.dirstate.parents()[0]
2779 if parent in [s.node for s in self.mq.applied]:
2785 if parent in [s.node for s in self.mq.applied]:
2780 raise util.Abort(errmsg)
2786 raise util.Abort(errmsg)
2781
2787
2782 def commit(self, text="", user=None, date=None, match=None,
2788 def commit(self, text="", user=None, date=None, match=None,
2783 force=False, editor=False, extra={}):
2789 force=False, editor=False, extra={}):
2784 self.abort_if_wdir_patched(
2790 self.abort_if_wdir_patched(
2785 _('cannot commit over an applied mq patch'),
2791 _('cannot commit over an applied mq patch'),
2786 force)
2792 force)
2787
2793
2788 return super(mqrepo, self).commit(text, user, date, match, force,
2794 return super(mqrepo, self).commit(text, user, date, match, force,
2789 editor, extra)
2795 editor, extra)
2790
2796
2791 def push(self, remote, force=False, revs=None, newbranch=False):
2797 def push(self, remote, force=False, revs=None, newbranch=False):
2792 if self.mq.applied and not force and not revs:
2798 if self.mq.applied and not force and not revs:
2793 raise util.Abort(_('source has mq patches applied'))
2799 raise util.Abort(_('source has mq patches applied'))
2794 return super(mqrepo, self).push(remote, force, revs, newbranch)
2800 return super(mqrepo, self).push(remote, force, revs, newbranch)
2795
2801
2796 def _findtags(self):
2802 def _findtags(self):
2797 '''augment tags from base class with patch tags'''
2803 '''augment tags from base class with patch tags'''
2798 result = super(mqrepo, self)._findtags()
2804 result = super(mqrepo, self)._findtags()
2799
2805
2800 q = self.mq
2806 q = self.mq
2801 if not q.applied:
2807 if not q.applied:
2802 return result
2808 return result
2803
2809
2804 mqtags = [(patch.node, patch.name) for patch in q.applied]
2810 mqtags = [(patch.node, patch.name) for patch in q.applied]
2805
2811
2806 if mqtags[-1][0] not in self.changelog.nodemap:
2812 if mqtags[-1][0] not in self.changelog.nodemap:
2807 self.ui.warn(_('mq status file refers to unknown node %s\n')
2813 self.ui.warn(_('mq status file refers to unknown node %s\n')
2808 % short(mqtags[-1][0]))
2814 % short(mqtags[-1][0]))
2809 return result
2815 return result
2810
2816
2811 mqtags.append((mqtags[-1][0], 'qtip'))
2817 mqtags.append((mqtags[-1][0], 'qtip'))
2812 mqtags.append((mqtags[0][0], 'qbase'))
2818 mqtags.append((mqtags[0][0], 'qbase'))
2813 mqtags.append((self.changelog.parents(mqtags[0][0])[0], 'qparent'))
2819 mqtags.append((self.changelog.parents(mqtags[0][0])[0], 'qparent'))
2814 tags = result[0]
2820 tags = result[0]
2815 for patch in mqtags:
2821 for patch in mqtags:
2816 if patch[1] in tags:
2822 if patch[1] in tags:
2817 self.ui.warn(_('Tag %s overrides mq patch of the same name\n')
2823 self.ui.warn(_('Tag %s overrides mq patch of the same name\n')
2818 % patch[1])
2824 % patch[1])
2819 else:
2825 else:
2820 tags[patch[1]] = patch[0]
2826 tags[patch[1]] = patch[0]
2821
2827
2822 return result
2828 return result
2823
2829
2824 def _branchtags(self, partial, lrev):
2830 def _branchtags(self, partial, lrev):
2825 q = self.mq
2831 q = self.mq
2826 if not q.applied:
2832 if not q.applied:
2827 return super(mqrepo, self)._branchtags(partial, lrev)
2833 return super(mqrepo, self)._branchtags(partial, lrev)
2828
2834
2829 cl = self.changelog
2835 cl = self.changelog
2830 qbasenode = q.applied[0].node
2836 qbasenode = q.applied[0].node
2831 if qbasenode not in cl.nodemap:
2837 if qbasenode not in cl.nodemap:
2832 self.ui.warn(_('mq status file refers to unknown node %s\n')
2838 self.ui.warn(_('mq status file refers to unknown node %s\n')
2833 % short(qbasenode))
2839 % short(qbasenode))
2834 return super(mqrepo, self)._branchtags(partial, lrev)
2840 return super(mqrepo, self)._branchtags(partial, lrev)
2835
2841
2836 qbase = cl.rev(qbasenode)
2842 qbase = cl.rev(qbasenode)
2837 start = lrev + 1
2843 start = lrev + 1
2838 if start < qbase:
2844 if start < qbase:
2839 # update the cache (excluding the patches) and save it
2845 # update the cache (excluding the patches) and save it
2840 ctxgen = (self[r] for r in xrange(lrev + 1, qbase))
2846 ctxgen = (self[r] for r in xrange(lrev + 1, qbase))
2841 self._updatebranchcache(partial, ctxgen)
2847 self._updatebranchcache(partial, ctxgen)
2842 self._writebranchcache(partial, cl.node(qbase - 1), qbase - 1)
2848 self._writebranchcache(partial, cl.node(qbase - 1), qbase - 1)
2843 start = qbase
2849 start = qbase
2844 # if start = qbase, the cache is as updated as it should be.
2850 # if start = qbase, the cache is as updated as it should be.
2845 # if start > qbase, the cache includes (part of) the patches.
2851 # if start > qbase, the cache includes (part of) the patches.
2846 # we might as well use it, but we won't save it.
2852 # we might as well use it, but we won't save it.
2847
2853
2848 # update the cache up to the tip
2854 # update the cache up to the tip
2849 ctxgen = (self[r] for r in xrange(start, len(cl)))
2855 ctxgen = (self[r] for r in xrange(start, len(cl)))
2850 self._updatebranchcache(partial, ctxgen)
2856 self._updatebranchcache(partial, ctxgen)
2851
2857
2852 return partial
2858 return partial
2853
2859
2854 if repo.local():
2860 if repo.local():
2855 repo.__class__ = mqrepo
2861 repo.__class__ = mqrepo
2856
2862
2857 def mqimport(orig, ui, repo, *args, **kwargs):
2863 def mqimport(orig, ui, repo, *args, **kwargs):
2858 if (hasattr(repo, 'abort_if_wdir_patched')
2864 if (hasattr(repo, 'abort_if_wdir_patched')
2859 and not kwargs.get('no_commit', False)):
2865 and not kwargs.get('no_commit', False)):
2860 repo.abort_if_wdir_patched(_('cannot import over an applied patch'),
2866 repo.abort_if_wdir_patched(_('cannot import over an applied patch'),
2861 kwargs.get('force'))
2867 kwargs.get('force'))
2862 return orig(ui, repo, *args, **kwargs)
2868 return orig(ui, repo, *args, **kwargs)
2863
2869
2864 def mqinit(orig, ui, *args, **kwargs):
2870 def mqinit(orig, ui, *args, **kwargs):
2865 mq = kwargs.pop('mq', None)
2871 mq = kwargs.pop('mq', None)
2866
2872
2867 if not mq:
2873 if not mq:
2868 return orig(ui, *args, **kwargs)
2874 return orig(ui, *args, **kwargs)
2869
2875
2870 if args:
2876 if args:
2871 repopath = args[0]
2877 repopath = args[0]
2872 if not hg.islocal(repopath):
2878 if not hg.islocal(repopath):
2873 raise util.Abort(_('only a local queue repository '
2879 raise util.Abort(_('only a local queue repository '
2874 'may be initialized'))
2880 'may be initialized'))
2875 else:
2881 else:
2876 repopath = cmdutil.findrepo(os.getcwd())
2882 repopath = cmdutil.findrepo(os.getcwd())
2877 if not repopath:
2883 if not repopath:
2878 raise util.Abort(_('There is no Mercurial repository here '
2884 raise util.Abort(_('There is no Mercurial repository here '
2879 '(.hg not found)'))
2885 '(.hg not found)'))
2880 repo = hg.repository(ui, repopath)
2886 repo = hg.repository(ui, repopath)
2881 return qinit(ui, repo, True)
2887 return qinit(ui, repo, True)
2882
2888
2883 def mqcommand(orig, ui, repo, *args, **kwargs):
2889 def mqcommand(orig, ui, repo, *args, **kwargs):
2884 """Add --mq option to operate on patch repository instead of main"""
2890 """Add --mq option to operate on patch repository instead of main"""
2885
2891
2886 # some commands do not like getting unknown options
2892 # some commands do not like getting unknown options
2887 mq = kwargs.pop('mq', None)
2893 mq = kwargs.pop('mq', None)
2888
2894
2889 if not mq:
2895 if not mq:
2890 return orig(ui, repo, *args, **kwargs)
2896 return orig(ui, repo, *args, **kwargs)
2891
2897
2892 q = repo.mq
2898 q = repo.mq
2893 r = q.qrepo()
2899 r = q.qrepo()
2894 if not r:
2900 if not r:
2895 raise util.Abort(_('no queue repository'))
2901 raise util.Abort(_('no queue repository'))
2896 return orig(r.ui, r, *args, **kwargs)
2902 return orig(r.ui, r, *args, **kwargs)
2897
2903
2898 def summary(orig, ui, repo, *args, **kwargs):
2904 def summary(orig, ui, repo, *args, **kwargs):
2899 r = orig(ui, repo, *args, **kwargs)
2905 r = orig(ui, repo, *args, **kwargs)
2900 q = repo.mq
2906 q = repo.mq
2901 m = []
2907 m = []
2902 a, u = len(q.applied), len(q.unapplied(repo))
2908 a, u = len(q.applied), len(q.unapplied(repo))
2903 if a:
2909 if a:
2904 m.append(ui.label(_("%d applied"), 'qseries.applied') % a)
2910 m.append(ui.label(_("%d applied"), 'qseries.applied') % a)
2905 if u:
2911 if u:
2906 m.append(ui.label(_("%d unapplied"), 'qseries.unapplied') % u)
2912 m.append(ui.label(_("%d unapplied"), 'qseries.unapplied') % u)
2907 if m:
2913 if m:
2908 ui.write("mq: %s\n" % ', '.join(m))
2914 ui.write("mq: %s\n" % ', '.join(m))
2909 else:
2915 else:
2910 ui.note(_("mq: (empty queue)\n"))
2916 ui.note(_("mq: (empty queue)\n"))
2911 return r
2917 return r
2912
2918
2913 def uisetup(ui):
2919 def uisetup(ui):
2914 mqopt = [('', 'mq', None, _("operate on patch repository"))]
2920 mqopt = [('', 'mq', None, _("operate on patch repository"))]
2915
2921
2916 extensions.wrapcommand(commands.table, 'import', mqimport)
2922 extensions.wrapcommand(commands.table, 'import', mqimport)
2917 extensions.wrapcommand(commands.table, 'summary', summary)
2923 extensions.wrapcommand(commands.table, 'summary', summary)
2918
2924
2919 entry = extensions.wrapcommand(commands.table, 'init', mqinit)
2925 entry = extensions.wrapcommand(commands.table, 'init', mqinit)
2920 entry[1].extend(mqopt)
2926 entry[1].extend(mqopt)
2921
2927
2922 norepo = commands.norepo.split(" ")
2928 norepo = commands.norepo.split(" ")
2923 for cmd in commands.table.keys():
2929 for cmd in commands.table.keys():
2924 cmd = cmdutil.parsealiases(cmd)[0]
2930 cmd = cmdutil.parsealiases(cmd)[0]
2925 if cmd in norepo:
2931 if cmd in norepo:
2926 continue
2932 continue
2927 entry = extensions.wrapcommand(commands.table, cmd, mqcommand)
2933 entry = extensions.wrapcommand(commands.table, cmd, mqcommand)
2928 entry[1].extend(mqopt)
2934 entry[1].extend(mqopt)
2929
2935
2930 seriesopts = [('s', 'summary', None, _('print first line of patch header'))]
2936 seriesopts = [('s', 'summary', None, _('print first line of patch header'))]
2931
2937
2932 cmdtable = {
2938 cmdtable = {
2933 "qapplied":
2939 "qapplied":
2934 (applied,
2940 (applied,
2935 [('1', 'last', None, _('show only the last patch'))] + seriesopts,
2941 [('1', 'last', None, _('show only the last patch'))] + seriesopts,
2936 _('hg qapplied [-1] [-s] [PATCH]')),
2942 _('hg qapplied [-1] [-s] [PATCH]')),
2937 "qclone":
2943 "qclone":
2938 (clone,
2944 (clone,
2939 [('', 'pull', None, _('use pull protocol to copy metadata')),
2945 [('', 'pull', None, _('use pull protocol to copy metadata')),
2940 ('U', 'noupdate', None, _('do not update the new working directories')),
2946 ('U', 'noupdate', None, _('do not update the new working directories')),
2941 ('', 'uncompressed', None,
2947 ('', 'uncompressed', None,
2942 _('use uncompressed transfer (fast over LAN)')),
2948 _('use uncompressed transfer (fast over LAN)')),
2943 ('p', 'patches', '',
2949 ('p', 'patches', '',
2944 _('location of source patch repository'), _('REPO')),
2950 _('location of source patch repository'), _('REPO')),
2945 ] + commands.remoteopts,
2951 ] + commands.remoteopts,
2946 _('hg qclone [OPTION]... SOURCE [DEST]')),
2952 _('hg qclone [OPTION]... SOURCE [DEST]')),
2947 "qcommit|qci":
2953 "qcommit|qci":
2948 (commit,
2954 (commit,
2949 commands.table["^commit|ci"][1],
2955 commands.table["^commit|ci"][1],
2950 _('hg qcommit [OPTION]... [FILE]...')),
2956 _('hg qcommit [OPTION]... [FILE]...')),
2951 "^qdiff":
2957 "^qdiff":
2952 (diff,
2958 (diff,
2953 commands.diffopts + commands.diffopts2 + commands.walkopts,
2959 commands.diffopts + commands.diffopts2 + commands.walkopts,
2954 _('hg qdiff [OPTION]... [FILE]...')),
2960 _('hg qdiff [OPTION]... [FILE]...')),
2955 "qdelete|qremove|qrm":
2961 "qdelete|qremove|qrm":
2956 (delete,
2962 (delete,
2957 [('k', 'keep', None, _('keep patch file')),
2963 [('k', 'keep', None, _('keep patch file')),
2958 ('r', 'rev', [],
2964 ('r', 'rev', [],
2959 _('stop managing a revision (DEPRECATED)'), _('REV'))],
2965 _('stop managing a revision (DEPRECATED)'), _('REV'))],
2960 _('hg qdelete [-k] [-r REV]... [PATCH]...')),
2966 _('hg qdelete [-k] [-r REV]... [PATCH]...')),
2961 'qfold':
2967 'qfold':
2962 (fold,
2968 (fold,
2963 [('e', 'edit', None, _('edit patch header')),
2969 [('e', 'edit', None, _('edit patch header')),
2964 ('k', 'keep', None, _('keep folded patch files')),
2970 ('k', 'keep', None, _('keep folded patch files')),
2965 ] + commands.commitopts,
2971 ] + commands.commitopts,
2966 _('hg qfold [-e] [-k] [-m TEXT] [-l FILE] PATCH...')),
2972 _('hg qfold [-e] [-k] [-m TEXT] [-l FILE] PATCH...')),
2967 'qgoto':
2973 'qgoto':
2968 (goto,
2974 (goto,
2969 [('f', 'force', None, _('overwrite any local changes'))],
2975 [('f', 'force', None, _('overwrite any local changes'))],
2970 _('hg qgoto [OPTION]... PATCH')),
2976 _('hg qgoto [OPTION]... PATCH')),
2971 'qguard':
2977 'qguard':
2972 (guard,
2978 (guard,
2973 [('l', 'list', None, _('list all patches and guards')),
2979 [('l', 'list', None, _('list all patches and guards')),
2974 ('n', 'none', None, _('drop all guards'))],
2980 ('n', 'none', None, _('drop all guards'))],
2975 _('hg qguard [-l] [-n] [PATCH] [-- [+GUARD]... [-GUARD]...]')),
2981 _('hg qguard [-l] [-n] [PATCH] [-- [+GUARD]... [-GUARD]...]')),
2976 'qheader': (header, [], _('hg qheader [PATCH]')),
2982 'qheader': (header, [], _('hg qheader [PATCH]')),
2977 "qimport":
2983 "qimport":
2978 (qimport,
2984 (qimport,
2979 [('e', 'existing', None, _('import file in patch directory')),
2985 [('e', 'existing', None, _('import file in patch directory')),
2980 ('n', 'name', '',
2986 ('n', 'name', '',
2981 _('name of patch file'), _('NAME')),
2987 _('name of patch file'), _('NAME')),
2982 ('f', 'force', None, _('overwrite existing files')),
2988 ('f', 'force', None, _('overwrite existing files')),
2983 ('r', 'rev', [],
2989 ('r', 'rev', [],
2984 _('place existing revisions under mq control'), _('REV')),
2990 _('place existing revisions under mq control'), _('REV')),
2985 ('g', 'git', None, _('use git extended diff format')),
2991 ('g', 'git', None, _('use git extended diff format')),
2986 ('P', 'push', None, _('qpush after importing'))],
2992 ('P', 'push', None, _('qpush after importing'))],
2987 _('hg qimport [-e] [-n NAME] [-f] [-g] [-P] [-r REV]... FILE...')),
2993 _('hg qimport [-e] [-n NAME] [-f] [-g] [-P] [-r REV]... FILE...')),
2988 "^qinit":
2994 "^qinit":
2989 (init,
2995 (init,
2990 [('c', 'create-repo', None, _('create queue repository'))],
2996 [('c', 'create-repo', None, _('create queue repository'))],
2991 _('hg qinit [-c]')),
2997 _('hg qinit [-c]')),
2992 "^qnew":
2998 "^qnew":
2993 (new,
2999 (new,
2994 [('e', 'edit', None, _('edit commit message')),
3000 [('e', 'edit', None, _('edit commit message')),
2995 ('f', 'force', None, _('import uncommitted changes (DEPRECATED)')),
3001 ('f', 'force', None, _('import uncommitted changes (DEPRECATED)')),
2996 ('g', 'git', None, _('use git extended diff format')),
3002 ('g', 'git', None, _('use git extended diff format')),
2997 ('U', 'currentuser', None, _('add "From: <current user>" to patch')),
3003 ('U', 'currentuser', None, _('add "From: <current user>" to patch')),
2998 ('u', 'user', '',
3004 ('u', 'user', '',
2999 _('add "From: <USER>" to patch'), _('USER')),
3005 _('add "From: <USER>" to patch'), _('USER')),
3000 ('D', 'currentdate', None, _('add "Date: <current date>" to patch')),
3006 ('D', 'currentdate', None, _('add "Date: <current date>" to patch')),
3001 ('d', 'date', '',
3007 ('d', 'date', '',
3002 _('add "Date: <DATE>" to patch'), _('DATE'))
3008 _('add "Date: <DATE>" to patch'), _('DATE'))
3003 ] + commands.walkopts + commands.commitopts,
3009 ] + commands.walkopts + commands.commitopts,
3004 _('hg qnew [-e] [-m TEXT] [-l FILE] PATCH [FILE]...')),
3010 _('hg qnew [-e] [-m TEXT] [-l FILE] PATCH [FILE]...')),
3005 "qnext": (next, [] + seriesopts, _('hg qnext [-s]')),
3011 "qnext": (next, [] + seriesopts, _('hg qnext [-s]')),
3006 "qprev": (prev, [] + seriesopts, _('hg qprev [-s]')),
3012 "qprev": (prev, [] + seriesopts, _('hg qprev [-s]')),
3007 "^qpop":
3013 "^qpop":
3008 (pop,
3014 (pop,
3009 [('a', 'all', None, _('pop all patches')),
3015 [('a', 'all', None, _('pop all patches')),
3010 ('n', 'name', '',
3016 ('n', 'name', '',
3011 _('queue name to pop (DEPRECATED)'), _('NAME')),
3017 _('queue name to pop (DEPRECATED)'), _('NAME')),
3012 ('f', 'force', None, _('forget any local changes to patched files'))],
3018 ('f', 'force', None, _('forget any local changes to patched files'))],
3013 _('hg qpop [-a] [-n NAME] [-f] [PATCH | INDEX]')),
3019 _('hg qpop [-a] [-n NAME] [-f] [PATCH | INDEX]')),
3014 "^qpush":
3020 "^qpush":
3015 (push,
3021 (push,
3016 [('f', 'force', None, _('apply if the patch has rejects')),
3022 [('f', 'force', None, _('apply if the patch has rejects')),
3017 ('l', 'list', None, _('list patch name in commit text')),
3023 ('l', 'list', None, _('list patch name in commit text')),
3018 ('a', 'all', None, _('apply all patches')),
3024 ('a', 'all', None, _('apply all patches')),
3019 ('m', 'merge', None, _('merge from another queue (DEPRECATED)')),
3025 ('m', 'merge', None, _('merge from another queue (DEPRECATED)')),
3020 ('n', 'name', '',
3026 ('n', 'name', '',
3021 _('merge queue name (DEPRECATED)'), _('NAME')),
3027 _('merge queue name (DEPRECATED)'), _('NAME')),
3022 ('', 'move', None, _('reorder patch series and apply only the patch'))],
3028 ('', 'move', None, _('reorder patch series and apply only the patch'))],
3023 _('hg qpush [-f] [-l] [-a] [-m] [-n NAME] [--move] [PATCH | INDEX]')),
3029 _('hg qpush [-f] [-l] [-a] [-m] [-n NAME] [--move] [PATCH | INDEX]')),
3024 "^qrefresh":
3030 "^qrefresh":
3025 (refresh,
3031 (refresh,
3026 [('e', 'edit', None, _('edit commit message')),
3032 [('e', 'edit', None, _('edit commit message')),
3027 ('g', 'git', None, _('use git extended diff format')),
3033 ('g', 'git', None, _('use git extended diff format')),
3028 ('s', 'short', None,
3034 ('s', 'short', None,
3029 _('refresh only files already in the patch and specified files')),
3035 _('refresh only files already in the patch and specified files')),
3030 ('U', 'currentuser', None,
3036 ('U', 'currentuser', None,
3031 _('add/update author field in patch with current user')),
3037 _('add/update author field in patch with current user')),
3032 ('u', 'user', '',
3038 ('u', 'user', '',
3033 _('add/update author field in patch with given user'), _('USER')),
3039 _('add/update author field in patch with given user'), _('USER')),
3034 ('D', 'currentdate', None,
3040 ('D', 'currentdate', None,
3035 _('add/update date field in patch with current date')),
3041 _('add/update date field in patch with current date')),
3036 ('d', 'date', '',
3042 ('d', 'date', '',
3037 _('add/update date field in patch with given date'), _('DATE'))
3043 _('add/update date field in patch with given date'), _('DATE'))
3038 ] + commands.walkopts + commands.commitopts,
3044 ] + commands.walkopts + commands.commitopts,
3039 _('hg qrefresh [-I] [-X] [-e] [-m TEXT] [-l FILE] [-s] [FILE]...')),
3045 _('hg qrefresh [-I] [-X] [-e] [-m TEXT] [-l FILE] [-s] [FILE]...')),
3040 'qrename|qmv':
3046 'qrename|qmv':
3041 (rename, [], _('hg qrename PATCH1 [PATCH2]')),
3047 (rename, [], _('hg qrename PATCH1 [PATCH2]')),
3042 "qrestore":
3048 "qrestore":
3043 (restore,
3049 (restore,
3044 [('d', 'delete', None, _('delete save entry')),
3050 [('d', 'delete', None, _('delete save entry')),
3045 ('u', 'update', None, _('update queue working directory'))],
3051 ('u', 'update', None, _('update queue working directory'))],
3046 _('hg qrestore [-d] [-u] REV')),
3052 _('hg qrestore [-d] [-u] REV')),
3047 "qsave":
3053 "qsave":
3048 (save,
3054 (save,
3049 [('c', 'copy', None, _('copy patch directory')),
3055 [('c', 'copy', None, _('copy patch directory')),
3050 ('n', 'name', '',
3056 ('n', 'name', '',
3051 _('copy directory name'), _('NAME')),
3057 _('copy directory name'), _('NAME')),
3052 ('e', 'empty', None, _('clear queue status file')),
3058 ('e', 'empty', None, _('clear queue status file')),
3053 ('f', 'force', None, _('force copy'))] + commands.commitopts,
3059 ('f', 'force', None, _('force copy'))] + commands.commitopts,
3054 _('hg qsave [-m TEXT] [-l FILE] [-c] [-n NAME] [-e] [-f]')),
3060 _('hg qsave [-m TEXT] [-l FILE] [-c] [-n NAME] [-e] [-f]')),
3055 "qselect":
3061 "qselect":
3056 (select,
3062 (select,
3057 [('n', 'none', None, _('disable all guards')),
3063 [('n', 'none', None, _('disable all guards')),
3058 ('s', 'series', None, _('list all guards in series file')),
3064 ('s', 'series', None, _('list all guards in series file')),
3059 ('', 'pop', None, _('pop to before first guarded applied patch')),
3065 ('', 'pop', None, _('pop to before first guarded applied patch')),
3060 ('', 'reapply', None, _('pop, then reapply patches'))],
3066 ('', 'reapply', None, _('pop, then reapply patches'))],
3061 _('hg qselect [OPTION]... [GUARD]...')),
3067 _('hg qselect [OPTION]... [GUARD]...')),
3062 "qseries":
3068 "qseries":
3063 (series,
3069 (series,
3064 [('m', 'missing', None, _('print patches not in series')),
3070 [('m', 'missing', None, _('print patches not in series')),
3065 ] + seriesopts,
3071 ] + seriesopts,
3066 _('hg qseries [-ms]')),
3072 _('hg qseries [-ms]')),
3067 "strip":
3073 "strip":
3068 (strip,
3074 (strip,
3069 [('f', 'force', None, _('force removal of changesets even if the '
3075 [('f', 'force', None, _('force removal of changesets even if the '
3070 'working directory has uncommitted changes')),
3076 'working directory has uncommitted changes')),
3071 ('b', 'backup', None, _('bundle only changesets with local revision'
3077 ('b', 'backup', None, _('bundle only changesets with local revision'
3072 ' number greater than REV which are not'
3078 ' number greater than REV which are not'
3073 ' descendants of REV (DEPRECATED)')),
3079 ' descendants of REV (DEPRECATED)')),
3074 ('n', 'nobackup', None, _('no backups'))],
3080 ('n', 'nobackup', None, _('no backups'))],
3075 _('hg strip [-f] [-n] REV...')),
3081 _('hg strip [-f] [-n] REV...')),
3076 "qtop": (top, [] + seriesopts, _('hg qtop [-s]')),
3082 "qtop": (top, [] + seriesopts, _('hg qtop [-s]')),
3077 "qunapplied":
3083 "qunapplied":
3078 (unapplied,
3084 (unapplied,
3079 [('1', 'first', None, _('show only the first patch'))] + seriesopts,
3085 [('1', 'first', None, _('show only the first patch'))] + seriesopts,
3080 _('hg qunapplied [-1] [-s] [PATCH]')),
3086 _('hg qunapplied [-1] [-s] [PATCH]')),
3081 "qfinish":
3087 "qfinish":
3082 (finish,
3088 (finish,
3083 [('a', 'applied', None, _('finish all applied changesets'))],
3089 [('a', 'applied', None, _('finish all applied changesets'))],
3084 _('hg qfinish [-a] [REV]...')),
3090 _('hg qfinish [-a] [REV]...')),
3085 'qqueue':
3091 'qqueue':
3086 (qqueue,
3092 (qqueue,
3087 [
3093 [
3088 ('l', 'list', False, _('list all available queues')),
3094 ('l', 'list', False, _('list all available queues')),
3089 ('c', 'create', False, _('create new queue')),
3095 ('c', 'create', False, _('create new queue')),
3090 ('', 'rename', False, _('rename active queue')),
3096 ('', 'rename', False, _('rename active queue')),
3091 ('', 'delete', False, _('delete reference to queue')),
3097 ('', 'delete', False, _('delete reference to queue')),
3098 ('', 'purge', False, _('delete queue, and remove patch dir')),
3092 ],
3099 ],
3093 _('[OPTION] [QUEUE]')),
3100 _('[OPTION] [QUEUE]')),
3094 }
3101 }
3095
3102
3096 colortable = {'qguard.negative': 'red',
3103 colortable = {'qguard.negative': 'red',
3097 'qguard.positive': 'yellow',
3104 'qguard.positive': 'yellow',
3098 'qguard.unguarded': 'green',
3105 'qguard.unguarded': 'green',
3099 'qseries.applied': 'blue bold underline',
3106 'qseries.applied': 'blue bold underline',
3100 'qseries.guarded': 'black bold',
3107 'qseries.guarded': 'black bold',
3101 'qseries.missing': 'red bold',
3108 'qseries.missing': 'red bold',
3102 'qseries.unapplied': 'black bold'}
3109 'qseries.unapplied': 'black bold'}
@@ -1,86 +1,101 b''
1 #!/bin/sh
1 #!/bin/sh
2
2
3 echo "[extensions]" >> $HGRCPATH
3 echo "[extensions]" >> $HGRCPATH
4 echo "mq=" >> $HGRCPATH
4 echo "mq=" >> $HGRCPATH
5
5
6 hg init foo
6 hg init foo
7 cd foo
7 cd foo
8 echo a > a
8 echo a > a
9 hg ci -qAm a
9 hg ci -qAm a
10
10
11 echo %% default queue
11 echo %% default queue
12 hg qqueue
12 hg qqueue
13
13
14 echo b > a
14 echo b > a
15 hg qnew -fgDU somestuff
15 hg qnew -fgDU somestuff
16
16
17 echo %% applied patches in default queue
17 echo %% applied patches in default queue
18 hg qap
18 hg qap
19
19
20 echo %% try to change patch \(create succeeds, switch fails\)
20 echo %% try to change patch \(create succeeds, switch fails\)
21 hg qqueue foo --create
21 hg qqueue foo --create
22 hg qqueue
22 hg qqueue
23
23
24 echo %% empty default queue
24 echo %% empty default queue
25 hg qpop
25 hg qpop
26
26
27 echo %% switch queue
27 echo %% switch queue
28 hg qqueue foo
28 hg qqueue foo
29 hg qqueue
29 hg qqueue
30
30
31 echo %% list queues, quiet
31 echo %% list queues, quiet
32 hg qqueue --quiet
32 hg qqueue --quiet
33
33
34 echo %% fail creating queue with already existing name
34 echo %% fail creating queue with already existing name
35 hg qqueue --create foo
35 hg qqueue --create foo
36 hg qqueue
36 hg qqueue
37
37
38 echo %% create new queue for rename
38 echo %% create new queue for rename
39 hg qqueue --create bar
39 hg qqueue --create bar
40 hg qqueue
40 hg qqueue
41
41
42 echo %% rename queue, same name
42 echo %% rename queue, same name
43 hg qqueue --rename bar
43 hg qqueue --rename bar
44
44
45 echo %% rename queue to existing
45 echo %% rename queue to existing
46 hg qqueue --rename foo
46 hg qqueue --rename foo
47
47
48 echo %% rename queue
48 echo %% rename queue
49 hg qqueue --rename buz
49 hg qqueue --rename buz
50 hg qqueue
50 hg qqueue
51
51
52 echo %% switch back to previous queue
52 echo %% switch back to previous queue
53 hg qqueue foo
53 hg qqueue foo
54 hg qqueue --delete buz
54 hg qqueue --delete buz
55 hg qqueue
55 hg qqueue
56
56
57 echo %% create queue for purge
58 hg qqueue --create purge-me
59 hg qqueue
60
61 echo %% create patch for purge
62 hg qnew patch-purge-me
63 ls -1d .hg/patches-purge-me 2>/dev/null || true
64 hg qpop -a
65
66 echo %% purge queue
67 hg qqueue foo
68 hg qqueue --purge purge-me
69 hg qqueue
70 ls -1d .hg/patches-purge-me 2>/dev/null || true
71
57 echo %% unapplied patches
72 echo %% unapplied patches
58 hg qun
73 hg qun
59 echo c > a
74 echo c > a
60 hg qnew -fgDU otherstuff
75 hg qnew -fgDU otherstuff
61
76
62 echo %% fail switching back
77 echo %% fail switching back
63 hg qqueue patches
78 hg qqueue patches
64
79
65 echo %% fail deleting current
80 echo %% fail deleting current
66 hg qqueue foo --delete
81 hg qqueue foo --delete
67
82
68 echo %% switch back and delete foo
83 echo %% switch back and delete foo
69 hg qpop -a
84 hg qpop -a
70 hg qqueue patches
85 hg qqueue patches
71 hg qqueue foo --delete
86 hg qqueue foo --delete
72 hg qqueue
87 hg qqueue
73
88
74 echo %% tricky cases
89 echo %% tricky cases
75 hg qqueue store --create
90 hg qqueue store --create
76 hg qnew journal
91 hg qnew journal
77 hg qqueue
92 hg qqueue
78 hg qpop -a
93 hg qpop -a
79 hg qqueue patches
94 hg qqueue patches
80 hg qun
95 hg qun
81
96
82 echo %% invalid names
97 echo %% invalid names
83 hg qqueue test/../../bar --create
98 hg qqueue test/../../bar --create
84 hg qqueue . --create
99 hg qqueue . --create
85
100
86 cd ..
101 cd ..
@@ -1,54 +1,65 b''
1 %% default queue
1 %% default queue
2 patches (active)
2 patches (active)
3 %% applied patches in default queue
3 %% applied patches in default queue
4 somestuff
4 somestuff
5 %% try to change patch (create succeeds, switch fails)
5 %% try to change patch (create succeeds, switch fails)
6 abort: patches applied - cannot set new queue active
6 abort: patches applied - cannot set new queue active
7 foo
7 foo
8 patches (active)
8 patches (active)
9 %% empty default queue
9 %% empty default queue
10 popping somestuff
10 popping somestuff
11 patch queue now empty
11 patch queue now empty
12 %% switch queue
12 %% switch queue
13 foo (active)
13 foo (active)
14 patches
14 patches
15 %% list queues, quiet
15 %% list queues, quiet
16 foo
16 foo
17 patches
17 patches
18 %% fail creating queue with already existing name
18 %% fail creating queue with already existing name
19 abort: queue "foo" already exists
19 abort: queue "foo" already exists
20 foo (active)
20 foo (active)
21 patches
21 patches
22 %% create new queue for rename
22 %% create new queue for rename
23 bar (active)
23 bar (active)
24 foo
24 foo
25 patches
25 patches
26 %% rename queue, same name
26 %% rename queue, same name
27 abort: can't rename "bar" to its current name
27 abort: can't rename "bar" to its current name
28 %% rename queue to existing
28 %% rename queue to existing
29 abort: queue "foo" already exists
29 abort: queue "foo" already exists
30 %% rename queue
30 %% rename queue
31 buz (active)
31 buz (active)
32 foo
32 foo
33 patches
33 patches
34 %% switch back to previous queue
34 %% switch back to previous queue
35 foo (active)
35 foo (active)
36 patches
36 patches
37 %% create queue for purge
38 foo
39 patches
40 purge-me (active)
41 %% create patch for purge
42 .hg/patches-purge-me
43 popping patch-purge-me
44 patch queue now empty
45 %% purge queue
46 foo (active)
47 patches
37 %% unapplied patches
48 %% unapplied patches
38 %% fail switching back
49 %% fail switching back
39 abort: patches applied - cannot set new queue active
50 abort: patches applied - cannot set new queue active
40 %% fail deleting current
51 %% fail deleting current
41 abort: cannot delete currently active queue
52 abort: cannot delete currently active queue
42 %% switch back and delete foo
53 %% switch back and delete foo
43 popping otherstuff
54 popping otherstuff
44 patch queue now empty
55 patch queue now empty
45 patches (active)
56 patches (active)
46 %% tricky cases
57 %% tricky cases
47 patches
58 patches
48 store (active)
59 store (active)
49 popping journal
60 popping journal
50 patch queue now empty
61 patch queue now empty
51 somestuff
62 somestuff
52 %% invalid names
63 %% invalid names
53 abort: invalid queue name, may not contain the characters ":\/."
64 abort: invalid queue name, may not contain the characters ":\/."
54 abort: invalid queue name, may not contain the characters ":\/."
65 abort: invalid queue name, may not contain the characters ":\/."
General Comments 0
You need to be logged in to leave comments. Login now