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