##// END OF EJS Templates
en-us: labeled
timeless@mozdev.org -
r17500:8ac8db8d default
parent child Browse files
Show More
@@ -1,5898 +1,5898 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 or any later version.
7 7
8 8 from node import hex, bin, nullid, nullrev, short
9 9 from lock import release
10 10 from i18n import _, gettext
11 11 import os, re, difflib, time, tempfile, errno
12 12 import hg, scmutil, util, revlog, extensions, copies, error, bookmarks
13 13 import patch, help, url, encoding, templatekw, discovery
14 14 import archival, changegroup, cmdutil, hbisect
15 15 import sshserver, hgweb, hgweb.server, commandserver
16 16 import merge as mergemod
17 17 import minirst, revset, fileset
18 18 import dagparser, context, simplemerge, graphmod
19 19 import random, setdiscovery, treediscovery, dagutil, pvec, localrepo
20 20 import phases, obsolete
21 21
22 22 table = {}
23 23
24 24 command = cmdutil.command(table)
25 25
26 26 # common command options
27 27
28 28 globalopts = [
29 29 ('R', 'repository', '',
30 30 _('repository root directory or name of overlay bundle file'),
31 31 _('REPO')),
32 32 ('', 'cwd', '',
33 33 _('change working directory'), _('DIR')),
34 34 ('y', 'noninteractive', None,
35 35 _('do not prompt, automatically pick the first choice for all prompts')),
36 36 ('q', 'quiet', None, _('suppress output')),
37 37 ('v', 'verbose', None, _('enable additional output')),
38 38 ('', 'config', [],
39 39 _('set/override config option (use \'section.name=value\')'),
40 40 _('CONFIG')),
41 41 ('', 'debug', None, _('enable debugging output')),
42 42 ('', 'debugger', None, _('start debugger')),
43 43 ('', 'encoding', encoding.encoding, _('set the charset encoding'),
44 44 _('ENCODE')),
45 45 ('', 'encodingmode', encoding.encodingmode,
46 46 _('set the charset encoding mode'), _('MODE')),
47 47 ('', 'traceback', None, _('always print a traceback on exception')),
48 48 ('', 'time', None, _('time how long the command takes')),
49 49 ('', 'profile', None, _('print command execution profile')),
50 50 ('', 'version', None, _('output version information and exit')),
51 51 ('h', 'help', None, _('display help and exit')),
52 52 ]
53 53
54 54 dryrunopts = [('n', 'dry-run', None,
55 55 _('do not perform actions, just print output'))]
56 56
57 57 remoteopts = [
58 58 ('e', 'ssh', '',
59 59 _('specify ssh command to use'), _('CMD')),
60 60 ('', 'remotecmd', '',
61 61 _('specify hg command to run on the remote side'), _('CMD')),
62 62 ('', 'insecure', None,
63 63 _('do not verify server certificate (ignoring web.cacerts config)')),
64 64 ]
65 65
66 66 walkopts = [
67 67 ('I', 'include', [],
68 68 _('include names matching the given patterns'), _('PATTERN')),
69 69 ('X', 'exclude', [],
70 70 _('exclude names matching the given patterns'), _('PATTERN')),
71 71 ]
72 72
73 73 commitopts = [
74 74 ('m', 'message', '',
75 75 _('use text as commit message'), _('TEXT')),
76 76 ('l', 'logfile', '',
77 77 _('read commit message from file'), _('FILE')),
78 78 ]
79 79
80 80 commitopts2 = [
81 81 ('d', 'date', '',
82 82 _('record the specified date as commit date'), _('DATE')),
83 83 ('u', 'user', '',
84 84 _('record the specified user as committer'), _('USER')),
85 85 ]
86 86
87 87 templateopts = [
88 88 ('', 'style', '',
89 89 _('display using template map file'), _('STYLE')),
90 90 ('', 'template', '',
91 91 _('display with template'), _('TEMPLATE')),
92 92 ]
93 93
94 94 logopts = [
95 95 ('p', 'patch', None, _('show patch')),
96 96 ('g', 'git', None, _('use git extended diff format')),
97 97 ('l', 'limit', '',
98 98 _('limit number of changes displayed'), _('NUM')),
99 99 ('M', 'no-merges', None, _('do not show merges')),
100 100 ('', 'stat', None, _('output diffstat-style summary of changes')),
101 101 ('G', 'graph', None, _("show the revision DAG")),
102 102 ] + templateopts
103 103
104 104 diffopts = [
105 105 ('a', 'text', None, _('treat all files as text')),
106 106 ('g', 'git', None, _('use git extended diff format')),
107 107 ('', 'nodates', None, _('omit dates from diff headers'))
108 108 ]
109 109
110 110 diffwsopts = [
111 111 ('w', 'ignore-all-space', None,
112 112 _('ignore white space when comparing lines')),
113 113 ('b', 'ignore-space-change', None,
114 114 _('ignore changes in the amount of white space')),
115 115 ('B', 'ignore-blank-lines', None,
116 116 _('ignore changes whose lines are all blank')),
117 117 ]
118 118
119 119 diffopts2 = [
120 120 ('p', 'show-function', None, _('show which function each change is in')),
121 121 ('', 'reverse', None, _('produce a diff that undoes the changes')),
122 122 ] + diffwsopts + [
123 123 ('U', 'unified', '',
124 124 _('number of lines of context to show'), _('NUM')),
125 125 ('', 'stat', None, _('output diffstat-style summary of changes')),
126 126 ]
127 127
128 128 mergetoolopts = [
129 129 ('t', 'tool', '', _('specify merge tool')),
130 130 ]
131 131
132 132 similarityopts = [
133 133 ('s', 'similarity', '',
134 134 _('guess renamed files by similarity (0<=s<=100)'), _('SIMILARITY'))
135 135 ]
136 136
137 137 subrepoopts = [
138 138 ('S', 'subrepos', None,
139 139 _('recurse into subrepositories'))
140 140 ]
141 141
142 142 # Commands start here, listed alphabetically
143 143
144 144 @command('^add',
145 145 walkopts + subrepoopts + dryrunopts,
146 146 _('[OPTION]... [FILE]...'))
147 147 def add(ui, repo, *pats, **opts):
148 148 """add the specified files on the next commit
149 149
150 150 Schedule files to be version controlled and added to the
151 151 repository.
152 152
153 153 The files will be added to the repository at the next commit. To
154 154 undo an add before that, see :hg:`forget`.
155 155
156 156 If no names are given, add all files to the repository.
157 157
158 158 .. container:: verbose
159 159
160 160 An example showing how new (unknown) files are added
161 161 automatically by :hg:`add`::
162 162
163 163 $ ls
164 164 foo.c
165 165 $ hg status
166 166 ? foo.c
167 167 $ hg add
168 168 adding foo.c
169 169 $ hg status
170 170 A foo.c
171 171
172 172 Returns 0 if all files are successfully added.
173 173 """
174 174
175 175 m = scmutil.match(repo[None], pats, opts)
176 176 rejected = cmdutil.add(ui, repo, m, opts.get('dry_run'),
177 177 opts.get('subrepos'), prefix="", explicitonly=False)
178 178 return rejected and 1 or 0
179 179
180 180 @command('addremove',
181 181 similarityopts + walkopts + dryrunopts,
182 182 _('[OPTION]... [FILE]...'))
183 183 def addremove(ui, repo, *pats, **opts):
184 184 """add all new files, delete all missing files
185 185
186 186 Add all new files and remove all missing files from the
187 187 repository.
188 188
189 189 New files are ignored if they match any of the patterns in
190 190 ``.hgignore``. As with add, these changes take effect at the next
191 191 commit.
192 192
193 193 Use the -s/--similarity option to detect renamed files. This
194 194 option takes a percentage between 0 (disabled) and 100 (files must
195 195 be identical) as its parameter. With a parameter greater than 0,
196 196 this compares every removed file with every added file and records
197 197 those similar enough as renames. Detecting renamed files this way
198 198 can be expensive. After using this option, :hg:`status -C` can be
199 199 used to check which files were identified as moved or renamed. If
200 200 not specified, -s/--similarity defaults to 100 and only renames of
201 201 identical files are detected.
202 202
203 203 Returns 0 if all files are successfully added.
204 204 """
205 205 try:
206 206 sim = float(opts.get('similarity') or 100)
207 207 except ValueError:
208 208 raise util.Abort(_('similarity must be a number'))
209 209 if sim < 0 or sim > 100:
210 210 raise util.Abort(_('similarity must be between 0 and 100'))
211 211 return scmutil.addremove(repo, pats, opts, similarity=sim / 100.0)
212 212
213 213 @command('^annotate|blame',
214 214 [('r', 'rev', '', _('annotate the specified revision'), _('REV')),
215 215 ('', 'follow', None,
216 216 _('follow copies/renames and list the filename (DEPRECATED)')),
217 217 ('', 'no-follow', None, _("don't follow copies and renames")),
218 218 ('a', 'text', None, _('treat all files as text')),
219 219 ('u', 'user', None, _('list the author (long with -v)')),
220 220 ('f', 'file', None, _('list the filename')),
221 221 ('d', 'date', None, _('list the date (short with -q)')),
222 222 ('n', 'number', None, _('list the revision number (default)')),
223 223 ('c', 'changeset', None, _('list the changeset')),
224 224 ('l', 'line-number', None, _('show line number at the first appearance'))
225 225 ] + diffwsopts + walkopts,
226 226 _('[-r REV] [-f] [-a] [-u] [-d] [-n] [-c] [-l] FILE...'))
227 227 def annotate(ui, repo, *pats, **opts):
228 228 """show changeset information by line for each file
229 229
230 230 List changes in files, showing the revision id responsible for
231 231 each line
232 232
233 233 This command is useful for discovering when a change was made and
234 234 by whom.
235 235
236 236 Without the -a/--text option, annotate will avoid processing files
237 237 it detects as binary. With -a, annotate will annotate the file
238 238 anyway, although the results will probably be neither useful
239 239 nor desirable.
240 240
241 241 Returns 0 on success.
242 242 """
243 243 if opts.get('follow'):
244 244 # --follow is deprecated and now just an alias for -f/--file
245 245 # to mimic the behavior of Mercurial before version 1.5
246 246 opts['file'] = True
247 247
248 248 datefunc = ui.quiet and util.shortdate or util.datestr
249 249 getdate = util.cachefunc(lambda x: datefunc(x[0].date()))
250 250
251 251 if not pats:
252 252 raise util.Abort(_('at least one filename or pattern is required'))
253 253
254 254 hexfn = ui.debugflag and hex or short
255 255
256 256 opmap = [('user', ' ', lambda x: ui.shortuser(x[0].user())),
257 257 ('number', ' ', lambda x: str(x[0].rev())),
258 258 ('changeset', ' ', lambda x: hexfn(x[0].node())),
259 259 ('date', ' ', getdate),
260 260 ('file', ' ', lambda x: x[0].path()),
261 261 ('line_number', ':', lambda x: str(x[1])),
262 262 ]
263 263
264 264 if (not opts.get('user') and not opts.get('changeset')
265 265 and not opts.get('date') and not opts.get('file')):
266 266 opts['number'] = True
267 267
268 268 linenumber = opts.get('line_number') is not None
269 269 if linenumber and (not opts.get('changeset')) and (not opts.get('number')):
270 270 raise util.Abort(_('at least one of -n/-c is required for -l'))
271 271
272 272 funcmap = [(func, sep) for op, sep, func in opmap if opts.get(op)]
273 273 funcmap[0] = (funcmap[0][0], '') # no separator in front of first column
274 274
275 275 def bad(x, y):
276 276 raise util.Abort("%s: %s" % (x, y))
277 277
278 278 ctx = scmutil.revsingle(repo, opts.get('rev'))
279 279 m = scmutil.match(ctx, pats, opts)
280 280 m.bad = bad
281 281 follow = not opts.get('no_follow')
282 282 diffopts = patch.diffopts(ui, opts, section='annotate')
283 283 for abs in ctx.walk(m):
284 284 fctx = ctx[abs]
285 285 if not opts.get('text') and util.binary(fctx.data()):
286 286 ui.write(_("%s: binary file\n") % ((pats and m.rel(abs)) or abs))
287 287 continue
288 288
289 289 lines = fctx.annotate(follow=follow, linenumber=linenumber,
290 290 diffopts=diffopts)
291 291 pieces = []
292 292
293 293 for f, sep in funcmap:
294 294 l = [f(n) for n, dummy in lines]
295 295 if l:
296 296 sized = [(x, encoding.colwidth(x)) for x in l]
297 297 ml = max([w for x, w in sized])
298 298 pieces.append(["%s%s%s" % (sep, ' ' * (ml - w), x)
299 299 for x, w in sized])
300 300
301 301 if pieces:
302 302 for p, l in zip(zip(*pieces), lines):
303 303 ui.write("%s: %s" % ("".join(p), l[1]))
304 304
305 305 if lines and not lines[-1][1].endswith('\n'):
306 306 ui.write('\n')
307 307
308 308 @command('archive',
309 309 [('', 'no-decode', None, _('do not pass files through decoders')),
310 310 ('p', 'prefix', '', _('directory prefix for files in archive'),
311 311 _('PREFIX')),
312 312 ('r', 'rev', '', _('revision to distribute'), _('REV')),
313 313 ('t', 'type', '', _('type of distribution to create'), _('TYPE')),
314 314 ] + subrepoopts + walkopts,
315 315 _('[OPTION]... DEST'))
316 316 def archive(ui, repo, dest, **opts):
317 317 '''create an unversioned archive of a repository revision
318 318
319 319 By default, the revision used is the parent of the working
320 320 directory; use -r/--rev to specify a different revision.
321 321
322 322 The archive type is automatically detected based on file
323 323 extension (or override using -t/--type).
324 324
325 325 .. container:: verbose
326 326
327 327 Examples:
328 328
329 329 - create a zip file containing the 1.0 release::
330 330
331 331 hg archive -r 1.0 project-1.0.zip
332 332
333 333 - create a tarball excluding .hg files::
334 334
335 335 hg archive project.tar.gz -X ".hg*"
336 336
337 337 Valid types are:
338 338
339 339 :``files``: a directory full of files (default)
340 340 :``tar``: tar archive, uncompressed
341 341 :``tbz2``: tar archive, compressed using bzip2
342 342 :``tgz``: tar archive, compressed using gzip
343 343 :``uzip``: zip archive, uncompressed
344 344 :``zip``: zip archive, compressed using deflate
345 345
346 346 The exact name of the destination archive or directory is given
347 347 using a format string; see :hg:`help export` for details.
348 348
349 349 Each member added to an archive file has a directory prefix
350 350 prepended. Use -p/--prefix to specify a format string for the
351 351 prefix. The default is the basename of the archive, with suffixes
352 352 removed.
353 353
354 354 Returns 0 on success.
355 355 '''
356 356
357 357 ctx = scmutil.revsingle(repo, opts.get('rev'))
358 358 if not ctx:
359 359 raise util.Abort(_('no working directory: please specify a revision'))
360 360 node = ctx.node()
361 361 dest = cmdutil.makefilename(repo, dest, node)
362 362 if os.path.realpath(dest) == repo.root:
363 363 raise util.Abort(_('repository root cannot be destination'))
364 364
365 365 kind = opts.get('type') or archival.guesskind(dest) or 'files'
366 366 prefix = opts.get('prefix')
367 367
368 368 if dest == '-':
369 369 if kind == 'files':
370 370 raise util.Abort(_('cannot archive plain files to stdout'))
371 371 dest = cmdutil.makefileobj(repo, dest)
372 372 if not prefix:
373 373 prefix = os.path.basename(repo.root) + '-%h'
374 374
375 375 prefix = cmdutil.makefilename(repo, prefix, node)
376 376 matchfn = scmutil.match(ctx, [], opts)
377 377 archival.archive(repo, dest, node, kind, not opts.get('no_decode'),
378 378 matchfn, prefix, subrepos=opts.get('subrepos'))
379 379
380 380 @command('backout',
381 381 [('', 'merge', None, _('merge with old dirstate parent after backout')),
382 382 ('', 'parent', '',
383 383 _('parent to choose when backing out merge (DEPRECATED)'), _('REV')),
384 384 ('r', 'rev', '', _('revision to backout'), _('REV')),
385 385 ] + mergetoolopts + walkopts + commitopts + commitopts2,
386 386 _('[OPTION]... [-r] REV'))
387 387 def backout(ui, repo, node=None, rev=None, **opts):
388 388 '''reverse effect of earlier changeset
389 389
390 390 Prepare a new changeset with the effect of REV undone in the
391 391 current working directory.
392 392
393 393 If REV is the parent of the working directory, then this new changeset
394 394 is committed automatically. Otherwise, hg needs to merge the
395 395 changes and the merged result is left uncommitted.
396 396
397 397 .. note::
398 398 backout cannot be used to fix either an unwanted or
399 399 incorrect merge.
400 400
401 401 .. container:: verbose
402 402
403 403 By default, the pending changeset will have one parent,
404 404 maintaining a linear history. With --merge, the pending
405 405 changeset will instead have two parents: the old parent of the
406 406 working directory and a new child of REV that simply undoes REV.
407 407
408 408 Before version 1.7, the behavior without --merge was equivalent
409 409 to specifying --merge followed by :hg:`update --clean .` to
410 410 cancel the merge and leave the child of REV as a head to be
411 411 merged separately.
412 412
413 413 See :hg:`help dates` for a list of formats valid for -d/--date.
414 414
415 415 Returns 0 on success.
416 416 '''
417 417 if rev and node:
418 418 raise util.Abort(_("please specify just one revision"))
419 419
420 420 if not rev:
421 421 rev = node
422 422
423 423 if not rev:
424 424 raise util.Abort(_("please specify a revision to backout"))
425 425
426 426 date = opts.get('date')
427 427 if date:
428 428 opts['date'] = util.parsedate(date)
429 429
430 430 cmdutil.bailifchanged(repo)
431 431 node = scmutil.revsingle(repo, rev).node()
432 432
433 433 op1, op2 = repo.dirstate.parents()
434 434 a = repo.changelog.ancestor(op1, node)
435 435 if a != node:
436 436 raise util.Abort(_('cannot backout change on a different branch'))
437 437
438 438 p1, p2 = repo.changelog.parents(node)
439 439 if p1 == nullid:
440 440 raise util.Abort(_('cannot backout a change with no parents'))
441 441 if p2 != nullid:
442 442 if not opts.get('parent'):
443 443 raise util.Abort(_('cannot backout a merge changeset'))
444 444 p = repo.lookup(opts['parent'])
445 445 if p not in (p1, p2):
446 446 raise util.Abort(_('%s is not a parent of %s') %
447 447 (short(p), short(node)))
448 448 parent = p
449 449 else:
450 450 if opts.get('parent'):
451 451 raise util.Abort(_('cannot use --parent on non-merge changeset'))
452 452 parent = p1
453 453
454 454 # the backout should appear on the same branch
455 455 wlock = repo.wlock()
456 456 try:
457 457 branch = repo.dirstate.branch()
458 458 hg.clean(repo, node, show_stats=False)
459 459 repo.dirstate.setbranch(branch)
460 460 revert_opts = opts.copy()
461 461 revert_opts['date'] = None
462 462 revert_opts['all'] = True
463 463 revert_opts['rev'] = hex(parent)
464 464 revert_opts['no_backup'] = None
465 465 revert(ui, repo, **revert_opts)
466 466 if not opts.get('merge') and op1 != node:
467 467 try:
468 468 ui.setconfig('ui', 'forcemerge', opts.get('tool', ''))
469 469 return hg.update(repo, op1)
470 470 finally:
471 471 ui.setconfig('ui', 'forcemerge', '')
472 472
473 473 commit_opts = opts.copy()
474 474 commit_opts['addremove'] = False
475 475 if not commit_opts['message'] and not commit_opts['logfile']:
476 476 # we don't translate commit messages
477 477 commit_opts['message'] = "Backed out changeset %s" % short(node)
478 478 commit_opts['force_editor'] = True
479 479 commit(ui, repo, **commit_opts)
480 480 def nice(node):
481 481 return '%d:%s' % (repo.changelog.rev(node), short(node))
482 482 ui.status(_('changeset %s backs out changeset %s\n') %
483 483 (nice(repo.changelog.tip()), nice(node)))
484 484 if opts.get('merge') and op1 != node:
485 485 hg.clean(repo, op1, show_stats=False)
486 486 ui.status(_('merging with changeset %s\n')
487 487 % nice(repo.changelog.tip()))
488 488 try:
489 489 ui.setconfig('ui', 'forcemerge', opts.get('tool', ''))
490 490 return hg.merge(repo, hex(repo.changelog.tip()))
491 491 finally:
492 492 ui.setconfig('ui', 'forcemerge', '')
493 493 finally:
494 494 wlock.release()
495 495 return 0
496 496
497 497 @command('bisect',
498 498 [('r', 'reset', False, _('reset bisect state')),
499 499 ('g', 'good', False, _('mark changeset good')),
500 500 ('b', 'bad', False, _('mark changeset bad')),
501 501 ('s', 'skip', False, _('skip testing changeset')),
502 502 ('e', 'extend', False, _('extend the bisect range')),
503 503 ('c', 'command', '', _('use command to check changeset state'), _('CMD')),
504 504 ('U', 'noupdate', False, _('do not update to target'))],
505 505 _("[-gbsr] [-U] [-c CMD] [REV]"))
506 506 def bisect(ui, repo, rev=None, extra=None, command=None,
507 507 reset=None, good=None, bad=None, skip=None, extend=None,
508 508 noupdate=None):
509 509 """subdivision search of changesets
510 510
511 511 This command helps to find changesets which introduce problems. To
512 512 use, mark the earliest changeset you know exhibits the problem as
513 513 bad, then mark the latest changeset which is free from the problem
514 514 as good. Bisect will update your working directory to a revision
515 515 for testing (unless the -U/--noupdate option is specified). Once
516 516 you have performed tests, mark the working directory as good or
517 517 bad, and bisect will either update to another candidate changeset
518 518 or announce that it has found the bad revision.
519 519
520 520 As a shortcut, you can also use the revision argument to mark a
521 521 revision as good or bad without checking it out first.
522 522
523 523 If you supply a command, it will be used for automatic bisection.
524 524 The environment variable HG_NODE will contain the ID of the
525 525 changeset being tested. The exit status of the command will be
526 526 used to mark revisions as good or bad: status 0 means good, 125
527 527 means to skip the revision, 127 (command not found) will abort the
528 528 bisection, and any other non-zero exit status means the revision
529 529 is bad.
530 530
531 531 .. container:: verbose
532 532
533 533 Some examples:
534 534
535 535 - start a bisection with known bad revision 12, and good revision 34::
536 536
537 537 hg bisect --bad 34
538 538 hg bisect --good 12
539 539
540 540 - advance the current bisection by marking current revision as good or
541 541 bad::
542 542
543 543 hg bisect --good
544 544 hg bisect --bad
545 545
546 546 - mark the current revision, or a known revision, to be skipped (eg. if
547 547 that revision is not usable because of another issue)::
548 548
549 549 hg bisect --skip
550 550 hg bisect --skip 23
551 551
552 552 - forget the current bisection::
553 553
554 554 hg bisect --reset
555 555
556 556 - use 'make && make tests' to automatically find the first broken
557 557 revision::
558 558
559 559 hg bisect --reset
560 560 hg bisect --bad 34
561 561 hg bisect --good 12
562 562 hg bisect --command 'make && make tests'
563 563
564 564 - see all changesets whose states are already known in the current
565 565 bisection::
566 566
567 567 hg log -r "bisect(pruned)"
568 568
569 569 - see the changeset currently being bisected (especially useful
570 570 if running with -U/--noupdate)::
571 571
572 572 hg log -r "bisect(current)"
573 573
574 574 - see all changesets that took part in the current bisection::
575 575
576 576 hg log -r "bisect(range)"
577 577
578 578 - with the graphlog extension, you can even get a nice graph::
579 579
580 580 hg log --graph -r "bisect(range)"
581 581
582 582 See :hg:`help revsets` for more about the `bisect()` keyword.
583 583
584 584 Returns 0 on success.
585 585 """
586 586 def extendbisectrange(nodes, good):
587 587 # bisect is incomplete when it ends on a merge node and
588 588 # one of the parent was not checked.
589 589 parents = repo[nodes[0]].parents()
590 590 if len(parents) > 1:
591 591 side = good and state['bad'] or state['good']
592 592 num = len(set(i.node() for i in parents) & set(side))
593 593 if num == 1:
594 594 return parents[0].ancestor(parents[1])
595 595 return None
596 596
597 597 def print_result(nodes, good):
598 598 displayer = cmdutil.show_changeset(ui, repo, {})
599 599 if len(nodes) == 1:
600 600 # narrowed it down to a single revision
601 601 if good:
602 602 ui.write(_("The first good revision is:\n"))
603 603 else:
604 604 ui.write(_("The first bad revision is:\n"))
605 605 displayer.show(repo[nodes[0]])
606 606 extendnode = extendbisectrange(nodes, good)
607 607 if extendnode is not None:
608 608 ui.write(_('Not all ancestors of this changeset have been'
609 609 ' checked.\nUse bisect --extend to continue the '
610 610 'bisection from\nthe common ancestor, %s.\n')
611 611 % extendnode)
612 612 else:
613 613 # multiple possible revisions
614 614 if good:
615 615 ui.write(_("Due to skipped revisions, the first "
616 616 "good revision could be any of:\n"))
617 617 else:
618 618 ui.write(_("Due to skipped revisions, the first "
619 619 "bad revision could be any of:\n"))
620 620 for n in nodes:
621 621 displayer.show(repo[n])
622 622 displayer.close()
623 623
624 624 def check_state(state, interactive=True):
625 625 if not state['good'] or not state['bad']:
626 626 if (good or bad or skip or reset) and interactive:
627 627 return
628 628 if not state['good']:
629 629 raise util.Abort(_('cannot bisect (no known good revisions)'))
630 630 else:
631 631 raise util.Abort(_('cannot bisect (no known bad revisions)'))
632 632 return True
633 633
634 634 # backward compatibility
635 635 if rev in "good bad reset init".split():
636 636 ui.warn(_("(use of 'hg bisect <cmd>' is deprecated)\n"))
637 637 cmd, rev, extra = rev, extra, None
638 638 if cmd == "good":
639 639 good = True
640 640 elif cmd == "bad":
641 641 bad = True
642 642 else:
643 643 reset = True
644 644 elif extra or good + bad + skip + reset + extend + bool(command) > 1:
645 645 raise util.Abort(_('incompatible arguments'))
646 646
647 647 if reset:
648 648 p = repo.join("bisect.state")
649 649 if os.path.exists(p):
650 650 os.unlink(p)
651 651 return
652 652
653 653 state = hbisect.load_state(repo)
654 654
655 655 if command:
656 656 changesets = 1
657 657 try:
658 658 node = state['current'][0]
659 659 except LookupError:
660 660 if noupdate:
661 661 raise util.Abort(_('current bisect revision is unknown - '
662 662 'start a new bisect to fix'))
663 663 node, p2 = repo.dirstate.parents()
664 664 if p2 != nullid:
665 665 raise util.Abort(_('current bisect revision is a merge'))
666 666 try:
667 667 while changesets:
668 668 # update state
669 669 state['current'] = [node]
670 670 hbisect.save_state(repo, state)
671 671 status = util.system(command,
672 672 environ={'HG_NODE': hex(node)},
673 673 out=ui.fout)
674 674 if status == 125:
675 675 transition = "skip"
676 676 elif status == 0:
677 677 transition = "good"
678 678 # status < 0 means process was killed
679 679 elif status == 127:
680 680 raise util.Abort(_("failed to execute %s") % command)
681 681 elif status < 0:
682 682 raise util.Abort(_("%s killed") % command)
683 683 else:
684 684 transition = "bad"
685 685 ctx = scmutil.revsingle(repo, rev, node)
686 686 rev = None # clear for future iterations
687 687 state[transition].append(ctx.node())
688 688 ui.status(_('changeset %d:%s: %s\n') % (ctx, ctx, transition))
689 689 check_state(state, interactive=False)
690 690 # bisect
691 691 nodes, changesets, good = hbisect.bisect(repo.changelog, state)
692 692 # update to next check
693 693 node = nodes[0]
694 694 if not noupdate:
695 695 cmdutil.bailifchanged(repo)
696 696 hg.clean(repo, node, show_stats=False)
697 697 finally:
698 698 state['current'] = [node]
699 699 hbisect.save_state(repo, state)
700 700 print_result(nodes, good)
701 701 return
702 702
703 703 # update state
704 704
705 705 if rev:
706 706 nodes = [repo.lookup(i) for i in scmutil.revrange(repo, [rev])]
707 707 else:
708 708 nodes = [repo.lookup('.')]
709 709
710 710 if good or bad or skip:
711 711 if good:
712 712 state['good'] += nodes
713 713 elif bad:
714 714 state['bad'] += nodes
715 715 elif skip:
716 716 state['skip'] += nodes
717 717 hbisect.save_state(repo, state)
718 718
719 719 if not check_state(state):
720 720 return
721 721
722 722 # actually bisect
723 723 nodes, changesets, good = hbisect.bisect(repo.changelog, state)
724 724 if extend:
725 725 if not changesets:
726 726 extendnode = extendbisectrange(nodes, good)
727 727 if extendnode is not None:
728 728 ui.write(_("Extending search to changeset %d:%s\n"
729 729 % (extendnode.rev(), extendnode)))
730 730 state['current'] = [extendnode.node()]
731 731 hbisect.save_state(repo, state)
732 732 if noupdate:
733 733 return
734 734 cmdutil.bailifchanged(repo)
735 735 return hg.clean(repo, extendnode.node())
736 736 raise util.Abort(_("nothing to extend"))
737 737
738 738 if changesets == 0:
739 739 print_result(nodes, good)
740 740 else:
741 741 assert len(nodes) == 1 # only a single node can be tested next
742 742 node = nodes[0]
743 743 # compute the approximate number of remaining tests
744 744 tests, size = 0, 2
745 745 while size <= changesets:
746 746 tests, size = tests + 1, size * 2
747 747 rev = repo.changelog.rev(node)
748 748 ui.write(_("Testing changeset %d:%s "
749 749 "(%d changesets remaining, ~%d tests)\n")
750 750 % (rev, short(node), changesets, tests))
751 751 state['current'] = [node]
752 752 hbisect.save_state(repo, state)
753 753 if not noupdate:
754 754 cmdutil.bailifchanged(repo)
755 755 return hg.clean(repo, node)
756 756
757 757 @command('bookmarks',
758 758 [('f', 'force', False, _('force')),
759 759 ('r', 'rev', '', _('revision'), _('REV')),
760 760 ('d', 'delete', False, _('delete a given bookmark')),
761 761 ('m', 'rename', '', _('rename a given bookmark'), _('NAME')),
762 762 ('i', 'inactive', False, _('mark a bookmark inactive'))],
763 763 _('hg bookmarks [-f] [-d] [-i] [-m NAME] [-r REV] [NAME]'))
764 764 def bookmark(ui, repo, mark=None, rev=None, force=False, delete=False,
765 765 rename=None, inactive=False):
766 766 '''track a line of development with movable markers
767 767
768 768 Bookmarks are pointers to certain commits that move when committing.
769 769 Bookmarks are local. They can be renamed, copied and deleted. It is
770 770 possible to use :hg:`merge NAME` to merge from a given bookmark, and
771 771 :hg:`update NAME` to update to a given bookmark.
772 772
773 773 You can use :hg:`bookmark NAME` to set a bookmark on the working
774 774 directory's parent revision with the given name. If you specify
775 775 a revision using -r REV (where REV may be an existing bookmark),
776 776 the bookmark is assigned to that revision.
777 777
778 778 Bookmarks can be pushed and pulled between repositories (see :hg:`help
779 779 push` and :hg:`help pull`). This requires both the local and remote
780 780 repositories to support bookmarks. For versions prior to 1.8, this means
781 781 the bookmarks extension must be enabled.
782 782
783 783 With -i/--inactive, the new bookmark will not be made the active
784 784 bookmark. If -r/--rev is given, the new bookmark will not be made
785 785 active even if -i/--inactive is not given. If no NAME is given, the
786 786 current active bookmark will be marked inactive.
787 787 '''
788 788 hexfn = ui.debugflag and hex or short
789 789 marks = repo._bookmarks
790 790 cur = repo.changectx('.').node()
791 791
792 792 if delete:
793 793 if mark is None:
794 794 raise util.Abort(_("bookmark name required"))
795 795 if mark not in marks:
796 796 raise util.Abort(_("bookmark '%s' does not exist") % mark)
797 797 if mark == repo._bookmarkcurrent:
798 798 bookmarks.setcurrent(repo, None)
799 799 del marks[mark]
800 800 bookmarks.write(repo)
801 801 return
802 802
803 803 if rename:
804 804 if rename not in marks:
805 805 raise util.Abort(_("bookmark '%s' does not exist") % rename)
806 806 if mark in marks and not force:
807 807 raise util.Abort(_("bookmark '%s' already exists "
808 808 "(use -f to force)") % mark)
809 809 if mark is None:
810 810 raise util.Abort(_("new bookmark name required"))
811 811 marks[mark] = marks[rename]
812 812 if repo._bookmarkcurrent == rename and not inactive:
813 813 bookmarks.setcurrent(repo, mark)
814 814 del marks[rename]
815 815 bookmarks.write(repo)
816 816 return
817 817
818 818 if mark is not None:
819 819 if "\n" in mark:
820 820 raise util.Abort(_("bookmark name cannot contain newlines"))
821 821 mark = mark.strip()
822 822 if not mark:
823 823 raise util.Abort(_("bookmark names cannot consist entirely of "
824 824 "whitespace"))
825 825 if inactive and mark == repo._bookmarkcurrent:
826 826 bookmarks.setcurrent(repo, None)
827 827 return
828 828 if mark in marks and not force:
829 829 raise util.Abort(_("bookmark '%s' already exists "
830 830 "(use -f to force)") % mark)
831 831 if ((mark in repo.branchmap() or mark == repo.dirstate.branch())
832 832 and not force):
833 833 raise util.Abort(
834 834 _("a bookmark cannot have the name of an existing branch"))
835 835 if rev:
836 836 marks[mark] = repo.lookup(rev)
837 837 else:
838 838 marks[mark] = cur
839 839 if not inactive and cur == marks[mark]:
840 840 bookmarks.setcurrent(repo, mark)
841 841 bookmarks.write(repo)
842 842 return
843 843
844 844 if mark is None:
845 845 if rev:
846 846 raise util.Abort(_("bookmark name required"))
847 847 if len(marks) == 0:
848 848 ui.status(_("no bookmarks set\n"))
849 849 else:
850 850 for bmark, n in sorted(marks.iteritems()):
851 851 current = repo._bookmarkcurrent
852 852 if bmark == current and n == cur:
853 853 prefix, label = '*', 'bookmarks.current'
854 854 else:
855 855 prefix, label = ' ', ''
856 856
857 857 if ui.quiet:
858 858 ui.write("%s\n" % bmark, label=label)
859 859 else:
860 860 ui.write(" %s %-25s %d:%s\n" % (
861 861 prefix, bmark, repo.changelog.rev(n), hexfn(n)),
862 862 label=label)
863 863 return
864 864
865 865 @command('branch',
866 866 [('f', 'force', None,
867 867 _('set branch name even if it shadows an existing branch')),
868 868 ('C', 'clean', None, _('reset branch name to parent branch name'))],
869 869 _('[-fC] [NAME]'))
870 870 def branch(ui, repo, label=None, **opts):
871 871 """set or show the current branch name
872 872
873 873 .. note::
874 874 Branch names are permanent and global. Use :hg:`bookmark` to create a
875 875 light-weight bookmark instead. See :hg:`help glossary` for more
876 876 information about named branches and bookmarks.
877 877
878 878 With no argument, show the current branch name. With one argument,
879 879 set the working directory branch name (the branch will not exist
880 880 in the repository until the next commit). Standard practice
881 881 recommends that primary development take place on the 'default'
882 882 branch.
883 883
884 884 Unless -f/--force is specified, branch will not let you set a
885 885 branch name that already exists, even if it's inactive.
886 886
887 887 Use -C/--clean to reset the working directory branch to that of
888 888 the parent of the working directory, negating a previous branch
889 889 change.
890 890
891 891 Use the command :hg:`update` to switch to an existing branch. Use
892 892 :hg:`commit --close-branch` to mark this branch as closed.
893 893
894 894 Returns 0 on success.
895 895 """
896 896 if not opts.get('clean') and not label:
897 897 ui.write("%s\n" % repo.dirstate.branch())
898 898 return
899 899
900 900 wlock = repo.wlock()
901 901 try:
902 902 if opts.get('clean'):
903 903 label = repo[None].p1().branch()
904 904 repo.dirstate.setbranch(label)
905 905 ui.status(_('reset working directory to branch %s\n') % label)
906 906 elif label:
907 907 if not opts.get('force') and label in repo.branchmap():
908 908 if label not in [p.branch() for p in repo.parents()]:
909 909 raise util.Abort(_('a branch of the same name already'
910 910 ' exists'),
911 911 # i18n: "it" refers to an existing branch
912 912 hint=_("use 'hg update' to switch to it"))
913 913 repo.dirstate.setbranch(label)
914 914 ui.status(_('marked working directory as branch %s\n') % label)
915 915 ui.status(_('(branches are permanent and global, '
916 916 'did you want a bookmark?)\n'))
917 917 finally:
918 918 wlock.release()
919 919
920 920 @command('branches',
921 921 [('a', 'active', False, _('show only branches that have unmerged heads')),
922 922 ('c', 'closed', False, _('show normal and closed branches'))],
923 923 _('[-ac]'))
924 924 def branches(ui, repo, active=False, closed=False):
925 925 """list repository named branches
926 926
927 927 List the repository's named branches, indicating which ones are
928 928 inactive. If -c/--closed is specified, also list branches which have
929 929 been marked closed (see :hg:`commit --close-branch`).
930 930
931 931 If -a/--active is specified, only show active branches. A branch
932 932 is considered active if it contains repository heads.
933 933
934 934 Use the command :hg:`update` to switch to an existing branch.
935 935
936 936 Returns 0.
937 937 """
938 938
939 939 hexfunc = ui.debugflag and hex or short
940 940
941 941 activebranches = set([repo[n].branch() for n in repo.heads()])
942 942 branches = []
943 943 for tag, heads in repo.branchmap().iteritems():
944 944 for h in reversed(heads):
945 945 ctx = repo[h]
946 946 isopen = not ctx.closesbranch()
947 947 if isopen:
948 948 tip = ctx
949 949 break
950 950 else:
951 951 tip = repo[heads[-1]]
952 952 isactive = tag in activebranches and isopen
953 953 branches.append((tip, isactive, isopen))
954 954 branches.sort(key=lambda i: (i[1], i[0].rev(), i[0].branch(), i[2]),
955 955 reverse=True)
956 956
957 957 for ctx, isactive, isopen in branches:
958 958 if (not active) or isactive:
959 959 if isactive:
960 960 label = 'branches.active'
961 961 notice = ''
962 962 elif not isopen:
963 963 if not closed:
964 964 continue
965 965 label = 'branches.closed'
966 966 notice = _(' (closed)')
967 967 else:
968 968 label = 'branches.inactive'
969 969 notice = _(' (inactive)')
970 970 if ctx.branch() == repo.dirstate.branch():
971 971 label = 'branches.current'
972 972 rev = str(ctx.rev()).rjust(31 - encoding.colwidth(ctx.branch()))
973 973 rev = ui.label('%s:%s' % (rev, hexfunc(ctx.node())),
974 974 'log.changeset')
975 975 tag = ui.label(ctx.branch(), label)
976 976 if ui.quiet:
977 977 ui.write("%s\n" % tag)
978 978 else:
979 979 ui.write("%s %s%s\n" % (tag, rev, notice))
980 980
981 981 @command('bundle',
982 982 [('f', 'force', None, _('run even when the destination is unrelated')),
983 983 ('r', 'rev', [], _('a changeset intended to be added to the destination'),
984 984 _('REV')),
985 985 ('b', 'branch', [], _('a specific branch you would like to bundle'),
986 986 _('BRANCH')),
987 987 ('', 'base', [],
988 988 _('a base changeset assumed to be available at the destination'),
989 989 _('REV')),
990 990 ('a', 'all', None, _('bundle all changesets in the repository')),
991 991 ('t', 'type', 'bzip2', _('bundle compression type to use'), _('TYPE')),
992 992 ] + remoteopts,
993 993 _('[-f] [-t TYPE] [-a] [-r REV]... [--base REV]... FILE [DEST]'))
994 994 def bundle(ui, repo, fname, dest=None, **opts):
995 995 """create a changegroup file
996 996
997 997 Generate a compressed changegroup file collecting changesets not
998 998 known to be in another repository.
999 999
1000 1000 If you omit the destination repository, then hg assumes the
1001 1001 destination will have all the nodes you specify with --base
1002 1002 parameters. To create a bundle containing all changesets, use
1003 1003 -a/--all (or --base null).
1004 1004
1005 1005 You can change compression method with the -t/--type option.
1006 1006 The available compression methods are: none, bzip2, and
1007 1007 gzip (by default, bundles are compressed using bzip2).
1008 1008
1009 1009 The bundle file can then be transferred using conventional means
1010 1010 and applied to another repository with the unbundle or pull
1011 1011 command. This is useful when direct push and pull are not
1012 1012 available or when exporting an entire repository is undesirable.
1013 1013
1014 1014 Applying bundles preserves all changeset contents including
1015 1015 permissions, copy/rename information, and revision history.
1016 1016
1017 1017 Returns 0 on success, 1 if no changes found.
1018 1018 """
1019 1019 revs = None
1020 1020 if 'rev' in opts:
1021 1021 revs = scmutil.revrange(repo, opts['rev'])
1022 1022
1023 1023 bundletype = opts.get('type', 'bzip2').lower()
1024 1024 btypes = {'none': 'HG10UN', 'bzip2': 'HG10BZ', 'gzip': 'HG10GZ'}
1025 1025 bundletype = btypes.get(bundletype)
1026 1026 if bundletype not in changegroup.bundletypes:
1027 1027 raise util.Abort(_('unknown bundle type specified with --type'))
1028 1028
1029 1029 if opts.get('all'):
1030 1030 base = ['null']
1031 1031 else:
1032 1032 base = scmutil.revrange(repo, opts.get('base'))
1033 1033 if base:
1034 1034 if dest:
1035 1035 raise util.Abort(_("--base is incompatible with specifying "
1036 1036 "a destination"))
1037 1037 common = [repo.lookup(rev) for rev in base]
1038 1038 heads = revs and map(repo.lookup, revs) or revs
1039 1039 cg = repo.getbundle('bundle', heads=heads, common=common)
1040 1040 outgoing = None
1041 1041 else:
1042 1042 dest = ui.expandpath(dest or 'default-push', dest or 'default')
1043 1043 dest, branches = hg.parseurl(dest, opts.get('branch'))
1044 1044 other = hg.peer(repo, opts, dest)
1045 1045 revs, checkout = hg.addbranchrevs(repo, other, branches, revs)
1046 1046 heads = revs and map(repo.lookup, revs) or revs
1047 1047 outgoing = discovery.findcommonoutgoing(repo, other,
1048 1048 onlyheads=heads,
1049 1049 force=opts.get('force'),
1050 1050 portable=True)
1051 1051 cg = repo.getlocalbundle('bundle', outgoing)
1052 1052 if not cg:
1053 1053 scmutil.nochangesfound(ui, repo, outgoing and outgoing.excluded)
1054 1054 return 1
1055 1055
1056 1056 changegroup.writebundle(cg, fname, bundletype)
1057 1057
1058 1058 @command('cat',
1059 1059 [('o', 'output', '',
1060 1060 _('print output to file with formatted name'), _('FORMAT')),
1061 1061 ('r', 'rev', '', _('print the given revision'), _('REV')),
1062 1062 ('', 'decode', None, _('apply any matching decode filter')),
1063 1063 ] + walkopts,
1064 1064 _('[OPTION]... FILE...'))
1065 1065 def cat(ui, repo, file1, *pats, **opts):
1066 1066 """output the current or given revision of files
1067 1067
1068 1068 Print the specified files as they were at the given revision. If
1069 1069 no revision is given, the parent of the working directory is used,
1070 1070 or tip if no revision is checked out.
1071 1071
1072 1072 Output may be to a file, in which case the name of the file is
1073 1073 given using a format string. The formatting rules are the same as
1074 1074 for the export command, with the following additions:
1075 1075
1076 1076 :``%s``: basename of file being printed
1077 1077 :``%d``: dirname of file being printed, or '.' if in repository root
1078 1078 :``%p``: root-relative path name of file being printed
1079 1079
1080 1080 Returns 0 on success.
1081 1081 """
1082 1082 ctx = scmutil.revsingle(repo, opts.get('rev'))
1083 1083 err = 1
1084 1084 m = scmutil.match(ctx, (file1,) + pats, opts)
1085 1085 for abs in ctx.walk(m):
1086 1086 fp = cmdutil.makefileobj(repo, opts.get('output'), ctx.node(),
1087 1087 pathname=abs)
1088 1088 data = ctx[abs].data()
1089 1089 if opts.get('decode'):
1090 1090 data = repo.wwritedata(abs, data)
1091 1091 fp.write(data)
1092 1092 fp.close()
1093 1093 err = 0
1094 1094 return err
1095 1095
1096 1096 @command('^clone',
1097 1097 [('U', 'noupdate', None,
1098 1098 _('the clone will include an empty working copy (only a repository)')),
1099 1099 ('u', 'updaterev', '', _('revision, tag or branch to check out'), _('REV')),
1100 1100 ('r', 'rev', [], _('include the specified changeset'), _('REV')),
1101 1101 ('b', 'branch', [], _('clone only the specified branch'), _('BRANCH')),
1102 1102 ('', 'pull', None, _('use pull protocol to copy metadata')),
1103 1103 ('', 'uncompressed', None, _('use uncompressed transfer (fast over LAN)')),
1104 1104 ] + remoteopts,
1105 1105 _('[OPTION]... SOURCE [DEST]'))
1106 1106 def clone(ui, source, dest=None, **opts):
1107 1107 """make a copy of an existing repository
1108 1108
1109 1109 Create a copy of an existing repository in a new directory.
1110 1110
1111 1111 If no destination directory name is specified, it defaults to the
1112 1112 basename of the source.
1113 1113
1114 1114 The location of the source is added to the new repository's
1115 1115 ``.hg/hgrc`` file, as the default to be used for future pulls.
1116 1116
1117 1117 Only local paths and ``ssh://`` URLs are supported as
1118 1118 destinations. For ``ssh://`` destinations, no working directory or
1119 1119 ``.hg/hgrc`` will be created on the remote side.
1120 1120
1121 1121 To pull only a subset of changesets, specify one or more revisions
1122 1122 identifiers with -r/--rev or branches with -b/--branch. The
1123 1123 resulting clone will contain only the specified changesets and
1124 1124 their ancestors. These options (or 'clone src#rev dest') imply
1125 1125 --pull, even for local source repositories. Note that specifying a
1126 1126 tag will include the tagged changeset but not the changeset
1127 1127 containing the tag.
1128 1128
1129 1129 To check out a particular version, use -u/--update, or
1130 1130 -U/--noupdate to create a clone with no working directory.
1131 1131
1132 1132 .. container:: verbose
1133 1133
1134 1134 For efficiency, hardlinks are used for cloning whenever the
1135 1135 source and destination are on the same filesystem (note this
1136 1136 applies only to the repository data, not to the working
1137 1137 directory). Some filesystems, such as AFS, implement hardlinking
1138 1138 incorrectly, but do not report errors. In these cases, use the
1139 1139 --pull option to avoid hardlinking.
1140 1140
1141 1141 In some cases, you can clone repositories and the working
1142 1142 directory using full hardlinks with ::
1143 1143
1144 1144 $ cp -al REPO REPOCLONE
1145 1145
1146 1146 This is the fastest way to clone, but it is not always safe. The
1147 1147 operation is not atomic (making sure REPO is not modified during
1148 1148 the operation is up to you) and you have to make sure your
1149 1149 editor breaks hardlinks (Emacs and most Linux Kernel tools do
1150 1150 so). Also, this is not compatible with certain extensions that
1151 1151 place their metadata under the .hg directory, such as mq.
1152 1152
1153 1153 Mercurial will update the working directory to the first applicable
1154 1154 revision from this list:
1155 1155
1156 1156 a) null if -U or the source repository has no changesets
1157 1157 b) if -u . and the source repository is local, the first parent of
1158 1158 the source repository's working directory
1159 1159 c) the changeset specified with -u (if a branch name, this means the
1160 1160 latest head of that branch)
1161 1161 d) the changeset specified with -r
1162 1162 e) the tipmost head specified with -b
1163 1163 f) the tipmost head specified with the url#branch source syntax
1164 1164 g) the tipmost head of the default branch
1165 1165 h) tip
1166 1166
1167 1167 Examples:
1168 1168
1169 1169 - clone a remote repository to a new directory named hg/::
1170 1170
1171 1171 hg clone http://selenic.com/hg
1172 1172
1173 1173 - create a lightweight local clone::
1174 1174
1175 1175 hg clone project/ project-feature/
1176 1176
1177 1177 - clone from an absolute path on an ssh server (note double-slash)::
1178 1178
1179 1179 hg clone ssh://user@server//home/projects/alpha/
1180 1180
1181 1181 - do a high-speed clone over a LAN while checking out a
1182 1182 specified version::
1183 1183
1184 1184 hg clone --uncompressed http://server/repo -u 1.5
1185 1185
1186 1186 - create a repository without changesets after a particular revision::
1187 1187
1188 1188 hg clone -r 04e544 experimental/ good/
1189 1189
1190 1190 - clone (and track) a particular named branch::
1191 1191
1192 1192 hg clone http://selenic.com/hg#stable
1193 1193
1194 1194 See :hg:`help urls` for details on specifying URLs.
1195 1195
1196 1196 Returns 0 on success.
1197 1197 """
1198 1198 if opts.get('noupdate') and opts.get('updaterev'):
1199 1199 raise util.Abort(_("cannot specify both --noupdate and --updaterev"))
1200 1200
1201 1201 r = hg.clone(ui, opts, source, dest,
1202 1202 pull=opts.get('pull'),
1203 1203 stream=opts.get('uncompressed'),
1204 1204 rev=opts.get('rev'),
1205 1205 update=opts.get('updaterev') or not opts.get('noupdate'),
1206 1206 branch=opts.get('branch'))
1207 1207
1208 1208 return r is None
1209 1209
1210 1210 @command('^commit|ci',
1211 1211 [('A', 'addremove', None,
1212 1212 _('mark new/missing files as added/removed before committing')),
1213 1213 ('', 'close-branch', None,
1214 1214 _('mark a branch as closed, hiding it from the branch list')),
1215 1215 ('', 'amend', None, _('amend the parent of the working dir')),
1216 1216 ] + walkopts + commitopts + commitopts2 + subrepoopts,
1217 1217 _('[OPTION]... [FILE]...'))
1218 1218 def commit(ui, repo, *pats, **opts):
1219 1219 """commit the specified files or all outstanding changes
1220 1220
1221 1221 Commit changes to the given files into the repository. Unlike a
1222 1222 centralized SCM, this operation is a local operation. See
1223 1223 :hg:`push` for a way to actively distribute your changes.
1224 1224
1225 1225 If a list of files is omitted, all changes reported by :hg:`status`
1226 1226 will be committed.
1227 1227
1228 1228 If you are committing the result of a merge, do not provide any
1229 1229 filenames or -I/-X filters.
1230 1230
1231 1231 If no commit message is specified, Mercurial starts your
1232 1232 configured editor where you can enter a message. In case your
1233 1233 commit fails, you will find a backup of your message in
1234 1234 ``.hg/last-message.txt``.
1235 1235
1236 1236 The --amend flag can be used to amend the parent of the
1237 1237 working directory with a new commit that contains the changes
1238 1238 in the parent in addition to those currently reported by :hg:`status`,
1239 1239 if there are any. The old commit is stored in a backup bundle in
1240 1240 ``.hg/strip-backup`` (see :hg:`help bundle` and :hg:`help unbundle`
1241 1241 on how to restore it).
1242 1242
1243 1243 Message, user and date are taken from the amended commit unless
1244 1244 specified. When a message isn't specified on the command line,
1245 1245 the editor will open with the message of the amended commit.
1246 1246
1247 1247 It is not possible to amend public changesets (see :hg:`help phases`)
1248 1248 or changesets that have children.
1249 1249
1250 1250 See :hg:`help dates` for a list of formats valid for -d/--date.
1251 1251
1252 1252 Returns 0 on success, 1 if nothing changed.
1253 1253 """
1254 1254 if opts.get('subrepos'):
1255 1255 # Let --subrepos on the command line overide config setting.
1256 1256 ui.setconfig('ui', 'commitsubrepos', True)
1257 1257
1258 1258 extra = {}
1259 1259 if opts.get('close_branch'):
1260 1260 if repo['.'].node() not in repo.branchheads():
1261 1261 # The topo heads set is included in the branch heads set of the
1262 1262 # current branch, so it's sufficient to test branchheads
1263 1263 raise util.Abort(_('can only close branch heads'))
1264 1264 extra['close'] = 1
1265 1265
1266 1266 branch = repo[None].branch()
1267 1267 bheads = repo.branchheads(branch)
1268 1268
1269 1269 if opts.get('amend'):
1270 1270 if ui.configbool('ui', 'commitsubrepos'):
1271 1271 raise util.Abort(_('cannot amend recursively'))
1272 1272
1273 1273 old = repo['.']
1274 1274 if old.phase() == phases.public:
1275 1275 raise util.Abort(_('cannot amend public changesets'))
1276 1276 if len(old.parents()) > 1:
1277 1277 raise util.Abort(_('cannot amend merge changesets'))
1278 1278 if len(repo[None].parents()) > 1:
1279 1279 raise util.Abort(_('cannot amend while merging'))
1280 1280 if old.children():
1281 1281 raise util.Abort(_('cannot amend changeset with children'))
1282 1282
1283 1283 e = cmdutil.commiteditor
1284 1284 if opts.get('force_editor'):
1285 1285 e = cmdutil.commitforceeditor
1286 1286
1287 1287 def commitfunc(ui, repo, message, match, opts):
1288 1288 editor = e
1289 1289 # message contains text from -m or -l, if it's empty,
1290 1290 # open the editor with the old message
1291 1291 if not message:
1292 1292 message = old.description()
1293 1293 editor = cmdutil.commitforceeditor
1294 1294 return repo.commit(message,
1295 1295 opts.get('user') or old.user(),
1296 1296 opts.get('date') or old.date(),
1297 1297 match,
1298 1298 editor=editor,
1299 1299 extra=extra)
1300 1300
1301 1301 current = repo._bookmarkcurrent
1302 1302 marks = old.bookmarks()
1303 1303 node = cmdutil.amend(ui, repo, commitfunc, old, extra, pats, opts)
1304 1304 if node == old.node():
1305 1305 ui.status(_("nothing changed\n"))
1306 1306 return 1
1307 1307 elif marks:
1308 1308 ui.debug('moving bookmarks %r from %s to %s\n' %
1309 1309 (marks, old.hex(), hex(node)))
1310 1310 for bm in marks:
1311 1311 repo._bookmarks[bm] = node
1312 1312 if bm == current:
1313 1313 bookmarks.setcurrent(repo, bm)
1314 1314 bookmarks.write(repo)
1315 1315 else:
1316 1316 e = cmdutil.commiteditor
1317 1317 if opts.get('force_editor'):
1318 1318 e = cmdutil.commitforceeditor
1319 1319
1320 1320 def commitfunc(ui, repo, message, match, opts):
1321 1321 return repo.commit(message, opts.get('user'), opts.get('date'),
1322 1322 match, editor=e, extra=extra)
1323 1323
1324 1324 node = cmdutil.commit(ui, repo, commitfunc, pats, opts)
1325 1325
1326 1326 if not node:
1327 1327 stat = repo.status(match=scmutil.match(repo[None], pats, opts))
1328 1328 if stat[3]:
1329 1329 ui.status(_("nothing changed (%d missing files, see "
1330 1330 "'hg status')\n") % len(stat[3]))
1331 1331 else:
1332 1332 ui.status(_("nothing changed\n"))
1333 1333 return 1
1334 1334
1335 1335 ctx = repo[node]
1336 1336 parents = ctx.parents()
1337 1337
1338 1338 if (not opts.get('amend') and bheads and node not in bheads and not
1339 1339 [x for x in parents if x.node() in bheads and x.branch() == branch]):
1340 1340 ui.status(_('created new head\n'))
1341 1341 # The message is not printed for initial roots. For the other
1342 1342 # changesets, it is printed in the following situations:
1343 1343 #
1344 1344 # Par column: for the 2 parents with ...
1345 1345 # N: null or no parent
1346 1346 # B: parent is on another named branch
1347 1347 # C: parent is a regular non head changeset
1348 1348 # H: parent was a branch head of the current branch
1349 1349 # Msg column: whether we print "created new head" message
1350 1350 # In the following, it is assumed that there already exists some
1351 1351 # initial branch heads of the current branch, otherwise nothing is
1352 1352 # printed anyway.
1353 1353 #
1354 1354 # Par Msg Comment
1355 1355 # NN y additional topo root
1356 1356 #
1357 1357 # BN y additional branch root
1358 1358 # CN y additional topo head
1359 1359 # HN n usual case
1360 1360 #
1361 1361 # BB y weird additional branch root
1362 1362 # CB y branch merge
1363 1363 # HB n merge with named branch
1364 1364 #
1365 1365 # CC y additional head from merge
1366 1366 # CH n merge with a head
1367 1367 #
1368 1368 # HH n head merge: head count decreases
1369 1369
1370 1370 if not opts.get('close_branch'):
1371 1371 for r in parents:
1372 1372 if r.closesbranch() and r.branch() == branch:
1373 1373 ui.status(_('reopening closed branch head %d\n') % r)
1374 1374
1375 1375 if ui.debugflag:
1376 1376 ui.write(_('committed changeset %d:%s\n') % (int(ctx), ctx.hex()))
1377 1377 elif ui.verbose:
1378 1378 ui.write(_('committed changeset %d:%s\n') % (int(ctx), ctx))
1379 1379
1380 1380 @command('copy|cp',
1381 1381 [('A', 'after', None, _('record a copy that has already occurred')),
1382 1382 ('f', 'force', None, _('forcibly copy over an existing managed file')),
1383 1383 ] + walkopts + dryrunopts,
1384 1384 _('[OPTION]... [SOURCE]... DEST'))
1385 1385 def copy(ui, repo, *pats, **opts):
1386 1386 """mark files as copied for the next commit
1387 1387
1388 1388 Mark dest as having copies of source files. If dest is a
1389 1389 directory, copies are put in that directory. If dest is a file,
1390 1390 the source must be a single file.
1391 1391
1392 1392 By default, this command copies the contents of files as they
1393 1393 exist in the working directory. If invoked with -A/--after, the
1394 1394 operation is recorded, but no copying is performed.
1395 1395
1396 1396 This command takes effect with the next commit. To undo a copy
1397 1397 before that, see :hg:`revert`.
1398 1398
1399 1399 Returns 0 on success, 1 if errors are encountered.
1400 1400 """
1401 1401 wlock = repo.wlock(False)
1402 1402 try:
1403 1403 return cmdutil.copy(ui, repo, pats, opts)
1404 1404 finally:
1405 1405 wlock.release()
1406 1406
1407 1407 @command('debugancestor', [], _('[INDEX] REV1 REV2'))
1408 1408 def debugancestor(ui, repo, *args):
1409 1409 """find the ancestor revision of two revisions in a given index"""
1410 1410 if len(args) == 3:
1411 1411 index, rev1, rev2 = args
1412 1412 r = revlog.revlog(scmutil.opener(os.getcwd(), audit=False), index)
1413 1413 lookup = r.lookup
1414 1414 elif len(args) == 2:
1415 1415 if not repo:
1416 1416 raise util.Abort(_("there is no Mercurial repository here "
1417 1417 "(.hg not found)"))
1418 1418 rev1, rev2 = args
1419 1419 r = repo.changelog
1420 1420 lookup = repo.lookup
1421 1421 else:
1422 1422 raise util.Abort(_('either two or three arguments required'))
1423 1423 a = r.ancestor(lookup(rev1), lookup(rev2))
1424 1424 ui.write("%d:%s\n" % (r.rev(a), hex(a)))
1425 1425
1426 1426 @command('debugbuilddag',
1427 1427 [('m', 'mergeable-file', None, _('add single file mergeable changes')),
1428 1428 ('o', 'overwritten-file', None, _('add single file all revs overwrite')),
1429 1429 ('n', 'new-file', None, _('add new file at each rev'))],
1430 1430 _('[OPTION]... [TEXT]'))
1431 1431 def debugbuilddag(ui, repo, text=None,
1432 1432 mergeable_file=False,
1433 1433 overwritten_file=False,
1434 1434 new_file=False):
1435 1435 """builds a repo with a given DAG from scratch in the current empty repo
1436 1436
1437 1437 The description of the DAG is read from stdin if not given on the
1438 1438 command line.
1439 1439
1440 1440 Elements:
1441 1441
1442 1442 - "+n" is a linear run of n nodes based on the current default parent
1443 1443 - "." is a single node based on the current default parent
1444 1444 - "$" resets the default parent to null (implied at the start);
1445 1445 otherwise the default parent is always the last node created
1446 1446 - "<p" sets the default parent to the backref p
1447 1447 - "*p" is a fork at parent p, which is a backref
1448 1448 - "*p1/p2" is a merge of parents p1 and p2, which are backrefs
1449 1449 - "/p2" is a merge of the preceding node and p2
1450 1450 - ":tag" defines a local tag for the preceding node
1451 1451 - "@branch" sets the named branch for subsequent nodes
1452 1452 - "#...\\n" is a comment up to the end of the line
1453 1453
1454 1454 Whitespace between the above elements is ignored.
1455 1455
1456 1456 A backref is either
1457 1457
1458 1458 - a number n, which references the node curr-n, where curr is the current
1459 1459 node, or
1460 1460 - the name of a local tag you placed earlier using ":tag", or
1461 1461 - empty to denote the default parent.
1462 1462
1463 1463 All string valued-elements are either strictly alphanumeric, or must
1464 1464 be enclosed in double quotes ("..."), with "\\" as escape character.
1465 1465 """
1466 1466
1467 1467 if text is None:
1468 1468 ui.status(_("reading DAG from stdin\n"))
1469 1469 text = ui.fin.read()
1470 1470
1471 1471 cl = repo.changelog
1472 1472 if len(cl) > 0:
1473 1473 raise util.Abort(_('repository is not empty'))
1474 1474
1475 1475 # determine number of revs in DAG
1476 1476 total = 0
1477 1477 for type, data in dagparser.parsedag(text):
1478 1478 if type == 'n':
1479 1479 total += 1
1480 1480
1481 1481 if mergeable_file:
1482 1482 linesperrev = 2
1483 1483 # make a file with k lines per rev
1484 1484 initialmergedlines = [str(i) for i in xrange(0, total * linesperrev)]
1485 1485 initialmergedlines.append("")
1486 1486
1487 1487 tags = []
1488 1488
1489 1489 lock = tr = None
1490 1490 try:
1491 1491 lock = repo.lock()
1492 1492 tr = repo.transaction("builddag")
1493 1493
1494 1494 at = -1
1495 1495 atbranch = 'default'
1496 1496 nodeids = []
1497 1497 id = 0
1498 1498 ui.progress(_('building'), id, unit=_('revisions'), total=total)
1499 1499 for type, data in dagparser.parsedag(text):
1500 1500 if type == 'n':
1501 1501 ui.note('node %s\n' % str(data))
1502 1502 id, ps = data
1503 1503
1504 1504 files = []
1505 1505 fctxs = {}
1506 1506
1507 1507 p2 = None
1508 1508 if mergeable_file:
1509 1509 fn = "mf"
1510 1510 p1 = repo[ps[0]]
1511 1511 if len(ps) > 1:
1512 1512 p2 = repo[ps[1]]
1513 1513 pa = p1.ancestor(p2)
1514 1514 base, local, other = [x[fn].data() for x in pa, p1, p2]
1515 1515 m3 = simplemerge.Merge3Text(base, local, other)
1516 1516 ml = [l.strip() for l in m3.merge_lines()]
1517 1517 ml.append("")
1518 1518 elif at > 0:
1519 1519 ml = p1[fn].data().split("\n")
1520 1520 else:
1521 1521 ml = initialmergedlines
1522 1522 ml[id * linesperrev] += " r%i" % id
1523 1523 mergedtext = "\n".join(ml)
1524 1524 files.append(fn)
1525 1525 fctxs[fn] = context.memfilectx(fn, mergedtext)
1526 1526
1527 1527 if overwritten_file:
1528 1528 fn = "of"
1529 1529 files.append(fn)
1530 1530 fctxs[fn] = context.memfilectx(fn, "r%i\n" % id)
1531 1531
1532 1532 if new_file:
1533 1533 fn = "nf%i" % id
1534 1534 files.append(fn)
1535 1535 fctxs[fn] = context.memfilectx(fn, "r%i\n" % id)
1536 1536 if len(ps) > 1:
1537 1537 if not p2:
1538 1538 p2 = repo[ps[1]]
1539 1539 for fn in p2:
1540 1540 if fn.startswith("nf"):
1541 1541 files.append(fn)
1542 1542 fctxs[fn] = p2[fn]
1543 1543
1544 1544 def fctxfn(repo, cx, path):
1545 1545 return fctxs.get(path)
1546 1546
1547 1547 if len(ps) == 0 or ps[0] < 0:
1548 1548 pars = [None, None]
1549 1549 elif len(ps) == 1:
1550 1550 pars = [nodeids[ps[0]], None]
1551 1551 else:
1552 1552 pars = [nodeids[p] for p in ps]
1553 1553 cx = context.memctx(repo, pars, "r%i" % id, files, fctxfn,
1554 1554 date=(id, 0),
1555 1555 user="debugbuilddag",
1556 1556 extra={'branch': atbranch})
1557 1557 nodeid = repo.commitctx(cx)
1558 1558 nodeids.append(nodeid)
1559 1559 at = id
1560 1560 elif type == 'l':
1561 1561 id, name = data
1562 1562 ui.note('tag %s\n' % name)
1563 1563 tags.append("%s %s\n" % (hex(repo.changelog.node(id)), name))
1564 1564 elif type == 'a':
1565 1565 ui.note('branch %s\n' % data)
1566 1566 atbranch = data
1567 1567 ui.progress(_('building'), id, unit=_('revisions'), total=total)
1568 1568 tr.close()
1569 1569
1570 1570 if tags:
1571 1571 repo.opener.write("localtags", "".join(tags))
1572 1572 finally:
1573 1573 ui.progress(_('building'), None)
1574 1574 release(tr, lock)
1575 1575
1576 1576 @command('debugbundle', [('a', 'all', None, _('show all details'))], _('FILE'))
1577 1577 def debugbundle(ui, bundlepath, all=None, **opts):
1578 1578 """lists the contents of a bundle"""
1579 1579 f = url.open(ui, bundlepath)
1580 1580 try:
1581 1581 gen = changegroup.readbundle(f, bundlepath)
1582 1582 if all:
1583 1583 ui.write("format: id, p1, p2, cset, delta base, len(delta)\n")
1584 1584
1585 1585 def showchunks(named):
1586 1586 ui.write("\n%s\n" % named)
1587 1587 chain = None
1588 1588 while True:
1589 1589 chunkdata = gen.deltachunk(chain)
1590 1590 if not chunkdata:
1591 1591 break
1592 1592 node = chunkdata['node']
1593 1593 p1 = chunkdata['p1']
1594 1594 p2 = chunkdata['p2']
1595 1595 cs = chunkdata['cs']
1596 1596 deltabase = chunkdata['deltabase']
1597 1597 delta = chunkdata['delta']
1598 1598 ui.write("%s %s %s %s %s %s\n" %
1599 1599 (hex(node), hex(p1), hex(p2),
1600 1600 hex(cs), hex(deltabase), len(delta)))
1601 1601 chain = node
1602 1602
1603 1603 chunkdata = gen.changelogheader()
1604 1604 showchunks("changelog")
1605 1605 chunkdata = gen.manifestheader()
1606 1606 showchunks("manifest")
1607 1607 while True:
1608 1608 chunkdata = gen.filelogheader()
1609 1609 if not chunkdata:
1610 1610 break
1611 1611 fname = chunkdata['filename']
1612 1612 showchunks(fname)
1613 1613 else:
1614 1614 chunkdata = gen.changelogheader()
1615 1615 chain = None
1616 1616 while True:
1617 1617 chunkdata = gen.deltachunk(chain)
1618 1618 if not chunkdata:
1619 1619 break
1620 1620 node = chunkdata['node']
1621 1621 ui.write("%s\n" % hex(node))
1622 1622 chain = node
1623 1623 finally:
1624 1624 f.close()
1625 1625
1626 1626 @command('debugcheckstate', [], '')
1627 1627 def debugcheckstate(ui, repo):
1628 1628 """validate the correctness of the current dirstate"""
1629 1629 parent1, parent2 = repo.dirstate.parents()
1630 1630 m1 = repo[parent1].manifest()
1631 1631 m2 = repo[parent2].manifest()
1632 1632 errors = 0
1633 1633 for f in repo.dirstate:
1634 1634 state = repo.dirstate[f]
1635 1635 if state in "nr" and f not in m1:
1636 1636 ui.warn(_("%s in state %s, but not in manifest1\n") % (f, state))
1637 1637 errors += 1
1638 1638 if state in "a" and f in m1:
1639 1639 ui.warn(_("%s in state %s, but also in manifest1\n") % (f, state))
1640 1640 errors += 1
1641 1641 if state in "m" and f not in m1 and f not in m2:
1642 1642 ui.warn(_("%s in state %s, but not in either manifest\n") %
1643 1643 (f, state))
1644 1644 errors += 1
1645 1645 for f in m1:
1646 1646 state = repo.dirstate[f]
1647 1647 if state not in "nrm":
1648 1648 ui.warn(_("%s in manifest1, but listed as state %s") % (f, state))
1649 1649 errors += 1
1650 1650 if errors:
1651 1651 error = _(".hg/dirstate inconsistent with current parent's manifest")
1652 1652 raise util.Abort(error)
1653 1653
1654 1654 @command('debugcommands', [], _('[COMMAND]'))
1655 1655 def debugcommands(ui, cmd='', *args):
1656 1656 """list all available commands and options"""
1657 1657 for cmd, vals in sorted(table.iteritems()):
1658 1658 cmd = cmd.split('|')[0].strip('^')
1659 1659 opts = ', '.join([i[1] for i in vals[1]])
1660 1660 ui.write('%s: %s\n' % (cmd, opts))
1661 1661
1662 1662 @command('debugcomplete',
1663 1663 [('o', 'options', None, _('show the command options'))],
1664 1664 _('[-o] CMD'))
1665 1665 def debugcomplete(ui, cmd='', **opts):
1666 1666 """returns the completion list associated with the given command"""
1667 1667
1668 1668 if opts.get('options'):
1669 1669 options = []
1670 1670 otables = [globalopts]
1671 1671 if cmd:
1672 1672 aliases, entry = cmdutil.findcmd(cmd, table, False)
1673 1673 otables.append(entry[1])
1674 1674 for t in otables:
1675 1675 for o in t:
1676 1676 if "(DEPRECATED)" in o[3]:
1677 1677 continue
1678 1678 if o[0]:
1679 1679 options.append('-%s' % o[0])
1680 1680 options.append('--%s' % o[1])
1681 1681 ui.write("%s\n" % "\n".join(options))
1682 1682 return
1683 1683
1684 1684 cmdlist = cmdutil.findpossible(cmd, table)
1685 1685 if ui.verbose:
1686 1686 cmdlist = [' '.join(c[0]) for c in cmdlist.values()]
1687 1687 ui.write("%s\n" % "\n".join(sorted(cmdlist)))
1688 1688
1689 1689 @command('debugdag',
1690 1690 [('t', 'tags', None, _('use tags as labels')),
1691 1691 ('b', 'branches', None, _('annotate with branch names')),
1692 1692 ('', 'dots', None, _('use dots for runs')),
1693 1693 ('s', 'spaces', None, _('separate elements by spaces'))],
1694 1694 _('[OPTION]... [FILE [REV]...]'))
1695 1695 def debugdag(ui, repo, file_=None, *revs, **opts):
1696 1696 """format the changelog or an index DAG as a concise textual description
1697 1697
1698 1698 If you pass a revlog index, the revlog's DAG is emitted. If you list
1699 revision numbers, they get labelled in the output as rN.
1699 revision numbers, they get labeled in the output as rN.
1700 1700
1701 1701 Otherwise, the changelog DAG of the current repo is emitted.
1702 1702 """
1703 1703 spaces = opts.get('spaces')
1704 1704 dots = opts.get('dots')
1705 1705 if file_:
1706 1706 rlog = revlog.revlog(scmutil.opener(os.getcwd(), audit=False), file_)
1707 1707 revs = set((int(r) for r in revs))
1708 1708 def events():
1709 1709 for r in rlog:
1710 1710 yield 'n', (r, list(set(p for p in rlog.parentrevs(r)
1711 1711 if p != -1)))
1712 1712 if r in revs:
1713 1713 yield 'l', (r, "r%i" % r)
1714 1714 elif repo:
1715 1715 cl = repo.changelog
1716 1716 tags = opts.get('tags')
1717 1717 branches = opts.get('branches')
1718 1718 if tags:
1719 1719 labels = {}
1720 1720 for l, n in repo.tags().items():
1721 1721 labels.setdefault(cl.rev(n), []).append(l)
1722 1722 def events():
1723 1723 b = "default"
1724 1724 for r in cl:
1725 1725 if branches:
1726 1726 newb = cl.read(cl.node(r))[5]['branch']
1727 1727 if newb != b:
1728 1728 yield 'a', newb
1729 1729 b = newb
1730 1730 yield 'n', (r, list(set(p for p in cl.parentrevs(r)
1731 1731 if p != -1)))
1732 1732 if tags:
1733 1733 ls = labels.get(r)
1734 1734 if ls:
1735 1735 for l in ls:
1736 1736 yield 'l', (r, l)
1737 1737 else:
1738 1738 raise util.Abort(_('need repo for changelog dag'))
1739 1739
1740 1740 for line in dagparser.dagtextlines(events(),
1741 1741 addspaces=spaces,
1742 1742 wraplabels=True,
1743 1743 wrapannotations=True,
1744 1744 wrapnonlinear=dots,
1745 1745 usedots=dots,
1746 1746 maxlinewidth=70):
1747 1747 ui.write(line)
1748 1748 ui.write("\n")
1749 1749
1750 1750 @command('debugdata',
1751 1751 [('c', 'changelog', False, _('open changelog')),
1752 1752 ('m', 'manifest', False, _('open manifest'))],
1753 1753 _('-c|-m|FILE REV'))
1754 1754 def debugdata(ui, repo, file_, rev = None, **opts):
1755 1755 """dump the contents of a data file revision"""
1756 1756 if opts.get('changelog') or opts.get('manifest'):
1757 1757 file_, rev = None, file_
1758 1758 elif rev is None:
1759 1759 raise error.CommandError('debugdata', _('invalid arguments'))
1760 1760 r = cmdutil.openrevlog(repo, 'debugdata', file_, opts)
1761 1761 try:
1762 1762 ui.write(r.revision(r.lookup(rev)))
1763 1763 except KeyError:
1764 1764 raise util.Abort(_('invalid revision identifier %s') % rev)
1765 1765
1766 1766 @command('debugdate',
1767 1767 [('e', 'extended', None, _('try extended date formats'))],
1768 1768 _('[-e] DATE [RANGE]'))
1769 1769 def debugdate(ui, date, range=None, **opts):
1770 1770 """parse and display a date"""
1771 1771 if opts["extended"]:
1772 1772 d = util.parsedate(date, util.extendeddateformats)
1773 1773 else:
1774 1774 d = util.parsedate(date)
1775 1775 ui.write("internal: %s %s\n" % d)
1776 1776 ui.write("standard: %s\n" % util.datestr(d))
1777 1777 if range:
1778 1778 m = util.matchdate(range)
1779 1779 ui.write("match: %s\n" % m(d[0]))
1780 1780
1781 1781 @command('debugdiscovery',
1782 1782 [('', 'old', None, _('use old-style discovery')),
1783 1783 ('', 'nonheads', None,
1784 1784 _('use old-style discovery with non-heads included')),
1785 1785 ] + remoteopts,
1786 1786 _('[-l REV] [-r REV] [-b BRANCH]... [OTHER]'))
1787 1787 def debugdiscovery(ui, repo, remoteurl="default", **opts):
1788 1788 """runs the changeset discovery protocol in isolation"""
1789 1789 remoteurl, branches = hg.parseurl(ui.expandpath(remoteurl),
1790 1790 opts.get('branch'))
1791 1791 remote = hg.peer(repo, opts, remoteurl)
1792 1792 ui.status(_('comparing with %s\n') % util.hidepassword(remoteurl))
1793 1793
1794 1794 # make sure tests are repeatable
1795 1795 random.seed(12323)
1796 1796
1797 1797 def doit(localheads, remoteheads, remote=remote):
1798 1798 if opts.get('old'):
1799 1799 if localheads:
1800 1800 raise util.Abort('cannot use localheads with old style '
1801 1801 'discovery')
1802 1802 if not util.safehasattr(remote, 'branches'):
1803 1803 # enable in-client legacy support
1804 1804 remote = localrepo.locallegacypeer(remote.local())
1805 1805 common, _in, hds = treediscovery.findcommonincoming(repo, remote,
1806 1806 force=True)
1807 1807 common = set(common)
1808 1808 if not opts.get('nonheads'):
1809 1809 ui.write("unpruned common: %s\n" % " ".join([short(n)
1810 1810 for n in common]))
1811 1811 dag = dagutil.revlogdag(repo.changelog)
1812 1812 all = dag.ancestorset(dag.internalizeall(common))
1813 1813 common = dag.externalizeall(dag.headsetofconnecteds(all))
1814 1814 else:
1815 1815 common, any, hds = setdiscovery.findcommonheads(ui, repo, remote)
1816 1816 common = set(common)
1817 1817 rheads = set(hds)
1818 1818 lheads = set(repo.heads())
1819 1819 ui.write("common heads: %s\n" % " ".join([short(n) for n in common]))
1820 1820 if lheads <= common:
1821 1821 ui.write("local is subset\n")
1822 1822 elif rheads <= common:
1823 1823 ui.write("remote is subset\n")
1824 1824
1825 1825 serverlogs = opts.get('serverlog')
1826 1826 if serverlogs:
1827 1827 for filename in serverlogs:
1828 1828 logfile = open(filename, 'r')
1829 1829 try:
1830 1830 line = logfile.readline()
1831 1831 while line:
1832 1832 parts = line.strip().split(';')
1833 1833 op = parts[1]
1834 1834 if op == 'cg':
1835 1835 pass
1836 1836 elif op == 'cgss':
1837 1837 doit(parts[2].split(' '), parts[3].split(' '))
1838 1838 elif op == 'unb':
1839 1839 doit(parts[3].split(' '), parts[2].split(' '))
1840 1840 line = logfile.readline()
1841 1841 finally:
1842 1842 logfile.close()
1843 1843
1844 1844 else:
1845 1845 remoterevs, _checkout = hg.addbranchrevs(repo, remote, branches,
1846 1846 opts.get('remote_head'))
1847 1847 localrevs = opts.get('local_head')
1848 1848 doit(localrevs, remoterevs)
1849 1849
1850 1850 @command('debugfileset',
1851 1851 [('r', 'rev', '', _('apply the filespec on this revision'), _('REV'))],
1852 1852 _('[-r REV] FILESPEC'))
1853 1853 def debugfileset(ui, repo, expr, **opts):
1854 1854 '''parse and apply a fileset specification'''
1855 1855 ctx = scmutil.revsingle(repo, opts.get('rev'), None)
1856 1856 if ui.verbose:
1857 1857 tree = fileset.parse(expr)[0]
1858 1858 ui.note(tree, "\n")
1859 1859
1860 1860 for f in fileset.getfileset(ctx, expr):
1861 1861 ui.write("%s\n" % f)
1862 1862
1863 1863 @command('debugfsinfo', [], _('[PATH]'))
1864 1864 def debugfsinfo(ui, path = "."):
1865 1865 """show information detected about current filesystem"""
1866 1866 util.writefile('.debugfsinfo', '')
1867 1867 ui.write('exec: %s\n' % (util.checkexec(path) and 'yes' or 'no'))
1868 1868 ui.write('symlink: %s\n' % (util.checklink(path) and 'yes' or 'no'))
1869 1869 ui.write('case-sensitive: %s\n' % (util.checkcase('.debugfsinfo')
1870 1870 and 'yes' or 'no'))
1871 1871 os.unlink('.debugfsinfo')
1872 1872
1873 1873 @command('debuggetbundle',
1874 1874 [('H', 'head', [], _('id of head node'), _('ID')),
1875 1875 ('C', 'common', [], _('id of common node'), _('ID')),
1876 1876 ('t', 'type', 'bzip2', _('bundle compression type to use'), _('TYPE'))],
1877 1877 _('REPO FILE [-H|-C ID]...'))
1878 1878 def debuggetbundle(ui, repopath, bundlepath, head=None, common=None, **opts):
1879 1879 """retrieves a bundle from a repo
1880 1880
1881 1881 Every ID must be a full-length hex node id string. Saves the bundle to the
1882 1882 given file.
1883 1883 """
1884 1884 repo = hg.peer(ui, opts, repopath)
1885 1885 if not repo.capable('getbundle'):
1886 1886 raise util.Abort("getbundle() not supported by target repository")
1887 1887 args = {}
1888 1888 if common:
1889 1889 args['common'] = [bin(s) for s in common]
1890 1890 if head:
1891 1891 args['heads'] = [bin(s) for s in head]
1892 1892 bundle = repo.getbundle('debug', **args)
1893 1893
1894 1894 bundletype = opts.get('type', 'bzip2').lower()
1895 1895 btypes = {'none': 'HG10UN', 'bzip2': 'HG10BZ', 'gzip': 'HG10GZ'}
1896 1896 bundletype = btypes.get(bundletype)
1897 1897 if bundletype not in changegroup.bundletypes:
1898 1898 raise util.Abort(_('unknown bundle type specified with --type'))
1899 1899 changegroup.writebundle(bundle, bundlepath, bundletype)
1900 1900
1901 1901 @command('debugignore', [], '')
1902 1902 def debugignore(ui, repo, *values, **opts):
1903 1903 """display the combined ignore pattern"""
1904 1904 ignore = repo.dirstate._ignore
1905 1905 includepat = getattr(ignore, 'includepat', None)
1906 1906 if includepat is not None:
1907 1907 ui.write("%s\n" % includepat)
1908 1908 else:
1909 1909 raise util.Abort(_("no ignore patterns found"))
1910 1910
1911 1911 @command('debugindex',
1912 1912 [('c', 'changelog', False, _('open changelog')),
1913 1913 ('m', 'manifest', False, _('open manifest')),
1914 1914 ('f', 'format', 0, _('revlog format'), _('FORMAT'))],
1915 1915 _('[-f FORMAT] -c|-m|FILE'))
1916 1916 def debugindex(ui, repo, file_ = None, **opts):
1917 1917 """dump the contents of an index file"""
1918 1918 r = cmdutil.openrevlog(repo, 'debugindex', file_, opts)
1919 1919 format = opts.get('format', 0)
1920 1920 if format not in (0, 1):
1921 1921 raise util.Abort(_("unknown format %d") % format)
1922 1922
1923 1923 generaldelta = r.version & revlog.REVLOGGENERALDELTA
1924 1924 if generaldelta:
1925 1925 basehdr = ' delta'
1926 1926 else:
1927 1927 basehdr = ' base'
1928 1928
1929 1929 if format == 0:
1930 1930 ui.write(" rev offset length " + basehdr + " linkrev"
1931 1931 " nodeid p1 p2\n")
1932 1932 elif format == 1:
1933 1933 ui.write(" rev flag offset length"
1934 1934 " size " + basehdr + " link p1 p2"
1935 1935 " nodeid\n")
1936 1936
1937 1937 for i in r:
1938 1938 node = r.node(i)
1939 1939 if generaldelta:
1940 1940 base = r.deltaparent(i)
1941 1941 else:
1942 1942 base = r.chainbase(i)
1943 1943 if format == 0:
1944 1944 try:
1945 1945 pp = r.parents(node)
1946 1946 except Exception:
1947 1947 pp = [nullid, nullid]
1948 1948 ui.write("% 6d % 9d % 7d % 6d % 7d %s %s %s\n" % (
1949 1949 i, r.start(i), r.length(i), base, r.linkrev(i),
1950 1950 short(node), short(pp[0]), short(pp[1])))
1951 1951 elif format == 1:
1952 1952 pr = r.parentrevs(i)
1953 1953 ui.write("% 6d %04x % 8d % 8d % 8d % 6d % 6d % 6d % 6d %s\n" % (
1954 1954 i, r.flags(i), r.start(i), r.length(i), r.rawsize(i),
1955 1955 base, r.linkrev(i), pr[0], pr[1], short(node)))
1956 1956
1957 1957 @command('debugindexdot', [], _('FILE'))
1958 1958 def debugindexdot(ui, repo, file_):
1959 1959 """dump an index DAG as a graphviz dot file"""
1960 1960 r = None
1961 1961 if repo:
1962 1962 filelog = repo.file(file_)
1963 1963 if len(filelog):
1964 1964 r = filelog
1965 1965 if not r:
1966 1966 r = revlog.revlog(scmutil.opener(os.getcwd(), audit=False), file_)
1967 1967 ui.write("digraph G {\n")
1968 1968 for i in r:
1969 1969 node = r.node(i)
1970 1970 pp = r.parents(node)
1971 1971 ui.write("\t%d -> %d\n" % (r.rev(pp[0]), i))
1972 1972 if pp[1] != nullid:
1973 1973 ui.write("\t%d -> %d\n" % (r.rev(pp[1]), i))
1974 1974 ui.write("}\n")
1975 1975
1976 1976 @command('debuginstall', [], '')
1977 1977 def debuginstall(ui):
1978 1978 '''test Mercurial installation
1979 1979
1980 1980 Returns 0 on success.
1981 1981 '''
1982 1982
1983 1983 def writetemp(contents):
1984 1984 (fd, name) = tempfile.mkstemp(prefix="hg-debuginstall-")
1985 1985 f = os.fdopen(fd, "wb")
1986 1986 f.write(contents)
1987 1987 f.close()
1988 1988 return name
1989 1989
1990 1990 problems = 0
1991 1991
1992 1992 # encoding
1993 1993 ui.status(_("checking encoding (%s)...\n") % encoding.encoding)
1994 1994 try:
1995 1995 encoding.fromlocal("test")
1996 1996 except util.Abort, inst:
1997 1997 ui.write(" %s\n" % inst)
1998 1998 ui.write(_(" (check that your locale is properly set)\n"))
1999 1999 problems += 1
2000 2000
2001 2001 # compiled modules
2002 2002 ui.status(_("checking installed modules (%s)...\n")
2003 2003 % os.path.dirname(__file__))
2004 2004 try:
2005 2005 import bdiff, mpatch, base85, osutil
2006 2006 dir(bdiff), dir(mpatch), dir(base85), dir(osutil) # quiet pyflakes
2007 2007 except Exception, inst:
2008 2008 ui.write(" %s\n" % inst)
2009 2009 ui.write(_(" One or more extensions could not be found"))
2010 2010 ui.write(_(" (check that you compiled the extensions)\n"))
2011 2011 problems += 1
2012 2012
2013 2013 # templates
2014 2014 import templater
2015 2015 p = templater.templatepath()
2016 2016 ui.status(_("checking templates (%s)...\n") % ' '.join(p))
2017 2017 try:
2018 2018 templater.templater(templater.templatepath("map-cmdline.default"))
2019 2019 except Exception, inst:
2020 2020 ui.write(" %s\n" % inst)
2021 2021 ui.write(_(" (templates seem to have been installed incorrectly)\n"))
2022 2022 problems += 1
2023 2023
2024 2024 # editor
2025 2025 ui.status(_("checking commit editor...\n"))
2026 2026 editor = ui.geteditor()
2027 2027 cmdpath = util.findexe(editor) or util.findexe(editor.split()[0])
2028 2028 if not cmdpath:
2029 2029 if editor == 'vi':
2030 2030 ui.write(_(" No commit editor set and can't find vi in PATH\n"))
2031 2031 ui.write(_(" (specify a commit editor in your configuration"
2032 2032 " file)\n"))
2033 2033 else:
2034 2034 ui.write(_(" Can't find editor '%s' in PATH\n") % editor)
2035 2035 ui.write(_(" (specify a commit editor in your configuration"
2036 2036 " file)\n"))
2037 2037 problems += 1
2038 2038
2039 2039 # check username
2040 2040 ui.status(_("checking username...\n"))
2041 2041 try:
2042 2042 ui.username()
2043 2043 except util.Abort, e:
2044 2044 ui.write(" %s\n" % e)
2045 2045 ui.write(_(" (specify a username in your configuration file)\n"))
2046 2046 problems += 1
2047 2047
2048 2048 if not problems:
2049 2049 ui.status(_("no problems detected\n"))
2050 2050 else:
2051 2051 ui.write(_("%s problems detected,"
2052 2052 " please check your install!\n") % problems)
2053 2053
2054 2054 return problems
2055 2055
2056 2056 @command('debugknown', [], _('REPO ID...'))
2057 2057 def debugknown(ui, repopath, *ids, **opts):
2058 2058 """test whether node ids are known to a repo
2059 2059
2060 2060 Every ID must be a full-length hex node id string. Returns a list of 0s
2061 2061 and 1s indicating unknown/known.
2062 2062 """
2063 2063 repo = hg.peer(ui, opts, repopath)
2064 2064 if not repo.capable('known'):
2065 2065 raise util.Abort("known() not supported by target repository")
2066 2066 flags = repo.known([bin(s) for s in ids])
2067 2067 ui.write("%s\n" % ("".join([f and "1" or "0" for f in flags])))
2068 2068
2069 2069 @command('debugobsolete', [] + commitopts2,
2070 2070 _('[OBSOLETED [REPLACEMENT] [REPL... ]'))
2071 2071 def debugobsolete(ui, repo, precursor=None, *successors, **opts):
2072 2072 """create arbitrary obsolete marker"""
2073 2073 def parsenodeid(s):
2074 2074 try:
2075 2075 # We do not use revsingle/revrange functions here to accept
2076 2076 # arbitrary node identifiers, possibly not present in the
2077 2077 # local repository.
2078 2078 n = bin(s)
2079 2079 if len(n) != len(nullid):
2080 2080 raise TypeError()
2081 2081 return n
2082 2082 except TypeError:
2083 2083 raise util.Abort('changeset references must be full hexadecimal '
2084 2084 'node identifiers')
2085 2085
2086 2086 if precursor is not None:
2087 2087 metadata = {}
2088 2088 if 'date' in opts:
2089 2089 metadata['date'] = opts['date']
2090 2090 metadata['user'] = opts['user'] or ui.username()
2091 2091 succs = tuple(parsenodeid(succ) for succ in successors)
2092 2092 l = repo.lock()
2093 2093 try:
2094 2094 tr = repo.transaction('debugobsolete')
2095 2095 try:
2096 2096 repo.obsstore.create(tr, parsenodeid(precursor), succs, 0,
2097 2097 metadata)
2098 2098 tr.close()
2099 2099 finally:
2100 2100 tr.release()
2101 2101 finally:
2102 2102 l.release()
2103 2103 else:
2104 2104 for m in obsolete.allmarkers(repo):
2105 2105 ui.write(hex(m.precnode()))
2106 2106 for repl in m.succnodes():
2107 2107 ui.write(' ')
2108 2108 ui.write(hex(repl))
2109 2109 ui.write(' %X ' % m._data[2])
2110 2110 ui.write(m.metadata())
2111 2111 ui.write('\n')
2112 2112
2113 2113 @command('debugpushkey', [], _('REPO NAMESPACE [KEY OLD NEW]'))
2114 2114 def debugpushkey(ui, repopath, namespace, *keyinfo, **opts):
2115 2115 '''access the pushkey key/value protocol
2116 2116
2117 2117 With two args, list the keys in the given namespace.
2118 2118
2119 2119 With five args, set a key to new if it currently is set to old.
2120 2120 Reports success or failure.
2121 2121 '''
2122 2122
2123 2123 target = hg.peer(ui, {}, repopath)
2124 2124 if keyinfo:
2125 2125 key, old, new = keyinfo
2126 2126 r = target.pushkey(namespace, key, old, new)
2127 2127 ui.status(str(r) + '\n')
2128 2128 return not r
2129 2129 else:
2130 2130 for k, v in target.listkeys(namespace).iteritems():
2131 2131 ui.write("%s\t%s\n" % (k.encode('string-escape'),
2132 2132 v.encode('string-escape')))
2133 2133
2134 2134 @command('debugpvec', [], _('A B'))
2135 2135 def debugpvec(ui, repo, a, b=None):
2136 2136 ca = scmutil.revsingle(repo, a)
2137 2137 cb = scmutil.revsingle(repo, b)
2138 2138 pa = pvec.ctxpvec(ca)
2139 2139 pb = pvec.ctxpvec(cb)
2140 2140 if pa == pb:
2141 2141 rel = "="
2142 2142 elif pa > pb:
2143 2143 rel = ">"
2144 2144 elif pa < pb:
2145 2145 rel = "<"
2146 2146 elif pa | pb:
2147 2147 rel = "|"
2148 2148 ui.write(_("a: %s\n") % pa)
2149 2149 ui.write(_("b: %s\n") % pb)
2150 2150 ui.write(_("depth(a): %d depth(b): %d\n") % (pa._depth, pb._depth))
2151 2151 ui.write(_("delta: %d hdist: %d distance: %d relation: %s\n") %
2152 2152 (abs(pa._depth - pb._depth), pvec._hamming(pa._vec, pb._vec),
2153 2153 pa.distance(pb), rel))
2154 2154
2155 2155 @command('debugrebuildstate',
2156 2156 [('r', 'rev', '', _('revision to rebuild to'), _('REV'))],
2157 2157 _('[-r REV] [REV]'))
2158 2158 def debugrebuildstate(ui, repo, rev="tip"):
2159 2159 """rebuild the dirstate as it would look like for the given revision"""
2160 2160 ctx = scmutil.revsingle(repo, rev)
2161 2161 wlock = repo.wlock()
2162 2162 try:
2163 2163 repo.dirstate.rebuild(ctx.node(), ctx.manifest())
2164 2164 finally:
2165 2165 wlock.release()
2166 2166
2167 2167 @command('debugrename',
2168 2168 [('r', 'rev', '', _('revision to debug'), _('REV'))],
2169 2169 _('[-r REV] FILE'))
2170 2170 def debugrename(ui, repo, file1, *pats, **opts):
2171 2171 """dump rename information"""
2172 2172
2173 2173 ctx = scmutil.revsingle(repo, opts.get('rev'))
2174 2174 m = scmutil.match(ctx, (file1,) + pats, opts)
2175 2175 for abs in ctx.walk(m):
2176 2176 fctx = ctx[abs]
2177 2177 o = fctx.filelog().renamed(fctx.filenode())
2178 2178 rel = m.rel(abs)
2179 2179 if o:
2180 2180 ui.write(_("%s renamed from %s:%s\n") % (rel, o[0], hex(o[1])))
2181 2181 else:
2182 2182 ui.write(_("%s not renamed\n") % rel)
2183 2183
2184 2184 @command('debugrevlog',
2185 2185 [('c', 'changelog', False, _('open changelog')),
2186 2186 ('m', 'manifest', False, _('open manifest')),
2187 2187 ('d', 'dump', False, _('dump index data'))],
2188 2188 _('-c|-m|FILE'))
2189 2189 def debugrevlog(ui, repo, file_ = None, **opts):
2190 2190 """show data and statistics about a revlog"""
2191 2191 r = cmdutil.openrevlog(repo, 'debugrevlog', file_, opts)
2192 2192
2193 2193 if opts.get("dump"):
2194 2194 numrevs = len(r)
2195 2195 ui.write("# rev p1rev p2rev start end deltastart base p1 p2"
2196 2196 " rawsize totalsize compression heads\n")
2197 2197 ts = 0
2198 2198 heads = set()
2199 2199 for rev in xrange(numrevs):
2200 2200 dbase = r.deltaparent(rev)
2201 2201 if dbase == -1:
2202 2202 dbase = rev
2203 2203 cbase = r.chainbase(rev)
2204 2204 p1, p2 = r.parentrevs(rev)
2205 2205 rs = r.rawsize(rev)
2206 2206 ts = ts + rs
2207 2207 heads -= set(r.parentrevs(rev))
2208 2208 heads.add(rev)
2209 2209 ui.write("%d %d %d %d %d %d %d %d %d %d %d %d %d\n" %
2210 2210 (rev, p1, p2, r.start(rev), r.end(rev),
2211 2211 r.start(dbase), r.start(cbase),
2212 2212 r.start(p1), r.start(p2),
2213 2213 rs, ts, ts / r.end(rev), len(heads)))
2214 2214 return 0
2215 2215
2216 2216 v = r.version
2217 2217 format = v & 0xFFFF
2218 2218 flags = []
2219 2219 gdelta = False
2220 2220 if v & revlog.REVLOGNGINLINEDATA:
2221 2221 flags.append('inline')
2222 2222 if v & revlog.REVLOGGENERALDELTA:
2223 2223 gdelta = True
2224 2224 flags.append('generaldelta')
2225 2225 if not flags:
2226 2226 flags = ['(none)']
2227 2227
2228 2228 nummerges = 0
2229 2229 numfull = 0
2230 2230 numprev = 0
2231 2231 nump1 = 0
2232 2232 nump2 = 0
2233 2233 numother = 0
2234 2234 nump1prev = 0
2235 2235 nump2prev = 0
2236 2236 chainlengths = []
2237 2237
2238 2238 datasize = [None, 0, 0L]
2239 2239 fullsize = [None, 0, 0L]
2240 2240 deltasize = [None, 0, 0L]
2241 2241
2242 2242 def addsize(size, l):
2243 2243 if l[0] is None or size < l[0]:
2244 2244 l[0] = size
2245 2245 if size > l[1]:
2246 2246 l[1] = size
2247 2247 l[2] += size
2248 2248
2249 2249 numrevs = len(r)
2250 2250 for rev in xrange(numrevs):
2251 2251 p1, p2 = r.parentrevs(rev)
2252 2252 delta = r.deltaparent(rev)
2253 2253 if format > 0:
2254 2254 addsize(r.rawsize(rev), datasize)
2255 2255 if p2 != nullrev:
2256 2256 nummerges += 1
2257 2257 size = r.length(rev)
2258 2258 if delta == nullrev:
2259 2259 chainlengths.append(0)
2260 2260 numfull += 1
2261 2261 addsize(size, fullsize)
2262 2262 else:
2263 2263 chainlengths.append(chainlengths[delta] + 1)
2264 2264 addsize(size, deltasize)
2265 2265 if delta == rev - 1:
2266 2266 numprev += 1
2267 2267 if delta == p1:
2268 2268 nump1prev += 1
2269 2269 elif delta == p2:
2270 2270 nump2prev += 1
2271 2271 elif delta == p1:
2272 2272 nump1 += 1
2273 2273 elif delta == p2:
2274 2274 nump2 += 1
2275 2275 elif delta != nullrev:
2276 2276 numother += 1
2277 2277
2278 2278 # Adjust size min value for empty cases
2279 2279 for size in (datasize, fullsize, deltasize):
2280 2280 if size[0] is None:
2281 2281 size[0] = 0
2282 2282
2283 2283 numdeltas = numrevs - numfull
2284 2284 numoprev = numprev - nump1prev - nump2prev
2285 2285 totalrawsize = datasize[2]
2286 2286 datasize[2] /= numrevs
2287 2287 fulltotal = fullsize[2]
2288 2288 fullsize[2] /= numfull
2289 2289 deltatotal = deltasize[2]
2290 2290 if numrevs - numfull > 0:
2291 2291 deltasize[2] /= numrevs - numfull
2292 2292 totalsize = fulltotal + deltatotal
2293 2293 avgchainlen = sum(chainlengths) / numrevs
2294 2294 compratio = totalrawsize / totalsize
2295 2295
2296 2296 basedfmtstr = '%%%dd\n'
2297 2297 basepcfmtstr = '%%%dd %s(%%5.2f%%%%)\n'
2298 2298
2299 2299 def dfmtstr(max):
2300 2300 return basedfmtstr % len(str(max))
2301 2301 def pcfmtstr(max, padding=0):
2302 2302 return basepcfmtstr % (len(str(max)), ' ' * padding)
2303 2303
2304 2304 def pcfmt(value, total):
2305 2305 return (value, 100 * float(value) / total)
2306 2306
2307 2307 ui.write('format : %d\n' % format)
2308 2308 ui.write('flags : %s\n' % ', '.join(flags))
2309 2309
2310 2310 ui.write('\n')
2311 2311 fmt = pcfmtstr(totalsize)
2312 2312 fmt2 = dfmtstr(totalsize)
2313 2313 ui.write('revisions : ' + fmt2 % numrevs)
2314 2314 ui.write(' merges : ' + fmt % pcfmt(nummerges, numrevs))
2315 2315 ui.write(' normal : ' + fmt % pcfmt(numrevs - nummerges, numrevs))
2316 2316 ui.write('revisions : ' + fmt2 % numrevs)
2317 2317 ui.write(' full : ' + fmt % pcfmt(numfull, numrevs))
2318 2318 ui.write(' deltas : ' + fmt % pcfmt(numdeltas, numrevs))
2319 2319 ui.write('revision size : ' + fmt2 % totalsize)
2320 2320 ui.write(' full : ' + fmt % pcfmt(fulltotal, totalsize))
2321 2321 ui.write(' deltas : ' + fmt % pcfmt(deltatotal, totalsize))
2322 2322
2323 2323 ui.write('\n')
2324 2324 fmt = dfmtstr(max(avgchainlen, compratio))
2325 2325 ui.write('avg chain length : ' + fmt % avgchainlen)
2326 2326 ui.write('compression ratio : ' + fmt % compratio)
2327 2327
2328 2328 if format > 0:
2329 2329 ui.write('\n')
2330 2330 ui.write('uncompressed data size (min/max/avg) : %d / %d / %d\n'
2331 2331 % tuple(datasize))
2332 2332 ui.write('full revision size (min/max/avg) : %d / %d / %d\n'
2333 2333 % tuple(fullsize))
2334 2334 ui.write('delta size (min/max/avg) : %d / %d / %d\n'
2335 2335 % tuple(deltasize))
2336 2336
2337 2337 if numdeltas > 0:
2338 2338 ui.write('\n')
2339 2339 fmt = pcfmtstr(numdeltas)
2340 2340 fmt2 = pcfmtstr(numdeltas, 4)
2341 2341 ui.write('deltas against prev : ' + fmt % pcfmt(numprev, numdeltas))
2342 2342 if numprev > 0:
2343 2343 ui.write(' where prev = p1 : ' + fmt2 % pcfmt(nump1prev,
2344 2344 numprev))
2345 2345 ui.write(' where prev = p2 : ' + fmt2 % pcfmt(nump2prev,
2346 2346 numprev))
2347 2347 ui.write(' other : ' + fmt2 % pcfmt(numoprev,
2348 2348 numprev))
2349 2349 if gdelta:
2350 2350 ui.write('deltas against p1 : ' + fmt % pcfmt(nump1, numdeltas))
2351 2351 ui.write('deltas against p2 : ' + fmt % pcfmt(nump2, numdeltas))
2352 2352 ui.write('deltas against other : ' + fmt % pcfmt(numother,
2353 2353 numdeltas))
2354 2354
2355 2355 @command('debugrevspec', [], ('REVSPEC'))
2356 2356 def debugrevspec(ui, repo, expr):
2357 2357 """parse and apply a revision specification
2358 2358
2359 2359 Use --verbose to print the parsed tree before and after aliases
2360 2360 expansion.
2361 2361 """
2362 2362 if ui.verbose:
2363 2363 tree = revset.parse(expr)[0]
2364 2364 ui.note(revset.prettyformat(tree), "\n")
2365 2365 newtree = revset.findaliases(ui, tree)
2366 2366 if newtree != tree:
2367 2367 ui.note(revset.prettyformat(newtree), "\n")
2368 2368 func = revset.match(ui, expr)
2369 2369 for c in func(repo, range(len(repo))):
2370 2370 ui.write("%s\n" % c)
2371 2371
2372 2372 @command('debugsetparents', [], _('REV1 [REV2]'))
2373 2373 def debugsetparents(ui, repo, rev1, rev2=None):
2374 2374 """manually set the parents of the current working directory
2375 2375
2376 2376 This is useful for writing repository conversion tools, but should
2377 2377 be used with care.
2378 2378
2379 2379 Returns 0 on success.
2380 2380 """
2381 2381
2382 2382 r1 = scmutil.revsingle(repo, rev1).node()
2383 2383 r2 = scmutil.revsingle(repo, rev2, 'null').node()
2384 2384
2385 2385 wlock = repo.wlock()
2386 2386 try:
2387 2387 repo.setparents(r1, r2)
2388 2388 finally:
2389 2389 wlock.release()
2390 2390
2391 2391 @command('debugstate',
2392 2392 [('', 'nodates', None, _('do not display the saved mtime')),
2393 2393 ('', 'datesort', None, _('sort by saved mtime'))],
2394 2394 _('[OPTION]...'))
2395 2395 def debugstate(ui, repo, nodates=None, datesort=None):
2396 2396 """show the contents of the current dirstate"""
2397 2397 timestr = ""
2398 2398 showdate = not nodates
2399 2399 if datesort:
2400 2400 keyfunc = lambda x: (x[1][3], x[0]) # sort by mtime, then by filename
2401 2401 else:
2402 2402 keyfunc = None # sort by filename
2403 2403 for file_, ent in sorted(repo.dirstate._map.iteritems(), key=keyfunc):
2404 2404 if showdate:
2405 2405 if ent[3] == -1:
2406 2406 # Pad or slice to locale representation
2407 2407 locale_len = len(time.strftime("%Y-%m-%d %H:%M:%S ",
2408 2408 time.localtime(0)))
2409 2409 timestr = 'unset'
2410 2410 timestr = (timestr[:locale_len] +
2411 2411 ' ' * (locale_len - len(timestr)))
2412 2412 else:
2413 2413 timestr = time.strftime("%Y-%m-%d %H:%M:%S ",
2414 2414 time.localtime(ent[3]))
2415 2415 if ent[1] & 020000:
2416 2416 mode = 'lnk'
2417 2417 else:
2418 2418 mode = '%3o' % (ent[1] & 0777 & ~util.umask)
2419 2419 ui.write("%c %s %10d %s%s\n" % (ent[0], mode, ent[2], timestr, file_))
2420 2420 for f in repo.dirstate.copies():
2421 2421 ui.write(_("copy: %s -> %s\n") % (repo.dirstate.copied(f), f))
2422 2422
2423 2423 @command('debugsub',
2424 2424 [('r', 'rev', '',
2425 2425 _('revision to check'), _('REV'))],
2426 2426 _('[-r REV] [REV]'))
2427 2427 def debugsub(ui, repo, rev=None):
2428 2428 ctx = scmutil.revsingle(repo, rev, None)
2429 2429 for k, v in sorted(ctx.substate.items()):
2430 2430 ui.write('path %s\n' % k)
2431 2431 ui.write(' source %s\n' % v[0])
2432 2432 ui.write(' revision %s\n' % v[1])
2433 2433
2434 2434 @command('debugwalk', walkopts, _('[OPTION]... [FILE]...'))
2435 2435 def debugwalk(ui, repo, *pats, **opts):
2436 2436 """show how files match on given patterns"""
2437 2437 m = scmutil.match(repo[None], pats, opts)
2438 2438 items = list(repo.walk(m))
2439 2439 if not items:
2440 2440 return
2441 2441 f = lambda fn: fn
2442 2442 if ui.configbool('ui', 'slash') and os.sep != '/':
2443 2443 f = lambda fn: util.normpath(fn)
2444 2444 fmt = 'f %%-%ds %%-%ds %%s' % (
2445 2445 max([len(abs) for abs in items]),
2446 2446 max([len(m.rel(abs)) for abs in items]))
2447 2447 for abs in items:
2448 2448 line = fmt % (abs, f(m.rel(abs)), m.exact(abs) and 'exact' or '')
2449 2449 ui.write("%s\n" % line.rstrip())
2450 2450
2451 2451 @command('debugwireargs',
2452 2452 [('', 'three', '', 'three'),
2453 2453 ('', 'four', '', 'four'),
2454 2454 ('', 'five', '', 'five'),
2455 2455 ] + remoteopts,
2456 2456 _('REPO [OPTIONS]... [ONE [TWO]]'))
2457 2457 def debugwireargs(ui, repopath, *vals, **opts):
2458 2458 repo = hg.peer(ui, opts, repopath)
2459 2459 for opt in remoteopts:
2460 2460 del opts[opt[1]]
2461 2461 args = {}
2462 2462 for k, v in opts.iteritems():
2463 2463 if v:
2464 2464 args[k] = v
2465 2465 # run twice to check that we don't mess up the stream for the next command
2466 2466 res1 = repo.debugwireargs(*vals, **args)
2467 2467 res2 = repo.debugwireargs(*vals, **args)
2468 2468 ui.write("%s\n" % res1)
2469 2469 if res1 != res2:
2470 2470 ui.warn("%s\n" % res2)
2471 2471
2472 2472 @command('^diff',
2473 2473 [('r', 'rev', [], _('revision'), _('REV')),
2474 2474 ('c', 'change', '', _('change made by revision'), _('REV'))
2475 2475 ] + diffopts + diffopts2 + walkopts + subrepoopts,
2476 2476 _('[OPTION]... ([-c REV] | [-r REV1 [-r REV2]]) [FILE]...'))
2477 2477 def diff(ui, repo, *pats, **opts):
2478 2478 """diff repository (or selected files)
2479 2479
2480 2480 Show differences between revisions for the specified files.
2481 2481
2482 2482 Differences between files are shown using the unified diff format.
2483 2483
2484 2484 .. note::
2485 2485 diff may generate unexpected results for merges, as it will
2486 2486 default to comparing against the working directory's first
2487 2487 parent changeset if no revisions are specified.
2488 2488
2489 2489 When two revision arguments are given, then changes are shown
2490 2490 between those revisions. If only one revision is specified then
2491 2491 that revision is compared to the working directory, and, when no
2492 2492 revisions are specified, the working directory files are compared
2493 2493 to its parent.
2494 2494
2495 2495 Alternatively you can specify -c/--change with a revision to see
2496 2496 the changes in that changeset relative to its first parent.
2497 2497
2498 2498 Without the -a/--text option, diff will avoid generating diffs of
2499 2499 files it detects as binary. With -a, diff will generate a diff
2500 2500 anyway, probably with undesirable results.
2501 2501
2502 2502 Use the -g/--git option to generate diffs in the git extended diff
2503 2503 format. For more information, read :hg:`help diffs`.
2504 2504
2505 2505 .. container:: verbose
2506 2506
2507 2507 Examples:
2508 2508
2509 2509 - compare a file in the current working directory to its parent::
2510 2510
2511 2511 hg diff foo.c
2512 2512
2513 2513 - compare two historical versions of a directory, with rename info::
2514 2514
2515 2515 hg diff --git -r 1.0:1.2 lib/
2516 2516
2517 2517 - get change stats relative to the last change on some date::
2518 2518
2519 2519 hg diff --stat -r "date('may 2')"
2520 2520
2521 2521 - diff all newly-added files that contain a keyword::
2522 2522
2523 2523 hg diff "set:added() and grep(GNU)"
2524 2524
2525 2525 - compare a revision and its parents::
2526 2526
2527 2527 hg diff -c 9353 # compare against first parent
2528 2528 hg diff -r 9353^:9353 # same using revset syntax
2529 2529 hg diff -r 9353^2:9353 # compare against the second parent
2530 2530
2531 2531 Returns 0 on success.
2532 2532 """
2533 2533
2534 2534 revs = opts.get('rev')
2535 2535 change = opts.get('change')
2536 2536 stat = opts.get('stat')
2537 2537 reverse = opts.get('reverse')
2538 2538
2539 2539 if revs and change:
2540 2540 msg = _('cannot specify --rev and --change at the same time')
2541 2541 raise util.Abort(msg)
2542 2542 elif change:
2543 2543 node2 = scmutil.revsingle(repo, change, None).node()
2544 2544 node1 = repo[node2].p1().node()
2545 2545 else:
2546 2546 node1, node2 = scmutil.revpair(repo, revs)
2547 2547
2548 2548 if reverse:
2549 2549 node1, node2 = node2, node1
2550 2550
2551 2551 diffopts = patch.diffopts(ui, opts)
2552 2552 m = scmutil.match(repo[node2], pats, opts)
2553 2553 cmdutil.diffordiffstat(ui, repo, diffopts, node1, node2, m, stat=stat,
2554 2554 listsubrepos=opts.get('subrepos'))
2555 2555
2556 2556 @command('^export',
2557 2557 [('o', 'output', '',
2558 2558 _('print output to file with formatted name'), _('FORMAT')),
2559 2559 ('', 'switch-parent', None, _('diff against the second parent')),
2560 2560 ('r', 'rev', [], _('revisions to export'), _('REV')),
2561 2561 ] + diffopts,
2562 2562 _('[OPTION]... [-o OUTFILESPEC] [-r] REV...'))
2563 2563 def export(ui, repo, *changesets, **opts):
2564 2564 """dump the header and diffs for one or more changesets
2565 2565
2566 2566 Print the changeset header and diffs for one or more revisions.
2567 2567
2568 2568 The information shown in the changeset header is: author, date,
2569 2569 branch name (if non-default), changeset hash, parent(s) and commit
2570 2570 comment.
2571 2571
2572 2572 .. note::
2573 2573 export may generate unexpected diff output for merge
2574 2574 changesets, as it will compare the merge changeset against its
2575 2575 first parent only.
2576 2576
2577 2577 Output may be to a file, in which case the name of the file is
2578 2578 given using a format string. The formatting rules are as follows:
2579 2579
2580 2580 :``%%``: literal "%" character
2581 2581 :``%H``: changeset hash (40 hexadecimal digits)
2582 2582 :``%N``: number of patches being generated
2583 2583 :``%R``: changeset revision number
2584 2584 :``%b``: basename of the exporting repository
2585 2585 :``%h``: short-form changeset hash (12 hexadecimal digits)
2586 2586 :``%m``: first line of the commit message (only alphanumeric characters)
2587 2587 :``%n``: zero-padded sequence number, starting at 1
2588 2588 :``%r``: zero-padded changeset revision number
2589 2589
2590 2590 Without the -a/--text option, export will avoid generating diffs
2591 2591 of files it detects as binary. With -a, export will generate a
2592 2592 diff anyway, probably with undesirable results.
2593 2593
2594 2594 Use the -g/--git option to generate diffs in the git extended diff
2595 2595 format. See :hg:`help diffs` for more information.
2596 2596
2597 2597 With the --switch-parent option, the diff will be against the
2598 2598 second parent. It can be useful to review a merge.
2599 2599
2600 2600 .. container:: verbose
2601 2601
2602 2602 Examples:
2603 2603
2604 2604 - use export and import to transplant a bugfix to the current
2605 2605 branch::
2606 2606
2607 2607 hg export -r 9353 | hg import -
2608 2608
2609 2609 - export all the changesets between two revisions to a file with
2610 2610 rename information::
2611 2611
2612 2612 hg export --git -r 123:150 > changes.txt
2613 2613
2614 2614 - split outgoing changes into a series of patches with
2615 2615 descriptive names::
2616 2616
2617 2617 hg export -r "outgoing()" -o "%n-%m.patch"
2618 2618
2619 2619 Returns 0 on success.
2620 2620 """
2621 2621 changesets += tuple(opts.get('rev', []))
2622 2622 revs = scmutil.revrange(repo, changesets)
2623 2623 if not revs:
2624 2624 raise util.Abort(_("export requires at least one changeset"))
2625 2625 if len(revs) > 1:
2626 2626 ui.note(_('exporting patches:\n'))
2627 2627 else:
2628 2628 ui.note(_('exporting patch:\n'))
2629 2629 cmdutil.export(repo, revs, template=opts.get('output'),
2630 2630 switch_parent=opts.get('switch_parent'),
2631 2631 opts=patch.diffopts(ui, opts))
2632 2632
2633 2633 @command('^forget', walkopts, _('[OPTION]... FILE...'))
2634 2634 def forget(ui, repo, *pats, **opts):
2635 2635 """forget the specified files on the next commit
2636 2636
2637 2637 Mark the specified files so they will no longer be tracked
2638 2638 after the next commit.
2639 2639
2640 2640 This only removes files from the current branch, not from the
2641 2641 entire project history, and it does not delete them from the
2642 2642 working directory.
2643 2643
2644 2644 To undo a forget before the next commit, see :hg:`add`.
2645 2645
2646 2646 .. container:: verbose
2647 2647
2648 2648 Examples:
2649 2649
2650 2650 - forget newly-added binary files::
2651 2651
2652 2652 hg forget "set:added() and binary()"
2653 2653
2654 2654 - forget files that would be excluded by .hgignore::
2655 2655
2656 2656 hg forget "set:hgignore()"
2657 2657
2658 2658 Returns 0 on success.
2659 2659 """
2660 2660
2661 2661 if not pats:
2662 2662 raise util.Abort(_('no files specified'))
2663 2663
2664 2664 m = scmutil.match(repo[None], pats, opts)
2665 2665 rejected = cmdutil.forget(ui, repo, m, prefix="", explicitonly=False)[0]
2666 2666 return rejected and 1 or 0
2667 2667
2668 2668 @command(
2669 2669 'graft',
2670 2670 [('r', 'rev', [], _('revisions to graft'), _('REV')),
2671 2671 ('c', 'continue', False, _('resume interrupted graft')),
2672 2672 ('e', 'edit', False, _('invoke editor on commit messages')),
2673 2673 ('', 'log', None, _('append graft info to log message')),
2674 2674 ('D', 'currentdate', False,
2675 2675 _('record the current date as commit date')),
2676 2676 ('U', 'currentuser', False,
2677 2677 _('record the current user as committer'), _('DATE'))]
2678 2678 + commitopts2 + mergetoolopts + dryrunopts,
2679 2679 _('[OPTION]... [-r] REV...'))
2680 2680 def graft(ui, repo, *revs, **opts):
2681 2681 '''copy changes from other branches onto the current branch
2682 2682
2683 2683 This command uses Mercurial's merge logic to copy individual
2684 2684 changes from other branches without merging branches in the
2685 2685 history graph. This is sometimes known as 'backporting' or
2686 2686 'cherry-picking'. By default, graft will copy user, date, and
2687 2687 description from the source changesets.
2688 2688
2689 2689 Changesets that are ancestors of the current revision, that have
2690 2690 already been grafted, or that are merges will be skipped.
2691 2691
2692 2692 If --log is specified, log messages will have a comment appended
2693 2693 of the form::
2694 2694
2695 2695 (grafted from CHANGESETHASH)
2696 2696
2697 2697 If a graft merge results in conflicts, the graft process is
2698 2698 interrupted so that the current merge can be manually resolved.
2699 2699 Once all conflicts are addressed, the graft process can be
2700 2700 continued with the -c/--continue option.
2701 2701
2702 2702 .. note::
2703 2703 The -c/--continue option does not reapply earlier options.
2704 2704
2705 2705 .. container:: verbose
2706 2706
2707 2707 Examples:
2708 2708
2709 2709 - copy a single change to the stable branch and edit its description::
2710 2710
2711 2711 hg update stable
2712 2712 hg graft --edit 9393
2713 2713
2714 2714 - graft a range of changesets with one exception, updating dates::
2715 2715
2716 2716 hg graft -D "2085::2093 and not 2091"
2717 2717
2718 2718 - continue a graft after resolving conflicts::
2719 2719
2720 2720 hg graft -c
2721 2721
2722 2722 - show the source of a grafted changeset::
2723 2723
2724 2724 hg log --debug -r tip
2725 2725
2726 2726 Returns 0 on successful completion.
2727 2727 '''
2728 2728
2729 2729 revs = list(revs)
2730 2730 revs.extend(opts['rev'])
2731 2731
2732 2732 if not opts.get('user') and opts.get('currentuser'):
2733 2733 opts['user'] = ui.username()
2734 2734 if not opts.get('date') and opts.get('currentdate'):
2735 2735 opts['date'] = "%d %d" % util.makedate()
2736 2736
2737 2737 editor = None
2738 2738 if opts.get('edit'):
2739 2739 editor = cmdutil.commitforceeditor
2740 2740
2741 2741 cont = False
2742 2742 if opts['continue']:
2743 2743 cont = True
2744 2744 if revs:
2745 2745 raise util.Abort(_("can't specify --continue and revisions"))
2746 2746 # read in unfinished revisions
2747 2747 try:
2748 2748 nodes = repo.opener.read('graftstate').splitlines()
2749 2749 revs = [repo[node].rev() for node in nodes]
2750 2750 except IOError, inst:
2751 2751 if inst.errno != errno.ENOENT:
2752 2752 raise
2753 2753 raise util.Abort(_("no graft state found, can't continue"))
2754 2754 else:
2755 2755 cmdutil.bailifchanged(repo)
2756 2756 if not revs:
2757 2757 raise util.Abort(_('no revisions specified'))
2758 2758 revs = scmutil.revrange(repo, revs)
2759 2759
2760 2760 # check for merges
2761 2761 for rev in repo.revs('%ld and merge()', revs):
2762 2762 ui.warn(_('skipping ungraftable merge revision %s\n') % rev)
2763 2763 revs.remove(rev)
2764 2764 if not revs:
2765 2765 return -1
2766 2766
2767 2767 # check for ancestors of dest branch
2768 2768 for rev in repo.revs('::. and %ld', revs):
2769 2769 ui.warn(_('skipping ancestor revision %s\n') % rev)
2770 2770 revs.remove(rev)
2771 2771 if not revs:
2772 2772 return -1
2773 2773
2774 2774 # analyze revs for earlier grafts
2775 2775 ids = {}
2776 2776 for ctx in repo.set("%ld", revs):
2777 2777 ids[ctx.hex()] = ctx.rev()
2778 2778 n = ctx.extra().get('source')
2779 2779 if n:
2780 2780 ids[n] = ctx.rev()
2781 2781
2782 2782 # check ancestors for earlier grafts
2783 2783 ui.debug('scanning for duplicate grafts\n')
2784 2784 for ctx in repo.set("::. - ::%ld", revs):
2785 2785 n = ctx.extra().get('source')
2786 2786 if n in ids:
2787 2787 r = repo[n].rev()
2788 2788 if r in revs:
2789 2789 ui.warn(_('skipping already grafted revision %s\n') % r)
2790 2790 revs.remove(r)
2791 2791 elif ids[n] in revs:
2792 2792 ui.warn(_('skipping already grafted revision %s '
2793 2793 '(same origin %d)\n') % (ids[n], r))
2794 2794 revs.remove(ids[n])
2795 2795 elif ctx.hex() in ids:
2796 2796 r = ids[ctx.hex()]
2797 2797 ui.warn(_('skipping already grafted revision %s '
2798 2798 '(was grafted from %d)\n') % (r, ctx.rev()))
2799 2799 revs.remove(r)
2800 2800 if not revs:
2801 2801 return -1
2802 2802
2803 2803 wlock = repo.wlock()
2804 2804 try:
2805 2805 for pos, ctx in enumerate(repo.set("%ld", revs)):
2806 2806 current = repo['.']
2807 2807
2808 2808 ui.status(_('grafting revision %s\n') % ctx.rev())
2809 2809 if opts.get('dry_run'):
2810 2810 continue
2811 2811
2812 2812 # we don't merge the first commit when continuing
2813 2813 if not cont:
2814 2814 # perform the graft merge with p1(rev) as 'ancestor'
2815 2815 try:
2816 2816 # ui.forcemerge is an internal variable, do not document
2817 2817 repo.ui.setconfig('ui', 'forcemerge', opts.get('tool', ''))
2818 2818 stats = mergemod.update(repo, ctx.node(), True, True, False,
2819 2819 ctx.p1().node())
2820 2820 finally:
2821 2821 repo.ui.setconfig('ui', 'forcemerge', '')
2822 2822 # report any conflicts
2823 2823 if stats and stats[3] > 0:
2824 2824 # write out state for --continue
2825 2825 nodelines = [repo[rev].hex() + "\n" for rev in revs[pos:]]
2826 2826 repo.opener.write('graftstate', ''.join(nodelines))
2827 2827 raise util.Abort(
2828 2828 _("unresolved conflicts, can't continue"),
2829 2829 hint=_('use hg resolve and hg graft --continue'))
2830 2830 else:
2831 2831 cont = False
2832 2832
2833 2833 # drop the second merge parent
2834 2834 repo.setparents(current.node(), nullid)
2835 2835 repo.dirstate.write()
2836 2836 # fix up dirstate for copies and renames
2837 2837 cmdutil.duplicatecopies(repo, ctx.rev(), ctx.p1().rev())
2838 2838
2839 2839 # commit
2840 2840 source = ctx.extra().get('source')
2841 2841 if not source:
2842 2842 source = ctx.hex()
2843 2843 extra = {'source': source}
2844 2844 user = ctx.user()
2845 2845 if opts.get('user'):
2846 2846 user = opts['user']
2847 2847 date = ctx.date()
2848 2848 if opts.get('date'):
2849 2849 date = opts['date']
2850 2850 message = ctx.description()
2851 2851 if opts.get('log'):
2852 2852 message += '\n(grafted from %s)' % ctx.hex()
2853 2853 node = repo.commit(text=message, user=user,
2854 2854 date=date, extra=extra, editor=editor)
2855 2855 if node is None:
2856 2856 ui.status(_('graft for revision %s is empty\n') % ctx.rev())
2857 2857 finally:
2858 2858 wlock.release()
2859 2859
2860 2860 # remove state when we complete successfully
2861 2861 if not opts.get('dry_run') and os.path.exists(repo.join('graftstate')):
2862 2862 util.unlinkpath(repo.join('graftstate'))
2863 2863
2864 2864 return 0
2865 2865
2866 2866 @command('grep',
2867 2867 [('0', 'print0', None, _('end fields with NUL')),
2868 2868 ('', 'all', None, _('print all revisions that match')),
2869 2869 ('a', 'text', None, _('treat all files as text')),
2870 2870 ('f', 'follow', None,
2871 2871 _('follow changeset history,'
2872 2872 ' or file history across copies and renames')),
2873 2873 ('i', 'ignore-case', None, _('ignore case when matching')),
2874 2874 ('l', 'files-with-matches', None,
2875 2875 _('print only filenames and revisions that match')),
2876 2876 ('n', 'line-number', None, _('print matching line numbers')),
2877 2877 ('r', 'rev', [],
2878 2878 _('only search files changed within revision range'), _('REV')),
2879 2879 ('u', 'user', None, _('list the author (long with -v)')),
2880 2880 ('d', 'date', None, _('list the date (short with -q)')),
2881 2881 ] + walkopts,
2882 2882 _('[OPTION]... PATTERN [FILE]...'))
2883 2883 def grep(ui, repo, pattern, *pats, **opts):
2884 2884 """search for a pattern in specified files and revisions
2885 2885
2886 2886 Search revisions of files for a regular expression.
2887 2887
2888 2888 This command behaves differently than Unix grep. It only accepts
2889 2889 Python/Perl regexps. It searches repository history, not the
2890 2890 working directory. It always prints the revision number in which a
2891 2891 match appears.
2892 2892
2893 2893 By default, grep only prints output for the first revision of a
2894 2894 file in which it finds a match. To get it to print every revision
2895 2895 that contains a change in match status ("-" for a match that
2896 2896 becomes a non-match, or "+" for a non-match that becomes a match),
2897 2897 use the --all flag.
2898 2898
2899 2899 Returns 0 if a match is found, 1 otherwise.
2900 2900 """
2901 2901 reflags = re.M
2902 2902 if opts.get('ignore_case'):
2903 2903 reflags |= re.I
2904 2904 try:
2905 2905 regexp = re.compile(pattern, reflags)
2906 2906 except re.error, inst:
2907 2907 ui.warn(_("grep: invalid match pattern: %s\n") % inst)
2908 2908 return 1
2909 2909 sep, eol = ':', '\n'
2910 2910 if opts.get('print0'):
2911 2911 sep = eol = '\0'
2912 2912
2913 2913 getfile = util.lrucachefunc(repo.file)
2914 2914
2915 2915 def matchlines(body):
2916 2916 begin = 0
2917 2917 linenum = 0
2918 2918 while True:
2919 2919 match = regexp.search(body, begin)
2920 2920 if not match:
2921 2921 break
2922 2922 mstart, mend = match.span()
2923 2923 linenum += body.count('\n', begin, mstart) + 1
2924 2924 lstart = body.rfind('\n', begin, mstart) + 1 or begin
2925 2925 begin = body.find('\n', mend) + 1 or len(body) + 1
2926 2926 lend = begin - 1
2927 2927 yield linenum, mstart - lstart, mend - lstart, body[lstart:lend]
2928 2928
2929 2929 class linestate(object):
2930 2930 def __init__(self, line, linenum, colstart, colend):
2931 2931 self.line = line
2932 2932 self.linenum = linenum
2933 2933 self.colstart = colstart
2934 2934 self.colend = colend
2935 2935
2936 2936 def __hash__(self):
2937 2937 return hash((self.linenum, self.line))
2938 2938
2939 2939 def __eq__(self, other):
2940 2940 return self.line == other.line
2941 2941
2942 2942 matches = {}
2943 2943 copies = {}
2944 2944 def grepbody(fn, rev, body):
2945 2945 matches[rev].setdefault(fn, [])
2946 2946 m = matches[rev][fn]
2947 2947 for lnum, cstart, cend, line in matchlines(body):
2948 2948 s = linestate(line, lnum, cstart, cend)
2949 2949 m.append(s)
2950 2950
2951 2951 def difflinestates(a, b):
2952 2952 sm = difflib.SequenceMatcher(None, a, b)
2953 2953 for tag, alo, ahi, blo, bhi in sm.get_opcodes():
2954 2954 if tag == 'insert':
2955 2955 for i in xrange(blo, bhi):
2956 2956 yield ('+', b[i])
2957 2957 elif tag == 'delete':
2958 2958 for i in xrange(alo, ahi):
2959 2959 yield ('-', a[i])
2960 2960 elif tag == 'replace':
2961 2961 for i in xrange(alo, ahi):
2962 2962 yield ('-', a[i])
2963 2963 for i in xrange(blo, bhi):
2964 2964 yield ('+', b[i])
2965 2965
2966 2966 def display(fn, ctx, pstates, states):
2967 2967 rev = ctx.rev()
2968 2968 datefunc = ui.quiet and util.shortdate or util.datestr
2969 2969 found = False
2970 2970 filerevmatches = {}
2971 2971 def binary():
2972 2972 flog = getfile(fn)
2973 2973 return util.binary(flog.read(ctx.filenode(fn)))
2974 2974
2975 2975 if opts.get('all'):
2976 2976 iter = difflinestates(pstates, states)
2977 2977 else:
2978 2978 iter = [('', l) for l in states]
2979 2979 for change, l in iter:
2980 2980 cols = [fn, str(rev)]
2981 2981 before, match, after = None, None, None
2982 2982 if opts.get('line_number'):
2983 2983 cols.append(str(l.linenum))
2984 2984 if opts.get('all'):
2985 2985 cols.append(change)
2986 2986 if opts.get('user'):
2987 2987 cols.append(ui.shortuser(ctx.user()))
2988 2988 if opts.get('date'):
2989 2989 cols.append(datefunc(ctx.date()))
2990 2990 if opts.get('files_with_matches'):
2991 2991 c = (fn, rev)
2992 2992 if c in filerevmatches:
2993 2993 continue
2994 2994 filerevmatches[c] = 1
2995 2995 else:
2996 2996 before = l.line[:l.colstart]
2997 2997 match = l.line[l.colstart:l.colend]
2998 2998 after = l.line[l.colend:]
2999 2999 ui.write(sep.join(cols))
3000 3000 if before is not None:
3001 3001 if not opts.get('text') and binary():
3002 3002 ui.write(sep + " Binary file matches")
3003 3003 else:
3004 3004 ui.write(sep + before)
3005 3005 ui.write(match, label='grep.match')
3006 3006 ui.write(after)
3007 3007 ui.write(eol)
3008 3008 found = True
3009 3009 return found
3010 3010
3011 3011 skip = {}
3012 3012 revfiles = {}
3013 3013 matchfn = scmutil.match(repo[None], pats, opts)
3014 3014 found = False
3015 3015 follow = opts.get('follow')
3016 3016
3017 3017 def prep(ctx, fns):
3018 3018 rev = ctx.rev()
3019 3019 pctx = ctx.p1()
3020 3020 parent = pctx.rev()
3021 3021 matches.setdefault(rev, {})
3022 3022 matches.setdefault(parent, {})
3023 3023 files = revfiles.setdefault(rev, [])
3024 3024 for fn in fns:
3025 3025 flog = getfile(fn)
3026 3026 try:
3027 3027 fnode = ctx.filenode(fn)
3028 3028 except error.LookupError:
3029 3029 continue
3030 3030
3031 3031 copied = flog.renamed(fnode)
3032 3032 copy = follow and copied and copied[0]
3033 3033 if copy:
3034 3034 copies.setdefault(rev, {})[fn] = copy
3035 3035 if fn in skip:
3036 3036 if copy:
3037 3037 skip[copy] = True
3038 3038 continue
3039 3039 files.append(fn)
3040 3040
3041 3041 if fn not in matches[rev]:
3042 3042 grepbody(fn, rev, flog.read(fnode))
3043 3043
3044 3044 pfn = copy or fn
3045 3045 if pfn not in matches[parent]:
3046 3046 try:
3047 3047 fnode = pctx.filenode(pfn)
3048 3048 grepbody(pfn, parent, flog.read(fnode))
3049 3049 except error.LookupError:
3050 3050 pass
3051 3051
3052 3052 for ctx in cmdutil.walkchangerevs(repo, matchfn, opts, prep):
3053 3053 rev = ctx.rev()
3054 3054 parent = ctx.p1().rev()
3055 3055 for fn in sorted(revfiles.get(rev, [])):
3056 3056 states = matches[rev][fn]
3057 3057 copy = copies.get(rev, {}).get(fn)
3058 3058 if fn in skip:
3059 3059 if copy:
3060 3060 skip[copy] = True
3061 3061 continue
3062 3062 pstates = matches.get(parent, {}).get(copy or fn, [])
3063 3063 if pstates or states:
3064 3064 r = display(fn, ctx, pstates, states)
3065 3065 found = found or r
3066 3066 if r and not opts.get('all'):
3067 3067 skip[fn] = True
3068 3068 if copy:
3069 3069 skip[copy] = True
3070 3070 del matches[rev]
3071 3071 del revfiles[rev]
3072 3072
3073 3073 return not found
3074 3074
3075 3075 @command('heads',
3076 3076 [('r', 'rev', '',
3077 3077 _('show only heads which are descendants of STARTREV'), _('STARTREV')),
3078 3078 ('t', 'topo', False, _('show topological heads only')),
3079 3079 ('a', 'active', False, _('show active branchheads only (DEPRECATED)')),
3080 3080 ('c', 'closed', False, _('show normal and closed branch heads')),
3081 3081 ] + templateopts,
3082 3082 _('[-ct] [-r STARTREV] [REV]...'))
3083 3083 def heads(ui, repo, *branchrevs, **opts):
3084 3084 """show current repository heads or show branch heads
3085 3085
3086 3086 With no arguments, show all repository branch heads.
3087 3087
3088 3088 Repository "heads" are changesets with no child changesets. They are
3089 3089 where development generally takes place and are the usual targets
3090 3090 for update and merge operations. Branch heads are changesets that have
3091 3091 no child changeset on the same branch.
3092 3092
3093 3093 If one or more REVs are given, only branch heads on the branches
3094 3094 associated with the specified changesets are shown. This means
3095 3095 that you can use :hg:`heads foo` to see the heads on a branch
3096 3096 named ``foo``.
3097 3097
3098 3098 If -c/--closed is specified, also show branch heads marked closed
3099 3099 (see :hg:`commit --close-branch`).
3100 3100
3101 3101 If STARTREV is specified, only those heads that are descendants of
3102 3102 STARTREV will be displayed.
3103 3103
3104 3104 If -t/--topo is specified, named branch mechanics will be ignored and only
3105 3105 changesets without children will be shown.
3106 3106
3107 3107 Returns 0 if matching heads are found, 1 if not.
3108 3108 """
3109 3109
3110 3110 start = None
3111 3111 if 'rev' in opts:
3112 3112 start = scmutil.revsingle(repo, opts['rev'], None).node()
3113 3113
3114 3114 if opts.get('topo'):
3115 3115 heads = [repo[h] for h in repo.heads(start)]
3116 3116 else:
3117 3117 heads = []
3118 3118 for branch in repo.branchmap():
3119 3119 heads += repo.branchheads(branch, start, opts.get('closed'))
3120 3120 heads = [repo[h] for h in heads]
3121 3121
3122 3122 if branchrevs:
3123 3123 branches = set(repo[br].branch() for br in branchrevs)
3124 3124 heads = [h for h in heads if h.branch() in branches]
3125 3125
3126 3126 if opts.get('active') and branchrevs:
3127 3127 dagheads = repo.heads(start)
3128 3128 heads = [h for h in heads if h.node() in dagheads]
3129 3129
3130 3130 if branchrevs:
3131 3131 haveheads = set(h.branch() for h in heads)
3132 3132 if branches - haveheads:
3133 3133 headless = ', '.join(b for b in branches - haveheads)
3134 3134 msg = _('no open branch heads found on branches %s')
3135 3135 if opts.get('rev'):
3136 3136 msg += _(' (started at %s)') % opts['rev']
3137 3137 ui.warn((msg + '\n') % headless)
3138 3138
3139 3139 if not heads:
3140 3140 return 1
3141 3141
3142 3142 heads = sorted(heads, key=lambda x: -x.rev())
3143 3143 displayer = cmdutil.show_changeset(ui, repo, opts)
3144 3144 for ctx in heads:
3145 3145 displayer.show(ctx)
3146 3146 displayer.close()
3147 3147
3148 3148 @command('help',
3149 3149 [('e', 'extension', None, _('show only help for extensions')),
3150 3150 ('c', 'command', None, _('show only help for commands')),
3151 3151 ('k', 'keyword', '', _('show topics matching keyword')),
3152 3152 ],
3153 3153 _('[-ec] [TOPIC]'))
3154 3154 def help_(ui, name=None, unknowncmd=False, full=True, **opts):
3155 3155 """show help for a given topic or a help overview
3156 3156
3157 3157 With no arguments, print a list of commands with short help messages.
3158 3158
3159 3159 Given a topic, extension, or command name, print help for that
3160 3160 topic.
3161 3161
3162 3162 Returns 0 if successful.
3163 3163 """
3164 3164
3165 3165 textwidth = min(ui.termwidth(), 80) - 2
3166 3166
3167 3167 def helpcmd(name):
3168 3168 try:
3169 3169 aliases, entry = cmdutil.findcmd(name, table, strict=unknowncmd)
3170 3170 except error.AmbiguousCommand, inst:
3171 3171 # py3k fix: except vars can't be used outside the scope of the
3172 3172 # except block, nor can be used inside a lambda. python issue4617
3173 3173 prefix = inst.args[0]
3174 3174 select = lambda c: c.lstrip('^').startswith(prefix)
3175 3175 rst = helplist(select)
3176 3176 return rst
3177 3177
3178 3178 rst = []
3179 3179
3180 3180 # check if it's an invalid alias and display its error if it is
3181 3181 if getattr(entry[0], 'badalias', False):
3182 3182 if not unknowncmd:
3183 3183 ui.pushbuffer()
3184 3184 entry[0](ui)
3185 3185 rst.append(ui.popbuffer())
3186 3186 return rst
3187 3187
3188 3188 # synopsis
3189 3189 if len(entry) > 2:
3190 3190 if entry[2].startswith('hg'):
3191 3191 rst.append("%s\n" % entry[2])
3192 3192 else:
3193 3193 rst.append('hg %s %s\n' % (aliases[0], entry[2]))
3194 3194 else:
3195 3195 rst.append('hg %s\n' % aliases[0])
3196 3196 # aliases
3197 3197 if full and not ui.quiet and len(aliases) > 1:
3198 3198 rst.append(_("\naliases: %s\n") % ', '.join(aliases[1:]))
3199 3199 rst.append('\n')
3200 3200
3201 3201 # description
3202 3202 doc = gettext(entry[0].__doc__)
3203 3203 if not doc:
3204 3204 doc = _("(no help text available)")
3205 3205 if util.safehasattr(entry[0], 'definition'): # aliased command
3206 3206 if entry[0].definition.startswith('!'): # shell alias
3207 3207 doc = _('shell alias for::\n\n %s') % entry[0].definition[1:]
3208 3208 else:
3209 3209 doc = _('alias for: hg %s\n\n%s') % (entry[0].definition, doc)
3210 3210 doc = doc.splitlines(True)
3211 3211 if ui.quiet or not full:
3212 3212 rst.append(doc[0])
3213 3213 else:
3214 3214 rst.extend(doc)
3215 3215 rst.append('\n')
3216 3216
3217 3217 # check if this command shadows a non-trivial (multi-line)
3218 3218 # extension help text
3219 3219 try:
3220 3220 mod = extensions.find(name)
3221 3221 doc = gettext(mod.__doc__) or ''
3222 3222 if '\n' in doc.strip():
3223 3223 msg = _('use "hg help -e %s" to show help for '
3224 3224 'the %s extension') % (name, name)
3225 3225 rst.append('\n%s\n' % msg)
3226 3226 except KeyError:
3227 3227 pass
3228 3228
3229 3229 # options
3230 3230 if not ui.quiet and entry[1]:
3231 3231 rst.append('\n%s\n\n' % _("options:"))
3232 3232 rst.append(help.optrst(entry[1], ui.verbose))
3233 3233
3234 3234 if ui.verbose:
3235 3235 rst.append('\n%s\n\n' % _("global options:"))
3236 3236 rst.append(help.optrst(globalopts, ui.verbose))
3237 3237
3238 3238 if not ui.verbose:
3239 3239 if not full:
3240 3240 rst.append(_('\nuse "hg help %s" to show the full help text\n')
3241 3241 % name)
3242 3242 elif not ui.quiet:
3243 3243 rst.append(_('\nuse "hg -v help %s" to show more info\n')
3244 3244 % name)
3245 3245 return rst
3246 3246
3247 3247
3248 3248 def helplist(select=None):
3249 3249 # list of commands
3250 3250 if name == "shortlist":
3251 3251 header = _('basic commands:\n\n')
3252 3252 else:
3253 3253 header = _('list of commands:\n\n')
3254 3254
3255 3255 h = {}
3256 3256 cmds = {}
3257 3257 for c, e in table.iteritems():
3258 3258 f = c.split("|", 1)[0]
3259 3259 if select and not select(f):
3260 3260 continue
3261 3261 if (not select and name != 'shortlist' and
3262 3262 e[0].__module__ != __name__):
3263 3263 continue
3264 3264 if name == "shortlist" and not f.startswith("^"):
3265 3265 continue
3266 3266 f = f.lstrip("^")
3267 3267 if not ui.debugflag and f.startswith("debug"):
3268 3268 continue
3269 3269 doc = e[0].__doc__
3270 3270 if doc and 'DEPRECATED' in doc and not ui.verbose:
3271 3271 continue
3272 3272 doc = gettext(doc)
3273 3273 if not doc:
3274 3274 doc = _("(no help text available)")
3275 3275 h[f] = doc.splitlines()[0].rstrip()
3276 3276 cmds[f] = c.lstrip("^")
3277 3277
3278 3278 rst = []
3279 3279 if not h:
3280 3280 if not ui.quiet:
3281 3281 rst.append(_('no commands defined\n'))
3282 3282 return rst
3283 3283
3284 3284 if not ui.quiet:
3285 3285 rst.append(header)
3286 3286 fns = sorted(h)
3287 3287 for f in fns:
3288 3288 if ui.verbose:
3289 3289 commands = cmds[f].replace("|",", ")
3290 3290 rst.append(" :%s: %s\n" % (commands, h[f]))
3291 3291 else:
3292 3292 rst.append(' :%s: %s\n' % (f, h[f]))
3293 3293
3294 3294 if not name:
3295 3295 exts = help.listexts(_('enabled extensions:'), extensions.enabled())
3296 3296 if exts:
3297 3297 rst.append('\n')
3298 3298 rst.extend(exts)
3299 3299
3300 3300 rst.append(_("\nadditional help topics:\n\n"))
3301 3301 topics = []
3302 3302 for names, header, doc in help.helptable:
3303 3303 topics.append((names[0], header))
3304 3304 for t, desc in topics:
3305 3305 rst.append(" :%s: %s\n" % (t, desc))
3306 3306
3307 3307 optlist = []
3308 3308 if not ui.quiet:
3309 3309 if ui.verbose:
3310 3310 optlist.append((_("global options:"), globalopts))
3311 3311 if name == 'shortlist':
3312 3312 optlist.append((_('use "hg help" for the full list '
3313 3313 'of commands'), ()))
3314 3314 else:
3315 3315 if name == 'shortlist':
3316 3316 msg = _('use "hg help" for the full list of commands '
3317 3317 'or "hg -v" for details')
3318 3318 elif name and not full:
3319 3319 msg = _('use "hg help %s" to show the full help '
3320 3320 'text') % name
3321 3321 else:
3322 3322 msg = _('use "hg -v help%s" to show builtin aliases and '
3323 3323 'global options') % (name and " " + name or "")
3324 3324 optlist.append((msg, ()))
3325 3325
3326 3326 if optlist:
3327 3327 for title, options in optlist:
3328 3328 rst.append('\n%s\n' % title)
3329 3329 if options:
3330 3330 rst.append('\n%s\n' % help.optrst(options, ui.verbose))
3331 3331 return rst
3332 3332
3333 3333 def helptopic(name):
3334 3334 for names, header, doc in help.helptable:
3335 3335 if name in names:
3336 3336 break
3337 3337 else:
3338 3338 raise error.UnknownCommand(name)
3339 3339
3340 3340 rst = ["%s\n\n" % header]
3341 3341 # description
3342 3342 if not doc:
3343 3343 rst.append(" %s\n" % _("(no help text available)"))
3344 3344 if util.safehasattr(doc, '__call__'):
3345 3345 rst += [" %s\n" % l for l in doc().splitlines()]
3346 3346
3347 3347 try:
3348 3348 cmdutil.findcmd(name, table)
3349 3349 rst.append(_('\nuse "hg help -c %s" to see help for '
3350 3350 'the %s command\n') % (name, name))
3351 3351 except error.UnknownCommand:
3352 3352 pass
3353 3353 return rst
3354 3354
3355 3355 def helpext(name):
3356 3356 try:
3357 3357 mod = extensions.find(name)
3358 3358 doc = gettext(mod.__doc__) or _('no help text available')
3359 3359 except KeyError:
3360 3360 mod = None
3361 3361 doc = extensions.disabledext(name)
3362 3362 if not doc:
3363 3363 raise error.UnknownCommand(name)
3364 3364
3365 3365 if '\n' not in doc:
3366 3366 head, tail = doc, ""
3367 3367 else:
3368 3368 head, tail = doc.split('\n', 1)
3369 3369 rst = [_('%s extension - %s\n\n') % (name.split('.')[-1], head)]
3370 3370 if tail:
3371 3371 rst.extend(tail.splitlines(True))
3372 3372 rst.append('\n')
3373 3373
3374 3374 if mod:
3375 3375 try:
3376 3376 ct = mod.cmdtable
3377 3377 except AttributeError:
3378 3378 ct = {}
3379 3379 modcmds = set([c.split('|', 1)[0] for c in ct])
3380 3380 rst.extend(helplist(modcmds.__contains__))
3381 3381 else:
3382 3382 rst.append(_('use "hg help extensions" for information on enabling '
3383 3383 'extensions\n'))
3384 3384 return rst
3385 3385
3386 3386 def helpextcmd(name):
3387 3387 cmd, ext, mod = extensions.disabledcmd(ui, name,
3388 3388 ui.configbool('ui', 'strict'))
3389 3389 doc = gettext(mod.__doc__).splitlines()[0]
3390 3390
3391 3391 rst = help.listexts(_("'%s' is provided by the following "
3392 3392 "extension:") % cmd, {ext: doc}, indent=4)
3393 3393 rst.append('\n')
3394 3394 rst.append(_('use "hg help extensions" for information on enabling '
3395 3395 'extensions\n'))
3396 3396 return rst
3397 3397
3398 3398
3399 3399 rst = []
3400 3400 kw = opts.get('keyword')
3401 3401 if kw:
3402 3402 matches = help.topicmatch(kw)
3403 3403 for t, title in (('topics', _('Topics')),
3404 3404 ('commands', _('Commands')),
3405 3405 ('extensions', _('Extensions')),
3406 3406 ('extensioncommands', _('Extension Commands'))):
3407 3407 if matches[t]:
3408 3408 rst.append('%s:\n\n' % title)
3409 3409 rst.extend(minirst.maketable(sorted(matches[t]), 1))
3410 3410 rst.append('\n')
3411 3411 elif name and name != 'shortlist':
3412 3412 i = None
3413 3413 if unknowncmd:
3414 3414 queries = (helpextcmd,)
3415 3415 elif opts.get('extension'):
3416 3416 queries = (helpext,)
3417 3417 elif opts.get('command'):
3418 3418 queries = (helpcmd,)
3419 3419 else:
3420 3420 queries = (helptopic, helpcmd, helpext, helpextcmd)
3421 3421 for f in queries:
3422 3422 try:
3423 3423 rst = f(name)
3424 3424 i = None
3425 3425 break
3426 3426 except error.UnknownCommand, inst:
3427 3427 i = inst
3428 3428 if i:
3429 3429 raise i
3430 3430 else:
3431 3431 # program name
3432 3432 if not ui.quiet:
3433 3433 rst = [_("Mercurial Distributed SCM\n"), '\n']
3434 3434 rst.extend(helplist())
3435 3435
3436 3436 keep = ui.verbose and ['verbose'] or []
3437 3437 formatted, pruned = minirst.format(''.join(rst), textwidth, keep=keep)
3438 3438 ui.write(formatted)
3439 3439
3440 3440
3441 3441 @command('identify|id',
3442 3442 [('r', 'rev', '',
3443 3443 _('identify the specified revision'), _('REV')),
3444 3444 ('n', 'num', None, _('show local revision number')),
3445 3445 ('i', 'id', None, _('show global revision id')),
3446 3446 ('b', 'branch', None, _('show branch')),
3447 3447 ('t', 'tags', None, _('show tags')),
3448 3448 ('B', 'bookmarks', None, _('show bookmarks')),
3449 3449 ] + remoteopts,
3450 3450 _('[-nibtB] [-r REV] [SOURCE]'))
3451 3451 def identify(ui, repo, source=None, rev=None,
3452 3452 num=None, id=None, branch=None, tags=None, bookmarks=None, **opts):
3453 3453 """identify the working copy or specified revision
3454 3454
3455 3455 Print a summary identifying the repository state at REV using one or
3456 3456 two parent hash identifiers, followed by a "+" if the working
3457 3457 directory has uncommitted changes, the branch name (if not default),
3458 3458 a list of tags, and a list of bookmarks.
3459 3459
3460 3460 When REV is not given, print a summary of the current state of the
3461 3461 repository.
3462 3462
3463 3463 Specifying a path to a repository root or Mercurial bundle will
3464 3464 cause lookup to operate on that repository/bundle.
3465 3465
3466 3466 .. container:: verbose
3467 3467
3468 3468 Examples:
3469 3469
3470 3470 - generate a build identifier for the working directory::
3471 3471
3472 3472 hg id --id > build-id.dat
3473 3473
3474 3474 - find the revision corresponding to a tag::
3475 3475
3476 3476 hg id -n -r 1.3
3477 3477
3478 3478 - check the most recent revision of a remote repository::
3479 3479
3480 3480 hg id -r tip http://selenic.com/hg/
3481 3481
3482 3482 Returns 0 if successful.
3483 3483 """
3484 3484
3485 3485 if not repo and not source:
3486 3486 raise util.Abort(_("there is no Mercurial repository here "
3487 3487 "(.hg not found)"))
3488 3488
3489 3489 hexfunc = ui.debugflag and hex or short
3490 3490 default = not (num or id or branch or tags or bookmarks)
3491 3491 output = []
3492 3492 revs = []
3493 3493
3494 3494 if source:
3495 3495 source, branches = hg.parseurl(ui.expandpath(source))
3496 3496 peer = hg.peer(ui, opts, source)
3497 3497 repo = peer.local()
3498 3498 revs, checkout = hg.addbranchrevs(repo, peer, branches, None)
3499 3499
3500 3500 if not repo:
3501 3501 if num or branch or tags:
3502 3502 raise util.Abort(
3503 3503 _("can't query remote revision number, branch, or tags"))
3504 3504 if not rev and revs:
3505 3505 rev = revs[0]
3506 3506 if not rev:
3507 3507 rev = "tip"
3508 3508
3509 3509 remoterev = peer.lookup(rev)
3510 3510 if default or id:
3511 3511 output = [hexfunc(remoterev)]
3512 3512
3513 3513 def getbms():
3514 3514 bms = []
3515 3515
3516 3516 if 'bookmarks' in peer.listkeys('namespaces'):
3517 3517 hexremoterev = hex(remoterev)
3518 3518 bms = [bm for bm, bmr in peer.listkeys('bookmarks').iteritems()
3519 3519 if bmr == hexremoterev]
3520 3520
3521 3521 return bms
3522 3522
3523 3523 if bookmarks:
3524 3524 output.extend(getbms())
3525 3525 elif default and not ui.quiet:
3526 3526 # multiple bookmarks for a single parent separated by '/'
3527 3527 bm = '/'.join(getbms())
3528 3528 if bm:
3529 3529 output.append(bm)
3530 3530 else:
3531 3531 if not rev:
3532 3532 ctx = repo[None]
3533 3533 parents = ctx.parents()
3534 3534 changed = ""
3535 3535 if default or id or num:
3536 3536 if (util.any(repo.status())
3537 3537 or util.any(ctx.sub(s).dirty() for s in ctx.substate)):
3538 3538 changed = '+'
3539 3539 if default or id:
3540 3540 output = ["%s%s" %
3541 3541 ('+'.join([hexfunc(p.node()) for p in parents]), changed)]
3542 3542 if num:
3543 3543 output.append("%s%s" %
3544 3544 ('+'.join([str(p.rev()) for p in parents]), changed))
3545 3545 else:
3546 3546 ctx = scmutil.revsingle(repo, rev)
3547 3547 if default or id:
3548 3548 output = [hexfunc(ctx.node())]
3549 3549 if num:
3550 3550 output.append(str(ctx.rev()))
3551 3551
3552 3552 if default and not ui.quiet:
3553 3553 b = ctx.branch()
3554 3554 if b != 'default':
3555 3555 output.append("(%s)" % b)
3556 3556
3557 3557 # multiple tags for a single parent separated by '/'
3558 3558 t = '/'.join(ctx.tags())
3559 3559 if t:
3560 3560 output.append(t)
3561 3561
3562 3562 # multiple bookmarks for a single parent separated by '/'
3563 3563 bm = '/'.join(ctx.bookmarks())
3564 3564 if bm:
3565 3565 output.append(bm)
3566 3566 else:
3567 3567 if branch:
3568 3568 output.append(ctx.branch())
3569 3569
3570 3570 if tags:
3571 3571 output.extend(ctx.tags())
3572 3572
3573 3573 if bookmarks:
3574 3574 output.extend(ctx.bookmarks())
3575 3575
3576 3576 ui.write("%s\n" % ' '.join(output))
3577 3577
3578 3578 @command('import|patch',
3579 3579 [('p', 'strip', 1,
3580 3580 _('directory strip option for patch. This has the same '
3581 3581 'meaning as the corresponding patch option'), _('NUM')),
3582 3582 ('b', 'base', '', _('base path (DEPRECATED)'), _('PATH')),
3583 3583 ('e', 'edit', False, _('invoke editor on commit messages')),
3584 3584 ('f', 'force', None, _('skip check for outstanding uncommitted changes')),
3585 3585 ('', 'no-commit', None,
3586 3586 _("don't commit, just update the working directory")),
3587 3587 ('', 'bypass', None,
3588 3588 _("apply patch without touching the working directory")),
3589 3589 ('', 'exact', None,
3590 3590 _('apply patch to the nodes from which it was generated')),
3591 3591 ('', 'import-branch', None,
3592 3592 _('use any branch information in patch (implied by --exact)'))] +
3593 3593 commitopts + commitopts2 + similarityopts,
3594 3594 _('[OPTION]... PATCH...'))
3595 3595 def import_(ui, repo, patch1=None, *patches, **opts):
3596 3596 """import an ordered set of patches
3597 3597
3598 3598 Import a list of patches and commit them individually (unless
3599 3599 --no-commit is specified).
3600 3600
3601 3601 If there are outstanding changes in the working directory, import
3602 3602 will abort unless given the -f/--force flag.
3603 3603
3604 3604 You can import a patch straight from a mail message. Even patches
3605 3605 as attachments work (to use the body part, it must have type
3606 3606 text/plain or text/x-patch). From and Subject headers of email
3607 3607 message are used as default committer and commit message. All
3608 3608 text/plain body parts before first diff are added to commit
3609 3609 message.
3610 3610
3611 3611 If the imported patch was generated by :hg:`export`, user and
3612 3612 description from patch override values from message headers and
3613 3613 body. Values given on command line with -m/--message and -u/--user
3614 3614 override these.
3615 3615
3616 3616 If --exact is specified, import will set the working directory to
3617 3617 the parent of each patch before applying it, and will abort if the
3618 3618 resulting changeset has a different ID than the one recorded in
3619 3619 the patch. This may happen due to character set problems or other
3620 3620 deficiencies in the text patch format.
3621 3621
3622 3622 Use --bypass to apply and commit patches directly to the
3623 3623 repository, not touching the working directory. Without --exact,
3624 3624 patches will be applied on top of the working directory parent
3625 3625 revision.
3626 3626
3627 3627 With -s/--similarity, hg will attempt to discover renames and
3628 3628 copies in the patch in the same way as :hg:`addremove`.
3629 3629
3630 3630 To read a patch from standard input, use "-" as the patch name. If
3631 3631 a URL is specified, the patch will be downloaded from it.
3632 3632 See :hg:`help dates` for a list of formats valid for -d/--date.
3633 3633
3634 3634 .. container:: verbose
3635 3635
3636 3636 Examples:
3637 3637
3638 3638 - import a traditional patch from a website and detect renames::
3639 3639
3640 3640 hg import -s 80 http://example.com/bugfix.patch
3641 3641
3642 3642 - import a changeset from an hgweb server::
3643 3643
3644 3644 hg import http://www.selenic.com/hg/rev/5ca8c111e9aa
3645 3645
3646 3646 - import all the patches in an Unix-style mbox::
3647 3647
3648 3648 hg import incoming-patches.mbox
3649 3649
3650 3650 - attempt to exactly restore an exported changeset (not always
3651 3651 possible)::
3652 3652
3653 3653 hg import --exact proposed-fix.patch
3654 3654
3655 3655 Returns 0 on success.
3656 3656 """
3657 3657
3658 3658 if not patch1:
3659 3659 raise util.Abort(_('need at least one patch to import'))
3660 3660
3661 3661 patches = (patch1,) + patches
3662 3662
3663 3663 date = opts.get('date')
3664 3664 if date:
3665 3665 opts['date'] = util.parsedate(date)
3666 3666
3667 3667 editor = cmdutil.commiteditor
3668 3668 if opts.get('edit'):
3669 3669 editor = cmdutil.commitforceeditor
3670 3670
3671 3671 update = not opts.get('bypass')
3672 3672 if not update and opts.get('no_commit'):
3673 3673 raise util.Abort(_('cannot use --no-commit with --bypass'))
3674 3674 try:
3675 3675 sim = float(opts.get('similarity') or 0)
3676 3676 except ValueError:
3677 3677 raise util.Abort(_('similarity must be a number'))
3678 3678 if sim < 0 or sim > 100:
3679 3679 raise util.Abort(_('similarity must be between 0 and 100'))
3680 3680 if sim and not update:
3681 3681 raise util.Abort(_('cannot use --similarity with --bypass'))
3682 3682
3683 3683 if (opts.get('exact') or not opts.get('force')) and update:
3684 3684 cmdutil.bailifchanged(repo)
3685 3685
3686 3686 base = opts["base"]
3687 3687 strip = opts["strip"]
3688 3688 wlock = lock = tr = None
3689 3689 msgs = []
3690 3690
3691 3691 def checkexact(repo, n, nodeid):
3692 3692 if opts.get('exact') and hex(n) != nodeid:
3693 3693 repo.rollback()
3694 3694 raise util.Abort(_('patch is damaged or loses information'))
3695 3695
3696 3696 def tryone(ui, hunk, parents):
3697 3697 tmpname, message, user, date, branch, nodeid, p1, p2 = \
3698 3698 patch.extract(ui, hunk)
3699 3699
3700 3700 if not tmpname:
3701 3701 return (None, None)
3702 3702 msg = _('applied to working directory')
3703 3703
3704 3704 try:
3705 3705 cmdline_message = cmdutil.logmessage(ui, opts)
3706 3706 if cmdline_message:
3707 3707 # pickup the cmdline msg
3708 3708 message = cmdline_message
3709 3709 elif message:
3710 3710 # pickup the patch msg
3711 3711 message = message.strip()
3712 3712 else:
3713 3713 # launch the editor
3714 3714 message = None
3715 3715 ui.debug('message:\n%s\n' % message)
3716 3716
3717 3717 if len(parents) == 1:
3718 3718 parents.append(repo[nullid])
3719 3719 if opts.get('exact'):
3720 3720 if not nodeid or not p1:
3721 3721 raise util.Abort(_('not a Mercurial patch'))
3722 3722 p1 = repo[p1]
3723 3723 p2 = repo[p2 or nullid]
3724 3724 elif p2:
3725 3725 try:
3726 3726 p1 = repo[p1]
3727 3727 p2 = repo[p2]
3728 3728 # Without any options, consider p2 only if the
3729 3729 # patch is being applied on top of the recorded
3730 3730 # first parent.
3731 3731 if p1 != parents[0]:
3732 3732 p1 = parents[0]
3733 3733 p2 = repo[nullid]
3734 3734 except error.RepoError:
3735 3735 p1, p2 = parents
3736 3736 else:
3737 3737 p1, p2 = parents
3738 3738
3739 3739 n = None
3740 3740 if update:
3741 3741 if p1 != parents[0]:
3742 3742 hg.clean(repo, p1.node())
3743 3743 if p2 != parents[1]:
3744 3744 repo.setparents(p1.node(), p2.node())
3745 3745
3746 3746 if opts.get('exact') or opts.get('import_branch'):
3747 3747 repo.dirstate.setbranch(branch or 'default')
3748 3748
3749 3749 files = set()
3750 3750 patch.patch(ui, repo, tmpname, strip=strip, files=files,
3751 3751 eolmode=None, similarity=sim / 100.0)
3752 3752 files = list(files)
3753 3753 if opts.get('no_commit'):
3754 3754 if message:
3755 3755 msgs.append(message)
3756 3756 else:
3757 3757 if opts.get('exact') or p2:
3758 3758 # If you got here, you either use --force and know what
3759 3759 # you are doing or used --exact or a merge patch while
3760 3760 # being updated to its first parent.
3761 3761 m = None
3762 3762 else:
3763 3763 m = scmutil.matchfiles(repo, files or [])
3764 3764 n = repo.commit(message, opts.get('user') or user,
3765 3765 opts.get('date') or date, match=m,
3766 3766 editor=editor)
3767 3767 checkexact(repo, n, nodeid)
3768 3768 else:
3769 3769 if opts.get('exact') or opts.get('import_branch'):
3770 3770 branch = branch or 'default'
3771 3771 else:
3772 3772 branch = p1.branch()
3773 3773 store = patch.filestore()
3774 3774 try:
3775 3775 files = set()
3776 3776 try:
3777 3777 patch.patchrepo(ui, repo, p1, store, tmpname, strip,
3778 3778 files, eolmode=None)
3779 3779 except patch.PatchError, e:
3780 3780 raise util.Abort(str(e))
3781 3781 memctx = patch.makememctx(repo, (p1.node(), p2.node()),
3782 3782 message,
3783 3783 opts.get('user') or user,
3784 3784 opts.get('date') or date,
3785 3785 branch, files, store,
3786 3786 editor=cmdutil.commiteditor)
3787 3787 repo.savecommitmessage(memctx.description())
3788 3788 n = memctx.commit()
3789 3789 checkexact(repo, n, nodeid)
3790 3790 finally:
3791 3791 store.close()
3792 3792 if n:
3793 3793 # i18n: refers to a short changeset id
3794 3794 msg = _('created %s') % short(n)
3795 3795 return (msg, n)
3796 3796 finally:
3797 3797 os.unlink(tmpname)
3798 3798
3799 3799 try:
3800 3800 try:
3801 3801 wlock = repo.wlock()
3802 3802 if not opts.get('no_commit'):
3803 3803 lock = repo.lock()
3804 3804 tr = repo.transaction('import')
3805 3805 parents = repo.parents()
3806 3806 for patchurl in patches:
3807 3807 if patchurl == '-':
3808 3808 ui.status(_('applying patch from stdin\n'))
3809 3809 patchfile = ui.fin
3810 3810 patchurl = 'stdin' # for error message
3811 3811 else:
3812 3812 patchurl = os.path.join(base, patchurl)
3813 3813 ui.status(_('applying %s\n') % patchurl)
3814 3814 patchfile = url.open(ui, patchurl)
3815 3815
3816 3816 haspatch = False
3817 3817 for hunk in patch.split(patchfile):
3818 3818 (msg, node) = tryone(ui, hunk, parents)
3819 3819 if msg:
3820 3820 haspatch = True
3821 3821 ui.note(msg + '\n')
3822 3822 if update or opts.get('exact'):
3823 3823 parents = repo.parents()
3824 3824 else:
3825 3825 parents = [repo[node]]
3826 3826
3827 3827 if not haspatch:
3828 3828 raise util.Abort(_('%s: no diffs found') % patchurl)
3829 3829
3830 3830 if tr:
3831 3831 tr.close()
3832 3832 if msgs:
3833 3833 repo.savecommitmessage('\n* * *\n'.join(msgs))
3834 3834 except: # re-raises
3835 3835 # wlock.release() indirectly calls dirstate.write(): since
3836 3836 # we're crashing, we do not want to change the working dir
3837 3837 # parent after all, so make sure it writes nothing
3838 3838 repo.dirstate.invalidate()
3839 3839 raise
3840 3840 finally:
3841 3841 if tr:
3842 3842 tr.release()
3843 3843 release(lock, wlock)
3844 3844
3845 3845 @command('incoming|in',
3846 3846 [('f', 'force', None,
3847 3847 _('run even if remote repository is unrelated')),
3848 3848 ('n', 'newest-first', None, _('show newest record first')),
3849 3849 ('', 'bundle', '',
3850 3850 _('file to store the bundles into'), _('FILE')),
3851 3851 ('r', 'rev', [], _('a remote changeset intended to be added'), _('REV')),
3852 3852 ('B', 'bookmarks', False, _("compare bookmarks")),
3853 3853 ('b', 'branch', [],
3854 3854 _('a specific branch you would like to pull'), _('BRANCH')),
3855 3855 ] + logopts + remoteopts + subrepoopts,
3856 3856 _('[-p] [-n] [-M] [-f] [-r REV]... [--bundle FILENAME] [SOURCE]'))
3857 3857 def incoming(ui, repo, source="default", **opts):
3858 3858 """show new changesets found in source
3859 3859
3860 3860 Show new changesets found in the specified path/URL or the default
3861 3861 pull location. These are the changesets that would have been pulled
3862 3862 if a pull at the time you issued this command.
3863 3863
3864 3864 For remote repository, using --bundle avoids downloading the
3865 3865 changesets twice if the incoming is followed by a pull.
3866 3866
3867 3867 See pull for valid source format details.
3868 3868
3869 3869 Returns 0 if there are incoming changes, 1 otherwise.
3870 3870 """
3871 3871 if opts.get('graph'):
3872 3872 cmdutil.checkunsupportedgraphflags([], opts)
3873 3873 def display(other, chlist, displayer):
3874 3874 revdag = cmdutil.graphrevs(other, chlist, opts)
3875 3875 showparents = [ctx.node() for ctx in repo[None].parents()]
3876 3876 cmdutil.displaygraph(ui, revdag, displayer, showparents,
3877 3877 graphmod.asciiedges)
3878 3878
3879 3879 hg._incoming(display, lambda: 1, ui, repo, source, opts, buffered=True)
3880 3880 return 0
3881 3881
3882 3882 if opts.get('bundle') and opts.get('subrepos'):
3883 3883 raise util.Abort(_('cannot combine --bundle and --subrepos'))
3884 3884
3885 3885 if opts.get('bookmarks'):
3886 3886 source, branches = hg.parseurl(ui.expandpath(source),
3887 3887 opts.get('branch'))
3888 3888 other = hg.peer(repo, opts, source)
3889 3889 if 'bookmarks' not in other.listkeys('namespaces'):
3890 3890 ui.warn(_("remote doesn't support bookmarks\n"))
3891 3891 return 0
3892 3892 ui.status(_('comparing with %s\n') % util.hidepassword(source))
3893 3893 return bookmarks.diff(ui, repo, other)
3894 3894
3895 3895 repo._subtoppath = ui.expandpath(source)
3896 3896 try:
3897 3897 return hg.incoming(ui, repo, source, opts)
3898 3898 finally:
3899 3899 del repo._subtoppath
3900 3900
3901 3901
3902 3902 @command('^init', remoteopts, _('[-e CMD] [--remotecmd CMD] [DEST]'))
3903 3903 def init(ui, dest=".", **opts):
3904 3904 """create a new repository in the given directory
3905 3905
3906 3906 Initialize a new repository in the given directory. If the given
3907 3907 directory does not exist, it will be created.
3908 3908
3909 3909 If no directory is given, the current directory is used.
3910 3910
3911 3911 It is possible to specify an ``ssh://`` URL as the destination.
3912 3912 See :hg:`help urls` for more information.
3913 3913
3914 3914 Returns 0 on success.
3915 3915 """
3916 3916 hg.peer(ui, opts, ui.expandpath(dest), create=True)
3917 3917
3918 3918 @command('locate',
3919 3919 [('r', 'rev', '', _('search the repository as it is in REV'), _('REV')),
3920 3920 ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
3921 3921 ('f', 'fullpath', None, _('print complete paths from the filesystem root')),
3922 3922 ] + walkopts,
3923 3923 _('[OPTION]... [PATTERN]...'))
3924 3924 def locate(ui, repo, *pats, **opts):
3925 3925 """locate files matching specific patterns
3926 3926
3927 3927 Print files under Mercurial control in the working directory whose
3928 3928 names match the given patterns.
3929 3929
3930 3930 By default, this command searches all directories in the working
3931 3931 directory. To search just the current directory and its
3932 3932 subdirectories, use "--include .".
3933 3933
3934 3934 If no patterns are given to match, this command prints the names
3935 3935 of all files under Mercurial control in the working directory.
3936 3936
3937 3937 If you want to feed the output of this command into the "xargs"
3938 3938 command, use the -0 option to both this command and "xargs". This
3939 3939 will avoid the problem of "xargs" treating single filenames that
3940 3940 contain whitespace as multiple filenames.
3941 3941
3942 3942 Returns 0 if a match is found, 1 otherwise.
3943 3943 """
3944 3944 end = opts.get('print0') and '\0' or '\n'
3945 3945 rev = scmutil.revsingle(repo, opts.get('rev'), None).node()
3946 3946
3947 3947 ret = 1
3948 3948 m = scmutil.match(repo[rev], pats, opts, default='relglob')
3949 3949 m.bad = lambda x, y: False
3950 3950 for abs in repo[rev].walk(m):
3951 3951 if not rev and abs not in repo.dirstate:
3952 3952 continue
3953 3953 if opts.get('fullpath'):
3954 3954 ui.write(repo.wjoin(abs), end)
3955 3955 else:
3956 3956 ui.write(((pats and m.rel(abs)) or abs), end)
3957 3957 ret = 0
3958 3958
3959 3959 return ret
3960 3960
3961 3961 @command('^log|history',
3962 3962 [('f', 'follow', None,
3963 3963 _('follow changeset history, or file history across copies and renames')),
3964 3964 ('', 'follow-first', None,
3965 3965 _('only follow the first parent of merge changesets (DEPRECATED)')),
3966 3966 ('d', 'date', '', _('show revisions matching date spec'), _('DATE')),
3967 3967 ('C', 'copies', None, _('show copied files')),
3968 3968 ('k', 'keyword', [],
3969 3969 _('do case-insensitive search for a given text'), _('TEXT')),
3970 3970 ('r', 'rev', [], _('show the specified revision or range'), _('REV')),
3971 3971 ('', 'removed', None, _('include revisions where files were removed')),
3972 3972 ('m', 'only-merges', None, _('show only merges (DEPRECATED)')),
3973 3973 ('u', 'user', [], _('revisions committed by user'), _('USER')),
3974 3974 ('', 'only-branch', [],
3975 3975 _('show only changesets within the given named branch (DEPRECATED)'),
3976 3976 _('BRANCH')),
3977 3977 ('b', 'branch', [],
3978 3978 _('show changesets within the given named branch'), _('BRANCH')),
3979 3979 ('P', 'prune', [],
3980 3980 _('do not display revision or any of its ancestors'), _('REV')),
3981 3981 ('', 'hidden', False, _('show hidden changesets (DEPRECATED)')),
3982 3982 ] + logopts + walkopts,
3983 3983 _('[OPTION]... [FILE]'))
3984 3984 def log(ui, repo, *pats, **opts):
3985 3985 """show revision history of entire repository or files
3986 3986
3987 3987 Print the revision history of the specified files or the entire
3988 3988 project.
3989 3989
3990 3990 If no revision range is specified, the default is ``tip:0`` unless
3991 3991 --follow is set, in which case the working directory parent is
3992 3992 used as the starting revision.
3993 3993
3994 3994 File history is shown without following rename or copy history of
3995 3995 files. Use -f/--follow with a filename to follow history across
3996 3996 renames and copies. --follow without a filename will only show
3997 3997 ancestors or descendants of the starting revision.
3998 3998
3999 3999 By default this command prints revision number and changeset id,
4000 4000 tags, non-trivial parents, user, date and time, and a summary for
4001 4001 each commit. When the -v/--verbose switch is used, the list of
4002 4002 changed files and full commit message are shown.
4003 4003
4004 4004 .. note::
4005 4005 log -p/--patch may generate unexpected diff output for merge
4006 4006 changesets, as it will only compare the merge changeset against
4007 4007 its first parent. Also, only files different from BOTH parents
4008 4008 will appear in files:.
4009 4009
4010 4010 .. note::
4011 4011 for performance reasons, log FILE may omit duplicate changes
4012 4012 made on branches and will not show deletions. To see all
4013 4013 changes including duplicates and deletions, use the --removed
4014 4014 switch.
4015 4015
4016 4016 .. container:: verbose
4017 4017
4018 4018 Some examples:
4019 4019
4020 4020 - changesets with full descriptions and file lists::
4021 4021
4022 4022 hg log -v
4023 4023
4024 4024 - changesets ancestral to the working directory::
4025 4025
4026 4026 hg log -f
4027 4027
4028 4028 - last 10 commits on the current branch::
4029 4029
4030 4030 hg log -l 10 -b .
4031 4031
4032 4032 - changesets showing all modifications of a file, including removals::
4033 4033
4034 4034 hg log --removed file.c
4035 4035
4036 4036 - all changesets that touch a directory, with diffs, excluding merges::
4037 4037
4038 4038 hg log -Mp lib/
4039 4039
4040 4040 - all revision numbers that match a keyword::
4041 4041
4042 4042 hg log -k bug --template "{rev}\\n"
4043 4043
4044 4044 - check if a given changeset is included is a tagged release::
4045 4045
4046 4046 hg log -r "a21ccf and ancestor(1.9)"
4047 4047
4048 4048 - find all changesets by some user in a date range::
4049 4049
4050 4050 hg log -k alice -d "may 2008 to jul 2008"
4051 4051
4052 4052 - summary of all changesets after the last tag::
4053 4053
4054 4054 hg log -r "last(tagged())::" --template "{desc|firstline}\\n"
4055 4055
4056 4056 See :hg:`help dates` for a list of formats valid for -d/--date.
4057 4057
4058 4058 See :hg:`help revisions` and :hg:`help revsets` for more about
4059 4059 specifying revisions.
4060 4060
4061 4061 See :hg:`help templates` for more about pre-packaged styles and
4062 4062 specifying custom templates.
4063 4063
4064 4064 Returns 0 on success.
4065 4065 """
4066 4066 if opts.get('graph'):
4067 4067 return cmdutil.graphlog(ui, repo, *pats, **opts)
4068 4068
4069 4069 matchfn = scmutil.match(repo[None], pats, opts)
4070 4070 limit = cmdutil.loglimit(opts)
4071 4071 count = 0
4072 4072
4073 4073 getrenamed, endrev = None, None
4074 4074 if opts.get('copies'):
4075 4075 if opts.get('rev'):
4076 4076 endrev = max(scmutil.revrange(repo, opts.get('rev'))) + 1
4077 4077 getrenamed = templatekw.getrenamedfn(repo, endrev=endrev)
4078 4078
4079 4079 df = False
4080 4080 if opts.get("date"):
4081 4081 df = util.matchdate(opts["date"])
4082 4082
4083 4083 branches = opts.get('branch', []) + opts.get('only_branch', [])
4084 4084 opts['branch'] = [repo.lookupbranch(b) for b in branches]
4085 4085
4086 4086 displayer = cmdutil.show_changeset(ui, repo, opts, True)
4087 4087 def prep(ctx, fns):
4088 4088 rev = ctx.rev()
4089 4089 parents = [p for p in repo.changelog.parentrevs(rev)
4090 4090 if p != nullrev]
4091 4091 if opts.get('no_merges') and len(parents) == 2:
4092 4092 return
4093 4093 if opts.get('only_merges') and len(parents) != 2:
4094 4094 return
4095 4095 if opts.get('branch') and ctx.branch() not in opts['branch']:
4096 4096 return
4097 4097 if not opts.get('hidden') and ctx.hidden():
4098 4098 return
4099 4099 if df and not df(ctx.date()[0]):
4100 4100 return
4101 4101
4102 4102 lower = encoding.lower
4103 4103 if opts.get('user'):
4104 4104 luser = lower(ctx.user())
4105 4105 for k in [lower(x) for x in opts['user']]:
4106 4106 if (k in luser):
4107 4107 break
4108 4108 else:
4109 4109 return
4110 4110 if opts.get('keyword'):
4111 4111 luser = lower(ctx.user())
4112 4112 ldesc = lower(ctx.description())
4113 4113 lfiles = lower(" ".join(ctx.files()))
4114 4114 for k in [lower(x) for x in opts['keyword']]:
4115 4115 if (k in luser or k in ldesc or k in lfiles):
4116 4116 break
4117 4117 else:
4118 4118 return
4119 4119
4120 4120 copies = None
4121 4121 if getrenamed is not None and rev:
4122 4122 copies = []
4123 4123 for fn in ctx.files():
4124 4124 rename = getrenamed(fn, rev)
4125 4125 if rename:
4126 4126 copies.append((fn, rename[0]))
4127 4127
4128 4128 revmatchfn = None
4129 4129 if opts.get('patch') or opts.get('stat'):
4130 4130 if opts.get('follow') or opts.get('follow_first'):
4131 4131 # note: this might be wrong when following through merges
4132 4132 revmatchfn = scmutil.match(repo[None], fns, default='path')
4133 4133 else:
4134 4134 revmatchfn = matchfn
4135 4135
4136 4136 displayer.show(ctx, copies=copies, matchfn=revmatchfn)
4137 4137
4138 4138 for ctx in cmdutil.walkchangerevs(repo, matchfn, opts, prep):
4139 4139 if count == limit:
4140 4140 break
4141 4141 if displayer.flush(ctx.rev()):
4142 4142 count += 1
4143 4143 displayer.close()
4144 4144
4145 4145 @command('manifest',
4146 4146 [('r', 'rev', '', _('revision to display'), _('REV')),
4147 4147 ('', 'all', False, _("list files from all revisions"))],
4148 4148 _('[-r REV]'))
4149 4149 def manifest(ui, repo, node=None, rev=None, **opts):
4150 4150 """output the current or given revision of the project manifest
4151 4151
4152 4152 Print a list of version controlled files for the given revision.
4153 4153 If no revision is given, the first parent of the working directory
4154 4154 is used, or the null revision if no revision is checked out.
4155 4155
4156 4156 With -v, print file permissions, symlink and executable bits.
4157 4157 With --debug, print file revision hashes.
4158 4158
4159 4159 If option --all is specified, the list of all files from all revisions
4160 4160 is printed. This includes deleted and renamed files.
4161 4161
4162 4162 Returns 0 on success.
4163 4163 """
4164 4164 if opts.get('all'):
4165 4165 if rev or node:
4166 4166 raise util.Abort(_("can't specify a revision with --all"))
4167 4167
4168 4168 res = []
4169 4169 prefix = "data/"
4170 4170 suffix = ".i"
4171 4171 plen = len(prefix)
4172 4172 slen = len(suffix)
4173 4173 lock = repo.lock()
4174 4174 try:
4175 4175 for fn, b, size in repo.store.datafiles():
4176 4176 if size != 0 and fn[-slen:] == suffix and fn[:plen] == prefix:
4177 4177 res.append(fn[plen:-slen])
4178 4178 finally:
4179 4179 lock.release()
4180 4180 for f in res:
4181 4181 ui.write("%s\n" % f)
4182 4182 return
4183 4183
4184 4184 if rev and node:
4185 4185 raise util.Abort(_("please specify just one revision"))
4186 4186
4187 4187 if not node:
4188 4188 node = rev
4189 4189
4190 4190 decor = {'l':'644 @ ', 'x':'755 * ', '':'644 '}
4191 4191 ctx = scmutil.revsingle(repo, node)
4192 4192 for f in ctx:
4193 4193 if ui.debugflag:
4194 4194 ui.write("%40s " % hex(ctx.manifest()[f]))
4195 4195 if ui.verbose:
4196 4196 ui.write(decor[ctx.flags(f)])
4197 4197 ui.write("%s\n" % f)
4198 4198
4199 4199 @command('^merge',
4200 4200 [('f', 'force', None, _('force a merge with outstanding changes')),
4201 4201 ('r', 'rev', '', _('revision to merge'), _('REV')),
4202 4202 ('P', 'preview', None,
4203 4203 _('review revisions to merge (no merge is performed)'))
4204 4204 ] + mergetoolopts,
4205 4205 _('[-P] [-f] [[-r] REV]'))
4206 4206 def merge(ui, repo, node=None, **opts):
4207 4207 """merge working directory with another revision
4208 4208
4209 4209 The current working directory is updated with all changes made in
4210 4210 the requested revision since the last common predecessor revision.
4211 4211
4212 4212 Files that changed between either parent are marked as changed for
4213 4213 the next commit and a commit must be performed before any further
4214 4214 updates to the repository are allowed. The next commit will have
4215 4215 two parents.
4216 4216
4217 4217 ``--tool`` can be used to specify the merge tool used for file
4218 4218 merges. It overrides the HGMERGE environment variable and your
4219 4219 configuration files. See :hg:`help merge-tools` for options.
4220 4220
4221 4221 If no revision is specified, the working directory's parent is a
4222 4222 head revision, and the current branch contains exactly one other
4223 4223 head, the other head is merged with by default. Otherwise, an
4224 4224 explicit revision with which to merge with must be provided.
4225 4225
4226 4226 :hg:`resolve` must be used to resolve unresolved files.
4227 4227
4228 4228 To undo an uncommitted merge, use :hg:`update --clean .` which
4229 4229 will check out a clean copy of the original merge parent, losing
4230 4230 all changes.
4231 4231
4232 4232 Returns 0 on success, 1 if there are unresolved files.
4233 4233 """
4234 4234
4235 4235 if opts.get('rev') and node:
4236 4236 raise util.Abort(_("please specify just one revision"))
4237 4237 if not node:
4238 4238 node = opts.get('rev')
4239 4239
4240 4240 if node:
4241 4241 node = scmutil.revsingle(repo, node).node()
4242 4242
4243 4243 if not node and repo._bookmarkcurrent:
4244 4244 bmheads = repo.bookmarkheads(repo._bookmarkcurrent)
4245 4245 curhead = repo[repo._bookmarkcurrent]
4246 4246 if len(bmheads) == 2:
4247 4247 if curhead == bmheads[0]:
4248 4248 node = bmheads[1]
4249 4249 else:
4250 4250 node = bmheads[0]
4251 4251 elif len(bmheads) > 2:
4252 4252 raise util.Abort(_("multiple matching bookmarks to merge - "
4253 4253 "please merge with an explicit rev or bookmark"),
4254 4254 hint=_("run 'hg heads' to see all heads"))
4255 4255 elif len(bmheads) <= 1:
4256 4256 raise util.Abort(_("no matching bookmark to merge - "
4257 4257 "please merge with an explicit rev or bookmark"),
4258 4258 hint=_("run 'hg heads' to see all heads"))
4259 4259
4260 4260 if not node and not repo._bookmarkcurrent:
4261 4261 branch = repo[None].branch()
4262 4262 bheads = repo.branchheads(branch)
4263 4263 nbhs = [bh for bh in bheads if not repo[bh].bookmarks()]
4264 4264
4265 4265 if len(nbhs) > 2:
4266 4266 raise util.Abort(_("branch '%s' has %d heads - "
4267 4267 "please merge with an explicit rev")
4268 4268 % (branch, len(bheads)),
4269 4269 hint=_("run 'hg heads .' to see heads"))
4270 4270
4271 4271 parent = repo.dirstate.p1()
4272 4272 if len(nbhs) == 1:
4273 4273 if len(bheads) > 1:
4274 4274 raise util.Abort(_("heads are bookmarked - "
4275 4275 "please merge with an explicit rev"),
4276 4276 hint=_("run 'hg heads' to see all heads"))
4277 4277 if len(repo.heads()) > 1:
4278 4278 raise util.Abort(_("branch '%s' has one head - "
4279 4279 "please merge with an explicit rev")
4280 4280 % branch,
4281 4281 hint=_("run 'hg heads' to see all heads"))
4282 4282 msg, hint = _('nothing to merge'), None
4283 4283 if parent != repo.lookup(branch):
4284 4284 hint = _("use 'hg update' instead")
4285 4285 raise util.Abort(msg, hint=hint)
4286 4286
4287 4287 if parent not in bheads:
4288 4288 raise util.Abort(_('working directory not at a head revision'),
4289 4289 hint=_("use 'hg update' or merge with an "
4290 4290 "explicit revision"))
4291 4291 if parent == nbhs[0]:
4292 4292 node = nbhs[-1]
4293 4293 else:
4294 4294 node = nbhs[0]
4295 4295
4296 4296 if opts.get('preview'):
4297 4297 # find nodes that are ancestors of p2 but not of p1
4298 4298 p1 = repo.lookup('.')
4299 4299 p2 = repo.lookup(node)
4300 4300 nodes = repo.changelog.findmissing(common=[p1], heads=[p2])
4301 4301
4302 4302 displayer = cmdutil.show_changeset(ui, repo, opts)
4303 4303 for node in nodes:
4304 4304 displayer.show(repo[node])
4305 4305 displayer.close()
4306 4306 return 0
4307 4307
4308 4308 try:
4309 4309 # ui.forcemerge is an internal variable, do not document
4310 4310 repo.ui.setconfig('ui', 'forcemerge', opts.get('tool', ''))
4311 4311 return hg.merge(repo, node, force=opts.get('force'))
4312 4312 finally:
4313 4313 ui.setconfig('ui', 'forcemerge', '')
4314 4314
4315 4315 @command('outgoing|out',
4316 4316 [('f', 'force', None, _('run even when the destination is unrelated')),
4317 4317 ('r', 'rev', [],
4318 4318 _('a changeset intended to be included in the destination'), _('REV')),
4319 4319 ('n', 'newest-first', None, _('show newest record first')),
4320 4320 ('B', 'bookmarks', False, _('compare bookmarks')),
4321 4321 ('b', 'branch', [], _('a specific branch you would like to push'),
4322 4322 _('BRANCH')),
4323 4323 ] + logopts + remoteopts + subrepoopts,
4324 4324 _('[-M] [-p] [-n] [-f] [-r REV]... [DEST]'))
4325 4325 def outgoing(ui, repo, dest=None, **opts):
4326 4326 """show changesets not found in the destination
4327 4327
4328 4328 Show changesets not found in the specified destination repository
4329 4329 or the default push location. These are the changesets that would
4330 4330 be pushed if a push was requested.
4331 4331
4332 4332 See pull for details of valid destination formats.
4333 4333
4334 4334 Returns 0 if there are outgoing changes, 1 otherwise.
4335 4335 """
4336 4336 if opts.get('graph'):
4337 4337 cmdutil.checkunsupportedgraphflags([], opts)
4338 4338 o = hg._outgoing(ui, repo, dest, opts)
4339 4339 if o is None:
4340 4340 return
4341 4341
4342 4342 revdag = cmdutil.graphrevs(repo, o, opts)
4343 4343 displayer = cmdutil.show_changeset(ui, repo, opts, buffered=True)
4344 4344 showparents = [ctx.node() for ctx in repo[None].parents()]
4345 4345 cmdutil.displaygraph(ui, revdag, displayer, showparents,
4346 4346 graphmod.asciiedges)
4347 4347 return 0
4348 4348
4349 4349 if opts.get('bookmarks'):
4350 4350 dest = ui.expandpath(dest or 'default-push', dest or 'default')
4351 4351 dest, branches = hg.parseurl(dest, opts.get('branch'))
4352 4352 other = hg.peer(repo, opts, dest)
4353 4353 if 'bookmarks' not in other.listkeys('namespaces'):
4354 4354 ui.warn(_("remote doesn't support bookmarks\n"))
4355 4355 return 0
4356 4356 ui.status(_('comparing with %s\n') % util.hidepassword(dest))
4357 4357 return bookmarks.diff(ui, other, repo)
4358 4358
4359 4359 repo._subtoppath = ui.expandpath(dest or 'default-push', dest or 'default')
4360 4360 try:
4361 4361 return hg.outgoing(ui, repo, dest, opts)
4362 4362 finally:
4363 4363 del repo._subtoppath
4364 4364
4365 4365 @command('parents',
4366 4366 [('r', 'rev', '', _('show parents of the specified revision'), _('REV')),
4367 4367 ] + templateopts,
4368 4368 _('[-r REV] [FILE]'))
4369 4369 def parents(ui, repo, file_=None, **opts):
4370 4370 """show the parents of the working directory or revision
4371 4371
4372 4372 Print the working directory's parent revisions. If a revision is
4373 4373 given via -r/--rev, the parent of that revision will be printed.
4374 4374 If a file argument is given, the revision in which the file was
4375 4375 last changed (before the working directory revision or the
4376 4376 argument to --rev if given) is printed.
4377 4377
4378 4378 Returns 0 on success.
4379 4379 """
4380 4380
4381 4381 ctx = scmutil.revsingle(repo, opts.get('rev'), None)
4382 4382
4383 4383 if file_:
4384 4384 m = scmutil.match(ctx, (file_,), opts)
4385 4385 if m.anypats() or len(m.files()) != 1:
4386 4386 raise util.Abort(_('can only specify an explicit filename'))
4387 4387 file_ = m.files()[0]
4388 4388 filenodes = []
4389 4389 for cp in ctx.parents():
4390 4390 if not cp:
4391 4391 continue
4392 4392 try:
4393 4393 filenodes.append(cp.filenode(file_))
4394 4394 except error.LookupError:
4395 4395 pass
4396 4396 if not filenodes:
4397 4397 raise util.Abort(_("'%s' not found in manifest!") % file_)
4398 4398 fl = repo.file(file_)
4399 4399 p = [repo.lookup(fl.linkrev(fl.rev(fn))) for fn in filenodes]
4400 4400 else:
4401 4401 p = [cp.node() for cp in ctx.parents()]
4402 4402
4403 4403 displayer = cmdutil.show_changeset(ui, repo, opts)
4404 4404 for n in p:
4405 4405 if n != nullid:
4406 4406 displayer.show(repo[n])
4407 4407 displayer.close()
4408 4408
4409 4409 @command('paths', [], _('[NAME]'))
4410 4410 def paths(ui, repo, search=None):
4411 4411 """show aliases for remote repositories
4412 4412
4413 4413 Show definition of symbolic path name NAME. If no name is given,
4414 4414 show definition of all available names.
4415 4415
4416 4416 Option -q/--quiet suppresses all output when searching for NAME
4417 4417 and shows only the path names when listing all definitions.
4418 4418
4419 4419 Path names are defined in the [paths] section of your
4420 4420 configuration file and in ``/etc/mercurial/hgrc``. If run inside a
4421 4421 repository, ``.hg/hgrc`` is used, too.
4422 4422
4423 4423 The path names ``default`` and ``default-push`` have a special
4424 4424 meaning. When performing a push or pull operation, they are used
4425 4425 as fallbacks if no location is specified on the command-line.
4426 4426 When ``default-push`` is set, it will be used for push and
4427 4427 ``default`` will be used for pull; otherwise ``default`` is used
4428 4428 as the fallback for both. When cloning a repository, the clone
4429 4429 source is written as ``default`` in ``.hg/hgrc``. Note that
4430 4430 ``default`` and ``default-push`` apply to all inbound (e.g.
4431 4431 :hg:`incoming`) and outbound (e.g. :hg:`outgoing`, :hg:`email` and
4432 4432 :hg:`bundle`) operations.
4433 4433
4434 4434 See :hg:`help urls` for more information.
4435 4435
4436 4436 Returns 0 on success.
4437 4437 """
4438 4438 if search:
4439 4439 for name, path in ui.configitems("paths"):
4440 4440 if name == search:
4441 4441 ui.status("%s\n" % util.hidepassword(path))
4442 4442 return
4443 4443 if not ui.quiet:
4444 4444 ui.warn(_("not found!\n"))
4445 4445 return 1
4446 4446 else:
4447 4447 for name, path in ui.configitems("paths"):
4448 4448 if ui.quiet:
4449 4449 ui.write("%s\n" % name)
4450 4450 else:
4451 4451 ui.write("%s = %s\n" % (name, util.hidepassword(path)))
4452 4452
4453 4453 @command('^phase',
4454 4454 [('p', 'public', False, _('set changeset phase to public')),
4455 4455 ('d', 'draft', False, _('set changeset phase to draft')),
4456 4456 ('s', 'secret', False, _('set changeset phase to secret')),
4457 4457 ('f', 'force', False, _('allow to move boundary backward')),
4458 4458 ('r', 'rev', [], _('target revision'), _('REV')),
4459 4459 ],
4460 4460 _('[-p|-d|-s] [-f] [-r] REV...'))
4461 4461 def phase(ui, repo, *revs, **opts):
4462 4462 """set or show the current phase name
4463 4463
4464 4464 With no argument, show the phase name of specified revisions.
4465 4465
4466 4466 With one of -p/--public, -d/--draft or -s/--secret, change the
4467 4467 phase value of the specified revisions.
4468 4468
4469 4469 Unless -f/--force is specified, :hg:`phase` won't move changeset from a
4470 4470 lower phase to an higher phase. Phases are ordered as follows::
4471 4471
4472 4472 public < draft < secret
4473 4473
4474 4474 Return 0 on success, 1 if no phases were changed or some could not
4475 4475 be changed.
4476 4476 """
4477 4477 # search for a unique phase argument
4478 4478 targetphase = None
4479 4479 for idx, name in enumerate(phases.phasenames):
4480 4480 if opts[name]:
4481 4481 if targetphase is not None:
4482 4482 raise util.Abort(_('only one phase can be specified'))
4483 4483 targetphase = idx
4484 4484
4485 4485 # look for specified revision
4486 4486 revs = list(revs)
4487 4487 revs.extend(opts['rev'])
4488 4488 if not revs:
4489 4489 raise util.Abort(_('no revisions specified'))
4490 4490
4491 4491 revs = scmutil.revrange(repo, revs)
4492 4492
4493 4493 lock = None
4494 4494 ret = 0
4495 4495 if targetphase is None:
4496 4496 # display
4497 4497 for r in revs:
4498 4498 ctx = repo[r]
4499 4499 ui.write('%i: %s\n' % (ctx.rev(), ctx.phasestr()))
4500 4500 else:
4501 4501 lock = repo.lock()
4502 4502 try:
4503 4503 # set phase
4504 4504 if not revs:
4505 4505 raise util.Abort(_('empty revision set'))
4506 4506 nodes = [repo[r].node() for r in revs]
4507 4507 olddata = repo._phasecache.getphaserevs(repo)[:]
4508 4508 phases.advanceboundary(repo, targetphase, nodes)
4509 4509 if opts['force']:
4510 4510 phases.retractboundary(repo, targetphase, nodes)
4511 4511 finally:
4512 4512 lock.release()
4513 4513 newdata = repo._phasecache.getphaserevs(repo)
4514 4514 changes = sum(o != newdata[i] for i, o in enumerate(olddata))
4515 4515 rejected = [n for n in nodes
4516 4516 if newdata[repo[n].rev()] < targetphase]
4517 4517 if rejected:
4518 4518 ui.warn(_('cannot move %i changesets to a more permissive '
4519 4519 'phase, use --force\n') % len(rejected))
4520 4520 ret = 1
4521 4521 if changes:
4522 4522 msg = _('phase changed for %i changesets\n') % changes
4523 4523 if ret:
4524 4524 ui.status(msg)
4525 4525 else:
4526 4526 ui.note(msg)
4527 4527 else:
4528 4528 ui.warn(_('no phases changed\n'))
4529 4529 ret = 1
4530 4530 return ret
4531 4531
4532 4532 def postincoming(ui, repo, modheads, optupdate, checkout):
4533 4533 if modheads == 0:
4534 4534 return
4535 4535 if optupdate:
4536 4536 movemarkfrom = repo['.'].node()
4537 4537 try:
4538 4538 ret = hg.update(repo, checkout)
4539 4539 except util.Abort, inst:
4540 4540 ui.warn(_("not updating: %s\n") % str(inst))
4541 4541 return 0
4542 4542 if not ret and not checkout:
4543 4543 if bookmarks.update(repo, [movemarkfrom], repo['.'].node()):
4544 4544 ui.status(_("updating bookmark %s\n") % repo._bookmarkcurrent)
4545 4545 return ret
4546 4546 if modheads > 1:
4547 4547 currentbranchheads = len(repo.branchheads())
4548 4548 if currentbranchheads == modheads:
4549 4549 ui.status(_("(run 'hg heads' to see heads, 'hg merge' to merge)\n"))
4550 4550 elif currentbranchheads > 1:
4551 4551 ui.status(_("(run 'hg heads .' to see heads, 'hg merge' to "
4552 4552 "merge)\n"))
4553 4553 else:
4554 4554 ui.status(_("(run 'hg heads' to see heads)\n"))
4555 4555 else:
4556 4556 ui.status(_("(run 'hg update' to get a working copy)\n"))
4557 4557
4558 4558 @command('^pull',
4559 4559 [('u', 'update', None,
4560 4560 _('update to new branch head if changesets were pulled')),
4561 4561 ('f', 'force', None, _('run even when remote repository is unrelated')),
4562 4562 ('r', 'rev', [], _('a remote changeset intended to be added'), _('REV')),
4563 4563 ('B', 'bookmark', [], _("bookmark to pull"), _('BOOKMARK')),
4564 4564 ('b', 'branch', [], _('a specific branch you would like to pull'),
4565 4565 _('BRANCH')),
4566 4566 ] + remoteopts,
4567 4567 _('[-u] [-f] [-r REV]... [-e CMD] [--remotecmd CMD] [SOURCE]'))
4568 4568 def pull(ui, repo, source="default", **opts):
4569 4569 """pull changes from the specified source
4570 4570
4571 4571 Pull changes from a remote repository to a local one.
4572 4572
4573 4573 This finds all changes from the repository at the specified path
4574 4574 or URL and adds them to a local repository (the current one unless
4575 4575 -R is specified). By default, this does not update the copy of the
4576 4576 project in the working directory.
4577 4577
4578 4578 Use :hg:`incoming` if you want to see what would have been added
4579 4579 by a pull at the time you issued this command. If you then decide
4580 4580 to add those changes to the repository, you should use :hg:`pull
4581 4581 -r X` where ``X`` is the last changeset listed by :hg:`incoming`.
4582 4582
4583 4583 If SOURCE is omitted, the 'default' path will be used.
4584 4584 See :hg:`help urls` for more information.
4585 4585
4586 4586 Returns 0 on success, 1 if an update had unresolved files.
4587 4587 """
4588 4588 source, branches = hg.parseurl(ui.expandpath(source), opts.get('branch'))
4589 4589 other = hg.peer(repo, opts, source)
4590 4590 ui.status(_('pulling from %s\n') % util.hidepassword(source))
4591 4591 revs, checkout = hg.addbranchrevs(repo, other, branches, opts.get('rev'))
4592 4592
4593 4593 if opts.get('bookmark'):
4594 4594 if not revs:
4595 4595 revs = []
4596 4596 rb = other.listkeys('bookmarks')
4597 4597 for b in opts['bookmark']:
4598 4598 if b not in rb:
4599 4599 raise util.Abort(_('remote bookmark %s not found!') % b)
4600 4600 revs.append(rb[b])
4601 4601
4602 4602 if revs:
4603 4603 try:
4604 4604 revs = [other.lookup(rev) for rev in revs]
4605 4605 except error.CapabilityError:
4606 4606 err = _("other repository doesn't support revision lookup, "
4607 4607 "so a rev cannot be specified.")
4608 4608 raise util.Abort(err)
4609 4609
4610 4610 modheads = repo.pull(other, heads=revs, force=opts.get('force'))
4611 4611 bookmarks.updatefromremote(ui, repo, other, source)
4612 4612 if checkout:
4613 4613 checkout = str(repo.changelog.rev(other.lookup(checkout)))
4614 4614 repo._subtoppath = source
4615 4615 try:
4616 4616 ret = postincoming(ui, repo, modheads, opts.get('update'), checkout)
4617 4617
4618 4618 finally:
4619 4619 del repo._subtoppath
4620 4620
4621 4621 # update specified bookmarks
4622 4622 if opts.get('bookmark'):
4623 4623 for b in opts['bookmark']:
4624 4624 # explicit pull overrides local bookmark if any
4625 4625 ui.status(_("importing bookmark %s\n") % b)
4626 4626 repo._bookmarks[b] = repo[rb[b]].node()
4627 4627 bookmarks.write(repo)
4628 4628
4629 4629 return ret
4630 4630
4631 4631 @command('^push',
4632 4632 [('f', 'force', None, _('force push')),
4633 4633 ('r', 'rev', [],
4634 4634 _('a changeset intended to be included in the destination'),
4635 4635 _('REV')),
4636 4636 ('B', 'bookmark', [], _("bookmark to push"), _('BOOKMARK')),
4637 4637 ('b', 'branch', [],
4638 4638 _('a specific branch you would like to push'), _('BRANCH')),
4639 4639 ('', 'new-branch', False, _('allow pushing a new branch')),
4640 4640 ] + remoteopts,
4641 4641 _('[-f] [-r REV]... [-e CMD] [--remotecmd CMD] [DEST]'))
4642 4642 def push(ui, repo, dest=None, **opts):
4643 4643 """push changes to the specified destination
4644 4644
4645 4645 Push changesets from the local repository to the specified
4646 4646 destination.
4647 4647
4648 4648 This operation is symmetrical to pull: it is identical to a pull
4649 4649 in the destination repository from the current one.
4650 4650
4651 4651 By default, push will not allow creation of new heads at the
4652 4652 destination, since multiple heads would make it unclear which head
4653 4653 to use. In this situation, it is recommended to pull and merge
4654 4654 before pushing.
4655 4655
4656 4656 Use --new-branch if you want to allow push to create a new named
4657 4657 branch that is not present at the destination. This allows you to
4658 4658 only create a new branch without forcing other changes.
4659 4659
4660 4660 Use -f/--force to override the default behavior and push all
4661 4661 changesets on all branches.
4662 4662
4663 4663 If -r/--rev is used, the specified revision and all its ancestors
4664 4664 will be pushed to the remote repository.
4665 4665
4666 4666 If -B/--bookmark is used, the specified bookmarked revision, its
4667 4667 ancestors, and the bookmark will be pushed to the remote
4668 4668 repository.
4669 4669
4670 4670 Please see :hg:`help urls` for important details about ``ssh://``
4671 4671 URLs. If DESTINATION is omitted, a default path will be used.
4672 4672
4673 4673 Returns 0 if push was successful, 1 if nothing to push.
4674 4674 """
4675 4675
4676 4676 if opts.get('bookmark'):
4677 4677 for b in opts['bookmark']:
4678 4678 # translate -B options to -r so changesets get pushed
4679 4679 if b in repo._bookmarks:
4680 4680 opts.setdefault('rev', []).append(b)
4681 4681 else:
4682 4682 # if we try to push a deleted bookmark, translate it to null
4683 4683 # this lets simultaneous -r, -b options continue working
4684 4684 opts.setdefault('rev', []).append("null")
4685 4685
4686 4686 dest = ui.expandpath(dest or 'default-push', dest or 'default')
4687 4687 dest, branches = hg.parseurl(dest, opts.get('branch'))
4688 4688 ui.status(_('pushing to %s\n') % util.hidepassword(dest))
4689 4689 revs, checkout = hg.addbranchrevs(repo, repo, branches, opts.get('rev'))
4690 4690 other = hg.peer(repo, opts, dest)
4691 4691 if revs:
4692 4692 revs = [repo.lookup(r) for r in scmutil.revrange(repo, revs)]
4693 4693
4694 4694 repo._subtoppath = dest
4695 4695 try:
4696 4696 # push subrepos depth-first for coherent ordering
4697 4697 c = repo['']
4698 4698 subs = c.substate # only repos that are committed
4699 4699 for s in sorted(subs):
4700 4700 if c.sub(s).push(opts) == 0:
4701 4701 return False
4702 4702 finally:
4703 4703 del repo._subtoppath
4704 4704 result = repo.push(other, opts.get('force'), revs=revs,
4705 4705 newbranch=opts.get('new_branch'))
4706 4706
4707 4707 result = not result
4708 4708
4709 4709 if opts.get('bookmark'):
4710 4710 rb = other.listkeys('bookmarks')
4711 4711 for b in opts['bookmark']:
4712 4712 # explicit push overrides remote bookmark if any
4713 4713 if b in repo._bookmarks:
4714 4714 ui.status(_("exporting bookmark %s\n") % b)
4715 4715 new = repo[b].hex()
4716 4716 elif b in rb:
4717 4717 ui.status(_("deleting remote bookmark %s\n") % b)
4718 4718 new = '' # delete
4719 4719 else:
4720 4720 ui.warn(_('bookmark %s does not exist on the local '
4721 4721 'or remote repository!\n') % b)
4722 4722 return 2
4723 4723 old = rb.get(b, '')
4724 4724 r = other.pushkey('bookmarks', b, old, new)
4725 4725 if not r:
4726 4726 ui.warn(_('updating bookmark %s failed!\n') % b)
4727 4727 if not result:
4728 4728 result = 2
4729 4729
4730 4730 return result
4731 4731
4732 4732 @command('recover', [])
4733 4733 def recover(ui, repo):
4734 4734 """roll back an interrupted transaction
4735 4735
4736 4736 Recover from an interrupted commit or pull.
4737 4737
4738 4738 This command tries to fix the repository status after an
4739 4739 interrupted operation. It should only be necessary when Mercurial
4740 4740 suggests it.
4741 4741
4742 4742 Returns 0 if successful, 1 if nothing to recover or verify fails.
4743 4743 """
4744 4744 if repo.recover():
4745 4745 return hg.verify(repo)
4746 4746 return 1
4747 4747
4748 4748 @command('^remove|rm',
4749 4749 [('A', 'after', None, _('record delete for missing files')),
4750 4750 ('f', 'force', None,
4751 4751 _('remove (and delete) file even if added or modified')),
4752 4752 ] + walkopts,
4753 4753 _('[OPTION]... FILE...'))
4754 4754 def remove(ui, repo, *pats, **opts):
4755 4755 """remove the specified files on the next commit
4756 4756
4757 4757 Schedule the indicated files for removal from the current branch.
4758 4758
4759 4759 This command schedules the files to be removed at the next commit.
4760 4760 To undo a remove before that, see :hg:`revert`. To undo added
4761 4761 files, see :hg:`forget`.
4762 4762
4763 4763 .. container:: verbose
4764 4764
4765 4765 -A/--after can be used to remove only files that have already
4766 4766 been deleted, -f/--force can be used to force deletion, and -Af
4767 4767 can be used to remove files from the next revision without
4768 4768 deleting them from the working directory.
4769 4769
4770 4770 The following table details the behavior of remove for different
4771 4771 file states (columns) and option combinations (rows). The file
4772 4772 states are Added [A], Clean [C], Modified [M] and Missing [!]
4773 4773 (as reported by :hg:`status`). The actions are Warn, Remove
4774 4774 (from branch) and Delete (from disk):
4775 4775
4776 4776 ======= == == == ==
4777 4777 A C M !
4778 4778 ======= == == == ==
4779 4779 none W RD W R
4780 4780 -f R RD RD R
4781 4781 -A W W W R
4782 4782 -Af R R R R
4783 4783 ======= == == == ==
4784 4784
4785 4785 Note that remove never deletes files in Added [A] state from the
4786 4786 working directory, not even if option --force is specified.
4787 4787
4788 4788 Returns 0 on success, 1 if any warnings encountered.
4789 4789 """
4790 4790
4791 4791 ret = 0
4792 4792 after, force = opts.get('after'), opts.get('force')
4793 4793 if not pats and not after:
4794 4794 raise util.Abort(_('no files specified'))
4795 4795
4796 4796 m = scmutil.match(repo[None], pats, opts)
4797 4797 s = repo.status(match=m, clean=True)
4798 4798 modified, added, deleted, clean = s[0], s[1], s[3], s[6]
4799 4799
4800 4800 for f in m.files():
4801 4801 if f not in repo.dirstate and not os.path.isdir(m.rel(f)):
4802 4802 if os.path.exists(m.rel(f)):
4803 4803 ui.warn(_('not removing %s: file is untracked\n') % m.rel(f))
4804 4804 ret = 1
4805 4805
4806 4806 if force:
4807 4807 list = modified + deleted + clean + added
4808 4808 elif after:
4809 4809 list = deleted
4810 4810 for f in modified + added + clean:
4811 4811 ui.warn(_('not removing %s: file still exists (use -f'
4812 4812 ' to force removal)\n') % m.rel(f))
4813 4813 ret = 1
4814 4814 else:
4815 4815 list = deleted + clean
4816 4816 for f in modified:
4817 4817 ui.warn(_('not removing %s: file is modified (use -f'
4818 4818 ' to force removal)\n') % m.rel(f))
4819 4819 ret = 1
4820 4820 for f in added:
4821 4821 ui.warn(_('not removing %s: file has been marked for add'
4822 4822 ' (use forget to undo)\n') % m.rel(f))
4823 4823 ret = 1
4824 4824
4825 4825 for f in sorted(list):
4826 4826 if ui.verbose or not m.exact(f):
4827 4827 ui.status(_('removing %s\n') % m.rel(f))
4828 4828
4829 4829 wlock = repo.wlock()
4830 4830 try:
4831 4831 if not after:
4832 4832 for f in list:
4833 4833 if f in added:
4834 4834 continue # we never unlink added files on remove
4835 4835 try:
4836 4836 util.unlinkpath(repo.wjoin(f))
4837 4837 except OSError, inst:
4838 4838 if inst.errno != errno.ENOENT:
4839 4839 raise
4840 4840 repo[None].forget(list)
4841 4841 finally:
4842 4842 wlock.release()
4843 4843
4844 4844 return ret
4845 4845
4846 4846 @command('rename|move|mv',
4847 4847 [('A', 'after', None, _('record a rename that has already occurred')),
4848 4848 ('f', 'force', None, _('forcibly copy over an existing managed file')),
4849 4849 ] + walkopts + dryrunopts,
4850 4850 _('[OPTION]... SOURCE... DEST'))
4851 4851 def rename(ui, repo, *pats, **opts):
4852 4852 """rename files; equivalent of copy + remove
4853 4853
4854 4854 Mark dest as copies of sources; mark sources for deletion. If dest
4855 4855 is a directory, copies are put in that directory. If dest is a
4856 4856 file, there can only be one source.
4857 4857
4858 4858 By default, this command copies the contents of files as they
4859 4859 exist in the working directory. If invoked with -A/--after, the
4860 4860 operation is recorded, but no copying is performed.
4861 4861
4862 4862 This command takes effect at the next commit. To undo a rename
4863 4863 before that, see :hg:`revert`.
4864 4864
4865 4865 Returns 0 on success, 1 if errors are encountered.
4866 4866 """
4867 4867 wlock = repo.wlock(False)
4868 4868 try:
4869 4869 return cmdutil.copy(ui, repo, pats, opts, rename=True)
4870 4870 finally:
4871 4871 wlock.release()
4872 4872
4873 4873 @command('resolve',
4874 4874 [('a', 'all', None, _('select all unresolved files')),
4875 4875 ('l', 'list', None, _('list state of files needing merge')),
4876 4876 ('m', 'mark', None, _('mark files as resolved')),
4877 4877 ('u', 'unmark', None, _('mark files as unresolved')),
4878 4878 ('n', 'no-status', None, _('hide status prefix'))]
4879 4879 + mergetoolopts + walkopts,
4880 4880 _('[OPTION]... [FILE]...'))
4881 4881 def resolve(ui, repo, *pats, **opts):
4882 4882 """redo merges or set/view the merge status of files
4883 4883
4884 4884 Merges with unresolved conflicts are often the result of
4885 4885 non-interactive merging using the ``internal:merge`` configuration
4886 4886 setting, or a command-line merge tool like ``diff3``. The resolve
4887 4887 command is used to manage the files involved in a merge, after
4888 4888 :hg:`merge` has been run, and before :hg:`commit` is run (i.e. the
4889 4889 working directory must have two parents). See :hg:`help
4890 4890 merge-tools` for information on configuring merge tools.
4891 4891
4892 4892 The resolve command can be used in the following ways:
4893 4893
4894 4894 - :hg:`resolve [--tool TOOL] FILE...`: attempt to re-merge the specified
4895 4895 files, discarding any previous merge attempts. Re-merging is not
4896 4896 performed for files already marked as resolved. Use ``--all/-a``
4897 4897 to select all unresolved files. ``--tool`` can be used to specify
4898 4898 the merge tool used for the given files. It overrides the HGMERGE
4899 4899 environment variable and your configuration files. Previous file
4900 4900 contents are saved with a ``.orig`` suffix.
4901 4901
4902 4902 - :hg:`resolve -m [FILE]`: mark a file as having been resolved
4903 4903 (e.g. after having manually fixed-up the files). The default is
4904 4904 to mark all unresolved files.
4905 4905
4906 4906 - :hg:`resolve -u [FILE]...`: mark a file as unresolved. The
4907 4907 default is to mark all resolved files.
4908 4908
4909 4909 - :hg:`resolve -l`: list files which had or still have conflicts.
4910 4910 In the printed list, ``U`` = unresolved and ``R`` = resolved.
4911 4911
4912 4912 Note that Mercurial will not let you commit files with unresolved
4913 4913 merge conflicts. You must use :hg:`resolve -m ...` before you can
4914 4914 commit after a conflicting merge.
4915 4915
4916 4916 Returns 0 on success, 1 if any files fail a resolve attempt.
4917 4917 """
4918 4918
4919 4919 all, mark, unmark, show, nostatus = \
4920 4920 [opts.get(o) for o in 'all mark unmark list no_status'.split()]
4921 4921
4922 4922 if (show and (mark or unmark)) or (mark and unmark):
4923 4923 raise util.Abort(_("too many options specified"))
4924 4924 if pats and all:
4925 4925 raise util.Abort(_("can't specify --all and patterns"))
4926 4926 if not (all or pats or show or mark or unmark):
4927 4927 raise util.Abort(_('no files or directories specified; '
4928 4928 'use --all to remerge all files'))
4929 4929
4930 4930 ms = mergemod.mergestate(repo)
4931 4931 m = scmutil.match(repo[None], pats, opts)
4932 4932 ret = 0
4933 4933
4934 4934 for f in ms:
4935 4935 if m(f):
4936 4936 if show:
4937 4937 if nostatus:
4938 4938 ui.write("%s\n" % f)
4939 4939 else:
4940 4940 ui.write("%s %s\n" % (ms[f].upper(), f),
4941 4941 label='resolve.' +
4942 4942 {'u': 'unresolved', 'r': 'resolved'}[ms[f]])
4943 4943 elif mark:
4944 4944 ms.mark(f, "r")
4945 4945 elif unmark:
4946 4946 ms.mark(f, "u")
4947 4947 else:
4948 4948 wctx = repo[None]
4949 4949 mctx = wctx.parents()[-1]
4950 4950
4951 4951 # backup pre-resolve (merge uses .orig for its own purposes)
4952 4952 a = repo.wjoin(f)
4953 4953 util.copyfile(a, a + ".resolve")
4954 4954
4955 4955 try:
4956 4956 # resolve file
4957 4957 ui.setconfig('ui', 'forcemerge', opts.get('tool', ''))
4958 4958 if ms.resolve(f, wctx, mctx):
4959 4959 ret = 1
4960 4960 finally:
4961 4961 ui.setconfig('ui', 'forcemerge', '')
4962 4962
4963 4963 # replace filemerge's .orig file with our resolve file
4964 4964 util.rename(a + ".resolve", a + ".orig")
4965 4965
4966 4966 ms.commit()
4967 4967 return ret
4968 4968
4969 4969 @command('revert',
4970 4970 [('a', 'all', None, _('revert all changes when no arguments given')),
4971 4971 ('d', 'date', '', _('tipmost revision matching date'), _('DATE')),
4972 4972 ('r', 'rev', '', _('revert to the specified revision'), _('REV')),
4973 4973 ('C', 'no-backup', None, _('do not save backup copies of files')),
4974 4974 ] + walkopts + dryrunopts,
4975 4975 _('[OPTION]... [-r REV] [NAME]...'))
4976 4976 def revert(ui, repo, *pats, **opts):
4977 4977 """restore files to their checkout state
4978 4978
4979 4979 .. note::
4980 4980
4981 4981 To check out earlier revisions, you should use :hg:`update REV`.
4982 4982 To cancel an uncommitted merge (and lose your changes), use
4983 4983 :hg:`update --clean .`.
4984 4984
4985 4985 With no revision specified, revert the specified files or directories
4986 4986 to the contents they had in the parent of the working directory.
4987 4987 This restores the contents of files to an unmodified
4988 4988 state and unschedules adds, removes, copies, and renames. If the
4989 4989 working directory has two parents, you must explicitly specify a
4990 4990 revision.
4991 4991
4992 4992 Using the -r/--rev or -d/--date options, revert the given files or
4993 4993 directories to their states as of a specific revision. Because
4994 4994 revert does not change the working directory parents, this will
4995 4995 cause these files to appear modified. This can be helpful to "back
4996 4996 out" some or all of an earlier change. See :hg:`backout` for a
4997 4997 related method.
4998 4998
4999 4999 Modified files are saved with a .orig suffix before reverting.
5000 5000 To disable these backups, use --no-backup.
5001 5001
5002 5002 See :hg:`help dates` for a list of formats valid for -d/--date.
5003 5003
5004 5004 Returns 0 on success.
5005 5005 """
5006 5006
5007 5007 if opts.get("date"):
5008 5008 if opts.get("rev"):
5009 5009 raise util.Abort(_("you can't specify a revision and a date"))
5010 5010 opts["rev"] = cmdutil.finddate(ui, repo, opts["date"])
5011 5011
5012 5012 parent, p2 = repo.dirstate.parents()
5013 5013 if not opts.get('rev') and p2 != nullid:
5014 5014 # revert after merge is a trap for new users (issue2915)
5015 5015 raise util.Abort(_('uncommitted merge with no revision specified'),
5016 5016 hint=_('use "hg update" or see "hg help revert"'))
5017 5017
5018 5018 ctx = scmutil.revsingle(repo, opts.get('rev'))
5019 5019
5020 5020 if not pats and not opts.get('all'):
5021 5021 msg = _("no files or directories specified")
5022 5022 if p2 != nullid:
5023 5023 hint = _("uncommitted merge, use --all to discard all changes,"
5024 5024 " or 'hg update -C .' to abort the merge")
5025 5025 raise util.Abort(msg, hint=hint)
5026 5026 dirty = util.any(repo.status())
5027 5027 node = ctx.node()
5028 5028 if node != parent:
5029 5029 if dirty:
5030 5030 hint = _("uncommitted changes, use --all to discard all"
5031 5031 " changes, or 'hg update %s' to update") % ctx.rev()
5032 5032 else:
5033 5033 hint = _("use --all to revert all files,"
5034 5034 " or 'hg update %s' to update") % ctx.rev()
5035 5035 elif dirty:
5036 5036 hint = _("uncommitted changes, use --all to discard all changes")
5037 5037 else:
5038 5038 hint = _("use --all to revert all files")
5039 5039 raise util.Abort(msg, hint=hint)
5040 5040
5041 5041 return cmdutil.revert(ui, repo, ctx, (parent, p2), *pats, **opts)
5042 5042
5043 5043 @command('rollback', dryrunopts +
5044 5044 [('f', 'force', False, _('ignore safety measures'))])
5045 5045 def rollback(ui, repo, **opts):
5046 5046 """roll back the last transaction (dangerous)
5047 5047
5048 5048 This command should be used with care. There is only one level of
5049 5049 rollback, and there is no way to undo a rollback. It will also
5050 5050 restore the dirstate at the time of the last transaction, losing
5051 5051 any dirstate changes since that time. This command does not alter
5052 5052 the working directory.
5053 5053
5054 5054 Transactions are used to encapsulate the effects of all commands
5055 5055 that create new changesets or propagate existing changesets into a
5056 5056 repository.
5057 5057
5058 5058 .. container:: verbose
5059 5059
5060 5060 For example, the following commands are transactional, and their
5061 5061 effects can be rolled back:
5062 5062
5063 5063 - commit
5064 5064 - import
5065 5065 - pull
5066 5066 - push (with this repository as the destination)
5067 5067 - unbundle
5068 5068
5069 5069 To avoid permanent data loss, rollback will refuse to rollback a
5070 5070 commit transaction if it isn't checked out. Use --force to
5071 5071 override this protection.
5072 5072
5073 5073 This command is not intended for use on public repositories. Once
5074 5074 changes are visible for pull by other users, rolling a transaction
5075 5075 back locally is ineffective (someone else may already have pulled
5076 5076 the changes). Furthermore, a race is possible with readers of the
5077 5077 repository; for example an in-progress pull from the repository
5078 5078 may fail if a rollback is performed.
5079 5079
5080 5080 Returns 0 on success, 1 if no rollback data is available.
5081 5081 """
5082 5082 return repo.rollback(dryrun=opts.get('dry_run'),
5083 5083 force=opts.get('force'))
5084 5084
5085 5085 @command('root', [])
5086 5086 def root(ui, repo):
5087 5087 """print the root (top) of the current working directory
5088 5088
5089 5089 Print the root directory of the current repository.
5090 5090
5091 5091 Returns 0 on success.
5092 5092 """
5093 5093 ui.write(repo.root + "\n")
5094 5094
5095 5095 @command('^serve',
5096 5096 [('A', 'accesslog', '', _('name of access log file to write to'),
5097 5097 _('FILE')),
5098 5098 ('d', 'daemon', None, _('run server in background')),
5099 5099 ('', 'daemon-pipefds', '', _('used internally by daemon mode'), _('NUM')),
5100 5100 ('E', 'errorlog', '', _('name of error log file to write to'), _('FILE')),
5101 5101 # use string type, then we can check if something was passed
5102 5102 ('p', 'port', '', _('port to listen on (default: 8000)'), _('PORT')),
5103 5103 ('a', 'address', '', _('address to listen on (default: all interfaces)'),
5104 5104 _('ADDR')),
5105 5105 ('', 'prefix', '', _('prefix path to serve from (default: server root)'),
5106 5106 _('PREFIX')),
5107 5107 ('n', 'name', '',
5108 5108 _('name to show in web pages (default: working directory)'), _('NAME')),
5109 5109 ('', 'web-conf', '',
5110 5110 _('name of the hgweb config file (see "hg help hgweb")'), _('FILE')),
5111 5111 ('', 'webdir-conf', '', _('name of the hgweb config file (DEPRECATED)'),
5112 5112 _('FILE')),
5113 5113 ('', 'pid-file', '', _('name of file to write process ID to'), _('FILE')),
5114 5114 ('', 'stdio', None, _('for remote clients')),
5115 5115 ('', 'cmdserver', '', _('for remote clients'), _('MODE')),
5116 5116 ('t', 'templates', '', _('web templates to use'), _('TEMPLATE')),
5117 5117 ('', 'style', '', _('template style to use'), _('STYLE')),
5118 5118 ('6', 'ipv6', None, _('use IPv6 in addition to IPv4')),
5119 5119 ('', 'certificate', '', _('SSL certificate file'), _('FILE'))],
5120 5120 _('[OPTION]...'))
5121 5121 def serve(ui, repo, **opts):
5122 5122 """start stand-alone webserver
5123 5123
5124 5124 Start a local HTTP repository browser and pull server. You can use
5125 5125 this for ad-hoc sharing and browsing of repositories. It is
5126 5126 recommended to use a real web server to serve a repository for
5127 5127 longer periods of time.
5128 5128
5129 5129 Please note that the server does not implement access control.
5130 5130 This means that, by default, anybody can read from the server and
5131 5131 nobody can write to it by default. Set the ``web.allow_push``
5132 5132 option to ``*`` to allow everybody to push to the server. You
5133 5133 should use a real web server if you need to authenticate users.
5134 5134
5135 5135 By default, the server logs accesses to stdout and errors to
5136 5136 stderr. Use the -A/--accesslog and -E/--errorlog options to log to
5137 5137 files.
5138 5138
5139 5139 To have the server choose a free port number to listen on, specify
5140 5140 a port number of 0; in this case, the server will print the port
5141 5141 number it uses.
5142 5142
5143 5143 Returns 0 on success.
5144 5144 """
5145 5145
5146 5146 if opts["stdio"] and opts["cmdserver"]:
5147 5147 raise util.Abort(_("cannot use --stdio with --cmdserver"))
5148 5148
5149 5149 def checkrepo():
5150 5150 if repo is None:
5151 5151 raise error.RepoError(_("there is no Mercurial repository here"
5152 5152 " (.hg not found)"))
5153 5153
5154 5154 if opts["stdio"]:
5155 5155 checkrepo()
5156 5156 s = sshserver.sshserver(ui, repo)
5157 5157 s.serve_forever()
5158 5158
5159 5159 if opts["cmdserver"]:
5160 5160 checkrepo()
5161 5161 s = commandserver.server(ui, repo, opts["cmdserver"])
5162 5162 return s.serve()
5163 5163
5164 5164 # this way we can check if something was given in the command-line
5165 5165 if opts.get('port'):
5166 5166 opts['port'] = util.getport(opts.get('port'))
5167 5167
5168 5168 baseui = repo and repo.baseui or ui
5169 5169 optlist = ("name templates style address port prefix ipv6"
5170 5170 " accesslog errorlog certificate encoding")
5171 5171 for o in optlist.split():
5172 5172 val = opts.get(o, '')
5173 5173 if val in (None, ''): # should check against default options instead
5174 5174 continue
5175 5175 baseui.setconfig("web", o, val)
5176 5176 if repo and repo.ui != baseui:
5177 5177 repo.ui.setconfig("web", o, val)
5178 5178
5179 5179 o = opts.get('web_conf') or opts.get('webdir_conf')
5180 5180 if not o:
5181 5181 if not repo:
5182 5182 raise error.RepoError(_("there is no Mercurial repository"
5183 5183 " here (.hg not found)"))
5184 5184 o = repo.root
5185 5185
5186 5186 app = hgweb.hgweb(o, baseui=ui)
5187 5187
5188 5188 class service(object):
5189 5189 def init(self):
5190 5190 util.setsignalhandler()
5191 5191 self.httpd = hgweb.server.create_server(ui, app)
5192 5192
5193 5193 if opts['port'] and not ui.verbose:
5194 5194 return
5195 5195
5196 5196 if self.httpd.prefix:
5197 5197 prefix = self.httpd.prefix.strip('/') + '/'
5198 5198 else:
5199 5199 prefix = ''
5200 5200
5201 5201 port = ':%d' % self.httpd.port
5202 5202 if port == ':80':
5203 5203 port = ''
5204 5204
5205 5205 bindaddr = self.httpd.addr
5206 5206 if bindaddr == '0.0.0.0':
5207 5207 bindaddr = '*'
5208 5208 elif ':' in bindaddr: # IPv6
5209 5209 bindaddr = '[%s]' % bindaddr
5210 5210
5211 5211 fqaddr = self.httpd.fqaddr
5212 5212 if ':' in fqaddr:
5213 5213 fqaddr = '[%s]' % fqaddr
5214 5214 if opts['port']:
5215 5215 write = ui.status
5216 5216 else:
5217 5217 write = ui.write
5218 5218 write(_('listening at http://%s%s/%s (bound to %s:%d)\n') %
5219 5219 (fqaddr, port, prefix, bindaddr, self.httpd.port))
5220 5220
5221 5221 def run(self):
5222 5222 self.httpd.serve_forever()
5223 5223
5224 5224 service = service()
5225 5225
5226 5226 cmdutil.service(opts, initfn=service.init, runfn=service.run)
5227 5227
5228 5228 @command('showconfig|debugconfig',
5229 5229 [('u', 'untrusted', None, _('show untrusted configuration options'))],
5230 5230 _('[-u] [NAME]...'))
5231 5231 def showconfig(ui, repo, *values, **opts):
5232 5232 """show combined config settings from all hgrc files
5233 5233
5234 5234 With no arguments, print names and values of all config items.
5235 5235
5236 5236 With one argument of the form section.name, print just the value
5237 5237 of that config item.
5238 5238
5239 5239 With multiple arguments, print names and values of all config
5240 5240 items with matching section names.
5241 5241
5242 5242 With --debug, the source (filename and line number) is printed
5243 5243 for each config item.
5244 5244
5245 5245 Returns 0 on success.
5246 5246 """
5247 5247
5248 5248 for f in scmutil.rcpath():
5249 5249 ui.debug('read config from: %s\n' % f)
5250 5250 untrusted = bool(opts.get('untrusted'))
5251 5251 if values:
5252 5252 sections = [v for v in values if '.' not in v]
5253 5253 items = [v for v in values if '.' in v]
5254 5254 if len(items) > 1 or items and sections:
5255 5255 raise util.Abort(_('only one config item permitted'))
5256 5256 for section, name, value in ui.walkconfig(untrusted=untrusted):
5257 5257 value = str(value).replace('\n', '\\n')
5258 5258 sectname = section + '.' + name
5259 5259 if values:
5260 5260 for v in values:
5261 5261 if v == section:
5262 5262 ui.debug('%s: ' %
5263 5263 ui.configsource(section, name, untrusted))
5264 5264 ui.write('%s=%s\n' % (sectname, value))
5265 5265 elif v == sectname:
5266 5266 ui.debug('%s: ' %
5267 5267 ui.configsource(section, name, untrusted))
5268 5268 ui.write(value, '\n')
5269 5269 else:
5270 5270 ui.debug('%s: ' %
5271 5271 ui.configsource(section, name, untrusted))
5272 5272 ui.write('%s=%s\n' % (sectname, value))
5273 5273
5274 5274 @command('^status|st',
5275 5275 [('A', 'all', None, _('show status of all files')),
5276 5276 ('m', 'modified', None, _('show only modified files')),
5277 5277 ('a', 'added', None, _('show only added files')),
5278 5278 ('r', 'removed', None, _('show only removed files')),
5279 5279 ('d', 'deleted', None, _('show only deleted (but tracked) files')),
5280 5280 ('c', 'clean', None, _('show only files without changes')),
5281 5281 ('u', 'unknown', None, _('show only unknown (not tracked) files')),
5282 5282 ('i', 'ignored', None, _('show only ignored files')),
5283 5283 ('n', 'no-status', None, _('hide status prefix')),
5284 5284 ('C', 'copies', None, _('show source of copied files')),
5285 5285 ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
5286 5286 ('', 'rev', [], _('show difference from revision'), _('REV')),
5287 5287 ('', 'change', '', _('list the changed files of a revision'), _('REV')),
5288 5288 ] + walkopts + subrepoopts,
5289 5289 _('[OPTION]... [FILE]...'))
5290 5290 def status(ui, repo, *pats, **opts):
5291 5291 """show changed files in the working directory
5292 5292
5293 5293 Show status of files in the repository. If names are given, only
5294 5294 files that match are shown. Files that are clean or ignored or
5295 5295 the source of a copy/move operation, are not listed unless
5296 5296 -c/--clean, -i/--ignored, -C/--copies or -A/--all are given.
5297 5297 Unless options described with "show only ..." are given, the
5298 5298 options -mardu are used.
5299 5299
5300 5300 Option -q/--quiet hides untracked (unknown and ignored) files
5301 5301 unless explicitly requested with -u/--unknown or -i/--ignored.
5302 5302
5303 5303 .. note::
5304 5304 status may appear to disagree with diff if permissions have
5305 5305 changed or a merge has occurred. The standard diff format does
5306 5306 not report permission changes and diff only reports changes
5307 5307 relative to one merge parent.
5308 5308
5309 5309 If one revision is given, it is used as the base revision.
5310 5310 If two revisions are given, the differences between them are
5311 5311 shown. The --change option can also be used as a shortcut to list
5312 5312 the changed files of a revision from its first parent.
5313 5313
5314 5314 The codes used to show the status of files are::
5315 5315
5316 5316 M = modified
5317 5317 A = added
5318 5318 R = removed
5319 5319 C = clean
5320 5320 ! = missing (deleted by non-hg command, but still tracked)
5321 5321 ? = not tracked
5322 5322 I = ignored
5323 5323 = origin of the previous file listed as A (added)
5324 5324
5325 5325 .. container:: verbose
5326 5326
5327 5327 Examples:
5328 5328
5329 5329 - show changes in the working directory relative to a
5330 5330 changeset::
5331 5331
5332 5332 hg status --rev 9353
5333 5333
5334 5334 - show all changes including copies in an existing changeset::
5335 5335
5336 5336 hg status --copies --change 9353
5337 5337
5338 5338 - get a NUL separated list of added files, suitable for xargs::
5339 5339
5340 5340 hg status -an0
5341 5341
5342 5342 Returns 0 on success.
5343 5343 """
5344 5344
5345 5345 revs = opts.get('rev')
5346 5346 change = opts.get('change')
5347 5347
5348 5348 if revs and change:
5349 5349 msg = _('cannot specify --rev and --change at the same time')
5350 5350 raise util.Abort(msg)
5351 5351 elif change:
5352 5352 node2 = scmutil.revsingle(repo, change, None).node()
5353 5353 node1 = repo[node2].p1().node()
5354 5354 else:
5355 5355 node1, node2 = scmutil.revpair(repo, revs)
5356 5356
5357 5357 cwd = (pats and repo.getcwd()) or ''
5358 5358 end = opts.get('print0') and '\0' or '\n'
5359 5359 copy = {}
5360 5360 states = 'modified added removed deleted unknown ignored clean'.split()
5361 5361 show = [k for k in states if opts.get(k)]
5362 5362 if opts.get('all'):
5363 5363 show += ui.quiet and (states[:4] + ['clean']) or states
5364 5364 if not show:
5365 5365 show = ui.quiet and states[:4] or states[:5]
5366 5366
5367 5367 stat = repo.status(node1, node2, scmutil.match(repo[node2], pats, opts),
5368 5368 'ignored' in show, 'clean' in show, 'unknown' in show,
5369 5369 opts.get('subrepos'))
5370 5370 changestates = zip(states, 'MAR!?IC', stat)
5371 5371
5372 5372 if (opts.get('all') or opts.get('copies')) and not opts.get('no_status'):
5373 5373 copy = copies.pathcopies(repo[node1], repo[node2])
5374 5374
5375 5375 fm = ui.formatter('status', opts)
5376 5376 format = '%s %s' + end
5377 5377 if opts.get('no_status'):
5378 5378 format = '%.0s%s' + end
5379 5379
5380 5380 for state, char, files in changestates:
5381 5381 if state in show:
5382 5382 label = 'status.' + state
5383 5383 for f in files:
5384 5384 fm.startitem()
5385 5385 fm.write("status path", format, char,
5386 5386 repo.pathto(f, cwd), label=label)
5387 5387 if f in copy:
5388 5388 fm.write("copy", ' %s' + end, repo.pathto(copy[f], cwd),
5389 5389 label='status.copied')
5390 5390 fm.end()
5391 5391
5392 5392 @command('^summary|sum',
5393 5393 [('', 'remote', None, _('check for push and pull'))], '[--remote]')
5394 5394 def summary(ui, repo, **opts):
5395 5395 """summarize working directory state
5396 5396
5397 5397 This generates a brief summary of the working directory state,
5398 5398 including parents, branch, commit status, and available updates.
5399 5399
5400 5400 With the --remote option, this will check the default paths for
5401 5401 incoming and outgoing changes. This can be time-consuming.
5402 5402
5403 5403 Returns 0 on success.
5404 5404 """
5405 5405
5406 5406 ctx = repo[None]
5407 5407 parents = ctx.parents()
5408 5408 pnode = parents[0].node()
5409 5409 marks = []
5410 5410
5411 5411 for p in parents:
5412 5412 # label with log.changeset (instead of log.parent) since this
5413 5413 # shows a working directory parent *changeset*:
5414 5414 ui.write(_('parent: %d:%s ') % (p.rev(), str(p)),
5415 5415 label='log.changeset')
5416 5416 ui.write(' '.join(p.tags()), label='log.tag')
5417 5417 if p.bookmarks():
5418 5418 marks.extend(p.bookmarks())
5419 5419 if p.rev() == -1:
5420 5420 if not len(repo):
5421 5421 ui.write(_(' (empty repository)'))
5422 5422 else:
5423 5423 ui.write(_(' (no revision checked out)'))
5424 5424 ui.write('\n')
5425 5425 if p.description():
5426 5426 ui.status(' ' + p.description().splitlines()[0].strip() + '\n',
5427 5427 label='log.summary')
5428 5428
5429 5429 branch = ctx.branch()
5430 5430 bheads = repo.branchheads(branch)
5431 5431 m = _('branch: %s\n') % branch
5432 5432 if branch != 'default':
5433 5433 ui.write(m, label='log.branch')
5434 5434 else:
5435 5435 ui.status(m, label='log.branch')
5436 5436
5437 5437 if marks:
5438 5438 current = repo._bookmarkcurrent
5439 5439 ui.write(_('bookmarks:'), label='log.bookmark')
5440 5440 if current is not None:
5441 5441 try:
5442 5442 marks.remove(current)
5443 5443 ui.write(' *' + current, label='bookmarks.current')
5444 5444 except ValueError:
5445 5445 # current bookmark not in parent ctx marks
5446 5446 pass
5447 5447 for m in marks:
5448 5448 ui.write(' ' + m, label='log.bookmark')
5449 5449 ui.write('\n', label='log.bookmark')
5450 5450
5451 5451 st = list(repo.status(unknown=True))[:6]
5452 5452
5453 5453 c = repo.dirstate.copies()
5454 5454 copied, renamed = [], []
5455 5455 for d, s in c.iteritems():
5456 5456 if s in st[2]:
5457 5457 st[2].remove(s)
5458 5458 renamed.append(d)
5459 5459 else:
5460 5460 copied.append(d)
5461 5461 if d in st[1]:
5462 5462 st[1].remove(d)
5463 5463 st.insert(3, renamed)
5464 5464 st.insert(4, copied)
5465 5465
5466 5466 ms = mergemod.mergestate(repo)
5467 5467 st.append([f for f in ms if ms[f] == 'u'])
5468 5468
5469 5469 subs = [s for s in ctx.substate if ctx.sub(s).dirty()]
5470 5470 st.append(subs)
5471 5471
5472 5472 labels = [ui.label(_('%d modified'), 'status.modified'),
5473 5473 ui.label(_('%d added'), 'status.added'),
5474 5474 ui.label(_('%d removed'), 'status.removed'),
5475 5475 ui.label(_('%d renamed'), 'status.copied'),
5476 5476 ui.label(_('%d copied'), 'status.copied'),
5477 5477 ui.label(_('%d deleted'), 'status.deleted'),
5478 5478 ui.label(_('%d unknown'), 'status.unknown'),
5479 5479 ui.label(_('%d ignored'), 'status.ignored'),
5480 5480 ui.label(_('%d unresolved'), 'resolve.unresolved'),
5481 5481 ui.label(_('%d subrepos'), 'status.modified')]
5482 5482 t = []
5483 5483 for s, l in zip(st, labels):
5484 5484 if s:
5485 5485 t.append(l % len(s))
5486 5486
5487 5487 t = ', '.join(t)
5488 5488 cleanworkdir = False
5489 5489
5490 5490 if len(parents) > 1:
5491 5491 t += _(' (merge)')
5492 5492 elif branch != parents[0].branch():
5493 5493 t += _(' (new branch)')
5494 5494 elif (parents[0].closesbranch() and
5495 5495 pnode in repo.branchheads(branch, closed=True)):
5496 5496 t += _(' (head closed)')
5497 5497 elif not (st[0] or st[1] or st[2] or st[3] or st[4] or st[9]):
5498 5498 t += _(' (clean)')
5499 5499 cleanworkdir = True
5500 5500 elif pnode not in bheads:
5501 5501 t += _(' (new branch head)')
5502 5502
5503 5503 if cleanworkdir:
5504 5504 ui.status(_('commit: %s\n') % t.strip())
5505 5505 else:
5506 5506 ui.write(_('commit: %s\n') % t.strip())
5507 5507
5508 5508 # all ancestors of branch heads - all ancestors of parent = new csets
5509 5509 new = [0] * len(repo)
5510 5510 cl = repo.changelog
5511 5511 for a in [cl.rev(n) for n in bheads]:
5512 5512 new[a] = 1
5513 5513 for a in cl.ancestors([cl.rev(n) for n in bheads]):
5514 5514 new[a] = 1
5515 5515 for a in [p.rev() for p in parents]:
5516 5516 if a >= 0:
5517 5517 new[a] = 0
5518 5518 for a in cl.ancestors([p.rev() for p in parents]):
5519 5519 new[a] = 0
5520 5520 new = sum(new)
5521 5521
5522 5522 if new == 0:
5523 5523 ui.status(_('update: (current)\n'))
5524 5524 elif pnode not in bheads:
5525 5525 ui.write(_('update: %d new changesets (update)\n') % new)
5526 5526 else:
5527 5527 ui.write(_('update: %d new changesets, %d branch heads (merge)\n') %
5528 5528 (new, len(bheads)))
5529 5529
5530 5530 if opts.get('remote'):
5531 5531 t = []
5532 5532 source, branches = hg.parseurl(ui.expandpath('default'))
5533 5533 other = hg.peer(repo, {}, source)
5534 5534 revs, checkout = hg.addbranchrevs(repo, other, branches,
5535 5535 opts.get('rev'))
5536 5536 ui.debug('comparing with %s\n' % util.hidepassword(source))
5537 5537 repo.ui.pushbuffer()
5538 5538 commoninc = discovery.findcommonincoming(repo, other)
5539 5539 _common, incoming, _rheads = commoninc
5540 5540 repo.ui.popbuffer()
5541 5541 if incoming:
5542 5542 t.append(_('1 or more incoming'))
5543 5543
5544 5544 dest, branches = hg.parseurl(ui.expandpath('default-push', 'default'))
5545 5545 revs, checkout = hg.addbranchrevs(repo, repo, branches, None)
5546 5546 if source != dest:
5547 5547 other = hg.peer(repo, {}, dest)
5548 5548 commoninc = None
5549 5549 ui.debug('comparing with %s\n' % util.hidepassword(dest))
5550 5550 repo.ui.pushbuffer()
5551 5551 outgoing = discovery.findcommonoutgoing(repo, other,
5552 5552 commoninc=commoninc)
5553 5553 repo.ui.popbuffer()
5554 5554 o = outgoing.missing
5555 5555 if o:
5556 5556 t.append(_('%d outgoing') % len(o))
5557 5557 if 'bookmarks' in other.listkeys('namespaces'):
5558 5558 lmarks = repo.listkeys('bookmarks')
5559 5559 rmarks = other.listkeys('bookmarks')
5560 5560 diff = set(rmarks) - set(lmarks)
5561 5561 if len(diff) > 0:
5562 5562 t.append(_('%d incoming bookmarks') % len(diff))
5563 5563 diff = set(lmarks) - set(rmarks)
5564 5564 if len(diff) > 0:
5565 5565 t.append(_('%d outgoing bookmarks') % len(diff))
5566 5566
5567 5567 if t:
5568 5568 ui.write(_('remote: %s\n') % (', '.join(t)))
5569 5569 else:
5570 5570 ui.status(_('remote: (synced)\n'))
5571 5571
5572 5572 @command('tag',
5573 5573 [('f', 'force', None, _('force tag')),
5574 5574 ('l', 'local', None, _('make the tag local')),
5575 5575 ('r', 'rev', '', _('revision to tag'), _('REV')),
5576 5576 ('', 'remove', None, _('remove a tag')),
5577 5577 # -l/--local is already there, commitopts cannot be used
5578 5578 ('e', 'edit', None, _('edit commit message')),
5579 5579 ('m', 'message', '', _('use <text> as commit message'), _('TEXT')),
5580 5580 ] + commitopts2,
5581 5581 _('[-f] [-l] [-m TEXT] [-d DATE] [-u USER] [-r REV] NAME...'))
5582 5582 def tag(ui, repo, name1, *names, **opts):
5583 5583 """add one or more tags for the current or given revision
5584 5584
5585 5585 Name a particular revision using <name>.
5586 5586
5587 5587 Tags are used to name particular revisions of the repository and are
5588 5588 very useful to compare different revisions, to go back to significant
5589 5589 earlier versions or to mark branch points as releases, etc. Changing
5590 5590 an existing tag is normally disallowed; use -f/--force to override.
5591 5591
5592 5592 If no revision is given, the parent of the working directory is
5593 5593 used, or tip if no revision is checked out.
5594 5594
5595 5595 To facilitate version control, distribution, and merging of tags,
5596 5596 they are stored as a file named ".hgtags" which is managed similarly
5597 5597 to other project files and can be hand-edited if necessary. This
5598 5598 also means that tagging creates a new commit. The file
5599 5599 ".hg/localtags" is used for local tags (not shared among
5600 5600 repositories).
5601 5601
5602 5602 Tag commits are usually made at the head of a branch. If the parent
5603 5603 of the working directory is not a branch head, :hg:`tag` aborts; use
5604 5604 -f/--force to force the tag commit to be based on a non-head
5605 5605 changeset.
5606 5606
5607 5607 See :hg:`help dates` for a list of formats valid for -d/--date.
5608 5608
5609 5609 Since tag names have priority over branch names during revision
5610 5610 lookup, using an existing branch name as a tag name is discouraged.
5611 5611
5612 5612 Returns 0 on success.
5613 5613 """
5614 5614 wlock = lock = None
5615 5615 try:
5616 5616 wlock = repo.wlock()
5617 5617 lock = repo.lock()
5618 5618 rev_ = "."
5619 5619 names = [t.strip() for t in (name1,) + names]
5620 5620 if len(names) != len(set(names)):
5621 5621 raise util.Abort(_('tag names must be unique'))
5622 5622 for n in names:
5623 5623 if n in ['tip', '.', 'null']:
5624 5624 raise util.Abort(_("the name '%s' is reserved") % n)
5625 5625 if not n:
5626 5626 raise util.Abort(_('tag names cannot consist entirely of '
5627 5627 'whitespace'))
5628 5628 if opts.get('rev') and opts.get('remove'):
5629 5629 raise util.Abort(_("--rev and --remove are incompatible"))
5630 5630 if opts.get('rev'):
5631 5631 rev_ = opts['rev']
5632 5632 message = opts.get('message')
5633 5633 if opts.get('remove'):
5634 5634 expectedtype = opts.get('local') and 'local' or 'global'
5635 5635 for n in names:
5636 5636 if not repo.tagtype(n):
5637 5637 raise util.Abort(_("tag '%s' does not exist") % n)
5638 5638 if repo.tagtype(n) != expectedtype:
5639 5639 if expectedtype == 'global':
5640 5640 raise util.Abort(_("tag '%s' is not a global tag") % n)
5641 5641 else:
5642 5642 raise util.Abort(_("tag '%s' is not a local tag") % n)
5643 5643 rev_ = nullid
5644 5644 if not message:
5645 5645 # we don't translate commit messages
5646 5646 message = 'Removed tag %s' % ', '.join(names)
5647 5647 elif not opts.get('force'):
5648 5648 for n in names:
5649 5649 if n in repo.tags():
5650 5650 raise util.Abort(_("tag '%s' already exists "
5651 5651 "(use -f to force)") % n)
5652 5652 if not opts.get('local'):
5653 5653 p1, p2 = repo.dirstate.parents()
5654 5654 if p2 != nullid:
5655 5655 raise util.Abort(_('uncommitted merge'))
5656 5656 bheads = repo.branchheads()
5657 5657 if not opts.get('force') and bheads and p1 not in bheads:
5658 5658 raise util.Abort(_('not at a branch head (use -f to force)'))
5659 5659 r = scmutil.revsingle(repo, rev_).node()
5660 5660
5661 5661 if not message:
5662 5662 # we don't translate commit messages
5663 5663 message = ('Added tag %s for changeset %s' %
5664 5664 (', '.join(names), short(r)))
5665 5665
5666 5666 date = opts.get('date')
5667 5667 if date:
5668 5668 date = util.parsedate(date)
5669 5669
5670 5670 if opts.get('edit'):
5671 5671 message = ui.edit(message, ui.username())
5672 5672
5673 5673 # don't allow tagging the null rev
5674 5674 if (not opts.get('remove') and
5675 5675 scmutil.revsingle(repo, rev_).rev() == nullrev):
5676 5676 raise util.Abort(_("null revision specified"))
5677 5677
5678 5678 repo.tag(names, r, message, opts.get('local'), opts.get('user'), date)
5679 5679 finally:
5680 5680 release(lock, wlock)
5681 5681
5682 5682 @command('tags', [], '')
5683 5683 def tags(ui, repo):
5684 5684 """list repository tags
5685 5685
5686 5686 This lists both regular and local tags. When the -v/--verbose
5687 5687 switch is used, a third column "local" is printed for local tags.
5688 5688
5689 5689 Returns 0 on success.
5690 5690 """
5691 5691
5692 5692 hexfunc = ui.debugflag and hex or short
5693 5693 tagtype = ""
5694 5694
5695 5695 for t, n in reversed(repo.tagslist()):
5696 5696 if ui.quiet:
5697 5697 ui.write("%s\n" % t, label='tags.normal')
5698 5698 continue
5699 5699
5700 5700 hn = hexfunc(n)
5701 5701 r = "%5d:%s" % (repo.changelog.rev(n), hn)
5702 5702 rev = ui.label(r, 'log.changeset')
5703 5703 spaces = " " * (30 - encoding.colwidth(t))
5704 5704
5705 5705 tag = ui.label(t, 'tags.normal')
5706 5706 if ui.verbose:
5707 5707 if repo.tagtype(t) == 'local':
5708 5708 tagtype = " local"
5709 5709 tag = ui.label(t, 'tags.local')
5710 5710 else:
5711 5711 tagtype = ""
5712 5712 ui.write("%s%s %s%s\n" % (tag, spaces, rev, tagtype))
5713 5713
5714 5714 @command('tip',
5715 5715 [('p', 'patch', None, _('show patch')),
5716 5716 ('g', 'git', None, _('use git extended diff format')),
5717 5717 ] + templateopts,
5718 5718 _('[-p] [-g]'))
5719 5719 def tip(ui, repo, **opts):
5720 5720 """show the tip revision
5721 5721
5722 5722 The tip revision (usually just called the tip) is the changeset
5723 5723 most recently added to the repository (and therefore the most
5724 5724 recently changed head).
5725 5725
5726 5726 If you have just made a commit, that commit will be the tip. If
5727 5727 you have just pulled changes from another repository, the tip of
5728 5728 that repository becomes the current tip. The "tip" tag is special
5729 5729 and cannot be renamed or assigned to a different changeset.
5730 5730
5731 5731 Returns 0 on success.
5732 5732 """
5733 5733 displayer = cmdutil.show_changeset(ui, repo, opts)
5734 5734 displayer.show(repo[len(repo) - 1])
5735 5735 displayer.close()
5736 5736
5737 5737 @command('unbundle',
5738 5738 [('u', 'update', None,
5739 5739 _('update to new branch head if changesets were unbundled'))],
5740 5740 _('[-u] FILE...'))
5741 5741 def unbundle(ui, repo, fname1, *fnames, **opts):
5742 5742 """apply one or more changegroup files
5743 5743
5744 5744 Apply one or more compressed changegroup files generated by the
5745 5745 bundle command.
5746 5746
5747 5747 Returns 0 on success, 1 if an update has unresolved files.
5748 5748 """
5749 5749 fnames = (fname1,) + fnames
5750 5750
5751 5751 lock = repo.lock()
5752 5752 wc = repo['.']
5753 5753 try:
5754 5754 for fname in fnames:
5755 5755 f = url.open(ui, fname)
5756 5756 gen = changegroup.readbundle(f, fname)
5757 5757 modheads = repo.addchangegroup(gen, 'unbundle', 'bundle:' + fname)
5758 5758 finally:
5759 5759 lock.release()
5760 5760 bookmarks.updatecurrentbookmark(repo, wc.node(), wc.branch())
5761 5761 return postincoming(ui, repo, modheads, opts.get('update'), None)
5762 5762
5763 5763 @command('^update|up|checkout|co',
5764 5764 [('C', 'clean', None, _('discard uncommitted changes (no backup)')),
5765 5765 ('c', 'check', None,
5766 5766 _('update across branches if no uncommitted changes')),
5767 5767 ('d', 'date', '', _('tipmost revision matching date'), _('DATE')),
5768 5768 ('r', 'rev', '', _('revision'), _('REV'))],
5769 5769 _('[-c] [-C] [-d DATE] [[-r] REV]'))
5770 5770 def update(ui, repo, node=None, rev=None, clean=False, date=None, check=False):
5771 5771 """update working directory (or switch revisions)
5772 5772
5773 5773 Update the repository's working directory to the specified
5774 5774 changeset. If no changeset is specified, update to the tip of the
5775 5775 current named branch and move the current bookmark (see :hg:`help
5776 5776 bookmarks`).
5777 5777
5778 5778 Update sets the working directory's parent revision to the specified
5779 5779 changeset (see :hg:`help parents`).
5780 5780
5781 5781 If the changeset is not a descendant or ancestor of the working
5782 5782 directory's parent, the update is aborted. With the -c/--check
5783 5783 option, the working directory is checked for uncommitted changes; if
5784 5784 none are found, the working directory is updated to the specified
5785 5785 changeset.
5786 5786
5787 5787 .. container:: verbose
5788 5788
5789 5789 The following rules apply when the working directory contains
5790 5790 uncommitted changes:
5791 5791
5792 5792 1. If neither -c/--check nor -C/--clean is specified, and if
5793 5793 the requested changeset is an ancestor or descendant of
5794 5794 the working directory's parent, the uncommitted changes
5795 5795 are merged into the requested changeset and the merged
5796 5796 result is left uncommitted. If the requested changeset is
5797 5797 not an ancestor or descendant (that is, it is on another
5798 5798 branch), the update is aborted and the uncommitted changes
5799 5799 are preserved.
5800 5800
5801 5801 2. With the -c/--check option, the update is aborted and the
5802 5802 uncommitted changes are preserved.
5803 5803
5804 5804 3. With the -C/--clean option, uncommitted changes are discarded and
5805 5805 the working directory is updated to the requested changeset.
5806 5806
5807 5807 To cancel an uncommitted merge (and lose your changes), use
5808 5808 :hg:`update --clean .`.
5809 5809
5810 5810 Use null as the changeset to remove the working directory (like
5811 5811 :hg:`clone -U`).
5812 5812
5813 5813 If you want to revert just one file to an older revision, use
5814 5814 :hg:`revert [-r REV] NAME`.
5815 5815
5816 5816 See :hg:`help dates` for a list of formats valid for -d/--date.
5817 5817
5818 5818 Returns 0 on success, 1 if there are unresolved files.
5819 5819 """
5820 5820 if rev and node:
5821 5821 raise util.Abort(_("please specify just one revision"))
5822 5822
5823 5823 if rev is None or rev == '':
5824 5824 rev = node
5825 5825
5826 5826 # with no argument, we also move the current bookmark, if any
5827 5827 movemarkfrom = None
5828 5828 if rev is None or node == '':
5829 5829 movemarkfrom = repo['.'].node()
5830 5830
5831 5831 # if we defined a bookmark, we have to remember the original bookmark name
5832 5832 brev = rev
5833 5833 rev = scmutil.revsingle(repo, rev, rev).rev()
5834 5834
5835 5835 if check and clean:
5836 5836 raise util.Abort(_("cannot specify both -c/--check and -C/--clean"))
5837 5837
5838 5838 if date:
5839 5839 if rev is not None:
5840 5840 raise util.Abort(_("you can't specify a revision and a date"))
5841 5841 rev = cmdutil.finddate(ui, repo, date)
5842 5842
5843 5843 if check:
5844 5844 c = repo[None]
5845 5845 if c.dirty(merge=False, branch=False):
5846 5846 raise util.Abort(_("uncommitted local changes"))
5847 5847 if rev is None:
5848 5848 rev = repo[repo[None].branch()].rev()
5849 5849 mergemod._checkunknown(repo, repo[None], repo[rev])
5850 5850
5851 5851 if clean:
5852 5852 ret = hg.clean(repo, rev)
5853 5853 else:
5854 5854 ret = hg.update(repo, rev)
5855 5855
5856 5856 if not ret and movemarkfrom:
5857 5857 if bookmarks.update(repo, [movemarkfrom], repo['.'].node()):
5858 5858 ui.status(_("updating bookmark %s\n") % repo._bookmarkcurrent)
5859 5859 elif brev in repo._bookmarks:
5860 5860 bookmarks.setcurrent(repo, brev)
5861 5861 elif brev:
5862 5862 bookmarks.unsetcurrent(repo)
5863 5863
5864 5864 return ret
5865 5865
5866 5866 @command('verify', [])
5867 5867 def verify(ui, repo):
5868 5868 """verify the integrity of the repository
5869 5869
5870 5870 Verify the integrity of the current repository.
5871 5871
5872 5872 This will perform an extensive check of the repository's
5873 5873 integrity, validating the hashes and checksums of each entry in
5874 5874 the changelog, manifest, and tracked files, as well as the
5875 5875 integrity of their crosslinks and indices.
5876 5876
5877 5877 Returns 0 on success, 1 if errors are encountered.
5878 5878 """
5879 5879 return hg.verify(repo)
5880 5880
5881 5881 @command('version', [])
5882 5882 def version_(ui):
5883 5883 """output version and copyright information"""
5884 5884 ui.write(_("Mercurial Distributed SCM (version %s)\n")
5885 5885 % util.version())
5886 5886 ui.status(_(
5887 5887 "(see http://mercurial.selenic.com for more information)\n"
5888 5888 "\nCopyright (C) 2005-2012 Matt Mackall and others\n"
5889 5889 "This is free software; see the source for copying conditions. "
5890 5890 "There is NO\nwarranty; "
5891 5891 "not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
5892 5892 ))
5893 5893
5894 5894 norepo = ("clone init version help debugcommands debugcomplete"
5895 5895 " debugdate debuginstall debugfsinfo debugpushkey debugwireargs"
5896 5896 " debugknown debuggetbundle debugbundle")
5897 5897 optionalrepo = ("identify paths serve showconfig debugancestor debugdag"
5898 5898 " debugdata debugindex debugindexdot debugrevlog")
@@ -1,479 +1,479 b''
1 1 # dagparser.py - parser and generator for concise description of DAGs
2 2 #
3 3 # Copyright 2010 Peter Arrenbrecht <peter@arrenbrecht.ch>
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 or any later version.
7 7
8 8 import re, string
9 9 import util
10 10 from i18n import _
11 11
12 12 def parsedag(desc):
13 13 '''parses a DAG from a concise textual description; generates events
14 14
15 15 "+n" is a linear run of n nodes based on the current default parent
16 16 "." is a single node based on the current default parent
17 17 "$" resets the default parent to -1 (implied at the start);
18 18 otherwise the default parent is always the last node created
19 19 "<p" sets the default parent to the backref p
20 20 "*p" is a fork at parent p, where p is a backref
21 21 "*p1/p2/.../pn" is a merge of parents p1..pn, where the pi are backrefs
22 22 "/p2/.../pn" is a merge of the preceding node and p2..pn
23 23 ":name" defines a label for the preceding node; labels can be redefined
24 24 "@text" emits an annotation event for text
25 25 "!command" emits an action event for the current node
26 26 "!!my command\n" is like "!", but to the end of the line
27 27 "#...\n" is a comment up to the end of the line
28 28
29 29 Whitespace between the above elements is ignored.
30 30
31 31 A backref is either
32 32 * a number n, which references the node curr-n, where curr is the current
33 33 node, or
34 34 * the name of a label you placed earlier using ":name", or
35 35 * empty to denote the default parent.
36 36
37 37 All string valued-elements are either strictly alphanumeric, or must
38 38 be enclosed in double quotes ("..."), with "\" as escape character.
39 39
40 40 Generates sequence of
41 41
42 42 ('n', (id, [parentids])) for node creation
43 43 ('l', (id, labelname)) for labels on nodes
44 44 ('a', text) for annotations
45 45 ('c', command) for actions (!)
46 46 ('C', command) for line actions (!!)
47 47
48 48 Examples
49 49 --------
50 50
51 51 Example of a complex graph (output not shown for brevity):
52 52
53 53 >>> len(list(parsedag("""
54 54 ...
55 55 ... +3 # 3 nodes in linear run
56 56 ... :forkhere # a label for the last of the 3 nodes from above
57 57 ... +5 # 5 more nodes on one branch
58 58 ... :mergethis # label again
59 ... <forkhere # set default parent to labelled fork node
59 ... <forkhere # set default parent to labeled fork node
60 60 ... +10 # 10 more nodes on a parallel branch
61 61 ... @stable # following nodes will be annotated as "stable"
62 62 ... +5 # 5 nodes in stable
63 63 ... !addfile # custom command; could trigger new file in next node
64 64 ... +2 # two more nodes
65 ... /mergethis # merge last node with labelled node
65 ... /mergethis # merge last node with labeled node
66 66 ... +4 # 4 more nodes descending from merge node
67 67 ...
68 68 ... """)))
69 69 34
70 70
71 71 Empty list:
72 72
73 73 >>> list(parsedag(""))
74 74 []
75 75
76 76 A simple linear run:
77 77
78 78 >>> list(parsedag("+3"))
79 79 [('n', (0, [-1])), ('n', (1, [0])), ('n', (2, [1]))]
80 80
81 81 Some non-standard ways to define such runs:
82 82
83 83 >>> list(parsedag("+1+2"))
84 84 [('n', (0, [-1])), ('n', (1, [0])), ('n', (2, [1]))]
85 85
86 86 >>> list(parsedag("+1*1*"))
87 87 [('n', (0, [-1])), ('n', (1, [0])), ('n', (2, [1]))]
88 88
89 89 >>> list(parsedag("*"))
90 90 [('n', (0, [-1]))]
91 91
92 92 >>> list(parsedag("..."))
93 93 [('n', (0, [-1])), ('n', (1, [0])), ('n', (2, [1]))]
94 94
95 95 A fork and a join, using numeric back references:
96 96
97 97 >>> list(parsedag("+2*2*/2"))
98 98 [('n', (0, [-1])), ('n', (1, [0])), ('n', (2, [0])), ('n', (3, [2, 1]))]
99 99
100 100 >>> list(parsedag("+2<2+1/2"))
101 101 [('n', (0, [-1])), ('n', (1, [0])), ('n', (2, [0])), ('n', (3, [2, 1]))]
102 102
103 103 Placing a label:
104 104
105 105 >>> list(parsedag("+1 :mylabel +1"))
106 106 [('n', (0, [-1])), ('l', (0, 'mylabel')), ('n', (1, [0]))]
107 107
108 108 An empty label (silly, really):
109 109
110 110 >>> list(parsedag("+1:+1"))
111 111 [('n', (0, [-1])), ('l', (0, '')), ('n', (1, [0]))]
112 112
113 113 Fork and join, but with labels instead of numeric back references:
114 114
115 115 >>> list(parsedag("+1:f +1:p2 *f */p2"))
116 116 [('n', (0, [-1])), ('l', (0, 'f')), ('n', (1, [0])), ('l', (1, 'p2')),
117 117 ('n', (2, [0])), ('n', (3, [2, 1]))]
118 118
119 119 >>> list(parsedag("+1:f +1:p2 <f +1 /p2"))
120 120 [('n', (0, [-1])), ('l', (0, 'f')), ('n', (1, [0])), ('l', (1, 'p2')),
121 121 ('n', (2, [0])), ('n', (3, [2, 1]))]
122 122
123 123 Restarting from the root:
124 124
125 125 >>> list(parsedag("+1 $ +1"))
126 126 [('n', (0, [-1])), ('n', (1, [-1]))]
127 127
128 128 Annotations, which are meant to introduce sticky state for subsequent nodes:
129 129
130 130 >>> list(parsedag("+1 @ann +1"))
131 131 [('n', (0, [-1])), ('a', 'ann'), ('n', (1, [0]))]
132 132
133 133 >>> list(parsedag('+1 @"my annotation" +1'))
134 134 [('n', (0, [-1])), ('a', 'my annotation'), ('n', (1, [0]))]
135 135
136 136 Commands, which are meant to operate on the most recently created node:
137 137
138 138 >>> list(parsedag("+1 !cmd +1"))
139 139 [('n', (0, [-1])), ('c', 'cmd'), ('n', (1, [0]))]
140 140
141 141 >>> list(parsedag('+1 !"my command" +1'))
142 142 [('n', (0, [-1])), ('c', 'my command'), ('n', (1, [0]))]
143 143
144 144 >>> list(parsedag('+1 !!my command line\\n +1'))
145 145 [('n', (0, [-1])), ('C', 'my command line'), ('n', (1, [0]))]
146 146
147 147 Comments, which extend to the end of the line:
148 148
149 149 >>> list(parsedag('+1 # comment\\n+1'))
150 150 [('n', (0, [-1])), ('n', (1, [0]))]
151 151
152 152 Error:
153 153
154 154 >>> try: list(parsedag('+1 bad'))
155 155 ... except Exception, e: print e
156 156 invalid character in dag description: bad...
157 157
158 158 '''
159 159 if not desc:
160 160 return
161 161
162 162 wordchars = string.ascii_letters + string.digits
163 163
164 164 labels = {}
165 165 p1 = -1
166 166 r = 0
167 167
168 168 def resolve(ref):
169 169 if not ref:
170 170 return p1
171 171 elif ref[0] in string.digits:
172 172 return r - int(ref)
173 173 else:
174 174 return labels[ref]
175 175
176 176 chiter = (c for c in desc)
177 177
178 178 def nextch():
179 179 try:
180 180 return chiter.next()
181 181 except StopIteration:
182 182 return '\0'
183 183
184 184 def nextrun(c, allow):
185 185 s = ''
186 186 while c in allow:
187 187 s += c
188 188 c = nextch()
189 189 return c, s
190 190
191 191 def nextdelimited(c, limit, escape):
192 192 s = ''
193 193 while c != limit:
194 194 if c == escape:
195 195 c = nextch()
196 196 s += c
197 197 c = nextch()
198 198 return nextch(), s
199 199
200 200 def nextstring(c):
201 201 if c == '"':
202 202 return nextdelimited(nextch(), '"', '\\')
203 203 else:
204 204 return nextrun(c, wordchars)
205 205
206 206 c = nextch()
207 207 while c != '\0':
208 208 while c in string.whitespace:
209 209 c = nextch()
210 210 if c == '.':
211 211 yield 'n', (r, [p1])
212 212 p1 = r
213 213 r += 1
214 214 c = nextch()
215 215 elif c == '+':
216 216 c, digs = nextrun(nextch(), string.digits)
217 217 n = int(digs)
218 218 for i in xrange(0, n):
219 219 yield 'n', (r, [p1])
220 220 p1 = r
221 221 r += 1
222 222 elif c in '*/':
223 223 if c == '*':
224 224 c = nextch()
225 225 c, pref = nextstring(c)
226 226 prefs = [pref]
227 227 while c == '/':
228 228 c, pref = nextstring(nextch())
229 229 prefs.append(pref)
230 230 ps = [resolve(ref) for ref in prefs]
231 231 yield 'n', (r, ps)
232 232 p1 = r
233 233 r += 1
234 234 elif c == '<':
235 235 c, ref = nextstring(nextch())
236 236 p1 = resolve(ref)
237 237 elif c == ':':
238 238 c, name = nextstring(nextch())
239 239 labels[name] = p1
240 240 yield 'l', (p1, name)
241 241 elif c == '@':
242 242 c, text = nextstring(nextch())
243 243 yield 'a', text
244 244 elif c == '!':
245 245 c = nextch()
246 246 if c == '!':
247 247 cmd = ''
248 248 c = nextch()
249 249 while c not in '\n\r\0':
250 250 cmd += c
251 251 c = nextch()
252 252 yield 'C', cmd
253 253 else:
254 254 c, cmd = nextstring(c)
255 255 yield 'c', cmd
256 256 elif c == '#':
257 257 while c not in '\n\r\0':
258 258 c = nextch()
259 259 elif c == '$':
260 260 p1 = -1
261 261 c = nextch()
262 262 elif c == '\0':
263 263 return # in case it was preceded by whitespace
264 264 else:
265 265 s = ''
266 266 i = 0
267 267 while c != '\0' and i < 10:
268 268 s += c
269 269 i += 1
270 270 c = nextch()
271 271 raise util.Abort(_('invalid character in dag description: '
272 272 '%s...') % s)
273 273
274 274 def dagtextlines(events,
275 275 addspaces=True,
276 276 wraplabels=False,
277 277 wrapannotations=False,
278 278 wrapcommands=False,
279 279 wrapnonlinear=False,
280 280 usedots=False,
281 281 maxlinewidth=70):
282 282 '''generates single lines for dagtext()'''
283 283
284 284 def wrapstring(text):
285 285 if re.match("^[0-9a-z]*$", text):
286 286 return text
287 287 return '"' + text.replace('\\', '\\\\').replace('"', '\"') + '"'
288 288
289 289 def gen():
290 290 labels = {}
291 291 run = 0
292 292 wantr = 0
293 293 needroot = False
294 294 for kind, data in events:
295 295 if kind == 'n':
296 296 r, ps = data
297 297
298 298 # sanity check
299 299 if r != wantr:
300 300 raise util.Abort(_("expected id %i, got %i") % (wantr, r))
301 301 if not ps:
302 302 ps = [-1]
303 303 else:
304 304 for p in ps:
305 305 if p >= r:
306 306 raise util.Abort(_("parent id %i is larger than "
307 307 "current id %i") % (p, r))
308 308 wantr += 1
309 309
310 310 # new root?
311 311 p1 = r - 1
312 312 if len(ps) == 1 and ps[0] == -1:
313 313 if needroot:
314 314 if run:
315 315 yield '+' + str(run)
316 316 run = 0
317 317 if wrapnonlinear:
318 318 yield '\n'
319 319 yield '$'
320 320 p1 = -1
321 321 else:
322 322 needroot = True
323 323 if len(ps) == 1 and ps[0] == p1:
324 324 if usedots:
325 325 yield "."
326 326 else:
327 327 run += 1
328 328 else:
329 329 if run:
330 330 yield '+' + str(run)
331 331 run = 0
332 332 if wrapnonlinear:
333 333 yield '\n'
334 334 prefs = []
335 335 for p in ps:
336 336 if p == p1:
337 337 prefs.append('')
338 338 elif p in labels:
339 339 prefs.append(labels[p])
340 340 else:
341 341 prefs.append(str(r - p))
342 342 yield '*' + '/'.join(prefs)
343 343 else:
344 344 if run:
345 345 yield '+' + str(run)
346 346 run = 0
347 347 if kind == 'l':
348 348 rid, name = data
349 349 labels[rid] = name
350 350 yield ':' + name
351 351 if wraplabels:
352 352 yield '\n'
353 353 elif kind == 'c':
354 354 yield '!' + wrapstring(data)
355 355 if wrapcommands:
356 356 yield '\n'
357 357 elif kind == 'C':
358 358 yield '!!' + data
359 359 yield '\n'
360 360 elif kind == 'a':
361 361 if wrapannotations:
362 362 yield '\n'
363 363 yield '@' + wrapstring(data)
364 364 elif kind == '#':
365 365 yield '#' + data
366 366 yield '\n'
367 367 else:
368 368 raise util.Abort(_("invalid event type in dag: %s")
369 369 % str((type, data)))
370 370 if run:
371 371 yield '+' + str(run)
372 372
373 373 line = ''
374 374 for part in gen():
375 375 if part == '\n':
376 376 if line:
377 377 yield line
378 378 line = ''
379 379 else:
380 380 if len(line) + len(part) >= maxlinewidth:
381 381 yield line
382 382 line = ''
383 383 elif addspaces and line and part != '.':
384 384 line += ' '
385 385 line += part
386 386 if line:
387 387 yield line
388 388
389 389 def dagtext(dag,
390 390 addspaces=True,
391 391 wraplabels=False,
392 392 wrapannotations=False,
393 393 wrapcommands=False,
394 394 wrapnonlinear=False,
395 395 usedots=False,
396 396 maxlinewidth=70):
397 397 '''generates lines of a textual representation for a dag event stream
398 398
399 399 events should generate what parsedag() does, so:
400 400
401 401 ('n', (id, [parentids])) for node creation
402 402 ('l', (id, labelname)) for labels on nodes
403 403 ('a', text) for annotations
404 404 ('c', text) for commands
405 405 ('C', text) for line commands ('!!')
406 406 ('#', text) for comment lines
407 407
408 408 Parent nodes must come before child nodes.
409 409
410 410 Examples
411 411 --------
412 412
413 413 Linear run:
414 414
415 415 >>> dagtext([('n', (0, [-1])), ('n', (1, [0]))])
416 416 '+2'
417 417
418 418 Two roots:
419 419
420 420 >>> dagtext([('n', (0, [-1])), ('n', (1, [-1]))])
421 421 '+1 $ +1'
422 422
423 423 Fork and join:
424 424
425 425 >>> dagtext([('n', (0, [-1])), ('n', (1, [0])), ('n', (2, [0])),
426 426 ... ('n', (3, [2, 1]))])
427 427 '+2 *2 */2'
428 428
429 429 Fork and join with labels:
430 430
431 431 >>> dagtext([('n', (0, [-1])), ('l', (0, 'f')), ('n', (1, [0])),
432 432 ... ('l', (1, 'p2')), ('n', (2, [0])), ('n', (3, [2, 1]))])
433 433 '+1 :f +1 :p2 *f */p2'
434 434
435 435 Annotations:
436 436
437 437 >>> dagtext([('n', (0, [-1])), ('a', 'ann'), ('n', (1, [0]))])
438 438 '+1 @ann +1'
439 439
440 440 >>> dagtext([('n', (0, [-1])),
441 441 ... ('a', 'my annotation'),
442 442 ... ('n', (1, [0]))])
443 443 '+1 @"my annotation" +1'
444 444
445 445 Commands:
446 446
447 447 >>> dagtext([('n', (0, [-1])), ('c', 'cmd'), ('n', (1, [0]))])
448 448 '+1 !cmd +1'
449 449
450 450 >>> dagtext([('n', (0, [-1])), ('c', 'my command'), ('n', (1, [0]))])
451 451 '+1 !"my command" +1'
452 452
453 453 >>> dagtext([('n', (0, [-1])),
454 454 ... ('C', 'my command line'),
455 455 ... ('n', (1, [0]))])
456 456 '+1 !!my command line\\n+1'
457 457
458 458 Comments:
459 459
460 460 >>> dagtext([('n', (0, [-1])), ('#', ' comment'), ('n', (1, [0]))])
461 461 '+1 # comment\\n+1'
462 462
463 463 >>> dagtext([])
464 464 ''
465 465
466 466 Combining parsedag and dagtext:
467 467
468 468 >>> dagtext(parsedag('+1 :f +1 :p2 *f */p2'))
469 469 '+1 :f +1 :p2 *f */p2'
470 470
471 471 '''
472 472 return "\n".join(dagtextlines(dag,
473 473 addspaces,
474 474 wraplabels,
475 475 wrapannotations,
476 476 wrapcommands,
477 477 wrapnonlinear,
478 478 usedots,
479 479 maxlinewidth))
@@ -1,95 +1,95 b''
1 1 # parser.py - simple top-down operator precedence parser for mercurial
2 2 #
3 3 # Copyright 2010 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 or any later version.
7 7
8 8 # see http://effbot.org/zone/simple-top-down-parsing.htm and
9 9 # http://eli.thegreenplace.net/2010/01/02/top-down-operator-precedence-parsing/
10 10 # for background
11 11
12 12 # takes a tokenizer and elements
13 13 # tokenizer is an iterator that returns type, value pairs
14 14 # elements is a mapping of types to binding strength, prefix and infix actions
15 15 # an action is a tree node name, a tree label, and an optional match
16 # __call__(program) parses program into a labelled tree
16 # __call__(program) parses program into a labeled tree
17 17
18 18 import error
19 19 from i18n import _
20 20
21 21 class parser(object):
22 22 def __init__(self, tokenizer, elements, methods=None):
23 23 self._tokenizer = tokenizer
24 24 self._elements = elements
25 25 self._methods = methods
26 26 self.current = None
27 27 def _advance(self):
28 28 'advance the tokenizer'
29 29 t = self.current
30 30 try:
31 31 self.current = self._iter.next()
32 32 except StopIteration:
33 33 pass
34 34 return t
35 35 def _match(self, m, pos):
36 36 'make sure the tokenizer matches an end condition'
37 37 if self.current[0] != m:
38 38 raise error.ParseError(_("unexpected token: %s") % self.current[0],
39 39 self.current[2])
40 40 self._advance()
41 41 def _parse(self, bind=0):
42 42 token, value, pos = self._advance()
43 43 # handle prefix rules on current token
44 44 prefix = self._elements[token][1]
45 45 if not prefix:
46 46 raise error.ParseError(_("not a prefix: %s") % token, pos)
47 47 if len(prefix) == 1:
48 48 expr = (prefix[0], value)
49 49 else:
50 50 if len(prefix) > 2 and prefix[2] == self.current[0]:
51 51 self._match(prefix[2], pos)
52 52 expr = (prefix[0], None)
53 53 else:
54 54 expr = (prefix[0], self._parse(prefix[1]))
55 55 if len(prefix) > 2:
56 56 self._match(prefix[2], pos)
57 57 # gather tokens until we meet a lower binding strength
58 58 while bind < self._elements[self.current[0]][0]:
59 59 token, value, pos = self._advance()
60 60 e = self._elements[token]
61 61 # check for suffix - next token isn't a valid prefix
62 62 if len(e) == 4 and not self._elements[self.current[0]][1]:
63 63 suffix = e[3]
64 64 expr = (suffix[0], expr)
65 65 else:
66 66 # handle infix rules
67 67 if len(e) < 3 or not e[2]:
68 68 raise error.ParseError(_("not an infix: %s") % token, pos)
69 69 infix = e[2]
70 70 if len(infix) == 3 and infix[2] == self.current[0]:
71 71 self._match(infix[2], pos)
72 72 expr = (infix[0], expr, (None))
73 73 else:
74 74 expr = (infix[0], expr, self._parse(infix[1]))
75 75 if len(infix) == 3:
76 76 self._match(infix[2], pos)
77 77 return expr
78 78 def parse(self, message):
79 79 'generate a parse tree from a message'
80 80 self._iter = self._tokenizer(message)
81 81 self._advance()
82 82 res = self._parse()
83 83 token, value, pos = self.current
84 84 return res, pos
85 85 def eval(self, tree):
86 86 'recursively evaluate a parse tree using node methods'
87 87 if not isinstance(tree, tuple):
88 88 return tree
89 89 return self._methods[tree[0]](*[self.eval(t) for t in tree[1:]])
90 90 def __call__(self, message):
91 91 'parse a message into a parse tree and evaluate if methods given'
92 92 t = self.parse(message)
93 93 if self._methods:
94 94 return self.eval(t)
95 95 return t
General Comments 0
You need to be logged in to leave comments. Login now