##// END OF EJS Templates
merge: respect bookmarks during merge...
David Soria Parra -
r16708:4a02cf4f default
parent child Browse files
Show More
@@ -1,5772 +1,5799 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)
1691 1691 if p != -1)))
1692 1692 if r in revs:
1693 1693 yield 'l', (r, "r%i" % r)
1694 1694 elif repo:
1695 1695 cl = repo.changelog
1696 1696 tags = opts.get('tags')
1697 1697 branches = opts.get('branches')
1698 1698 if tags:
1699 1699 labels = {}
1700 1700 for l, n in repo.tags().items():
1701 1701 labels.setdefault(cl.rev(n), []).append(l)
1702 1702 def events():
1703 1703 b = "default"
1704 1704 for r in cl:
1705 1705 if branches:
1706 1706 newb = cl.read(cl.node(r))[5]['branch']
1707 1707 if newb != b:
1708 1708 yield 'a', newb
1709 1709 b = newb
1710 1710 yield 'n', (r, list(set(p for p in cl.parentrevs(r)
1711 1711 if p != -1)))
1712 1712 if tags:
1713 1713 ls = labels.get(r)
1714 1714 if ls:
1715 1715 for l in ls:
1716 1716 yield 'l', (r, l)
1717 1717 else:
1718 1718 raise util.Abort(_('need repo for changelog dag'))
1719 1719
1720 1720 for line in dagparser.dagtextlines(events(),
1721 1721 addspaces=spaces,
1722 1722 wraplabels=True,
1723 1723 wrapannotations=True,
1724 1724 wrapnonlinear=dots,
1725 1725 usedots=dots,
1726 1726 maxlinewidth=70):
1727 1727 ui.write(line)
1728 1728 ui.write("\n")
1729 1729
1730 1730 @command('debugdata',
1731 1731 [('c', 'changelog', False, _('open changelog')),
1732 1732 ('m', 'manifest', False, _('open manifest'))],
1733 1733 _('-c|-m|FILE REV'))
1734 1734 def debugdata(ui, repo, file_, rev = None, **opts):
1735 1735 """dump the contents of a data file revision"""
1736 1736 if opts.get('changelog') or opts.get('manifest'):
1737 1737 file_, rev = None, file_
1738 1738 elif rev is None:
1739 1739 raise error.CommandError('debugdata', _('invalid arguments'))
1740 1740 r = cmdutil.openrevlog(repo, 'debugdata', file_, opts)
1741 1741 try:
1742 1742 ui.write(r.revision(r.lookup(rev)))
1743 1743 except KeyError:
1744 1744 raise util.Abort(_('invalid revision identifier %s') % rev)
1745 1745
1746 1746 @command('debugdate',
1747 1747 [('e', 'extended', None, _('try extended date formats'))],
1748 1748 _('[-e] DATE [RANGE]'))
1749 1749 def debugdate(ui, date, range=None, **opts):
1750 1750 """parse and display a date"""
1751 1751 if opts["extended"]:
1752 1752 d = util.parsedate(date, util.extendeddateformats)
1753 1753 else:
1754 1754 d = util.parsedate(date)
1755 1755 ui.write("internal: %s %s\n" % d)
1756 1756 ui.write("standard: %s\n" % util.datestr(d))
1757 1757 if range:
1758 1758 m = util.matchdate(range)
1759 1759 ui.write("match: %s\n" % m(d[0]))
1760 1760
1761 1761 @command('debugdiscovery',
1762 1762 [('', 'old', None, _('use old-style discovery')),
1763 1763 ('', 'nonheads', None,
1764 1764 _('use old-style discovery with non-heads included')),
1765 1765 ] + remoteopts,
1766 1766 _('[-l REV] [-r REV] [-b BRANCH]... [OTHER]'))
1767 1767 def debugdiscovery(ui, repo, remoteurl="default", **opts):
1768 1768 """runs the changeset discovery protocol in isolation"""
1769 1769 remoteurl, branches = hg.parseurl(ui.expandpath(remoteurl),
1770 1770 opts.get('branch'))
1771 1771 remote = hg.peer(repo, opts, remoteurl)
1772 1772 ui.status(_('comparing with %s\n') % util.hidepassword(remoteurl))
1773 1773
1774 1774 # make sure tests are repeatable
1775 1775 random.seed(12323)
1776 1776
1777 1777 def doit(localheads, remoteheads):
1778 1778 if opts.get('old'):
1779 1779 if localheads:
1780 1780 raise util.Abort('cannot use localheads with old style '
1781 1781 'discovery')
1782 1782 common, _in, hds = treediscovery.findcommonincoming(repo, remote,
1783 1783 force=True)
1784 1784 common = set(common)
1785 1785 if not opts.get('nonheads'):
1786 1786 ui.write("unpruned common: %s\n" % " ".join([short(n)
1787 1787 for n in common]))
1788 1788 dag = dagutil.revlogdag(repo.changelog)
1789 1789 all = dag.ancestorset(dag.internalizeall(common))
1790 1790 common = dag.externalizeall(dag.headsetofconnecteds(all))
1791 1791 else:
1792 1792 common, any, hds = setdiscovery.findcommonheads(ui, repo, remote)
1793 1793 common = set(common)
1794 1794 rheads = set(hds)
1795 1795 lheads = set(repo.heads())
1796 1796 ui.write("common heads: %s\n" % " ".join([short(n) for n in common]))
1797 1797 if lheads <= common:
1798 1798 ui.write("local is subset\n")
1799 1799 elif rheads <= common:
1800 1800 ui.write("remote is subset\n")
1801 1801
1802 1802 serverlogs = opts.get('serverlog')
1803 1803 if serverlogs:
1804 1804 for filename in serverlogs:
1805 1805 logfile = open(filename, 'r')
1806 1806 try:
1807 1807 line = logfile.readline()
1808 1808 while line:
1809 1809 parts = line.strip().split(';')
1810 1810 op = parts[1]
1811 1811 if op == 'cg':
1812 1812 pass
1813 1813 elif op == 'cgss':
1814 1814 doit(parts[2].split(' '), parts[3].split(' '))
1815 1815 elif op == 'unb':
1816 1816 doit(parts[3].split(' '), parts[2].split(' '))
1817 1817 line = logfile.readline()
1818 1818 finally:
1819 1819 logfile.close()
1820 1820
1821 1821 else:
1822 1822 remoterevs, _checkout = hg.addbranchrevs(repo, remote, branches,
1823 1823 opts.get('remote_head'))
1824 1824 localrevs = opts.get('local_head')
1825 1825 doit(localrevs, remoterevs)
1826 1826
1827 1827 @command('debugfileset', [], ('REVSPEC'))
1828 1828 def debugfileset(ui, repo, expr):
1829 1829 '''parse and apply a fileset specification'''
1830 1830 if ui.verbose:
1831 1831 tree = fileset.parse(expr)[0]
1832 1832 ui.note(tree, "\n")
1833 1833
1834 1834 for f in fileset.getfileset(repo[None], expr):
1835 1835 ui.write("%s\n" % f)
1836 1836
1837 1837 @command('debugfsinfo', [], _('[PATH]'))
1838 1838 def debugfsinfo(ui, path = "."):
1839 1839 """show information detected about current filesystem"""
1840 1840 util.writefile('.debugfsinfo', '')
1841 1841 ui.write('exec: %s\n' % (util.checkexec(path) and 'yes' or 'no'))
1842 1842 ui.write('symlink: %s\n' % (util.checklink(path) and 'yes' or 'no'))
1843 1843 ui.write('case-sensitive: %s\n' % (util.checkcase('.debugfsinfo')
1844 1844 and 'yes' or 'no'))
1845 1845 os.unlink('.debugfsinfo')
1846 1846
1847 1847 @command('debuggetbundle',
1848 1848 [('H', 'head', [], _('id of head node'), _('ID')),
1849 1849 ('C', 'common', [], _('id of common node'), _('ID')),
1850 1850 ('t', 'type', 'bzip2', _('bundle compression type to use'), _('TYPE'))],
1851 1851 _('REPO FILE [-H|-C ID]...'))
1852 1852 def debuggetbundle(ui, repopath, bundlepath, head=None, common=None, **opts):
1853 1853 """retrieves a bundle from a repo
1854 1854
1855 1855 Every ID must be a full-length hex node id string. Saves the bundle to the
1856 1856 given file.
1857 1857 """
1858 1858 repo = hg.peer(ui, opts, repopath)
1859 1859 if not repo.capable('getbundle'):
1860 1860 raise util.Abort("getbundle() not supported by target repository")
1861 1861 args = {}
1862 1862 if common:
1863 1863 args['common'] = [bin(s) for s in common]
1864 1864 if head:
1865 1865 args['heads'] = [bin(s) for s in head]
1866 1866 bundle = repo.getbundle('debug', **args)
1867 1867
1868 1868 bundletype = opts.get('type', 'bzip2').lower()
1869 1869 btypes = {'none': 'HG10UN', 'bzip2': 'HG10BZ', 'gzip': 'HG10GZ'}
1870 1870 bundletype = btypes.get(bundletype)
1871 1871 if bundletype not in changegroup.bundletypes:
1872 1872 raise util.Abort(_('unknown bundle type specified with --type'))
1873 1873 changegroup.writebundle(bundle, bundlepath, bundletype)
1874 1874
1875 1875 @command('debugignore', [], '')
1876 1876 def debugignore(ui, repo, *values, **opts):
1877 1877 """display the combined ignore pattern"""
1878 1878 ignore = repo.dirstate._ignore
1879 1879 includepat = getattr(ignore, 'includepat', None)
1880 1880 if includepat is not None:
1881 1881 ui.write("%s\n" % includepat)
1882 1882 else:
1883 1883 raise util.Abort(_("no ignore patterns found"))
1884 1884
1885 1885 @command('debugindex',
1886 1886 [('c', 'changelog', False, _('open changelog')),
1887 1887 ('m', 'manifest', False, _('open manifest')),
1888 1888 ('f', 'format', 0, _('revlog format'), _('FORMAT'))],
1889 1889 _('[-f FORMAT] -c|-m|FILE'))
1890 1890 def debugindex(ui, repo, file_ = None, **opts):
1891 1891 """dump the contents of an index file"""
1892 1892 r = cmdutil.openrevlog(repo, 'debugindex', file_, opts)
1893 1893 format = opts.get('format', 0)
1894 1894 if format not in (0, 1):
1895 1895 raise util.Abort(_("unknown format %d") % format)
1896 1896
1897 1897 generaldelta = r.version & revlog.REVLOGGENERALDELTA
1898 1898 if generaldelta:
1899 1899 basehdr = ' delta'
1900 1900 else:
1901 1901 basehdr = ' base'
1902 1902
1903 1903 if format == 0:
1904 1904 ui.write(" rev offset length " + basehdr + " linkrev"
1905 1905 " nodeid p1 p2\n")
1906 1906 elif format == 1:
1907 1907 ui.write(" rev flag offset length"
1908 1908 " size " + basehdr + " link p1 p2"
1909 1909 " nodeid\n")
1910 1910
1911 1911 for i in r:
1912 1912 node = r.node(i)
1913 1913 if generaldelta:
1914 1914 base = r.deltaparent(i)
1915 1915 else:
1916 1916 base = r.chainbase(i)
1917 1917 if format == 0:
1918 1918 try:
1919 1919 pp = r.parents(node)
1920 1920 except Exception:
1921 1921 pp = [nullid, nullid]
1922 1922 ui.write("% 6d % 9d % 7d % 6d % 7d %s %s %s\n" % (
1923 1923 i, r.start(i), r.length(i), base, r.linkrev(i),
1924 1924 short(node), short(pp[0]), short(pp[1])))
1925 1925 elif format == 1:
1926 1926 pr = r.parentrevs(i)
1927 1927 ui.write("% 6d %04x % 8d % 8d % 8d % 6d % 6d % 6d % 6d %s\n" % (
1928 1928 i, r.flags(i), r.start(i), r.length(i), r.rawsize(i),
1929 1929 base, r.linkrev(i), pr[0], pr[1], short(node)))
1930 1930
1931 1931 @command('debugindexdot', [], _('FILE'))
1932 1932 def debugindexdot(ui, repo, file_):
1933 1933 """dump an index DAG as a graphviz dot file"""
1934 1934 r = None
1935 1935 if repo:
1936 1936 filelog = repo.file(file_)
1937 1937 if len(filelog):
1938 1938 r = filelog
1939 1939 if not r:
1940 1940 r = revlog.revlog(scmutil.opener(os.getcwd(), audit=False), file_)
1941 1941 ui.write("digraph G {\n")
1942 1942 for i in r:
1943 1943 node = r.node(i)
1944 1944 pp = r.parents(node)
1945 1945 ui.write("\t%d -> %d\n" % (r.rev(pp[0]), i))
1946 1946 if pp[1] != nullid:
1947 1947 ui.write("\t%d -> %d\n" % (r.rev(pp[1]), i))
1948 1948 ui.write("}\n")
1949 1949
1950 1950 @command('debuginstall', [], '')
1951 1951 def debuginstall(ui):
1952 1952 '''test Mercurial installation
1953 1953
1954 1954 Returns 0 on success.
1955 1955 '''
1956 1956
1957 1957 def writetemp(contents):
1958 1958 (fd, name) = tempfile.mkstemp(prefix="hg-debuginstall-")
1959 1959 f = os.fdopen(fd, "wb")
1960 1960 f.write(contents)
1961 1961 f.close()
1962 1962 return name
1963 1963
1964 1964 problems = 0
1965 1965
1966 1966 # encoding
1967 1967 ui.status(_("Checking encoding (%s)...\n") % encoding.encoding)
1968 1968 try:
1969 1969 encoding.fromlocal("test")
1970 1970 except util.Abort, inst:
1971 1971 ui.write(" %s\n" % inst)
1972 1972 ui.write(_(" (check that your locale is properly set)\n"))
1973 1973 problems += 1
1974 1974
1975 1975 # compiled modules
1976 1976 ui.status(_("Checking installed modules (%s)...\n")
1977 1977 % os.path.dirname(__file__))
1978 1978 try:
1979 1979 import bdiff, mpatch, base85, osutil
1980 1980 dir(bdiff), dir(mpatch), dir(base85), dir(osutil) # quiet pyflakes
1981 1981 except Exception, inst:
1982 1982 ui.write(" %s\n" % inst)
1983 1983 ui.write(_(" One or more extensions could not be found"))
1984 1984 ui.write(_(" (check that you compiled the extensions)\n"))
1985 1985 problems += 1
1986 1986
1987 1987 # templates
1988 1988 import templater
1989 1989 p = templater.templatepath()
1990 1990 ui.status(_("Checking templates (%s)...\n") % ' '.join(p))
1991 1991 try:
1992 1992 templater.templater(templater.templatepath("map-cmdline.default"))
1993 1993 except Exception, inst:
1994 1994 ui.write(" %s\n" % inst)
1995 1995 ui.write(_(" (templates seem to have been installed incorrectly)\n"))
1996 1996 problems += 1
1997 1997
1998 1998 # editor
1999 1999 ui.status(_("Checking commit editor...\n"))
2000 2000 editor = ui.geteditor()
2001 2001 cmdpath = util.findexe(editor) or util.findexe(editor.split()[0])
2002 2002 if not cmdpath:
2003 2003 if editor == 'vi':
2004 2004 ui.write(_(" No commit editor set and can't find vi in PATH\n"))
2005 2005 ui.write(_(" (specify a commit editor in your configuration"
2006 2006 " file)\n"))
2007 2007 else:
2008 2008 ui.write(_(" Can't find editor '%s' in PATH\n") % editor)
2009 2009 ui.write(_(" (specify a commit editor in your configuration"
2010 2010 " file)\n"))
2011 2011 problems += 1
2012 2012
2013 2013 # check username
2014 2014 ui.status(_("Checking username...\n"))
2015 2015 try:
2016 2016 ui.username()
2017 2017 except util.Abort, e:
2018 2018 ui.write(" %s\n" % e)
2019 2019 ui.write(_(" (specify a username in your configuration file)\n"))
2020 2020 problems += 1
2021 2021
2022 2022 if not problems:
2023 2023 ui.status(_("No problems detected\n"))
2024 2024 else:
2025 2025 ui.write(_("%s problems detected,"
2026 2026 " please check your install!\n") % problems)
2027 2027
2028 2028 return problems
2029 2029
2030 2030 @command('debugknown', [], _('REPO ID...'))
2031 2031 def debugknown(ui, repopath, *ids, **opts):
2032 2032 """test whether node ids are known to a repo
2033 2033
2034 2034 Every ID must be a full-length hex node id string. Returns a list of 0s
2035 2035 and 1s indicating unknown/known.
2036 2036 """
2037 2037 repo = hg.peer(ui, opts, repopath)
2038 2038 if not repo.capable('known'):
2039 2039 raise util.Abort("known() not supported by target repository")
2040 2040 flags = repo.known([bin(s) for s in ids])
2041 2041 ui.write("%s\n" % ("".join([f and "1" or "0" for f in flags])))
2042 2042
2043 2043 @command('debugpushkey', [], _('REPO NAMESPACE [KEY OLD NEW]'))
2044 2044 def debugpushkey(ui, repopath, namespace, *keyinfo, **opts):
2045 2045 '''access the pushkey key/value protocol
2046 2046
2047 2047 With two args, list the keys in the given namespace.
2048 2048
2049 2049 With five args, set a key to new if it currently is set to old.
2050 2050 Reports success or failure.
2051 2051 '''
2052 2052
2053 2053 target = hg.peer(ui, {}, repopath)
2054 2054 if keyinfo:
2055 2055 key, old, new = keyinfo
2056 2056 r = target.pushkey(namespace, key, old, new)
2057 2057 ui.status(str(r) + '\n')
2058 2058 return not r
2059 2059 else:
2060 2060 for k, v in target.listkeys(namespace).iteritems():
2061 2061 ui.write("%s\t%s\n" % (k.encode('string-escape'),
2062 2062 v.encode('string-escape')))
2063 2063
2064 2064 @command('debugpvec', [], _('A B'))
2065 2065 def debugpvec(ui, repo, a, b=None):
2066 2066 ca = scmutil.revsingle(repo, a)
2067 2067 cb = scmutil.revsingle(repo, b)
2068 2068 pa = pvec.ctxpvec(ca)
2069 2069 pb = pvec.ctxpvec(cb)
2070 2070 if pa == pb:
2071 2071 rel = "="
2072 2072 elif pa > pb:
2073 2073 rel = ">"
2074 2074 elif pa < pb:
2075 2075 rel = "<"
2076 2076 elif pa | pb:
2077 2077 rel = "|"
2078 2078 ui.write(_("a: %s\n") % pa)
2079 2079 ui.write(_("b: %s\n") % pb)
2080 2080 ui.write(_("depth(a): %d depth(b): %d\n") % (pa._depth, pb._depth))
2081 2081 ui.write(_("delta: %d hdist: %d distance: %d relation: %s\n") %
2082 2082 (abs(pa._depth - pb._depth), pvec._hamming(pa._vec, pb._vec),
2083 2083 pa.distance(pb), rel))
2084 2084
2085 2085 @command('debugrebuildstate',
2086 2086 [('r', 'rev', '', _('revision to rebuild to'), _('REV'))],
2087 2087 _('[-r REV] [REV]'))
2088 2088 def debugrebuildstate(ui, repo, rev="tip"):
2089 2089 """rebuild the dirstate as it would look like for the given revision"""
2090 2090 ctx = scmutil.revsingle(repo, rev)
2091 2091 wlock = repo.wlock()
2092 2092 try:
2093 2093 repo.dirstate.rebuild(ctx.node(), ctx.manifest())
2094 2094 finally:
2095 2095 wlock.release()
2096 2096
2097 2097 @command('debugrename',
2098 2098 [('r', 'rev', '', _('revision to debug'), _('REV'))],
2099 2099 _('[-r REV] FILE'))
2100 2100 def debugrename(ui, repo, file1, *pats, **opts):
2101 2101 """dump rename information"""
2102 2102
2103 2103 ctx = scmutil.revsingle(repo, opts.get('rev'))
2104 2104 m = scmutil.match(ctx, (file1,) + pats, opts)
2105 2105 for abs in ctx.walk(m):
2106 2106 fctx = ctx[abs]
2107 2107 o = fctx.filelog().renamed(fctx.filenode())
2108 2108 rel = m.rel(abs)
2109 2109 if o:
2110 2110 ui.write(_("%s renamed from %s:%s\n") % (rel, o[0], hex(o[1])))
2111 2111 else:
2112 2112 ui.write(_("%s not renamed\n") % rel)
2113 2113
2114 2114 @command('debugrevlog',
2115 2115 [('c', 'changelog', False, _('open changelog')),
2116 2116 ('m', 'manifest', False, _('open manifest')),
2117 2117 ('d', 'dump', False, _('dump index data'))],
2118 2118 _('-c|-m|FILE'))
2119 2119 def debugrevlog(ui, repo, file_ = None, **opts):
2120 2120 """show data and statistics about a revlog"""
2121 2121 r = cmdutil.openrevlog(repo, 'debugrevlog', file_, opts)
2122 2122
2123 2123 if opts.get("dump"):
2124 2124 numrevs = len(r)
2125 2125 ui.write("# rev p1rev p2rev start end deltastart base p1 p2"
2126 2126 " rawsize totalsize compression heads\n")
2127 2127 ts = 0
2128 2128 heads = set()
2129 2129 for rev in xrange(numrevs):
2130 2130 dbase = r.deltaparent(rev)
2131 2131 if dbase == -1:
2132 2132 dbase = rev
2133 2133 cbase = r.chainbase(rev)
2134 2134 p1, p2 = r.parentrevs(rev)
2135 2135 rs = r.rawsize(rev)
2136 2136 ts = ts + rs
2137 2137 heads -= set(r.parentrevs(rev))
2138 2138 heads.add(rev)
2139 2139 ui.write("%d %d %d %d %d %d %d %d %d %d %d %d %d\n" %
2140 2140 (rev, p1, p2, r.start(rev), r.end(rev),
2141 2141 r.start(dbase), r.start(cbase),
2142 2142 r.start(p1), r.start(p2),
2143 2143 rs, ts, ts / r.end(rev), len(heads)))
2144 2144 return 0
2145 2145
2146 2146 v = r.version
2147 2147 format = v & 0xFFFF
2148 2148 flags = []
2149 2149 gdelta = False
2150 2150 if v & revlog.REVLOGNGINLINEDATA:
2151 2151 flags.append('inline')
2152 2152 if v & revlog.REVLOGGENERALDELTA:
2153 2153 gdelta = True
2154 2154 flags.append('generaldelta')
2155 2155 if not flags:
2156 2156 flags = ['(none)']
2157 2157
2158 2158 nummerges = 0
2159 2159 numfull = 0
2160 2160 numprev = 0
2161 2161 nump1 = 0
2162 2162 nump2 = 0
2163 2163 numother = 0
2164 2164 nump1prev = 0
2165 2165 nump2prev = 0
2166 2166 chainlengths = []
2167 2167
2168 2168 datasize = [None, 0, 0L]
2169 2169 fullsize = [None, 0, 0L]
2170 2170 deltasize = [None, 0, 0L]
2171 2171
2172 2172 def addsize(size, l):
2173 2173 if l[0] is None or size < l[0]:
2174 2174 l[0] = size
2175 2175 if size > l[1]:
2176 2176 l[1] = size
2177 2177 l[2] += size
2178 2178
2179 2179 numrevs = len(r)
2180 2180 for rev in xrange(numrevs):
2181 2181 p1, p2 = r.parentrevs(rev)
2182 2182 delta = r.deltaparent(rev)
2183 2183 if format > 0:
2184 2184 addsize(r.rawsize(rev), datasize)
2185 2185 if p2 != nullrev:
2186 2186 nummerges += 1
2187 2187 size = r.length(rev)
2188 2188 if delta == nullrev:
2189 2189 chainlengths.append(0)
2190 2190 numfull += 1
2191 2191 addsize(size, fullsize)
2192 2192 else:
2193 2193 chainlengths.append(chainlengths[delta] + 1)
2194 2194 addsize(size, deltasize)
2195 2195 if delta == rev - 1:
2196 2196 numprev += 1
2197 2197 if delta == p1:
2198 2198 nump1prev += 1
2199 2199 elif delta == p2:
2200 2200 nump2prev += 1
2201 2201 elif delta == p1:
2202 2202 nump1 += 1
2203 2203 elif delta == p2:
2204 2204 nump2 += 1
2205 2205 elif delta != nullrev:
2206 2206 numother += 1
2207 2207
2208 2208 numdeltas = numrevs - numfull
2209 2209 numoprev = numprev - nump1prev - nump2prev
2210 2210 totalrawsize = datasize[2]
2211 2211 datasize[2] /= numrevs
2212 2212 fulltotal = fullsize[2]
2213 2213 fullsize[2] /= numfull
2214 2214 deltatotal = deltasize[2]
2215 2215 deltasize[2] /= numrevs - numfull
2216 2216 totalsize = fulltotal + deltatotal
2217 2217 avgchainlen = sum(chainlengths) / numrevs
2218 2218 compratio = totalrawsize / totalsize
2219 2219
2220 2220 basedfmtstr = '%%%dd\n'
2221 2221 basepcfmtstr = '%%%dd %s(%%5.2f%%%%)\n'
2222 2222
2223 2223 def dfmtstr(max):
2224 2224 return basedfmtstr % len(str(max))
2225 2225 def pcfmtstr(max, padding=0):
2226 2226 return basepcfmtstr % (len(str(max)), ' ' * padding)
2227 2227
2228 2228 def pcfmt(value, total):
2229 2229 return (value, 100 * float(value) / total)
2230 2230
2231 2231 ui.write('format : %d\n' % format)
2232 2232 ui.write('flags : %s\n' % ', '.join(flags))
2233 2233
2234 2234 ui.write('\n')
2235 2235 fmt = pcfmtstr(totalsize)
2236 2236 fmt2 = dfmtstr(totalsize)
2237 2237 ui.write('revisions : ' + fmt2 % numrevs)
2238 2238 ui.write(' merges : ' + fmt % pcfmt(nummerges, numrevs))
2239 2239 ui.write(' normal : ' + fmt % pcfmt(numrevs - nummerges, numrevs))
2240 2240 ui.write('revisions : ' + fmt2 % numrevs)
2241 2241 ui.write(' full : ' + fmt % pcfmt(numfull, numrevs))
2242 2242 ui.write(' deltas : ' + fmt % pcfmt(numdeltas, numrevs))
2243 2243 ui.write('revision size : ' + fmt2 % totalsize)
2244 2244 ui.write(' full : ' + fmt % pcfmt(fulltotal, totalsize))
2245 2245 ui.write(' deltas : ' + fmt % pcfmt(deltatotal, totalsize))
2246 2246
2247 2247 ui.write('\n')
2248 2248 fmt = dfmtstr(max(avgchainlen, compratio))
2249 2249 ui.write('avg chain length : ' + fmt % avgchainlen)
2250 2250 ui.write('compression ratio : ' + fmt % compratio)
2251 2251
2252 2252 if format > 0:
2253 2253 ui.write('\n')
2254 2254 ui.write('uncompressed data size (min/max/avg) : %d / %d / %d\n'
2255 2255 % tuple(datasize))
2256 2256 ui.write('full revision size (min/max/avg) : %d / %d / %d\n'
2257 2257 % tuple(fullsize))
2258 2258 ui.write('delta size (min/max/avg) : %d / %d / %d\n'
2259 2259 % tuple(deltasize))
2260 2260
2261 2261 if numdeltas > 0:
2262 2262 ui.write('\n')
2263 2263 fmt = pcfmtstr(numdeltas)
2264 2264 fmt2 = pcfmtstr(numdeltas, 4)
2265 2265 ui.write('deltas against prev : ' + fmt % pcfmt(numprev, numdeltas))
2266 2266 if numprev > 0:
2267 2267 ui.write(' where prev = p1 : ' + fmt2 % pcfmt(nump1prev,
2268 2268 numprev))
2269 2269 ui.write(' where prev = p2 : ' + fmt2 % pcfmt(nump2prev,
2270 2270 numprev))
2271 2271 ui.write(' other : ' + fmt2 % pcfmt(numoprev,
2272 2272 numprev))
2273 2273 if gdelta:
2274 2274 ui.write('deltas against p1 : ' + fmt % pcfmt(nump1, numdeltas))
2275 2275 ui.write('deltas against p2 : ' + fmt % pcfmt(nump2, numdeltas))
2276 2276 ui.write('deltas against other : ' + fmt % pcfmt(numother,
2277 2277 numdeltas))
2278 2278
2279 2279 @command('debugrevspec', [], ('REVSPEC'))
2280 2280 def debugrevspec(ui, repo, expr):
2281 2281 """parse and apply a revision specification
2282 2282
2283 2283 Use --verbose to print the parsed tree before and after aliases
2284 2284 expansion.
2285 2285 """
2286 2286 if ui.verbose:
2287 2287 tree = revset.parse(expr)[0]
2288 2288 ui.note(revset.prettyformat(tree), "\n")
2289 2289 newtree = revset.findaliases(ui, tree)
2290 2290 if newtree != tree:
2291 2291 ui.note(revset.prettyformat(newtree), "\n")
2292 2292 func = revset.match(ui, expr)
2293 2293 for c in func(repo, range(len(repo))):
2294 2294 ui.write("%s\n" % c)
2295 2295
2296 2296 @command('debugsetparents', [], _('REV1 [REV2]'))
2297 2297 def debugsetparents(ui, repo, rev1, rev2=None):
2298 2298 """manually set the parents of the current working directory
2299 2299
2300 2300 This is useful for writing repository conversion tools, but should
2301 2301 be used with care.
2302 2302
2303 2303 Returns 0 on success.
2304 2304 """
2305 2305
2306 2306 r1 = scmutil.revsingle(repo, rev1).node()
2307 2307 r2 = scmutil.revsingle(repo, rev2, 'null').node()
2308 2308
2309 2309 wlock = repo.wlock()
2310 2310 try:
2311 2311 repo.setparents(r1, r2)
2312 2312 finally:
2313 2313 wlock.release()
2314 2314
2315 2315 @command('debugstate',
2316 2316 [('', 'nodates', None, _('do not display the saved mtime')),
2317 2317 ('', 'datesort', None, _('sort by saved mtime'))],
2318 2318 _('[OPTION]...'))
2319 2319 def debugstate(ui, repo, nodates=None, datesort=None):
2320 2320 """show the contents of the current dirstate"""
2321 2321 timestr = ""
2322 2322 showdate = not nodates
2323 2323 if datesort:
2324 2324 keyfunc = lambda x: (x[1][3], x[0]) # sort by mtime, then by filename
2325 2325 else:
2326 2326 keyfunc = None # sort by filename
2327 2327 for file_, ent in sorted(repo.dirstate._map.iteritems(), key=keyfunc):
2328 2328 if showdate:
2329 2329 if ent[3] == -1:
2330 2330 # Pad or slice to locale representation
2331 2331 locale_len = len(time.strftime("%Y-%m-%d %H:%M:%S ",
2332 2332 time.localtime(0)))
2333 2333 timestr = 'unset'
2334 2334 timestr = (timestr[:locale_len] +
2335 2335 ' ' * (locale_len - len(timestr)))
2336 2336 else:
2337 2337 timestr = time.strftime("%Y-%m-%d %H:%M:%S ",
2338 2338 time.localtime(ent[3]))
2339 2339 if ent[1] & 020000:
2340 2340 mode = 'lnk'
2341 2341 else:
2342 2342 mode = '%3o' % (ent[1] & 0777 & ~util.umask)
2343 2343 ui.write("%c %s %10d %s%s\n" % (ent[0], mode, ent[2], timestr, file_))
2344 2344 for f in repo.dirstate.copies():
2345 2345 ui.write(_("copy: %s -> %s\n") % (repo.dirstate.copied(f), f))
2346 2346
2347 2347 @command('debugsub',
2348 2348 [('r', 'rev', '',
2349 2349 _('revision to check'), _('REV'))],
2350 2350 _('[-r REV] [REV]'))
2351 2351 def debugsub(ui, repo, rev=None):
2352 2352 ctx = scmutil.revsingle(repo, rev, None)
2353 2353 for k, v in sorted(ctx.substate.items()):
2354 2354 ui.write('path %s\n' % k)
2355 2355 ui.write(' source %s\n' % v[0])
2356 2356 ui.write(' revision %s\n' % v[1])
2357 2357
2358 2358 @command('debugwalk', walkopts, _('[OPTION]... [FILE]...'))
2359 2359 def debugwalk(ui, repo, *pats, **opts):
2360 2360 """show how files match on given patterns"""
2361 2361 m = scmutil.match(repo[None], pats, opts)
2362 2362 items = list(repo.walk(m))
2363 2363 if not items:
2364 2364 return
2365 2365 fmt = 'f %%-%ds %%-%ds %%s' % (
2366 2366 max([len(abs) for abs in items]),
2367 2367 max([len(m.rel(abs)) for abs in items]))
2368 2368 for abs in items:
2369 2369 line = fmt % (abs, m.rel(abs), m.exact(abs) and 'exact' or '')
2370 2370 ui.write("%s\n" % line.rstrip())
2371 2371
2372 2372 @command('debugwireargs',
2373 2373 [('', 'three', '', 'three'),
2374 2374 ('', 'four', '', 'four'),
2375 2375 ('', 'five', '', 'five'),
2376 2376 ] + remoteopts,
2377 2377 _('REPO [OPTIONS]... [ONE [TWO]]'))
2378 2378 def debugwireargs(ui, repopath, *vals, **opts):
2379 2379 repo = hg.peer(ui, opts, repopath)
2380 2380 for opt in remoteopts:
2381 2381 del opts[opt[1]]
2382 2382 args = {}
2383 2383 for k, v in opts.iteritems():
2384 2384 if v:
2385 2385 args[k] = v
2386 2386 # run twice to check that we don't mess up the stream for the next command
2387 2387 res1 = repo.debugwireargs(*vals, **args)
2388 2388 res2 = repo.debugwireargs(*vals, **args)
2389 2389 ui.write("%s\n" % res1)
2390 2390 if res1 != res2:
2391 2391 ui.warn("%s\n" % res2)
2392 2392
2393 2393 @command('^diff',
2394 2394 [('r', 'rev', [], _('revision'), _('REV')),
2395 2395 ('c', 'change', '', _('change made by revision'), _('REV'))
2396 2396 ] + diffopts + diffopts2 + walkopts + subrepoopts,
2397 2397 _('[OPTION]... ([-c REV] | [-r REV1 [-r REV2]]) [FILE]...'))
2398 2398 def diff(ui, repo, *pats, **opts):
2399 2399 """diff repository (or selected files)
2400 2400
2401 2401 Show differences between revisions for the specified files.
2402 2402
2403 2403 Differences between files are shown using the unified diff format.
2404 2404
2405 2405 .. note::
2406 2406 diff may generate unexpected results for merges, as it will
2407 2407 default to comparing against the working directory's first
2408 2408 parent changeset if no revisions are specified.
2409 2409
2410 2410 When two revision arguments are given, then changes are shown
2411 2411 between those revisions. If only one revision is specified then
2412 2412 that revision is compared to the working directory, and, when no
2413 2413 revisions are specified, the working directory files are compared
2414 2414 to its parent.
2415 2415
2416 2416 Alternatively you can specify -c/--change with a revision to see
2417 2417 the changes in that changeset relative to its first parent.
2418 2418
2419 2419 Without the -a/--text option, diff will avoid generating diffs of
2420 2420 files it detects as binary. With -a, diff will generate a diff
2421 2421 anyway, probably with undesirable results.
2422 2422
2423 2423 Use the -g/--git option to generate diffs in the git extended diff
2424 2424 format. For more information, read :hg:`help diffs`.
2425 2425
2426 2426 .. container:: verbose
2427 2427
2428 2428 Examples:
2429 2429
2430 2430 - compare a file in the current working directory to its parent::
2431 2431
2432 2432 hg diff foo.c
2433 2433
2434 2434 - compare two historical versions of a directory, with rename info::
2435 2435
2436 2436 hg diff --git -r 1.0:1.2 lib/
2437 2437
2438 2438 - get change stats relative to the last change on some date::
2439 2439
2440 2440 hg diff --stat -r "date('may 2')"
2441 2441
2442 2442 - diff all newly-added files that contain a keyword::
2443 2443
2444 2444 hg diff "set:added() and grep(GNU)"
2445 2445
2446 2446 - compare a revision and its parents::
2447 2447
2448 2448 hg diff -c 9353 # compare against first parent
2449 2449 hg diff -r 9353^:9353 # same using revset syntax
2450 2450 hg diff -r 9353^2:9353 # compare against the second parent
2451 2451
2452 2452 Returns 0 on success.
2453 2453 """
2454 2454
2455 2455 revs = opts.get('rev')
2456 2456 change = opts.get('change')
2457 2457 stat = opts.get('stat')
2458 2458 reverse = opts.get('reverse')
2459 2459
2460 2460 if revs and change:
2461 2461 msg = _('cannot specify --rev and --change at the same time')
2462 2462 raise util.Abort(msg)
2463 2463 elif change:
2464 2464 node2 = scmutil.revsingle(repo, change, None).node()
2465 2465 node1 = repo[node2].p1().node()
2466 2466 else:
2467 2467 node1, node2 = scmutil.revpair(repo, revs)
2468 2468
2469 2469 if reverse:
2470 2470 node1, node2 = node2, node1
2471 2471
2472 2472 diffopts = patch.diffopts(ui, opts)
2473 2473 m = scmutil.match(repo[node2], pats, opts)
2474 2474 cmdutil.diffordiffstat(ui, repo, diffopts, node1, node2, m, stat=stat,
2475 2475 listsubrepos=opts.get('subrepos'))
2476 2476
2477 2477 @command('^export',
2478 2478 [('o', 'output', '',
2479 2479 _('print output to file with formatted name'), _('FORMAT')),
2480 2480 ('', 'switch-parent', None, _('diff against the second parent')),
2481 2481 ('r', 'rev', [], _('revisions to export'), _('REV')),
2482 2482 ] + diffopts,
2483 2483 _('[OPTION]... [-o OUTFILESPEC] REV...'))
2484 2484 def export(ui, repo, *changesets, **opts):
2485 2485 """dump the header and diffs for one or more changesets
2486 2486
2487 2487 Print the changeset header and diffs for one or more revisions.
2488 2488
2489 2489 The information shown in the changeset header is: author, date,
2490 2490 branch name (if non-default), changeset hash, parent(s) and commit
2491 2491 comment.
2492 2492
2493 2493 .. note::
2494 2494 export may generate unexpected diff output for merge
2495 2495 changesets, as it will compare the merge changeset against its
2496 2496 first parent only.
2497 2497
2498 2498 Output may be to a file, in which case the name of the file is
2499 2499 given using a format string. The formatting rules are as follows:
2500 2500
2501 2501 :``%%``: literal "%" character
2502 2502 :``%H``: changeset hash (40 hexadecimal digits)
2503 2503 :``%N``: number of patches being generated
2504 2504 :``%R``: changeset revision number
2505 2505 :``%b``: basename of the exporting repository
2506 2506 :``%h``: short-form changeset hash (12 hexadecimal digits)
2507 2507 :``%m``: first line of the commit message (only alphanumeric characters)
2508 2508 :``%n``: zero-padded sequence number, starting at 1
2509 2509 :``%r``: zero-padded changeset revision number
2510 2510
2511 2511 Without the -a/--text option, export will avoid generating diffs
2512 2512 of files it detects as binary. With -a, export will generate a
2513 2513 diff anyway, probably with undesirable results.
2514 2514
2515 2515 Use the -g/--git option to generate diffs in the git extended diff
2516 2516 format. See :hg:`help diffs` for more information.
2517 2517
2518 2518 With the --switch-parent option, the diff will be against the
2519 2519 second parent. It can be useful to review a merge.
2520 2520
2521 2521 .. container:: verbose
2522 2522
2523 2523 Examples:
2524 2524
2525 2525 - use export and import to transplant a bugfix to the current
2526 2526 branch::
2527 2527
2528 2528 hg export -r 9353 | hg import -
2529 2529
2530 2530 - export all the changesets between two revisions to a file with
2531 2531 rename information::
2532 2532
2533 2533 hg export --git -r 123:150 > changes.txt
2534 2534
2535 2535 - split outgoing changes into a series of patches with
2536 2536 descriptive names::
2537 2537
2538 2538 hg export -r "outgoing()" -o "%n-%m.patch"
2539 2539
2540 2540 Returns 0 on success.
2541 2541 """
2542 2542 changesets += tuple(opts.get('rev', []))
2543 2543 revs = scmutil.revrange(repo, changesets)
2544 2544 if not revs:
2545 2545 raise util.Abort(_("export requires at least one changeset"))
2546 2546 if len(revs) > 1:
2547 2547 ui.note(_('exporting patches:\n'))
2548 2548 else:
2549 2549 ui.note(_('exporting patch:\n'))
2550 2550 cmdutil.export(repo, revs, template=opts.get('output'),
2551 2551 switch_parent=opts.get('switch_parent'),
2552 2552 opts=patch.diffopts(ui, opts))
2553 2553
2554 2554 @command('^forget', walkopts, _('[OPTION]... FILE...'))
2555 2555 def forget(ui, repo, *pats, **opts):
2556 2556 """forget the specified files on the next commit
2557 2557
2558 2558 Mark the specified files so they will no longer be tracked
2559 2559 after the next commit.
2560 2560
2561 2561 This only removes files from the current branch, not from the
2562 2562 entire project history, and it does not delete them from the
2563 2563 working directory.
2564 2564
2565 2565 To undo a forget before the next commit, see :hg:`add`.
2566 2566
2567 2567 .. container:: verbose
2568 2568
2569 2569 Examples:
2570 2570
2571 2571 - forget newly-added binary files::
2572 2572
2573 2573 hg forget "set:added() and binary()"
2574 2574
2575 2575 - forget files that would be excluded by .hgignore::
2576 2576
2577 2577 hg forget "set:hgignore()"
2578 2578
2579 2579 Returns 0 on success.
2580 2580 """
2581 2581
2582 2582 if not pats:
2583 2583 raise util.Abort(_('no files specified'))
2584 2584
2585 2585 m = scmutil.match(repo[None], pats, opts)
2586 2586 rejected = cmdutil.forget(ui, repo, m, prefix="", explicitonly=False)[0]
2587 2587 return rejected and 1 or 0
2588 2588
2589 2589 @command(
2590 2590 'graft',
2591 2591 [('c', 'continue', False, _('resume interrupted graft')),
2592 2592 ('e', 'edit', False, _('invoke editor on commit messages')),
2593 2593 ('', 'log', None, _('append graft info to log message')),
2594 2594 ('D', 'currentdate', False,
2595 2595 _('record the current date as commit date')),
2596 2596 ('U', 'currentuser', False,
2597 2597 _('record the current user as committer'), _('DATE'))]
2598 2598 + commitopts2 + mergetoolopts + dryrunopts,
2599 2599 _('[OPTION]... REVISION...'))
2600 2600 def graft(ui, repo, *revs, **opts):
2601 2601 '''copy changes from other branches onto the current branch
2602 2602
2603 2603 This command uses Mercurial's merge logic to copy individual
2604 2604 changes from other branches without merging branches in the
2605 2605 history graph. This is sometimes known as 'backporting' or
2606 2606 'cherry-picking'. By default, graft will copy user, date, and
2607 2607 description from the source changesets.
2608 2608
2609 2609 Changesets that are ancestors of the current revision, that have
2610 2610 already been grafted, or that are merges will be skipped.
2611 2611
2612 2612 If --log is specified, log messages will have a comment appended
2613 2613 of the form::
2614 2614
2615 2615 (grafted from CHANGESETHASH)
2616 2616
2617 2617 If a graft merge results in conflicts, the graft process is
2618 2618 interrupted so that the current merge can be manually resolved.
2619 2619 Once all conflicts are addressed, the graft process can be
2620 2620 continued with the -c/--continue option.
2621 2621
2622 2622 .. note::
2623 2623 The -c/--continue option does not reapply earlier options.
2624 2624
2625 2625 .. container:: verbose
2626 2626
2627 2627 Examples:
2628 2628
2629 2629 - copy a single change to the stable branch and edit its description::
2630 2630
2631 2631 hg update stable
2632 2632 hg graft --edit 9393
2633 2633
2634 2634 - graft a range of changesets with one exception, updating dates::
2635 2635
2636 2636 hg graft -D "2085::2093 and not 2091"
2637 2637
2638 2638 - continue a graft after resolving conflicts::
2639 2639
2640 2640 hg graft -c
2641 2641
2642 2642 - show the source of a grafted changeset::
2643 2643
2644 2644 hg log --debug -r tip
2645 2645
2646 2646 Returns 0 on successful completion.
2647 2647 '''
2648 2648
2649 2649 if not opts.get('user') and opts.get('currentuser'):
2650 2650 opts['user'] = ui.username()
2651 2651 if not opts.get('date') and opts.get('currentdate'):
2652 2652 opts['date'] = "%d %d" % util.makedate()
2653 2653
2654 2654 editor = None
2655 2655 if opts.get('edit'):
2656 2656 editor = cmdutil.commitforceeditor
2657 2657
2658 2658 cont = False
2659 2659 if opts['continue']:
2660 2660 cont = True
2661 2661 if revs:
2662 2662 raise util.Abort(_("can't specify --continue and revisions"))
2663 2663 # read in unfinished revisions
2664 2664 try:
2665 2665 nodes = repo.opener.read('graftstate').splitlines()
2666 2666 revs = [repo[node].rev() for node in nodes]
2667 2667 except IOError, inst:
2668 2668 if inst.errno != errno.ENOENT:
2669 2669 raise
2670 2670 raise util.Abort(_("no graft state found, can't continue"))
2671 2671 else:
2672 2672 cmdutil.bailifchanged(repo)
2673 2673 if not revs:
2674 2674 raise util.Abort(_('no revisions specified'))
2675 2675 revs = scmutil.revrange(repo, revs)
2676 2676
2677 2677 # check for merges
2678 2678 for rev in repo.revs('%ld and merge()', revs):
2679 2679 ui.warn(_('skipping ungraftable merge revision %s\n') % rev)
2680 2680 revs.remove(rev)
2681 2681 if not revs:
2682 2682 return -1
2683 2683
2684 2684 # check for ancestors of dest branch
2685 2685 for rev in repo.revs('::. and %ld', revs):
2686 2686 ui.warn(_('skipping ancestor revision %s\n') % rev)
2687 2687 revs.remove(rev)
2688 2688 if not revs:
2689 2689 return -1
2690 2690
2691 2691 # analyze revs for earlier grafts
2692 2692 ids = {}
2693 2693 for ctx in repo.set("%ld", revs):
2694 2694 ids[ctx.hex()] = ctx.rev()
2695 2695 n = ctx.extra().get('source')
2696 2696 if n:
2697 2697 ids[n] = ctx.rev()
2698 2698
2699 2699 # check ancestors for earlier grafts
2700 2700 ui.debug('scanning for duplicate grafts\n')
2701 2701 for ctx in repo.set("::. - ::%ld", revs):
2702 2702 n = ctx.extra().get('source')
2703 2703 if n in ids:
2704 2704 r = repo[n].rev()
2705 2705 if r in revs:
2706 2706 ui.warn(_('skipping already grafted revision %s\n') % r)
2707 2707 revs.remove(r)
2708 2708 elif ids[n] in revs:
2709 2709 ui.warn(_('skipping already grafted revision %s '
2710 2710 '(same origin %d)\n') % (ids[n], r))
2711 2711 revs.remove(ids[n])
2712 2712 elif ctx.hex() in ids:
2713 2713 r = ids[ctx.hex()]
2714 2714 ui.warn(_('skipping already grafted revision %s '
2715 2715 '(was grafted from %d)\n') % (r, ctx.rev()))
2716 2716 revs.remove(r)
2717 2717 if not revs:
2718 2718 return -1
2719 2719
2720 2720 wlock = repo.wlock()
2721 2721 try:
2722 2722 for pos, ctx in enumerate(repo.set("%ld", revs)):
2723 2723 current = repo['.']
2724 2724
2725 2725 ui.status(_('grafting revision %s\n') % ctx.rev())
2726 2726 if opts.get('dry_run'):
2727 2727 continue
2728 2728
2729 2729 # we don't merge the first commit when continuing
2730 2730 if not cont:
2731 2731 # perform the graft merge with p1(rev) as 'ancestor'
2732 2732 try:
2733 2733 # ui.forcemerge is an internal variable, do not document
2734 2734 repo.ui.setconfig('ui', 'forcemerge', opts.get('tool', ''))
2735 2735 stats = mergemod.update(repo, ctx.node(), True, True, False,
2736 2736 ctx.p1().node())
2737 2737 finally:
2738 2738 ui.setconfig('ui', 'forcemerge', '')
2739 2739 # drop the second merge parent
2740 2740 repo.setparents(current.node(), nullid)
2741 2741 repo.dirstate.write()
2742 2742 # fix up dirstate for copies and renames
2743 2743 cmdutil.duplicatecopies(repo, ctx.rev(), ctx.p1().rev())
2744 2744 # report any conflicts
2745 2745 if stats and stats[3] > 0:
2746 2746 # write out state for --continue
2747 2747 nodelines = [repo[rev].hex() + "\n" for rev in revs[pos:]]
2748 2748 repo.opener.write('graftstate', ''.join(nodelines))
2749 2749 raise util.Abort(
2750 2750 _("unresolved conflicts, can't continue"),
2751 2751 hint=_('use hg resolve and hg graft --continue'))
2752 2752 else:
2753 2753 cont = False
2754 2754
2755 2755 # commit
2756 2756 source = ctx.extra().get('source')
2757 2757 if not source:
2758 2758 source = ctx.hex()
2759 2759 extra = {'source': source}
2760 2760 user = ctx.user()
2761 2761 if opts.get('user'):
2762 2762 user = opts['user']
2763 2763 date = ctx.date()
2764 2764 if opts.get('date'):
2765 2765 date = opts['date']
2766 2766 message = ctx.description()
2767 2767 if opts.get('log'):
2768 2768 message += '\n(grafted from %s)' % ctx.hex()
2769 2769 node = repo.commit(text=message, user=user,
2770 2770 date=date, extra=extra, editor=editor)
2771 2771 if node is None:
2772 2772 ui.status(_('graft for revision %s is empty\n') % ctx.rev())
2773 2773 finally:
2774 2774 wlock.release()
2775 2775
2776 2776 # remove state when we complete successfully
2777 2777 if not opts.get('dry_run') and os.path.exists(repo.join('graftstate')):
2778 2778 util.unlinkpath(repo.join('graftstate'))
2779 2779
2780 2780 return 0
2781 2781
2782 2782 @command('grep',
2783 2783 [('0', 'print0', None, _('end fields with NUL')),
2784 2784 ('', 'all', None, _('print all revisions that match')),
2785 2785 ('a', 'text', None, _('treat all files as text')),
2786 2786 ('f', 'follow', None,
2787 2787 _('follow changeset history,'
2788 2788 ' or file history across copies and renames')),
2789 2789 ('i', 'ignore-case', None, _('ignore case when matching')),
2790 2790 ('l', 'files-with-matches', None,
2791 2791 _('print only filenames and revisions that match')),
2792 2792 ('n', 'line-number', None, _('print matching line numbers')),
2793 2793 ('r', 'rev', [],
2794 2794 _('only search files changed within revision range'), _('REV')),
2795 2795 ('u', 'user', None, _('list the author (long with -v)')),
2796 2796 ('d', 'date', None, _('list the date (short with -q)')),
2797 2797 ] + walkopts,
2798 2798 _('[OPTION]... PATTERN [FILE]...'))
2799 2799 def grep(ui, repo, pattern, *pats, **opts):
2800 2800 """search for a pattern in specified files and revisions
2801 2801
2802 2802 Search revisions of files for a regular expression.
2803 2803
2804 2804 This command behaves differently than Unix grep. It only accepts
2805 2805 Python/Perl regexps. It searches repository history, not the
2806 2806 working directory. It always prints the revision number in which a
2807 2807 match appears.
2808 2808
2809 2809 By default, grep only prints output for the first revision of a
2810 2810 file in which it finds a match. To get it to print every revision
2811 2811 that contains a change in match status ("-" for a match that
2812 2812 becomes a non-match, or "+" for a non-match that becomes a match),
2813 2813 use the --all flag.
2814 2814
2815 2815 Returns 0 if a match is found, 1 otherwise.
2816 2816 """
2817 2817 reflags = re.M
2818 2818 if opts.get('ignore_case'):
2819 2819 reflags |= re.I
2820 2820 try:
2821 2821 regexp = re.compile(pattern, reflags)
2822 2822 except re.error, inst:
2823 2823 ui.warn(_("grep: invalid match pattern: %s\n") % inst)
2824 2824 return 1
2825 2825 sep, eol = ':', '\n'
2826 2826 if opts.get('print0'):
2827 2827 sep = eol = '\0'
2828 2828
2829 2829 getfile = util.lrucachefunc(repo.file)
2830 2830
2831 2831 def matchlines(body):
2832 2832 begin = 0
2833 2833 linenum = 0
2834 2834 while True:
2835 2835 match = regexp.search(body, begin)
2836 2836 if not match:
2837 2837 break
2838 2838 mstart, mend = match.span()
2839 2839 linenum += body.count('\n', begin, mstart) + 1
2840 2840 lstart = body.rfind('\n', begin, mstart) + 1 or begin
2841 2841 begin = body.find('\n', mend) + 1 or len(body) + 1
2842 2842 lend = begin - 1
2843 2843 yield linenum, mstart - lstart, mend - lstart, body[lstart:lend]
2844 2844
2845 2845 class linestate(object):
2846 2846 def __init__(self, line, linenum, colstart, colend):
2847 2847 self.line = line
2848 2848 self.linenum = linenum
2849 2849 self.colstart = colstart
2850 2850 self.colend = colend
2851 2851
2852 2852 def __hash__(self):
2853 2853 return hash((self.linenum, self.line))
2854 2854
2855 2855 def __eq__(self, other):
2856 2856 return self.line == other.line
2857 2857
2858 2858 matches = {}
2859 2859 copies = {}
2860 2860 def grepbody(fn, rev, body):
2861 2861 matches[rev].setdefault(fn, [])
2862 2862 m = matches[rev][fn]
2863 2863 for lnum, cstart, cend, line in matchlines(body):
2864 2864 s = linestate(line, lnum, cstart, cend)
2865 2865 m.append(s)
2866 2866
2867 2867 def difflinestates(a, b):
2868 2868 sm = difflib.SequenceMatcher(None, a, b)
2869 2869 for tag, alo, ahi, blo, bhi in sm.get_opcodes():
2870 2870 if tag == 'insert':
2871 2871 for i in xrange(blo, bhi):
2872 2872 yield ('+', b[i])
2873 2873 elif tag == 'delete':
2874 2874 for i in xrange(alo, ahi):
2875 2875 yield ('-', a[i])
2876 2876 elif tag == 'replace':
2877 2877 for i in xrange(alo, ahi):
2878 2878 yield ('-', a[i])
2879 2879 for i in xrange(blo, bhi):
2880 2880 yield ('+', b[i])
2881 2881
2882 2882 def display(fn, ctx, pstates, states):
2883 2883 rev = ctx.rev()
2884 2884 datefunc = ui.quiet and util.shortdate or util.datestr
2885 2885 found = False
2886 2886 filerevmatches = {}
2887 2887 def binary():
2888 2888 flog = getfile(fn)
2889 2889 return util.binary(flog.read(ctx.filenode(fn)))
2890 2890
2891 2891 if opts.get('all'):
2892 2892 iter = difflinestates(pstates, states)
2893 2893 else:
2894 2894 iter = [('', l) for l in states]
2895 2895 for change, l in iter:
2896 2896 cols = [fn, str(rev)]
2897 2897 before, match, after = None, None, None
2898 2898 if opts.get('line_number'):
2899 2899 cols.append(str(l.linenum))
2900 2900 if opts.get('all'):
2901 2901 cols.append(change)
2902 2902 if opts.get('user'):
2903 2903 cols.append(ui.shortuser(ctx.user()))
2904 2904 if opts.get('date'):
2905 2905 cols.append(datefunc(ctx.date()))
2906 2906 if opts.get('files_with_matches'):
2907 2907 c = (fn, rev)
2908 2908 if c in filerevmatches:
2909 2909 continue
2910 2910 filerevmatches[c] = 1
2911 2911 else:
2912 2912 before = l.line[:l.colstart]
2913 2913 match = l.line[l.colstart:l.colend]
2914 2914 after = l.line[l.colend:]
2915 2915 ui.write(sep.join(cols))
2916 2916 if before is not None:
2917 2917 if not opts.get('text') and binary():
2918 2918 ui.write(sep + " Binary file matches")
2919 2919 else:
2920 2920 ui.write(sep + before)
2921 2921 ui.write(match, label='grep.match')
2922 2922 ui.write(after)
2923 2923 ui.write(eol)
2924 2924 found = True
2925 2925 return found
2926 2926
2927 2927 skip = {}
2928 2928 revfiles = {}
2929 2929 matchfn = scmutil.match(repo[None], pats, opts)
2930 2930 found = False
2931 2931 follow = opts.get('follow')
2932 2932
2933 2933 def prep(ctx, fns):
2934 2934 rev = ctx.rev()
2935 2935 pctx = ctx.p1()
2936 2936 parent = pctx.rev()
2937 2937 matches.setdefault(rev, {})
2938 2938 matches.setdefault(parent, {})
2939 2939 files = revfiles.setdefault(rev, [])
2940 2940 for fn in fns:
2941 2941 flog = getfile(fn)
2942 2942 try:
2943 2943 fnode = ctx.filenode(fn)
2944 2944 except error.LookupError:
2945 2945 continue
2946 2946
2947 2947 copied = flog.renamed(fnode)
2948 2948 copy = follow and copied and copied[0]
2949 2949 if copy:
2950 2950 copies.setdefault(rev, {})[fn] = copy
2951 2951 if fn in skip:
2952 2952 if copy:
2953 2953 skip[copy] = True
2954 2954 continue
2955 2955 files.append(fn)
2956 2956
2957 2957 if fn not in matches[rev]:
2958 2958 grepbody(fn, rev, flog.read(fnode))
2959 2959
2960 2960 pfn = copy or fn
2961 2961 if pfn not in matches[parent]:
2962 2962 try:
2963 2963 fnode = pctx.filenode(pfn)
2964 2964 grepbody(pfn, parent, flog.read(fnode))
2965 2965 except error.LookupError:
2966 2966 pass
2967 2967
2968 2968 for ctx in cmdutil.walkchangerevs(repo, matchfn, opts, prep):
2969 2969 rev = ctx.rev()
2970 2970 parent = ctx.p1().rev()
2971 2971 for fn in sorted(revfiles.get(rev, [])):
2972 2972 states = matches[rev][fn]
2973 2973 copy = copies.get(rev, {}).get(fn)
2974 2974 if fn in skip:
2975 2975 if copy:
2976 2976 skip[copy] = True
2977 2977 continue
2978 2978 pstates = matches.get(parent, {}).get(copy or fn, [])
2979 2979 if pstates or states:
2980 2980 r = display(fn, ctx, pstates, states)
2981 2981 found = found or r
2982 2982 if r and not opts.get('all'):
2983 2983 skip[fn] = True
2984 2984 if copy:
2985 2985 skip[copy] = True
2986 2986 del matches[rev]
2987 2987 del revfiles[rev]
2988 2988
2989 2989 return not found
2990 2990
2991 2991 @command('heads',
2992 2992 [('r', 'rev', '',
2993 2993 _('show only heads which are descendants of STARTREV'), _('STARTREV')),
2994 2994 ('t', 'topo', False, _('show topological heads only')),
2995 2995 ('a', 'active', False, _('show active branchheads only (DEPRECATED)')),
2996 2996 ('c', 'closed', False, _('show normal and closed branch heads')),
2997 2997 ] + templateopts,
2998 2998 _('[-ac] [-r STARTREV] [REV]...'))
2999 2999 def heads(ui, repo, *branchrevs, **opts):
3000 3000 """show current repository heads or show branch heads
3001 3001
3002 3002 With no arguments, show all repository branch heads.
3003 3003
3004 3004 Repository "heads" are changesets with no child changesets. They are
3005 3005 where development generally takes place and are the usual targets
3006 3006 for update and merge operations. Branch heads are changesets that have
3007 3007 no child changeset on the same branch.
3008 3008
3009 3009 If one or more REVs are given, only branch heads on the branches
3010 3010 associated with the specified changesets are shown. This means
3011 3011 that you can use :hg:`heads foo` to see the heads on a branch
3012 3012 named ``foo``.
3013 3013
3014 3014 If -c/--closed is specified, also show branch heads marked closed
3015 3015 (see :hg:`commit --close-branch`).
3016 3016
3017 3017 If STARTREV is specified, only those heads that are descendants of
3018 3018 STARTREV will be displayed.
3019 3019
3020 3020 If -t/--topo is specified, named branch mechanics will be ignored and only
3021 3021 changesets without children will be shown.
3022 3022
3023 3023 Returns 0 if matching heads are found, 1 if not.
3024 3024 """
3025 3025
3026 3026 start = None
3027 3027 if 'rev' in opts:
3028 3028 start = scmutil.revsingle(repo, opts['rev'], None).node()
3029 3029
3030 3030 if opts.get('topo'):
3031 3031 heads = [repo[h] for h in repo.heads(start)]
3032 3032 else:
3033 3033 heads = []
3034 3034 for branch in repo.branchmap():
3035 3035 heads += repo.branchheads(branch, start, opts.get('closed'))
3036 3036 heads = [repo[h] for h in heads]
3037 3037
3038 3038 if branchrevs:
3039 3039 branches = set(repo[br].branch() for br in branchrevs)
3040 3040 heads = [h for h in heads if h.branch() in branches]
3041 3041
3042 3042 if opts.get('active') and branchrevs:
3043 3043 dagheads = repo.heads(start)
3044 3044 heads = [h for h in heads if h.node() in dagheads]
3045 3045
3046 3046 if branchrevs:
3047 3047 haveheads = set(h.branch() for h in heads)
3048 3048 if branches - haveheads:
3049 3049 headless = ', '.join(b for b in branches - haveheads)
3050 3050 msg = _('no open branch heads found on branches %s')
3051 3051 if opts.get('rev'):
3052 3052 msg += _(' (started at %s)') % opts['rev']
3053 3053 ui.warn((msg + '\n') % headless)
3054 3054
3055 3055 if not heads:
3056 3056 return 1
3057 3057
3058 3058 heads = sorted(heads, key=lambda x: -x.rev())
3059 3059 displayer = cmdutil.show_changeset(ui, repo, opts)
3060 3060 for ctx in heads:
3061 3061 displayer.show(ctx)
3062 3062 displayer.close()
3063 3063
3064 3064 @command('help',
3065 3065 [('e', 'extension', None, _('show only help for extensions')),
3066 3066 ('c', 'command', None, _('show only help for commands'))],
3067 3067 _('[-ec] [TOPIC]'))
3068 3068 def help_(ui, name=None, unknowncmd=False, full=True, **opts):
3069 3069 """show help for a given topic or a help overview
3070 3070
3071 3071 With no arguments, print a list of commands with short help messages.
3072 3072
3073 3073 Given a topic, extension, or command name, print help for that
3074 3074 topic.
3075 3075
3076 3076 Returns 0 if successful.
3077 3077 """
3078 3078
3079 3079 textwidth = min(ui.termwidth(), 80) - 2
3080 3080
3081 3081 def optrst(options):
3082 3082 data = []
3083 3083 multioccur = False
3084 3084 for option in options:
3085 3085 if len(option) == 5:
3086 3086 shortopt, longopt, default, desc, optlabel = option
3087 3087 else:
3088 3088 shortopt, longopt, default, desc = option
3089 3089 optlabel = _("VALUE") # default label
3090 3090
3091 3091 if _("DEPRECATED") in desc and not ui.verbose:
3092 3092 continue
3093 3093
3094 3094 so = ''
3095 3095 if shortopt:
3096 3096 so = '-' + shortopt
3097 3097 lo = '--' + longopt
3098 3098 if default:
3099 3099 desc += _(" (default: %s)") % default
3100 3100
3101 3101 if isinstance(default, list):
3102 3102 lo += " %s [+]" % optlabel
3103 3103 multioccur = True
3104 3104 elif (default is not None) and not isinstance(default, bool):
3105 3105 lo += " %s" % optlabel
3106 3106
3107 3107 data.append((so, lo, desc))
3108 3108
3109 3109 rst = minirst.maketable(data, 1)
3110 3110
3111 3111 if multioccur:
3112 3112 rst += _("\n[+] marked option can be specified multiple times\n")
3113 3113
3114 3114 return rst
3115 3115
3116 3116 # list all option lists
3117 3117 def opttext(optlist, width):
3118 3118 rst = ''
3119 3119 if not optlist:
3120 3120 return ''
3121 3121
3122 3122 for title, options in optlist:
3123 3123 rst += '\n%s\n' % title
3124 3124 if options:
3125 3125 rst += "\n"
3126 3126 rst += optrst(options)
3127 3127 rst += '\n'
3128 3128
3129 3129 return '\n' + minirst.format(rst, width)
3130 3130
3131 3131 def addglobalopts(optlist, aliases):
3132 3132 if ui.quiet:
3133 3133 return []
3134 3134
3135 3135 if ui.verbose:
3136 3136 optlist.append((_("global options:"), globalopts))
3137 3137 if name == 'shortlist':
3138 3138 optlist.append((_('use "hg help" for the full list '
3139 3139 'of commands'), ()))
3140 3140 else:
3141 3141 if name == 'shortlist':
3142 3142 msg = _('use "hg help" for the full list of commands '
3143 3143 'or "hg -v" for details')
3144 3144 elif name and not full:
3145 3145 msg = _('use "hg help %s" to show the full help text') % name
3146 3146 elif aliases:
3147 3147 msg = _('use "hg -v help%s" to show builtin aliases and '
3148 3148 'global options') % (name and " " + name or "")
3149 3149 else:
3150 3150 msg = _('use "hg -v help %s" to show more info') % name
3151 3151 optlist.append((msg, ()))
3152 3152
3153 3153 def helpcmd(name):
3154 3154 try:
3155 3155 aliases, entry = cmdutil.findcmd(name, table, strict=unknowncmd)
3156 3156 except error.AmbiguousCommand, inst:
3157 3157 # py3k fix: except vars can't be used outside the scope of the
3158 3158 # except block, nor can be used inside a lambda. python issue4617
3159 3159 prefix = inst.args[0]
3160 3160 select = lambda c: c.lstrip('^').startswith(prefix)
3161 3161 helplist(select)
3162 3162 return
3163 3163
3164 3164 # check if it's an invalid alias and display its error if it is
3165 3165 if getattr(entry[0], 'badalias', False):
3166 3166 if not unknowncmd:
3167 3167 entry[0](ui)
3168 3168 return
3169 3169
3170 3170 rst = ""
3171 3171
3172 3172 # synopsis
3173 3173 if len(entry) > 2:
3174 3174 if entry[2].startswith('hg'):
3175 3175 rst += "%s\n" % entry[2]
3176 3176 else:
3177 3177 rst += 'hg %s %s\n' % (aliases[0], entry[2])
3178 3178 else:
3179 3179 rst += 'hg %s\n' % aliases[0]
3180 3180
3181 3181 # aliases
3182 3182 if full and not ui.quiet and len(aliases) > 1:
3183 3183 rst += _("\naliases: %s\n") % ', '.join(aliases[1:])
3184 3184
3185 3185 # description
3186 3186 doc = gettext(entry[0].__doc__)
3187 3187 if not doc:
3188 3188 doc = _("(no help text available)")
3189 3189 if util.safehasattr(entry[0], 'definition'): # aliased command
3190 3190 if entry[0].definition.startswith('!'): # shell alias
3191 3191 doc = _('shell alias for::\n\n %s') % entry[0].definition[1:]
3192 3192 else:
3193 3193 doc = _('alias for: hg %s\n\n%s') % (entry[0].definition, doc)
3194 3194 if ui.quiet or not full:
3195 3195 doc = doc.splitlines()[0]
3196 3196 rst += "\n" + doc + "\n"
3197 3197
3198 3198 # check if this command shadows a non-trivial (multi-line)
3199 3199 # extension help text
3200 3200 try:
3201 3201 mod = extensions.find(name)
3202 3202 doc = gettext(mod.__doc__) or ''
3203 3203 if '\n' in doc.strip():
3204 3204 msg = _('use "hg help -e %s" to show help for '
3205 3205 'the %s extension') % (name, name)
3206 3206 rst += '\n%s\n' % msg
3207 3207 except KeyError:
3208 3208 pass
3209 3209
3210 3210 # options
3211 3211 if not ui.quiet and entry[1]:
3212 3212 rst += '\n'
3213 3213 rst += _("options:")
3214 3214 rst += '\n\n'
3215 3215 rst += optrst(entry[1])
3216 3216
3217 3217 if ui.verbose:
3218 3218 rst += '\n'
3219 3219 rst += _("global options:")
3220 3220 rst += '\n\n'
3221 3221 rst += optrst(globalopts)
3222 3222
3223 3223 keep = ui.verbose and ['verbose'] or []
3224 3224 formatted, pruned = minirst.format(rst, textwidth, keep=keep)
3225 3225 ui.write(formatted)
3226 3226
3227 3227 if not ui.verbose:
3228 3228 if not full:
3229 3229 ui.write(_('\nuse "hg help %s" to show the full help text\n')
3230 3230 % name)
3231 3231 elif not ui.quiet:
3232 3232 ui.write(_('\nuse "hg -v help %s" to show more info\n') % name)
3233 3233
3234 3234
3235 3235 def helplist(select=None):
3236 3236 # list of commands
3237 3237 if name == "shortlist":
3238 3238 header = _('basic commands:\n\n')
3239 3239 else:
3240 3240 header = _('list of commands:\n\n')
3241 3241
3242 3242 h = {}
3243 3243 cmds = {}
3244 3244 for c, e in table.iteritems():
3245 3245 f = c.split("|", 1)[0]
3246 3246 if select and not select(f):
3247 3247 continue
3248 3248 if (not select and name != 'shortlist' and
3249 3249 e[0].__module__ != __name__):
3250 3250 continue
3251 3251 if name == "shortlist" and not f.startswith("^"):
3252 3252 continue
3253 3253 f = f.lstrip("^")
3254 3254 if not ui.debugflag and f.startswith("debug"):
3255 3255 continue
3256 3256 doc = e[0].__doc__
3257 3257 if doc and 'DEPRECATED' in doc and not ui.verbose:
3258 3258 continue
3259 3259 doc = gettext(doc)
3260 3260 if not doc:
3261 3261 doc = _("(no help text available)")
3262 3262 h[f] = doc.splitlines()[0].rstrip()
3263 3263 cmds[f] = c.lstrip("^")
3264 3264
3265 3265 if not h:
3266 3266 ui.status(_('no commands defined\n'))
3267 3267 return
3268 3268
3269 3269 ui.status(header)
3270 3270 fns = sorted(h)
3271 3271 m = max(map(len, fns))
3272 3272 for f in fns:
3273 3273 if ui.verbose:
3274 3274 commands = cmds[f].replace("|",", ")
3275 3275 ui.write(" %s:\n %s\n"%(commands, h[f]))
3276 3276 else:
3277 3277 ui.write('%s\n' % (util.wrap(h[f], textwidth,
3278 3278 initindent=' %-*s ' % (m, f),
3279 3279 hangindent=' ' * (m + 4))))
3280 3280
3281 3281 if not name:
3282 3282 text = help.listexts(_('enabled extensions:'), extensions.enabled())
3283 3283 if text:
3284 3284 ui.write("\n%s" % minirst.format(text, textwidth))
3285 3285
3286 3286 ui.write(_("\nadditional help topics:\n\n"))
3287 3287 topics = []
3288 3288 for names, header, doc in help.helptable:
3289 3289 topics.append((sorted(names, key=len, reverse=True)[0], header))
3290 3290 topics_len = max([len(s[0]) for s in topics])
3291 3291 for t, desc in topics:
3292 3292 ui.write(" %-*s %s\n" % (topics_len, t, desc))
3293 3293
3294 3294 optlist = []
3295 3295 addglobalopts(optlist, True)
3296 3296 ui.write(opttext(optlist, textwidth))
3297 3297
3298 3298 def helptopic(name):
3299 3299 for names, header, doc in help.helptable:
3300 3300 if name in names:
3301 3301 break
3302 3302 else:
3303 3303 raise error.UnknownCommand(name)
3304 3304
3305 3305 # description
3306 3306 if not doc:
3307 3307 doc = _("(no help text available)")
3308 3308 if util.safehasattr(doc, '__call__'):
3309 3309 doc = doc()
3310 3310
3311 3311 ui.write("%s\n\n" % header)
3312 3312 ui.write("%s" % minirst.format(doc, textwidth, indent=4))
3313 3313 try:
3314 3314 cmdutil.findcmd(name, table)
3315 3315 ui.write(_('\nuse "hg help -c %s" to see help for '
3316 3316 'the %s command\n') % (name, name))
3317 3317 except error.UnknownCommand:
3318 3318 pass
3319 3319
3320 3320 def helpext(name):
3321 3321 try:
3322 3322 mod = extensions.find(name)
3323 3323 doc = gettext(mod.__doc__) or _('no help text available')
3324 3324 except KeyError:
3325 3325 mod = None
3326 3326 doc = extensions.disabledext(name)
3327 3327 if not doc:
3328 3328 raise error.UnknownCommand(name)
3329 3329
3330 3330 if '\n' not in doc:
3331 3331 head, tail = doc, ""
3332 3332 else:
3333 3333 head, tail = doc.split('\n', 1)
3334 3334 ui.write(_('%s extension - %s\n\n') % (name.split('.')[-1], head))
3335 3335 if tail:
3336 3336 ui.write(minirst.format(tail, textwidth))
3337 3337 ui.status('\n')
3338 3338
3339 3339 if mod:
3340 3340 try:
3341 3341 ct = mod.cmdtable
3342 3342 except AttributeError:
3343 3343 ct = {}
3344 3344 modcmds = set([c.split('|', 1)[0] for c in ct])
3345 3345 helplist(modcmds.__contains__)
3346 3346 else:
3347 3347 ui.write(_('use "hg help extensions" for information on enabling '
3348 3348 'extensions\n'))
3349 3349
3350 3350 def helpextcmd(name):
3351 3351 cmd, ext, mod = extensions.disabledcmd(ui, name,
3352 3352 ui.configbool('ui', 'strict'))
3353 3353 doc = gettext(mod.__doc__).splitlines()[0]
3354 3354
3355 3355 msg = help.listexts(_("'%s' is provided by the following "
3356 3356 "extension:") % cmd, {ext: doc}, indent=4)
3357 3357 ui.write(minirst.format(msg, textwidth))
3358 3358 ui.write('\n')
3359 3359 ui.write(_('use "hg help extensions" for information on enabling '
3360 3360 'extensions\n'))
3361 3361
3362 3362 if name and name != 'shortlist':
3363 3363 i = None
3364 3364 if unknowncmd:
3365 3365 queries = (helpextcmd,)
3366 3366 elif opts.get('extension'):
3367 3367 queries = (helpext,)
3368 3368 elif opts.get('command'):
3369 3369 queries = (helpcmd,)
3370 3370 else:
3371 3371 queries = (helptopic, helpcmd, helpext, helpextcmd)
3372 3372 for f in queries:
3373 3373 try:
3374 3374 f(name)
3375 3375 i = None
3376 3376 break
3377 3377 except error.UnknownCommand, inst:
3378 3378 i = inst
3379 3379 if i:
3380 3380 raise i
3381 3381 else:
3382 3382 # program name
3383 3383 ui.status(_("Mercurial Distributed SCM\n"))
3384 3384 ui.status('\n')
3385 3385 helplist()
3386 3386
3387 3387
3388 3388 @command('identify|id',
3389 3389 [('r', 'rev', '',
3390 3390 _('identify the specified revision'), _('REV')),
3391 3391 ('n', 'num', None, _('show local revision number')),
3392 3392 ('i', 'id', None, _('show global revision id')),
3393 3393 ('b', 'branch', None, _('show branch')),
3394 3394 ('t', 'tags', None, _('show tags')),
3395 3395 ('B', 'bookmarks', None, _('show bookmarks')),
3396 3396 ] + remoteopts,
3397 3397 _('[-nibtB] [-r REV] [SOURCE]'))
3398 3398 def identify(ui, repo, source=None, rev=None,
3399 3399 num=None, id=None, branch=None, tags=None, bookmarks=None, **opts):
3400 3400 """identify the working copy or specified revision
3401 3401
3402 3402 Print a summary identifying the repository state at REV using one or
3403 3403 two parent hash identifiers, followed by a "+" if the working
3404 3404 directory has uncommitted changes, the branch name (if not default),
3405 3405 a list of tags, and a list of bookmarks.
3406 3406
3407 3407 When REV is not given, print a summary of the current state of the
3408 3408 repository.
3409 3409
3410 3410 Specifying a path to a repository root or Mercurial bundle will
3411 3411 cause lookup to operate on that repository/bundle.
3412 3412
3413 3413 .. container:: verbose
3414 3414
3415 3415 Examples:
3416 3416
3417 3417 - generate a build identifier for the working directory::
3418 3418
3419 3419 hg id --id > build-id.dat
3420 3420
3421 3421 - find the revision corresponding to a tag::
3422 3422
3423 3423 hg id -n -r 1.3
3424 3424
3425 3425 - check the most recent revision of a remote repository::
3426 3426
3427 3427 hg id -r tip http://selenic.com/hg/
3428 3428
3429 3429 Returns 0 if successful.
3430 3430 """
3431 3431
3432 3432 if not repo and not source:
3433 3433 raise util.Abort(_("there is no Mercurial repository here "
3434 3434 "(.hg not found)"))
3435 3435
3436 3436 hexfunc = ui.debugflag and hex or short
3437 3437 default = not (num or id or branch or tags or bookmarks)
3438 3438 output = []
3439 3439 revs = []
3440 3440
3441 3441 if source:
3442 3442 source, branches = hg.parseurl(ui.expandpath(source))
3443 3443 repo = hg.peer(ui, opts, source)
3444 3444 revs, checkout = hg.addbranchrevs(repo, repo, branches, None)
3445 3445
3446 3446 if not repo.local():
3447 3447 if num or branch or tags:
3448 3448 raise util.Abort(
3449 3449 _("can't query remote revision number, branch, or tags"))
3450 3450 if not rev and revs:
3451 3451 rev = revs[0]
3452 3452 if not rev:
3453 3453 rev = "tip"
3454 3454
3455 3455 remoterev = repo.lookup(rev)
3456 3456 if default or id:
3457 3457 output = [hexfunc(remoterev)]
3458 3458
3459 3459 def getbms():
3460 3460 bms = []
3461 3461
3462 3462 if 'bookmarks' in repo.listkeys('namespaces'):
3463 3463 hexremoterev = hex(remoterev)
3464 3464 bms = [bm for bm, bmr in repo.listkeys('bookmarks').iteritems()
3465 3465 if bmr == hexremoterev]
3466 3466
3467 3467 return bms
3468 3468
3469 3469 if bookmarks:
3470 3470 output.extend(getbms())
3471 3471 elif default and not ui.quiet:
3472 3472 # multiple bookmarks for a single parent separated by '/'
3473 3473 bm = '/'.join(getbms())
3474 3474 if bm:
3475 3475 output.append(bm)
3476 3476 else:
3477 3477 if not rev:
3478 3478 ctx = repo[None]
3479 3479 parents = ctx.parents()
3480 3480 changed = ""
3481 3481 if default or id or num:
3482 3482 changed = util.any(repo.status()) and "+" or ""
3483 3483 if default or id:
3484 3484 output = ["%s%s" %
3485 3485 ('+'.join([hexfunc(p.node()) for p in parents]), changed)]
3486 3486 if num:
3487 3487 output.append("%s%s" %
3488 3488 ('+'.join([str(p.rev()) for p in parents]), changed))
3489 3489 else:
3490 3490 ctx = scmutil.revsingle(repo, rev)
3491 3491 if default or id:
3492 3492 output = [hexfunc(ctx.node())]
3493 3493 if num:
3494 3494 output.append(str(ctx.rev()))
3495 3495
3496 3496 if default and not ui.quiet:
3497 3497 b = ctx.branch()
3498 3498 if b != 'default':
3499 3499 output.append("(%s)" % b)
3500 3500
3501 3501 # multiple tags for a single parent separated by '/'
3502 3502 t = '/'.join(ctx.tags())
3503 3503 if t:
3504 3504 output.append(t)
3505 3505
3506 3506 # multiple bookmarks for a single parent separated by '/'
3507 3507 bm = '/'.join(ctx.bookmarks())
3508 3508 if bm:
3509 3509 output.append(bm)
3510 3510 else:
3511 3511 if branch:
3512 3512 output.append(ctx.branch())
3513 3513
3514 3514 if tags:
3515 3515 output.extend(ctx.tags())
3516 3516
3517 3517 if bookmarks:
3518 3518 output.extend(ctx.bookmarks())
3519 3519
3520 3520 ui.write("%s\n" % ' '.join(output))
3521 3521
3522 3522 @command('import|patch',
3523 3523 [('p', 'strip', 1,
3524 3524 _('directory strip option for patch. This has the same '
3525 3525 'meaning as the corresponding patch option'), _('NUM')),
3526 3526 ('b', 'base', '', _('base path (DEPRECATED)'), _('PATH')),
3527 3527 ('e', 'edit', False, _('invoke editor on commit messages')),
3528 3528 ('f', 'force', None, _('skip check for outstanding uncommitted changes')),
3529 3529 ('', 'no-commit', None,
3530 3530 _("don't commit, just update the working directory")),
3531 3531 ('', 'bypass', None,
3532 3532 _("apply patch without touching the working directory")),
3533 3533 ('', 'exact', None,
3534 3534 _('apply patch to the nodes from which it was generated')),
3535 3535 ('', 'import-branch', None,
3536 3536 _('use any branch information in patch (implied by --exact)'))] +
3537 3537 commitopts + commitopts2 + similarityopts,
3538 3538 _('[OPTION]... PATCH...'))
3539 3539 def import_(ui, repo, patch1=None, *patches, **opts):
3540 3540 """import an ordered set of patches
3541 3541
3542 3542 Import a list of patches and commit them individually (unless
3543 3543 --no-commit is specified).
3544 3544
3545 3545 If there are outstanding changes in the working directory, import
3546 3546 will abort unless given the -f/--force flag.
3547 3547
3548 3548 You can import a patch straight from a mail message. Even patches
3549 3549 as attachments work (to use the body part, it must have type
3550 3550 text/plain or text/x-patch). From and Subject headers of email
3551 3551 message are used as default committer and commit message. All
3552 3552 text/plain body parts before first diff are added to commit
3553 3553 message.
3554 3554
3555 3555 If the imported patch was generated by :hg:`export`, user and
3556 3556 description from patch override values from message headers and
3557 3557 body. Values given on command line with -m/--message and -u/--user
3558 3558 override these.
3559 3559
3560 3560 If --exact is specified, import will set the working directory to
3561 3561 the parent of each patch before applying it, and will abort if the
3562 3562 resulting changeset has a different ID than the one recorded in
3563 3563 the patch. This may happen due to character set problems or other
3564 3564 deficiencies in the text patch format.
3565 3565
3566 3566 Use --bypass to apply and commit patches directly to the
3567 3567 repository, not touching the working directory. Without --exact,
3568 3568 patches will be applied on top of the working directory parent
3569 3569 revision.
3570 3570
3571 3571 With -s/--similarity, hg will attempt to discover renames and
3572 3572 copies in the patch in the same way as :hg:`addremove`.
3573 3573
3574 3574 To read a patch from standard input, use "-" as the patch name. If
3575 3575 a URL is specified, the patch will be downloaded from it.
3576 3576 See :hg:`help dates` for a list of formats valid for -d/--date.
3577 3577
3578 3578 .. container:: verbose
3579 3579
3580 3580 Examples:
3581 3581
3582 3582 - import a traditional patch from a website and detect renames::
3583 3583
3584 3584 hg import -s 80 http://example.com/bugfix.patch
3585 3585
3586 3586 - import a changeset from an hgweb server::
3587 3587
3588 3588 hg import http://www.selenic.com/hg/rev/5ca8c111e9aa
3589 3589
3590 3590 - import all the patches in an Unix-style mbox::
3591 3591
3592 3592 hg import incoming-patches.mbox
3593 3593
3594 3594 - attempt to exactly restore an exported changeset (not always
3595 3595 possible)::
3596 3596
3597 3597 hg import --exact proposed-fix.patch
3598 3598
3599 3599 Returns 0 on success.
3600 3600 """
3601 3601
3602 3602 if not patch1:
3603 3603 raise util.Abort(_('need at least one patch to import'))
3604 3604
3605 3605 patches = (patch1,) + patches
3606 3606
3607 3607 date = opts.get('date')
3608 3608 if date:
3609 3609 opts['date'] = util.parsedate(date)
3610 3610
3611 3611 editor = cmdutil.commiteditor
3612 3612 if opts.get('edit'):
3613 3613 editor = cmdutil.commitforceeditor
3614 3614
3615 3615 update = not opts.get('bypass')
3616 3616 if not update and opts.get('no_commit'):
3617 3617 raise util.Abort(_('cannot use --no-commit with --bypass'))
3618 3618 try:
3619 3619 sim = float(opts.get('similarity') or 0)
3620 3620 except ValueError:
3621 3621 raise util.Abort(_('similarity must be a number'))
3622 3622 if sim < 0 or sim > 100:
3623 3623 raise util.Abort(_('similarity must be between 0 and 100'))
3624 3624 if sim and not update:
3625 3625 raise util.Abort(_('cannot use --similarity with --bypass'))
3626 3626
3627 3627 if (opts.get('exact') or not opts.get('force')) and update:
3628 3628 cmdutil.bailifchanged(repo)
3629 3629
3630 3630 base = opts["base"]
3631 3631 strip = opts["strip"]
3632 3632 wlock = lock = tr = None
3633 3633 msgs = []
3634 3634
3635 3635 def checkexact(repo, n, nodeid):
3636 3636 if opts.get('exact') and hex(n) != nodeid:
3637 3637 repo.rollback()
3638 3638 raise util.Abort(_('patch is damaged or loses information'))
3639 3639
3640 3640 def tryone(ui, hunk, parents):
3641 3641 tmpname, message, user, date, branch, nodeid, p1, p2 = \
3642 3642 patch.extract(ui, hunk)
3643 3643
3644 3644 if not tmpname:
3645 3645 return (None, None)
3646 3646 msg = _('applied to working directory')
3647 3647
3648 3648 try:
3649 3649 cmdline_message = cmdutil.logmessage(ui, opts)
3650 3650 if cmdline_message:
3651 3651 # pickup the cmdline msg
3652 3652 message = cmdline_message
3653 3653 elif message:
3654 3654 # pickup the patch msg
3655 3655 message = message.strip()
3656 3656 else:
3657 3657 # launch the editor
3658 3658 message = None
3659 3659 ui.debug('message:\n%s\n' % message)
3660 3660
3661 3661 if len(parents) == 1:
3662 3662 parents.append(repo[nullid])
3663 3663 if opts.get('exact'):
3664 3664 if not nodeid or not p1:
3665 3665 raise util.Abort(_('not a Mercurial patch'))
3666 3666 p1 = repo[p1]
3667 3667 p2 = repo[p2 or nullid]
3668 3668 elif p2:
3669 3669 try:
3670 3670 p1 = repo[p1]
3671 3671 p2 = repo[p2]
3672 3672 # Without any options, consider p2 only if the
3673 3673 # patch is being applied on top of the recorded
3674 3674 # first parent.
3675 3675 if p1 != parents[0]:
3676 3676 p1 = parents[0]
3677 3677 p2 = repo[nullid]
3678 3678 except error.RepoError:
3679 3679 p1, p2 = parents
3680 3680 else:
3681 3681 p1, p2 = parents
3682 3682
3683 3683 n = None
3684 3684 if update:
3685 3685 if p1 != parents[0]:
3686 3686 hg.clean(repo, p1.node())
3687 3687 if p2 != parents[1]:
3688 3688 repo.setparents(p1.node(), p2.node())
3689 3689
3690 3690 if opts.get('exact') or opts.get('import_branch'):
3691 3691 repo.dirstate.setbranch(branch or 'default')
3692 3692
3693 3693 files = set()
3694 3694 patch.patch(ui, repo, tmpname, strip=strip, files=files,
3695 3695 eolmode=None, similarity=sim / 100.0)
3696 3696 files = list(files)
3697 3697 if opts.get('no_commit'):
3698 3698 if message:
3699 3699 msgs.append(message)
3700 3700 else:
3701 3701 if opts.get('exact') or p2:
3702 3702 # If you got here, you either use --force and know what
3703 3703 # you are doing or used --exact or a merge patch while
3704 3704 # being updated to its first parent.
3705 3705 m = None
3706 3706 else:
3707 3707 m = scmutil.matchfiles(repo, files or [])
3708 3708 n = repo.commit(message, opts.get('user') or user,
3709 3709 opts.get('date') or date, match=m,
3710 3710 editor=editor)
3711 3711 checkexact(repo, n, nodeid)
3712 3712 else:
3713 3713 if opts.get('exact') or opts.get('import_branch'):
3714 3714 branch = branch or 'default'
3715 3715 else:
3716 3716 branch = p1.branch()
3717 3717 store = patch.filestore()
3718 3718 try:
3719 3719 files = set()
3720 3720 try:
3721 3721 patch.patchrepo(ui, repo, p1, store, tmpname, strip,
3722 3722 files, eolmode=None)
3723 3723 except patch.PatchError, e:
3724 3724 raise util.Abort(str(e))
3725 3725 memctx = patch.makememctx(repo, (p1.node(), p2.node()),
3726 3726 message,
3727 3727 opts.get('user') or user,
3728 3728 opts.get('date') or date,
3729 3729 branch, files, store,
3730 3730 editor=cmdutil.commiteditor)
3731 3731 repo.savecommitmessage(memctx.description())
3732 3732 n = memctx.commit()
3733 3733 checkexact(repo, n, nodeid)
3734 3734 finally:
3735 3735 store.close()
3736 3736 if n:
3737 3737 # i18n: refers to a short changeset id
3738 3738 msg = _('created %s') % short(n)
3739 3739 return (msg, n)
3740 3740 finally:
3741 3741 os.unlink(tmpname)
3742 3742
3743 3743 try:
3744 3744 try:
3745 3745 wlock = repo.wlock()
3746 3746 if not opts.get('no_commit'):
3747 3747 lock = repo.lock()
3748 3748 tr = repo.transaction('import')
3749 3749 parents = repo.parents()
3750 3750 for patchurl in patches:
3751 3751 if patchurl == '-':
3752 3752 ui.status(_('applying patch from stdin\n'))
3753 3753 patchfile = ui.fin
3754 3754 patchurl = 'stdin' # for error message
3755 3755 else:
3756 3756 patchurl = os.path.join(base, patchurl)
3757 3757 ui.status(_('applying %s\n') % patchurl)
3758 3758 patchfile = url.open(ui, patchurl)
3759 3759
3760 3760 haspatch = False
3761 3761 for hunk in patch.split(patchfile):
3762 3762 (msg, node) = tryone(ui, hunk, parents)
3763 3763 if msg:
3764 3764 haspatch = True
3765 3765 ui.note(msg + '\n')
3766 3766 if update or opts.get('exact'):
3767 3767 parents = repo.parents()
3768 3768 else:
3769 3769 parents = [repo[node]]
3770 3770
3771 3771 if not haspatch:
3772 3772 raise util.Abort(_('%s: no diffs found') % patchurl)
3773 3773
3774 3774 if tr:
3775 3775 tr.close()
3776 3776 if msgs:
3777 3777 repo.savecommitmessage('\n* * *\n'.join(msgs))
3778 3778 except: # re-raises
3779 3779 # wlock.release() indirectly calls dirstate.write(): since
3780 3780 # we're crashing, we do not want to change the working dir
3781 3781 # parent after all, so make sure it writes nothing
3782 3782 repo.dirstate.invalidate()
3783 3783 raise
3784 3784 finally:
3785 3785 if tr:
3786 3786 tr.release()
3787 3787 release(lock, wlock)
3788 3788
3789 3789 @command('incoming|in',
3790 3790 [('f', 'force', None,
3791 3791 _('run even if remote repository is unrelated')),
3792 3792 ('n', 'newest-first', None, _('show newest record first')),
3793 3793 ('', 'bundle', '',
3794 3794 _('file to store the bundles into'), _('FILE')),
3795 3795 ('r', 'rev', [], _('a remote changeset intended to be added'), _('REV')),
3796 3796 ('B', 'bookmarks', False, _("compare bookmarks")),
3797 3797 ('b', 'branch', [],
3798 3798 _('a specific branch you would like to pull'), _('BRANCH')),
3799 3799 ] + logopts + remoteopts + subrepoopts,
3800 3800 _('[-p] [-n] [-M] [-f] [-r REV]... [--bundle FILENAME] [SOURCE]'))
3801 3801 def incoming(ui, repo, source="default", **opts):
3802 3802 """show new changesets found in source
3803 3803
3804 3804 Show new changesets found in the specified path/URL or the default
3805 3805 pull location. These are the changesets that would have been pulled
3806 3806 if a pull at the time you issued this command.
3807 3807
3808 3808 For remote repository, using --bundle avoids downloading the
3809 3809 changesets twice if the incoming is followed by a pull.
3810 3810
3811 3811 See pull for valid source format details.
3812 3812
3813 3813 Returns 0 if there are incoming changes, 1 otherwise.
3814 3814 """
3815 3815 if opts.get('bundle') and opts.get('subrepos'):
3816 3816 raise util.Abort(_('cannot combine --bundle and --subrepos'))
3817 3817
3818 3818 if opts.get('bookmarks'):
3819 3819 source, branches = hg.parseurl(ui.expandpath(source),
3820 3820 opts.get('branch'))
3821 3821 other = hg.peer(repo, opts, source)
3822 3822 if 'bookmarks' not in other.listkeys('namespaces'):
3823 3823 ui.warn(_("remote doesn't support bookmarks\n"))
3824 3824 return 0
3825 3825 ui.status(_('comparing with %s\n') % util.hidepassword(source))
3826 3826 return bookmarks.diff(ui, repo, other)
3827 3827
3828 3828 repo._subtoppath = ui.expandpath(source)
3829 3829 try:
3830 3830 return hg.incoming(ui, repo, source, opts)
3831 3831 finally:
3832 3832 del repo._subtoppath
3833 3833
3834 3834
3835 3835 @command('^init', remoteopts, _('[-e CMD] [--remotecmd CMD] [DEST]'))
3836 3836 def init(ui, dest=".", **opts):
3837 3837 """create a new repository in the given directory
3838 3838
3839 3839 Initialize a new repository in the given directory. If the given
3840 3840 directory does not exist, it will be created.
3841 3841
3842 3842 If no directory is given, the current directory is used.
3843 3843
3844 3844 It is possible to specify an ``ssh://`` URL as the destination.
3845 3845 See :hg:`help urls` for more information.
3846 3846
3847 3847 Returns 0 on success.
3848 3848 """
3849 3849 hg.peer(ui, opts, ui.expandpath(dest), create=True)
3850 3850
3851 3851 @command('locate',
3852 3852 [('r', 'rev', '', _('search the repository as it is in REV'), _('REV')),
3853 3853 ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
3854 3854 ('f', 'fullpath', None, _('print complete paths from the filesystem root')),
3855 3855 ] + walkopts,
3856 3856 _('[OPTION]... [PATTERN]...'))
3857 3857 def locate(ui, repo, *pats, **opts):
3858 3858 """locate files matching specific patterns
3859 3859
3860 3860 Print files under Mercurial control in the working directory whose
3861 3861 names match the given patterns.
3862 3862
3863 3863 By default, this command searches all directories in the working
3864 3864 directory. To search just the current directory and its
3865 3865 subdirectories, use "--include .".
3866 3866
3867 3867 If no patterns are given to match, this command prints the names
3868 3868 of all files under Mercurial control in the working directory.
3869 3869
3870 3870 If you want to feed the output of this command into the "xargs"
3871 3871 command, use the -0 option to both this command and "xargs". This
3872 3872 will avoid the problem of "xargs" treating single filenames that
3873 3873 contain whitespace as multiple filenames.
3874 3874
3875 3875 Returns 0 if a match is found, 1 otherwise.
3876 3876 """
3877 3877 end = opts.get('print0') and '\0' or '\n'
3878 3878 rev = scmutil.revsingle(repo, opts.get('rev'), None).node()
3879 3879
3880 3880 ret = 1
3881 3881 m = scmutil.match(repo[rev], pats, opts, default='relglob')
3882 3882 m.bad = lambda x, y: False
3883 3883 for abs in repo[rev].walk(m):
3884 3884 if not rev and abs not in repo.dirstate:
3885 3885 continue
3886 3886 if opts.get('fullpath'):
3887 3887 ui.write(repo.wjoin(abs), end)
3888 3888 else:
3889 3889 ui.write(((pats and m.rel(abs)) or abs), end)
3890 3890 ret = 0
3891 3891
3892 3892 return ret
3893 3893
3894 3894 @command('^log|history',
3895 3895 [('f', 'follow', None,
3896 3896 _('follow changeset history, or file history across copies and renames')),
3897 3897 ('', 'follow-first', None,
3898 3898 _('only follow the first parent of merge changesets (DEPRECATED)')),
3899 3899 ('d', 'date', '', _('show revisions matching date spec'), _('DATE')),
3900 3900 ('C', 'copies', None, _('show copied files')),
3901 3901 ('k', 'keyword', [],
3902 3902 _('do case-insensitive search for a given text'), _('TEXT')),
3903 3903 ('r', 'rev', [], _('show the specified revision or range'), _('REV')),
3904 3904 ('', 'removed', None, _('include revisions where files were removed')),
3905 3905 ('m', 'only-merges', None, _('show only merges (DEPRECATED)')),
3906 3906 ('u', 'user', [], _('revisions committed by user'), _('USER')),
3907 3907 ('', 'only-branch', [],
3908 3908 _('show only changesets within the given named branch (DEPRECATED)'),
3909 3909 _('BRANCH')),
3910 3910 ('b', 'branch', [],
3911 3911 _('show changesets within the given named branch'), _('BRANCH')),
3912 3912 ('P', 'prune', [],
3913 3913 _('do not display revision or any of its ancestors'), _('REV')),
3914 3914 ('', 'hidden', False, _('show hidden changesets (DEPRECATED)')),
3915 3915 ] + logopts + walkopts,
3916 3916 _('[OPTION]... [FILE]'))
3917 3917 def log(ui, repo, *pats, **opts):
3918 3918 """show revision history of entire repository or files
3919 3919
3920 3920 Print the revision history of the specified files or the entire
3921 3921 project.
3922 3922
3923 3923 If no revision range is specified, the default is ``tip:0`` unless
3924 3924 --follow is set, in which case the working directory parent is
3925 3925 used as the starting revision.
3926 3926
3927 3927 File history is shown without following rename or copy history of
3928 3928 files. Use -f/--follow with a filename to follow history across
3929 3929 renames and copies. --follow without a filename will only show
3930 3930 ancestors or descendants of the starting revision.
3931 3931
3932 3932 By default this command prints revision number and changeset id,
3933 3933 tags, non-trivial parents, user, date and time, and a summary for
3934 3934 each commit. When the -v/--verbose switch is used, the list of
3935 3935 changed files and full commit message are shown.
3936 3936
3937 3937 .. note::
3938 3938 log -p/--patch may generate unexpected diff output for merge
3939 3939 changesets, as it will only compare the merge changeset against
3940 3940 its first parent. Also, only files different from BOTH parents
3941 3941 will appear in files:.
3942 3942
3943 3943 .. note::
3944 3944 for performance reasons, log FILE may omit duplicate changes
3945 3945 made on branches and will not show deletions. To see all
3946 3946 changes including duplicates and deletions, use the --removed
3947 3947 switch.
3948 3948
3949 3949 .. container:: verbose
3950 3950
3951 3951 Some examples:
3952 3952
3953 3953 - changesets with full descriptions and file lists::
3954 3954
3955 3955 hg log -v
3956 3956
3957 3957 - changesets ancestral to the working directory::
3958 3958
3959 3959 hg log -f
3960 3960
3961 3961 - last 10 commits on the current branch::
3962 3962
3963 3963 hg log -l 10 -b .
3964 3964
3965 3965 - changesets showing all modifications of a file, including removals::
3966 3966
3967 3967 hg log --removed file.c
3968 3968
3969 3969 - all changesets that touch a directory, with diffs, excluding merges::
3970 3970
3971 3971 hg log -Mp lib/
3972 3972
3973 3973 - all revision numbers that match a keyword::
3974 3974
3975 3975 hg log -k bug --template "{rev}\\n"
3976 3976
3977 3977 - check if a given changeset is included is a tagged release::
3978 3978
3979 3979 hg log -r "a21ccf and ancestor(1.9)"
3980 3980
3981 3981 - find all changesets by some user in a date range::
3982 3982
3983 3983 hg log -k alice -d "may 2008 to jul 2008"
3984 3984
3985 3985 - summary of all changesets after the last tag::
3986 3986
3987 3987 hg log -r "last(tagged())::" --template "{desc|firstline}\\n"
3988 3988
3989 3989 See :hg:`help dates` for a list of formats valid for -d/--date.
3990 3990
3991 3991 See :hg:`help revisions` and :hg:`help revsets` for more about
3992 3992 specifying revisions.
3993 3993
3994 3994 See :hg:`help templates` for more about pre-packaged styles and
3995 3995 specifying custom templates.
3996 3996
3997 3997 Returns 0 on success.
3998 3998 """
3999 3999
4000 4000 matchfn = scmutil.match(repo[None], pats, opts)
4001 4001 limit = cmdutil.loglimit(opts)
4002 4002 count = 0
4003 4003
4004 4004 getrenamed, endrev = None, None
4005 4005 if opts.get('copies'):
4006 4006 if opts.get('rev'):
4007 4007 endrev = max(scmutil.revrange(repo, opts.get('rev'))) + 1
4008 4008 getrenamed = templatekw.getrenamedfn(repo, endrev=endrev)
4009 4009
4010 4010 df = False
4011 4011 if opts["date"]:
4012 4012 df = util.matchdate(opts["date"])
4013 4013
4014 4014 branches = opts.get('branch', []) + opts.get('only_branch', [])
4015 4015 opts['branch'] = [repo.lookupbranch(b) for b in branches]
4016 4016
4017 4017 displayer = cmdutil.show_changeset(ui, repo, opts, True)
4018 4018 def prep(ctx, fns):
4019 4019 rev = ctx.rev()
4020 4020 parents = [p for p in repo.changelog.parentrevs(rev)
4021 4021 if p != nullrev]
4022 4022 if opts.get('no_merges') and len(parents) == 2:
4023 4023 return
4024 4024 if opts.get('only_merges') and len(parents) != 2:
4025 4025 return
4026 4026 if opts.get('branch') and ctx.branch() not in opts['branch']:
4027 4027 return
4028 4028 if not opts.get('hidden') and ctx.hidden():
4029 4029 return
4030 4030 if df and not df(ctx.date()[0]):
4031 4031 return
4032 4032
4033 4033 lower = encoding.lower
4034 4034 if opts.get('user'):
4035 4035 luser = lower(ctx.user())
4036 4036 for k in [lower(x) for x in opts['user']]:
4037 4037 if (k in luser):
4038 4038 break
4039 4039 else:
4040 4040 return
4041 4041 if opts.get('keyword'):
4042 4042 luser = lower(ctx.user())
4043 4043 ldesc = lower(ctx.description())
4044 4044 lfiles = lower(" ".join(ctx.files()))
4045 4045 for k in [lower(x) for x in opts['keyword']]:
4046 4046 if (k in luser or k in ldesc or k in lfiles):
4047 4047 break
4048 4048 else:
4049 4049 return
4050 4050
4051 4051 copies = None
4052 4052 if getrenamed is not None and rev:
4053 4053 copies = []
4054 4054 for fn in ctx.files():
4055 4055 rename = getrenamed(fn, rev)
4056 4056 if rename:
4057 4057 copies.append((fn, rename[0]))
4058 4058
4059 4059 revmatchfn = None
4060 4060 if opts.get('patch') or opts.get('stat'):
4061 4061 if opts.get('follow') or opts.get('follow_first'):
4062 4062 # note: this might be wrong when following through merges
4063 4063 revmatchfn = scmutil.match(repo[None], fns, default='path')
4064 4064 else:
4065 4065 revmatchfn = matchfn
4066 4066
4067 4067 displayer.show(ctx, copies=copies, matchfn=revmatchfn)
4068 4068
4069 4069 for ctx in cmdutil.walkchangerevs(repo, matchfn, opts, prep):
4070 4070 if count == limit:
4071 4071 break
4072 4072 if displayer.flush(ctx.rev()):
4073 4073 count += 1
4074 4074 displayer.close()
4075 4075
4076 4076 @command('manifest',
4077 4077 [('r', 'rev', '', _('revision to display'), _('REV')),
4078 4078 ('', 'all', False, _("list files from all revisions"))],
4079 4079 _('[-r REV]'))
4080 4080 def manifest(ui, repo, node=None, rev=None, **opts):
4081 4081 """output the current or given revision of the project manifest
4082 4082
4083 4083 Print a list of version controlled files for the given revision.
4084 4084 If no revision is given, the first parent of the working directory
4085 4085 is used, or the null revision if no revision is checked out.
4086 4086
4087 4087 With -v, print file permissions, symlink and executable bits.
4088 4088 With --debug, print file revision hashes.
4089 4089
4090 4090 If option --all is specified, the list of all files from all revisions
4091 4091 is printed. This includes deleted and renamed files.
4092 4092
4093 4093 Returns 0 on success.
4094 4094 """
4095 4095 if opts.get('all'):
4096 4096 if rev or node:
4097 4097 raise util.Abort(_("can't specify a revision with --all"))
4098 4098
4099 4099 res = []
4100 4100 prefix = "data/"
4101 4101 suffix = ".i"
4102 4102 plen = len(prefix)
4103 4103 slen = len(suffix)
4104 4104 lock = repo.lock()
4105 4105 try:
4106 4106 for fn, b, size in repo.store.datafiles():
4107 4107 if size != 0 and fn[-slen:] == suffix and fn[:plen] == prefix:
4108 4108 res.append(fn[plen:-slen])
4109 4109 finally:
4110 4110 lock.release()
4111 4111 for f in sorted(res):
4112 4112 ui.write("%s\n" % f)
4113 4113 return
4114 4114
4115 4115 if rev and node:
4116 4116 raise util.Abort(_("please specify just one revision"))
4117 4117
4118 4118 if not node:
4119 4119 node = rev
4120 4120
4121 4121 decor = {'l':'644 @ ', 'x':'755 * ', '':'644 '}
4122 4122 ctx = scmutil.revsingle(repo, node)
4123 4123 for f in ctx:
4124 4124 if ui.debugflag:
4125 4125 ui.write("%40s " % hex(ctx.manifest()[f]))
4126 4126 if ui.verbose:
4127 4127 ui.write(decor[ctx.flags(f)])
4128 4128 ui.write("%s\n" % f)
4129 4129
4130 4130 @command('^merge',
4131 4131 [('f', 'force', None, _('force a merge with outstanding changes')),
4132 4132 ('r', 'rev', '', _('revision to merge'), _('REV')),
4133 4133 ('P', 'preview', None,
4134 4134 _('review revisions to merge (no merge is performed)'))
4135 4135 ] + mergetoolopts,
4136 4136 _('[-P] [-f] [[-r] REV]'))
4137 4137 def merge(ui, repo, node=None, **opts):
4138 4138 """merge working directory with another revision
4139 4139
4140 4140 The current working directory is updated with all changes made in
4141 4141 the requested revision since the last common predecessor revision.
4142 4142
4143 4143 Files that changed between either parent are marked as changed for
4144 4144 the next commit and a commit must be performed before any further
4145 4145 updates to the repository are allowed. The next commit will have
4146 4146 two parents.
4147 4147
4148 4148 ``--tool`` can be used to specify the merge tool used for file
4149 4149 merges. It overrides the HGMERGE environment variable and your
4150 4150 configuration files. See :hg:`help merge-tools` for options.
4151 4151
4152 4152 If no revision is specified, the working directory's parent is a
4153 4153 head revision, and the current branch contains exactly one other
4154 4154 head, the other head is merged with by default. Otherwise, an
4155 4155 explicit revision with which to merge with must be provided.
4156 4156
4157 4157 :hg:`resolve` must be used to resolve unresolved files.
4158 4158
4159 4159 To undo an uncommitted merge, use :hg:`update --clean .` which
4160 4160 will check out a clean copy of the original merge parent, losing
4161 4161 all changes.
4162 4162
4163 4163 Returns 0 on success, 1 if there are unresolved files.
4164 4164 """
4165 4165
4166 4166 if opts.get('rev') and node:
4167 4167 raise util.Abort(_("please specify just one revision"))
4168 4168 if not node:
4169 4169 node = opts.get('rev')
4170 4170
4171 if not node:
4171 if node:
4172 node = scmutil.revsingle(repo, node).node()
4173
4174 if not node and repo._bookmarkcurrent:
4175 bmheads = repo.bookmarkheads(repo._bookmarkcurrent)
4176 curhead = repo[repo._bookmarkcurrent]
4177 if len(bmheads) == 2:
4178 if curhead == bmheads[0]:
4179 node = bmheads[1]
4180 else:
4181 node = bmheads[0]
4182 elif len(bmheads) > 2:
4183 raise util.Abort(_("multiple matching bookmarks to merge - "
4184 "please merge with an explicit rev or bookmark"),
4185 hint=_("run 'hg heads' to see all heads"))
4186 elif len(bmheads) <= 1:
4187 raise util.Abort(_("no matching bookmark to merge - "
4188 "please merge with an explicit rev or bookmark"),
4189 hint=_("run 'hg heads' to see all heads"))
4190
4191 if not node and not repo._bookmarkcurrent:
4172 4192 branch = repo[None].branch()
4173 4193 bheads = repo.branchheads(branch)
4174 if len(bheads) > 2:
4194 nbhs = [bh for bh in bheads if not repo[bh].bookmarks()]
4195
4196 if len(nbhs) > 2:
4175 4197 raise util.Abort(_("branch '%s' has %d heads - "
4176 4198 "please merge with an explicit rev")
4177 4199 % (branch, len(bheads)),
4178 4200 hint=_("run 'hg heads .' to see heads"))
4179 4201
4180 4202 parent = repo.dirstate.p1()
4181 if len(bheads) == 1:
4203 if len(nbhs) == 1:
4204 if len(bheads) > 1:
4205 raise util.Abort(_("heads are bookmarked - "
4206 "please merge with an explicit rev"),
4207 hint=_("run 'hg heads' to see all heads"))
4182 4208 if len(repo.heads()) > 1:
4183 4209 raise util.Abort(_("branch '%s' has one head - "
4184 4210 "please merge with an explicit rev")
4185 4211 % branch,
4186 4212 hint=_("run 'hg heads' to see all heads"))
4187 4213 msg, hint = _('nothing to merge'), None
4188 4214 if parent != repo.lookup(branch):
4189 4215 hint = _("use 'hg update' instead")
4190 4216 raise util.Abort(msg, hint=hint)
4191 4217
4192 4218 if parent not in bheads:
4193 4219 raise util.Abort(_('working directory not at a head revision'),
4194 4220 hint=_("use 'hg update' or merge with an "
4195 4221 "explicit revision"))
4196 node = parent == bheads[0] and bheads[-1] or bheads[0]
4197 else:
4198 node = scmutil.revsingle(repo, node).node()
4222 if parent == nbhs[0]:
4223 node = nbhs[-1]
4224 else:
4225 node = nbhs[0]
4199 4226
4200 4227 if opts.get('preview'):
4201 4228 # find nodes that are ancestors of p2 but not of p1
4202 4229 p1 = repo.lookup('.')
4203 4230 p2 = repo.lookup(node)
4204 4231 nodes = repo.changelog.findmissing(common=[p1], heads=[p2])
4205 4232
4206 4233 displayer = cmdutil.show_changeset(ui, repo, opts)
4207 4234 for node in nodes:
4208 4235 displayer.show(repo[node])
4209 4236 displayer.close()
4210 4237 return 0
4211 4238
4212 4239 try:
4213 4240 # ui.forcemerge is an internal variable, do not document
4214 4241 repo.ui.setconfig('ui', 'forcemerge', opts.get('tool', ''))
4215 4242 return hg.merge(repo, node, force=opts.get('force'))
4216 4243 finally:
4217 4244 ui.setconfig('ui', 'forcemerge', '')
4218 4245
4219 4246 @command('outgoing|out',
4220 4247 [('f', 'force', None, _('run even when the destination is unrelated')),
4221 4248 ('r', 'rev', [],
4222 4249 _('a changeset intended to be included in the destination'), _('REV')),
4223 4250 ('n', 'newest-first', None, _('show newest record first')),
4224 4251 ('B', 'bookmarks', False, _('compare bookmarks')),
4225 4252 ('b', 'branch', [], _('a specific branch you would like to push'),
4226 4253 _('BRANCH')),
4227 4254 ] + logopts + remoteopts + subrepoopts,
4228 4255 _('[-M] [-p] [-n] [-f] [-r REV]... [DEST]'))
4229 4256 def outgoing(ui, repo, dest=None, **opts):
4230 4257 """show changesets not found in the destination
4231 4258
4232 4259 Show changesets not found in the specified destination repository
4233 4260 or the default push location. These are the changesets that would
4234 4261 be pushed if a push was requested.
4235 4262
4236 4263 See pull for details of valid destination formats.
4237 4264
4238 4265 Returns 0 if there are outgoing changes, 1 otherwise.
4239 4266 """
4240 4267
4241 4268 if opts.get('bookmarks'):
4242 4269 dest = ui.expandpath(dest or 'default-push', dest or 'default')
4243 4270 dest, branches = hg.parseurl(dest, opts.get('branch'))
4244 4271 other = hg.peer(repo, opts, dest)
4245 4272 if 'bookmarks' not in other.listkeys('namespaces'):
4246 4273 ui.warn(_("remote doesn't support bookmarks\n"))
4247 4274 return 0
4248 4275 ui.status(_('comparing with %s\n') % util.hidepassword(dest))
4249 4276 return bookmarks.diff(ui, other, repo)
4250 4277
4251 4278 repo._subtoppath = ui.expandpath(dest or 'default-push', dest or 'default')
4252 4279 try:
4253 4280 return hg.outgoing(ui, repo, dest, opts)
4254 4281 finally:
4255 4282 del repo._subtoppath
4256 4283
4257 4284 @command('parents',
4258 4285 [('r', 'rev', '', _('show parents of the specified revision'), _('REV')),
4259 4286 ] + templateopts,
4260 4287 _('[-r REV] [FILE]'))
4261 4288 def parents(ui, repo, file_=None, **opts):
4262 4289 """show the parents of the working directory or revision
4263 4290
4264 4291 Print the working directory's parent revisions. If a revision is
4265 4292 given via -r/--rev, the parent of that revision will be printed.
4266 4293 If a file argument is given, the revision in which the file was
4267 4294 last changed (before the working directory revision or the
4268 4295 argument to --rev if given) is printed.
4269 4296
4270 4297 Returns 0 on success.
4271 4298 """
4272 4299
4273 4300 ctx = scmutil.revsingle(repo, opts.get('rev'), None)
4274 4301
4275 4302 if file_:
4276 4303 m = scmutil.match(ctx, (file_,), opts)
4277 4304 if m.anypats() or len(m.files()) != 1:
4278 4305 raise util.Abort(_('can only specify an explicit filename'))
4279 4306 file_ = m.files()[0]
4280 4307 filenodes = []
4281 4308 for cp in ctx.parents():
4282 4309 if not cp:
4283 4310 continue
4284 4311 try:
4285 4312 filenodes.append(cp.filenode(file_))
4286 4313 except error.LookupError:
4287 4314 pass
4288 4315 if not filenodes:
4289 4316 raise util.Abort(_("'%s' not found in manifest!") % file_)
4290 4317 fl = repo.file(file_)
4291 4318 p = [repo.lookup(fl.linkrev(fl.rev(fn))) for fn in filenodes]
4292 4319 else:
4293 4320 p = [cp.node() for cp in ctx.parents()]
4294 4321
4295 4322 displayer = cmdutil.show_changeset(ui, repo, opts)
4296 4323 for n in p:
4297 4324 if n != nullid:
4298 4325 displayer.show(repo[n])
4299 4326 displayer.close()
4300 4327
4301 4328 @command('paths', [], _('[NAME]'))
4302 4329 def paths(ui, repo, search=None):
4303 4330 """show aliases for remote repositories
4304 4331
4305 4332 Show definition of symbolic path name NAME. If no name is given,
4306 4333 show definition of all available names.
4307 4334
4308 4335 Option -q/--quiet suppresses all output when searching for NAME
4309 4336 and shows only the path names when listing all definitions.
4310 4337
4311 4338 Path names are defined in the [paths] section of your
4312 4339 configuration file and in ``/etc/mercurial/hgrc``. If run inside a
4313 4340 repository, ``.hg/hgrc`` is used, too.
4314 4341
4315 4342 The path names ``default`` and ``default-push`` have a special
4316 4343 meaning. When performing a push or pull operation, they are used
4317 4344 as fallbacks if no location is specified on the command-line.
4318 4345 When ``default-push`` is set, it will be used for push and
4319 4346 ``default`` will be used for pull; otherwise ``default`` is used
4320 4347 as the fallback for both. When cloning a repository, the clone
4321 4348 source is written as ``default`` in ``.hg/hgrc``. Note that
4322 4349 ``default`` and ``default-push`` apply to all inbound (e.g.
4323 4350 :hg:`incoming`) and outbound (e.g. :hg:`outgoing`, :hg:`email` and
4324 4351 :hg:`bundle`) operations.
4325 4352
4326 4353 See :hg:`help urls` for more information.
4327 4354
4328 4355 Returns 0 on success.
4329 4356 """
4330 4357 if search:
4331 4358 for name, path in ui.configitems("paths"):
4332 4359 if name == search:
4333 4360 ui.status("%s\n" % util.hidepassword(path))
4334 4361 return
4335 4362 if not ui.quiet:
4336 4363 ui.warn(_("not found!\n"))
4337 4364 return 1
4338 4365 else:
4339 4366 for name, path in ui.configitems("paths"):
4340 4367 if ui.quiet:
4341 4368 ui.write("%s\n" % name)
4342 4369 else:
4343 4370 ui.write("%s = %s\n" % (name, util.hidepassword(path)))
4344 4371
4345 4372 @command('^phase',
4346 4373 [('p', 'public', False, _('set changeset phase to public')),
4347 4374 ('d', 'draft', False, _('set changeset phase to draft')),
4348 4375 ('s', 'secret', False, _('set changeset phase to secret')),
4349 4376 ('f', 'force', False, _('allow to move boundary backward')),
4350 4377 ('r', 'rev', [], _('target revision'), _('REV')),
4351 4378 ],
4352 4379 _('[-p|-d|-s] [-f] [-r] REV...'))
4353 4380 def phase(ui, repo, *revs, **opts):
4354 4381 """set or show the current phase name
4355 4382
4356 4383 With no argument, show the phase name of specified revisions.
4357 4384
4358 4385 With one of -p/--public, -d/--draft or -s/--secret, change the
4359 4386 phase value of the specified revisions.
4360 4387
4361 4388 Unless -f/--force is specified, :hg:`phase` won't move changeset from a
4362 4389 lower phase to an higher phase. Phases are ordered as follows::
4363 4390
4364 4391 public < draft < secret
4365 4392
4366 4393 Return 0 on success, 1 if no phases were changed or some could not
4367 4394 be changed.
4368 4395 """
4369 4396 # search for a unique phase argument
4370 4397 targetphase = None
4371 4398 for idx, name in enumerate(phases.phasenames):
4372 4399 if opts[name]:
4373 4400 if targetphase is not None:
4374 4401 raise util.Abort(_('only one phase can be specified'))
4375 4402 targetphase = idx
4376 4403
4377 4404 # look for specified revision
4378 4405 revs = list(revs)
4379 4406 revs.extend(opts['rev'])
4380 4407 if not revs:
4381 4408 raise util.Abort(_('no revisions specified'))
4382 4409
4383 4410 revs = scmutil.revrange(repo, revs)
4384 4411
4385 4412 lock = None
4386 4413 ret = 0
4387 4414 if targetphase is None:
4388 4415 # display
4389 4416 for r in revs:
4390 4417 ctx = repo[r]
4391 4418 ui.write('%i: %s\n' % (ctx.rev(), ctx.phasestr()))
4392 4419 else:
4393 4420 lock = repo.lock()
4394 4421 try:
4395 4422 # set phase
4396 4423 if not revs:
4397 4424 raise util.Abort(_('empty revision set'))
4398 4425 nodes = [repo[r].node() for r in revs]
4399 4426 olddata = repo._phasecache.getphaserevs(repo)[:]
4400 4427 phases.advanceboundary(repo, targetphase, nodes)
4401 4428 if opts['force']:
4402 4429 phases.retractboundary(repo, targetphase, nodes)
4403 4430 finally:
4404 4431 lock.release()
4405 4432 if olddata is not None:
4406 4433 changes = 0
4407 4434 newdata = repo._phasecache.getphaserevs(repo)
4408 4435 changes = sum(o != newdata[i] for i, o in enumerate(olddata))
4409 4436 rejected = [n for n in nodes
4410 4437 if newdata[repo[n].rev()] < targetphase]
4411 4438 if rejected:
4412 4439 ui.warn(_('cannot move %i changesets to a more permissive '
4413 4440 'phase, use --force\n') % len(rejected))
4414 4441 ret = 1
4415 4442 if changes:
4416 4443 msg = _('phase changed for %i changesets\n') % changes
4417 4444 if ret:
4418 4445 ui.status(msg)
4419 4446 else:
4420 4447 ui.note(msg)
4421 4448 else:
4422 4449 ui.warn(_('no phases changed\n'))
4423 4450 ret = 1
4424 4451 return ret
4425 4452
4426 4453 def postincoming(ui, repo, modheads, optupdate, checkout):
4427 4454 if modheads == 0:
4428 4455 return
4429 4456 if optupdate:
4430 4457 movemarkfrom = repo['.'].node()
4431 4458 try:
4432 4459 ret = hg.update(repo, checkout)
4433 4460 except util.Abort, inst:
4434 4461 ui.warn(_("not updating: %s\n") % str(inst))
4435 4462 return 0
4436 4463 if not ret and not checkout:
4437 4464 if bookmarks.update(repo, [movemarkfrom], repo['.'].node()):
4438 4465 ui.status(_("updating bookmark %s\n") % repo._bookmarkcurrent)
4439 4466 return ret
4440 4467 if modheads > 1:
4441 4468 currentbranchheads = len(repo.branchheads())
4442 4469 if currentbranchheads == modheads:
4443 4470 ui.status(_("(run 'hg heads' to see heads, 'hg merge' to merge)\n"))
4444 4471 elif currentbranchheads > 1:
4445 4472 ui.status(_("(run 'hg heads .' to see heads, 'hg merge' to "
4446 4473 "merge)\n"))
4447 4474 else:
4448 4475 ui.status(_("(run 'hg heads' to see heads)\n"))
4449 4476 else:
4450 4477 ui.status(_("(run 'hg update' to get a working copy)\n"))
4451 4478
4452 4479 @command('^pull',
4453 4480 [('u', 'update', None,
4454 4481 _('update to new branch head if changesets were pulled')),
4455 4482 ('f', 'force', None, _('run even when remote repository is unrelated')),
4456 4483 ('r', 'rev', [], _('a remote changeset intended to be added'), _('REV')),
4457 4484 ('B', 'bookmark', [], _("bookmark to pull"), _('BOOKMARK')),
4458 4485 ('b', 'branch', [], _('a specific branch you would like to pull'),
4459 4486 _('BRANCH')),
4460 4487 ] + remoteopts,
4461 4488 _('[-u] [-f] [-r REV]... [-e CMD] [--remotecmd CMD] [SOURCE]'))
4462 4489 def pull(ui, repo, source="default", **opts):
4463 4490 """pull changes from the specified source
4464 4491
4465 4492 Pull changes from a remote repository to a local one.
4466 4493
4467 4494 This finds all changes from the repository at the specified path
4468 4495 or URL and adds them to a local repository (the current one unless
4469 4496 -R is specified). By default, this does not update the copy of the
4470 4497 project in the working directory.
4471 4498
4472 4499 Use :hg:`incoming` if you want to see what would have been added
4473 4500 by a pull at the time you issued this command. If you then decide
4474 4501 to add those changes to the repository, you should use :hg:`pull
4475 4502 -r X` where ``X`` is the last changeset listed by :hg:`incoming`.
4476 4503
4477 4504 If SOURCE is omitted, the 'default' path will be used.
4478 4505 See :hg:`help urls` for more information.
4479 4506
4480 4507 Returns 0 on success, 1 if an update had unresolved files.
4481 4508 """
4482 4509 source, branches = hg.parseurl(ui.expandpath(source), opts.get('branch'))
4483 4510 other = hg.peer(repo, opts, source)
4484 4511 ui.status(_('pulling from %s\n') % util.hidepassword(source))
4485 4512 revs, checkout = hg.addbranchrevs(repo, other, branches, opts.get('rev'))
4486 4513
4487 4514 if opts.get('bookmark'):
4488 4515 if not revs:
4489 4516 revs = []
4490 4517 rb = other.listkeys('bookmarks')
4491 4518 for b in opts['bookmark']:
4492 4519 if b not in rb:
4493 4520 raise util.Abort(_('remote bookmark %s not found!') % b)
4494 4521 revs.append(rb[b])
4495 4522
4496 4523 if revs:
4497 4524 try:
4498 4525 revs = [other.lookup(rev) for rev in revs]
4499 4526 except error.CapabilityError:
4500 4527 err = _("other repository doesn't support revision lookup, "
4501 4528 "so a rev cannot be specified.")
4502 4529 raise util.Abort(err)
4503 4530
4504 4531 modheads = repo.pull(other, heads=revs, force=opts.get('force'))
4505 4532 bookmarks.updatefromremote(ui, repo, other, source)
4506 4533 if checkout:
4507 4534 checkout = str(repo.changelog.rev(other.lookup(checkout)))
4508 4535 repo._subtoppath = source
4509 4536 try:
4510 4537 ret = postincoming(ui, repo, modheads, opts.get('update'), checkout)
4511 4538
4512 4539 finally:
4513 4540 del repo._subtoppath
4514 4541
4515 4542 # update specified bookmarks
4516 4543 if opts.get('bookmark'):
4517 4544 for b in opts['bookmark']:
4518 4545 # explicit pull overrides local bookmark if any
4519 4546 ui.status(_("importing bookmark %s\n") % b)
4520 4547 repo._bookmarks[b] = repo[rb[b]].node()
4521 4548 bookmarks.write(repo)
4522 4549
4523 4550 return ret
4524 4551
4525 4552 @command('^push',
4526 4553 [('f', 'force', None, _('force push')),
4527 4554 ('r', 'rev', [],
4528 4555 _('a changeset intended to be included in the destination'),
4529 4556 _('REV')),
4530 4557 ('B', 'bookmark', [], _("bookmark to push"), _('BOOKMARK')),
4531 4558 ('b', 'branch', [],
4532 4559 _('a specific branch you would like to push'), _('BRANCH')),
4533 4560 ('', 'new-branch', False, _('allow pushing a new branch')),
4534 4561 ] + remoteopts,
4535 4562 _('[-f] [-r REV]... [-e CMD] [--remotecmd CMD] [DEST]'))
4536 4563 def push(ui, repo, dest=None, **opts):
4537 4564 """push changes to the specified destination
4538 4565
4539 4566 Push changesets from the local repository to the specified
4540 4567 destination.
4541 4568
4542 4569 This operation is symmetrical to pull: it is identical to a pull
4543 4570 in the destination repository from the current one.
4544 4571
4545 4572 By default, push will not allow creation of new heads at the
4546 4573 destination, since multiple heads would make it unclear which head
4547 4574 to use. In this situation, it is recommended to pull and merge
4548 4575 before pushing.
4549 4576
4550 4577 Use --new-branch if you want to allow push to create a new named
4551 4578 branch that is not present at the destination. This allows you to
4552 4579 only create a new branch without forcing other changes.
4553 4580
4554 4581 Use -f/--force to override the default behavior and push all
4555 4582 changesets on all branches.
4556 4583
4557 4584 If -r/--rev is used, the specified revision and all its ancestors
4558 4585 will be pushed to the remote repository.
4559 4586
4560 4587 Please see :hg:`help urls` for important details about ``ssh://``
4561 4588 URLs. If DESTINATION is omitted, a default path will be used.
4562 4589
4563 4590 Returns 0 if push was successful, 1 if nothing to push.
4564 4591 """
4565 4592
4566 4593 if opts.get('bookmark'):
4567 4594 for b in opts['bookmark']:
4568 4595 # translate -B options to -r so changesets get pushed
4569 4596 if b in repo._bookmarks:
4570 4597 opts.setdefault('rev', []).append(b)
4571 4598 else:
4572 4599 # if we try to push a deleted bookmark, translate it to null
4573 4600 # this lets simultaneous -r, -b options continue working
4574 4601 opts.setdefault('rev', []).append("null")
4575 4602
4576 4603 dest = ui.expandpath(dest or 'default-push', dest or 'default')
4577 4604 dest, branches = hg.parseurl(dest, opts.get('branch'))
4578 4605 ui.status(_('pushing to %s\n') % util.hidepassword(dest))
4579 4606 revs, checkout = hg.addbranchrevs(repo, repo, branches, opts.get('rev'))
4580 4607 other = hg.peer(repo, opts, dest)
4581 4608 if revs:
4582 4609 revs = [repo.lookup(rev) for rev in revs]
4583 4610
4584 4611 repo._subtoppath = dest
4585 4612 try:
4586 4613 # push subrepos depth-first for coherent ordering
4587 4614 c = repo['']
4588 4615 subs = c.substate # only repos that are committed
4589 4616 for s in sorted(subs):
4590 4617 if c.sub(s).push(opts) == 0:
4591 4618 return False
4592 4619 finally:
4593 4620 del repo._subtoppath
4594 4621 result = repo.push(other, opts.get('force'), revs=revs,
4595 4622 newbranch=opts.get('new_branch'))
4596 4623
4597 4624 result = not result
4598 4625
4599 4626 if opts.get('bookmark'):
4600 4627 rb = other.listkeys('bookmarks')
4601 4628 for b in opts['bookmark']:
4602 4629 # explicit push overrides remote bookmark if any
4603 4630 if b in repo._bookmarks:
4604 4631 ui.status(_("exporting bookmark %s\n") % b)
4605 4632 new = repo[b].hex()
4606 4633 elif b in rb:
4607 4634 ui.status(_("deleting remote bookmark %s\n") % b)
4608 4635 new = '' # delete
4609 4636 else:
4610 4637 ui.warn(_('bookmark %s does not exist on the local '
4611 4638 'or remote repository!\n') % b)
4612 4639 return 2
4613 4640 old = rb.get(b, '')
4614 4641 r = other.pushkey('bookmarks', b, old, new)
4615 4642 if not r:
4616 4643 ui.warn(_('updating bookmark %s failed!\n') % b)
4617 4644 if not result:
4618 4645 result = 2
4619 4646
4620 4647 return result
4621 4648
4622 4649 @command('recover', [])
4623 4650 def recover(ui, repo):
4624 4651 """roll back an interrupted transaction
4625 4652
4626 4653 Recover from an interrupted commit or pull.
4627 4654
4628 4655 This command tries to fix the repository status after an
4629 4656 interrupted operation. It should only be necessary when Mercurial
4630 4657 suggests it.
4631 4658
4632 4659 Returns 0 if successful, 1 if nothing to recover or verify fails.
4633 4660 """
4634 4661 if repo.recover():
4635 4662 return hg.verify(repo)
4636 4663 return 1
4637 4664
4638 4665 @command('^remove|rm',
4639 4666 [('A', 'after', None, _('record delete for missing files')),
4640 4667 ('f', 'force', None,
4641 4668 _('remove (and delete) file even if added or modified')),
4642 4669 ] + walkopts,
4643 4670 _('[OPTION]... FILE...'))
4644 4671 def remove(ui, repo, *pats, **opts):
4645 4672 """remove the specified files on the next commit
4646 4673
4647 4674 Schedule the indicated files for removal from the current branch.
4648 4675
4649 4676 This command schedules the files to be removed at the next commit.
4650 4677 To undo a remove before that, see :hg:`revert`. To undo added
4651 4678 files, see :hg:`forget`.
4652 4679
4653 4680 .. container:: verbose
4654 4681
4655 4682 -A/--after can be used to remove only files that have already
4656 4683 been deleted, -f/--force can be used to force deletion, and -Af
4657 4684 can be used to remove files from the next revision without
4658 4685 deleting them from the working directory.
4659 4686
4660 4687 The following table details the behavior of remove for different
4661 4688 file states (columns) and option combinations (rows). The file
4662 4689 states are Added [A], Clean [C], Modified [M] and Missing [!]
4663 4690 (as reported by :hg:`status`). The actions are Warn, Remove
4664 4691 (from branch) and Delete (from disk):
4665 4692
4666 4693 ======= == == == ==
4667 4694 A C M !
4668 4695 ======= == == == ==
4669 4696 none W RD W R
4670 4697 -f R RD RD R
4671 4698 -A W W W R
4672 4699 -Af R R R R
4673 4700 ======= == == == ==
4674 4701
4675 4702 Note that remove never deletes files in Added [A] state from the
4676 4703 working directory, not even if option --force is specified.
4677 4704
4678 4705 Returns 0 on success, 1 if any warnings encountered.
4679 4706 """
4680 4707
4681 4708 ret = 0
4682 4709 after, force = opts.get('after'), opts.get('force')
4683 4710 if not pats and not after:
4684 4711 raise util.Abort(_('no files specified'))
4685 4712
4686 4713 m = scmutil.match(repo[None], pats, opts)
4687 4714 s = repo.status(match=m, clean=True)
4688 4715 modified, added, deleted, clean = s[0], s[1], s[3], s[6]
4689 4716
4690 4717 for f in m.files():
4691 4718 if f not in repo.dirstate and not os.path.isdir(m.rel(f)):
4692 4719 if os.path.exists(m.rel(f)):
4693 4720 ui.warn(_('not removing %s: file is untracked\n') % m.rel(f))
4694 4721 ret = 1
4695 4722
4696 4723 if force:
4697 4724 list = modified + deleted + clean + added
4698 4725 elif after:
4699 4726 list = deleted
4700 4727 for f in modified + added + clean:
4701 4728 ui.warn(_('not removing %s: file still exists (use -f'
4702 4729 ' to force removal)\n') % m.rel(f))
4703 4730 ret = 1
4704 4731 else:
4705 4732 list = deleted + clean
4706 4733 for f in modified:
4707 4734 ui.warn(_('not removing %s: file is modified (use -f'
4708 4735 ' to force removal)\n') % m.rel(f))
4709 4736 ret = 1
4710 4737 for f in added:
4711 4738 ui.warn(_('not removing %s: file has been marked for add'
4712 4739 ' (use forget to undo)\n') % m.rel(f))
4713 4740 ret = 1
4714 4741
4715 4742 for f in sorted(list):
4716 4743 if ui.verbose or not m.exact(f):
4717 4744 ui.status(_('removing %s\n') % m.rel(f))
4718 4745
4719 4746 wlock = repo.wlock()
4720 4747 try:
4721 4748 if not after:
4722 4749 for f in list:
4723 4750 if f in added:
4724 4751 continue # we never unlink added files on remove
4725 4752 try:
4726 4753 util.unlinkpath(repo.wjoin(f))
4727 4754 except OSError, inst:
4728 4755 if inst.errno != errno.ENOENT:
4729 4756 raise
4730 4757 repo[None].forget(list)
4731 4758 finally:
4732 4759 wlock.release()
4733 4760
4734 4761 return ret
4735 4762
4736 4763 @command('rename|move|mv',
4737 4764 [('A', 'after', None, _('record a rename that has already occurred')),
4738 4765 ('f', 'force', None, _('forcibly copy over an existing managed file')),
4739 4766 ] + walkopts + dryrunopts,
4740 4767 _('[OPTION]... SOURCE... DEST'))
4741 4768 def rename(ui, repo, *pats, **opts):
4742 4769 """rename files; equivalent of copy + remove
4743 4770
4744 4771 Mark dest as copies of sources; mark sources for deletion. If dest
4745 4772 is a directory, copies are put in that directory. If dest is a
4746 4773 file, there can only be one source.
4747 4774
4748 4775 By default, this command copies the contents of files as they
4749 4776 exist in the working directory. If invoked with -A/--after, the
4750 4777 operation is recorded, but no copying is performed.
4751 4778
4752 4779 This command takes effect at the next commit. To undo a rename
4753 4780 before that, see :hg:`revert`.
4754 4781
4755 4782 Returns 0 on success, 1 if errors are encountered.
4756 4783 """
4757 4784 wlock = repo.wlock(False)
4758 4785 try:
4759 4786 return cmdutil.copy(ui, repo, pats, opts, rename=True)
4760 4787 finally:
4761 4788 wlock.release()
4762 4789
4763 4790 @command('resolve',
4764 4791 [('a', 'all', None, _('select all unresolved files')),
4765 4792 ('l', 'list', None, _('list state of files needing merge')),
4766 4793 ('m', 'mark', None, _('mark files as resolved')),
4767 4794 ('u', 'unmark', None, _('mark files as unresolved')),
4768 4795 ('n', 'no-status', None, _('hide status prefix'))]
4769 4796 + mergetoolopts + walkopts,
4770 4797 _('[OPTION]... [FILE]...'))
4771 4798 def resolve(ui, repo, *pats, **opts):
4772 4799 """redo merges or set/view the merge status of files
4773 4800
4774 4801 Merges with unresolved conflicts are often the result of
4775 4802 non-interactive merging using the ``internal:merge`` configuration
4776 4803 setting, or a command-line merge tool like ``diff3``. The resolve
4777 4804 command is used to manage the files involved in a merge, after
4778 4805 :hg:`merge` has been run, and before :hg:`commit` is run (i.e. the
4779 4806 working directory must have two parents). See :hg:`help
4780 4807 merge-tools` for information on configuring merge tools.
4781 4808
4782 4809 The resolve command can be used in the following ways:
4783 4810
4784 4811 - :hg:`resolve [--tool TOOL] FILE...`: attempt to re-merge the specified
4785 4812 files, discarding any previous merge attempts. Re-merging is not
4786 4813 performed for files already marked as resolved. Use ``--all/-a``
4787 4814 to select all unresolved files. ``--tool`` can be used to specify
4788 4815 the merge tool used for the given files. It overrides the HGMERGE
4789 4816 environment variable and your configuration files. Previous file
4790 4817 contents are saved with a ``.orig`` suffix.
4791 4818
4792 4819 - :hg:`resolve -m [FILE]`: mark a file as having been resolved
4793 4820 (e.g. after having manually fixed-up the files). The default is
4794 4821 to mark all unresolved files.
4795 4822
4796 4823 - :hg:`resolve -u [FILE]...`: mark a file as unresolved. The
4797 4824 default is to mark all resolved files.
4798 4825
4799 4826 - :hg:`resolve -l`: list files which had or still have conflicts.
4800 4827 In the printed list, ``U`` = unresolved and ``R`` = resolved.
4801 4828
4802 4829 Note that Mercurial will not let you commit files with unresolved
4803 4830 merge conflicts. You must use :hg:`resolve -m ...` before you can
4804 4831 commit after a conflicting merge.
4805 4832
4806 4833 Returns 0 on success, 1 if any files fail a resolve attempt.
4807 4834 """
4808 4835
4809 4836 all, mark, unmark, show, nostatus = \
4810 4837 [opts.get(o) for o in 'all mark unmark list no_status'.split()]
4811 4838
4812 4839 if (show and (mark or unmark)) or (mark and unmark):
4813 4840 raise util.Abort(_("too many options specified"))
4814 4841 if pats and all:
4815 4842 raise util.Abort(_("can't specify --all and patterns"))
4816 4843 if not (all or pats or show or mark or unmark):
4817 4844 raise util.Abort(_('no files or directories specified; '
4818 4845 'use --all to remerge all files'))
4819 4846
4820 4847 ms = mergemod.mergestate(repo)
4821 4848 m = scmutil.match(repo[None], pats, opts)
4822 4849 ret = 0
4823 4850
4824 4851 for f in ms:
4825 4852 if m(f):
4826 4853 if show:
4827 4854 if nostatus:
4828 4855 ui.write("%s\n" % f)
4829 4856 else:
4830 4857 ui.write("%s %s\n" % (ms[f].upper(), f),
4831 4858 label='resolve.' +
4832 4859 {'u': 'unresolved', 'r': 'resolved'}[ms[f]])
4833 4860 elif mark:
4834 4861 ms.mark(f, "r")
4835 4862 elif unmark:
4836 4863 ms.mark(f, "u")
4837 4864 else:
4838 4865 wctx = repo[None]
4839 4866 mctx = wctx.parents()[-1]
4840 4867
4841 4868 # backup pre-resolve (merge uses .orig for its own purposes)
4842 4869 a = repo.wjoin(f)
4843 4870 util.copyfile(a, a + ".resolve")
4844 4871
4845 4872 try:
4846 4873 # resolve file
4847 4874 ui.setconfig('ui', 'forcemerge', opts.get('tool', ''))
4848 4875 if ms.resolve(f, wctx, mctx):
4849 4876 ret = 1
4850 4877 finally:
4851 4878 ui.setconfig('ui', 'forcemerge', '')
4852 4879
4853 4880 # replace filemerge's .orig file with our resolve file
4854 4881 util.rename(a + ".resolve", a + ".orig")
4855 4882
4856 4883 ms.commit()
4857 4884 return ret
4858 4885
4859 4886 @command('revert',
4860 4887 [('a', 'all', None, _('revert all changes when no arguments given')),
4861 4888 ('d', 'date', '', _('tipmost revision matching date'), _('DATE')),
4862 4889 ('r', 'rev', '', _('revert to the specified revision'), _('REV')),
4863 4890 ('C', 'no-backup', None, _('do not save backup copies of files')),
4864 4891 ] + walkopts + dryrunopts,
4865 4892 _('[OPTION]... [-r REV] [NAME]...'))
4866 4893 def revert(ui, repo, *pats, **opts):
4867 4894 """restore files to their checkout state
4868 4895
4869 4896 .. note::
4870 4897 To check out earlier revisions, you should use :hg:`update REV`.
4871 4898 To cancel a merge (and lose your changes), use :hg:`update --clean .`.
4872 4899
4873 4900 With no revision specified, revert the specified files or directories
4874 4901 to the contents they had in the parent of the working directory.
4875 4902 This restores the contents of files to an unmodified
4876 4903 state and unschedules adds, removes, copies, and renames. If the
4877 4904 working directory has two parents, you must explicitly specify a
4878 4905 revision.
4879 4906
4880 4907 Using the -r/--rev or -d/--date options, revert the given files or
4881 4908 directories to their states as of a specific revision. Because
4882 4909 revert does not change the working directory parents, this will
4883 4910 cause these files to appear modified. This can be helpful to "back
4884 4911 out" some or all of an earlier change. See :hg:`backout` for a
4885 4912 related method.
4886 4913
4887 4914 Modified files are saved with a .orig suffix before reverting.
4888 4915 To disable these backups, use --no-backup.
4889 4916
4890 4917 See :hg:`help dates` for a list of formats valid for -d/--date.
4891 4918
4892 4919 Returns 0 on success.
4893 4920 """
4894 4921
4895 4922 if opts.get("date"):
4896 4923 if opts.get("rev"):
4897 4924 raise util.Abort(_("you can't specify a revision and a date"))
4898 4925 opts["rev"] = cmdutil.finddate(ui, repo, opts["date"])
4899 4926
4900 4927 parent, p2 = repo.dirstate.parents()
4901 4928 if not opts.get('rev') and p2 != nullid:
4902 4929 # revert after merge is a trap for new users (issue2915)
4903 4930 raise util.Abort(_('uncommitted merge with no revision specified'),
4904 4931 hint=_('use "hg update" or see "hg help revert"'))
4905 4932
4906 4933 ctx = scmutil.revsingle(repo, opts.get('rev'))
4907 4934
4908 4935 if not pats and not opts.get('all'):
4909 4936 msg = _("no files or directories specified")
4910 4937 if p2 != nullid:
4911 4938 hint = _("uncommitted merge, use --all to discard all changes,"
4912 4939 " or 'hg update -C .' to abort the merge")
4913 4940 raise util.Abort(msg, hint=hint)
4914 4941 dirty = util.any(repo.status())
4915 4942 node = ctx.node()
4916 4943 if node != parent:
4917 4944 if dirty:
4918 4945 hint = _("uncommitted changes, use --all to discard all"
4919 4946 " changes, or 'hg update %s' to update") % ctx.rev()
4920 4947 else:
4921 4948 hint = _("use --all to revert all files,"
4922 4949 " or 'hg update %s' to update") % ctx.rev()
4923 4950 elif dirty:
4924 4951 hint = _("uncommitted changes, use --all to discard all changes")
4925 4952 else:
4926 4953 hint = _("use --all to revert all files")
4927 4954 raise util.Abort(msg, hint=hint)
4928 4955
4929 4956 return cmdutil.revert(ui, repo, ctx, (parent, p2), *pats, **opts)
4930 4957
4931 4958 @command('rollback', dryrunopts +
4932 4959 [('f', 'force', False, _('ignore safety measures'))])
4933 4960 def rollback(ui, repo, **opts):
4934 4961 """roll back the last transaction (dangerous)
4935 4962
4936 4963 This command should be used with care. There is only one level of
4937 4964 rollback, and there is no way to undo a rollback. It will also
4938 4965 restore the dirstate at the time of the last transaction, losing
4939 4966 any dirstate changes since that time. This command does not alter
4940 4967 the working directory.
4941 4968
4942 4969 Transactions are used to encapsulate the effects of all commands
4943 4970 that create new changesets or propagate existing changesets into a
4944 4971 repository. For example, the following commands are transactional,
4945 4972 and their effects can be rolled back:
4946 4973
4947 4974 - commit
4948 4975 - import
4949 4976 - pull
4950 4977 - push (with this repository as the destination)
4951 4978 - unbundle
4952 4979
4953 4980 To avoid permanent data loss, rollback will refuse to rollback a
4954 4981 commit transaction if it isn't checked out. Use --force to
4955 4982 override this protection.
4956 4983
4957 4984 This command is not intended for use on public repositories. Once
4958 4985 changes are visible for pull by other users, rolling a transaction
4959 4986 back locally is ineffective (someone else may already have pulled
4960 4987 the changes). Furthermore, a race is possible with readers of the
4961 4988 repository; for example an in-progress pull from the repository
4962 4989 may fail if a rollback is performed.
4963 4990
4964 4991 Returns 0 on success, 1 if no rollback data is available.
4965 4992 """
4966 4993 return repo.rollback(dryrun=opts.get('dry_run'),
4967 4994 force=opts.get('force'))
4968 4995
4969 4996 @command('root', [])
4970 4997 def root(ui, repo):
4971 4998 """print the root (top) of the current working directory
4972 4999
4973 5000 Print the root directory of the current repository.
4974 5001
4975 5002 Returns 0 on success.
4976 5003 """
4977 5004 ui.write(repo.root + "\n")
4978 5005
4979 5006 @command('^serve',
4980 5007 [('A', 'accesslog', '', _('name of access log file to write to'),
4981 5008 _('FILE')),
4982 5009 ('d', 'daemon', None, _('run server in background')),
4983 5010 ('', 'daemon-pipefds', '', _('used internally by daemon mode'), _('NUM')),
4984 5011 ('E', 'errorlog', '', _('name of error log file to write to'), _('FILE')),
4985 5012 # use string type, then we can check if something was passed
4986 5013 ('p', 'port', '', _('port to listen on (default: 8000)'), _('PORT')),
4987 5014 ('a', 'address', '', _('address to listen on (default: all interfaces)'),
4988 5015 _('ADDR')),
4989 5016 ('', 'prefix', '', _('prefix path to serve from (default: server root)'),
4990 5017 _('PREFIX')),
4991 5018 ('n', 'name', '',
4992 5019 _('name to show in web pages (default: working directory)'), _('NAME')),
4993 5020 ('', 'web-conf', '',
4994 5021 _('name of the hgweb config file (see "hg help hgweb")'), _('FILE')),
4995 5022 ('', 'webdir-conf', '', _('name of the hgweb config file (DEPRECATED)'),
4996 5023 _('FILE')),
4997 5024 ('', 'pid-file', '', _('name of file to write process ID to'), _('FILE')),
4998 5025 ('', 'stdio', None, _('for remote clients')),
4999 5026 ('', 'cmdserver', '', _('for remote clients'), _('MODE')),
5000 5027 ('t', 'templates', '', _('web templates to use'), _('TEMPLATE')),
5001 5028 ('', 'style', '', _('template style to use'), _('STYLE')),
5002 5029 ('6', 'ipv6', None, _('use IPv6 in addition to IPv4')),
5003 5030 ('', 'certificate', '', _('SSL certificate file'), _('FILE'))],
5004 5031 _('[OPTION]...'))
5005 5032 def serve(ui, repo, **opts):
5006 5033 """start stand-alone webserver
5007 5034
5008 5035 Start a local HTTP repository browser and pull server. You can use
5009 5036 this for ad-hoc sharing and browsing of repositories. It is
5010 5037 recommended to use a real web server to serve a repository for
5011 5038 longer periods of time.
5012 5039
5013 5040 Please note that the server does not implement access control.
5014 5041 This means that, by default, anybody can read from the server and
5015 5042 nobody can write to it by default. Set the ``web.allow_push``
5016 5043 option to ``*`` to allow everybody to push to the server. You
5017 5044 should use a real web server if you need to authenticate users.
5018 5045
5019 5046 By default, the server logs accesses to stdout and errors to
5020 5047 stderr. Use the -A/--accesslog and -E/--errorlog options to log to
5021 5048 files.
5022 5049
5023 5050 To have the server choose a free port number to listen on, specify
5024 5051 a port number of 0; in this case, the server will print the port
5025 5052 number it uses.
5026 5053
5027 5054 Returns 0 on success.
5028 5055 """
5029 5056
5030 5057 if opts["stdio"] and opts["cmdserver"]:
5031 5058 raise util.Abort(_("cannot use --stdio with --cmdserver"))
5032 5059
5033 5060 def checkrepo():
5034 5061 if repo is None:
5035 5062 raise error.RepoError(_("There is no Mercurial repository here"
5036 5063 " (.hg not found)"))
5037 5064
5038 5065 if opts["stdio"]:
5039 5066 checkrepo()
5040 5067 s = sshserver.sshserver(ui, repo)
5041 5068 s.serve_forever()
5042 5069
5043 5070 if opts["cmdserver"]:
5044 5071 checkrepo()
5045 5072 s = commandserver.server(ui, repo, opts["cmdserver"])
5046 5073 return s.serve()
5047 5074
5048 5075 # this way we can check if something was given in the command-line
5049 5076 if opts.get('port'):
5050 5077 opts['port'] = util.getport(opts.get('port'))
5051 5078
5052 5079 baseui = repo and repo.baseui or ui
5053 5080 optlist = ("name templates style address port prefix ipv6"
5054 5081 " accesslog errorlog certificate encoding")
5055 5082 for o in optlist.split():
5056 5083 val = opts.get(o, '')
5057 5084 if val in (None, ''): # should check against default options instead
5058 5085 continue
5059 5086 baseui.setconfig("web", o, val)
5060 5087 if repo and repo.ui != baseui:
5061 5088 repo.ui.setconfig("web", o, val)
5062 5089
5063 5090 o = opts.get('web_conf') or opts.get('webdir_conf')
5064 5091 if not o:
5065 5092 if not repo:
5066 5093 raise error.RepoError(_("There is no Mercurial repository"
5067 5094 " here (.hg not found)"))
5068 5095 o = repo.root
5069 5096
5070 5097 app = hgweb.hgweb(o, baseui=ui)
5071 5098
5072 5099 class service(object):
5073 5100 def init(self):
5074 5101 util.setsignalhandler()
5075 5102 self.httpd = hgweb.server.create_server(ui, app)
5076 5103
5077 5104 if opts['port'] and not ui.verbose:
5078 5105 return
5079 5106
5080 5107 if self.httpd.prefix:
5081 5108 prefix = self.httpd.prefix.strip('/') + '/'
5082 5109 else:
5083 5110 prefix = ''
5084 5111
5085 5112 port = ':%d' % self.httpd.port
5086 5113 if port == ':80':
5087 5114 port = ''
5088 5115
5089 5116 bindaddr = self.httpd.addr
5090 5117 if bindaddr == '0.0.0.0':
5091 5118 bindaddr = '*'
5092 5119 elif ':' in bindaddr: # IPv6
5093 5120 bindaddr = '[%s]' % bindaddr
5094 5121
5095 5122 fqaddr = self.httpd.fqaddr
5096 5123 if ':' in fqaddr:
5097 5124 fqaddr = '[%s]' % fqaddr
5098 5125 if opts['port']:
5099 5126 write = ui.status
5100 5127 else:
5101 5128 write = ui.write
5102 5129 write(_('listening at http://%s%s/%s (bound to %s:%d)\n') %
5103 5130 (fqaddr, port, prefix, bindaddr, self.httpd.port))
5104 5131
5105 5132 def run(self):
5106 5133 self.httpd.serve_forever()
5107 5134
5108 5135 service = service()
5109 5136
5110 5137 cmdutil.service(opts, initfn=service.init, runfn=service.run)
5111 5138
5112 5139 @command('showconfig|debugconfig',
5113 5140 [('u', 'untrusted', None, _('show untrusted configuration options'))],
5114 5141 _('[-u] [NAME]...'))
5115 5142 def showconfig(ui, repo, *values, **opts):
5116 5143 """show combined config settings from all hgrc files
5117 5144
5118 5145 With no arguments, print names and values of all config items.
5119 5146
5120 5147 With one argument of the form section.name, print just the value
5121 5148 of that config item.
5122 5149
5123 5150 With multiple arguments, print names and values of all config
5124 5151 items with matching section names.
5125 5152
5126 5153 With --debug, the source (filename and line number) is printed
5127 5154 for each config item.
5128 5155
5129 5156 Returns 0 on success.
5130 5157 """
5131 5158
5132 5159 for f in scmutil.rcpath():
5133 5160 ui.debug('read config from: %s\n' % f)
5134 5161 untrusted = bool(opts.get('untrusted'))
5135 5162 if values:
5136 5163 sections = [v for v in values if '.' not in v]
5137 5164 items = [v for v in values if '.' in v]
5138 5165 if len(items) > 1 or items and sections:
5139 5166 raise util.Abort(_('only one config item permitted'))
5140 5167 for section, name, value in ui.walkconfig(untrusted=untrusted):
5141 5168 value = str(value).replace('\n', '\\n')
5142 5169 sectname = section + '.' + name
5143 5170 if values:
5144 5171 for v in values:
5145 5172 if v == section:
5146 5173 ui.debug('%s: ' %
5147 5174 ui.configsource(section, name, untrusted))
5148 5175 ui.write('%s=%s\n' % (sectname, value))
5149 5176 elif v == sectname:
5150 5177 ui.debug('%s: ' %
5151 5178 ui.configsource(section, name, untrusted))
5152 5179 ui.write(value, '\n')
5153 5180 else:
5154 5181 ui.debug('%s: ' %
5155 5182 ui.configsource(section, name, untrusted))
5156 5183 ui.write('%s=%s\n' % (sectname, value))
5157 5184
5158 5185 @command('^status|st',
5159 5186 [('A', 'all', None, _('show status of all files')),
5160 5187 ('m', 'modified', None, _('show only modified files')),
5161 5188 ('a', 'added', None, _('show only added files')),
5162 5189 ('r', 'removed', None, _('show only removed files')),
5163 5190 ('d', 'deleted', None, _('show only deleted (but tracked) files')),
5164 5191 ('c', 'clean', None, _('show only files without changes')),
5165 5192 ('u', 'unknown', None, _('show only unknown (not tracked) files')),
5166 5193 ('i', 'ignored', None, _('show only ignored files')),
5167 5194 ('n', 'no-status', None, _('hide status prefix')),
5168 5195 ('C', 'copies', None, _('show source of copied files')),
5169 5196 ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
5170 5197 ('', 'rev', [], _('show difference from revision'), _('REV')),
5171 5198 ('', 'change', '', _('list the changed files of a revision'), _('REV')),
5172 5199 ] + walkopts + subrepoopts,
5173 5200 _('[OPTION]... [FILE]...'))
5174 5201 def status(ui, repo, *pats, **opts):
5175 5202 """show changed files in the working directory
5176 5203
5177 5204 Show status of files in the repository. If names are given, only
5178 5205 files that match are shown. Files that are clean or ignored or
5179 5206 the source of a copy/move operation, are not listed unless
5180 5207 -c/--clean, -i/--ignored, -C/--copies or -A/--all are given.
5181 5208 Unless options described with "show only ..." are given, the
5182 5209 options -mardu are used.
5183 5210
5184 5211 Option -q/--quiet hides untracked (unknown and ignored) files
5185 5212 unless explicitly requested with -u/--unknown or -i/--ignored.
5186 5213
5187 5214 .. note::
5188 5215 status may appear to disagree with diff if permissions have
5189 5216 changed or a merge has occurred. The standard diff format does
5190 5217 not report permission changes and diff only reports changes
5191 5218 relative to one merge parent.
5192 5219
5193 5220 If one revision is given, it is used as the base revision.
5194 5221 If two revisions are given, the differences between them are
5195 5222 shown. The --change option can also be used as a shortcut to list
5196 5223 the changed files of a revision from its first parent.
5197 5224
5198 5225 The codes used to show the status of files are::
5199 5226
5200 5227 M = modified
5201 5228 A = added
5202 5229 R = removed
5203 5230 C = clean
5204 5231 ! = missing (deleted by non-hg command, but still tracked)
5205 5232 ? = not tracked
5206 5233 I = ignored
5207 5234 = origin of the previous file listed as A (added)
5208 5235
5209 5236 .. container:: verbose
5210 5237
5211 5238 Examples:
5212 5239
5213 5240 - show changes in the working directory relative to a
5214 5241 changeset::
5215 5242
5216 5243 hg status --rev 9353
5217 5244
5218 5245 - show all changes including copies in an existing changeset::
5219 5246
5220 5247 hg status --copies --change 9353
5221 5248
5222 5249 - get a NUL separated list of added files, suitable for xargs::
5223 5250
5224 5251 hg status -an0
5225 5252
5226 5253 Returns 0 on success.
5227 5254 """
5228 5255
5229 5256 revs = opts.get('rev')
5230 5257 change = opts.get('change')
5231 5258
5232 5259 if revs and change:
5233 5260 msg = _('cannot specify --rev and --change at the same time')
5234 5261 raise util.Abort(msg)
5235 5262 elif change:
5236 5263 node2 = scmutil.revsingle(repo, change, None).node()
5237 5264 node1 = repo[node2].p1().node()
5238 5265 else:
5239 5266 node1, node2 = scmutil.revpair(repo, revs)
5240 5267
5241 5268 cwd = (pats and repo.getcwd()) or ''
5242 5269 end = opts.get('print0') and '\0' or '\n'
5243 5270 copy = {}
5244 5271 states = 'modified added removed deleted unknown ignored clean'.split()
5245 5272 show = [k for k in states if opts.get(k)]
5246 5273 if opts.get('all'):
5247 5274 show += ui.quiet and (states[:4] + ['clean']) or states
5248 5275 if not show:
5249 5276 show = ui.quiet and states[:4] or states[:5]
5250 5277
5251 5278 stat = repo.status(node1, node2, scmutil.match(repo[node2], pats, opts),
5252 5279 'ignored' in show, 'clean' in show, 'unknown' in show,
5253 5280 opts.get('subrepos'))
5254 5281 changestates = zip(states, 'MAR!?IC', stat)
5255 5282
5256 5283 if (opts.get('all') or opts.get('copies')) and not opts.get('no_status'):
5257 5284 copy = copies.pathcopies(repo[node1], repo[node2])
5258 5285
5259 5286 fm = ui.formatter('status', opts)
5260 5287 format = '%s %s' + end
5261 5288 if opts.get('no_status'):
5262 5289 format = '%.0s%s' + end
5263 5290
5264 5291 for state, char, files in changestates:
5265 5292 if state in show:
5266 5293 label = 'status.' + state
5267 5294 for f in files:
5268 5295 fm.startitem()
5269 5296 fm.write("status path", format, char,
5270 5297 repo.pathto(f, cwd), label=label)
5271 5298 if f in copy:
5272 5299 fm.write("copy", ' %s' + end, repo.pathto(copy[f], cwd),
5273 5300 label='status.copied')
5274 5301 fm.end()
5275 5302
5276 5303 @command('^summary|sum',
5277 5304 [('', 'remote', None, _('check for push and pull'))], '[--remote]')
5278 5305 def summary(ui, repo, **opts):
5279 5306 """summarize working directory state
5280 5307
5281 5308 This generates a brief summary of the working directory state,
5282 5309 including parents, branch, commit status, and available updates.
5283 5310
5284 5311 With the --remote option, this will check the default paths for
5285 5312 incoming and outgoing changes. This can be time-consuming.
5286 5313
5287 5314 Returns 0 on success.
5288 5315 """
5289 5316
5290 5317 ctx = repo[None]
5291 5318 parents = ctx.parents()
5292 5319 pnode = parents[0].node()
5293 5320 marks = []
5294 5321
5295 5322 for p in parents:
5296 5323 # label with log.changeset (instead of log.parent) since this
5297 5324 # shows a working directory parent *changeset*:
5298 5325 ui.write(_('parent: %d:%s ') % (p.rev(), str(p)),
5299 5326 label='log.changeset')
5300 5327 ui.write(' '.join(p.tags()), label='log.tag')
5301 5328 if p.bookmarks():
5302 5329 marks.extend(p.bookmarks())
5303 5330 if p.rev() == -1:
5304 5331 if not len(repo):
5305 5332 ui.write(_(' (empty repository)'))
5306 5333 else:
5307 5334 ui.write(_(' (no revision checked out)'))
5308 5335 ui.write('\n')
5309 5336 if p.description():
5310 5337 ui.status(' ' + p.description().splitlines()[0].strip() + '\n',
5311 5338 label='log.summary')
5312 5339
5313 5340 branch = ctx.branch()
5314 5341 bheads = repo.branchheads(branch)
5315 5342 m = _('branch: %s\n') % branch
5316 5343 if branch != 'default':
5317 5344 ui.write(m, label='log.branch')
5318 5345 else:
5319 5346 ui.status(m, label='log.branch')
5320 5347
5321 5348 if marks:
5322 5349 current = repo._bookmarkcurrent
5323 5350 ui.write(_('bookmarks:'), label='log.bookmark')
5324 5351 if current is not None:
5325 5352 try:
5326 5353 marks.remove(current)
5327 5354 ui.write(' *' + current, label='bookmarks.current')
5328 5355 except ValueError:
5329 5356 # current bookmark not in parent ctx marks
5330 5357 pass
5331 5358 for m in marks:
5332 5359 ui.write(' ' + m, label='log.bookmark')
5333 5360 ui.write('\n', label='log.bookmark')
5334 5361
5335 5362 st = list(repo.status(unknown=True))[:6]
5336 5363
5337 5364 c = repo.dirstate.copies()
5338 5365 copied, renamed = [], []
5339 5366 for d, s in c.iteritems():
5340 5367 if s in st[2]:
5341 5368 st[2].remove(s)
5342 5369 renamed.append(d)
5343 5370 else:
5344 5371 copied.append(d)
5345 5372 if d in st[1]:
5346 5373 st[1].remove(d)
5347 5374 st.insert(3, renamed)
5348 5375 st.insert(4, copied)
5349 5376
5350 5377 ms = mergemod.mergestate(repo)
5351 5378 st.append([f for f in ms if ms[f] == 'u'])
5352 5379
5353 5380 subs = [s for s in ctx.substate if ctx.sub(s).dirty()]
5354 5381 st.append(subs)
5355 5382
5356 5383 labels = [ui.label(_('%d modified'), 'status.modified'),
5357 5384 ui.label(_('%d added'), 'status.added'),
5358 5385 ui.label(_('%d removed'), 'status.removed'),
5359 5386 ui.label(_('%d renamed'), 'status.copied'),
5360 5387 ui.label(_('%d copied'), 'status.copied'),
5361 5388 ui.label(_('%d deleted'), 'status.deleted'),
5362 5389 ui.label(_('%d unknown'), 'status.unknown'),
5363 5390 ui.label(_('%d ignored'), 'status.ignored'),
5364 5391 ui.label(_('%d unresolved'), 'resolve.unresolved'),
5365 5392 ui.label(_('%d subrepos'), 'status.modified')]
5366 5393 t = []
5367 5394 for s, l in zip(st, labels):
5368 5395 if s:
5369 5396 t.append(l % len(s))
5370 5397
5371 5398 t = ', '.join(t)
5372 5399 cleanworkdir = False
5373 5400
5374 5401 if len(parents) > 1:
5375 5402 t += _(' (merge)')
5376 5403 elif branch != parents[0].branch():
5377 5404 t += _(' (new branch)')
5378 5405 elif (parents[0].extra().get('close') and
5379 5406 pnode in repo.branchheads(branch, closed=True)):
5380 5407 t += _(' (head closed)')
5381 5408 elif not (st[0] or st[1] or st[2] or st[3] or st[4] or st[9]):
5382 5409 t += _(' (clean)')
5383 5410 cleanworkdir = True
5384 5411 elif pnode not in bheads:
5385 5412 t += _(' (new branch head)')
5386 5413
5387 5414 if cleanworkdir:
5388 5415 ui.status(_('commit: %s\n') % t.strip())
5389 5416 else:
5390 5417 ui.write(_('commit: %s\n') % t.strip())
5391 5418
5392 5419 # all ancestors of branch heads - all ancestors of parent = new csets
5393 5420 new = [0] * len(repo)
5394 5421 cl = repo.changelog
5395 5422 for a in [cl.rev(n) for n in bheads]:
5396 5423 new[a] = 1
5397 5424 for a in cl.ancestors(*[cl.rev(n) for n in bheads]):
5398 5425 new[a] = 1
5399 5426 for a in [p.rev() for p in parents]:
5400 5427 if a >= 0:
5401 5428 new[a] = 0
5402 5429 for a in cl.ancestors(*[p.rev() for p in parents]):
5403 5430 new[a] = 0
5404 5431 new = sum(new)
5405 5432
5406 5433 if new == 0:
5407 5434 ui.status(_('update: (current)\n'))
5408 5435 elif pnode not in bheads:
5409 5436 ui.write(_('update: %d new changesets (update)\n') % new)
5410 5437 else:
5411 5438 ui.write(_('update: %d new changesets, %d branch heads (merge)\n') %
5412 5439 (new, len(bheads)))
5413 5440
5414 5441 if opts.get('remote'):
5415 5442 t = []
5416 5443 source, branches = hg.parseurl(ui.expandpath('default'))
5417 5444 other = hg.peer(repo, {}, source)
5418 5445 revs, checkout = hg.addbranchrevs(repo, other, branches,
5419 5446 opts.get('rev'))
5420 5447 ui.debug('comparing with %s\n' % util.hidepassword(source))
5421 5448 repo.ui.pushbuffer()
5422 5449 commoninc = discovery.findcommonincoming(repo, other)
5423 5450 _common, incoming, _rheads = commoninc
5424 5451 repo.ui.popbuffer()
5425 5452 if incoming:
5426 5453 t.append(_('1 or more incoming'))
5427 5454
5428 5455 dest, branches = hg.parseurl(ui.expandpath('default-push', 'default'))
5429 5456 revs, checkout = hg.addbranchrevs(repo, repo, branches, None)
5430 5457 if source != dest:
5431 5458 other = hg.peer(repo, {}, dest)
5432 5459 commoninc = None
5433 5460 ui.debug('comparing with %s\n' % util.hidepassword(dest))
5434 5461 repo.ui.pushbuffer()
5435 5462 outgoing = discovery.findcommonoutgoing(repo, other,
5436 5463 commoninc=commoninc)
5437 5464 repo.ui.popbuffer()
5438 5465 o = outgoing.missing
5439 5466 if o:
5440 5467 t.append(_('%d outgoing') % len(o))
5441 5468 if 'bookmarks' in other.listkeys('namespaces'):
5442 5469 lmarks = repo.listkeys('bookmarks')
5443 5470 rmarks = other.listkeys('bookmarks')
5444 5471 diff = set(rmarks) - set(lmarks)
5445 5472 if len(diff) > 0:
5446 5473 t.append(_('%d incoming bookmarks') % len(diff))
5447 5474 diff = set(lmarks) - set(rmarks)
5448 5475 if len(diff) > 0:
5449 5476 t.append(_('%d outgoing bookmarks') % len(diff))
5450 5477
5451 5478 if t:
5452 5479 ui.write(_('remote: %s\n') % (', '.join(t)))
5453 5480 else:
5454 5481 ui.status(_('remote: (synced)\n'))
5455 5482
5456 5483 @command('tag',
5457 5484 [('f', 'force', None, _('force tag')),
5458 5485 ('l', 'local', None, _('make the tag local')),
5459 5486 ('r', 'rev', '', _('revision to tag'), _('REV')),
5460 5487 ('', 'remove', None, _('remove a tag')),
5461 5488 # -l/--local is already there, commitopts cannot be used
5462 5489 ('e', 'edit', None, _('edit commit message')),
5463 5490 ('m', 'message', '', _('use <text> as commit message'), _('TEXT')),
5464 5491 ] + commitopts2,
5465 5492 _('[-f] [-l] [-m TEXT] [-d DATE] [-u USER] [-r REV] NAME...'))
5466 5493 def tag(ui, repo, name1, *names, **opts):
5467 5494 """add one or more tags for the current or given revision
5468 5495
5469 5496 Name a particular revision using <name>.
5470 5497
5471 5498 Tags are used to name particular revisions of the repository and are
5472 5499 very useful to compare different revisions, to go back to significant
5473 5500 earlier versions or to mark branch points as releases, etc. Changing
5474 5501 an existing tag is normally disallowed; use -f/--force to override.
5475 5502
5476 5503 If no revision is given, the parent of the working directory is
5477 5504 used, or tip if no revision is checked out.
5478 5505
5479 5506 To facilitate version control, distribution, and merging of tags,
5480 5507 they are stored as a file named ".hgtags" which is managed similarly
5481 5508 to other project files and can be hand-edited if necessary. This
5482 5509 also means that tagging creates a new commit. The file
5483 5510 ".hg/localtags" is used for local tags (not shared among
5484 5511 repositories).
5485 5512
5486 5513 Tag commits are usually made at the head of a branch. If the parent
5487 5514 of the working directory is not a branch head, :hg:`tag` aborts; use
5488 5515 -f/--force to force the tag commit to be based on a non-head
5489 5516 changeset.
5490 5517
5491 5518 See :hg:`help dates` for a list of formats valid for -d/--date.
5492 5519
5493 5520 Since tag names have priority over branch names during revision
5494 5521 lookup, using an existing branch name as a tag name is discouraged.
5495 5522
5496 5523 Returns 0 on success.
5497 5524 """
5498 5525 wlock = lock = None
5499 5526 try:
5500 5527 wlock = repo.wlock()
5501 5528 lock = repo.lock()
5502 5529 rev_ = "."
5503 5530 names = [t.strip() for t in (name1,) + names]
5504 5531 if len(names) != len(set(names)):
5505 5532 raise util.Abort(_('tag names must be unique'))
5506 5533 for n in names:
5507 5534 if n in ['tip', '.', 'null']:
5508 5535 raise util.Abort(_("the name '%s' is reserved") % n)
5509 5536 if not n:
5510 5537 raise util.Abort(_('tag names cannot consist entirely of '
5511 5538 'whitespace'))
5512 5539 if opts.get('rev') and opts.get('remove'):
5513 5540 raise util.Abort(_("--rev and --remove are incompatible"))
5514 5541 if opts.get('rev'):
5515 5542 rev_ = opts['rev']
5516 5543 message = opts.get('message')
5517 5544 if opts.get('remove'):
5518 5545 expectedtype = opts.get('local') and 'local' or 'global'
5519 5546 for n in names:
5520 5547 if not repo.tagtype(n):
5521 5548 raise util.Abort(_("tag '%s' does not exist") % n)
5522 5549 if repo.tagtype(n) != expectedtype:
5523 5550 if expectedtype == 'global':
5524 5551 raise util.Abort(_("tag '%s' is not a global tag") % n)
5525 5552 else:
5526 5553 raise util.Abort(_("tag '%s' is not a local tag") % n)
5527 5554 rev_ = nullid
5528 5555 if not message:
5529 5556 # we don't translate commit messages
5530 5557 message = 'Removed tag %s' % ', '.join(names)
5531 5558 elif not opts.get('force'):
5532 5559 for n in names:
5533 5560 if n in repo.tags():
5534 5561 raise util.Abort(_("tag '%s' already exists "
5535 5562 "(use -f to force)") % n)
5536 5563 if not opts.get('local'):
5537 5564 p1, p2 = repo.dirstate.parents()
5538 5565 if p2 != nullid:
5539 5566 raise util.Abort(_('uncommitted merge'))
5540 5567 bheads = repo.branchheads()
5541 5568 if not opts.get('force') and bheads and p1 not in bheads:
5542 5569 raise util.Abort(_('not at a branch head (use -f to force)'))
5543 5570 r = scmutil.revsingle(repo, rev_).node()
5544 5571
5545 5572 if not message:
5546 5573 # we don't translate commit messages
5547 5574 message = ('Added tag %s for changeset %s' %
5548 5575 (', '.join(names), short(r)))
5549 5576
5550 5577 date = opts.get('date')
5551 5578 if date:
5552 5579 date = util.parsedate(date)
5553 5580
5554 5581 if opts.get('edit'):
5555 5582 message = ui.edit(message, ui.username())
5556 5583
5557 5584 repo.tag(names, r, message, opts.get('local'), opts.get('user'), date)
5558 5585 finally:
5559 5586 release(lock, wlock)
5560 5587
5561 5588 @command('tags', [], '')
5562 5589 def tags(ui, repo):
5563 5590 """list repository tags
5564 5591
5565 5592 This lists both regular and local tags. When the -v/--verbose
5566 5593 switch is used, a third column "local" is printed for local tags.
5567 5594
5568 5595 Returns 0 on success.
5569 5596 """
5570 5597
5571 5598 hexfunc = ui.debugflag and hex or short
5572 5599 tagtype = ""
5573 5600
5574 5601 for t, n in reversed(repo.tagslist()):
5575 5602 if ui.quiet:
5576 5603 ui.write("%s\n" % t, label='tags.normal')
5577 5604 continue
5578 5605
5579 5606 hn = hexfunc(n)
5580 5607 r = "%5d:%s" % (repo.changelog.rev(n), hn)
5581 5608 rev = ui.label(r, 'log.changeset')
5582 5609 spaces = " " * (30 - encoding.colwidth(t))
5583 5610
5584 5611 tag = ui.label(t, 'tags.normal')
5585 5612 if ui.verbose:
5586 5613 if repo.tagtype(t) == 'local':
5587 5614 tagtype = " local"
5588 5615 tag = ui.label(t, 'tags.local')
5589 5616 else:
5590 5617 tagtype = ""
5591 5618 ui.write("%s%s %s%s\n" % (tag, spaces, rev, tagtype))
5592 5619
5593 5620 @command('tip',
5594 5621 [('p', 'patch', None, _('show patch')),
5595 5622 ('g', 'git', None, _('use git extended diff format')),
5596 5623 ] + templateopts,
5597 5624 _('[-p] [-g]'))
5598 5625 def tip(ui, repo, **opts):
5599 5626 """show the tip revision
5600 5627
5601 5628 The tip revision (usually just called the tip) is the changeset
5602 5629 most recently added to the repository (and therefore the most
5603 5630 recently changed head).
5604 5631
5605 5632 If you have just made a commit, that commit will be the tip. If
5606 5633 you have just pulled changes from another repository, the tip of
5607 5634 that repository becomes the current tip. The "tip" tag is special
5608 5635 and cannot be renamed or assigned to a different changeset.
5609 5636
5610 5637 Returns 0 on success.
5611 5638 """
5612 5639 displayer = cmdutil.show_changeset(ui, repo, opts)
5613 5640 displayer.show(repo[len(repo) - 1])
5614 5641 displayer.close()
5615 5642
5616 5643 @command('unbundle',
5617 5644 [('u', 'update', None,
5618 5645 _('update to new branch head if changesets were unbundled'))],
5619 5646 _('[-u] FILE...'))
5620 5647 def unbundle(ui, repo, fname1, *fnames, **opts):
5621 5648 """apply one or more changegroup files
5622 5649
5623 5650 Apply one or more compressed changegroup files generated by the
5624 5651 bundle command.
5625 5652
5626 5653 Returns 0 on success, 1 if an update has unresolved files.
5627 5654 """
5628 5655 fnames = (fname1,) + fnames
5629 5656
5630 5657 lock = repo.lock()
5631 5658 wc = repo['.']
5632 5659 try:
5633 5660 for fname in fnames:
5634 5661 f = url.open(ui, fname)
5635 5662 gen = changegroup.readbundle(f, fname)
5636 5663 modheads = repo.addchangegroup(gen, 'unbundle', 'bundle:' + fname)
5637 5664 finally:
5638 5665 lock.release()
5639 5666 bookmarks.updatecurrentbookmark(repo, wc.node(), wc.branch())
5640 5667 return postincoming(ui, repo, modheads, opts.get('update'), None)
5641 5668
5642 5669 @command('^update|up|checkout|co',
5643 5670 [('C', 'clean', None, _('discard uncommitted changes (no backup)')),
5644 5671 ('c', 'check', None,
5645 5672 _('update across branches if no uncommitted changes')),
5646 5673 ('d', 'date', '', _('tipmost revision matching date'), _('DATE')),
5647 5674 ('r', 'rev', '', _('revision'), _('REV'))],
5648 5675 _('[-c] [-C] [-d DATE] [[-r] REV]'))
5649 5676 def update(ui, repo, node=None, rev=None, clean=False, date=None, check=False):
5650 5677 """update working directory (or switch revisions)
5651 5678
5652 5679 Update the repository's working directory to the specified
5653 5680 changeset. If no changeset is specified, update to the tip of the
5654 5681 current named branch and move the current bookmark (see :hg:`help
5655 5682 bookmarks`).
5656 5683
5657 5684 If the changeset is not a descendant of the working directory's
5658 5685 parent, the update is aborted. With the -c/--check option, the
5659 5686 working directory is checked for uncommitted changes; if none are
5660 5687 found, the working directory is updated to the specified
5661 5688 changeset.
5662 5689
5663 5690 Update sets the working directory's parent revison to the specified
5664 5691 changeset (see :hg:`help parents`).
5665 5692
5666 5693 The following rules apply when the working directory contains
5667 5694 uncommitted changes:
5668 5695
5669 5696 1. If neither -c/--check nor -C/--clean is specified, and if
5670 5697 the requested changeset is an ancestor or descendant of
5671 5698 the working directory's parent, the uncommitted changes
5672 5699 are merged into the requested changeset and the merged
5673 5700 result is left uncommitted. If the requested changeset is
5674 5701 not an ancestor or descendant (that is, it is on another
5675 5702 branch), the update is aborted and the uncommitted changes
5676 5703 are preserved.
5677 5704
5678 5705 2. With the -c/--check option, the update is aborted and the
5679 5706 uncommitted changes are preserved.
5680 5707
5681 5708 3. With the -C/--clean option, uncommitted changes are discarded and
5682 5709 the working directory is updated to the requested changeset.
5683 5710
5684 5711 Use null as the changeset to remove the working directory (like
5685 5712 :hg:`clone -U`).
5686 5713
5687 5714 If you want to revert just one file to an older revision, use
5688 5715 :hg:`revert [-r REV] NAME`.
5689 5716
5690 5717 See :hg:`help dates` for a list of formats valid for -d/--date.
5691 5718
5692 5719 Returns 0 on success, 1 if there are unresolved files.
5693 5720 """
5694 5721 if rev and node:
5695 5722 raise util.Abort(_("please specify just one revision"))
5696 5723
5697 5724 if rev is None or rev == '':
5698 5725 rev = node
5699 5726
5700 5727 # with no argument, we also move the current bookmark, if any
5701 5728 movemarkfrom = None
5702 5729 if rev is None or node == '':
5703 5730 movemarkfrom = repo['.'].node()
5704 5731
5705 5732 # if we defined a bookmark, we have to remember the original bookmark name
5706 5733 brev = rev
5707 5734 rev = scmutil.revsingle(repo, rev, rev).rev()
5708 5735
5709 5736 if check and clean:
5710 5737 raise util.Abort(_("cannot specify both -c/--check and -C/--clean"))
5711 5738
5712 5739 if date:
5713 5740 if rev is not None:
5714 5741 raise util.Abort(_("you can't specify a revision and a date"))
5715 5742 rev = cmdutil.finddate(ui, repo, date)
5716 5743
5717 5744 if check:
5718 5745 c = repo[None]
5719 5746 if c.dirty(merge=False, branch=False):
5720 5747 raise util.Abort(_("uncommitted local changes"))
5721 5748 if rev is None:
5722 5749 rev = repo[repo[None].branch()].rev()
5723 5750 mergemod._checkunknown(repo, repo[None], repo[rev])
5724 5751
5725 5752 if clean:
5726 5753 ret = hg.clean(repo, rev)
5727 5754 else:
5728 5755 ret = hg.update(repo, rev)
5729 5756
5730 5757 if not ret and movemarkfrom:
5731 5758 if bookmarks.update(repo, [movemarkfrom], repo['.'].node()):
5732 5759 ui.status(_("updating bookmark %s\n") % repo._bookmarkcurrent)
5733 5760 elif brev in repo._bookmarks:
5734 5761 bookmarks.setcurrent(repo, brev)
5735 5762 elif brev:
5736 5763 bookmarks.unsetcurrent(repo)
5737 5764
5738 5765 return ret
5739 5766
5740 5767 @command('verify', [])
5741 5768 def verify(ui, repo):
5742 5769 """verify the integrity of the repository
5743 5770
5744 5771 Verify the integrity of the current repository.
5745 5772
5746 5773 This will perform an extensive check of the repository's
5747 5774 integrity, validating the hashes and checksums of each entry in
5748 5775 the changelog, manifest, and tracked files, as well as the
5749 5776 integrity of their crosslinks and indices.
5750 5777
5751 5778 Returns 0 on success, 1 if errors are encountered.
5752 5779 """
5753 5780 return hg.verify(repo)
5754 5781
5755 5782 @command('version', [])
5756 5783 def version_(ui):
5757 5784 """output version and copyright information"""
5758 5785 ui.write(_("Mercurial Distributed SCM (version %s)\n")
5759 5786 % util.version())
5760 5787 ui.status(_(
5761 5788 "(see http://mercurial.selenic.com for more information)\n"
5762 5789 "\nCopyright (C) 2005-2012 Matt Mackall and others\n"
5763 5790 "This is free software; see the source for copying conditions. "
5764 5791 "There is NO\nwarranty; "
5765 5792 "not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
5766 5793 ))
5767 5794
5768 5795 norepo = ("clone init version help debugcommands debugcomplete"
5769 5796 " debugdate debuginstall debugfsinfo debugpushkey debugwireargs"
5770 5797 " debugknown debuggetbundle debugbundle")
5771 5798 optionalrepo = ("identify paths serve showconfig debugancestor debugdag"
5772 5799 " debugdata debugindex debugindexdot debugrevlog")
@@ -1,31 +1,93 b''
1 1 # init
2 2
3 3 $ hg init
4 4 $ echo a > a
5 5 $ hg add a
6 6 $ hg commit -m'a'
7 7 $ echo b > b
8 8 $ hg add b
9 9 $ hg commit -m'b'
10 10 $ hg up -C 0
11 11 0 files updated, 0 files merged, 1 files removed, 0 files unresolved
12 12 $ echo c > c
13 13 $ hg add c
14 14 $ hg commit -m'c'
15 15 created new head
16 16
17 17 # test merging of diverged bookmarks
18 18 $ hg bookmark -r 1 "c@diverge"
19 19 $ hg bookmark -r 1 b
20 20 $ hg bookmark c
21 21 $ hg bookmarks
22 22 b 1:d2ae7f538514
23 23 * c 2:d36c0562f908
24 24 c@diverge 1:d2ae7f538514
25 25 $ hg merge "c@diverge"
26 26 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
27 27 (branch merge, don't forget to commit)
28 28 $ hg commit -m'merge'
29 29 $ hg bookmarks
30 30 b 1:d2ae7f538514
31 31 * c 3:b8f96cf4688b
32
33 $ hg up -C 3
34 0 files updated, 0 files merged, 0 files removed, 0 files unresolved
35 $ echo d > d
36 $ hg add d
37 $ hg commit -m'd'
38
39 $ hg up -C 3
40 0 files updated, 0 files merged, 1 files removed, 0 files unresolved
41 $ echo e > e
42 $ hg add e
43 $ hg commit -m'e'
44 created new head
45 $ hg up -C 5
46 0 files updated, 0 files merged, 0 files removed, 0 files unresolved
47 $ hg bookmark e
48 $ hg bookmarks
49 b 1:d2ae7f538514
50 c 3:b8f96cf4688b
51 * e 5:26bee9c5bcf3
52
53 # the picked side is bookmarked
54
55 $ hg up -C 4
56 1 files updated, 0 files merged, 1 files removed, 0 files unresolved
57 $ hg merge
58 abort: heads are bookmarked - please merge with an explicit rev
59 (run 'hg heads' to see all heads)
60 [255]
61
62 # our revision is bookmarked
63
64 $ hg up -C e
65 1 files updated, 0 files merged, 1 files removed, 0 files unresolved
66 $ hg merge
67 abort: no matching bookmark to merge - please merge with an explicit rev or bookmark
68 (run 'hg heads' to see all heads)
69 [255]
70
71 # merge bookmark heads
72
73 $ hg up -C 4
74 1 files updated, 0 files merged, 1 files removed, 0 files unresolved
75 $ echo f > f
76 $ hg commit -Am "f"
77 adding f
78 $ hg up -C e
79 1 files updated, 0 files merged, 2 files removed, 0 files unresolved
80 $ hg bookmarks -r 4 "e@diverged"
81 $ hg bookmarks
82 b 1:d2ae7f538514
83 c 3:b8f96cf4688b
84 * e 5:26bee9c5bcf3
85 e@diverged 4:a0546fcfe0fb
86 $ hg merge
87 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
88 (branch merge, don't forget to commit)
89 $ hg commit -m'merge'
90 $ hg bookmarks
91 b 1:d2ae7f538514
92 c 3:b8f96cf4688b
93 * e 7:ca784329f0ba
@@ -1,140 +1,140 b''
1 1 $ "$TESTDIR/hghave" execbit || exit 80
2 2
3 3 $ cat >> $HGRCPATH <<EOF
4 4 > [extensions]
5 5 > convert=
6 6 > [convert]
7 7 > hg.saverev=False
8 8 > EOF
9 9 $ hg init orig
10 10 $ cd orig
11 11 $ echo foo > foo
12 12 $ echo bar > bar
13 13 $ hg ci -qAm 'add foo bar' -d '0 0'
14 14 $ echo >> foo
15 15 $ hg ci -m 'change foo' -d '1 0'
16 16 $ hg up -qC 0
17 17 $ hg copy --after --force foo bar
18 18 $ hg copy foo baz
19 19 $ hg ci -m 'make bar and baz copies of foo' -d '2 0'
20 20 created new head
21 21 $ hg bookmark premerge1
22 $ hg merge
22 $ hg merge -r 1
23 23 merging baz and foo to baz
24 24 1 files updated, 1 files merged, 0 files removed, 0 files unresolved
25 25 (branch merge, don't forget to commit)
26 26 $ hg ci -m 'merge local copy' -d '3 0'
27 27 $ hg up -C 1
28 28 1 files updated, 0 files merged, 1 files removed, 0 files unresolved
29 29 $ hg bookmark premerge2
30 30 $ hg merge 2
31 31 merging foo and baz to baz
32 32 1 files updated, 1 files merged, 0 files removed, 0 files unresolved
33 33 (branch merge, don't forget to commit)
34 34 $ hg ci -m 'merge remote copy' -d '4 0'
35 35 created new head
36 36 $ chmod +x baz
37 37 $ hg ci -m 'mark baz executable' -d '5 0'
38 38 $ cd ..
39 39 $ hg convert --datesort orig new 2>&1 | grep -v 'subversion python bindings could not be loaded'
40 40 initializing destination new repository
41 41 scanning source...
42 42 sorting...
43 43 converting...
44 44 5 add foo bar
45 45 4 change foo
46 46 3 make bar and baz copies of foo
47 47 2 merge local copy
48 48 1 merge remote copy
49 49 0 mark baz executable
50 50 updating bookmarks
51 51 $ cd new
52 52 $ hg out ../orig
53 53 comparing with ../orig
54 54 searching for changes
55 55 no changes found
56 56 [1]
57 57 $ hg bookmarks
58 58 premerge1 3:973ef48a98a4
59 59 premerge2 5:13d9b87cf8f8
60 60 $ cd ..
61 61
62 62 check shamap LF and CRLF handling
63 63
64 64 $ cat > rewrite.py <<EOF
65 65 > import sys
66 66 > # Interlace LF and CRLF
67 67 > lines = [(l.rstrip() + ((i % 2) and '\n' or '\r\n'))
68 68 > for i, l in enumerate(file(sys.argv[1]))]
69 69 > file(sys.argv[1], 'wb').write(''.join(lines))
70 70 > EOF
71 71 $ python rewrite.py new/.hg/shamap
72 72 $ cd orig
73 73 $ hg up -qC 1
74 74 $ echo foo >> foo
75 75 $ hg ci -qm 'change foo again'
76 76 $ hg up -qC 2
77 77 $ echo foo >> foo
78 78 $ hg ci -qm 'change foo again again'
79 79 $ cd ..
80 80 $ hg convert --datesort orig new 2>&1 | grep -v 'subversion python bindings could not be loaded'
81 81 scanning source...
82 82 sorting...
83 83 converting...
84 84 1 change foo again again
85 85 0 change foo again
86 86 updating bookmarks
87 87
88 88 init broken repository
89 89
90 90 $ hg init broken
91 91 $ cd broken
92 92 $ echo a >> a
93 93 $ echo b >> b
94 94 $ hg ci -qAm init
95 95 $ echo a >> a
96 96 $ echo b >> b
97 97 $ hg copy b c
98 98 $ hg ci -qAm changeall
99 99 $ hg up -qC 0
100 100 $ echo bc >> b
101 101 $ hg ci -m changebagain
102 102 created new head
103 103 $ HGMERGE=internal:local hg -q merge
104 104 $ hg ci -m merge
105 105 $ hg mv b d
106 106 $ hg ci -m moveb
107 107
108 108 break it
109 109
110 110 $ rm .hg/store/data/b.*
111 111 $ cd ..
112 112 $ hg --config convert.hg.ignoreerrors=True convert broken fixed
113 113 initializing destination fixed repository
114 114 scanning source...
115 115 sorting...
116 116 converting...
117 117 4 init
118 118 ignoring: data/b.i@1e88685f5dde: no match found
119 119 3 changeall
120 120 2 changebagain
121 121 1 merge
122 122 0 moveb
123 123 $ hg -R fixed verify
124 124 checking changesets
125 125 checking manifests
126 126 crosschecking files in changesets and manifests
127 127 checking files
128 128 3 files, 5 changesets, 5 total revisions
129 129
130 130 manifest -r 0
131 131
132 132 $ hg -R fixed manifest -r 0
133 133 a
134 134
135 135 manifest -r tip
136 136
137 137 $ hg -R fixed manifest -r tip
138 138 a
139 139 c
140 140 d
General Comments 0
You need to be logged in to leave comments. Login now