##// END OF EJS Templates
cmdutil: use context objects for walkchangerevs()
Dirkjan Ochtman -
r9367:1ef63045 default
parent child Browse files
Show More
@@ -1,174 +1,176 b''
1 1 # churn.py - create a graph of revisions count grouped by template
2 2 #
3 3 # Copyright 2006 Josef "Jeff" Sipek <jeffpc@josefsipek.net>
4 4 # Copyright 2008 Alexander Solovyov <piranha@piranha.org.ua>
5 5 #
6 6 # This software may be used and distributed according to the terms of the
7 7 # GNU General Public License version 2, incorporated herein by reference.
8 8
9 9 '''command to display statistics about repository history'''
10 10
11 11 from mercurial.i18n import _
12 12 from mercurial import patch, cmdutil, util, templater
13 13 import sys, os
14 14 import time, datetime
15 15
16 16 def maketemplater(ui, repo, tmpl):
17 17 tmpl = templater.parsestring(tmpl, quoted=False)
18 18 try:
19 19 t = cmdutil.changeset_templater(ui, repo, False, None, None, False)
20 20 except SyntaxError, inst:
21 21 raise util.Abort(inst.args[0])
22 22 t.use_template(tmpl)
23 23 return t
24 24
25 25 def changedlines(ui, repo, ctx1, ctx2, fns):
26 26 lines = 0
27 27 fmatch = cmdutil.matchfiles(repo, fns)
28 28 diff = ''.join(patch.diff(repo, ctx1.node(), ctx2.node(), fmatch))
29 29 for l in diff.split('\n'):
30 30 if (l.startswith("+") and not l.startswith("+++ ") or
31 31 l.startswith("-") and not l.startswith("--- ")):
32 32 lines += 1
33 33 return lines
34 34
35 35 def countrate(ui, repo, amap, *pats, **opts):
36 36 """Calculate stats"""
37 37 if opts.get('dateformat'):
38 38 def getkey(ctx):
39 39 t, tz = ctx.date()
40 40 date = datetime.datetime(*time.gmtime(float(t) - tz)[:6])
41 41 return date.strftime(opts['dateformat'])
42 42 else:
43 43 tmpl = opts.get('template', '{author|email}')
44 44 tmpl = maketemplater(ui, repo, tmpl)
45 45 def getkey(ctx):
46 46 ui.pushbuffer()
47 47 tmpl.show(ctx)
48 48 return ui.popbuffer()
49 49
50 50 count = pct = 0
51 51 rate = {}
52 52 df = False
53 53 if opts.get('date'):
54 54 df = util.matchdate(opts['date'])
55 55
56 get = util.cachefunc(lambda r: repo[r].changeset())
56 get = util.cachefunc(lambda r: repo[r])
57 57 changeiter, matchfn = cmdutil.walkchangerevs(ui, repo, pats, get, opts)
58 58 for st, rev, fns in changeiter:
59
59 60 if not st == 'add':
60 61 continue
61 if df and not df(get(rev)[2][0]): # doesn't match date format
62
63 ctx = get(rev)
64 if df and not df(ctx.date()[0]): # doesn't match date format
62 65 continue
63 66
64 ctx = repo[rev]
65 67 key = getkey(ctx)
66 68 key = amap.get(key, key) # alias remap
67 69 if opts.get('changesets'):
68 70 rate[key] = rate.get(key, 0) + 1
69 71 else:
70 72 parents = ctx.parents()
71 73 if len(parents) > 1:
72 74 ui.note(_('Revision %d is a merge, ignoring...\n') % (rev,))
73 75 continue
74 76
75 77 ctx1 = parents[0]
76 78 lines = changedlines(ui, repo, ctx1, ctx, fns)
77 79 rate[key] = rate.get(key, 0) + lines
78 80
79 81 if opts.get('progress'):
80 82 count += 1
81 83 newpct = int(100.0 * count / max(len(repo), 1))
82 84 if pct < newpct:
83 85 pct = newpct
84 86 ui.write("\r" + _("generating stats: %d%%") % pct)
85 87 sys.stdout.flush()
86 88
87 89 if opts.get('progress'):
88 90 ui.write("\r")
89 91 sys.stdout.flush()
90 92
91 93 return rate
92 94
93 95
94 96 def churn(ui, repo, *pats, **opts):
95 97 '''histogram of changes to the repository
96 98
97 99 This command will display a histogram representing the number
98 100 of changed lines or revisions, grouped according to the given
99 101 template. The default template will group changes by author.
100 102 The --dateformat option may be used to group the results by
101 103 date instead.
102 104
103 105 Statistics are based on the number of changed lines, or
104 106 alternatively the number of matching revisions if the
105 107 --changesets option is specified.
106 108
107 109 Examples::
108 110
109 111 # display count of changed lines for every committer
110 112 hg churn -t '{author|email}'
111 113
112 114 # display daily activity graph
113 115 hg churn -f '%H' -s -c
114 116
115 117 # display activity of developers by month
116 118 hg churn -f '%Y-%m' -s -c
117 119
118 120 # display count of lines changed in every year
119 121 hg churn -f '%Y' -s
120 122
121 123 It is possible to map alternate email addresses to a main address
122 124 by providing a file using the following format::
123 125
124 126 <alias email> <actual email>
125 127
126 128 Such a file may be specified with the --aliases option, otherwise
127 129 a .hgchurn file will be looked for in the working directory root.
128 130 '''
129 131 def pad(s, l):
130 132 return (s + " " * l)[:l]
131 133
132 134 amap = {}
133 135 aliases = opts.get('aliases')
134 136 if not aliases and os.path.exists(repo.wjoin('.hgchurn')):
135 137 aliases = repo.wjoin('.hgchurn')
136 138 if aliases:
137 139 for l in open(aliases, "r"):
138 140 l = l.strip()
139 141 alias, actual = l.split()
140 142 amap[alias] = actual
141 143
142 144 rate = countrate(ui, repo, amap, *pats, **opts).items()
143 145 if not rate:
144 146 return
145 147
146 148 sortkey = ((not opts.get('sort')) and (lambda x: -x[1]) or None)
147 149 rate.sort(key=sortkey)
148 150
149 151 maxcount = float(max([v for k, v in rate]))
150 152 maxname = max([len(k) for k, v in rate])
151 153
152 154 ttywidth = util.termwidth()
153 155 ui.debug(_("assuming %i character terminal\n") % ttywidth)
154 156 width = ttywidth - maxname - 2 - 6 - 2 - 2
155 157
156 158 for date, count in rate:
157 159 print "%s %6d %s" % (pad(date, maxname), count,
158 160 "*" * int(count * width / maxcount))
159 161
160 162
161 163 cmdtable = {
162 164 "churn":
163 165 (churn,
164 166 [('r', 'rev', [], _('count rate for the specified revision or range')),
165 167 ('d', 'date', '', _('count rate for revisions matching date spec')),
166 168 ('t', 'template', '{author|email}', _('template to group changesets')),
167 169 ('f', 'dateformat', '',
168 170 _('strftime-compatible format for grouping by date')),
169 171 ('c', 'changesets', False, _('count rate by number of changesets')),
170 172 ('s', 'sort', False, _('sort by key (default: sort by count)')),
171 173 ('', 'aliases', '', _('file with email aliases')),
172 174 ('', 'progress', None, _('show progress'))],
173 175 _("hg churn [-d DATE] [-r REV] [--aliases FILE] [--progress] [FILE]")),
174 176 }
@@ -1,1254 +1,1254 b''
1 1 # cmdutil.py - help for command processing in mercurial
2 2 #
3 3 # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
4 4 #
5 5 # This software may be used and distributed according to the terms of the
6 6 # GNU General Public License version 2, incorporated herein by reference.
7 7
8 8 from node import hex, nullid, nullrev, short
9 9 from i18n import _
10 10 import os, sys, errno, re, glob
11 11 import mdiff, bdiff, util, templater, patch, error, encoding
12 12 import match as _match
13 13
14 14 revrangesep = ':'
15 15
16 16 def findpossible(cmd, table, strict=False):
17 17 """
18 18 Return cmd -> (aliases, command table entry)
19 19 for each matching command.
20 20 Return debug commands (or their aliases) only if no normal command matches.
21 21 """
22 22 choice = {}
23 23 debugchoice = {}
24 24 for e in table.keys():
25 25 aliases = e.lstrip("^").split("|")
26 26 found = None
27 27 if cmd in aliases:
28 28 found = cmd
29 29 elif not strict:
30 30 for a in aliases:
31 31 if a.startswith(cmd):
32 32 found = a
33 33 break
34 34 if found is not None:
35 35 if aliases[0].startswith("debug") or found.startswith("debug"):
36 36 debugchoice[found] = (aliases, table[e])
37 37 else:
38 38 choice[found] = (aliases, table[e])
39 39
40 40 if not choice and debugchoice:
41 41 choice = debugchoice
42 42
43 43 return choice
44 44
45 45 def findcmd(cmd, table, strict=True):
46 46 """Return (aliases, command table entry) for command string."""
47 47 choice = findpossible(cmd, table, strict)
48 48
49 49 if cmd in choice:
50 50 return choice[cmd]
51 51
52 52 if len(choice) > 1:
53 53 clist = choice.keys()
54 54 clist.sort()
55 55 raise error.AmbiguousCommand(cmd, clist)
56 56
57 57 if choice:
58 58 return choice.values()[0]
59 59
60 60 raise error.UnknownCommand(cmd)
61 61
62 62 def bail_if_changed(repo):
63 63 if repo.dirstate.parents()[1] != nullid:
64 64 raise util.Abort(_('outstanding uncommitted merge'))
65 65 modified, added, removed, deleted = repo.status()[:4]
66 66 if modified or added or removed or deleted:
67 67 raise util.Abort(_("outstanding uncommitted changes"))
68 68
69 69 def logmessage(opts):
70 70 """ get the log message according to -m and -l option """
71 71 message = opts.get('message')
72 72 logfile = opts.get('logfile')
73 73
74 74 if message and logfile:
75 75 raise util.Abort(_('options --message and --logfile are mutually '
76 76 'exclusive'))
77 77 if not message and logfile:
78 78 try:
79 79 if logfile == '-':
80 80 message = sys.stdin.read()
81 81 else:
82 82 message = open(logfile).read()
83 83 except IOError, inst:
84 84 raise util.Abort(_("can't read commit message '%s': %s") %
85 85 (logfile, inst.strerror))
86 86 return message
87 87
88 88 def loglimit(opts):
89 89 """get the log limit according to option -l/--limit"""
90 90 limit = opts.get('limit')
91 91 if limit:
92 92 try:
93 93 limit = int(limit)
94 94 except ValueError:
95 95 raise util.Abort(_('limit must be a positive integer'))
96 96 if limit <= 0: raise util.Abort(_('limit must be positive'))
97 97 else:
98 98 limit = sys.maxint
99 99 return limit
100 100
101 101 def remoteui(src, opts):
102 102 'build a remote ui from ui or repo and opts'
103 103 if hasattr(src, 'baseui'): # looks like a repository
104 104 dst = src.baseui.copy() # drop repo-specific config
105 105 src = src.ui # copy target options from repo
106 106 else: # assume it's a global ui object
107 107 dst = src.copy() # keep all global options
108 108
109 109 # copy ssh-specific options
110 110 for o in 'ssh', 'remotecmd':
111 111 v = opts.get(o) or src.config('ui', o)
112 112 if v:
113 113 dst.setconfig("ui", o, v)
114 114 # copy bundle-specific options
115 115 r = src.config('bundle', 'mainreporoot')
116 116 if r:
117 117 dst.setconfig('bundle', 'mainreporoot', r)
118 118
119 119 return dst
120 120
121 121 def revpair(repo, revs):
122 122 '''return pair of nodes, given list of revisions. second item can
123 123 be None, meaning use working dir.'''
124 124
125 125 def revfix(repo, val, defval):
126 126 if not val and val != 0 and defval is not None:
127 127 val = defval
128 128 return repo.lookup(val)
129 129
130 130 if not revs:
131 131 return repo.dirstate.parents()[0], None
132 132 end = None
133 133 if len(revs) == 1:
134 134 if revrangesep in revs[0]:
135 135 start, end = revs[0].split(revrangesep, 1)
136 136 start = revfix(repo, start, 0)
137 137 end = revfix(repo, end, len(repo) - 1)
138 138 else:
139 139 start = revfix(repo, revs[0], None)
140 140 elif len(revs) == 2:
141 141 if revrangesep in revs[0] or revrangesep in revs[1]:
142 142 raise util.Abort(_('too many revisions specified'))
143 143 start = revfix(repo, revs[0], None)
144 144 end = revfix(repo, revs[1], None)
145 145 else:
146 146 raise util.Abort(_('too many revisions specified'))
147 147 return start, end
148 148
149 149 def revrange(repo, revs):
150 150 """Yield revision as strings from a list of revision specifications."""
151 151
152 152 def revfix(repo, val, defval):
153 153 if not val and val != 0 and defval is not None:
154 154 return defval
155 155 return repo.changelog.rev(repo.lookup(val))
156 156
157 157 seen, l = set(), []
158 158 for spec in revs:
159 159 if revrangesep in spec:
160 160 start, end = spec.split(revrangesep, 1)
161 161 start = revfix(repo, start, 0)
162 162 end = revfix(repo, end, len(repo) - 1)
163 163 step = start > end and -1 or 1
164 164 for rev in xrange(start, end+step, step):
165 165 if rev in seen:
166 166 continue
167 167 seen.add(rev)
168 168 l.append(rev)
169 169 else:
170 170 rev = revfix(repo, spec, None)
171 171 if rev in seen:
172 172 continue
173 173 seen.add(rev)
174 174 l.append(rev)
175 175
176 176 return l
177 177
178 178 def make_filename(repo, pat, node,
179 179 total=None, seqno=None, revwidth=None, pathname=None):
180 180 node_expander = {
181 181 'H': lambda: hex(node),
182 182 'R': lambda: str(repo.changelog.rev(node)),
183 183 'h': lambda: short(node),
184 184 }
185 185 expander = {
186 186 '%': lambda: '%',
187 187 'b': lambda: os.path.basename(repo.root),
188 188 }
189 189
190 190 try:
191 191 if node:
192 192 expander.update(node_expander)
193 193 if node:
194 194 expander['r'] = (lambda:
195 195 str(repo.changelog.rev(node)).zfill(revwidth or 0))
196 196 if total is not None:
197 197 expander['N'] = lambda: str(total)
198 198 if seqno is not None:
199 199 expander['n'] = lambda: str(seqno)
200 200 if total is not None and seqno is not None:
201 201 expander['n'] = lambda: str(seqno).zfill(len(str(total)))
202 202 if pathname is not None:
203 203 expander['s'] = lambda: os.path.basename(pathname)
204 204 expander['d'] = lambda: os.path.dirname(pathname) or '.'
205 205 expander['p'] = lambda: pathname
206 206
207 207 newname = []
208 208 patlen = len(pat)
209 209 i = 0
210 210 while i < patlen:
211 211 c = pat[i]
212 212 if c == '%':
213 213 i += 1
214 214 c = pat[i]
215 215 c = expander[c]()
216 216 newname.append(c)
217 217 i += 1
218 218 return ''.join(newname)
219 219 except KeyError, inst:
220 220 raise util.Abort(_("invalid format spec '%%%s' in output filename") %
221 221 inst.args[0])
222 222
223 223 def make_file(repo, pat, node=None,
224 224 total=None, seqno=None, revwidth=None, mode='wb', pathname=None):
225 225
226 226 writable = 'w' in mode or 'a' in mode
227 227
228 228 if not pat or pat == '-':
229 229 return writable and sys.stdout or sys.stdin
230 230 if hasattr(pat, 'write') and writable:
231 231 return pat
232 232 if hasattr(pat, 'read') and 'r' in mode:
233 233 return pat
234 234 return open(make_filename(repo, pat, node, total, seqno, revwidth,
235 235 pathname),
236 236 mode)
237 237
238 238 def expandpats(pats):
239 239 if not util.expandglobs:
240 240 return list(pats)
241 241 ret = []
242 242 for p in pats:
243 243 kind, name = _match._patsplit(p, None)
244 244 if kind is None:
245 245 try:
246 246 globbed = glob.glob(name)
247 247 except re.error:
248 248 globbed = [name]
249 249 if globbed:
250 250 ret.extend(globbed)
251 251 continue
252 252 ret.append(p)
253 253 return ret
254 254
255 255 def match(repo, pats=[], opts={}, globbed=False, default='relpath'):
256 256 if not globbed and default == 'relpath':
257 257 pats = expandpats(pats or [])
258 258 m = _match.match(repo.root, repo.getcwd(), pats,
259 259 opts.get('include'), opts.get('exclude'), default)
260 260 def badfn(f, msg):
261 261 repo.ui.warn("%s: %s\n" % (m.rel(f), msg))
262 262 m.bad = badfn
263 263 return m
264 264
265 265 def matchall(repo):
266 266 return _match.always(repo.root, repo.getcwd())
267 267
268 268 def matchfiles(repo, files):
269 269 return _match.exact(repo.root, repo.getcwd(), files)
270 270
271 271 def findrenames(repo, added, removed, threshold):
272 272 '''find renamed files -- yields (before, after, score) tuples'''
273 273 ctx = repo['.']
274 274 for a in added:
275 275 aa = repo.wread(a)
276 276 bestname, bestscore = None, threshold
277 277 for r in removed:
278 278 if r not in ctx:
279 279 continue
280 280 rr = ctx.filectx(r).data()
281 281
282 282 # bdiff.blocks() returns blocks of matching lines
283 283 # count the number of bytes in each
284 284 equal = 0
285 285 alines = mdiff.splitnewlines(aa)
286 286 matches = bdiff.blocks(aa, rr)
287 287 for x1,x2,y1,y2 in matches:
288 288 for line in alines[x1:x2]:
289 289 equal += len(line)
290 290
291 291 lengths = len(aa) + len(rr)
292 292 if lengths:
293 293 myscore = equal*2.0 / lengths
294 294 if myscore >= bestscore:
295 295 bestname, bestscore = r, myscore
296 296 if bestname:
297 297 yield bestname, a, bestscore
298 298
299 299 def addremove(repo, pats=[], opts={}, dry_run=None, similarity=None):
300 300 if dry_run is None:
301 301 dry_run = opts.get('dry_run')
302 302 if similarity is None:
303 303 similarity = float(opts.get('similarity') or 0)
304 304 # we'd use status here, except handling of symlinks and ignore is tricky
305 305 added, unknown, deleted, removed = [], [], [], []
306 306 audit_path = util.path_auditor(repo.root)
307 307 m = match(repo, pats, opts)
308 308 for abs in repo.walk(m):
309 309 target = repo.wjoin(abs)
310 310 good = True
311 311 try:
312 312 audit_path(abs)
313 313 except:
314 314 good = False
315 315 rel = m.rel(abs)
316 316 exact = m.exact(abs)
317 317 if good and abs not in repo.dirstate:
318 318 unknown.append(abs)
319 319 if repo.ui.verbose or not exact:
320 320 repo.ui.status(_('adding %s\n') % ((pats and rel) or abs))
321 321 elif repo.dirstate[abs] != 'r' and (not good or not util.lexists(target)
322 322 or (os.path.isdir(target) and not os.path.islink(target))):
323 323 deleted.append(abs)
324 324 if repo.ui.verbose or not exact:
325 325 repo.ui.status(_('removing %s\n') % ((pats and rel) or abs))
326 326 # for finding renames
327 327 elif repo.dirstate[abs] == 'r':
328 328 removed.append(abs)
329 329 elif repo.dirstate[abs] == 'a':
330 330 added.append(abs)
331 331 if not dry_run:
332 332 repo.remove(deleted)
333 333 repo.add(unknown)
334 334 if similarity > 0:
335 335 for old, new, score in findrenames(repo, added + unknown,
336 336 removed + deleted, similarity):
337 337 if repo.ui.verbose or not m.exact(old) or not m.exact(new):
338 338 repo.ui.status(_('recording removal of %s as rename to %s '
339 339 '(%d%% similar)\n') %
340 340 (m.rel(old), m.rel(new), score * 100))
341 341 if not dry_run:
342 342 repo.copy(old, new)
343 343
344 344 def copy(ui, repo, pats, opts, rename=False):
345 345 # called with the repo lock held
346 346 #
347 347 # hgsep => pathname that uses "/" to separate directories
348 348 # ossep => pathname that uses os.sep to separate directories
349 349 cwd = repo.getcwd()
350 350 targets = {}
351 351 after = opts.get("after")
352 352 dryrun = opts.get("dry_run")
353 353
354 354 def walkpat(pat):
355 355 srcs = []
356 356 m = match(repo, [pat], opts, globbed=True)
357 357 for abs in repo.walk(m):
358 358 state = repo.dirstate[abs]
359 359 rel = m.rel(abs)
360 360 exact = m.exact(abs)
361 361 if state in '?r':
362 362 if exact and state == '?':
363 363 ui.warn(_('%s: not copying - file is not managed\n') % rel)
364 364 if exact and state == 'r':
365 365 ui.warn(_('%s: not copying - file has been marked for'
366 366 ' remove\n') % rel)
367 367 continue
368 368 # abs: hgsep
369 369 # rel: ossep
370 370 srcs.append((abs, rel, exact))
371 371 return srcs
372 372
373 373 # abssrc: hgsep
374 374 # relsrc: ossep
375 375 # otarget: ossep
376 376 def copyfile(abssrc, relsrc, otarget, exact):
377 377 abstarget = util.canonpath(repo.root, cwd, otarget)
378 378 reltarget = repo.pathto(abstarget, cwd)
379 379 target = repo.wjoin(abstarget)
380 380 src = repo.wjoin(abssrc)
381 381 state = repo.dirstate[abstarget]
382 382
383 383 # check for collisions
384 384 prevsrc = targets.get(abstarget)
385 385 if prevsrc is not None:
386 386 ui.warn(_('%s: not overwriting - %s collides with %s\n') %
387 387 (reltarget, repo.pathto(abssrc, cwd),
388 388 repo.pathto(prevsrc, cwd)))
389 389 return
390 390
391 391 # check for overwrites
392 392 exists = os.path.exists(target)
393 393 if not after and exists or after and state in 'mn':
394 394 if not opts['force']:
395 395 ui.warn(_('%s: not overwriting - file exists\n') %
396 396 reltarget)
397 397 return
398 398
399 399 if after:
400 400 if not exists:
401 401 return
402 402 elif not dryrun:
403 403 try:
404 404 if exists:
405 405 os.unlink(target)
406 406 targetdir = os.path.dirname(target) or '.'
407 407 if not os.path.isdir(targetdir):
408 408 os.makedirs(targetdir)
409 409 util.copyfile(src, target)
410 410 except IOError, inst:
411 411 if inst.errno == errno.ENOENT:
412 412 ui.warn(_('%s: deleted in working copy\n') % relsrc)
413 413 else:
414 414 ui.warn(_('%s: cannot copy - %s\n') %
415 415 (relsrc, inst.strerror))
416 416 return True # report a failure
417 417
418 418 if ui.verbose or not exact:
419 419 if rename:
420 420 ui.status(_('moving %s to %s\n') % (relsrc, reltarget))
421 421 else:
422 422 ui.status(_('copying %s to %s\n') % (relsrc, reltarget))
423 423
424 424 targets[abstarget] = abssrc
425 425
426 426 # fix up dirstate
427 427 origsrc = repo.dirstate.copied(abssrc) or abssrc
428 428 if abstarget == origsrc: # copying back a copy?
429 429 if state not in 'mn' and not dryrun:
430 430 repo.dirstate.normallookup(abstarget)
431 431 else:
432 432 if repo.dirstate[origsrc] == 'a' and origsrc == abssrc:
433 433 if not ui.quiet:
434 434 ui.warn(_("%s has not been committed yet, so no copy "
435 435 "data will be stored for %s.\n")
436 436 % (repo.pathto(origsrc, cwd), reltarget))
437 437 if repo.dirstate[abstarget] in '?r' and not dryrun:
438 438 repo.add([abstarget])
439 439 elif not dryrun:
440 440 repo.copy(origsrc, abstarget)
441 441
442 442 if rename and not dryrun:
443 443 repo.remove([abssrc], not after)
444 444
445 445 # pat: ossep
446 446 # dest ossep
447 447 # srcs: list of (hgsep, hgsep, ossep, bool)
448 448 # return: function that takes hgsep and returns ossep
449 449 def targetpathfn(pat, dest, srcs):
450 450 if os.path.isdir(pat):
451 451 abspfx = util.canonpath(repo.root, cwd, pat)
452 452 abspfx = util.localpath(abspfx)
453 453 if destdirexists:
454 454 striplen = len(os.path.split(abspfx)[0])
455 455 else:
456 456 striplen = len(abspfx)
457 457 if striplen:
458 458 striplen += len(os.sep)
459 459 res = lambda p: os.path.join(dest, util.localpath(p)[striplen:])
460 460 elif destdirexists:
461 461 res = lambda p: os.path.join(dest,
462 462 os.path.basename(util.localpath(p)))
463 463 else:
464 464 res = lambda p: dest
465 465 return res
466 466
467 467 # pat: ossep
468 468 # dest ossep
469 469 # srcs: list of (hgsep, hgsep, ossep, bool)
470 470 # return: function that takes hgsep and returns ossep
471 471 def targetpathafterfn(pat, dest, srcs):
472 472 if _match.patkind(pat):
473 473 # a mercurial pattern
474 474 res = lambda p: os.path.join(dest,
475 475 os.path.basename(util.localpath(p)))
476 476 else:
477 477 abspfx = util.canonpath(repo.root, cwd, pat)
478 478 if len(abspfx) < len(srcs[0][0]):
479 479 # A directory. Either the target path contains the last
480 480 # component of the source path or it does not.
481 481 def evalpath(striplen):
482 482 score = 0
483 483 for s in srcs:
484 484 t = os.path.join(dest, util.localpath(s[0])[striplen:])
485 485 if os.path.exists(t):
486 486 score += 1
487 487 return score
488 488
489 489 abspfx = util.localpath(abspfx)
490 490 striplen = len(abspfx)
491 491 if striplen:
492 492 striplen += len(os.sep)
493 493 if os.path.isdir(os.path.join(dest, os.path.split(abspfx)[1])):
494 494 score = evalpath(striplen)
495 495 striplen1 = len(os.path.split(abspfx)[0])
496 496 if striplen1:
497 497 striplen1 += len(os.sep)
498 498 if evalpath(striplen1) > score:
499 499 striplen = striplen1
500 500 res = lambda p: os.path.join(dest,
501 501 util.localpath(p)[striplen:])
502 502 else:
503 503 # a file
504 504 if destdirexists:
505 505 res = lambda p: os.path.join(dest,
506 506 os.path.basename(util.localpath(p)))
507 507 else:
508 508 res = lambda p: dest
509 509 return res
510 510
511 511
512 512 pats = expandpats(pats)
513 513 if not pats:
514 514 raise util.Abort(_('no source or destination specified'))
515 515 if len(pats) == 1:
516 516 raise util.Abort(_('no destination specified'))
517 517 dest = pats.pop()
518 518 destdirexists = os.path.isdir(dest) and not os.path.islink(dest)
519 519 if not destdirexists:
520 520 if len(pats) > 1 or _match.patkind(pats[0]):
521 521 raise util.Abort(_('with multiple sources, destination must be an '
522 522 'existing directory'))
523 523 if util.endswithsep(dest):
524 524 raise util.Abort(_('destination %s is not a directory') % dest)
525 525
526 526 tfn = targetpathfn
527 527 if after:
528 528 tfn = targetpathafterfn
529 529 copylist = []
530 530 for pat in pats:
531 531 srcs = walkpat(pat)
532 532 if not srcs:
533 533 continue
534 534 copylist.append((tfn(pat, dest, srcs), srcs))
535 535 if not copylist:
536 536 raise util.Abort(_('no files to copy'))
537 537
538 538 errors = 0
539 539 for targetpath, srcs in copylist:
540 540 for abssrc, relsrc, exact in srcs:
541 541 if copyfile(abssrc, relsrc, targetpath(abssrc), exact):
542 542 errors += 1
543 543
544 544 if errors:
545 545 ui.warn(_('(consider using --after)\n'))
546 546
547 547 return errors
548 548
549 549 def service(opts, parentfn=None, initfn=None, runfn=None, logfile=None):
550 550 '''Run a command as a service.'''
551 551
552 552 if opts['daemon'] and not opts['daemon_pipefds']:
553 553 rfd, wfd = os.pipe()
554 554 args = sys.argv[:]
555 555 args.append('--daemon-pipefds=%d,%d' % (rfd, wfd))
556 556 # Don't pass --cwd to the child process, because we've already
557 557 # changed directory.
558 558 for i in xrange(1,len(args)):
559 559 if args[i].startswith('--cwd='):
560 560 del args[i]
561 561 break
562 562 elif args[i].startswith('--cwd'):
563 563 del args[i:i+2]
564 564 break
565 565 pid = os.spawnvp(os.P_NOWAIT | getattr(os, 'P_DETACH', 0),
566 566 args[0], args)
567 567 os.close(wfd)
568 568 os.read(rfd, 1)
569 569 if parentfn:
570 570 return parentfn(pid)
571 571 else:
572 572 os._exit(0)
573 573
574 574 if initfn:
575 575 initfn()
576 576
577 577 if opts['pid_file']:
578 578 fp = open(opts['pid_file'], 'w')
579 579 fp.write(str(os.getpid()) + '\n')
580 580 fp.close()
581 581
582 582 if opts['daemon_pipefds']:
583 583 rfd, wfd = [int(x) for x in opts['daemon_pipefds'].split(',')]
584 584 os.close(rfd)
585 585 try:
586 586 os.setsid()
587 587 except AttributeError:
588 588 pass
589 589 os.write(wfd, 'y')
590 590 os.close(wfd)
591 591 sys.stdout.flush()
592 592 sys.stderr.flush()
593 593
594 594 nullfd = os.open(util.nulldev, os.O_RDWR)
595 595 logfilefd = nullfd
596 596 if logfile:
597 597 logfilefd = os.open(logfile, os.O_RDWR | os.O_CREAT | os.O_APPEND)
598 598 os.dup2(nullfd, 0)
599 599 os.dup2(logfilefd, 1)
600 600 os.dup2(logfilefd, 2)
601 601 if nullfd not in (0, 1, 2):
602 602 os.close(nullfd)
603 603 if logfile and logfilefd not in (0, 1, 2):
604 604 os.close(logfilefd)
605 605
606 606 if runfn:
607 607 return runfn()
608 608
609 609 class changeset_printer(object):
610 610 '''show changeset information when templating not requested.'''
611 611
612 612 def __init__(self, ui, repo, patch, diffopts, buffered):
613 613 self.ui = ui
614 614 self.repo = repo
615 615 self.buffered = buffered
616 616 self.patch = patch
617 617 self.diffopts = diffopts
618 618 self.header = {}
619 619 self.hunk = {}
620 620 self.lastheader = None
621 621
622 622 def flush(self, rev):
623 623 if rev in self.header:
624 624 h = self.header[rev]
625 625 if h != self.lastheader:
626 626 self.lastheader = h
627 627 self.ui.write(h)
628 628 del self.header[rev]
629 629 if rev in self.hunk:
630 630 self.ui.write(self.hunk[rev])
631 631 del self.hunk[rev]
632 632 return 1
633 633 return 0
634 634
635 635 def show(self, ctx, copies=(), **props):
636 636 if self.buffered:
637 637 self.ui.pushbuffer()
638 638 self._show(ctx, copies, props)
639 639 self.hunk[ctx.rev()] = self.ui.popbuffer()
640 640 else:
641 641 self._show(ctx, copies, props)
642 642
643 643 def _show(self, ctx, copies, props):
644 644 '''show a single changeset or file revision'''
645 645 changenode = ctx.node()
646 646 rev = ctx.rev()
647 647
648 648 if self.ui.quiet:
649 649 self.ui.write("%d:%s\n" % (rev, short(changenode)))
650 650 return
651 651
652 652 log = self.repo.changelog
653 653 changes = log.read(changenode)
654 654 date = util.datestr(changes[2])
655 655 extra = changes[5]
656 656 branch = extra.get("branch")
657 657
658 658 hexfunc = self.ui.debugflag and hex or short
659 659
660 660 parents = [(p, hexfunc(log.node(p)))
661 661 for p in self._meaningful_parentrevs(log, rev)]
662 662
663 663 self.ui.write(_("changeset: %d:%s\n") % (rev, hexfunc(changenode)))
664 664
665 665 # don't show the default branch name
666 666 if branch != 'default':
667 667 branch = encoding.tolocal(branch)
668 668 self.ui.write(_("branch: %s\n") % branch)
669 669 for tag in self.repo.nodetags(changenode):
670 670 self.ui.write(_("tag: %s\n") % tag)
671 671 for parent in parents:
672 672 self.ui.write(_("parent: %d:%s\n") % parent)
673 673
674 674 if self.ui.debugflag:
675 675 self.ui.write(_("manifest: %d:%s\n") %
676 676 (self.repo.manifest.rev(changes[0]), hex(changes[0])))
677 677 self.ui.write(_("user: %s\n") % changes[1])
678 678 self.ui.write(_("date: %s\n") % date)
679 679
680 680 if self.ui.debugflag:
681 681 files = self.repo.status(log.parents(changenode)[0], changenode)[:3]
682 682 for key, value in zip([_("files:"), _("files+:"), _("files-:")],
683 683 files):
684 684 if value:
685 685 self.ui.write("%-12s %s\n" % (key, " ".join(value)))
686 686 elif changes[3] and self.ui.verbose:
687 687 self.ui.write(_("files: %s\n") % " ".join(changes[3]))
688 688 if copies and self.ui.verbose:
689 689 copies = ['%s (%s)' % c for c in copies]
690 690 self.ui.write(_("copies: %s\n") % ' '.join(copies))
691 691
692 692 if extra and self.ui.debugflag:
693 693 for key, value in sorted(extra.items()):
694 694 self.ui.write(_("extra: %s=%s\n")
695 695 % (key, value.encode('string_escape')))
696 696
697 697 description = changes[4].strip()
698 698 if description:
699 699 if self.ui.verbose:
700 700 self.ui.write(_("description:\n"))
701 701 self.ui.write(description)
702 702 self.ui.write("\n\n")
703 703 else:
704 704 self.ui.write(_("summary: %s\n") %
705 705 description.splitlines()[0])
706 706 self.ui.write("\n")
707 707
708 708 self.showpatch(changenode)
709 709
710 710 def showpatch(self, node):
711 711 if self.patch:
712 712 prev = self.repo.changelog.parents(node)[0]
713 713 chunks = patch.diff(self.repo, prev, node, match=self.patch,
714 714 opts=patch.diffopts(self.ui, self.diffopts))
715 715 for chunk in chunks:
716 716 self.ui.write(chunk)
717 717 self.ui.write("\n")
718 718
719 719 def _meaningful_parentrevs(self, log, rev):
720 720 """Return list of meaningful (or all if debug) parentrevs for rev.
721 721
722 722 For merges (two non-nullrev revisions) both parents are meaningful.
723 723 Otherwise the first parent revision is considered meaningful if it
724 724 is not the preceding revision.
725 725 """
726 726 parents = log.parentrevs(rev)
727 727 if not self.ui.debugflag and parents[1] == nullrev:
728 728 if parents[0] >= rev - 1:
729 729 parents = []
730 730 else:
731 731 parents = [parents[0]]
732 732 return parents
733 733
734 734
735 735 class changeset_templater(changeset_printer):
736 736 '''format changeset information.'''
737 737
738 738 def __init__(self, ui, repo, patch, diffopts, mapfile, buffered):
739 739 changeset_printer.__init__(self, ui, repo, patch, diffopts, buffered)
740 740 formatnode = ui.debugflag and (lambda x: x) or (lambda x: x[:12])
741 741 self.t = templater.templater(mapfile, {'formatnode': formatnode},
742 742 cache={
743 743 'parent': '{rev}:{node|formatnode} ',
744 744 'manifest': '{rev}:{node|formatnode}',
745 745 'filecopy': '{name} ({source})'})
746 746
747 747 def use_template(self, t):
748 748 '''set template string to use'''
749 749 self.t.cache['changeset'] = t
750 750
751 751 def _meaningful_parentrevs(self, ctx):
752 752 """Return list of meaningful (or all if debug) parentrevs for rev.
753 753 """
754 754 parents = ctx.parents()
755 755 if len(parents) > 1:
756 756 return parents
757 757 if self.ui.debugflag:
758 758 return [parents[0], self.repo['null']]
759 759 if parents[0].rev() >= ctx.rev() - 1:
760 760 return []
761 761 return parents
762 762
763 763 def _show(self, ctx, copies, props):
764 764 '''show a single changeset or file revision'''
765 765
766 766 def showlist(name, values, plural=None, **args):
767 767 '''expand set of values.
768 768 name is name of key in template map.
769 769 values is list of strings or dicts.
770 770 plural is plural of name, if not simply name + 's'.
771 771
772 772 expansion works like this, given name 'foo'.
773 773
774 774 if values is empty, expand 'no_foos'.
775 775
776 776 if 'foo' not in template map, return values as a string,
777 777 joined by space.
778 778
779 779 expand 'start_foos'.
780 780
781 781 for each value, expand 'foo'. if 'last_foo' in template
782 782 map, expand it instead of 'foo' for last key.
783 783
784 784 expand 'end_foos'.
785 785 '''
786 786 if plural: names = plural
787 787 else: names = name + 's'
788 788 if not values:
789 789 noname = 'no_' + names
790 790 if noname in self.t:
791 791 yield self.t(noname, **args)
792 792 return
793 793 if name not in self.t:
794 794 if isinstance(values[0], str):
795 795 yield ' '.join(values)
796 796 else:
797 797 for v in values:
798 798 yield dict(v, **args)
799 799 return
800 800 startname = 'start_' + names
801 801 if startname in self.t:
802 802 yield self.t(startname, **args)
803 803 vargs = args.copy()
804 804 def one(v, tag=name):
805 805 try:
806 806 vargs.update(v)
807 807 except (AttributeError, ValueError):
808 808 try:
809 809 for a, b in v:
810 810 vargs[a] = b
811 811 except ValueError:
812 812 vargs[name] = v
813 813 return self.t(tag, **vargs)
814 814 lastname = 'last_' + name
815 815 if lastname in self.t:
816 816 last = values.pop()
817 817 else:
818 818 last = None
819 819 for v in values:
820 820 yield one(v)
821 821 if last is not None:
822 822 yield one(last, tag=lastname)
823 823 endname = 'end_' + names
824 824 if endname in self.t:
825 825 yield self.t(endname, **args)
826 826
827 827 def showbranches(**args):
828 828 branch = ctx.branch()
829 829 if branch != 'default':
830 830 branch = encoding.tolocal(branch)
831 831 return showlist('branch', [branch], plural='branches', **args)
832 832
833 833 def showparents(**args):
834 834 parents = [[('rev', p.rev()), ('node', p.hex())]
835 835 for p in self._meaningful_parentrevs(ctx)]
836 836 return showlist('parent', parents, **args)
837 837
838 838 def showtags(**args):
839 839 return showlist('tag', ctx.tags(), **args)
840 840
841 841 def showextras(**args):
842 842 for key, value in sorted(ctx.extra().items()):
843 843 args = args.copy()
844 844 args.update(dict(key=key, value=value))
845 845 yield self.t('extra', **args)
846 846
847 847 def showcopies(**args):
848 848 c = [{'name': x[0], 'source': x[1]} for x in copies]
849 849 return showlist('file_copy', c, plural='file_copies', **args)
850 850
851 851 files = []
852 852 def getfiles():
853 853 if not files:
854 854 files[:] = self.repo.status(ctx.parents()[0].node(),
855 855 ctx.node())[:3]
856 856 return files
857 857 def showfiles(**args):
858 858 return showlist('file', ctx.files(), **args)
859 859 def showmods(**args):
860 860 return showlist('file_mod', getfiles()[0], **args)
861 861 def showadds(**args):
862 862 return showlist('file_add', getfiles()[1], **args)
863 863 def showdels(**args):
864 864 return showlist('file_del', getfiles()[2], **args)
865 865 def showmanifest(**args):
866 866 args = args.copy()
867 867 args.update(dict(rev=self.repo.manifest.rev(ctx.changeset()[0]),
868 868 node=hex(ctx.changeset()[0])))
869 869 return self.t('manifest', **args)
870 870
871 871 def showdiffstat(**args):
872 872 diff = patch.diff(self.repo, ctx.parents()[0].node(), ctx.node())
873 873 files, adds, removes = 0, 0, 0
874 874 for i in patch.diffstatdata(util.iterlines(diff)):
875 875 files += 1
876 876 adds += i[1]
877 877 removes += i[2]
878 878 return '%s: +%s/-%s' % (files, adds, removes)
879 879
880 880 defprops = {
881 881 'author': ctx.user(),
882 882 'branches': showbranches,
883 883 'date': ctx.date(),
884 884 'desc': ctx.description().strip(),
885 885 'file_adds': showadds,
886 886 'file_dels': showdels,
887 887 'file_mods': showmods,
888 888 'files': showfiles,
889 889 'file_copies': showcopies,
890 890 'manifest': showmanifest,
891 891 'node': ctx.hex(),
892 892 'parents': showparents,
893 893 'rev': ctx.rev(),
894 894 'tags': showtags,
895 895 'extras': showextras,
896 896 'diffstat': showdiffstat,
897 897 }
898 898 props = props.copy()
899 899 props.update(defprops)
900 900
901 901 # find correct templates for current mode
902 902
903 903 tmplmodes = [
904 904 (True, None),
905 905 (self.ui.verbose, 'verbose'),
906 906 (self.ui.quiet, 'quiet'),
907 907 (self.ui.debugflag, 'debug'),
908 908 ]
909 909
910 910 types = {'header': '', 'changeset': 'changeset'}
911 911 for mode, postfix in tmplmodes:
912 912 for type in types:
913 913 cur = postfix and ('%s_%s' % (type, postfix)) or type
914 914 if mode and cur in self.t:
915 915 types[type] = cur
916 916
917 917 try:
918 918
919 919 # write header
920 920 if types['header']:
921 921 h = templater.stringify(self.t(types['header'], **props))
922 922 if self.buffered:
923 923 self.header[ctx.rev()] = h
924 924 else:
925 925 self.ui.write(h)
926 926
927 927 # write changeset metadata, then patch if requested
928 928 key = types['changeset']
929 929 self.ui.write(templater.stringify(self.t(key, **props)))
930 930 self.showpatch(ctx.node())
931 931
932 932 except KeyError, inst:
933 933 msg = _("%s: no key named '%s'")
934 934 raise util.Abort(msg % (self.t.mapfile, inst.args[0]))
935 935 except SyntaxError, inst:
936 936 raise util.Abort(_('%s: %s') % (self.t.mapfile, inst.args[0]))
937 937
938 938 def show_changeset(ui, repo, opts, buffered=False, matchfn=False):
939 939 """show one changeset using template or regular display.
940 940
941 941 Display format will be the first non-empty hit of:
942 942 1. option 'template'
943 943 2. option 'style'
944 944 3. [ui] setting 'logtemplate'
945 945 4. [ui] setting 'style'
946 946 If all of these values are either the unset or the empty string,
947 947 regular display via changeset_printer() is done.
948 948 """
949 949 # options
950 950 patch = False
951 951 if opts.get('patch'):
952 952 patch = matchfn or matchall(repo)
953 953
954 954 tmpl = opts.get('template')
955 955 style = None
956 956 if tmpl:
957 957 tmpl = templater.parsestring(tmpl, quoted=False)
958 958 else:
959 959 style = opts.get('style')
960 960
961 961 # ui settings
962 962 if not (tmpl or style):
963 963 tmpl = ui.config('ui', 'logtemplate')
964 964 if tmpl:
965 965 tmpl = templater.parsestring(tmpl)
966 966 else:
967 967 style = ui.config('ui', 'style')
968 968
969 969 if not (tmpl or style):
970 970 return changeset_printer(ui, repo, patch, opts, buffered)
971 971
972 972 mapfile = None
973 973 if style and not tmpl:
974 974 mapfile = style
975 975 if not os.path.split(mapfile)[0]:
976 976 mapname = (templater.templatepath('map-cmdline.' + mapfile)
977 977 or templater.templatepath(mapfile))
978 978 if mapname: mapfile = mapname
979 979
980 980 try:
981 981 t = changeset_templater(ui, repo, patch, opts, mapfile, buffered)
982 982 except SyntaxError, inst:
983 983 raise util.Abort(inst.args[0])
984 984 if tmpl: t.use_template(tmpl)
985 985 return t
986 986
987 987 def finddate(ui, repo, date):
988 988 """Find the tipmost changeset that matches the given date spec"""
989 989 df = util.matchdate(date)
990 get = util.cachefunc(lambda r: repo[r].changeset())
990 get = util.cachefunc(lambda r: repo[r])
991 991 changeiter, matchfn = walkchangerevs(ui, repo, [], get, {'rev':None})
992 992 results = {}
993 993 for st, rev, fns in changeiter:
994 994 if st == 'add':
995 d = get(rev)[2]
995 d = get(rev).date()
996 996 if df(d[0]):
997 997 results[rev] = d
998 998 elif st == 'iter':
999 999 if rev in results:
1000 1000 ui.status(_("Found revision %s from %s\n") %
1001 1001 (rev, util.datestr(results[rev])))
1002 1002 return str(rev)
1003 1003
1004 1004 raise util.Abort(_("revision matching date not found"))
1005 1005
1006 1006 def walkchangerevs(ui, repo, pats, change, opts):
1007 1007 '''Iterate over files and the revs in which they changed.
1008 1008
1009 1009 Callers most commonly need to iterate backwards over the history
1010 1010 in which they are interested. Doing so has awful (quadratic-looking)
1011 1011 performance, so we use iterators in a "windowed" way.
1012 1012
1013 1013 We walk a window of revisions in the desired order. Within the
1014 1014 window, we first walk forwards to gather data, then in the desired
1015 1015 order (usually backwards) to display it.
1016 1016
1017 1017 This function returns an (iterator, matchfn) tuple. The iterator
1018 1018 yields 3-tuples. They will be of one of the following forms:
1019 1019
1020 1020 "window", incrementing, lastrev: stepping through a window,
1021 1021 positive if walking forwards through revs, last rev in the
1022 1022 sequence iterated over - use to reset state for the current window
1023 1023
1024 1024 "add", rev, fns: out-of-order traversal of the given filenames
1025 1025 fns, which changed during revision rev - use to gather data for
1026 1026 possible display
1027 1027
1028 1028 "iter", rev, None: in-order traversal of the revs earlier iterated
1029 1029 over with "add" - use to display data'''
1030 1030
1031 1031 def increasing_windows(start, end, windowsize=8, sizelimit=512):
1032 1032 if start < end:
1033 1033 while start < end:
1034 1034 yield start, min(windowsize, end-start)
1035 1035 start += windowsize
1036 1036 if windowsize < sizelimit:
1037 1037 windowsize *= 2
1038 1038 else:
1039 1039 while start > end:
1040 1040 yield start, min(windowsize, start-end-1)
1041 1041 start -= windowsize
1042 1042 if windowsize < sizelimit:
1043 1043 windowsize *= 2
1044 1044
1045 1045 m = match(repo, pats, opts)
1046 1046 follow = opts.get('follow') or opts.get('follow_first')
1047 1047
1048 1048 if not len(repo):
1049 1049 return [], m
1050 1050
1051 1051 if follow:
1052 1052 defrange = '%s:0' % repo['.'].rev()
1053 1053 else:
1054 1054 defrange = '-1:0'
1055 1055 revs = revrange(repo, opts['rev'] or [defrange])
1056 1056 wanted = set()
1057 1057 slowpath = m.anypats() or (m.files() and opts.get('removed'))
1058 1058 fncache = {}
1059 1059
1060 1060 if not slowpath and not m.files():
1061 1061 # No files, no patterns. Display all revs.
1062 1062 wanted = set(revs)
1063 1063 copies = []
1064 1064 if not slowpath:
1065 1065 # Only files, no patterns. Check the history of each file.
1066 1066 def filerevgen(filelog, node):
1067 1067 cl_count = len(repo)
1068 1068 if node is None:
1069 1069 last = len(filelog) - 1
1070 1070 else:
1071 1071 last = filelog.rev(node)
1072 1072 for i, window in increasing_windows(last, nullrev):
1073 1073 revs = []
1074 1074 for j in xrange(i - window, i + 1):
1075 1075 n = filelog.node(j)
1076 1076 revs.append((filelog.linkrev(j),
1077 1077 follow and filelog.renamed(n)))
1078 1078 for rev in reversed(revs):
1079 1079 # only yield rev for which we have the changelog, it can
1080 1080 # happen while doing "hg log" during a pull or commit
1081 1081 if rev[0] < cl_count:
1082 1082 yield rev
1083 1083 def iterfiles():
1084 1084 for filename in m.files():
1085 1085 yield filename, None
1086 1086 for filename_node in copies:
1087 1087 yield filename_node
1088 1088 minrev, maxrev = min(revs), max(revs)
1089 1089 for file_, node in iterfiles():
1090 1090 filelog = repo.file(file_)
1091 1091 if not len(filelog):
1092 1092 if node is None:
1093 1093 # A zero count may be a directory or deleted file, so
1094 1094 # try to find matching entries on the slow path.
1095 1095 if follow:
1096 1096 raise util.Abort(_('cannot follow nonexistent file: "%s"') % file_)
1097 1097 slowpath = True
1098 1098 break
1099 1099 else:
1100 1100 ui.warn(_('%s:%s copy source revision cannot be found!\n')
1101 1101 % (file_, short(node)))
1102 1102 continue
1103 1103 for rev, copied in filerevgen(filelog, node):
1104 1104 if rev <= maxrev:
1105 1105 if rev < minrev:
1106 1106 break
1107 1107 fncache.setdefault(rev, [])
1108 1108 fncache[rev].append(file_)
1109 1109 wanted.add(rev)
1110 1110 if follow and copied:
1111 1111 copies.append(copied)
1112 1112 if slowpath:
1113 1113 if follow:
1114 1114 raise util.Abort(_('can only follow copies/renames for explicit '
1115 1115 'filenames'))
1116 1116
1117 1117 # The slow path checks files modified in every changeset.
1118 1118 def changerevgen():
1119 1119 for i, window in increasing_windows(len(repo) - 1, nullrev):
1120 1120 for j in xrange(i - window, i + 1):
1121 yield j, change(j)[3]
1121 yield change(j)
1122 1122
1123 for rev, changefiles in changerevgen():
1124 matches = filter(m, changefiles)
1123 for ctx in changerevgen():
1124 matches = filter(m, ctx.files())
1125 1125 if matches:
1126 fncache[rev] = matches
1127 wanted.add(rev)
1126 fncache[ctx.rev()] = matches
1127 wanted.add(ctx.rev())
1128 1128
1129 1129 class followfilter(object):
1130 1130 def __init__(self, onlyfirst=False):
1131 1131 self.startrev = nullrev
1132 1132 self.roots = []
1133 1133 self.onlyfirst = onlyfirst
1134 1134
1135 1135 def match(self, rev):
1136 1136 def realparents(rev):
1137 1137 if self.onlyfirst:
1138 1138 return repo.changelog.parentrevs(rev)[0:1]
1139 1139 else:
1140 1140 return filter(lambda x: x != nullrev,
1141 1141 repo.changelog.parentrevs(rev))
1142 1142
1143 1143 if self.startrev == nullrev:
1144 1144 self.startrev = rev
1145 1145 return True
1146 1146
1147 1147 if rev > self.startrev:
1148 1148 # forward: all descendants
1149 1149 if not self.roots:
1150 1150 self.roots.append(self.startrev)
1151 1151 for parent in realparents(rev):
1152 1152 if parent in self.roots:
1153 1153 self.roots.append(rev)
1154 1154 return True
1155 1155 else:
1156 1156 # backwards: all parents
1157 1157 if not self.roots:
1158 1158 self.roots.extend(realparents(self.startrev))
1159 1159 if rev in self.roots:
1160 1160 self.roots.remove(rev)
1161 1161 self.roots.extend(realparents(rev))
1162 1162 return True
1163 1163
1164 1164 return False
1165 1165
1166 1166 # it might be worthwhile to do this in the iterator if the rev range
1167 1167 # is descending and the prune args are all within that range
1168 1168 for rev in opts.get('prune', ()):
1169 1169 rev = repo.changelog.rev(repo.lookup(rev))
1170 1170 ff = followfilter()
1171 1171 stop = min(revs[0], revs[-1])
1172 1172 for x in xrange(rev, stop-1, -1):
1173 1173 if ff.match(x):
1174 1174 wanted.discard(x)
1175 1175
1176 1176 def iterate():
1177 1177 if follow and not m.files():
1178 1178 ff = followfilter(onlyfirst=opts.get('follow_first'))
1179 1179 def want(rev):
1180 1180 return ff.match(rev) and rev in wanted
1181 1181 else:
1182 1182 def want(rev):
1183 1183 return rev in wanted
1184 1184
1185 1185 for i, window in increasing_windows(0, len(revs)):
1186 1186 yield 'window', revs[0] < revs[-1], revs[-1]
1187 1187 nrevs = [rev for rev in revs[i:i+window] if want(rev)]
1188 1188 for rev in sorted(nrevs):
1189 1189 fns = fncache.get(rev)
1190 1190 if not fns:
1191 1191 def fns_generator():
1192 for f in change(rev)[3]:
1192 for f in change(rev).files():
1193 1193 if m(f):
1194 1194 yield f
1195 1195 fns = fns_generator()
1196 1196 yield 'add', rev, fns
1197 1197 for rev in nrevs:
1198 1198 yield 'iter', rev, None
1199 1199 return iterate(), m
1200 1200
1201 1201 def commit(ui, repo, commitfunc, pats, opts):
1202 1202 '''commit the specified files or all outstanding changes'''
1203 1203 date = opts.get('date')
1204 1204 if date:
1205 1205 opts['date'] = util.parsedate(date)
1206 1206 message = logmessage(opts)
1207 1207
1208 1208 # extract addremove carefully -- this function can be called from a command
1209 1209 # that doesn't support addremove
1210 1210 if opts.get('addremove'):
1211 1211 addremove(repo, pats, opts)
1212 1212
1213 1213 return commitfunc(ui, repo, message, match(repo, pats, opts), opts)
1214 1214
1215 1215 def commiteditor(repo, ctx, subs):
1216 1216 if ctx.description():
1217 1217 return ctx.description()
1218 1218 return commitforceeditor(repo, ctx, subs)
1219 1219
1220 1220 def commitforceeditor(repo, ctx, subs):
1221 1221 edittext = []
1222 1222 modified, added, removed = ctx.modified(), ctx.added(), ctx.removed()
1223 1223 if ctx.description():
1224 1224 edittext.append(ctx.description())
1225 1225 edittext.append("")
1226 1226 edittext.append("") # Empty line between message and comments.
1227 1227 edittext.append(_("HG: Enter commit message."
1228 1228 " Lines beginning with 'HG:' are removed."))
1229 1229 edittext.append(_("HG: Leave message empty to abort commit."))
1230 1230 edittext.append("HG: --")
1231 1231 edittext.append(_("HG: user: %s") % ctx.user())
1232 1232 if ctx.p2():
1233 1233 edittext.append(_("HG: branch merge"))
1234 1234 if ctx.branch():
1235 1235 edittext.append(_("HG: branch '%s'")
1236 1236 % encoding.tolocal(ctx.branch()))
1237 1237 edittext.extend([_("HG: subrepo %s") % s for s in subs])
1238 1238 edittext.extend([_("HG: added %s") % f for f in added])
1239 1239 edittext.extend([_("HG: changed %s") % f for f in modified])
1240 1240 edittext.extend([_("HG: removed %s") % f for f in removed])
1241 1241 if not added and not modified and not removed:
1242 1242 edittext.append(_("HG: no files changed"))
1243 1243 edittext.append("")
1244 1244 # run editor in the repository root
1245 1245 olddir = os.getcwd()
1246 1246 os.chdir(repo.root)
1247 1247 text = repo.ui.edit("\n".join(edittext), ctx.user())
1248 1248 text = re.sub("(?m)^HG:.*\n", "", text)
1249 1249 os.chdir(olddir)
1250 1250
1251 1251 if not text.strip():
1252 1252 raise util.Abort(_("empty commit message"))
1253 1253
1254 1254 return text
@@ -1,3565 +1,3562 b''
1 1 # commands.py - command processing for mercurial
2 2 #
3 3 # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
4 4 #
5 5 # This software may be used and distributed according to the terms of the
6 6 # GNU General Public License version 2, incorporated herein by reference.
7 7
8 8 from node import hex, nullid, nullrev, short
9 9 from lock import release
10 10 from i18n import _, gettext
11 11 import os, re, sys, subprocess, difflib, time, tempfile
12 12 import hg, util, revlog, bundlerepo, extensions, copies, context, error
13 13 import patch, help, mdiff, url, encoding
14 14 import archival, changegroup, cmdutil, sshserver, hbisect
15 15 from hgweb import server
16 16 import merge as merge_
17 17 import minirst
18 18
19 19 # Commands start here, listed alphabetically
20 20
21 21 def add(ui, repo, *pats, **opts):
22 22 """add the specified files on the next commit
23 23
24 24 Schedule files to be version controlled and added to the
25 25 repository.
26 26
27 27 The files will be added to the repository at the next commit. To
28 28 undo an add before that, see hg forget.
29 29
30 30 If no names are given, add all files to the repository.
31 31 """
32 32
33 33 bad = []
34 34 exacts = {}
35 35 names = []
36 36 m = cmdutil.match(repo, pats, opts)
37 37 oldbad = m.bad
38 38 m.bad = lambda x,y: bad.append(x) or oldbad(x,y)
39 39
40 40 for f in repo.walk(m):
41 41 exact = m.exact(f)
42 42 if exact or f not in repo.dirstate:
43 43 names.append(f)
44 44 if ui.verbose or not exact:
45 45 ui.status(_('adding %s\n') % m.rel(f))
46 46 if not opts.get('dry_run'):
47 47 bad += [f for f in repo.add(names) if f in m.files()]
48 48 return bad and 1 or 0
49 49
50 50 def addremove(ui, repo, *pats, **opts):
51 51 """add all new files, delete all missing files
52 52
53 53 Add all new files and remove all missing files from the
54 54 repository.
55 55
56 56 New files are ignored if they match any of the patterns in
57 57 .hgignore. As with add, these changes take effect at the next
58 58 commit.
59 59
60 60 Use the -s/--similarity option to detect renamed files. With a
61 61 parameter greater than 0, this compares every removed file with
62 62 every added file and records those similar enough as renames. This
63 63 option takes a percentage between 0 (disabled) and 100 (files must
64 64 be identical) as its parameter. Detecting renamed files this way
65 65 can be expensive.
66 66 """
67 67 try:
68 68 sim = float(opts.get('similarity') or 0)
69 69 except ValueError:
70 70 raise util.Abort(_('similarity must be a number'))
71 71 if sim < 0 or sim > 100:
72 72 raise util.Abort(_('similarity must be between 0 and 100'))
73 73 return cmdutil.addremove(repo, pats, opts, similarity=sim/100.)
74 74
75 75 def annotate(ui, repo, *pats, **opts):
76 76 """show changeset information by line for each file
77 77
78 78 List changes in files, showing the revision id responsible for
79 79 each line
80 80
81 81 This command is useful for discovering when a change was made and
82 82 by whom.
83 83
84 84 Without the -a/--text option, annotate will avoid processing files
85 85 it detects as binary. With -a, annotate will annotate the file
86 86 anyway, although the results will probably be neither useful
87 87 nor desirable.
88 88 """
89 89 datefunc = ui.quiet and util.shortdate or util.datestr
90 90 getdate = util.cachefunc(lambda x: datefunc(x[0].date()))
91 91
92 92 if not pats:
93 93 raise util.Abort(_('at least one filename or pattern is required'))
94 94
95 95 opmap = [('user', lambda x: ui.shortuser(x[0].user())),
96 96 ('number', lambda x: str(x[0].rev())),
97 97 ('changeset', lambda x: short(x[0].node())),
98 98 ('date', getdate),
99 99 ('follow', lambda x: x[0].path()),
100 100 ]
101 101
102 102 if (not opts.get('user') and not opts.get('changeset') and not opts.get('date')
103 103 and not opts.get('follow')):
104 104 opts['number'] = 1
105 105
106 106 linenumber = opts.get('line_number') is not None
107 107 if (linenumber and (not opts.get('changeset')) and (not opts.get('number'))):
108 108 raise util.Abort(_('at least one of -n/-c is required for -l'))
109 109
110 110 funcmap = [func for op, func in opmap if opts.get(op)]
111 111 if linenumber:
112 112 lastfunc = funcmap[-1]
113 113 funcmap[-1] = lambda x: "%s:%s" % (lastfunc(x), x[1])
114 114
115 115 ctx = repo[opts.get('rev')]
116 116
117 117 m = cmdutil.match(repo, pats, opts)
118 118 for abs in ctx.walk(m):
119 119 fctx = ctx[abs]
120 120 if not opts.get('text') and util.binary(fctx.data()):
121 121 ui.write(_("%s: binary file\n") % ((pats and m.rel(abs)) or abs))
122 122 continue
123 123
124 124 lines = fctx.annotate(follow=opts.get('follow'),
125 125 linenumber=linenumber)
126 126 pieces = []
127 127
128 128 for f in funcmap:
129 129 l = [f(n) for n, dummy in lines]
130 130 if l:
131 131 ml = max(map(len, l))
132 132 pieces.append(["%*s" % (ml, x) for x in l])
133 133
134 134 if pieces:
135 135 for p, l in zip(zip(*pieces), lines):
136 136 ui.write("%s: %s" % (" ".join(p), l[1]))
137 137
138 138 def archive(ui, repo, dest, **opts):
139 139 '''create an unversioned archive of a repository revision
140 140
141 141 By default, the revision used is the parent of the working
142 142 directory; use -r/--rev to specify a different revision.
143 143
144 144 To specify the type of archive to create, use -t/--type. Valid
145 145 types are::
146 146
147 147 "files" (default): a directory full of files
148 148 "tar": tar archive, uncompressed
149 149 "tbz2": tar archive, compressed using bzip2
150 150 "tgz": tar archive, compressed using gzip
151 151 "uzip": zip archive, uncompressed
152 152 "zip": zip archive, compressed using deflate
153 153
154 154 The exact name of the destination archive or directory is given
155 155 using a format string; see 'hg help export' for details.
156 156
157 157 Each member added to an archive file has a directory prefix
158 158 prepended. Use -p/--prefix to specify a format string for the
159 159 prefix. The default is the basename of the archive, with suffixes
160 160 removed.
161 161 '''
162 162
163 163 ctx = repo[opts.get('rev')]
164 164 if not ctx:
165 165 raise util.Abort(_('no working directory: please specify a revision'))
166 166 node = ctx.node()
167 167 dest = cmdutil.make_filename(repo, dest, node)
168 168 if os.path.realpath(dest) == repo.root:
169 169 raise util.Abort(_('repository root cannot be destination'))
170 170 matchfn = cmdutil.match(repo, [], opts)
171 171 kind = opts.get('type') or 'files'
172 172 prefix = opts.get('prefix')
173 173 if dest == '-':
174 174 if kind == 'files':
175 175 raise util.Abort(_('cannot archive plain files to stdout'))
176 176 dest = sys.stdout
177 177 if not prefix: prefix = os.path.basename(repo.root) + '-%h'
178 178 prefix = cmdutil.make_filename(repo, prefix, node)
179 179 archival.archive(repo, dest, node, kind, not opts.get('no_decode'),
180 180 matchfn, prefix)
181 181
182 182 def backout(ui, repo, node=None, rev=None, **opts):
183 183 '''reverse effect of earlier changeset
184 184
185 185 Commit the backed out changes as a new changeset. The new
186 186 changeset is a child of the backed out changeset.
187 187
188 188 If you backout a changeset other than the tip, a new head is
189 189 created. This head will be the new tip and you should merge this
190 190 backout changeset with another head.
191 191
192 192 The --merge option remembers the parent of the working directory
193 193 before starting the backout, then merges the new head with that
194 194 changeset afterwards. This saves you from doing the merge by hand.
195 195 The result of this merge is not committed, as with a normal merge.
196 196
197 197 See 'hg help dates' for a list of formats valid for -d/--date.
198 198 '''
199 199 if rev and node:
200 200 raise util.Abort(_("please specify just one revision"))
201 201
202 202 if not rev:
203 203 rev = node
204 204
205 205 if not rev:
206 206 raise util.Abort(_("please specify a revision to backout"))
207 207
208 208 date = opts.get('date')
209 209 if date:
210 210 opts['date'] = util.parsedate(date)
211 211
212 212 cmdutil.bail_if_changed(repo)
213 213 node = repo.lookup(rev)
214 214
215 215 op1, op2 = repo.dirstate.parents()
216 216 a = repo.changelog.ancestor(op1, node)
217 217 if a != node:
218 218 raise util.Abort(_('cannot backout change on a different branch'))
219 219
220 220 p1, p2 = repo.changelog.parents(node)
221 221 if p1 == nullid:
222 222 raise util.Abort(_('cannot backout a change with no parents'))
223 223 if p2 != nullid:
224 224 if not opts.get('parent'):
225 225 raise util.Abort(_('cannot backout a merge changeset without '
226 226 '--parent'))
227 227 p = repo.lookup(opts['parent'])
228 228 if p not in (p1, p2):
229 229 raise util.Abort(_('%s is not a parent of %s') %
230 230 (short(p), short(node)))
231 231 parent = p
232 232 else:
233 233 if opts.get('parent'):
234 234 raise util.Abort(_('cannot use --parent on non-merge changeset'))
235 235 parent = p1
236 236
237 237 # the backout should appear on the same branch
238 238 branch = repo.dirstate.branch()
239 239 hg.clean(repo, node, show_stats=False)
240 240 repo.dirstate.setbranch(branch)
241 241 revert_opts = opts.copy()
242 242 revert_opts['date'] = None
243 243 revert_opts['all'] = True
244 244 revert_opts['rev'] = hex(parent)
245 245 revert_opts['no_backup'] = None
246 246 revert(ui, repo, **revert_opts)
247 247 commit_opts = opts.copy()
248 248 commit_opts['addremove'] = False
249 249 if not commit_opts['message'] and not commit_opts['logfile']:
250 250 # we don't translate commit messages
251 251 commit_opts['message'] = "Backed out changeset %s" % short(node)
252 252 commit_opts['force_editor'] = True
253 253 commit(ui, repo, **commit_opts)
254 254 def nice(node):
255 255 return '%d:%s' % (repo.changelog.rev(node), short(node))
256 256 ui.status(_('changeset %s backs out changeset %s\n') %
257 257 (nice(repo.changelog.tip()), nice(node)))
258 258 if op1 != node:
259 259 hg.clean(repo, op1, show_stats=False)
260 260 if opts.get('merge'):
261 261 ui.status(_('merging with changeset %s\n') % nice(repo.changelog.tip()))
262 262 hg.merge(repo, hex(repo.changelog.tip()))
263 263 else:
264 264 ui.status(_('the backout changeset is a new head - '
265 265 'do not forget to merge\n'))
266 266 ui.status(_('(use "backout --merge" '
267 267 'if you want to auto-merge)\n'))
268 268
269 269 def bisect(ui, repo, rev=None, extra=None, command=None,
270 270 reset=None, good=None, bad=None, skip=None, noupdate=None):
271 271 """subdivision search of changesets
272 272
273 273 This command helps to find changesets which introduce problems. To
274 274 use, mark the earliest changeset you know exhibits the problem as
275 275 bad, then mark the latest changeset which is free from the problem
276 276 as good. Bisect will update your working directory to a revision
277 277 for testing (unless the -U/--noupdate option is specified). Once
278 278 you have performed tests, mark the working directory as good or
279 279 bad, and bisect will either update to another candidate changeset
280 280 or announce that it has found the bad revision.
281 281
282 282 As a shortcut, you can also use the revision argument to mark a
283 283 revision as good or bad without checking it out first.
284 284
285 285 If you supply a command, it will be used for automatic bisection.
286 286 Its exit status will be used to mark revisions as good or bad:
287 287 status 0 means good, 125 means to skip the revision, 127
288 288 (command not found) will abort the bisection, and any other
289 289 non-zero exit status means the revision is bad.
290 290 """
291 291 def print_result(nodes, good):
292 292 displayer = cmdutil.show_changeset(ui, repo, {})
293 293 if len(nodes) == 1:
294 294 # narrowed it down to a single revision
295 295 if good:
296 296 ui.write(_("The first good revision is:\n"))
297 297 else:
298 298 ui.write(_("The first bad revision is:\n"))
299 299 displayer.show(repo[nodes[0]])
300 300 else:
301 301 # multiple possible revisions
302 302 if good:
303 303 ui.write(_("Due to skipped revisions, the first "
304 304 "good revision could be any of:\n"))
305 305 else:
306 306 ui.write(_("Due to skipped revisions, the first "
307 307 "bad revision could be any of:\n"))
308 308 for n in nodes:
309 309 displayer.show(repo[n])
310 310
311 311 def check_state(state, interactive=True):
312 312 if not state['good'] or not state['bad']:
313 313 if (good or bad or skip or reset) and interactive:
314 314 return
315 315 if not state['good']:
316 316 raise util.Abort(_('cannot bisect (no known good revisions)'))
317 317 else:
318 318 raise util.Abort(_('cannot bisect (no known bad revisions)'))
319 319 return True
320 320
321 321 # backward compatibility
322 322 if rev in "good bad reset init".split():
323 323 ui.warn(_("(use of 'hg bisect <cmd>' is deprecated)\n"))
324 324 cmd, rev, extra = rev, extra, None
325 325 if cmd == "good":
326 326 good = True
327 327 elif cmd == "bad":
328 328 bad = True
329 329 else:
330 330 reset = True
331 331 elif extra or good + bad + skip + reset + bool(command) > 1:
332 332 raise util.Abort(_('incompatible arguments'))
333 333
334 334 if reset:
335 335 p = repo.join("bisect.state")
336 336 if os.path.exists(p):
337 337 os.unlink(p)
338 338 return
339 339
340 340 state = hbisect.load_state(repo)
341 341
342 342 if command:
343 343 commandpath = util.find_exe(command)
344 344 if commandpath is None:
345 345 raise util.Abort(_("cannot find executable: %s") % command)
346 346 changesets = 1
347 347 try:
348 348 while changesets:
349 349 # update state
350 350 status = subprocess.call([commandpath])
351 351 if status == 125:
352 352 transition = "skip"
353 353 elif status == 0:
354 354 transition = "good"
355 355 # status < 0 means process was killed
356 356 elif status == 127:
357 357 raise util.Abort(_("failed to execute %s") % command)
358 358 elif status < 0:
359 359 raise util.Abort(_("%s killed") % command)
360 360 else:
361 361 transition = "bad"
362 362 ctx = repo[rev or '.']
363 363 state[transition].append(ctx.node())
364 364 ui.status(_('Changeset %d:%s: %s\n') % (ctx, ctx, transition))
365 365 check_state(state, interactive=False)
366 366 # bisect
367 367 nodes, changesets, good = hbisect.bisect(repo.changelog, state)
368 368 # update to next check
369 369 cmdutil.bail_if_changed(repo)
370 370 hg.clean(repo, nodes[0], show_stats=False)
371 371 finally:
372 372 hbisect.save_state(repo, state)
373 373 return print_result(nodes, not status)
374 374
375 375 # update state
376 376 node = repo.lookup(rev or '.')
377 377 if good:
378 378 state['good'].append(node)
379 379 elif bad:
380 380 state['bad'].append(node)
381 381 elif skip:
382 382 state['skip'].append(node)
383 383
384 384 hbisect.save_state(repo, state)
385 385
386 386 if not check_state(state):
387 387 return
388 388
389 389 # actually bisect
390 390 nodes, changesets, good = hbisect.bisect(repo.changelog, state)
391 391 if changesets == 0:
392 392 print_result(nodes, good)
393 393 else:
394 394 assert len(nodes) == 1 # only a single node can be tested next
395 395 node = nodes[0]
396 396 # compute the approximate number of remaining tests
397 397 tests, size = 0, 2
398 398 while size <= changesets:
399 399 tests, size = tests + 1, size * 2
400 400 rev = repo.changelog.rev(node)
401 401 ui.write(_("Testing changeset %d:%s "
402 402 "(%d changesets remaining, ~%d tests)\n")
403 403 % (rev, short(node), changesets, tests))
404 404 if not noupdate:
405 405 cmdutil.bail_if_changed(repo)
406 406 return hg.clean(repo, node)
407 407
408 408 def branch(ui, repo, label=None, **opts):
409 409 """set or show the current branch name
410 410
411 411 With no argument, show the current branch name. With one argument,
412 412 set the working directory branch name (the branch will not exist
413 413 in the repository until the next commit). Standard practice
414 414 recommends that primary development take place on the 'default'
415 415 branch.
416 416
417 417 Unless -f/--force is specified, branch will not let you set a
418 418 branch name that already exists, even if it's inactive.
419 419
420 420 Use -C/--clean to reset the working directory branch to that of
421 421 the parent of the working directory, negating a previous branch
422 422 change.
423 423
424 424 Use the command 'hg update' to switch to an existing branch. Use
425 425 'hg commit --close-branch' to mark this branch as closed.
426 426 """
427 427
428 428 if opts.get('clean'):
429 429 label = repo[None].parents()[0].branch()
430 430 repo.dirstate.setbranch(label)
431 431 ui.status(_('reset working directory to branch %s\n') % label)
432 432 elif label:
433 433 if not opts.get('force') and label in repo.branchtags():
434 434 if label not in [p.branch() for p in repo.parents()]:
435 435 raise util.Abort(_('a branch of the same name already exists'
436 436 ' (use --force to override)'))
437 437 repo.dirstate.setbranch(encoding.fromlocal(label))
438 438 ui.status(_('marked working directory as branch %s\n') % label)
439 439 else:
440 440 ui.write("%s\n" % encoding.tolocal(repo.dirstate.branch()))
441 441
442 442 def branches(ui, repo, active=False, closed=False):
443 443 """list repository named branches
444 444
445 445 List the repository's named branches, indicating which ones are
446 446 inactive. If -c/--closed is specified, also list branches which have
447 447 been marked closed (see hg commit --close-branch).
448 448
449 449 If -a/--active is specified, only show active branches. A branch
450 450 is considered active if it contains repository heads.
451 451
452 452 Use the command 'hg update' to switch to an existing branch.
453 453 """
454 454
455 455 hexfunc = ui.debugflag and hex or short
456 456 activebranches = [encoding.tolocal(repo[n].branch())
457 457 for n in repo.heads()]
458 458 def testactive(tag, node):
459 459 realhead = tag in activebranches
460 460 open = node in repo.branchheads(tag, closed=False)
461 461 return realhead and open
462 462 branches = sorted([(testactive(tag, node), repo.changelog.rev(node), tag)
463 463 for tag, node in repo.branchtags().items()],
464 464 reverse=True)
465 465
466 466 for isactive, node, tag in branches:
467 467 if (not active) or isactive:
468 468 if ui.quiet:
469 469 ui.write("%s\n" % tag)
470 470 else:
471 471 hn = repo.lookup(node)
472 472 if isactive:
473 473 notice = ''
474 474 elif hn not in repo.branchheads(tag, closed=False):
475 475 if not closed:
476 476 continue
477 477 notice = ' (closed)'
478 478 else:
479 479 notice = ' (inactive)'
480 480 rev = str(node).rjust(31 - encoding.colwidth(tag))
481 481 data = tag, rev, hexfunc(hn), notice
482 482 ui.write("%s %s:%s%s\n" % data)
483 483
484 484 def bundle(ui, repo, fname, dest=None, **opts):
485 485 """create a changegroup file
486 486
487 487 Generate a compressed changegroup file collecting changesets not
488 488 known to be in another repository.
489 489
490 490 If no destination repository is specified the destination is
491 491 assumed to have all the nodes specified by one or more --base
492 492 parameters. To create a bundle containing all changesets, use
493 493 -a/--all (or --base null).
494 494
495 495 You can change compression method with the -t/--type option.
496 496 The available compression methods are: none, bzip2, and
497 497 gzip (by default, bundles are compressed using bzip2).
498 498
499 499 The bundle file can then be transferred using conventional means
500 500 and applied to another repository with the unbundle or pull
501 501 command. This is useful when direct push and pull are not
502 502 available or when exporting an entire repository is undesirable.
503 503
504 504 Applying bundles preserves all changeset contents including
505 505 permissions, copy/rename information, and revision history.
506 506 """
507 507 revs = opts.get('rev') or None
508 508 if revs:
509 509 revs = [repo.lookup(rev) for rev in revs]
510 510 if opts.get('all'):
511 511 base = ['null']
512 512 else:
513 513 base = opts.get('base')
514 514 if base:
515 515 if dest:
516 516 raise util.Abort(_("--base is incompatible with specifying "
517 517 "a destination"))
518 518 base = [repo.lookup(rev) for rev in base]
519 519 # create the right base
520 520 # XXX: nodesbetween / changegroup* should be "fixed" instead
521 521 o = []
522 522 has = set((nullid,))
523 523 for n in base:
524 524 has.update(repo.changelog.reachable(n))
525 525 if revs:
526 526 visit = list(revs)
527 527 else:
528 528 visit = repo.changelog.heads()
529 529 seen = {}
530 530 while visit:
531 531 n = visit.pop(0)
532 532 parents = [p for p in repo.changelog.parents(n) if p not in has]
533 533 if len(parents) == 0:
534 534 o.insert(0, n)
535 535 else:
536 536 for p in parents:
537 537 if p not in seen:
538 538 seen[p] = 1
539 539 visit.append(p)
540 540 else:
541 541 dest, revs, checkout = hg.parseurl(
542 542 ui.expandpath(dest or 'default-push', dest or 'default'), revs)
543 543 other = hg.repository(cmdutil.remoteui(repo, opts), dest)
544 544 o = repo.findoutgoing(other, force=opts.get('force'))
545 545
546 546 if revs:
547 547 cg = repo.changegroupsubset(o, revs, 'bundle')
548 548 else:
549 549 cg = repo.changegroup(o, 'bundle')
550 550
551 551 bundletype = opts.get('type', 'bzip2').lower()
552 552 btypes = {'none': 'HG10UN', 'bzip2': 'HG10BZ', 'gzip': 'HG10GZ'}
553 553 bundletype = btypes.get(bundletype)
554 554 if bundletype not in changegroup.bundletypes:
555 555 raise util.Abort(_('unknown bundle type specified with --type'))
556 556
557 557 changegroup.writebundle(cg, fname, bundletype)
558 558
559 559 def cat(ui, repo, file1, *pats, **opts):
560 560 """output the current or given revision of files
561 561
562 562 Print the specified files as they were at the given revision. If
563 563 no revision is given, the parent of the working directory is used,
564 564 or tip if no revision is checked out.
565 565
566 566 Output may be to a file, in which case the name of the file is
567 567 given using a format string. The formatting rules are the same as
568 568 for the export command, with the following additions::
569 569
570 570 %s basename of file being printed
571 571 %d dirname of file being printed, or '.' if in repository root
572 572 %p root-relative path name of file being printed
573 573 """
574 574 ctx = repo[opts.get('rev')]
575 575 err = 1
576 576 m = cmdutil.match(repo, (file1,) + pats, opts)
577 577 for abs in ctx.walk(m):
578 578 fp = cmdutil.make_file(repo, opts.get('output'), ctx.node(), pathname=abs)
579 579 data = ctx[abs].data()
580 580 if opts.get('decode'):
581 581 data = repo.wwritedata(abs, data)
582 582 fp.write(data)
583 583 err = 0
584 584 return err
585 585
586 586 def clone(ui, source, dest=None, **opts):
587 587 """make a copy of an existing repository
588 588
589 589 Create a copy of an existing repository in a new directory.
590 590
591 591 If no destination directory name is specified, it defaults to the
592 592 basename of the source.
593 593
594 594 The location of the source is added to the new repository's
595 595 .hg/hgrc file, as the default to be used for future pulls.
596 596
597 597 If you use the -r/--rev option to clone up to a specific revision,
598 598 no subsequent revisions (including subsequent tags) will be
599 599 present in the cloned repository. This option implies --pull, even
600 600 on local repositories.
601 601
602 602 By default, clone will check out the head of the 'default' branch.
603 603 If the -U/--noupdate option is used, the new clone will contain
604 604 only a repository (.hg) and no working copy (the working copy
605 605 parent is the null revision).
606 606
607 607 See 'hg help urls' for valid source format details.
608 608
609 609 It is possible to specify an ssh:// URL as the destination, but no
610 610 .hg/hgrc and working directory will be created on the remote side.
611 611 Please see 'hg help urls' for important details about ssh:// URLs.
612 612
613 613 For efficiency, hardlinks are used for cloning whenever the source
614 614 and destination are on the same filesystem (note this applies only
615 615 to the repository data, not to the checked out files). Some
616 616 filesystems, such as AFS, implement hardlinking incorrectly, but
617 617 do not report errors. In these cases, use the --pull option to
618 618 avoid hardlinking.
619 619
620 620 In some cases, you can clone repositories and checked out files
621 621 using full hardlinks with ::
622 622
623 623 $ cp -al REPO REPOCLONE
624 624
625 625 This is the fastest way to clone, but it is not always safe. The
626 626 operation is not atomic (making sure REPO is not modified during
627 627 the operation is up to you) and you have to make sure your editor
628 628 breaks hardlinks (Emacs and most Linux Kernel tools do so). Also,
629 629 this is not compatible with certain extensions that place their
630 630 metadata under the .hg directory, such as mq.
631 631 """
632 632 hg.clone(cmdutil.remoteui(ui, opts), source, dest,
633 633 pull=opts.get('pull'),
634 634 stream=opts.get('uncompressed'),
635 635 rev=opts.get('rev'),
636 636 update=not opts.get('noupdate'))
637 637
638 638 def commit(ui, repo, *pats, **opts):
639 639 """commit the specified files or all outstanding changes
640 640
641 641 Commit changes to the given files into the repository. Unlike a
642 642 centralized RCS, this operation is a local operation. See hg push
643 643 for a way to actively distribute your changes.
644 644
645 645 If a list of files is omitted, all changes reported by "hg status"
646 646 will be committed.
647 647
648 648 If you are committing the result of a merge, do not provide any
649 649 filenames or -I/-X filters.
650 650
651 651 If no commit message is specified, the configured editor is
652 652 started to prompt you for a message.
653 653
654 654 See 'hg help dates' for a list of formats valid for -d/--date.
655 655 """
656 656 extra = {}
657 657 if opts.get('close_branch'):
658 658 extra['close'] = 1
659 659 e = cmdutil.commiteditor
660 660 if opts.get('force_editor'):
661 661 e = cmdutil.commitforceeditor
662 662
663 663 def commitfunc(ui, repo, message, match, opts):
664 664 return repo.commit(message, opts.get('user'), opts.get('date'), match,
665 665 editor=e, extra=extra)
666 666
667 667 node = cmdutil.commit(ui, repo, commitfunc, pats, opts)
668 668 if not node:
669 669 ui.status(_("nothing changed\n"))
670 670 return
671 671 cl = repo.changelog
672 672 rev = cl.rev(node)
673 673 parents = cl.parentrevs(rev)
674 674 if rev - 1 in parents:
675 675 # one of the parents was the old tip
676 676 pass
677 677 elif (parents == (nullrev, nullrev) or
678 678 len(cl.heads(cl.node(parents[0]))) > 1 and
679 679 (parents[1] == nullrev or len(cl.heads(cl.node(parents[1]))) > 1)):
680 680 ui.status(_('created new head\n'))
681 681
682 682 if ui.debugflag:
683 683 ui.write(_('committed changeset %d:%s\n') % (rev, hex(node)))
684 684 elif ui.verbose:
685 685 ui.write(_('committed changeset %d:%s\n') % (rev, short(node)))
686 686
687 687 def copy(ui, repo, *pats, **opts):
688 688 """mark files as copied for the next commit
689 689
690 690 Mark dest as having copies of source files. If dest is a
691 691 directory, copies are put in that directory. If dest is a file,
692 692 the source must be a single file.
693 693
694 694 By default, this command copies the contents of files as they
695 695 exist in the working directory. If invoked with -A/--after, the
696 696 operation is recorded, but no copying is performed.
697 697
698 698 This command takes effect with the next commit. To undo a copy
699 699 before that, see hg revert.
700 700 """
701 701 wlock = repo.wlock(False)
702 702 try:
703 703 return cmdutil.copy(ui, repo, pats, opts)
704 704 finally:
705 705 wlock.release()
706 706
707 707 def debugancestor(ui, repo, *args):
708 708 """find the ancestor revision of two revisions in a given index"""
709 709 if len(args) == 3:
710 710 index, rev1, rev2 = args
711 711 r = revlog.revlog(util.opener(os.getcwd(), audit=False), index)
712 712 lookup = r.lookup
713 713 elif len(args) == 2:
714 714 if not repo:
715 715 raise util.Abort(_("There is no Mercurial repository here "
716 716 "(.hg not found)"))
717 717 rev1, rev2 = args
718 718 r = repo.changelog
719 719 lookup = repo.lookup
720 720 else:
721 721 raise util.Abort(_('either two or three arguments required'))
722 722 a = r.ancestor(lookup(rev1), lookup(rev2))
723 723 ui.write("%d:%s\n" % (r.rev(a), hex(a)))
724 724
725 725 def debugcommands(ui, cmd='', *args):
726 726 for cmd, vals in sorted(table.iteritems()):
727 727 cmd = cmd.split('|')[0].strip('^')
728 728 opts = ', '.join([i[1] for i in vals[1]])
729 729 ui.write('%s: %s\n' % (cmd, opts))
730 730
731 731 def debugcomplete(ui, cmd='', **opts):
732 732 """returns the completion list associated with the given command"""
733 733
734 734 if opts.get('options'):
735 735 options = []
736 736 otables = [globalopts]
737 737 if cmd:
738 738 aliases, entry = cmdutil.findcmd(cmd, table, False)
739 739 otables.append(entry[1])
740 740 for t in otables:
741 741 for o in t:
742 742 if o[0]:
743 743 options.append('-%s' % o[0])
744 744 options.append('--%s' % o[1])
745 745 ui.write("%s\n" % "\n".join(options))
746 746 return
747 747
748 748 cmdlist = cmdutil.findpossible(cmd, table)
749 749 if ui.verbose:
750 750 cmdlist = [' '.join(c[0]) for c in cmdlist.values()]
751 751 ui.write("%s\n" % "\n".join(sorted(cmdlist)))
752 752
753 753 def debugfsinfo(ui, path = "."):
754 754 open('.debugfsinfo', 'w').write('')
755 755 ui.write('exec: %s\n' % (util.checkexec(path) and 'yes' or 'no'))
756 756 ui.write('symlink: %s\n' % (util.checklink(path) and 'yes' or 'no'))
757 757 ui.write('case-sensitive: %s\n' % (util.checkcase('.debugfsinfo')
758 758 and 'yes' or 'no'))
759 759 os.unlink('.debugfsinfo')
760 760
761 761 def debugrebuildstate(ui, repo, rev="tip"):
762 762 """rebuild the dirstate as it would look like for the given revision"""
763 763 ctx = repo[rev]
764 764 wlock = repo.wlock()
765 765 try:
766 766 repo.dirstate.rebuild(ctx.node(), ctx.manifest())
767 767 finally:
768 768 wlock.release()
769 769
770 770 def debugcheckstate(ui, repo):
771 771 """validate the correctness of the current dirstate"""
772 772 parent1, parent2 = repo.dirstate.parents()
773 773 m1 = repo[parent1].manifest()
774 774 m2 = repo[parent2].manifest()
775 775 errors = 0
776 776 for f in repo.dirstate:
777 777 state = repo.dirstate[f]
778 778 if state in "nr" and f not in m1:
779 779 ui.warn(_("%s in state %s, but not in manifest1\n") % (f, state))
780 780 errors += 1
781 781 if state in "a" and f in m1:
782 782 ui.warn(_("%s in state %s, but also in manifest1\n") % (f, state))
783 783 errors += 1
784 784 if state in "m" and f not in m1 and f not in m2:
785 785 ui.warn(_("%s in state %s, but not in either manifest\n") %
786 786 (f, state))
787 787 errors += 1
788 788 for f in m1:
789 789 state = repo.dirstate[f]
790 790 if state not in "nrm":
791 791 ui.warn(_("%s in manifest1, but listed as state %s") % (f, state))
792 792 errors += 1
793 793 if errors:
794 794 error = _(".hg/dirstate inconsistent with current parent's manifest")
795 795 raise util.Abort(error)
796 796
797 797 def showconfig(ui, repo, *values, **opts):
798 798 """show combined config settings from all hgrc files
799 799
800 800 With no arguments, print names and values of all config items.
801 801
802 802 With one argument of the form section.name, print just the value
803 803 of that config item.
804 804
805 805 With multiple arguments, print names and values of all config
806 806 items with matching section names.
807 807
808 808 With --debug, the source (filename and line number) is printed
809 809 for each config item.
810 810 """
811 811
812 812 untrusted = bool(opts.get('untrusted'))
813 813 if values:
814 814 if len([v for v in values if '.' in v]) > 1:
815 815 raise util.Abort(_('only one config item permitted'))
816 816 for section, name, value in ui.walkconfig(untrusted=untrusted):
817 817 sectname = section + '.' + name
818 818 if values:
819 819 for v in values:
820 820 if v == section:
821 821 ui.debug('%s: ' %
822 822 ui.configsource(section, name, untrusted))
823 823 ui.write('%s=%s\n' % (sectname, value))
824 824 elif v == sectname:
825 825 ui.debug('%s: ' %
826 826 ui.configsource(section, name, untrusted))
827 827 ui.write(value, '\n')
828 828 else:
829 829 ui.debug('%s: ' %
830 830 ui.configsource(section, name, untrusted))
831 831 ui.write('%s=%s\n' % (sectname, value))
832 832
833 833 def debugsetparents(ui, repo, rev1, rev2=None):
834 834 """manually set the parents of the current working directory
835 835
836 836 This is useful for writing repository conversion tools, but should
837 837 be used with care.
838 838 """
839 839
840 840 if not rev2:
841 841 rev2 = hex(nullid)
842 842
843 843 wlock = repo.wlock()
844 844 try:
845 845 repo.dirstate.setparents(repo.lookup(rev1), repo.lookup(rev2))
846 846 finally:
847 847 wlock.release()
848 848
849 849 def debugstate(ui, repo, nodates=None):
850 850 """show the contents of the current dirstate"""
851 851 timestr = ""
852 852 showdate = not nodates
853 853 for file_, ent in sorted(repo.dirstate._map.iteritems()):
854 854 if showdate:
855 855 if ent[3] == -1:
856 856 # Pad or slice to locale representation
857 857 locale_len = len(time.strftime("%Y-%m-%d %H:%M:%S ", time.localtime(0)))
858 858 timestr = 'unset'
859 859 timestr = timestr[:locale_len] + ' '*(locale_len - len(timestr))
860 860 else:
861 861 timestr = time.strftime("%Y-%m-%d %H:%M:%S ", time.localtime(ent[3]))
862 862 if ent[1] & 020000:
863 863 mode = 'lnk'
864 864 else:
865 865 mode = '%3o' % (ent[1] & 0777)
866 866 ui.write("%c %s %10d %s%s\n" % (ent[0], mode, ent[2], timestr, file_))
867 867 for f in repo.dirstate.copies():
868 868 ui.write(_("copy: %s -> %s\n") % (repo.dirstate.copied(f), f))
869 869
870 870 def debugsub(ui, repo, rev=None):
871 871 if rev == '':
872 872 rev = None
873 873 for k,v in sorted(repo[rev].substate.items()):
874 874 ui.write('path %s\n' % k)
875 875 ui.write(' source %s\n' % v[0])
876 876 ui.write(' revision %s\n' % v[1])
877 877
878 878 def debugdata(ui, file_, rev):
879 879 """dump the contents of a data file revision"""
880 880 r = revlog.revlog(util.opener(os.getcwd(), audit=False), file_[:-2] + ".i")
881 881 try:
882 882 ui.write(r.revision(r.lookup(rev)))
883 883 except KeyError:
884 884 raise util.Abort(_('invalid revision identifier %s') % rev)
885 885
886 886 def debugdate(ui, date, range=None, **opts):
887 887 """parse and display a date"""
888 888 if opts["extended"]:
889 889 d = util.parsedate(date, util.extendeddateformats)
890 890 else:
891 891 d = util.parsedate(date)
892 892 ui.write("internal: %s %s\n" % d)
893 893 ui.write("standard: %s\n" % util.datestr(d))
894 894 if range:
895 895 m = util.matchdate(range)
896 896 ui.write("match: %s\n" % m(d[0]))
897 897
898 898 def debugindex(ui, file_):
899 899 """dump the contents of an index file"""
900 900 r = revlog.revlog(util.opener(os.getcwd(), audit=False), file_)
901 901 ui.write(" rev offset length base linkrev"
902 902 " nodeid p1 p2\n")
903 903 for i in r:
904 904 node = r.node(i)
905 905 try:
906 906 pp = r.parents(node)
907 907 except:
908 908 pp = [nullid, nullid]
909 909 ui.write("% 6d % 9d % 7d % 6d % 7d %s %s %s\n" % (
910 910 i, r.start(i), r.length(i), r.base(i), r.linkrev(i),
911 911 short(node), short(pp[0]), short(pp[1])))
912 912
913 913 def debugindexdot(ui, file_):
914 914 """dump an index DAG as a graphviz dot file"""
915 915 r = revlog.revlog(util.opener(os.getcwd(), audit=False), file_)
916 916 ui.write("digraph G {\n")
917 917 for i in r:
918 918 node = r.node(i)
919 919 pp = r.parents(node)
920 920 ui.write("\t%d -> %d\n" % (r.rev(pp[0]), i))
921 921 if pp[1] != nullid:
922 922 ui.write("\t%d -> %d\n" % (r.rev(pp[1]), i))
923 923 ui.write("}\n")
924 924
925 925 def debuginstall(ui):
926 926 '''test Mercurial installation'''
927 927
928 928 def writetemp(contents):
929 929 (fd, name) = tempfile.mkstemp(prefix="hg-debuginstall-")
930 930 f = os.fdopen(fd, "wb")
931 931 f.write(contents)
932 932 f.close()
933 933 return name
934 934
935 935 problems = 0
936 936
937 937 # encoding
938 938 ui.status(_("Checking encoding (%s)...\n") % encoding.encoding)
939 939 try:
940 940 encoding.fromlocal("test")
941 941 except util.Abort, inst:
942 942 ui.write(" %s\n" % inst)
943 943 ui.write(_(" (check that your locale is properly set)\n"))
944 944 problems += 1
945 945
946 946 # compiled modules
947 947 ui.status(_("Checking extensions...\n"))
948 948 try:
949 949 import bdiff, mpatch, base85
950 950 except Exception, inst:
951 951 ui.write(" %s\n" % inst)
952 952 ui.write(_(" One or more extensions could not be found"))
953 953 ui.write(_(" (check that you compiled the extensions)\n"))
954 954 problems += 1
955 955
956 956 # templates
957 957 ui.status(_("Checking templates...\n"))
958 958 try:
959 959 import templater
960 960 templater.templater(templater.templatepath("map-cmdline.default"))
961 961 except Exception, inst:
962 962 ui.write(" %s\n" % inst)
963 963 ui.write(_(" (templates seem to have been installed incorrectly)\n"))
964 964 problems += 1
965 965
966 966 # patch
967 967 ui.status(_("Checking patch...\n"))
968 968 patchproblems = 0
969 969 a = "1\n2\n3\n4\n"
970 970 b = "1\n2\n3\ninsert\n4\n"
971 971 fa = writetemp(a)
972 972 d = mdiff.unidiff(a, None, b, None, os.path.basename(fa),
973 973 os.path.basename(fa))
974 974 fd = writetemp(d)
975 975
976 976 files = {}
977 977 try:
978 978 patch.patch(fd, ui, cwd=os.path.dirname(fa), files=files)
979 979 except util.Abort, e:
980 980 ui.write(_(" patch call failed:\n"))
981 981 ui.write(" " + str(e) + "\n")
982 982 patchproblems += 1
983 983 else:
984 984 if list(files) != [os.path.basename(fa)]:
985 985 ui.write(_(" unexpected patch output!\n"))
986 986 patchproblems += 1
987 987 a = open(fa).read()
988 988 if a != b:
989 989 ui.write(_(" patch test failed!\n"))
990 990 patchproblems += 1
991 991
992 992 if patchproblems:
993 993 if ui.config('ui', 'patch'):
994 994 ui.write(_(" (Current patch tool may be incompatible with patch,"
995 995 " or misconfigured. Please check your .hgrc file)\n"))
996 996 else:
997 997 ui.write(_(" Internal patcher failure, please report this error"
998 998 " to http://mercurial.selenic.com/bts/\n"))
999 999 problems += patchproblems
1000 1000
1001 1001 os.unlink(fa)
1002 1002 os.unlink(fd)
1003 1003
1004 1004 # editor
1005 1005 ui.status(_("Checking commit editor...\n"))
1006 1006 editor = ui.geteditor()
1007 1007 cmdpath = util.find_exe(editor) or util.find_exe(editor.split()[0])
1008 1008 if not cmdpath:
1009 1009 if editor == 'vi':
1010 1010 ui.write(_(" No commit editor set and can't find vi in PATH\n"))
1011 1011 ui.write(_(" (specify a commit editor in your .hgrc file)\n"))
1012 1012 else:
1013 1013 ui.write(_(" Can't find editor '%s' in PATH\n") % editor)
1014 1014 ui.write(_(" (specify a commit editor in your .hgrc file)\n"))
1015 1015 problems += 1
1016 1016
1017 1017 # check username
1018 1018 ui.status(_("Checking username...\n"))
1019 1019 user = os.environ.get("HGUSER")
1020 1020 if user is None:
1021 1021 user = ui.config("ui", "username")
1022 1022 if user is None:
1023 1023 user = os.environ.get("EMAIL")
1024 1024 if not user:
1025 1025 ui.warn(" ")
1026 1026 ui.username()
1027 1027 ui.write(_(" (specify a username in your .hgrc file)\n"))
1028 1028
1029 1029 if not problems:
1030 1030 ui.status(_("No problems detected\n"))
1031 1031 else:
1032 1032 ui.write(_("%s problems detected,"
1033 1033 " please check your install!\n") % problems)
1034 1034
1035 1035 return problems
1036 1036
1037 1037 def debugrename(ui, repo, file1, *pats, **opts):
1038 1038 """dump rename information"""
1039 1039
1040 1040 ctx = repo[opts.get('rev')]
1041 1041 m = cmdutil.match(repo, (file1,) + pats, opts)
1042 1042 for abs in ctx.walk(m):
1043 1043 fctx = ctx[abs]
1044 1044 o = fctx.filelog().renamed(fctx.filenode())
1045 1045 rel = m.rel(abs)
1046 1046 if o:
1047 1047 ui.write(_("%s renamed from %s:%s\n") % (rel, o[0], hex(o[1])))
1048 1048 else:
1049 1049 ui.write(_("%s not renamed\n") % rel)
1050 1050
1051 1051 def debugwalk(ui, repo, *pats, **opts):
1052 1052 """show how files match on given patterns"""
1053 1053 m = cmdutil.match(repo, pats, opts)
1054 1054 items = list(repo.walk(m))
1055 1055 if not items:
1056 1056 return
1057 1057 fmt = 'f %%-%ds %%-%ds %%s' % (
1058 1058 max([len(abs) for abs in items]),
1059 1059 max([len(m.rel(abs)) for abs in items]))
1060 1060 for abs in items:
1061 1061 line = fmt % (abs, m.rel(abs), m.exact(abs) and 'exact' or '')
1062 1062 ui.write("%s\n" % line.rstrip())
1063 1063
1064 1064 def diff(ui, repo, *pats, **opts):
1065 1065 """diff repository (or selected files)
1066 1066
1067 1067 Show differences between revisions for the specified files.
1068 1068
1069 1069 Differences between files are shown using the unified diff format.
1070 1070
1071 1071 NOTE: diff may generate unexpected results for merges, as it will
1072 1072 default to comparing against the working directory's first parent
1073 1073 changeset if no revisions are specified.
1074 1074
1075 1075 When two revision arguments are given, then changes are shown
1076 1076 between those revisions. If only one revision is specified then
1077 1077 that revision is compared to the working directory, and, when no
1078 1078 revisions are specified, the working directory files are compared
1079 1079 to its parent.
1080 1080
1081 1081 Without the -a/--text option, diff will avoid generating diffs of
1082 1082 files it detects as binary. With -a, diff will generate a diff
1083 1083 anyway, probably with undesirable results.
1084 1084
1085 1085 Use the -g/--git option to generate diffs in the git extended diff
1086 1086 format. For more information, read 'hg help diffs'.
1087 1087 """
1088 1088
1089 1089 revs = opts.get('rev')
1090 1090 change = opts.get('change')
1091 1091
1092 1092 if revs and change:
1093 1093 msg = _('cannot specify --rev and --change at the same time')
1094 1094 raise util.Abort(msg)
1095 1095 elif change:
1096 1096 node2 = repo.lookup(change)
1097 1097 node1 = repo[node2].parents()[0].node()
1098 1098 else:
1099 1099 node1, node2 = cmdutil.revpair(repo, revs)
1100 1100
1101 1101 m = cmdutil.match(repo, pats, opts)
1102 1102 it = patch.diff(repo, node1, node2, match=m, opts=patch.diffopts(ui, opts))
1103 1103 for chunk in it:
1104 1104 ui.write(chunk)
1105 1105
1106 1106 def export(ui, repo, *changesets, **opts):
1107 1107 """dump the header and diffs for one or more changesets
1108 1108
1109 1109 Print the changeset header and diffs for one or more revisions.
1110 1110
1111 1111 The information shown in the changeset header is: author,
1112 1112 changeset hash, parent(s) and commit comment.
1113 1113
1114 1114 NOTE: export may generate unexpected diff output for merge
1115 1115 changesets, as it will compare the merge changeset against its
1116 1116 first parent only.
1117 1117
1118 1118 Output may be to a file, in which case the name of the file is
1119 1119 given using a format string. The formatting rules are as follows::
1120 1120
1121 1121 %% literal "%" character
1122 1122 %H changeset hash (40 bytes of hexadecimal)
1123 1123 %N number of patches being generated
1124 1124 %R changeset revision number
1125 1125 %b basename of the exporting repository
1126 1126 %h short-form changeset hash (12 bytes of hexadecimal)
1127 1127 %n zero-padded sequence number, starting at 1
1128 1128 %r zero-padded changeset revision number
1129 1129
1130 1130 Without the -a/--text option, export will avoid generating diffs
1131 1131 of files it detects as binary. With -a, export will generate a
1132 1132 diff anyway, probably with undesirable results.
1133 1133
1134 1134 Use the -g/--git option to generate diffs in the git extended diff
1135 1135 format. See 'hg help diffs' for more information.
1136 1136
1137 1137 With the --switch-parent option, the diff will be against the
1138 1138 second parent. It can be useful to review a merge.
1139 1139 """
1140 1140 if not changesets:
1141 1141 raise util.Abort(_("export requires at least one changeset"))
1142 1142 revs = cmdutil.revrange(repo, changesets)
1143 1143 if len(revs) > 1:
1144 1144 ui.note(_('exporting patches:\n'))
1145 1145 else:
1146 1146 ui.note(_('exporting patch:\n'))
1147 1147 patch.export(repo, revs, template=opts.get('output'),
1148 1148 switch_parent=opts.get('switch_parent'),
1149 1149 opts=patch.diffopts(ui, opts))
1150 1150
1151 1151 def forget(ui, repo, *pats, **opts):
1152 1152 """forget the specified files on the next commit
1153 1153
1154 1154 Mark the specified files so they will no longer be tracked
1155 1155 after the next commit.
1156 1156
1157 1157 This only removes files from the current branch, not from the
1158 1158 entire project history, and it does not delete them from the
1159 1159 working directory.
1160 1160
1161 1161 To undo a forget before the next commit, see hg add.
1162 1162 """
1163 1163
1164 1164 if not pats:
1165 1165 raise util.Abort(_('no files specified'))
1166 1166
1167 1167 m = cmdutil.match(repo, pats, opts)
1168 1168 s = repo.status(match=m, clean=True)
1169 1169 forget = sorted(s[0] + s[1] + s[3] + s[6])
1170 1170
1171 1171 for f in m.files():
1172 1172 if f not in repo.dirstate and not os.path.isdir(m.rel(f)):
1173 1173 ui.warn(_('not removing %s: file is already untracked\n')
1174 1174 % m.rel(f))
1175 1175
1176 1176 for f in forget:
1177 1177 if ui.verbose or not m.exact(f):
1178 1178 ui.status(_('removing %s\n') % m.rel(f))
1179 1179
1180 1180 repo.remove(forget, unlink=False)
1181 1181
1182 1182 def grep(ui, repo, pattern, *pats, **opts):
1183 1183 """search for a pattern in specified files and revisions
1184 1184
1185 1185 Search revisions of files for a regular expression.
1186 1186
1187 1187 This command behaves differently than Unix grep. It only accepts
1188 1188 Python/Perl regexps. It searches repository history, not the
1189 1189 working directory. It always prints the revision number in which a
1190 1190 match appears.
1191 1191
1192 1192 By default, grep only prints output for the first revision of a
1193 1193 file in which it finds a match. To get it to print every revision
1194 1194 that contains a change in match status ("-" for a match that
1195 1195 becomes a non-match, or "+" for a non-match that becomes a match),
1196 1196 use the --all flag.
1197 1197 """
1198 1198 reflags = 0
1199 1199 if opts.get('ignore_case'):
1200 1200 reflags |= re.I
1201 1201 try:
1202 1202 regexp = re.compile(pattern, reflags)
1203 1203 except Exception, inst:
1204 1204 ui.warn(_("grep: invalid match pattern: %s\n") % inst)
1205 1205 return None
1206 1206 sep, eol = ':', '\n'
1207 1207 if opts.get('print0'):
1208 1208 sep = eol = '\0'
1209 1209
1210 1210 getfile = util.lrucachefunc(repo.file)
1211 1211
1212 1212 def matchlines(body):
1213 1213 begin = 0
1214 1214 linenum = 0
1215 1215 while True:
1216 1216 match = regexp.search(body, begin)
1217 1217 if not match:
1218 1218 break
1219 1219 mstart, mend = match.span()
1220 1220 linenum += body.count('\n', begin, mstart) + 1
1221 1221 lstart = body.rfind('\n', begin, mstart) + 1 or begin
1222 1222 begin = body.find('\n', mend) + 1 or len(body)
1223 1223 lend = begin - 1
1224 1224 yield linenum, mstart - lstart, mend - lstart, body[lstart:lend]
1225 1225
1226 1226 class linestate(object):
1227 1227 def __init__(self, line, linenum, colstart, colend):
1228 1228 self.line = line
1229 1229 self.linenum = linenum
1230 1230 self.colstart = colstart
1231 1231 self.colend = colend
1232 1232
1233 1233 def __hash__(self):
1234 1234 return hash((self.linenum, self.line))
1235 1235
1236 1236 def __eq__(self, other):
1237 1237 return self.line == other.line
1238 1238
1239 1239 matches = {}
1240 1240 copies = {}
1241 1241 def grepbody(fn, rev, body):
1242 1242 matches[rev].setdefault(fn, [])
1243 1243 m = matches[rev][fn]
1244 1244 for lnum, cstart, cend, line in matchlines(body):
1245 1245 s = linestate(line, lnum, cstart, cend)
1246 1246 m.append(s)
1247 1247
1248 1248 def difflinestates(a, b):
1249 1249 sm = difflib.SequenceMatcher(None, a, b)
1250 1250 for tag, alo, ahi, blo, bhi in sm.get_opcodes():
1251 1251 if tag == 'insert':
1252 1252 for i in xrange(blo, bhi):
1253 1253 yield ('+', b[i])
1254 1254 elif tag == 'delete':
1255 1255 for i in xrange(alo, ahi):
1256 1256 yield ('-', a[i])
1257 1257 elif tag == 'replace':
1258 1258 for i in xrange(alo, ahi):
1259 1259 yield ('-', a[i])
1260 1260 for i in xrange(blo, bhi):
1261 1261 yield ('+', b[i])
1262 1262
1263 1263 def display(fn, r, pstates, states):
1264 1264 datefunc = ui.quiet and util.shortdate or util.datestr
1265 1265 found = False
1266 1266 filerevmatches = {}
1267 1267 if opts.get('all'):
1268 1268 iter = difflinestates(pstates, states)
1269 1269 else:
1270 1270 iter = [('', l) for l in states]
1271 1271 for change, l in iter:
1272 1272 cols = [fn, str(r)]
1273 1273 if opts.get('line_number'):
1274 1274 cols.append(str(l.linenum))
1275 1275 if opts.get('all'):
1276 1276 cols.append(change)
1277 1277 if opts.get('user'):
1278 cols.append(ui.shortuser(get(r)[1]))
1278 cols.append(ui.shortuser(get(r).user()))
1279 1279 if opts.get('date'):
1280 cols.append(datefunc(get(r)[2]))
1280 cols.append(datefunc(get(r).date()))
1281 1281 if opts.get('files_with_matches'):
1282 1282 c = (fn, r)
1283 1283 if c in filerevmatches:
1284 1284 continue
1285 1285 filerevmatches[c] = 1
1286 1286 else:
1287 1287 cols.append(l.line)
1288 1288 ui.write(sep.join(cols), eol)
1289 1289 found = True
1290 1290 return found
1291 1291
1292 1292 skip = {}
1293 1293 revfiles = {}
1294 get = util.cachefunc(lambda r: repo[r].changeset())
1294 get = util.cachefunc(lambda r: repo[r])
1295 1295 changeiter, matchfn = cmdutil.walkchangerevs(ui, repo, pats, get, opts)
1296 1296 found = False
1297 1297 follow = opts.get('follow')
1298 1298 for st, rev, fns in changeiter:
1299 1299 if st == 'window':
1300 1300 matches.clear()
1301 1301 revfiles.clear()
1302 1302 elif st == 'add':
1303 ctx = repo[rev]
1303 ctx = get(rev)
1304 1304 pctx = ctx.parents()[0]
1305 1305 parent = pctx.rev()
1306 1306 matches.setdefault(rev, {})
1307 1307 matches.setdefault(parent, {})
1308 1308 files = revfiles.setdefault(rev, [])
1309 1309 for fn in fns:
1310 1310 flog = getfile(fn)
1311 1311 try:
1312 1312 fnode = ctx.filenode(fn)
1313 1313 except error.LookupError:
1314 1314 continue
1315 1315
1316 1316 copied = flog.renamed(fnode)
1317 1317 copy = follow and copied and copied[0]
1318 1318 if copy:
1319 1319 copies.setdefault(rev, {})[fn] = copy
1320 1320 if fn in skip:
1321 1321 if copy:
1322 1322 skip[copy] = True
1323 1323 continue
1324 1324 files.append(fn)
1325 1325
1326 1326 if not matches[rev].has_key(fn):
1327 1327 grepbody(fn, rev, flog.read(fnode))
1328 1328
1329 1329 pfn = copy or fn
1330 1330 if not matches[parent].has_key(pfn):
1331 1331 try:
1332 1332 fnode = pctx.filenode(pfn)
1333 1333 grepbody(pfn, parent, flog.read(fnode))
1334 1334 except error.LookupError:
1335 1335 pass
1336 1336 elif st == 'iter':
1337 parent = repo[rev].parents()[0].rev()
1337 parent = get(rev).parents()[0].rev()
1338 1338 for fn in sorted(revfiles.get(rev, [])):
1339 1339 states = matches[rev][fn]
1340 1340 copy = copies.get(rev, {}).get(fn)
1341 1341 if fn in skip:
1342 1342 if copy:
1343 1343 skip[copy] = True
1344 1344 continue
1345 1345 pstates = matches.get(parent, {}).get(copy or fn, [])
1346 1346 if pstates or states:
1347 1347 r = display(fn, rev, pstates, states)
1348 1348 found = found or r
1349 1349 if r and not opts.get('all'):
1350 1350 skip[fn] = True
1351 1351 if copy:
1352 1352 skip[copy] = True
1353 1353
1354 1354 def heads(ui, repo, *branchrevs, **opts):
1355 1355 """show current repository heads or show branch heads
1356 1356
1357 1357 With no arguments, show all repository head changesets.
1358 1358
1359 1359 Repository "heads" are changesets that don't have child
1360 1360 changesets. They are where development generally takes place and
1361 1361 are the usual targets for update and merge operations.
1362 1362
1363 1363 If one or more REV is given, the "branch heads" will be shown for
1364 1364 the named branch associated with that revision. The name of the
1365 1365 branch is called the revision's branch tag.
1366 1366
1367 1367 Branch heads are revisions on a given named branch that do not have
1368 1368 any descendants on the same branch. A branch head could be a true head
1369 1369 or it could be the last changeset on a branch before a new branch
1370 1370 was created. If none of the branch heads are true heads, the branch
1371 1371 is considered inactive. If -c/--closed is specified, also show branch
1372 1372 heads marked closed (see hg commit --close-branch).
1373 1373
1374 1374 If STARTREV is specified only those heads (or branch heads) that
1375 1375 are descendants of STARTREV will be displayed.
1376 1376 """
1377 1377 if opts.get('rev'):
1378 1378 start = repo.lookup(opts['rev'])
1379 1379 else:
1380 1380 start = None
1381 1381 closed = opts.get('closed')
1382 1382 hideinactive, _heads = opts.get('active'), None
1383 1383 if not branchrevs:
1384 1384 if closed:
1385 1385 raise error.Abort(_('you must specify a branch to use --closed'))
1386 1386 # Assume we're looking repo-wide heads if no revs were specified.
1387 1387 heads = repo.heads(start)
1388 1388 else:
1389 1389 if hideinactive:
1390 1390 _heads = repo.heads(start)
1391 1391 heads = []
1392 1392 visitedset = set()
1393 1393 for branchrev in branchrevs:
1394 1394 branch = repo[branchrev].branch()
1395 1395 if branch in visitedset:
1396 1396 continue
1397 1397 visitedset.add(branch)
1398 1398 bheads = repo.branchheads(branch, start, closed=closed)
1399 1399 if not bheads:
1400 1400 if not opts.get('rev'):
1401 1401 ui.warn(_("no open branch heads on branch %s\n") % branch)
1402 1402 elif branch != branchrev:
1403 1403 ui.warn(_("no changes on branch %s containing %s are "
1404 1404 "reachable from %s\n")
1405 1405 % (branch, branchrev, opts.get('rev')))
1406 1406 else:
1407 1407 ui.warn(_("no changes on branch %s are reachable from %s\n")
1408 1408 % (branch, opts.get('rev')))
1409 1409 if hideinactive:
1410 1410 bheads = [bhead for bhead in bheads if bhead in _heads]
1411 1411 heads.extend(bheads)
1412 1412 if not heads:
1413 1413 return 1
1414 1414 displayer = cmdutil.show_changeset(ui, repo, opts)
1415 1415 for n in heads:
1416 1416 displayer.show(repo[n])
1417 1417
1418 1418 def help_(ui, name=None, with_version=False):
1419 1419 """show help for a given topic or a help overview
1420 1420
1421 1421 With no arguments, print a list of commands with short help messages.
1422 1422
1423 1423 Given a topic, extension, or command name, print help for that
1424 1424 topic."""
1425 1425 option_lists = []
1426 1426 textwidth = util.termwidth() - 2
1427 1427
1428 1428 def addglobalopts(aliases):
1429 1429 if ui.verbose:
1430 1430 option_lists.append((_("global options:"), globalopts))
1431 1431 if name == 'shortlist':
1432 1432 option_lists.append((_('use "hg help" for the full list '
1433 1433 'of commands'), ()))
1434 1434 else:
1435 1435 if name == 'shortlist':
1436 1436 msg = _('use "hg help" for the full list of commands '
1437 1437 'or "hg -v" for details')
1438 1438 elif aliases:
1439 1439 msg = _('use "hg -v help%s" to show aliases and '
1440 1440 'global options') % (name and " " + name or "")
1441 1441 else:
1442 1442 msg = _('use "hg -v help %s" to show global options') % name
1443 1443 option_lists.append((msg, ()))
1444 1444
1445 1445 def helpcmd(name):
1446 1446 if with_version:
1447 1447 version_(ui)
1448 1448 ui.write('\n')
1449 1449
1450 1450 try:
1451 1451 aliases, i = cmdutil.findcmd(name, table, False)
1452 1452 except error.AmbiguousCommand, inst:
1453 1453 # py3k fix: except vars can't be used outside the scope of the
1454 1454 # except block, nor can be used inside a lambda. python issue4617
1455 1455 prefix = inst.args[0]
1456 1456 select = lambda c: c.lstrip('^').startswith(prefix)
1457 1457 helplist(_('list of commands:\n\n'), select)
1458 1458 return
1459 1459
1460 1460 # synopsis
1461 1461 if len(i) > 2:
1462 1462 if i[2].startswith('hg'):
1463 1463 ui.write("%s\n" % i[2])
1464 1464 else:
1465 1465 ui.write('hg %s %s\n' % (aliases[0], i[2]))
1466 1466 else:
1467 1467 ui.write('hg %s\n' % aliases[0])
1468 1468
1469 1469 # aliases
1470 1470 if not ui.quiet and len(aliases) > 1:
1471 1471 ui.write(_("\naliases: %s\n") % ', '.join(aliases[1:]))
1472 1472
1473 1473 # description
1474 1474 doc = gettext(i[0].__doc__)
1475 1475 if not doc:
1476 1476 doc = _("(no help text available)")
1477 1477 if ui.quiet:
1478 1478 doc = doc.splitlines()[0]
1479 1479 ui.write("\n%s\n" % minirst.format(doc, textwidth))
1480 1480
1481 1481 if not ui.quiet:
1482 1482 # options
1483 1483 if i[1]:
1484 1484 option_lists.append((_("options:\n"), i[1]))
1485 1485
1486 1486 addglobalopts(False)
1487 1487
1488 1488 def helplist(header, select=None):
1489 1489 h = {}
1490 1490 cmds = {}
1491 1491 for c, e in table.iteritems():
1492 1492 f = c.split("|", 1)[0]
1493 1493 if select and not select(f):
1494 1494 continue
1495 1495 if (not select and name != 'shortlist' and
1496 1496 e[0].__module__ != __name__):
1497 1497 continue
1498 1498 if name == "shortlist" and not f.startswith("^"):
1499 1499 continue
1500 1500 f = f.lstrip("^")
1501 1501 if not ui.debugflag and f.startswith("debug"):
1502 1502 continue
1503 1503 doc = e[0].__doc__
1504 1504 if doc and 'DEPRECATED' in doc and not ui.verbose:
1505 1505 continue
1506 1506 doc = gettext(doc)
1507 1507 if not doc:
1508 1508 doc = _("(no help text available)")
1509 1509 h[f] = doc.splitlines()[0].rstrip()
1510 1510 cmds[f] = c.lstrip("^")
1511 1511
1512 1512 if not h:
1513 1513 ui.status(_('no commands defined\n'))
1514 1514 return
1515 1515
1516 1516 ui.status(header)
1517 1517 fns = sorted(h)
1518 1518 m = max(map(len, fns))
1519 1519 for f in fns:
1520 1520 if ui.verbose:
1521 1521 commands = cmds[f].replace("|",", ")
1522 1522 ui.write(" %s:\n %s\n"%(commands, h[f]))
1523 1523 else:
1524 1524 ui.write(' %-*s %s\n' % (m, f, util.wrap(h[f], m + 4)))
1525 1525
1526 1526 if name != 'shortlist':
1527 1527 exts, maxlength = extensions.enabled()
1528 1528 text = help.listexts(_('enabled extensions:'), exts, maxlength)
1529 1529 if text:
1530 1530 ui.write("\n%s\n" % minirst.format(text, textwidth))
1531 1531
1532 1532 if not ui.quiet:
1533 1533 addglobalopts(True)
1534 1534
1535 1535 def helptopic(name):
1536 1536 for names, header, doc in help.helptable:
1537 1537 if name in names:
1538 1538 break
1539 1539 else:
1540 1540 raise error.UnknownCommand(name)
1541 1541
1542 1542 # description
1543 1543 if not doc:
1544 1544 doc = _("(no help text available)")
1545 1545 if hasattr(doc, '__call__'):
1546 1546 doc = doc()
1547 1547
1548 1548 ui.write("%s\n\n" % header)
1549 1549 ui.write("%s\n" % minirst.format(doc, textwidth))
1550 1550
1551 1551 def helpext(name):
1552 1552 try:
1553 1553 mod = extensions.find(name)
1554 1554 except KeyError:
1555 1555 raise error.UnknownCommand(name)
1556 1556
1557 1557 doc = gettext(mod.__doc__) or _('no help text available')
1558 1558 if '\n' not in doc:
1559 1559 head, tail = doc, ""
1560 1560 else:
1561 1561 head, tail = doc.split('\n', 1)
1562 1562 ui.write(_('%s extension - %s\n\n') % (name.split('.')[-1], head))
1563 1563 if tail:
1564 1564 ui.write(minirst.format(tail, textwidth))
1565 1565 ui.status('\n\n')
1566 1566
1567 1567 try:
1568 1568 ct = mod.cmdtable
1569 1569 except AttributeError:
1570 1570 ct = {}
1571 1571
1572 1572 modcmds = set([c.split('|', 1)[0] for c in ct])
1573 1573 helplist(_('list of commands:\n\n'), modcmds.__contains__)
1574 1574
1575 1575 if name and name != 'shortlist':
1576 1576 i = None
1577 1577 for f in (helptopic, helpcmd, helpext):
1578 1578 try:
1579 1579 f(name)
1580 1580 i = None
1581 1581 break
1582 1582 except error.UnknownCommand, inst:
1583 1583 i = inst
1584 1584 if i:
1585 1585 raise i
1586 1586
1587 1587 else:
1588 1588 # program name
1589 1589 if ui.verbose or with_version:
1590 1590 version_(ui)
1591 1591 else:
1592 1592 ui.status(_("Mercurial Distributed SCM\n"))
1593 1593 ui.status('\n')
1594 1594
1595 1595 # list of commands
1596 1596 if name == "shortlist":
1597 1597 header = _('basic commands:\n\n')
1598 1598 else:
1599 1599 header = _('list of commands:\n\n')
1600 1600
1601 1601 helplist(header)
1602 1602
1603 1603 # list all option lists
1604 1604 opt_output = []
1605 1605 for title, options in option_lists:
1606 1606 opt_output.append(("\n%s" % title, None))
1607 1607 for shortopt, longopt, default, desc in options:
1608 1608 if "DEPRECATED" in desc and not ui.verbose: continue
1609 1609 opt_output.append(("%2s%s" % (shortopt and "-%s" % shortopt,
1610 1610 longopt and " --%s" % longopt),
1611 1611 "%s%s" % (desc,
1612 1612 default
1613 1613 and _(" (default: %s)") % default
1614 1614 or "")))
1615 1615
1616 1616 if not name:
1617 1617 ui.write(_("\nadditional help topics:\n\n"))
1618 1618 topics = []
1619 1619 for names, header, doc in help.helptable:
1620 1620 names = [(-len(name), name) for name in names]
1621 1621 names.sort()
1622 1622 topics.append((names[0][1], header))
1623 1623 topics_len = max([len(s[0]) for s in topics])
1624 1624 for t, desc in topics:
1625 1625 ui.write(" %-*s %s\n" % (topics_len, t, desc))
1626 1626
1627 1627 if opt_output:
1628 1628 opts_len = max([len(line[0]) for line in opt_output if line[1]] or [0])
1629 1629 for first, second in opt_output:
1630 1630 if second:
1631 1631 second = util.wrap(second, opts_len + 3)
1632 1632 ui.write(" %-*s %s\n" % (opts_len, first, second))
1633 1633 else:
1634 1634 ui.write("%s\n" % first)
1635 1635
1636 1636 def identify(ui, repo, source=None,
1637 1637 rev=None, num=None, id=None, branch=None, tags=None):
1638 1638 """identify the working copy or specified revision
1639 1639
1640 1640 With no revision, print a summary of the current state of the
1641 1641 repository.
1642 1642
1643 1643 Specifying a path to a repository root or Mercurial bundle will
1644 1644 cause lookup to operate on that repository/bundle.
1645 1645
1646 1646 This summary identifies the repository state using one or two
1647 1647 parent hash identifiers, followed by a "+" if there are
1648 1648 uncommitted changes in the working directory, a list of tags for
1649 1649 this revision and a branch name for non-default branches.
1650 1650 """
1651 1651
1652 1652 if not repo and not source:
1653 1653 raise util.Abort(_("There is no Mercurial repository here "
1654 1654 "(.hg not found)"))
1655 1655
1656 1656 hexfunc = ui.debugflag and hex or short
1657 1657 default = not (num or id or branch or tags)
1658 1658 output = []
1659 1659
1660 1660 revs = []
1661 1661 if source:
1662 1662 source, revs, checkout = hg.parseurl(ui.expandpath(source), [])
1663 1663 repo = hg.repository(ui, source)
1664 1664
1665 1665 if not repo.local():
1666 1666 if not rev and revs:
1667 1667 rev = revs[0]
1668 1668 if not rev:
1669 1669 rev = "tip"
1670 1670 if num or branch or tags:
1671 1671 raise util.Abort(
1672 1672 "can't query remote revision number, branch, or tags")
1673 1673 output = [hexfunc(repo.lookup(rev))]
1674 1674 elif not rev:
1675 1675 ctx = repo[None]
1676 1676 parents = ctx.parents()
1677 1677 changed = False
1678 1678 if default or id or num:
1679 1679 changed = ctx.files() + ctx.deleted()
1680 1680 if default or id:
1681 1681 output = ["%s%s" % ('+'.join([hexfunc(p.node()) for p in parents]),
1682 1682 (changed) and "+" or "")]
1683 1683 if num:
1684 1684 output.append("%s%s" % ('+'.join([str(p.rev()) for p in parents]),
1685 1685 (changed) and "+" or ""))
1686 1686 else:
1687 1687 ctx = repo[rev]
1688 1688 if default or id:
1689 1689 output = [hexfunc(ctx.node())]
1690 1690 if num:
1691 1691 output.append(str(ctx.rev()))
1692 1692
1693 1693 if repo.local() and default and not ui.quiet:
1694 1694 b = encoding.tolocal(ctx.branch())
1695 1695 if b != 'default':
1696 1696 output.append("(%s)" % b)
1697 1697
1698 1698 # multiple tags for a single parent separated by '/'
1699 1699 t = "/".join(ctx.tags())
1700 1700 if t:
1701 1701 output.append(t)
1702 1702
1703 1703 if branch:
1704 1704 output.append(encoding.tolocal(ctx.branch()))
1705 1705
1706 1706 if tags:
1707 1707 output.extend(ctx.tags())
1708 1708
1709 1709 ui.write("%s\n" % ' '.join(output))
1710 1710
1711 1711 def import_(ui, repo, patch1, *patches, **opts):
1712 1712 """import an ordered set of patches
1713 1713
1714 1714 Import a list of patches and commit them individually.
1715 1715
1716 1716 If there are outstanding changes in the working directory, import
1717 1717 will abort unless given the -f/--force flag.
1718 1718
1719 1719 You can import a patch straight from a mail message. Even patches
1720 1720 as attachments work (to use the body part, it must have type
1721 1721 text/plain or text/x-patch). From and Subject headers of email
1722 1722 message are used as default committer and commit message. All
1723 1723 text/plain body parts before first diff are added to commit
1724 1724 message.
1725 1725
1726 1726 If the imported patch was generated by hg export, user and
1727 1727 description from patch override values from message headers and
1728 1728 body. Values given on command line with -m/--message and -u/--user
1729 1729 override these.
1730 1730
1731 1731 If --exact is specified, import will set the working directory to
1732 1732 the parent of each patch before applying it, and will abort if the
1733 1733 resulting changeset has a different ID than the one recorded in
1734 1734 the patch. This may happen due to character set problems or other
1735 1735 deficiencies in the text patch format.
1736 1736
1737 1737 With -s/--similarity, hg will attempt to discover renames and
1738 1738 copies in the patch in the same way as 'addremove'.
1739 1739
1740 1740 To read a patch from standard input, use "-" as the patch name. If
1741 1741 a URL is specified, the patch will be downloaded from it.
1742 1742 See 'hg help dates' for a list of formats valid for -d/--date.
1743 1743 """
1744 1744 patches = (patch1,) + patches
1745 1745
1746 1746 date = opts.get('date')
1747 1747 if date:
1748 1748 opts['date'] = util.parsedate(date)
1749 1749
1750 1750 try:
1751 1751 sim = float(opts.get('similarity') or 0)
1752 1752 except ValueError:
1753 1753 raise util.Abort(_('similarity must be a number'))
1754 1754 if sim < 0 or sim > 100:
1755 1755 raise util.Abort(_('similarity must be between 0 and 100'))
1756 1756
1757 1757 if opts.get('exact') or not opts.get('force'):
1758 1758 cmdutil.bail_if_changed(repo)
1759 1759
1760 1760 d = opts["base"]
1761 1761 strip = opts["strip"]
1762 1762 wlock = lock = None
1763 1763 try:
1764 1764 wlock = repo.wlock()
1765 1765 lock = repo.lock()
1766 1766 for p in patches:
1767 1767 pf = os.path.join(d, p)
1768 1768
1769 1769 if pf == '-':
1770 1770 ui.status(_("applying patch from stdin\n"))
1771 1771 pf = sys.stdin
1772 1772 else:
1773 1773 ui.status(_("applying %s\n") % p)
1774 1774 pf = url.open(ui, pf)
1775 1775 data = patch.extract(ui, pf)
1776 1776 tmpname, message, user, date, branch, nodeid, p1, p2 = data
1777 1777
1778 1778 if tmpname is None:
1779 1779 raise util.Abort(_('no diffs found'))
1780 1780
1781 1781 try:
1782 1782 cmdline_message = cmdutil.logmessage(opts)
1783 1783 if cmdline_message:
1784 1784 # pickup the cmdline msg
1785 1785 message = cmdline_message
1786 1786 elif message:
1787 1787 # pickup the patch msg
1788 1788 message = message.strip()
1789 1789 else:
1790 1790 # launch the editor
1791 1791 message = None
1792 1792 ui.debug(_('message:\n%s\n') % message)
1793 1793
1794 1794 wp = repo.parents()
1795 1795 if opts.get('exact'):
1796 1796 if not nodeid or not p1:
1797 1797 raise util.Abort(_('not a Mercurial patch'))
1798 1798 p1 = repo.lookup(p1)
1799 1799 p2 = repo.lookup(p2 or hex(nullid))
1800 1800
1801 1801 if p1 != wp[0].node():
1802 1802 hg.clean(repo, p1)
1803 1803 repo.dirstate.setparents(p1, p2)
1804 1804 elif p2:
1805 1805 try:
1806 1806 p1 = repo.lookup(p1)
1807 1807 p2 = repo.lookup(p2)
1808 1808 if p1 == wp[0].node():
1809 1809 repo.dirstate.setparents(p1, p2)
1810 1810 except error.RepoError:
1811 1811 pass
1812 1812 if opts.get('exact') or opts.get('import_branch'):
1813 1813 repo.dirstate.setbranch(branch or 'default')
1814 1814
1815 1815 files = {}
1816 1816 try:
1817 1817 patch.patch(tmpname, ui, strip=strip, cwd=repo.root,
1818 1818 files=files, eolmode=None)
1819 1819 finally:
1820 1820 files = patch.updatedir(ui, repo, files, similarity=sim/100.)
1821 1821 if not opts.get('no_commit'):
1822 1822 m = cmdutil.matchfiles(repo, files or [])
1823 1823 n = repo.commit(message, opts.get('user') or user,
1824 1824 opts.get('date') or date, match=m,
1825 1825 editor=cmdutil.commiteditor)
1826 1826 if opts.get('exact'):
1827 1827 if hex(n) != nodeid:
1828 1828 repo.rollback()
1829 1829 raise util.Abort(_('patch is damaged'
1830 1830 ' or loses information'))
1831 1831 # Force a dirstate write so that the next transaction
1832 1832 # backups an up-do-date file.
1833 1833 repo.dirstate.write()
1834 1834 finally:
1835 1835 os.unlink(tmpname)
1836 1836 finally:
1837 1837 release(lock, wlock)
1838 1838
1839 1839 def incoming(ui, repo, source="default", **opts):
1840 1840 """show new changesets found in source
1841 1841
1842 1842 Show new changesets found in the specified path/URL or the default
1843 1843 pull location. These are the changesets that would have been pulled
1844 1844 if a pull at the time you issued this command.
1845 1845
1846 1846 For remote repository, using --bundle avoids downloading the
1847 1847 changesets twice if the incoming is followed by a pull.
1848 1848
1849 1849 See pull for valid source format details.
1850 1850 """
1851 1851 limit = cmdutil.loglimit(opts)
1852 1852 source, revs, checkout = hg.parseurl(ui.expandpath(source), opts.get('rev'))
1853 1853 other = hg.repository(cmdutil.remoteui(repo, opts), source)
1854 1854 ui.status(_('comparing with %s\n') % url.hidepassword(source))
1855 1855 if revs:
1856 1856 revs = [other.lookup(rev) for rev in revs]
1857 1857 common, incoming, rheads = repo.findcommonincoming(other, heads=revs,
1858 1858 force=opts["force"])
1859 1859 if not incoming:
1860 1860 try:
1861 1861 os.unlink(opts["bundle"])
1862 1862 except:
1863 1863 pass
1864 1864 ui.status(_("no changes found\n"))
1865 1865 return 1
1866 1866
1867 1867 cleanup = None
1868 1868 try:
1869 1869 fname = opts["bundle"]
1870 1870 if fname or not other.local():
1871 1871 # create a bundle (uncompressed if other repo is not local)
1872 1872
1873 1873 if revs is None and other.capable('changegroupsubset'):
1874 1874 revs = rheads
1875 1875
1876 1876 if revs is None:
1877 1877 cg = other.changegroup(incoming, "incoming")
1878 1878 else:
1879 1879 cg = other.changegroupsubset(incoming, revs, 'incoming')
1880 1880 bundletype = other.local() and "HG10BZ" or "HG10UN"
1881 1881 fname = cleanup = changegroup.writebundle(cg, fname, bundletype)
1882 1882 # keep written bundle?
1883 1883 if opts["bundle"]:
1884 1884 cleanup = None
1885 1885 if not other.local():
1886 1886 # use the created uncompressed bundlerepo
1887 1887 other = bundlerepo.bundlerepository(ui, repo.root, fname)
1888 1888
1889 1889 o = other.changelog.nodesbetween(incoming, revs)[0]
1890 1890 if opts.get('newest_first'):
1891 1891 o.reverse()
1892 1892 displayer = cmdutil.show_changeset(ui, other, opts)
1893 1893 count = 0
1894 1894 for n in o:
1895 1895 if count >= limit:
1896 1896 break
1897 1897 parents = [p for p in other.changelog.parents(n) if p != nullid]
1898 1898 if opts.get('no_merges') and len(parents) == 2:
1899 1899 continue
1900 1900 count += 1
1901 1901 displayer.show(other[n])
1902 1902 finally:
1903 1903 if hasattr(other, 'close'):
1904 1904 other.close()
1905 1905 if cleanup:
1906 1906 os.unlink(cleanup)
1907 1907
1908 1908 def init(ui, dest=".", **opts):
1909 1909 """create a new repository in the given directory
1910 1910
1911 1911 Initialize a new repository in the given directory. If the given
1912 1912 directory does not exist, it will be created.
1913 1913
1914 1914 If no directory is given, the current directory is used.
1915 1915
1916 1916 It is possible to specify an ssh:// URL as the destination.
1917 1917 See 'hg help urls' for more information.
1918 1918 """
1919 1919 hg.repository(cmdutil.remoteui(ui, opts), dest, create=1)
1920 1920
1921 1921 def locate(ui, repo, *pats, **opts):
1922 1922 """locate files matching specific patterns
1923 1923
1924 1924 Print files under Mercurial control in the working directory whose
1925 1925 names match the given patterns.
1926 1926
1927 1927 By default, this command searches all directories in the working
1928 1928 directory. To search just the current directory and its
1929 1929 subdirectories, use "--include .".
1930 1930
1931 1931 If no patterns are given to match, this command prints the names
1932 1932 of all files under Mercurial control in the working directory.
1933 1933
1934 1934 If you want to feed the output of this command into the "xargs"
1935 1935 command, use the -0 option to both this command and "xargs". This
1936 1936 will avoid the problem of "xargs" treating single filenames that
1937 1937 contain whitespace as multiple filenames.
1938 1938 """
1939 1939 end = opts.get('print0') and '\0' or '\n'
1940 1940 rev = opts.get('rev') or None
1941 1941
1942 1942 ret = 1
1943 1943 m = cmdutil.match(repo, pats, opts, default='relglob')
1944 1944 m.bad = lambda x,y: False
1945 1945 for abs in repo[rev].walk(m):
1946 1946 if not rev and abs not in repo.dirstate:
1947 1947 continue
1948 1948 if opts.get('fullpath'):
1949 1949 ui.write(repo.wjoin(abs), end)
1950 1950 else:
1951 1951 ui.write(((pats and m.rel(abs)) or abs), end)
1952 1952 ret = 0
1953 1953
1954 1954 return ret
1955 1955
1956 1956 def log(ui, repo, *pats, **opts):
1957 1957 """show revision history of entire repository or files
1958 1958
1959 1959 Print the revision history of the specified files or the entire
1960 1960 project.
1961 1961
1962 1962 File history is shown without following rename or copy history of
1963 1963 files. Use -f/--follow with a filename to follow history across
1964 1964 renames and copies. --follow without a filename will only show
1965 1965 ancestors or descendants of the starting revision. --follow-first
1966 1966 only follows the first parent of merge revisions.
1967 1967
1968 1968 If no revision range is specified, the default is tip:0 unless
1969 1969 --follow is set, in which case the working directory parent is
1970 1970 used as the starting revision.
1971 1971
1972 1972 See 'hg help dates' for a list of formats valid for -d/--date.
1973 1973
1974 1974 By default this command prints revision number and changeset id,
1975 1975 tags, non-trivial parents, user, date and time, and a summary for
1976 1976 each commit. When the -v/--verbose switch is used, the list of
1977 1977 changed files and full commit message are shown.
1978 1978
1979 1979 NOTE: log -p/--patch may generate unexpected diff output for merge
1980 1980 changesets, as it will only compare the merge changeset against
1981 1981 its first parent. Also, only files different from BOTH parents
1982 1982 will appear in files:.
1983 1983 """
1984 1984
1985 get = util.cachefunc(lambda r: repo[r].changeset())
1985 get = util.cachefunc(lambda r: repo[r])
1986 1986 changeiter, matchfn = cmdutil.walkchangerevs(ui, repo, pats, get, opts)
1987 1987
1988 1988 limit = cmdutil.loglimit(opts)
1989 1989 count = 0
1990 1990
1991 1991 if opts.get('copies') and opts.get('rev'):
1992 1992 endrev = max(cmdutil.revrange(repo, opts.get('rev'))) + 1
1993 1993 else:
1994 1994 endrev = len(repo)
1995 1995 rcache = {}
1996 1996 ncache = {}
1997 1997 def getrenamed(fn, rev):
1998 1998 '''looks up all renames for a file (up to endrev) the first
1999 1999 time the file is given. It indexes on the changerev and only
2000 2000 parses the manifest if linkrev != changerev.
2001 2001 Returns rename info for fn at changerev rev.'''
2002 2002 if fn not in rcache:
2003 2003 rcache[fn] = {}
2004 2004 ncache[fn] = {}
2005 2005 fl = repo.file(fn)
2006 2006 for i in fl:
2007 2007 node = fl.node(i)
2008 2008 lr = fl.linkrev(i)
2009 2009 renamed = fl.renamed(node)
2010 2010 rcache[fn][lr] = renamed
2011 2011 if renamed:
2012 2012 ncache[fn][node] = renamed
2013 2013 if lr >= endrev:
2014 2014 break
2015 2015 if rev in rcache[fn]:
2016 2016 return rcache[fn][rev]
2017 2017
2018 2018 # If linkrev != rev (i.e. rev not found in rcache) fallback to
2019 2019 # filectx logic.
2020 2020
2021 2021 try:
2022 2022 return repo[rev][fn].renamed()
2023 2023 except error.LookupError:
2024 2024 pass
2025 2025 return None
2026 2026
2027 2027 df = False
2028 2028 if opts["date"]:
2029 2029 df = util.matchdate(opts["date"])
2030 2030
2031 2031 only_branches = opts.get('only_branch')
2032 2032
2033 2033 displayer = cmdutil.show_changeset(ui, repo, opts, True, matchfn)
2034 2034 for st, rev, fns in changeiter:
2035 2035 if st == 'add':
2036 2036 parents = [p for p in repo.changelog.parentrevs(rev)
2037 2037 if p != nullrev]
2038 2038 if opts.get('no_merges') and len(parents) == 2:
2039 2039 continue
2040 2040 if opts.get('only_merges') and len(parents) != 2:
2041 2041 continue
2042 2042
2043 if only_branches:
2044 revbranch = get(rev)[5]['branch']
2045 if revbranch not in only_branches:
2046 continue
2047
2048 if df:
2049 changes = get(rev)
2050 if not df(changes[2][0]):
2051 continue
2043 ctx = get(rev)
2044 if only_branches and ctx.branch() not in only_branches:
2045 continue
2046
2047 if df and not df(ctx.date()):
2048 continue
2052 2049
2053 2050 if opts.get('keyword'):
2054 changes = get(rev)
2055 2051 miss = 0
2056 2052 for k in [kw.lower() for kw in opts['keyword']]:
2057 if not (k in changes[1].lower() or
2058 k in changes[4].lower() or
2059 k in " ".join(changes[3]).lower()):
2053 if not (k in ctx.user().lower() or
2054 k in ctx.description().lower() or
2055 k in " ".join(ctx.files()[3]).lower()):
2060 2056 miss = 1
2061 2057 break
2062 2058 if miss:
2063 2059 continue
2064 2060
2065 2061 if opts['user']:
2066 changes = get(rev)
2067 if not [k for k in opts['user'] if k in changes[1]]:
2062 if not [k for k in opts['user'] if k in ctx.user()]:
2068 2063 continue
2069 2064
2070 2065 copies = []
2071 2066 if opts.get('copies') and rev:
2072 for fn in get(rev)[3]:
2067 for fn in ctx.files():
2073 2068 rename = getrenamed(fn, rev)
2074 2069 if rename:
2075 2070 copies.append((fn, rename[0]))
2076 displayer.show(context.changectx(repo, rev), copies=copies)
2071
2072 displayer.show(ctx, copies=copies)
2073
2077 2074 elif st == 'iter':
2078 2075 if count == limit: break
2079 2076 if displayer.flush(rev):
2080 2077 count += 1
2081 2078
2082 2079 def manifest(ui, repo, node=None, rev=None):
2083 2080 """output the current or given revision of the project manifest
2084 2081
2085 2082 Print a list of version controlled files for the given revision.
2086 2083 If no revision is given, the first parent of the working directory
2087 2084 is used, or the null revision if no revision is checked out.
2088 2085
2089 2086 With -v, print file permissions, symlink and executable bits.
2090 2087 With --debug, print file revision hashes.
2091 2088 """
2092 2089
2093 2090 if rev and node:
2094 2091 raise util.Abort(_("please specify just one revision"))
2095 2092
2096 2093 if not node:
2097 2094 node = rev
2098 2095
2099 2096 decor = {'l':'644 @ ', 'x':'755 * ', '':'644 '}
2100 2097 ctx = repo[node]
2101 2098 for f in ctx:
2102 2099 if ui.debugflag:
2103 2100 ui.write("%40s " % hex(ctx.manifest()[f]))
2104 2101 if ui.verbose:
2105 2102 ui.write(decor[ctx.flags(f)])
2106 2103 ui.write("%s\n" % f)
2107 2104
2108 2105 def merge(ui, repo, node=None, **opts):
2109 2106 """merge working directory with another revision
2110 2107
2111 2108 The current working directory is updated with all changes made in
2112 2109 the requested revision since the last common predecessor revision.
2113 2110
2114 2111 Files that changed between either parent are marked as changed for
2115 2112 the next commit and a commit must be performed before any further
2116 2113 updates to the repository are allowed. The next commit will have
2117 2114 two parents.
2118 2115
2119 2116 If no revision is specified, the working directory's parent is a
2120 2117 head revision, and the current branch contains exactly one other
2121 2118 head, the other head is merged with by default. Otherwise, an
2122 2119 explicit revision with which to merge with must be provided.
2123 2120 """
2124 2121
2125 2122 if opts.get('rev') and node:
2126 2123 raise util.Abort(_("please specify just one revision"))
2127 2124 if not node:
2128 2125 node = opts.get('rev')
2129 2126
2130 2127 if not node:
2131 2128 branch = repo.changectx(None).branch()
2132 2129 bheads = repo.branchheads(branch)
2133 2130 if len(bheads) > 2:
2134 2131 raise util.Abort(_("branch '%s' has %d heads - "
2135 2132 "please merge with an explicit rev") %
2136 2133 (branch, len(bheads)))
2137 2134
2138 2135 parent = repo.dirstate.parents()[0]
2139 2136 if len(bheads) == 1:
2140 2137 if len(repo.heads()) > 1:
2141 2138 raise util.Abort(_("branch '%s' has one head - "
2142 2139 "please merge with an explicit rev") %
2143 2140 branch)
2144 2141 msg = _('there is nothing to merge')
2145 2142 if parent != repo.lookup(repo[None].branch()):
2146 2143 msg = _('%s - use "hg update" instead') % msg
2147 2144 raise util.Abort(msg)
2148 2145
2149 2146 if parent not in bheads:
2150 2147 raise util.Abort(_('working dir not at a head rev - '
2151 2148 'use "hg update" or merge with an explicit rev'))
2152 2149 node = parent == bheads[0] and bheads[-1] or bheads[0]
2153 2150
2154 2151 if opts.get('preview'):
2155 2152 p1 = repo['.']
2156 2153 p2 = repo[node]
2157 2154 common = p1.ancestor(p2)
2158 2155 roots, heads = [common.node()], [p2.node()]
2159 2156 displayer = cmdutil.show_changeset(ui, repo, opts)
2160 2157 for node in repo.changelog.nodesbetween(roots=roots, heads=heads)[0]:
2161 2158 displayer.show(repo[node])
2162 2159 return 0
2163 2160
2164 2161 return hg.merge(repo, node, force=opts.get('force'))
2165 2162
2166 2163 def outgoing(ui, repo, dest=None, **opts):
2167 2164 """show changesets not found in destination
2168 2165
2169 2166 Show changesets not found in the specified destination repository
2170 2167 or the default push location. These are the changesets that would
2171 2168 be pushed if a push was requested.
2172 2169
2173 2170 See pull for valid destination format details.
2174 2171 """
2175 2172 limit = cmdutil.loglimit(opts)
2176 2173 dest, revs, checkout = hg.parseurl(
2177 2174 ui.expandpath(dest or 'default-push', dest or 'default'), opts.get('rev'))
2178 2175 if revs:
2179 2176 revs = [repo.lookup(rev) for rev in revs]
2180 2177
2181 2178 other = hg.repository(cmdutil.remoteui(repo, opts), dest)
2182 2179 ui.status(_('comparing with %s\n') % url.hidepassword(dest))
2183 2180 o = repo.findoutgoing(other, force=opts.get('force'))
2184 2181 if not o:
2185 2182 ui.status(_("no changes found\n"))
2186 2183 return 1
2187 2184 o = repo.changelog.nodesbetween(o, revs)[0]
2188 2185 if opts.get('newest_first'):
2189 2186 o.reverse()
2190 2187 displayer = cmdutil.show_changeset(ui, repo, opts)
2191 2188 count = 0
2192 2189 for n in o:
2193 2190 if count >= limit:
2194 2191 break
2195 2192 parents = [p for p in repo.changelog.parents(n) if p != nullid]
2196 2193 if opts.get('no_merges') and len(parents) == 2:
2197 2194 continue
2198 2195 count += 1
2199 2196 displayer.show(repo[n])
2200 2197
2201 2198 def parents(ui, repo, file_=None, **opts):
2202 2199 """show the parents of the working directory or revision
2203 2200
2204 2201 Print the working directory's parent revisions. If a revision is
2205 2202 given via -r/--rev, the parent of that revision will be printed.
2206 2203 If a file argument is given, the revision in which the file was
2207 2204 last changed (before the working directory revision or the
2208 2205 argument to --rev if given) is printed.
2209 2206 """
2210 2207 rev = opts.get('rev')
2211 2208 if rev:
2212 2209 ctx = repo[rev]
2213 2210 else:
2214 2211 ctx = repo[None]
2215 2212
2216 2213 if file_:
2217 2214 m = cmdutil.match(repo, (file_,), opts)
2218 2215 if m.anypats() or len(m.files()) != 1:
2219 2216 raise util.Abort(_('can only specify an explicit filename'))
2220 2217 file_ = m.files()[0]
2221 2218 filenodes = []
2222 2219 for cp in ctx.parents():
2223 2220 if not cp:
2224 2221 continue
2225 2222 try:
2226 2223 filenodes.append(cp.filenode(file_))
2227 2224 except error.LookupError:
2228 2225 pass
2229 2226 if not filenodes:
2230 2227 raise util.Abort(_("'%s' not found in manifest!") % file_)
2231 2228 fl = repo.file(file_)
2232 2229 p = [repo.lookup(fl.linkrev(fl.rev(fn))) for fn in filenodes]
2233 2230 else:
2234 2231 p = [cp.node() for cp in ctx.parents()]
2235 2232
2236 2233 displayer = cmdutil.show_changeset(ui, repo, opts)
2237 2234 for n in p:
2238 2235 if n != nullid:
2239 2236 displayer.show(repo[n])
2240 2237
2241 2238 def paths(ui, repo, search=None):
2242 2239 """show aliases for remote repositories
2243 2240
2244 2241 Show definition of symbolic path name NAME. If no name is given,
2245 2242 show definition of all available names.
2246 2243
2247 2244 Path names are defined in the [paths] section of /etc/mercurial/hgrc
2248 2245 and $HOME/.hgrc. If run inside a repository, .hg/hgrc is used, too.
2249 2246
2250 2247 See 'hg help urls' for more information.
2251 2248 """
2252 2249 if search:
2253 2250 for name, path in ui.configitems("paths"):
2254 2251 if name == search:
2255 2252 ui.write("%s\n" % url.hidepassword(path))
2256 2253 return
2257 2254 ui.warn(_("not found!\n"))
2258 2255 return 1
2259 2256 else:
2260 2257 for name, path in ui.configitems("paths"):
2261 2258 ui.write("%s = %s\n" % (name, url.hidepassword(path)))
2262 2259
2263 2260 def postincoming(ui, repo, modheads, optupdate, checkout):
2264 2261 if modheads == 0:
2265 2262 return
2266 2263 if optupdate:
2267 2264 if (modheads <= 1 or len(repo.branchheads()) == 1) or checkout:
2268 2265 return hg.update(repo, checkout)
2269 2266 else:
2270 2267 ui.status(_("not updating, since new heads added\n"))
2271 2268 if modheads > 1:
2272 2269 ui.status(_("(run 'hg heads' to see heads, 'hg merge' to merge)\n"))
2273 2270 else:
2274 2271 ui.status(_("(run 'hg update' to get a working copy)\n"))
2275 2272
2276 2273 def pull(ui, repo, source="default", **opts):
2277 2274 """pull changes from the specified source
2278 2275
2279 2276 Pull changes from a remote repository to a local one.
2280 2277
2281 2278 This finds all changes from the repository at the specified path
2282 2279 or URL and adds them to a local repository (the current one unless
2283 2280 -R is specified). By default, this does not update the copy of the
2284 2281 project in the working directory.
2285 2282
2286 2283 Use hg incoming if you want to see what would have been added by a
2287 2284 pull at the time you issued this command. If you then decide to
2288 2285 added those changes to the repository, you should use pull -r X
2289 2286 where X is the last changeset listed by hg incoming.
2290 2287
2291 2288 If SOURCE is omitted, the 'default' path will be used.
2292 2289 See 'hg help urls' for more information.
2293 2290 """
2294 2291 source, revs, checkout = hg.parseurl(ui.expandpath(source), opts.get('rev'))
2295 2292 other = hg.repository(cmdutil.remoteui(repo, opts), source)
2296 2293 ui.status(_('pulling from %s\n') % url.hidepassword(source))
2297 2294 if revs:
2298 2295 try:
2299 2296 revs = [other.lookup(rev) for rev in revs]
2300 2297 except error.CapabilityError:
2301 2298 err = _("Other repository doesn't support revision lookup, "
2302 2299 "so a rev cannot be specified.")
2303 2300 raise util.Abort(err)
2304 2301
2305 2302 modheads = repo.pull(other, heads=revs, force=opts.get('force'))
2306 2303 return postincoming(ui, repo, modheads, opts.get('update'), checkout)
2307 2304
2308 2305 def push(ui, repo, dest=None, **opts):
2309 2306 """push changes to the specified destination
2310 2307
2311 2308 Push changes from the local repository to the given destination.
2312 2309
2313 2310 This is the symmetrical operation for pull. It moves changes from
2314 2311 the current repository to a different one. If the destination is
2315 2312 local this is identical to a pull in that directory from the
2316 2313 current one.
2317 2314
2318 2315 By default, push will refuse to run if it detects the result would
2319 2316 increase the number of remote heads. This generally indicates the
2320 2317 user forgot to pull and merge before pushing.
2321 2318
2322 2319 If -r/--rev is used, the named revision and all its ancestors will
2323 2320 be pushed to the remote repository.
2324 2321
2325 2322 Please see 'hg help urls' for important details about ssh://
2326 2323 URLs. If DESTINATION is omitted, a default path will be used.
2327 2324 """
2328 2325 dest, revs, checkout = hg.parseurl(
2329 2326 ui.expandpath(dest or 'default-push', dest or 'default'), opts.get('rev'))
2330 2327 other = hg.repository(cmdutil.remoteui(repo, opts), dest)
2331 2328 ui.status(_('pushing to %s\n') % url.hidepassword(dest))
2332 2329 if revs:
2333 2330 revs = [repo.lookup(rev) for rev in revs]
2334 2331
2335 2332 # push subrepos depth-first for coherent ordering
2336 2333 c = repo['']
2337 2334 subs = c.substate # only repos that are committed
2338 2335 for s in sorted(subs):
2339 2336 c.sub(s).push(opts.get('force'))
2340 2337
2341 2338 r = repo.push(other, opts.get('force'), revs=revs)
2342 2339 return r == 0
2343 2340
2344 2341 def recover(ui, repo):
2345 2342 """roll back an interrupted transaction
2346 2343
2347 2344 Recover from an interrupted commit or pull.
2348 2345
2349 2346 This command tries to fix the repository status after an
2350 2347 interrupted operation. It should only be necessary when Mercurial
2351 2348 suggests it.
2352 2349 """
2353 2350 if repo.recover():
2354 2351 return hg.verify(repo)
2355 2352 return 1
2356 2353
2357 2354 def remove(ui, repo, *pats, **opts):
2358 2355 """remove the specified files on the next commit
2359 2356
2360 2357 Schedule the indicated files for removal from the repository.
2361 2358
2362 2359 This only removes files from the current branch, not from the
2363 2360 entire project history. -A/--after can be used to remove only
2364 2361 files that have already been deleted, -f/--force can be used to
2365 2362 force deletion, and -Af can be used to remove files from the next
2366 2363 revision without deleting them from the working directory.
2367 2364
2368 2365 The following table details the behavior of remove for different
2369 2366 file states (columns) and option combinations (rows). The file
2370 2367 states are Added [A], Clean [C], Modified [M] and Missing [!] (as
2371 2368 reported by hg status). The actions are Warn, Remove (from branch)
2372 2369 and Delete (from disk)::
2373 2370
2374 2371 A C M !
2375 2372 none W RD W R
2376 2373 -f R RD RD R
2377 2374 -A W W W R
2378 2375 -Af R R R R
2379 2376
2380 2377 This command schedules the files to be removed at the next commit.
2381 2378 To undo a remove before that, see hg revert.
2382 2379 """
2383 2380
2384 2381 after, force = opts.get('after'), opts.get('force')
2385 2382 if not pats and not after:
2386 2383 raise util.Abort(_('no files specified'))
2387 2384
2388 2385 m = cmdutil.match(repo, pats, opts)
2389 2386 s = repo.status(match=m, clean=True)
2390 2387 modified, added, deleted, clean = s[0], s[1], s[3], s[6]
2391 2388
2392 2389 for f in m.files():
2393 2390 if f not in repo.dirstate and not os.path.isdir(m.rel(f)):
2394 2391 ui.warn(_('not removing %s: file is untracked\n') % m.rel(f))
2395 2392
2396 2393 def warn(files, reason):
2397 2394 for f in files:
2398 2395 ui.warn(_('not removing %s: file %s (use -f to force removal)\n')
2399 2396 % (m.rel(f), reason))
2400 2397
2401 2398 if force:
2402 2399 remove, forget = modified + deleted + clean, added
2403 2400 elif after:
2404 2401 remove, forget = deleted, []
2405 2402 warn(modified + added + clean, _('still exists'))
2406 2403 else:
2407 2404 remove, forget = deleted + clean, []
2408 2405 warn(modified, _('is modified'))
2409 2406 warn(added, _('has been marked for add'))
2410 2407
2411 2408 for f in sorted(remove + forget):
2412 2409 if ui.verbose or not m.exact(f):
2413 2410 ui.status(_('removing %s\n') % m.rel(f))
2414 2411
2415 2412 repo.forget(forget)
2416 2413 repo.remove(remove, unlink=not after)
2417 2414
2418 2415 def rename(ui, repo, *pats, **opts):
2419 2416 """rename files; equivalent of copy + remove
2420 2417
2421 2418 Mark dest as copies of sources; mark sources for deletion. If dest
2422 2419 is a directory, copies are put in that directory. If dest is a
2423 2420 file, there can only be one source.
2424 2421
2425 2422 By default, this command copies the contents of files as they
2426 2423 exist in the working directory. If invoked with -A/--after, the
2427 2424 operation is recorded, but no copying is performed.
2428 2425
2429 2426 This command takes effect at the next commit. To undo a rename
2430 2427 before that, see hg revert.
2431 2428 """
2432 2429 wlock = repo.wlock(False)
2433 2430 try:
2434 2431 return cmdutil.copy(ui, repo, pats, opts, rename=True)
2435 2432 finally:
2436 2433 wlock.release()
2437 2434
2438 2435 def resolve(ui, repo, *pats, **opts):
2439 2436 """retry file merges from a merge or update
2440 2437
2441 2438 This command will cleanly retry unresolved file merges using file
2442 2439 revisions preserved from the last update or merge. To attempt to
2443 2440 resolve all unresolved files, use the -a/--all switch.
2444 2441
2445 2442 If a conflict is resolved manually, please note that the changes
2446 2443 will be overwritten if the merge is retried with resolve. The
2447 2444 -m/--mark switch should be used to mark the file as resolved.
2448 2445
2449 2446 This command also allows listing resolved files and manually
2450 2447 indicating whether or not files are resolved. All files must be
2451 2448 marked as resolved before a commit is permitted.
2452 2449
2453 2450 The codes used to show the status of files are::
2454 2451
2455 2452 U = unresolved
2456 2453 R = resolved
2457 2454 """
2458 2455
2459 2456 all, mark, unmark, show = [opts.get(o) for o in 'all mark unmark list'.split()]
2460 2457
2461 2458 if (show and (mark or unmark)) or (mark and unmark):
2462 2459 raise util.Abort(_("too many options specified"))
2463 2460 if pats and all:
2464 2461 raise util.Abort(_("can't specify --all and patterns"))
2465 2462 if not (all or pats or show or mark or unmark):
2466 2463 raise util.Abort(_('no files or directories specified; '
2467 2464 'use --all to remerge all files'))
2468 2465
2469 2466 ms = merge_.mergestate(repo)
2470 2467 m = cmdutil.match(repo, pats, opts)
2471 2468
2472 2469 for f in ms:
2473 2470 if m(f):
2474 2471 if show:
2475 2472 ui.write("%s %s\n" % (ms[f].upper(), f))
2476 2473 elif mark:
2477 2474 ms.mark(f, "r")
2478 2475 elif unmark:
2479 2476 ms.mark(f, "u")
2480 2477 else:
2481 2478 wctx = repo[None]
2482 2479 mctx = wctx.parents()[-1]
2483 2480
2484 2481 # backup pre-resolve (merge uses .orig for its own purposes)
2485 2482 a = repo.wjoin(f)
2486 2483 util.copyfile(a, a + ".resolve")
2487 2484
2488 2485 # resolve file
2489 2486 ms.resolve(f, wctx, mctx)
2490 2487
2491 2488 # replace filemerge's .orig file with our resolve file
2492 2489 util.rename(a + ".resolve", a + ".orig")
2493 2490
2494 2491 def revert(ui, repo, *pats, **opts):
2495 2492 """restore individual files or directories to an earlier state
2496 2493
2497 2494 (Use update -r to check out earlier revisions, revert does not
2498 2495 change the working directory parents.)
2499 2496
2500 2497 With no revision specified, revert the named files or directories
2501 2498 to the contents they had in the parent of the working directory.
2502 2499 This restores the contents of the affected files to an unmodified
2503 2500 state and unschedules adds, removes, copies, and renames. If the
2504 2501 working directory has two parents, you must explicitly specify the
2505 2502 revision to revert to.
2506 2503
2507 2504 Using the -r/--rev option, revert the given files or directories
2508 2505 to their contents as of a specific revision. This can be helpful
2509 2506 to "roll back" some or all of an earlier change. See 'hg help
2510 2507 dates' for a list of formats valid for -d/--date.
2511 2508
2512 2509 Revert modifies the working directory. It does not commit any
2513 2510 changes, or change the parent of the working directory. If you
2514 2511 revert to a revision other than the parent of the working
2515 2512 directory, the reverted files will thus appear modified
2516 2513 afterwards.
2517 2514
2518 2515 If a file has been deleted, it is restored. If the executable mode
2519 2516 of a file was changed, it is reset.
2520 2517
2521 2518 If names are given, all files matching the names are reverted.
2522 2519 If no arguments are given, no files are reverted.
2523 2520
2524 2521 Modified files are saved with a .orig suffix before reverting.
2525 2522 To disable these backups, use --no-backup.
2526 2523 """
2527 2524
2528 2525 if opts["date"]:
2529 2526 if opts["rev"]:
2530 2527 raise util.Abort(_("you can't specify a revision and a date"))
2531 2528 opts["rev"] = cmdutil.finddate(ui, repo, opts["date"])
2532 2529
2533 2530 if not pats and not opts.get('all'):
2534 2531 raise util.Abort(_('no files or directories specified; '
2535 2532 'use --all to revert the whole repo'))
2536 2533
2537 2534 parent, p2 = repo.dirstate.parents()
2538 2535 if not opts.get('rev') and p2 != nullid:
2539 2536 raise util.Abort(_('uncommitted merge - please provide a '
2540 2537 'specific revision'))
2541 2538 ctx = repo[opts.get('rev')]
2542 2539 node = ctx.node()
2543 2540 mf = ctx.manifest()
2544 2541 if node == parent:
2545 2542 pmf = mf
2546 2543 else:
2547 2544 pmf = None
2548 2545
2549 2546 # need all matching names in dirstate and manifest of target rev,
2550 2547 # so have to walk both. do not print errors if files exist in one
2551 2548 # but not other.
2552 2549
2553 2550 names = {}
2554 2551
2555 2552 wlock = repo.wlock()
2556 2553 try:
2557 2554 # walk dirstate.
2558 2555
2559 2556 m = cmdutil.match(repo, pats, opts)
2560 2557 m.bad = lambda x,y: False
2561 2558 for abs in repo.walk(m):
2562 2559 names[abs] = m.rel(abs), m.exact(abs)
2563 2560
2564 2561 # walk target manifest.
2565 2562
2566 2563 def badfn(path, msg):
2567 2564 if path in names:
2568 2565 return
2569 2566 path_ = path + '/'
2570 2567 for f in names:
2571 2568 if f.startswith(path_):
2572 2569 return
2573 2570 ui.warn("%s: %s\n" % (m.rel(path), msg))
2574 2571
2575 2572 m = cmdutil.match(repo, pats, opts)
2576 2573 m.bad = badfn
2577 2574 for abs in repo[node].walk(m):
2578 2575 if abs not in names:
2579 2576 names[abs] = m.rel(abs), m.exact(abs)
2580 2577
2581 2578 m = cmdutil.matchfiles(repo, names)
2582 2579 changes = repo.status(match=m)[:4]
2583 2580 modified, added, removed, deleted = map(set, changes)
2584 2581
2585 2582 # if f is a rename, also revert the source
2586 2583 cwd = repo.getcwd()
2587 2584 for f in added:
2588 2585 src = repo.dirstate.copied(f)
2589 2586 if src and src not in names and repo.dirstate[src] == 'r':
2590 2587 removed.add(src)
2591 2588 names[src] = (repo.pathto(src, cwd), True)
2592 2589
2593 2590 def removeforget(abs):
2594 2591 if repo.dirstate[abs] == 'a':
2595 2592 return _('forgetting %s\n')
2596 2593 return _('removing %s\n')
2597 2594
2598 2595 revert = ([], _('reverting %s\n'))
2599 2596 add = ([], _('adding %s\n'))
2600 2597 remove = ([], removeforget)
2601 2598 undelete = ([], _('undeleting %s\n'))
2602 2599
2603 2600 disptable = (
2604 2601 # dispatch table:
2605 2602 # file state
2606 2603 # action if in target manifest
2607 2604 # action if not in target manifest
2608 2605 # make backup if in target manifest
2609 2606 # make backup if not in target manifest
2610 2607 (modified, revert, remove, True, True),
2611 2608 (added, revert, remove, True, False),
2612 2609 (removed, undelete, None, False, False),
2613 2610 (deleted, revert, remove, False, False),
2614 2611 )
2615 2612
2616 2613 for abs, (rel, exact) in sorted(names.items()):
2617 2614 mfentry = mf.get(abs)
2618 2615 target = repo.wjoin(abs)
2619 2616 def handle(xlist, dobackup):
2620 2617 xlist[0].append(abs)
2621 2618 if dobackup and not opts.get('no_backup') and util.lexists(target):
2622 2619 bakname = "%s.orig" % rel
2623 2620 ui.note(_('saving current version of %s as %s\n') %
2624 2621 (rel, bakname))
2625 2622 if not opts.get('dry_run'):
2626 2623 util.copyfile(target, bakname)
2627 2624 if ui.verbose or not exact:
2628 2625 msg = xlist[1]
2629 2626 if not isinstance(msg, basestring):
2630 2627 msg = msg(abs)
2631 2628 ui.status(msg % rel)
2632 2629 for table, hitlist, misslist, backuphit, backupmiss in disptable:
2633 2630 if abs not in table: continue
2634 2631 # file has changed in dirstate
2635 2632 if mfentry:
2636 2633 handle(hitlist, backuphit)
2637 2634 elif misslist is not None:
2638 2635 handle(misslist, backupmiss)
2639 2636 break
2640 2637 else:
2641 2638 if abs not in repo.dirstate:
2642 2639 if mfentry:
2643 2640 handle(add, True)
2644 2641 elif exact:
2645 2642 ui.warn(_('file not managed: %s\n') % rel)
2646 2643 continue
2647 2644 # file has not changed in dirstate
2648 2645 if node == parent:
2649 2646 if exact: ui.warn(_('no changes needed to %s\n') % rel)
2650 2647 continue
2651 2648 if pmf is None:
2652 2649 # only need parent manifest in this unlikely case,
2653 2650 # so do not read by default
2654 2651 pmf = repo[parent].manifest()
2655 2652 if abs in pmf:
2656 2653 if mfentry:
2657 2654 # if version of file is same in parent and target
2658 2655 # manifests, do nothing
2659 2656 if (pmf[abs] != mfentry or
2660 2657 pmf.flags(abs) != mf.flags(abs)):
2661 2658 handle(revert, False)
2662 2659 else:
2663 2660 handle(remove, False)
2664 2661
2665 2662 if not opts.get('dry_run'):
2666 2663 def checkout(f):
2667 2664 fc = ctx[f]
2668 2665 repo.wwrite(f, fc.data(), fc.flags())
2669 2666
2670 2667 audit_path = util.path_auditor(repo.root)
2671 2668 for f in remove[0]:
2672 2669 if repo.dirstate[f] == 'a':
2673 2670 repo.dirstate.forget(f)
2674 2671 continue
2675 2672 audit_path(f)
2676 2673 try:
2677 2674 util.unlink(repo.wjoin(f))
2678 2675 except OSError:
2679 2676 pass
2680 2677 repo.dirstate.remove(f)
2681 2678
2682 2679 normal = None
2683 2680 if node == parent:
2684 2681 # We're reverting to our parent. If possible, we'd like status
2685 2682 # to report the file as clean. We have to use normallookup for
2686 2683 # merges to avoid losing information about merged/dirty files.
2687 2684 if p2 != nullid:
2688 2685 normal = repo.dirstate.normallookup
2689 2686 else:
2690 2687 normal = repo.dirstate.normal
2691 2688 for f in revert[0]:
2692 2689 checkout(f)
2693 2690 if normal:
2694 2691 normal(f)
2695 2692
2696 2693 for f in add[0]:
2697 2694 checkout(f)
2698 2695 repo.dirstate.add(f)
2699 2696
2700 2697 normal = repo.dirstate.normallookup
2701 2698 if node == parent and p2 == nullid:
2702 2699 normal = repo.dirstate.normal
2703 2700 for f in undelete[0]:
2704 2701 checkout(f)
2705 2702 normal(f)
2706 2703
2707 2704 finally:
2708 2705 wlock.release()
2709 2706
2710 2707 def rollback(ui, repo):
2711 2708 """roll back the last transaction
2712 2709
2713 2710 This command should be used with care. There is only one level of
2714 2711 rollback, and there is no way to undo a rollback. It will also
2715 2712 restore the dirstate at the time of the last transaction, losing
2716 2713 any dirstate changes since that time. This command does not alter
2717 2714 the working directory.
2718 2715
2719 2716 Transactions are used to encapsulate the effects of all commands
2720 2717 that create new changesets or propagate existing changesets into a
2721 2718 repository. For example, the following commands are transactional,
2722 2719 and their effects can be rolled back::
2723 2720
2724 2721 commit
2725 2722 import
2726 2723 pull
2727 2724 push (with this repository as destination)
2728 2725 unbundle
2729 2726
2730 2727 This command is not intended for use on public repositories. Once
2731 2728 changes are visible for pull by other users, rolling a transaction
2732 2729 back locally is ineffective (someone else may already have pulled
2733 2730 the changes). Furthermore, a race is possible with readers of the
2734 2731 repository; for example an in-progress pull from the repository
2735 2732 may fail if a rollback is performed.
2736 2733 """
2737 2734 repo.rollback()
2738 2735
2739 2736 def root(ui, repo):
2740 2737 """print the root (top) of the current working directory
2741 2738
2742 2739 Print the root directory of the current repository.
2743 2740 """
2744 2741 ui.write(repo.root + "\n")
2745 2742
2746 2743 def serve(ui, repo, **opts):
2747 2744 """export the repository via HTTP
2748 2745
2749 2746 Start a local HTTP repository browser and pull server.
2750 2747
2751 2748 By default, the server logs accesses to stdout and errors to
2752 2749 stderr. Use the -A/--accesslog and -E/--errorlog options to log to
2753 2750 files.
2754 2751 """
2755 2752
2756 2753 if opts["stdio"]:
2757 2754 if repo is None:
2758 2755 raise error.RepoError(_("There is no Mercurial repository here"
2759 2756 " (.hg not found)"))
2760 2757 s = sshserver.sshserver(ui, repo)
2761 2758 s.serve_forever()
2762 2759
2763 2760 baseui = repo and repo.baseui or ui
2764 2761 optlist = ("name templates style address port prefix ipv6"
2765 2762 " accesslog errorlog webdir_conf certificate encoding")
2766 2763 for o in optlist.split():
2767 2764 if opts.get(o, None):
2768 2765 baseui.setconfig("web", o, str(opts[o]))
2769 2766 if (repo is not None) and (repo.ui != baseui):
2770 2767 repo.ui.setconfig("web", o, str(opts[o]))
2771 2768
2772 2769 if repo is None and not ui.config("web", "webdir_conf"):
2773 2770 raise error.RepoError(_("There is no Mercurial repository here"
2774 2771 " (.hg not found)"))
2775 2772
2776 2773 class service(object):
2777 2774 def init(self):
2778 2775 util.set_signal_handler()
2779 2776 self.httpd = server.create_server(baseui, repo)
2780 2777
2781 2778 if not ui.verbose: return
2782 2779
2783 2780 if self.httpd.prefix:
2784 2781 prefix = self.httpd.prefix.strip('/') + '/'
2785 2782 else:
2786 2783 prefix = ''
2787 2784
2788 2785 port = ':%d' % self.httpd.port
2789 2786 if port == ':80':
2790 2787 port = ''
2791 2788
2792 2789 bindaddr = self.httpd.addr
2793 2790 if bindaddr == '0.0.0.0':
2794 2791 bindaddr = '*'
2795 2792 elif ':' in bindaddr: # IPv6
2796 2793 bindaddr = '[%s]' % bindaddr
2797 2794
2798 2795 fqaddr = self.httpd.fqaddr
2799 2796 if ':' in fqaddr:
2800 2797 fqaddr = '[%s]' % fqaddr
2801 2798 ui.status(_('listening at http://%s%s/%s (bound to %s:%d)\n') %
2802 2799 (fqaddr, port, prefix, bindaddr, self.httpd.port))
2803 2800
2804 2801 def run(self):
2805 2802 self.httpd.serve_forever()
2806 2803
2807 2804 service = service()
2808 2805
2809 2806 cmdutil.service(opts, initfn=service.init, runfn=service.run)
2810 2807
2811 2808 def status(ui, repo, *pats, **opts):
2812 2809 """show changed files in the working directory
2813 2810
2814 2811 Show status of files in the repository. If names are given, only
2815 2812 files that match are shown. Files that are clean or ignored or
2816 2813 the source of a copy/move operation, are not listed unless
2817 2814 -c/--clean, -i/--ignored, -C/--copies or -A/--all are given.
2818 2815 Unless options described with "show only ..." are given, the
2819 2816 options -mardu are used.
2820 2817
2821 2818 Option -q/--quiet hides untracked (unknown and ignored) files
2822 2819 unless explicitly requested with -u/--unknown or -i/--ignored.
2823 2820
2824 2821 NOTE: status may appear to disagree with diff if permissions have
2825 2822 changed or a merge has occurred. The standard diff format does not
2826 2823 report permission changes and diff only reports changes relative
2827 2824 to one merge parent.
2828 2825
2829 2826 If one revision is given, it is used as the base revision.
2830 2827 If two revisions are given, the differences between them are
2831 2828 shown.
2832 2829
2833 2830 The codes used to show the status of files are::
2834 2831
2835 2832 M = modified
2836 2833 A = added
2837 2834 R = removed
2838 2835 C = clean
2839 2836 ! = missing (deleted by non-hg command, but still tracked)
2840 2837 ? = not tracked
2841 2838 I = ignored
2842 2839 = origin of the previous file listed as A (added)
2843 2840 """
2844 2841
2845 2842 node1, node2 = cmdutil.revpair(repo, opts.get('rev'))
2846 2843 cwd = (pats and repo.getcwd()) or ''
2847 2844 end = opts.get('print0') and '\0' or '\n'
2848 2845 copy = {}
2849 2846 states = 'modified added removed deleted unknown ignored clean'.split()
2850 2847 show = [k for k in states if opts.get(k)]
2851 2848 if opts.get('all'):
2852 2849 show += ui.quiet and (states[:4] + ['clean']) or states
2853 2850 if not show:
2854 2851 show = ui.quiet and states[:4] or states[:5]
2855 2852
2856 2853 stat = repo.status(node1, node2, cmdutil.match(repo, pats, opts),
2857 2854 'ignored' in show, 'clean' in show, 'unknown' in show)
2858 2855 changestates = zip(states, 'MAR!?IC', stat)
2859 2856
2860 2857 if (opts.get('all') or opts.get('copies')) and not opts.get('no_status'):
2861 2858 ctxn = repo[nullid]
2862 2859 ctx1 = repo[node1]
2863 2860 ctx2 = repo[node2]
2864 2861 added = stat[1]
2865 2862 if node2 is None:
2866 2863 added = stat[0] + stat[1] # merged?
2867 2864
2868 2865 for k, v in copies.copies(repo, ctx1, ctx2, ctxn)[0].iteritems():
2869 2866 if k in added:
2870 2867 copy[k] = v
2871 2868 elif v in added:
2872 2869 copy[v] = k
2873 2870
2874 2871 for state, char, files in changestates:
2875 2872 if state in show:
2876 2873 format = "%s %%s%s" % (char, end)
2877 2874 if opts.get('no_status'):
2878 2875 format = "%%s%s" % end
2879 2876
2880 2877 for f in files:
2881 2878 ui.write(format % repo.pathto(f, cwd))
2882 2879 if f in copy:
2883 2880 ui.write(' %s%s' % (repo.pathto(copy[f], cwd), end))
2884 2881
2885 2882 def tag(ui, repo, name1, *names, **opts):
2886 2883 """add one or more tags for the current or given revision
2887 2884
2888 2885 Name a particular revision using <name>.
2889 2886
2890 2887 Tags are used to name particular revisions of the repository and are
2891 2888 very useful to compare different revisions, to go back to significant
2892 2889 earlier versions or to mark branch points as releases, etc.
2893 2890
2894 2891 If no revision is given, the parent of the working directory is
2895 2892 used, or tip if no revision is checked out.
2896 2893
2897 2894 To facilitate version control, distribution, and merging of tags,
2898 2895 they are stored as a file named ".hgtags" which is managed
2899 2896 similarly to other project files and can be hand-edited if
2900 2897 necessary. The file '.hg/localtags' is used for local tags (not
2901 2898 shared among repositories).
2902 2899
2903 2900 See 'hg help dates' for a list of formats valid for -d/--date.
2904 2901 """
2905 2902
2906 2903 rev_ = "."
2907 2904 names = (name1,) + names
2908 2905 if len(names) != len(set(names)):
2909 2906 raise util.Abort(_('tag names must be unique'))
2910 2907 for n in names:
2911 2908 if n in ['tip', '.', 'null']:
2912 2909 raise util.Abort(_('the name \'%s\' is reserved') % n)
2913 2910 if opts.get('rev') and opts.get('remove'):
2914 2911 raise util.Abort(_("--rev and --remove are incompatible"))
2915 2912 if opts.get('rev'):
2916 2913 rev_ = opts['rev']
2917 2914 message = opts.get('message')
2918 2915 if opts.get('remove'):
2919 2916 expectedtype = opts.get('local') and 'local' or 'global'
2920 2917 for n in names:
2921 2918 if not repo.tagtype(n):
2922 2919 raise util.Abort(_('tag \'%s\' does not exist') % n)
2923 2920 if repo.tagtype(n) != expectedtype:
2924 2921 if expectedtype == 'global':
2925 2922 raise util.Abort(_('tag \'%s\' is not a global tag') % n)
2926 2923 else:
2927 2924 raise util.Abort(_('tag \'%s\' is not a local tag') % n)
2928 2925 rev_ = nullid
2929 2926 if not message:
2930 2927 # we don't translate commit messages
2931 2928 message = 'Removed tag %s' % ', '.join(names)
2932 2929 elif not opts.get('force'):
2933 2930 for n in names:
2934 2931 if n in repo.tags():
2935 2932 raise util.Abort(_('tag \'%s\' already exists '
2936 2933 '(use -f to force)') % n)
2937 2934 if not rev_ and repo.dirstate.parents()[1] != nullid:
2938 2935 raise util.Abort(_('uncommitted merge - please provide a '
2939 2936 'specific revision'))
2940 2937 r = repo[rev_].node()
2941 2938
2942 2939 if not message:
2943 2940 # we don't translate commit messages
2944 2941 message = ('Added tag %s for changeset %s' %
2945 2942 (', '.join(names), short(r)))
2946 2943
2947 2944 date = opts.get('date')
2948 2945 if date:
2949 2946 date = util.parsedate(date)
2950 2947
2951 2948 repo.tag(names, r, message, opts.get('local'), opts.get('user'), date)
2952 2949
2953 2950 def tags(ui, repo):
2954 2951 """list repository tags
2955 2952
2956 2953 This lists both regular and local tags. When the -v/--verbose
2957 2954 switch is used, a third column "local" is printed for local tags.
2958 2955 """
2959 2956
2960 2957 hexfunc = ui.debugflag and hex or short
2961 2958 tagtype = ""
2962 2959
2963 2960 for t, n in reversed(repo.tagslist()):
2964 2961 if ui.quiet:
2965 2962 ui.write("%s\n" % t)
2966 2963 continue
2967 2964
2968 2965 try:
2969 2966 hn = hexfunc(n)
2970 2967 r = "%5d:%s" % (repo.changelog.rev(n), hn)
2971 2968 except error.LookupError:
2972 2969 r = " ?:%s" % hn
2973 2970 else:
2974 2971 spaces = " " * (30 - encoding.colwidth(t))
2975 2972 if ui.verbose:
2976 2973 if repo.tagtype(t) == 'local':
2977 2974 tagtype = " local"
2978 2975 else:
2979 2976 tagtype = ""
2980 2977 ui.write("%s%s %s%s\n" % (t, spaces, r, tagtype))
2981 2978
2982 2979 def tip(ui, repo, **opts):
2983 2980 """show the tip revision
2984 2981
2985 2982 The tip revision (usually just called the tip) is the changeset
2986 2983 most recently added to the repository (and therefore the most
2987 2984 recently changed head).
2988 2985
2989 2986 If you have just made a commit, that commit will be the tip. If
2990 2987 you have just pulled changes from another repository, the tip of
2991 2988 that repository becomes the current tip. The "tip" tag is special
2992 2989 and cannot be renamed or assigned to a different changeset.
2993 2990 """
2994 2991 cmdutil.show_changeset(ui, repo, opts).show(repo[len(repo) - 1])
2995 2992
2996 2993 def unbundle(ui, repo, fname1, *fnames, **opts):
2997 2994 """apply one or more changegroup files
2998 2995
2999 2996 Apply one or more compressed changegroup files generated by the
3000 2997 bundle command.
3001 2998 """
3002 2999 fnames = (fname1,) + fnames
3003 3000
3004 3001 lock = repo.lock()
3005 3002 try:
3006 3003 for fname in fnames:
3007 3004 f = url.open(ui, fname)
3008 3005 gen = changegroup.readbundle(f, fname)
3009 3006 modheads = repo.addchangegroup(gen, 'unbundle', 'bundle:' + fname)
3010 3007 finally:
3011 3008 lock.release()
3012 3009
3013 3010 return postincoming(ui, repo, modheads, opts.get('update'), None)
3014 3011
3015 3012 def update(ui, repo, node=None, rev=None, clean=False, date=None, check=False):
3016 3013 """update working directory
3017 3014
3018 3015 Update the repository's working directory to the specified
3019 3016 revision, or the tip of the current branch if none is specified.
3020 3017 Use null as the revision to remove the working copy (like 'hg
3021 3018 clone -U').
3022 3019
3023 3020 When the working directory contains no uncommitted changes, it
3024 3021 will be replaced by the state of the requested revision from the
3025 3022 repository. When the requested revision is on a different branch,
3026 3023 the working directory will additionally be switched to that
3027 3024 branch.
3028 3025
3029 3026 When there are uncommitted changes, use option -C/--clean to
3030 3027 discard them, forcibly replacing the state of the working
3031 3028 directory with the requested revision. Alternately, use -c/--check
3032 3029 to abort.
3033 3030
3034 3031 When there are uncommitted changes and option -C/--clean is not
3035 3032 used, and the parent revision and requested revision are on the
3036 3033 same branch, and one of them is an ancestor of the other, then the
3037 3034 new working directory will contain the requested revision merged
3038 3035 with the uncommitted changes. Otherwise, the update will fail with
3039 3036 a suggestion to use 'merge' or 'update -C' instead.
3040 3037
3041 3038 If you want to update just one file to an older revision, use
3042 3039 revert.
3043 3040
3044 3041 See 'hg help dates' for a list of formats valid for -d/--date.
3045 3042 """
3046 3043 if rev and node:
3047 3044 raise util.Abort(_("please specify just one revision"))
3048 3045
3049 3046 if not rev:
3050 3047 rev = node
3051 3048
3052 3049 if not clean and check:
3053 3050 # we could use dirty() but we can ignore merge and branch trivia
3054 3051 c = repo[None]
3055 3052 if c.modified() or c.added() or c.removed():
3056 3053 raise util.Abort(_("uncommitted local changes"))
3057 3054
3058 3055 if date:
3059 3056 if rev:
3060 3057 raise util.Abort(_("you can't specify a revision and a date"))
3061 3058 rev = cmdutil.finddate(ui, repo, date)
3062 3059
3063 3060 if clean or check:
3064 3061 return hg.clean(repo, rev)
3065 3062 else:
3066 3063 return hg.update(repo, rev)
3067 3064
3068 3065 def verify(ui, repo):
3069 3066 """verify the integrity of the repository
3070 3067
3071 3068 Verify the integrity of the current repository.
3072 3069
3073 3070 This will perform an extensive check of the repository's
3074 3071 integrity, validating the hashes and checksums of each entry in
3075 3072 the changelog, manifest, and tracked files, as well as the
3076 3073 integrity of their crosslinks and indices.
3077 3074 """
3078 3075 return hg.verify(repo)
3079 3076
3080 3077 def version_(ui):
3081 3078 """output version and copyright information"""
3082 3079 ui.write(_("Mercurial Distributed SCM (version %s)\n")
3083 3080 % util.version())
3084 3081 ui.status(_(
3085 3082 "\nCopyright (C) 2005-2009 Matt Mackall <mpm@selenic.com> and others\n"
3086 3083 "This is free software; see the source for copying conditions. "
3087 3084 "There is NO\nwarranty; "
3088 3085 "not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
3089 3086 ))
3090 3087
3091 3088 # Command options and aliases are listed here, alphabetically
3092 3089
3093 3090 globalopts = [
3094 3091 ('R', 'repository', '',
3095 3092 _('repository root directory or symbolic path name')),
3096 3093 ('', 'cwd', '', _('change working directory')),
3097 3094 ('y', 'noninteractive', None,
3098 3095 _('do not prompt, assume \'yes\' for any required answers')),
3099 3096 ('q', 'quiet', None, _('suppress output')),
3100 3097 ('v', 'verbose', None, _('enable additional output')),
3101 3098 ('', 'config', [], _('set/override config option')),
3102 3099 ('', 'debug', None, _('enable debugging output')),
3103 3100 ('', 'debugger', None, _('start debugger')),
3104 3101 ('', 'encoding', encoding.encoding, _('set the charset encoding')),
3105 3102 ('', 'encodingmode', encoding.encodingmode,
3106 3103 _('set the charset encoding mode')),
3107 3104 ('', 'traceback', None, _('print traceback on exception')),
3108 3105 ('', 'time', None, _('time how long the command takes')),
3109 3106 ('', 'profile', None, _('print command execution profile')),
3110 3107 ('', 'version', None, _('output version information and exit')),
3111 3108 ('h', 'help', None, _('display help and exit')),
3112 3109 ]
3113 3110
3114 3111 dryrunopts = [('n', 'dry-run', None,
3115 3112 _('do not perform actions, just print output'))]
3116 3113
3117 3114 remoteopts = [
3118 3115 ('e', 'ssh', '', _('specify ssh command to use')),
3119 3116 ('', 'remotecmd', '', _('specify hg command to run on the remote side')),
3120 3117 ]
3121 3118
3122 3119 walkopts = [
3123 3120 ('I', 'include', [], _('include names matching the given patterns')),
3124 3121 ('X', 'exclude', [], _('exclude names matching the given patterns')),
3125 3122 ]
3126 3123
3127 3124 commitopts = [
3128 3125 ('m', 'message', '', _('use <text> as commit message')),
3129 3126 ('l', 'logfile', '', _('read commit message from <file>')),
3130 3127 ]
3131 3128
3132 3129 commitopts2 = [
3133 3130 ('d', 'date', '', _('record datecode as commit date')),
3134 3131 ('u', 'user', '', _('record the specified user as committer')),
3135 3132 ]
3136 3133
3137 3134 templateopts = [
3138 3135 ('', 'style', '', _('display using template map file')),
3139 3136 ('', 'template', '', _('display with template')),
3140 3137 ]
3141 3138
3142 3139 logopts = [
3143 3140 ('p', 'patch', None, _('show patch')),
3144 3141 ('g', 'git', None, _('use git extended diff format')),
3145 3142 ('l', 'limit', '', _('limit number of changes displayed')),
3146 3143 ('M', 'no-merges', None, _('do not show merges')),
3147 3144 ] + templateopts
3148 3145
3149 3146 diffopts = [
3150 3147 ('a', 'text', None, _('treat all files as text')),
3151 3148 ('g', 'git', None, _('use git extended diff format')),
3152 3149 ('', 'nodates', None, _("don't include dates in diff headers"))
3153 3150 ]
3154 3151
3155 3152 diffopts2 = [
3156 3153 ('p', 'show-function', None, _('show which function each change is in')),
3157 3154 ('w', 'ignore-all-space', None,
3158 3155 _('ignore white space when comparing lines')),
3159 3156 ('b', 'ignore-space-change', None,
3160 3157 _('ignore changes in the amount of white space')),
3161 3158 ('B', 'ignore-blank-lines', None,
3162 3159 _('ignore changes whose lines are all blank')),
3163 3160 ('U', 'unified', '', _('number of lines of context to show'))
3164 3161 ]
3165 3162
3166 3163 similarityopts = [
3167 3164 ('s', 'similarity', '',
3168 3165 _('guess renamed files by similarity (0<=s<=100)'))
3169 3166 ]
3170 3167
3171 3168 table = {
3172 3169 "^add": (add, walkopts + dryrunopts, _('[OPTION]... [FILE]...')),
3173 3170 "addremove":
3174 3171 (addremove, similarityopts + walkopts + dryrunopts,
3175 3172 _('[OPTION]... [FILE]...')),
3176 3173 "^annotate|blame":
3177 3174 (annotate,
3178 3175 [('r', 'rev', '', _('annotate the specified revision')),
3179 3176 ('f', 'follow', None, _('follow file copies and renames')),
3180 3177 ('a', 'text', None, _('treat all files as text')),
3181 3178 ('u', 'user', None, _('list the author (long with -v)')),
3182 3179 ('d', 'date', None, _('list the date (short with -q)')),
3183 3180 ('n', 'number', None, _('list the revision number (default)')),
3184 3181 ('c', 'changeset', None, _('list the changeset')),
3185 3182 ('l', 'line-number', None,
3186 3183 _('show line number at the first appearance'))
3187 3184 ] + walkopts,
3188 3185 _('[-r REV] [-f] [-a] [-u] [-d] [-n] [-c] [-l] FILE...')),
3189 3186 "archive":
3190 3187 (archive,
3191 3188 [('', 'no-decode', None, _('do not pass files through decoders')),
3192 3189 ('p', 'prefix', '', _('directory prefix for files in archive')),
3193 3190 ('r', 'rev', '', _('revision to distribute')),
3194 3191 ('t', 'type', '', _('type of distribution to create')),
3195 3192 ] + walkopts,
3196 3193 _('[OPTION]... DEST')),
3197 3194 "backout":
3198 3195 (backout,
3199 3196 [('', 'merge', None,
3200 3197 _('merge with old dirstate parent after backout')),
3201 3198 ('', 'parent', '', _('parent to choose when backing out merge')),
3202 3199 ('r', 'rev', '', _('revision to backout')),
3203 3200 ] + walkopts + commitopts + commitopts2,
3204 3201 _('[OPTION]... [-r] REV')),
3205 3202 "bisect":
3206 3203 (bisect,
3207 3204 [('r', 'reset', False, _('reset bisect state')),
3208 3205 ('g', 'good', False, _('mark changeset good')),
3209 3206 ('b', 'bad', False, _('mark changeset bad')),
3210 3207 ('s', 'skip', False, _('skip testing changeset')),
3211 3208 ('c', 'command', '', _('use command to check changeset state')),
3212 3209 ('U', 'noupdate', False, _('do not update to target'))],
3213 3210 _("[-gbsr] [-c CMD] [REV]")),
3214 3211 "branch":
3215 3212 (branch,
3216 3213 [('f', 'force', None,
3217 3214 _('set branch name even if it shadows an existing branch')),
3218 3215 ('C', 'clean', None, _('reset branch name to parent branch name'))],
3219 3216 _('[-fC] [NAME]')),
3220 3217 "branches":
3221 3218 (branches,
3222 3219 [('a', 'active', False,
3223 3220 _('show only branches that have unmerged heads')),
3224 3221 ('c', 'closed', False,
3225 3222 _('show normal and closed branches'))],
3226 3223 _('[-a]')),
3227 3224 "bundle":
3228 3225 (bundle,
3229 3226 [('f', 'force', None,
3230 3227 _('run even when remote repository is unrelated')),
3231 3228 ('r', 'rev', [],
3232 3229 _('a changeset up to which you would like to bundle')),
3233 3230 ('', 'base', [],
3234 3231 _('a base changeset to specify instead of a destination')),
3235 3232 ('a', 'all', None, _('bundle all changesets in the repository')),
3236 3233 ('t', 'type', 'bzip2', _('bundle compression type to use')),
3237 3234 ] + remoteopts,
3238 3235 _('[-f] [-a] [-r REV]... [--base REV]... FILE [DEST]')),
3239 3236 "cat":
3240 3237 (cat,
3241 3238 [('o', 'output', '', _('print output to file with formatted name')),
3242 3239 ('r', 'rev', '', _('print the given revision')),
3243 3240 ('', 'decode', None, _('apply any matching decode filter')),
3244 3241 ] + walkopts,
3245 3242 _('[OPTION]... FILE...')),
3246 3243 "^clone":
3247 3244 (clone,
3248 3245 [('U', 'noupdate', None,
3249 3246 _('the clone will only contain a repository (no working copy)')),
3250 3247 ('r', 'rev', [],
3251 3248 _('a changeset you would like to have after cloning')),
3252 3249 ('', 'pull', None, _('use pull protocol to copy metadata')),
3253 3250 ('', 'uncompressed', None,
3254 3251 _('use uncompressed transfer (fast over LAN)')),
3255 3252 ] + remoteopts,
3256 3253 _('[OPTION]... SOURCE [DEST]')),
3257 3254 "^commit|ci":
3258 3255 (commit,
3259 3256 [('A', 'addremove', None,
3260 3257 _('mark new/missing files as added/removed before committing')),
3261 3258 ('', 'close-branch', None,
3262 3259 _('mark a branch as closed, hiding it from the branch list')),
3263 3260 ] + walkopts + commitopts + commitopts2,
3264 3261 _('[OPTION]... [FILE]...')),
3265 3262 "copy|cp":
3266 3263 (copy,
3267 3264 [('A', 'after', None, _('record a copy that has already occurred')),
3268 3265 ('f', 'force', None,
3269 3266 _('forcibly copy over an existing managed file')),
3270 3267 ] + walkopts + dryrunopts,
3271 3268 _('[OPTION]... [SOURCE]... DEST')),
3272 3269 "debugancestor": (debugancestor, [], _('[INDEX] REV1 REV2')),
3273 3270 "debugcheckstate": (debugcheckstate, []),
3274 3271 "debugcommands": (debugcommands, [], _('[COMMAND]')),
3275 3272 "debugcomplete":
3276 3273 (debugcomplete,
3277 3274 [('o', 'options', None, _('show the command options'))],
3278 3275 _('[-o] CMD')),
3279 3276 "debugdate":
3280 3277 (debugdate,
3281 3278 [('e', 'extended', None, _('try extended date formats'))],
3282 3279 _('[-e] DATE [RANGE]')),
3283 3280 "debugdata": (debugdata, [], _('FILE REV')),
3284 3281 "debugfsinfo": (debugfsinfo, [], _('[PATH]')),
3285 3282 "debugindex": (debugindex, [], _('FILE')),
3286 3283 "debugindexdot": (debugindexdot, [], _('FILE')),
3287 3284 "debuginstall": (debuginstall, []),
3288 3285 "debugrebuildstate":
3289 3286 (debugrebuildstate,
3290 3287 [('r', 'rev', '', _('revision to rebuild to'))],
3291 3288 _('[-r REV] [REV]')),
3292 3289 "debugrename":
3293 3290 (debugrename,
3294 3291 [('r', 'rev', '', _('revision to debug'))],
3295 3292 _('[-r REV] FILE')),
3296 3293 "debugsetparents":
3297 3294 (debugsetparents, [], _('REV1 [REV2]')),
3298 3295 "debugstate":
3299 3296 (debugstate,
3300 3297 [('', 'nodates', None, _('do not display the saved mtime'))],
3301 3298 _('[OPTION]...')),
3302 3299 "debugsub":
3303 3300 (debugsub,
3304 3301 [('r', 'rev', '', _('revision to check'))],
3305 3302 _('[-r REV] [REV]')),
3306 3303 "debugwalk": (debugwalk, walkopts, _('[OPTION]... [FILE]...')),
3307 3304 "^diff":
3308 3305 (diff,
3309 3306 [('r', 'rev', [], _('revision')),
3310 3307 ('c', 'change', '', _('change made by revision'))
3311 3308 ] + diffopts + diffopts2 + walkopts,
3312 3309 _('[OPTION]... [-r REV1 [-r REV2]] [FILE]...')),
3313 3310 "^export":
3314 3311 (export,
3315 3312 [('o', 'output', '', _('print output to file with formatted name')),
3316 3313 ('', 'switch-parent', None, _('diff against the second parent'))
3317 3314 ] + diffopts,
3318 3315 _('[OPTION]... [-o OUTFILESPEC] REV...')),
3319 3316 "^forget":
3320 3317 (forget,
3321 3318 [] + walkopts,
3322 3319 _('[OPTION]... FILE...')),
3323 3320 "grep":
3324 3321 (grep,
3325 3322 [('0', 'print0', None, _('end fields with NUL')),
3326 3323 ('', 'all', None, _('print all revisions that match')),
3327 3324 ('f', 'follow', None,
3328 3325 _('follow changeset history, or file history across copies and renames')),
3329 3326 ('i', 'ignore-case', None, _('ignore case when matching')),
3330 3327 ('l', 'files-with-matches', None,
3331 3328 _('print only filenames and revisions that match')),
3332 3329 ('n', 'line-number', None, _('print matching line numbers')),
3333 3330 ('r', 'rev', [], _('search in given revision range')),
3334 3331 ('u', 'user', None, _('list the author (long with -v)')),
3335 3332 ('d', 'date', None, _('list the date (short with -q)')),
3336 3333 ] + walkopts,
3337 3334 _('[OPTION]... PATTERN [FILE]...')),
3338 3335 "heads":
3339 3336 (heads,
3340 3337 [('r', 'rev', '', _('show only heads which are descendants of REV')),
3341 3338 ('a', 'active', False,
3342 3339 _('show only the active branch heads from open branches')),
3343 3340 ('c', 'closed', False,
3344 3341 _('show normal and closed branch heads')),
3345 3342 ] + templateopts,
3346 3343 _('[-r STARTREV] [REV]...')),
3347 3344 "help": (help_, [], _('[TOPIC]')),
3348 3345 "identify|id":
3349 3346 (identify,
3350 3347 [('r', 'rev', '', _('identify the specified revision')),
3351 3348 ('n', 'num', None, _('show local revision number')),
3352 3349 ('i', 'id', None, _('show global revision id')),
3353 3350 ('b', 'branch', None, _('show branch')),
3354 3351 ('t', 'tags', None, _('show tags'))],
3355 3352 _('[-nibt] [-r REV] [SOURCE]')),
3356 3353 "import|patch":
3357 3354 (import_,
3358 3355 [('p', 'strip', 1,
3359 3356 _('directory strip option for patch. This has the same '
3360 3357 'meaning as the corresponding patch option')),
3361 3358 ('b', 'base', '', _('base path')),
3362 3359 ('f', 'force', None,
3363 3360 _('skip check for outstanding uncommitted changes')),
3364 3361 ('', 'no-commit', None, _("don't commit, just update the working directory")),
3365 3362 ('', 'exact', None,
3366 3363 _('apply patch to the nodes from which it was generated')),
3367 3364 ('', 'import-branch', None,
3368 3365 _('use any branch information in patch (implied by --exact)'))] +
3369 3366 commitopts + commitopts2 + similarityopts,
3370 3367 _('[OPTION]... PATCH...')),
3371 3368 "incoming|in":
3372 3369 (incoming,
3373 3370 [('f', 'force', None,
3374 3371 _('run even when remote repository is unrelated')),
3375 3372 ('n', 'newest-first', None, _('show newest record first')),
3376 3373 ('', 'bundle', '', _('file to store the bundles into')),
3377 3374 ('r', 'rev', [],
3378 3375 _('a specific revision up to which you would like to pull')),
3379 3376 ] + logopts + remoteopts,
3380 3377 _('[-p] [-n] [-M] [-f] [-r REV]...'
3381 3378 ' [--bundle FILENAME] [SOURCE]')),
3382 3379 "^init":
3383 3380 (init,
3384 3381 remoteopts,
3385 3382 _('[-e CMD] [--remotecmd CMD] [DEST]')),
3386 3383 "locate":
3387 3384 (locate,
3388 3385 [('r', 'rev', '', _('search the repository as it stood at REV')),
3389 3386 ('0', 'print0', None,
3390 3387 _('end filenames with NUL, for use with xargs')),
3391 3388 ('f', 'fullpath', None,
3392 3389 _('print complete paths from the filesystem root')),
3393 3390 ] + walkopts,
3394 3391 _('[OPTION]... [PATTERN]...')),
3395 3392 "^log|history":
3396 3393 (log,
3397 3394 [('f', 'follow', None,
3398 3395 _('follow changeset history, or file history across copies and renames')),
3399 3396 ('', 'follow-first', None,
3400 3397 _('only follow the first parent of merge changesets')),
3401 3398 ('d', 'date', '', _('show revisions matching date spec')),
3402 3399 ('C', 'copies', None, _('show copied files')),
3403 3400 ('k', 'keyword', [], _('do case-insensitive search for a keyword')),
3404 3401 ('r', 'rev', [], _('show the specified revision or range')),
3405 3402 ('', 'removed', None, _('include revisions where files were removed')),
3406 3403 ('m', 'only-merges', None, _('show only merges')),
3407 3404 ('u', 'user', [], _('revisions committed by user')),
3408 3405 ('b', 'only-branch', [],
3409 3406 _('show only changesets within the given named branch')),
3410 3407 ('P', 'prune', [], _('do not display revision or any of its ancestors')),
3411 3408 ] + logopts + walkopts,
3412 3409 _('[OPTION]... [FILE]')),
3413 3410 "manifest":
3414 3411 (manifest,
3415 3412 [('r', 'rev', '', _('revision to display'))],
3416 3413 _('[-r REV]')),
3417 3414 "^merge":
3418 3415 (merge,
3419 3416 [('f', 'force', None, _('force a merge with outstanding changes')),
3420 3417 ('r', 'rev', '', _('revision to merge')),
3421 3418 ('P', 'preview', None,
3422 3419 _('review revisions to merge (no merge is performed)'))],
3423 3420 _('[-f] [[-r] REV]')),
3424 3421 "outgoing|out":
3425 3422 (outgoing,
3426 3423 [('f', 'force', None,
3427 3424 _('run even when remote repository is unrelated')),
3428 3425 ('r', 'rev', [],
3429 3426 _('a specific revision up to which you would like to push')),
3430 3427 ('n', 'newest-first', None, _('show newest record first')),
3431 3428 ] + logopts + remoteopts,
3432 3429 _('[-M] [-p] [-n] [-f] [-r REV]... [DEST]')),
3433 3430 "^parents":
3434 3431 (parents,
3435 3432 [('r', 'rev', '', _('show parents from the specified revision')),
3436 3433 ] + templateopts,
3437 3434 _('[-r REV] [FILE]')),
3438 3435 "paths": (paths, [], _('[NAME]')),
3439 3436 "^pull":
3440 3437 (pull,
3441 3438 [('u', 'update', None,
3442 3439 _('update to new tip if changesets were pulled')),
3443 3440 ('f', 'force', None,
3444 3441 _('run even when remote repository is unrelated')),
3445 3442 ('r', 'rev', [],
3446 3443 _('a specific revision up to which you would like to pull')),
3447 3444 ] + remoteopts,
3448 3445 _('[-u] [-f] [-r REV]... [-e CMD] [--remotecmd CMD] [SOURCE]')),
3449 3446 "^push":
3450 3447 (push,
3451 3448 [('f', 'force', None, _('force push')),
3452 3449 ('r', 'rev', [],
3453 3450 _('a specific revision up to which you would like to push')),
3454 3451 ] + remoteopts,
3455 3452 _('[-f] [-r REV]... [-e CMD] [--remotecmd CMD] [DEST]')),
3456 3453 "recover": (recover, []),
3457 3454 "^remove|rm":
3458 3455 (remove,
3459 3456 [('A', 'after', None, _('record delete for missing files')),
3460 3457 ('f', 'force', None,
3461 3458 _('remove (and delete) file even if added or modified')),
3462 3459 ] + walkopts,
3463 3460 _('[OPTION]... FILE...')),
3464 3461 "rename|mv":
3465 3462 (rename,
3466 3463 [('A', 'after', None, _('record a rename that has already occurred')),
3467 3464 ('f', 'force', None,
3468 3465 _('forcibly copy over an existing managed file')),
3469 3466 ] + walkopts + dryrunopts,
3470 3467 _('[OPTION]... SOURCE... DEST')),
3471 3468 "resolve":
3472 3469 (resolve,
3473 3470 [('a', 'all', None, _('remerge all unresolved files')),
3474 3471 ('l', 'list', None, _('list state of files needing merge')),
3475 3472 ('m', 'mark', None, _('mark files as resolved')),
3476 3473 ('u', 'unmark', None, _('unmark files as resolved'))]
3477 3474 + walkopts,
3478 3475 _('[OPTION]... [FILE]...')),
3479 3476 "revert":
3480 3477 (revert,
3481 3478 [('a', 'all', None, _('revert all changes when no arguments given')),
3482 3479 ('d', 'date', '', _('tipmost revision matching date')),
3483 3480 ('r', 'rev', '', _('revision to revert to')),
3484 3481 ('', 'no-backup', None, _('do not save backup copies of files')),
3485 3482 ] + walkopts + dryrunopts,
3486 3483 _('[OPTION]... [-r REV] [NAME]...')),
3487 3484 "rollback": (rollback, []),
3488 3485 "root": (root, []),
3489 3486 "^serve":
3490 3487 (serve,
3491 3488 [('A', 'accesslog', '', _('name of access log file to write to')),
3492 3489 ('d', 'daemon', None, _('run server in background')),
3493 3490 ('', 'daemon-pipefds', '', _('used internally by daemon mode')),
3494 3491 ('E', 'errorlog', '', _('name of error log file to write to')),
3495 3492 ('p', 'port', 0, _('port to listen on (default: 8000)')),
3496 3493 ('a', 'address', '', _('address to listen on (default: all interfaces)')),
3497 3494 ('', 'prefix', '', _('prefix path to serve from (default: server root)')),
3498 3495 ('n', 'name', '',
3499 3496 _('name to show in web pages (default: working directory)')),
3500 3497 ('', 'webdir-conf', '', _('name of the webdir config file'
3501 3498 ' (serve more than one repository)')),
3502 3499 ('', 'pid-file', '', _('name of file to write process ID to')),
3503 3500 ('', 'stdio', None, _('for remote clients')),
3504 3501 ('t', 'templates', '', _('web templates to use')),
3505 3502 ('', 'style', '', _('template style to use')),
3506 3503 ('6', 'ipv6', None, _('use IPv6 in addition to IPv4')),
3507 3504 ('', 'certificate', '', _('SSL certificate file'))],
3508 3505 _('[OPTION]...')),
3509 3506 "showconfig|debugconfig":
3510 3507 (showconfig,
3511 3508 [('u', 'untrusted', None, _('show untrusted configuration options'))],
3512 3509 _('[-u] [NAME]...')),
3513 3510 "^status|st":
3514 3511 (status,
3515 3512 [('A', 'all', None, _('show status of all files')),
3516 3513 ('m', 'modified', None, _('show only modified files')),
3517 3514 ('a', 'added', None, _('show only added files')),
3518 3515 ('r', 'removed', None, _('show only removed files')),
3519 3516 ('d', 'deleted', None, _('show only deleted (but tracked) files')),
3520 3517 ('c', 'clean', None, _('show only files without changes')),
3521 3518 ('u', 'unknown', None, _('show only unknown (not tracked) files')),
3522 3519 ('i', 'ignored', None, _('show only ignored files')),
3523 3520 ('n', 'no-status', None, _('hide status prefix')),
3524 3521 ('C', 'copies', None, _('show source of copied files')),
3525 3522 ('0', 'print0', None,
3526 3523 _('end filenames with NUL, for use with xargs')),
3527 3524 ('', 'rev', [], _('show difference from revision')),
3528 3525 ] + walkopts,
3529 3526 _('[OPTION]... [FILE]...')),
3530 3527 "tag":
3531 3528 (tag,
3532 3529 [('f', 'force', None, _('replace existing tag')),
3533 3530 ('l', 'local', None, _('make the tag local')),
3534 3531 ('r', 'rev', '', _('revision to tag')),
3535 3532 ('', 'remove', None, _('remove a tag')),
3536 3533 # -l/--local is already there, commitopts cannot be used
3537 3534 ('m', 'message', '', _('use <text> as commit message')),
3538 3535 ] + commitopts2,
3539 3536 _('[-l] [-m TEXT] [-d DATE] [-u USER] [-r REV] NAME...')),
3540 3537 "tags": (tags, []),
3541 3538 "tip":
3542 3539 (tip,
3543 3540 [('p', 'patch', None, _('show patch')),
3544 3541 ('g', 'git', None, _('use git extended diff format')),
3545 3542 ] + templateopts,
3546 3543 _('[-p]')),
3547 3544 "unbundle":
3548 3545 (unbundle,
3549 3546 [('u', 'update', None,
3550 3547 _('update to new tip if changesets were unbundled'))],
3551 3548 _('[-u] FILE...')),
3552 3549 "^update|up|checkout|co":
3553 3550 (update,
3554 3551 [('C', 'clean', None, _('overwrite locally modified files (no backup)')),
3555 3552 ('c', 'check', None, _('check for uncommitted changes')),
3556 3553 ('d', 'date', '', _('tipmost revision matching date')),
3557 3554 ('r', 'rev', '', _('revision'))],
3558 3555 _('[-C] [-d DATE] [[-r] REV]')),
3559 3556 "verify": (verify, []),
3560 3557 "version": (version_, []),
3561 3558 }
3562 3559
3563 3560 norepo = ("clone init version help debugcommands debugcomplete debugdata"
3564 3561 " debugindex debugindexdot debugdate debuginstall debugfsinfo")
3565 3562 optionalrepo = ("identify paths serve showconfig debugancestor")
@@ -1,97 +1,97 b''
1 1 #!/bin/sh
2 2
3 3 mkdir t
4 4 cd t
5 5 hg init
6 6 echo import > port
7 7 hg add port
8 8 hg commit -m 0 -u spam -d '0 0'
9 9 echo export >> port
10 10 hg commit -m 1 -u eggs -d '1 0'
11 11 echo export > port
12 12 echo vaportight >> port
13 13 echo 'import/export' >> port
14 14 hg commit -m 2 -u spam -d '2 0'
15 15 echo 'import/export' >> port
16 16 hg commit -m 3 -u eggs -d '3 0'
17 17 head -n 3 port > port1
18 18 mv port1 port
19 19 hg commit -m 4 -u spam -d '4 0'
20 20 echo % pattern error
21 21 hg grep '**test**'
22 22 echo % simple
23 23 hg grep port port
24 24 echo % all
25 hg grep --all -nu port port
25 hg grep --traceback --all -nu port port
26 26 echo % other
27 27 hg grep import port
28 28
29 29 hg cp port port2
30 30 hg commit -m 4 -u spam -d '5 0'
31 echo '% follow'
32 hg grep -f 'import$' port2
31 echo % follow
32 hg grep --traceback -f 'import$' port2
33 33 echo deport >> port2
34 34 hg commit -m 5 -u eggs -d '6 0'
35 35 hg grep -f --all -nu port port2
36 36
37 37 cd ..
38 38 hg init t2
39 39 cd t2
40 40 hg grep foobar foo
41 41 hg grep foobar
42 42 echo blue >> color
43 43 echo black >> color
44 44 hg add color
45 45 hg ci -m 0
46 46 echo orange >> color
47 47 hg ci -m 1
48 48 echo black > color
49 49 hg ci -m 2
50 50 echo orange >> color
51 51 echo blue >> color
52 52 hg ci -m 3
53 53 hg grep orange
54 54 hg grep --all orange
55 55
56 56 echo % match in last "line" without newline
57 57 python -c 'fp = open("noeol", "wb"); fp.write("no infinite loop"); fp.close();'
58 58 hg ci -Amnoeol
59 59 echo % last character omitted in output to avoid infinite loop
60 60 hg grep loop
61 61
62 62 # Got a traceback when using grep on a single
63 63 # revision with renamed files.
64 64 cd ..
65 65 echo % issue 685
66 66 hg init issue685
67 67 cd issue685
68 68 echo octarine > color
69 69 hg ci -Amcolor
70 70 hg rename color colour
71 71 hg ci -Am rename
72 72 hg grep octarine
73 73 # Used to crash here
74 74 hg grep -r 1 octarine
75 75
76 76 # Issue337: test that grep follows parent-child relationships instead
77 77 # of just using revision numbers.
78 78 cd ..
79 79 echo % issue 337
80 80 hg init issue337
81 81 cd issue337
82 82
83 83 echo white > color
84 84 hg commit -A -m "0 white"
85 85
86 86 echo red > color
87 87 hg commit -A -m "1 red"
88 88
89 89 hg update 0
90 90 echo black > color
91 91 hg commit -A -m "2 black"
92 92
93 93 hg update --clean 1
94 94 echo blue > color
95 95 hg commit -A -m "3 blue"
96 96
97 97 hg grep --all red
General Comments 0
You need to be logged in to leave comments. Login now