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