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