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