##// END OF EJS Templates
import: reorder help text...
timeless -
r27390:8bc6ece9 default
parent child Browse files
Show More
@@ -1,6992 +1,6994 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, nullhex, nullid, nullrev, short
9 9 from lock import release
10 10 from i18n import _
11 11 import os, re, difflib, time, tempfile, errno, shlex
12 12 import sys, socket
13 13 import hg, scmutil, util, revlog, copies, error, bookmarks
14 14 import patch, help, encoding, templatekw, discovery
15 15 import archival, changegroup, cmdutil, hbisect
16 16 import sshserver, hgweb
17 17 import extensions
18 18 import merge as mergemod
19 19 import minirst, revset, fileset
20 20 import dagparser, context, simplemerge, graphmod, copies
21 21 import random, operator
22 22 import setdiscovery, treediscovery, dagutil, pvec, localrepo, destutil
23 23 import phases, obsolete, exchange, bundle2, repair, lock as lockmod
24 24 import ui as uimod
25 25 import streamclone
26 26 import commandserver
27 27
28 28 table = {}
29 29
30 30 command = cmdutil.command(table)
31 31
32 32 # Space delimited list of commands that don't require local repositories.
33 33 # This should be populated by passing norepo=True into the @command decorator.
34 34 norepo = ''
35 35 # Space delimited list of commands that optionally require local repositories.
36 36 # This should be populated by passing optionalrepo=True into the @command
37 37 # decorator.
38 38 optionalrepo = ''
39 39 # Space delimited list of commands that will examine arguments looking for
40 40 # a repository. This should be populated by passing inferrepo=True into the
41 41 # @command decorator.
42 42 inferrepo = ''
43 43
44 44 # label constants
45 45 # until 3.5, bookmarks.current was the advertised name, not
46 46 # bookmarks.active, so we must use both to avoid breaking old
47 47 # custom styles
48 48 activebookmarklabel = 'bookmarks.active bookmarks.current'
49 49
50 50 # common command options
51 51
52 52 globalopts = [
53 53 ('R', 'repository', '',
54 54 _('repository root directory or name of overlay bundle file'),
55 55 _('REPO')),
56 56 ('', 'cwd', '',
57 57 _('change working directory'), _('DIR')),
58 58 ('y', 'noninteractive', None,
59 59 _('do not prompt, automatically pick the first choice for all prompts')),
60 60 ('q', 'quiet', None, _('suppress output')),
61 61 ('v', 'verbose', None, _('enable additional output')),
62 62 ('', 'config', [],
63 63 _('set/override config option (use \'section.name=value\')'),
64 64 _('CONFIG')),
65 65 ('', 'debug', None, _('enable debugging output')),
66 66 ('', 'debugger', None, _('start debugger')),
67 67 ('', 'encoding', encoding.encoding, _('set the charset encoding'),
68 68 _('ENCODE')),
69 69 ('', 'encodingmode', encoding.encodingmode,
70 70 _('set the charset encoding mode'), _('MODE')),
71 71 ('', 'traceback', None, _('always print a traceback on exception')),
72 72 ('', 'time', None, _('time how long the command takes')),
73 73 ('', 'profile', None, _('print command execution profile')),
74 74 ('', 'version', None, _('output version information and exit')),
75 75 ('h', 'help', None, _('display help and exit')),
76 76 ('', 'hidden', False, _('consider hidden changesets')),
77 77 ]
78 78
79 79 dryrunopts = [('n', 'dry-run', None,
80 80 _('do not perform actions, just print output'))]
81 81
82 82 remoteopts = [
83 83 ('e', 'ssh', '',
84 84 _('specify ssh command to use'), _('CMD')),
85 85 ('', 'remotecmd', '',
86 86 _('specify hg command to run on the remote side'), _('CMD')),
87 87 ('', 'insecure', None,
88 88 _('do not verify server certificate (ignoring web.cacerts config)')),
89 89 ]
90 90
91 91 walkopts = [
92 92 ('I', 'include', [],
93 93 _('include names matching the given patterns'), _('PATTERN')),
94 94 ('X', 'exclude', [],
95 95 _('exclude names matching the given patterns'), _('PATTERN')),
96 96 ]
97 97
98 98 commitopts = [
99 99 ('m', 'message', '',
100 100 _('use text as commit message'), _('TEXT')),
101 101 ('l', 'logfile', '',
102 102 _('read commit message from file'), _('FILE')),
103 103 ]
104 104
105 105 commitopts2 = [
106 106 ('d', 'date', '',
107 107 _('record the specified date as commit date'), _('DATE')),
108 108 ('u', 'user', '',
109 109 _('record the specified user as committer'), _('USER')),
110 110 ]
111 111
112 112 # hidden for now
113 113 formatteropts = [
114 114 ('T', 'template', '',
115 115 _('display with template (EXPERIMENTAL)'), _('TEMPLATE')),
116 116 ]
117 117
118 118 templateopts = [
119 119 ('', 'style', '',
120 120 _('display using template map file (DEPRECATED)'), _('STYLE')),
121 121 ('T', 'template', '',
122 122 _('display with template'), _('TEMPLATE')),
123 123 ]
124 124
125 125 logopts = [
126 126 ('p', 'patch', None, _('show patch')),
127 127 ('g', 'git', None, _('use git extended diff format')),
128 128 ('l', 'limit', '',
129 129 _('limit number of changes displayed'), _('NUM')),
130 130 ('M', 'no-merges', None, _('do not show merges')),
131 131 ('', 'stat', None, _('output diffstat-style summary of changes')),
132 132 ('G', 'graph', None, _("show the revision DAG")),
133 133 ] + templateopts
134 134
135 135 diffopts = [
136 136 ('a', 'text', None, _('treat all files as text')),
137 137 ('g', 'git', None, _('use git extended diff format')),
138 138 ('', 'nodates', None, _('omit dates from diff headers'))
139 139 ]
140 140
141 141 diffwsopts = [
142 142 ('w', 'ignore-all-space', None,
143 143 _('ignore white space when comparing lines')),
144 144 ('b', 'ignore-space-change', None,
145 145 _('ignore changes in the amount of white space')),
146 146 ('B', 'ignore-blank-lines', None,
147 147 _('ignore changes whose lines are all blank')),
148 148 ]
149 149
150 150 diffopts2 = [
151 151 ('', 'noprefix', None, _('omit a/ and b/ prefixes from filenames')),
152 152 ('p', 'show-function', None, _('show which function each change is in')),
153 153 ('', 'reverse', None, _('produce a diff that undoes the changes')),
154 154 ] + diffwsopts + [
155 155 ('U', 'unified', '',
156 156 _('number of lines of context to show'), _('NUM')),
157 157 ('', 'stat', None, _('output diffstat-style summary of changes')),
158 158 ('', 'root', '', _('produce diffs relative to subdirectory'), _('DIR')),
159 159 ]
160 160
161 161 mergetoolopts = [
162 162 ('t', 'tool', '', _('specify merge tool')),
163 163 ]
164 164
165 165 similarityopts = [
166 166 ('s', 'similarity', '',
167 167 _('guess renamed files by similarity (0<=s<=100)'), _('SIMILARITY'))
168 168 ]
169 169
170 170 subrepoopts = [
171 171 ('S', 'subrepos', None,
172 172 _('recurse into subrepositories'))
173 173 ]
174 174
175 175 debugrevlogopts = [
176 176 ('c', 'changelog', False, _('open changelog')),
177 177 ('m', 'manifest', False, _('open manifest')),
178 178 ('', 'dir', False, _('open directory manifest')),
179 179 ]
180 180
181 181 # Commands start here, listed alphabetically
182 182
183 183 @command('^add',
184 184 walkopts + subrepoopts + dryrunopts,
185 185 _('[OPTION]... [FILE]...'),
186 186 inferrepo=True)
187 187 def add(ui, repo, *pats, **opts):
188 188 """add the specified files on the next commit
189 189
190 190 Schedule files to be version controlled and added to the
191 191 repository.
192 192
193 193 The files will be added to the repository at the next commit. To
194 194 undo an add before that, see :hg:`forget`.
195 195
196 196 If no names are given, add all files to the repository.
197 197
198 198 .. container:: verbose
199 199
200 200 Examples:
201 201
202 202 - New (unknown) files are added
203 203 automatically by :hg:`add`::
204 204
205 205 $ ls
206 206 foo.c
207 207 $ hg status
208 208 ? foo.c
209 209 $ hg add
210 210 adding foo.c
211 211 $ hg status
212 212 A foo.c
213 213
214 214 - Specific files to be added can be specified::
215 215
216 216 $ ls
217 217 bar.c foo.c
218 218 $ hg status
219 219 ? bar.c
220 220 ? foo.c
221 221 $ hg add bar.c
222 222 $ hg status
223 223 A bar.c
224 224 ? foo.c
225 225
226 226 Returns 0 if all files are successfully added.
227 227 """
228 228
229 229 m = scmutil.match(repo[None], pats, opts)
230 230 rejected = cmdutil.add(ui, repo, m, "", False, **opts)
231 231 return rejected and 1 or 0
232 232
233 233 @command('addremove',
234 234 similarityopts + subrepoopts + walkopts + dryrunopts,
235 235 _('[OPTION]... [FILE]...'),
236 236 inferrepo=True)
237 237 def addremove(ui, repo, *pats, **opts):
238 238 """add all new files, delete all missing files
239 239
240 240 Add all new files and remove all missing files from the
241 241 repository.
242 242
243 243 New files are ignored if they match any of the patterns in
244 244 ``.hgignore``. As with add, these changes take effect at the next
245 245 commit.
246 246
247 247 Use the -s/--similarity option to detect renamed files. This
248 248 option takes a percentage between 0 (disabled) and 100 (files must
249 249 be identical) as its parameter. With a parameter greater than 0,
250 250 this compares every removed file with every added file and records
251 251 those similar enough as renames. Detecting renamed files this way
252 252 can be expensive. After using this option, :hg:`status -C` can be
253 253 used to check which files were identified as moved or renamed. If
254 254 not specified, -s/--similarity defaults to 100 and only renames of
255 255 identical files are detected.
256 256
257 257 .. container:: verbose
258 258
259 259 Examples:
260 260
261 261 - A number of files (bar.c and foo.c) are new,
262 262 while foobar.c has been removed (without using :hg:`remove`)
263 263 from the repository::
264 264
265 265 $ ls
266 266 bar.c foo.c
267 267 $ hg status
268 268 ! foobar.c
269 269 ? bar.c
270 270 ? foo.c
271 271 $ hg addremove
272 272 adding bar.c
273 273 adding foo.c
274 274 removing foobar.c
275 275 $ hg status
276 276 A bar.c
277 277 A foo.c
278 278 R foobar.c
279 279
280 280 - A file foobar.c was moved to foo.c without using :hg:`rename`.
281 281 Afterwards, it was edited slightly::
282 282
283 283 $ ls
284 284 foo.c
285 285 $ hg status
286 286 ! foobar.c
287 287 ? foo.c
288 288 $ hg addremove --similarity 90
289 289 removing foobar.c
290 290 adding foo.c
291 291 recording removal of foobar.c as rename to foo.c (94% similar)
292 292 $ hg status -C
293 293 A foo.c
294 294 foobar.c
295 295 R foobar.c
296 296
297 297 Returns 0 if all files are successfully added.
298 298 """
299 299 try:
300 300 sim = float(opts.get('similarity') or 100)
301 301 except ValueError:
302 302 raise error.Abort(_('similarity must be a number'))
303 303 if sim < 0 or sim > 100:
304 304 raise error.Abort(_('similarity must be between 0 and 100'))
305 305 matcher = scmutil.match(repo[None], pats, opts)
306 306 return scmutil.addremove(repo, matcher, "", opts, similarity=sim / 100.0)
307 307
308 308 @command('^annotate|blame',
309 309 [('r', 'rev', '', _('annotate the specified revision'), _('REV')),
310 310 ('', 'follow', None,
311 311 _('follow copies/renames and list the filename (DEPRECATED)')),
312 312 ('', 'no-follow', None, _("don't follow copies and renames")),
313 313 ('a', 'text', None, _('treat all files as text')),
314 314 ('u', 'user', None, _('list the author (long with -v)')),
315 315 ('f', 'file', None, _('list the filename')),
316 316 ('d', 'date', None, _('list the date (short with -q)')),
317 317 ('n', 'number', None, _('list the revision number (default)')),
318 318 ('c', 'changeset', None, _('list the changeset')),
319 319 ('l', 'line-number', None, _('show line number at the first appearance'))
320 320 ] + diffwsopts + walkopts + formatteropts,
321 321 _('[-r REV] [-f] [-a] [-u] [-d] [-n] [-c] [-l] FILE...'),
322 322 inferrepo=True)
323 323 def annotate(ui, repo, *pats, **opts):
324 324 """show changeset information by line for each file
325 325
326 326 List changes in files, showing the revision id responsible for
327 327 each line
328 328
329 329 This command is useful for discovering when a change was made and
330 330 by whom.
331 331
332 332 Without the -a/--text option, annotate will avoid processing files
333 333 it detects as binary. With -a, annotate will annotate the file
334 334 anyway, although the results will probably be neither useful
335 335 nor desirable.
336 336
337 337 Returns 0 on success.
338 338 """
339 339 if not pats:
340 340 raise error.Abort(_('at least one filename or pattern is required'))
341 341
342 342 if opts.get('follow'):
343 343 # --follow is deprecated and now just an alias for -f/--file
344 344 # to mimic the behavior of Mercurial before version 1.5
345 345 opts['file'] = True
346 346
347 347 ctx = scmutil.revsingle(repo, opts.get('rev'))
348 348
349 349 fm = ui.formatter('annotate', opts)
350 350 if ui.quiet:
351 351 datefunc = util.shortdate
352 352 else:
353 353 datefunc = util.datestr
354 354 if ctx.rev() is None:
355 355 def hexfn(node):
356 356 if node is None:
357 357 return None
358 358 else:
359 359 return fm.hexfunc(node)
360 360 if opts.get('changeset'):
361 361 # omit "+" suffix which is appended to node hex
362 362 def formatrev(rev):
363 363 if rev is None:
364 364 return '%d' % ctx.p1().rev()
365 365 else:
366 366 return '%d' % rev
367 367 else:
368 368 def formatrev(rev):
369 369 if rev is None:
370 370 return '%d+' % ctx.p1().rev()
371 371 else:
372 372 return '%d ' % rev
373 373 def formathex(hex):
374 374 if hex is None:
375 375 return '%s+' % fm.hexfunc(ctx.p1().node())
376 376 else:
377 377 return '%s ' % hex
378 378 else:
379 379 hexfn = fm.hexfunc
380 380 formatrev = formathex = str
381 381
382 382 opmap = [('user', ' ', lambda x: x[0].user(), ui.shortuser),
383 383 ('number', ' ', lambda x: x[0].rev(), formatrev),
384 384 ('changeset', ' ', lambda x: hexfn(x[0].node()), formathex),
385 385 ('date', ' ', lambda x: x[0].date(), util.cachefunc(datefunc)),
386 386 ('file', ' ', lambda x: x[0].path(), str),
387 387 ('line_number', ':', lambda x: x[1], str),
388 388 ]
389 389 fieldnamemap = {'number': 'rev', 'changeset': 'node'}
390 390
391 391 if (not opts.get('user') and not opts.get('changeset')
392 392 and not opts.get('date') and not opts.get('file')):
393 393 opts['number'] = True
394 394
395 395 linenumber = opts.get('line_number') is not None
396 396 if linenumber and (not opts.get('changeset')) and (not opts.get('number')):
397 397 raise error.Abort(_('at least one of -n/-c is required for -l'))
398 398
399 399 if fm:
400 400 def makefunc(get, fmt):
401 401 return get
402 402 else:
403 403 def makefunc(get, fmt):
404 404 return lambda x: fmt(get(x))
405 405 funcmap = [(makefunc(get, fmt), sep) for op, sep, get, fmt in opmap
406 406 if opts.get(op)]
407 407 funcmap[0] = (funcmap[0][0], '') # no separator in front of first column
408 408 fields = ' '.join(fieldnamemap.get(op, op) for op, sep, get, fmt in opmap
409 409 if opts.get(op))
410 410
411 411 def bad(x, y):
412 412 raise error.Abort("%s: %s" % (x, y))
413 413
414 414 m = scmutil.match(ctx, pats, opts, badfn=bad)
415 415
416 416 follow = not opts.get('no_follow')
417 417 diffopts = patch.difffeatureopts(ui, opts, section='annotate',
418 418 whitespace=True)
419 419 for abs in ctx.walk(m):
420 420 fctx = ctx[abs]
421 421 if not opts.get('text') and util.binary(fctx.data()):
422 422 fm.plain(_("%s: binary file\n") % ((pats and m.rel(abs)) or abs))
423 423 continue
424 424
425 425 lines = fctx.annotate(follow=follow, linenumber=linenumber,
426 426 diffopts=diffopts)
427 427 formats = []
428 428 pieces = []
429 429
430 430 for f, sep in funcmap:
431 431 l = [f(n) for n, dummy in lines]
432 432 if l:
433 433 if fm:
434 434 formats.append(['%s' for x in l])
435 435 else:
436 436 sizes = [encoding.colwidth(x) for x in l]
437 437 ml = max(sizes)
438 438 formats.append([sep + ' ' * (ml - w) + '%s' for w in sizes])
439 439 pieces.append(l)
440 440
441 441 for f, p, l in zip(zip(*formats), zip(*pieces), lines):
442 442 fm.startitem()
443 443 fm.write(fields, "".join(f), *p)
444 444 fm.write('line', ": %s", l[1])
445 445
446 446 if lines and not lines[-1][1].endswith('\n'):
447 447 fm.plain('\n')
448 448
449 449 fm.end()
450 450
451 451 @command('archive',
452 452 [('', 'no-decode', None, _('do not pass files through decoders')),
453 453 ('p', 'prefix', '', _('directory prefix for files in archive'),
454 454 _('PREFIX')),
455 455 ('r', 'rev', '', _('revision to distribute'), _('REV')),
456 456 ('t', 'type', '', _('type of distribution to create'), _('TYPE')),
457 457 ] + subrepoopts + walkopts,
458 458 _('[OPTION]... DEST'))
459 459 def archive(ui, repo, dest, **opts):
460 460 '''create an unversioned archive of a repository revision
461 461
462 462 By default, the revision used is the parent of the working
463 463 directory; use -r/--rev to specify a different revision.
464 464
465 465 The archive type is automatically detected based on file
466 466 extension (or override using -t/--type).
467 467
468 468 .. container:: verbose
469 469
470 470 Examples:
471 471
472 472 - create a zip file containing the 1.0 release::
473 473
474 474 hg archive -r 1.0 project-1.0.zip
475 475
476 476 - create a tarball excluding .hg files::
477 477
478 478 hg archive project.tar.gz -X ".hg*"
479 479
480 480 Valid types are:
481 481
482 482 :``files``: a directory full of files (default)
483 483 :``tar``: tar archive, uncompressed
484 484 :``tbz2``: tar archive, compressed using bzip2
485 485 :``tgz``: tar archive, compressed using gzip
486 486 :``uzip``: zip archive, uncompressed
487 487 :``zip``: zip archive, compressed using deflate
488 488
489 489 The exact name of the destination archive or directory is given
490 490 using a format string; see :hg:`help export` for details.
491 491
492 492 Each member added to an archive file has a directory prefix
493 493 prepended. Use -p/--prefix to specify a format string for the
494 494 prefix. The default is the basename of the archive, with suffixes
495 495 removed.
496 496
497 497 Returns 0 on success.
498 498 '''
499 499
500 500 ctx = scmutil.revsingle(repo, opts.get('rev'))
501 501 if not ctx:
502 502 raise error.Abort(_('no working directory: please specify a revision'))
503 503 node = ctx.node()
504 504 dest = cmdutil.makefilename(repo, dest, node)
505 505 if os.path.realpath(dest) == repo.root:
506 506 raise error.Abort(_('repository root cannot be destination'))
507 507
508 508 kind = opts.get('type') or archival.guesskind(dest) or 'files'
509 509 prefix = opts.get('prefix')
510 510
511 511 if dest == '-':
512 512 if kind == 'files':
513 513 raise error.Abort(_('cannot archive plain files to stdout'))
514 514 dest = cmdutil.makefileobj(repo, dest)
515 515 if not prefix:
516 516 prefix = os.path.basename(repo.root) + '-%h'
517 517
518 518 prefix = cmdutil.makefilename(repo, prefix, node)
519 519 matchfn = scmutil.match(ctx, [], opts)
520 520 archival.archive(repo, dest, node, kind, not opts.get('no_decode'),
521 521 matchfn, prefix, subrepos=opts.get('subrepos'))
522 522
523 523 @command('backout',
524 524 [('', 'merge', None, _('merge with old dirstate parent after backout')),
525 525 ('', 'commit', None, _('commit if no conflicts were encountered')),
526 526 ('', 'parent', '',
527 527 _('parent to choose when backing out merge (DEPRECATED)'), _('REV')),
528 528 ('r', 'rev', '', _('revision to backout'), _('REV')),
529 529 ('e', 'edit', False, _('invoke editor on commit messages')),
530 530 ] + mergetoolopts + walkopts + commitopts + commitopts2,
531 531 _('[OPTION]... [-r] REV'))
532 532 def backout(ui, repo, node=None, rev=None, commit=False, **opts):
533 533 '''reverse effect of earlier changeset
534 534
535 535 Prepare a new changeset with the effect of REV undone in the
536 536 current working directory.
537 537
538 538 If REV is the parent of the working directory, then this new changeset
539 539 is committed automatically. Otherwise, hg needs to merge the
540 540 changes and the merged result is left uncommitted.
541 541
542 542 .. note::
543 543
544 544 backout cannot be used to fix either an unwanted or
545 545 incorrect merge.
546 546
547 547 .. container:: verbose
548 548
549 549 Examples:
550 550
551 551 - Reverse the effect of the parent of the working directory.
552 552 This backout will be committed immediately::
553 553
554 554 hg backout -r .
555 555
556 556 - Reverse the effect of previous bad revision 23::
557 557
558 558 hg backout -r 23
559 559 hg commit -m "Backout revision 23"
560 560
561 561 - Reverse the effect of previous bad revision 23 and
562 562 commit the backout immediately::
563 563
564 564 hg backout -r 23 --commit
565 565
566 566 By default, the pending changeset will have one parent,
567 567 maintaining a linear history. With --merge, the pending
568 568 changeset will instead have two parents: the old parent of the
569 569 working directory and a new child of REV that simply undoes REV.
570 570
571 571 Before version 1.7, the behavior without --merge was equivalent
572 572 to specifying --merge followed by :hg:`update --clean .` to
573 573 cancel the merge and leave the child of REV as a head to be
574 574 merged separately.
575 575
576 576 See :hg:`help dates` for a list of formats valid for -d/--date.
577 577
578 578 See :hg:`help revert` for a way to restore files to the state
579 579 of another revision.
580 580
581 581 Returns 0 on success, 1 if nothing to backout or there are unresolved
582 582 files.
583 583 '''
584 584 wlock = lock = None
585 585 try:
586 586 wlock = repo.wlock()
587 587 lock = repo.lock()
588 588 return _dobackout(ui, repo, node, rev, commit, **opts)
589 589 finally:
590 590 release(lock, wlock)
591 591
592 592 def _dobackout(ui, repo, node=None, rev=None, commit=False, **opts):
593 593 if rev and node:
594 594 raise error.Abort(_("please specify just one revision"))
595 595
596 596 if not rev:
597 597 rev = node
598 598
599 599 if not rev:
600 600 raise error.Abort(_("please specify a revision to backout"))
601 601
602 602 date = opts.get('date')
603 603 if date:
604 604 opts['date'] = util.parsedate(date)
605 605
606 606 cmdutil.checkunfinished(repo)
607 607 cmdutil.bailifchanged(repo)
608 608 node = scmutil.revsingle(repo, rev).node()
609 609
610 610 op1, op2 = repo.dirstate.parents()
611 611 if not repo.changelog.isancestor(node, op1):
612 612 raise error.Abort(_('cannot backout change that is not an ancestor'))
613 613
614 614 p1, p2 = repo.changelog.parents(node)
615 615 if p1 == nullid:
616 616 raise error.Abort(_('cannot backout a change with no parents'))
617 617 if p2 != nullid:
618 618 if not opts.get('parent'):
619 619 raise error.Abort(_('cannot backout a merge changeset'))
620 620 p = repo.lookup(opts['parent'])
621 621 if p not in (p1, p2):
622 622 raise error.Abort(_('%s is not a parent of %s') %
623 623 (short(p), short(node)))
624 624 parent = p
625 625 else:
626 626 if opts.get('parent'):
627 627 raise error.Abort(_('cannot use --parent on non-merge changeset'))
628 628 parent = p1
629 629
630 630 # the backout should appear on the same branch
631 631 try:
632 632 branch = repo.dirstate.branch()
633 633 bheads = repo.branchheads(branch)
634 634 rctx = scmutil.revsingle(repo, hex(parent))
635 635 if not opts.get('merge') and op1 != node:
636 636 dsguard = cmdutil.dirstateguard(repo, 'backout')
637 637 try:
638 638 ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
639 639 'backout')
640 640 stats = mergemod.update(repo, parent, True, True, node, False)
641 641 repo.setparents(op1, op2)
642 642 dsguard.close()
643 643 hg._showstats(repo, stats)
644 644 if stats[3]:
645 645 repo.ui.status(_("use 'hg resolve' to retry unresolved "
646 646 "file merges\n"))
647 647 return 1
648 648 elif not commit:
649 649 msg = _("changeset %s backed out, "
650 650 "don't forget to commit.\n")
651 651 ui.status(msg % short(node))
652 652 return 0
653 653 finally:
654 654 ui.setconfig('ui', 'forcemerge', '', '')
655 655 lockmod.release(dsguard)
656 656 else:
657 657 hg.clean(repo, node, show_stats=False)
658 658 repo.dirstate.setbranch(branch)
659 659 cmdutil.revert(ui, repo, rctx, repo.dirstate.parents())
660 660
661 661
662 662 def commitfunc(ui, repo, message, match, opts):
663 663 editform = 'backout'
664 664 e = cmdutil.getcommiteditor(editform=editform, **opts)
665 665 if not message:
666 666 # we don't translate commit messages
667 667 message = "Backed out changeset %s" % short(node)
668 668 e = cmdutil.getcommiteditor(edit=True, editform=editform)
669 669 return repo.commit(message, opts.get('user'), opts.get('date'),
670 670 match, editor=e)
671 671 newnode = cmdutil.commit(ui, repo, commitfunc, [], opts)
672 672 if not newnode:
673 673 ui.status(_("nothing changed\n"))
674 674 return 1
675 675 cmdutil.commitstatus(repo, newnode, branch, bheads)
676 676
677 677 def nice(node):
678 678 return '%d:%s' % (repo.changelog.rev(node), short(node))
679 679 ui.status(_('changeset %s backs out changeset %s\n') %
680 680 (nice(repo.changelog.tip()), nice(node)))
681 681 if opts.get('merge') and op1 != node:
682 682 hg.clean(repo, op1, show_stats=False)
683 683 ui.status(_('merging with changeset %s\n')
684 684 % nice(repo.changelog.tip()))
685 685 try:
686 686 ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
687 687 'backout')
688 688 return hg.merge(repo, hex(repo.changelog.tip()))
689 689 finally:
690 690 ui.setconfig('ui', 'forcemerge', '', '')
691 691 finally:
692 692 # TODO: get rid of this meaningless try/finally enclosing.
693 693 # this is kept only to reduce changes in a patch.
694 694 pass
695 695 return 0
696 696
697 697 @command('bisect',
698 698 [('r', 'reset', False, _('reset bisect state')),
699 699 ('g', 'good', False, _('mark changeset good')),
700 700 ('b', 'bad', False, _('mark changeset bad')),
701 701 ('s', 'skip', False, _('skip testing changeset')),
702 702 ('e', 'extend', False, _('extend the bisect range')),
703 703 ('c', 'command', '', _('use command to check changeset state'), _('CMD')),
704 704 ('U', 'noupdate', False, _('do not update to target'))],
705 705 _("[-gbsr] [-U] [-c CMD] [REV]"))
706 706 def bisect(ui, repo, rev=None, extra=None, command=None,
707 707 reset=None, good=None, bad=None, skip=None, extend=None,
708 708 noupdate=None):
709 709 """subdivision search of changesets
710 710
711 711 This command helps to find changesets which introduce problems. To
712 712 use, mark the earliest changeset you know exhibits the problem as
713 713 bad, then mark the latest changeset which is free from the problem
714 714 as good. Bisect will update your working directory to a revision
715 715 for testing (unless the -U/--noupdate option is specified). Once
716 716 you have performed tests, mark the working directory as good or
717 717 bad, and bisect will either update to another candidate changeset
718 718 or announce that it has found the bad revision.
719 719
720 720 As a shortcut, you can also use the revision argument to mark a
721 721 revision as good or bad without checking it out first.
722 722
723 723 If you supply a command, it will be used for automatic bisection.
724 724 The environment variable HG_NODE will contain the ID of the
725 725 changeset being tested. The exit status of the command will be
726 726 used to mark revisions as good or bad: status 0 means good, 125
727 727 means to skip the revision, 127 (command not found) will abort the
728 728 bisection, and any other non-zero exit status means the revision
729 729 is bad.
730 730
731 731 .. container:: verbose
732 732
733 733 Some examples:
734 734
735 735 - start a bisection with known bad revision 34, and good revision 12::
736 736
737 737 hg bisect --bad 34
738 738 hg bisect --good 12
739 739
740 740 - advance the current bisection by marking current revision as good or
741 741 bad::
742 742
743 743 hg bisect --good
744 744 hg bisect --bad
745 745
746 746 - mark the current revision, or a known revision, to be skipped (e.g. if
747 747 that revision is not usable because of another issue)::
748 748
749 749 hg bisect --skip
750 750 hg bisect --skip 23
751 751
752 752 - skip all revisions that do not touch directories ``foo`` or ``bar``::
753 753
754 754 hg bisect --skip "!( file('path:foo') & file('path:bar') )"
755 755
756 756 - forget the current bisection::
757 757
758 758 hg bisect --reset
759 759
760 760 - use 'make && make tests' to automatically find the first broken
761 761 revision::
762 762
763 763 hg bisect --reset
764 764 hg bisect --bad 34
765 765 hg bisect --good 12
766 766 hg bisect --command "make && make tests"
767 767
768 768 - see all changesets whose states are already known in the current
769 769 bisection::
770 770
771 771 hg log -r "bisect(pruned)"
772 772
773 773 - see the changeset currently being bisected (especially useful
774 774 if running with -U/--noupdate)::
775 775
776 776 hg log -r "bisect(current)"
777 777
778 778 - see all changesets that took part in the current bisection::
779 779
780 780 hg log -r "bisect(range)"
781 781
782 782 - you can even get a nice graph::
783 783
784 784 hg log --graph -r "bisect(range)"
785 785
786 786 See :hg:`help revsets` for more about the `bisect()` keyword.
787 787
788 788 Returns 0 on success.
789 789 """
790 790 def extendbisectrange(nodes, good):
791 791 # bisect is incomplete when it ends on a merge node and
792 792 # one of the parent was not checked.
793 793 parents = repo[nodes[0]].parents()
794 794 if len(parents) > 1:
795 795 if good:
796 796 side = state['bad']
797 797 else:
798 798 side = state['good']
799 799 num = len(set(i.node() for i in parents) & set(side))
800 800 if num == 1:
801 801 return parents[0].ancestor(parents[1])
802 802 return None
803 803
804 804 def print_result(nodes, good):
805 805 displayer = cmdutil.show_changeset(ui, repo, {})
806 806 if len(nodes) == 1:
807 807 # narrowed it down to a single revision
808 808 if good:
809 809 ui.write(_("The first good revision is:\n"))
810 810 else:
811 811 ui.write(_("The first bad revision is:\n"))
812 812 displayer.show(repo[nodes[0]])
813 813 extendnode = extendbisectrange(nodes, good)
814 814 if extendnode is not None:
815 815 ui.write(_('Not all ancestors of this changeset have been'
816 816 ' checked.\nUse bisect --extend to continue the '
817 817 'bisection from\nthe common ancestor, %s.\n')
818 818 % extendnode)
819 819 else:
820 820 # multiple possible revisions
821 821 if good:
822 822 ui.write(_("Due to skipped revisions, the first "
823 823 "good revision could be any of:\n"))
824 824 else:
825 825 ui.write(_("Due to skipped revisions, the first "
826 826 "bad revision could be any of:\n"))
827 827 for n in nodes:
828 828 displayer.show(repo[n])
829 829 displayer.close()
830 830
831 831 def check_state(state, interactive=True):
832 832 if not state['good'] or not state['bad']:
833 833 if (good or bad or skip or reset) and interactive:
834 834 return
835 835 if not state['good']:
836 836 raise error.Abort(_('cannot bisect (no known good revisions)'))
837 837 else:
838 838 raise error.Abort(_('cannot bisect (no known bad revisions)'))
839 839 return True
840 840
841 841 # backward compatibility
842 842 if rev in "good bad reset init".split():
843 843 ui.warn(_("(use of 'hg bisect <cmd>' is deprecated)\n"))
844 844 cmd, rev, extra = rev, extra, None
845 845 if cmd == "good":
846 846 good = True
847 847 elif cmd == "bad":
848 848 bad = True
849 849 else:
850 850 reset = True
851 851 elif extra or good + bad + skip + reset + extend + bool(command) > 1:
852 852 raise error.Abort(_('incompatible arguments'))
853 853
854 854 cmdutil.checkunfinished(repo)
855 855
856 856 if reset:
857 857 p = repo.join("bisect.state")
858 858 if os.path.exists(p):
859 859 os.unlink(p)
860 860 return
861 861
862 862 state = hbisect.load_state(repo)
863 863
864 864 if command:
865 865 changesets = 1
866 866 if noupdate:
867 867 try:
868 868 node = state['current'][0]
869 869 except LookupError:
870 870 raise error.Abort(_('current bisect revision is unknown - '
871 871 'start a new bisect to fix'))
872 872 else:
873 873 node, p2 = repo.dirstate.parents()
874 874 if p2 != nullid:
875 875 raise error.Abort(_('current bisect revision is a merge'))
876 876 try:
877 877 while changesets:
878 878 # update state
879 879 state['current'] = [node]
880 880 hbisect.save_state(repo, state)
881 881 status = ui.system(command, environ={'HG_NODE': hex(node)})
882 882 if status == 125:
883 883 transition = "skip"
884 884 elif status == 0:
885 885 transition = "good"
886 886 # status < 0 means process was killed
887 887 elif status == 127:
888 888 raise error.Abort(_("failed to execute %s") % command)
889 889 elif status < 0:
890 890 raise error.Abort(_("%s killed") % command)
891 891 else:
892 892 transition = "bad"
893 893 ctx = scmutil.revsingle(repo, rev, node)
894 894 rev = None # clear for future iterations
895 895 state[transition].append(ctx.node())
896 896 ui.status(_('changeset %d:%s: %s\n') % (ctx, ctx, transition))
897 897 check_state(state, interactive=False)
898 898 # bisect
899 899 nodes, changesets, bgood = hbisect.bisect(repo.changelog, state)
900 900 # update to next check
901 901 node = nodes[0]
902 902 if not noupdate:
903 903 cmdutil.bailifchanged(repo)
904 904 hg.clean(repo, node, show_stats=False)
905 905 finally:
906 906 state['current'] = [node]
907 907 hbisect.save_state(repo, state)
908 908 print_result(nodes, bgood)
909 909 return
910 910
911 911 # update state
912 912
913 913 if rev:
914 914 nodes = [repo.lookup(i) for i in scmutil.revrange(repo, [rev])]
915 915 else:
916 916 nodes = [repo.lookup('.')]
917 917
918 918 if good or bad or skip:
919 919 if good:
920 920 state['good'] += nodes
921 921 elif bad:
922 922 state['bad'] += nodes
923 923 elif skip:
924 924 state['skip'] += nodes
925 925 hbisect.save_state(repo, state)
926 926
927 927 if not check_state(state):
928 928 return
929 929
930 930 # actually bisect
931 931 nodes, changesets, good = hbisect.bisect(repo.changelog, state)
932 932 if extend:
933 933 if not changesets:
934 934 extendnode = extendbisectrange(nodes, good)
935 935 if extendnode is not None:
936 936 ui.write(_("Extending search to changeset %d:%s\n")
937 937 % (extendnode.rev(), extendnode))
938 938 state['current'] = [extendnode.node()]
939 939 hbisect.save_state(repo, state)
940 940 if noupdate:
941 941 return
942 942 cmdutil.bailifchanged(repo)
943 943 return hg.clean(repo, extendnode.node())
944 944 raise error.Abort(_("nothing to extend"))
945 945
946 946 if changesets == 0:
947 947 print_result(nodes, good)
948 948 else:
949 949 assert len(nodes) == 1 # only a single node can be tested next
950 950 node = nodes[0]
951 951 # compute the approximate number of remaining tests
952 952 tests, size = 0, 2
953 953 while size <= changesets:
954 954 tests, size = tests + 1, size * 2
955 955 rev = repo.changelog.rev(node)
956 956 ui.write(_("Testing changeset %d:%s "
957 957 "(%d changesets remaining, ~%d tests)\n")
958 958 % (rev, short(node), changesets, tests))
959 959 state['current'] = [node]
960 960 hbisect.save_state(repo, state)
961 961 if not noupdate:
962 962 cmdutil.bailifchanged(repo)
963 963 return hg.clean(repo, node)
964 964
965 965 @command('bookmarks|bookmark',
966 966 [('f', 'force', False, _('force')),
967 967 ('r', 'rev', '', _('revision'), _('REV')),
968 968 ('d', 'delete', False, _('delete a given bookmark')),
969 969 ('m', 'rename', '', _('rename a given bookmark'), _('OLD')),
970 970 ('i', 'inactive', False, _('mark a bookmark inactive')),
971 971 ] + formatteropts,
972 972 _('hg bookmarks [OPTIONS]... [NAME]...'))
973 973 def bookmark(ui, repo, *names, **opts):
974 974 '''create a new bookmark or list existing bookmarks
975 975
976 976 Bookmarks are labels on changesets to help track lines of development.
977 977 Bookmarks are unversioned and can be moved, renamed and deleted.
978 978 Deleting or moving a bookmark has no effect on the associated changesets.
979 979
980 980 Creating or updating to a bookmark causes it to be marked as 'active'.
981 981 The active bookmark is indicated with a '*'.
982 982 When a commit is made, the active bookmark will advance to the new commit.
983 983 A plain :hg:`update` will also advance an active bookmark, if possible.
984 984 Updating away from a bookmark will cause it to be deactivated.
985 985
986 986 Bookmarks can be pushed and pulled between repositories (see
987 987 :hg:`help push` and :hg:`help pull`). If a shared bookmark has
988 988 diverged, a new 'divergent bookmark' of the form 'name@path' will
989 989 be created. Using :hg:`merge` will resolve the divergence.
990 990
991 991 A bookmark named '@' has the special property that :hg:`clone` will
992 992 check it out by default if it exists.
993 993
994 994 .. container:: verbose
995 995
996 996 Examples:
997 997
998 998 - create an active bookmark for a new line of development::
999 999
1000 1000 hg book new-feature
1001 1001
1002 1002 - create an inactive bookmark as a place marker::
1003 1003
1004 1004 hg book -i reviewed
1005 1005
1006 1006 - create an inactive bookmark on another changeset::
1007 1007
1008 1008 hg book -r .^ tested
1009 1009
1010 1010 - rename bookmark turkey to dinner::
1011 1011
1012 1012 hg book -m turkey dinner
1013 1013
1014 1014 - move the '@' bookmark from another branch::
1015 1015
1016 1016 hg book -f @
1017 1017 '''
1018 1018 force = opts.get('force')
1019 1019 rev = opts.get('rev')
1020 1020 delete = opts.get('delete')
1021 1021 rename = opts.get('rename')
1022 1022 inactive = opts.get('inactive')
1023 1023
1024 1024 def checkformat(mark):
1025 1025 mark = mark.strip()
1026 1026 if not mark:
1027 1027 raise error.Abort(_("bookmark names cannot consist entirely of "
1028 1028 "whitespace"))
1029 1029 scmutil.checknewlabel(repo, mark, 'bookmark')
1030 1030 return mark
1031 1031
1032 1032 def checkconflict(repo, mark, cur, force=False, target=None):
1033 1033 if mark in marks and not force:
1034 1034 if target:
1035 1035 if marks[mark] == target and target == cur:
1036 1036 # re-activating a bookmark
1037 1037 return
1038 1038 anc = repo.changelog.ancestors([repo[target].rev()])
1039 1039 bmctx = repo[marks[mark]]
1040 1040 divs = [repo[b].node() for b in marks
1041 1041 if b.split('@', 1)[0] == mark.split('@', 1)[0]]
1042 1042
1043 1043 # allow resolving a single divergent bookmark even if moving
1044 1044 # the bookmark across branches when a revision is specified
1045 1045 # that contains a divergent bookmark
1046 1046 if bmctx.rev() not in anc and target in divs:
1047 1047 bookmarks.deletedivergent(repo, [target], mark)
1048 1048 return
1049 1049
1050 1050 deletefrom = [b for b in divs
1051 1051 if repo[b].rev() in anc or b == target]
1052 1052 bookmarks.deletedivergent(repo, deletefrom, mark)
1053 1053 if bookmarks.validdest(repo, bmctx, repo[target]):
1054 1054 ui.status(_("moving bookmark '%s' forward from %s\n") %
1055 1055 (mark, short(bmctx.node())))
1056 1056 return
1057 1057 raise error.Abort(_("bookmark '%s' already exists "
1058 1058 "(use -f to force)") % mark)
1059 1059 if ((mark in repo.branchmap() or mark == repo.dirstate.branch())
1060 1060 and not force):
1061 1061 raise error.Abort(
1062 1062 _("a bookmark cannot have the name of an existing branch"))
1063 1063
1064 1064 if delete and rename:
1065 1065 raise error.Abort(_("--delete and --rename are incompatible"))
1066 1066 if delete and rev:
1067 1067 raise error.Abort(_("--rev is incompatible with --delete"))
1068 1068 if rename and rev:
1069 1069 raise error.Abort(_("--rev is incompatible with --rename"))
1070 1070 if not names and (delete or rev):
1071 1071 raise error.Abort(_("bookmark name required"))
1072 1072
1073 1073 if delete or rename or names or inactive:
1074 1074 wlock = lock = tr = None
1075 1075 try:
1076 1076 wlock = repo.wlock()
1077 1077 lock = repo.lock()
1078 1078 cur = repo.changectx('.').node()
1079 1079 marks = repo._bookmarks
1080 1080 if delete:
1081 1081 tr = repo.transaction('bookmark')
1082 1082 for mark in names:
1083 1083 if mark not in marks:
1084 1084 raise error.Abort(_("bookmark '%s' does not exist") %
1085 1085 mark)
1086 1086 if mark == repo._activebookmark:
1087 1087 bookmarks.deactivate(repo)
1088 1088 del marks[mark]
1089 1089
1090 1090 elif rename:
1091 1091 tr = repo.transaction('bookmark')
1092 1092 if not names:
1093 1093 raise error.Abort(_("new bookmark name required"))
1094 1094 elif len(names) > 1:
1095 1095 raise error.Abort(_("only one new bookmark name allowed"))
1096 1096 mark = checkformat(names[0])
1097 1097 if rename not in marks:
1098 1098 raise error.Abort(_("bookmark '%s' does not exist")
1099 1099 % rename)
1100 1100 checkconflict(repo, mark, cur, force)
1101 1101 marks[mark] = marks[rename]
1102 1102 if repo._activebookmark == rename and not inactive:
1103 1103 bookmarks.activate(repo, mark)
1104 1104 del marks[rename]
1105 1105 elif names:
1106 1106 tr = repo.transaction('bookmark')
1107 1107 newact = None
1108 1108 for mark in names:
1109 1109 mark = checkformat(mark)
1110 1110 if newact is None:
1111 1111 newact = mark
1112 1112 if inactive and mark == repo._activebookmark:
1113 1113 bookmarks.deactivate(repo)
1114 1114 return
1115 1115 tgt = cur
1116 1116 if rev:
1117 1117 tgt = scmutil.revsingle(repo, rev).node()
1118 1118 checkconflict(repo, mark, cur, force, tgt)
1119 1119 marks[mark] = tgt
1120 1120 if not inactive and cur == marks[newact] and not rev:
1121 1121 bookmarks.activate(repo, newact)
1122 1122 elif cur != tgt and newact == repo._activebookmark:
1123 1123 bookmarks.deactivate(repo)
1124 1124 elif inactive:
1125 1125 if len(marks) == 0:
1126 1126 ui.status(_("no bookmarks set\n"))
1127 1127 elif not repo._activebookmark:
1128 1128 ui.status(_("no active bookmark\n"))
1129 1129 else:
1130 1130 bookmarks.deactivate(repo)
1131 1131 if tr is not None:
1132 1132 marks.recordchange(tr)
1133 1133 tr.close()
1134 1134 finally:
1135 1135 lockmod.release(tr, lock, wlock)
1136 1136 else: # show bookmarks
1137 1137 fm = ui.formatter('bookmarks', opts)
1138 1138 hexfn = fm.hexfunc
1139 1139 marks = repo._bookmarks
1140 1140 if len(marks) == 0 and not fm:
1141 1141 ui.status(_("no bookmarks set\n"))
1142 1142 for bmark, n in sorted(marks.iteritems()):
1143 1143 active = repo._activebookmark
1144 1144 if bmark == active:
1145 1145 prefix, label = '*', activebookmarklabel
1146 1146 else:
1147 1147 prefix, label = ' ', ''
1148 1148
1149 1149 fm.startitem()
1150 1150 if not ui.quiet:
1151 1151 fm.plain(' %s ' % prefix, label=label)
1152 1152 fm.write('bookmark', '%s', bmark, label=label)
1153 1153 pad = " " * (25 - encoding.colwidth(bmark))
1154 1154 fm.condwrite(not ui.quiet, 'rev node', pad + ' %d:%s',
1155 1155 repo.changelog.rev(n), hexfn(n), label=label)
1156 1156 fm.data(active=(bmark == active))
1157 1157 fm.plain('\n')
1158 1158 fm.end()
1159 1159
1160 1160 @command('branch',
1161 1161 [('f', 'force', None,
1162 1162 _('set branch name even if it shadows an existing branch')),
1163 1163 ('C', 'clean', None, _('reset branch name to parent branch name'))],
1164 1164 _('[-fC] [NAME]'))
1165 1165 def branch(ui, repo, label=None, **opts):
1166 1166 """set or show the current branch name
1167 1167
1168 1168 .. note::
1169 1169
1170 1170 Branch names are permanent and global. Use :hg:`bookmark` to create a
1171 1171 light-weight bookmark instead. See :hg:`help glossary` for more
1172 1172 information about named branches and bookmarks.
1173 1173
1174 1174 With no argument, show the current branch name. With one argument,
1175 1175 set the working directory branch name (the branch will not exist
1176 1176 in the repository until the next commit). Standard practice
1177 1177 recommends that primary development take place on the 'default'
1178 1178 branch.
1179 1179
1180 1180 Unless -f/--force is specified, branch will not let you set a
1181 1181 branch name that already exists.
1182 1182
1183 1183 Use -C/--clean to reset the working directory branch to that of
1184 1184 the parent of the working directory, negating a previous branch
1185 1185 change.
1186 1186
1187 1187 Use the command :hg:`update` to switch to an existing branch. Use
1188 1188 :hg:`commit --close-branch` to mark this branch head as closed.
1189 1189 When all heads of the branch are closed, the branch will be
1190 1190 considered closed.
1191 1191
1192 1192 Returns 0 on success.
1193 1193 """
1194 1194 if label:
1195 1195 label = label.strip()
1196 1196
1197 1197 if not opts.get('clean') and not label:
1198 1198 ui.write("%s\n" % repo.dirstate.branch())
1199 1199 return
1200 1200
1201 1201 wlock = repo.wlock()
1202 1202 try:
1203 1203 if opts.get('clean'):
1204 1204 label = repo[None].p1().branch()
1205 1205 repo.dirstate.setbranch(label)
1206 1206 ui.status(_('reset working directory to branch %s\n') % label)
1207 1207 elif label:
1208 1208 if not opts.get('force') and label in repo.branchmap():
1209 1209 if label not in [p.branch() for p in repo[None].parents()]:
1210 1210 raise error.Abort(_('a branch of the same name already'
1211 1211 ' exists'),
1212 1212 # i18n: "it" refers to an existing branch
1213 1213 hint=_("use 'hg update' to switch to it"))
1214 1214 scmutil.checknewlabel(repo, label, 'branch')
1215 1215 repo.dirstate.setbranch(label)
1216 1216 ui.status(_('marked working directory as branch %s\n') % label)
1217 1217
1218 1218 # find any open named branches aside from default
1219 1219 others = [n for n, h, t, c in repo.branchmap().iterbranches()
1220 1220 if n != "default" and not c]
1221 1221 if not others:
1222 1222 ui.status(_('(branches are permanent and global, '
1223 1223 'did you want a bookmark?)\n'))
1224 1224 finally:
1225 1225 wlock.release()
1226 1226
1227 1227 @command('branches',
1228 1228 [('a', 'active', False,
1229 1229 _('show only branches that have unmerged heads (DEPRECATED)')),
1230 1230 ('c', 'closed', False, _('show normal and closed branches')),
1231 1231 ] + formatteropts,
1232 1232 _('[-ac]'))
1233 1233 def branches(ui, repo, active=False, closed=False, **opts):
1234 1234 """list repository named branches
1235 1235
1236 1236 List the repository's named branches, indicating which ones are
1237 1237 inactive. If -c/--closed is specified, also list branches which have
1238 1238 been marked closed (see :hg:`commit --close-branch`).
1239 1239
1240 1240 Use the command :hg:`update` to switch to an existing branch.
1241 1241
1242 1242 Returns 0.
1243 1243 """
1244 1244
1245 1245 fm = ui.formatter('branches', opts)
1246 1246 hexfunc = fm.hexfunc
1247 1247
1248 1248 allheads = set(repo.heads())
1249 1249 branches = []
1250 1250 for tag, heads, tip, isclosed in repo.branchmap().iterbranches():
1251 1251 isactive = not isclosed and bool(set(heads) & allheads)
1252 1252 branches.append((tag, repo[tip], isactive, not isclosed))
1253 1253 branches.sort(key=lambda i: (i[2], i[1].rev(), i[0], i[3]),
1254 1254 reverse=True)
1255 1255
1256 1256 for tag, ctx, isactive, isopen in branches:
1257 1257 if active and not isactive:
1258 1258 continue
1259 1259 if isactive:
1260 1260 label = 'branches.active'
1261 1261 notice = ''
1262 1262 elif not isopen:
1263 1263 if not closed:
1264 1264 continue
1265 1265 label = 'branches.closed'
1266 1266 notice = _(' (closed)')
1267 1267 else:
1268 1268 label = 'branches.inactive'
1269 1269 notice = _(' (inactive)')
1270 1270 current = (tag == repo.dirstate.branch())
1271 1271 if current:
1272 1272 label = 'branches.current'
1273 1273
1274 1274 fm.startitem()
1275 1275 fm.write('branch', '%s', tag, label=label)
1276 1276 rev = ctx.rev()
1277 1277 padsize = max(31 - len(str(rev)) - encoding.colwidth(tag), 0)
1278 1278 fmt = ' ' * padsize + ' %d:%s'
1279 1279 fm.condwrite(not ui.quiet, 'rev node', fmt, rev, hexfunc(ctx.node()),
1280 1280 label='log.changeset changeset.%s' % ctx.phasestr())
1281 1281 fm.data(active=isactive, closed=not isopen, current=current)
1282 1282 if not ui.quiet:
1283 1283 fm.plain(notice)
1284 1284 fm.plain('\n')
1285 1285 fm.end()
1286 1286
1287 1287 @command('bundle',
1288 1288 [('f', 'force', None, _('run even when the destination is unrelated')),
1289 1289 ('r', 'rev', [], _('a changeset intended to be added to the destination'),
1290 1290 _('REV')),
1291 1291 ('b', 'branch', [], _('a specific branch you would like to bundle'),
1292 1292 _('BRANCH')),
1293 1293 ('', 'base', [],
1294 1294 _('a base changeset assumed to be available at the destination'),
1295 1295 _('REV')),
1296 1296 ('a', 'all', None, _('bundle all changesets in the repository')),
1297 1297 ('t', 'type', 'bzip2', _('bundle compression type to use'), _('TYPE')),
1298 1298 ] + remoteopts,
1299 1299 _('[-f] [-t TYPE] [-a] [-r REV]... [--base REV]... FILE [DEST]'))
1300 1300 def bundle(ui, repo, fname, dest=None, **opts):
1301 1301 """create a changegroup file
1302 1302
1303 1303 Generate a compressed changegroup file collecting changesets not
1304 1304 known to be in another repository.
1305 1305
1306 1306 If you omit the destination repository, then hg assumes the
1307 1307 destination will have all the nodes you specify with --base
1308 1308 parameters. To create a bundle containing all changesets, use
1309 1309 -a/--all (or --base null).
1310 1310
1311 1311 You can change bundle format with the -t/--type option. You can
1312 1312 specify a compression, a bundle version or both using a dash
1313 1313 (comp-version). The available compression methods are: none, bzip2,
1314 1314 and gzip (by default, bundles are compressed using bzip2). The
1315 1315 available format are: v1, v2 (default to most suitable).
1316 1316
1317 1317 The bundle file can then be transferred using conventional means
1318 1318 and applied to another repository with the unbundle or pull
1319 1319 command. This is useful when direct push and pull are not
1320 1320 available or when exporting an entire repository is undesirable.
1321 1321
1322 1322 Applying bundles preserves all changeset contents including
1323 1323 permissions, copy/rename information, and revision history.
1324 1324
1325 1325 Returns 0 on success, 1 if no changes found.
1326 1326 """
1327 1327 revs = None
1328 1328 if 'rev' in opts:
1329 1329 revs = scmutil.revrange(repo, opts['rev'])
1330 1330
1331 1331 bundletype = opts.get('type', 'bzip2').lower()
1332 1332 try:
1333 1333 bcompression, cgversion, params = exchange.parsebundlespec(
1334 1334 repo, bundletype, strict=False)
1335 1335 except error.UnsupportedBundleSpecification as e:
1336 1336 raise error.Abort(str(e),
1337 1337 hint=_('see "hg help bundle" for supported '
1338 1338 'values for --type'))
1339 1339
1340 1340 # Packed bundles are a pseudo bundle format for now.
1341 1341 if cgversion == 's1':
1342 1342 raise error.Abort(_('packed bundles cannot be produced by "hg bundle"'),
1343 1343 hint=_('use "hg debugcreatestreamclonebundle"'))
1344 1344
1345 1345 if opts.get('all'):
1346 1346 base = ['null']
1347 1347 else:
1348 1348 base = scmutil.revrange(repo, opts.get('base'))
1349 1349 # TODO: get desired bundlecaps from command line.
1350 1350 bundlecaps = None
1351 1351 if base:
1352 1352 if dest:
1353 1353 raise error.Abort(_("--base is incompatible with specifying "
1354 1354 "a destination"))
1355 1355 common = [repo.lookup(rev) for rev in base]
1356 1356 heads = revs and map(repo.lookup, revs) or revs
1357 1357 cg = changegroup.getchangegroup(repo, 'bundle', heads=heads,
1358 1358 common=common, bundlecaps=bundlecaps,
1359 1359 version=cgversion)
1360 1360 outgoing = None
1361 1361 else:
1362 1362 dest = ui.expandpath(dest or 'default-push', dest or 'default')
1363 1363 dest, branches = hg.parseurl(dest, opts.get('branch'))
1364 1364 other = hg.peer(repo, opts, dest)
1365 1365 revs, checkout = hg.addbranchrevs(repo, repo, branches, revs)
1366 1366 heads = revs and map(repo.lookup, revs) or revs
1367 1367 outgoing = discovery.findcommonoutgoing(repo, other,
1368 1368 onlyheads=heads,
1369 1369 force=opts.get('force'),
1370 1370 portable=True)
1371 1371 cg = changegroup.getlocalchangegroup(repo, 'bundle', outgoing,
1372 1372 bundlecaps, version=cgversion)
1373 1373 if not cg:
1374 1374 scmutil.nochangesfound(ui, repo, outgoing and outgoing.excluded)
1375 1375 return 1
1376 1376
1377 1377 if cgversion == '01': #bundle1
1378 1378 if bcompression is None:
1379 1379 bcompression = 'UN'
1380 1380 bversion = 'HG10' + bcompression
1381 1381 bcompression = None
1382 1382 else:
1383 1383 assert cgversion == '02'
1384 1384 bversion = 'HG20'
1385 1385
1386 1386
1387 1387 changegroup.writebundle(ui, cg, fname, bversion, compression=bcompression)
1388 1388
1389 1389 @command('cat',
1390 1390 [('o', 'output', '',
1391 1391 _('print output to file with formatted name'), _('FORMAT')),
1392 1392 ('r', 'rev', '', _('print the given revision'), _('REV')),
1393 1393 ('', 'decode', None, _('apply any matching decode filter')),
1394 1394 ] + walkopts,
1395 1395 _('[OPTION]... FILE...'),
1396 1396 inferrepo=True)
1397 1397 def cat(ui, repo, file1, *pats, **opts):
1398 1398 """output the current or given revision of files
1399 1399
1400 1400 Print the specified files as they were at the given revision. If
1401 1401 no revision is given, the parent of the working directory is used.
1402 1402
1403 1403 Output may be to a file, in which case the name of the file is
1404 1404 given using a format string. The formatting rules as follows:
1405 1405
1406 1406 :``%%``: literal "%" character
1407 1407 :``%s``: basename of file being printed
1408 1408 :``%d``: dirname of file being printed, or '.' if in repository root
1409 1409 :``%p``: root-relative path name of file being printed
1410 1410 :``%H``: changeset hash (40 hexadecimal digits)
1411 1411 :``%R``: changeset revision number
1412 1412 :``%h``: short-form changeset hash (12 hexadecimal digits)
1413 1413 :``%r``: zero-padded changeset revision number
1414 1414 :``%b``: basename of the exporting repository
1415 1415
1416 1416 Returns 0 on success.
1417 1417 """
1418 1418 ctx = scmutil.revsingle(repo, opts.get('rev'))
1419 1419 m = scmutil.match(ctx, (file1,) + pats, opts)
1420 1420
1421 1421 return cmdutil.cat(ui, repo, ctx, m, '', **opts)
1422 1422
1423 1423 @command('^clone',
1424 1424 [('U', 'noupdate', None, _('the clone will include an empty working '
1425 1425 'directory (only a repository)')),
1426 1426 ('u', 'updaterev', '', _('revision, tag, or branch to check out'),
1427 1427 _('REV')),
1428 1428 ('r', 'rev', [], _('include the specified changeset'), _('REV')),
1429 1429 ('b', 'branch', [], _('clone only the specified branch'), _('BRANCH')),
1430 1430 ('', 'pull', None, _('use pull protocol to copy metadata')),
1431 1431 ('', 'uncompressed', None, _('use uncompressed transfer (fast over LAN)')),
1432 1432 ] + remoteopts,
1433 1433 _('[OPTION]... SOURCE [DEST]'),
1434 1434 norepo=True)
1435 1435 def clone(ui, source, dest=None, **opts):
1436 1436 """make a copy of an existing repository
1437 1437
1438 1438 Create a copy of an existing repository in a new directory.
1439 1439
1440 1440 If no destination directory name is specified, it defaults to the
1441 1441 basename of the source.
1442 1442
1443 1443 The location of the source is added to the new repository's
1444 1444 ``.hg/hgrc`` file, as the default to be used for future pulls.
1445 1445
1446 1446 Only local paths and ``ssh://`` URLs are supported as
1447 1447 destinations. For ``ssh://`` destinations, no working directory or
1448 1448 ``.hg/hgrc`` will be created on the remote side.
1449 1449
1450 1450 To pull only a subset of changesets, specify one or more revisions
1451 1451 identifiers with -r/--rev or branches with -b/--branch. The
1452 1452 resulting clone will contain only the specified changesets and
1453 1453 their ancestors. These options (or 'clone src#rev dest') imply
1454 1454 --pull, even for local source repositories. Note that specifying a
1455 1455 tag will include the tagged changeset but not the changeset
1456 1456 containing the tag.
1457 1457
1458 1458 If the source repository has a bookmark called '@' set, that
1459 1459 revision will be checked out in the new repository by default.
1460 1460
1461 1461 To check out a particular version, use -u/--update, or
1462 1462 -U/--noupdate to create a clone with no working directory.
1463 1463
1464 1464 .. container:: verbose
1465 1465
1466 1466 For efficiency, hardlinks are used for cloning whenever the
1467 1467 source and destination are on the same filesystem (note this
1468 1468 applies only to the repository data, not to the working
1469 1469 directory). Some filesystems, such as AFS, implement hardlinking
1470 1470 incorrectly, but do not report errors. In these cases, use the
1471 1471 --pull option to avoid hardlinking.
1472 1472
1473 1473 In some cases, you can clone repositories and the working
1474 1474 directory using full hardlinks with ::
1475 1475
1476 1476 $ cp -al REPO REPOCLONE
1477 1477
1478 1478 This is the fastest way to clone, but it is not always safe. The
1479 1479 operation is not atomic (making sure REPO is not modified during
1480 1480 the operation is up to you) and you have to make sure your
1481 1481 editor breaks hardlinks (Emacs and most Linux Kernel tools do
1482 1482 so). Also, this is not compatible with certain extensions that
1483 1483 place their metadata under the .hg directory, such as mq.
1484 1484
1485 1485 Mercurial will update the working directory to the first applicable
1486 1486 revision from this list:
1487 1487
1488 1488 a) null if -U or the source repository has no changesets
1489 1489 b) if -u . and the source repository is local, the first parent of
1490 1490 the source repository's working directory
1491 1491 c) the changeset specified with -u (if a branch name, this means the
1492 1492 latest head of that branch)
1493 1493 d) the changeset specified with -r
1494 1494 e) the tipmost head specified with -b
1495 1495 f) the tipmost head specified with the url#branch source syntax
1496 1496 g) the revision marked with the '@' bookmark, if present
1497 1497 h) the tipmost head of the default branch
1498 1498 i) tip
1499 1499
1500 1500 Examples:
1501 1501
1502 1502 - clone a remote repository to a new directory named hg/::
1503 1503
1504 1504 hg clone http://selenic.com/hg
1505 1505
1506 1506 - create a lightweight local clone::
1507 1507
1508 1508 hg clone project/ project-feature/
1509 1509
1510 1510 - clone from an absolute path on an ssh server (note double-slash)::
1511 1511
1512 1512 hg clone ssh://user@server//home/projects/alpha/
1513 1513
1514 1514 - do a high-speed clone over a LAN while checking out a
1515 1515 specified version::
1516 1516
1517 1517 hg clone --uncompressed http://server/repo -u 1.5
1518 1518
1519 1519 - create a repository without changesets after a particular revision::
1520 1520
1521 1521 hg clone -r 04e544 experimental/ good/
1522 1522
1523 1523 - clone (and track) a particular named branch::
1524 1524
1525 1525 hg clone http://selenic.com/hg#stable
1526 1526
1527 1527 See :hg:`help urls` for details on specifying URLs.
1528 1528
1529 1529 Returns 0 on success.
1530 1530 """
1531 1531 if opts.get('noupdate') and opts.get('updaterev'):
1532 1532 raise error.Abort(_("cannot specify both --noupdate and --updaterev"))
1533 1533
1534 1534 r = hg.clone(ui, opts, source, dest,
1535 1535 pull=opts.get('pull'),
1536 1536 stream=opts.get('uncompressed'),
1537 1537 rev=opts.get('rev'),
1538 1538 update=opts.get('updaterev') or not opts.get('noupdate'),
1539 1539 branch=opts.get('branch'),
1540 1540 shareopts=opts.get('shareopts'))
1541 1541
1542 1542 return r is None
1543 1543
1544 1544 @command('^commit|ci',
1545 1545 [('A', 'addremove', None,
1546 1546 _('mark new/missing files as added/removed before committing')),
1547 1547 ('', 'close-branch', None,
1548 1548 _('mark a branch head as closed')),
1549 1549 ('', 'amend', None, _('amend the parent of the working directory')),
1550 1550 ('s', 'secret', None, _('use the secret phase for committing')),
1551 1551 ('e', 'edit', None, _('invoke editor on commit messages')),
1552 1552 ('i', 'interactive', None, _('use interactive mode')),
1553 1553 ] + walkopts + commitopts + commitopts2 + subrepoopts,
1554 1554 _('[OPTION]... [FILE]...'),
1555 1555 inferrepo=True)
1556 1556 def commit(ui, repo, *pats, **opts):
1557 1557 """commit the specified files or all outstanding changes
1558 1558
1559 1559 Commit changes to the given files into the repository. Unlike a
1560 1560 centralized SCM, this operation is a local operation. See
1561 1561 :hg:`push` for a way to actively distribute your changes.
1562 1562
1563 1563 If a list of files is omitted, all changes reported by :hg:`status`
1564 1564 will be committed.
1565 1565
1566 1566 If you are committing the result of a merge, do not provide any
1567 1567 filenames or -I/-X filters.
1568 1568
1569 1569 If no commit message is specified, Mercurial starts your
1570 1570 configured editor where you can enter a message. In case your
1571 1571 commit fails, you will find a backup of your message in
1572 1572 ``.hg/last-message.txt``.
1573 1573
1574 1574 The --close-branch flag can be used to mark the current branch
1575 1575 head closed. When all heads of a branch are closed, the branch
1576 1576 will be considered closed and no longer listed.
1577 1577
1578 1578 The --amend flag can be used to amend the parent of the
1579 1579 working directory with a new commit that contains the changes
1580 1580 in the parent in addition to those currently reported by :hg:`status`,
1581 1581 if there are any. The old commit is stored in a backup bundle in
1582 1582 ``.hg/strip-backup`` (see :hg:`help bundle` and :hg:`help unbundle`
1583 1583 on how to restore it).
1584 1584
1585 1585 Message, user and date are taken from the amended commit unless
1586 1586 specified. When a message isn't specified on the command line,
1587 1587 the editor will open with the message of the amended commit.
1588 1588
1589 1589 It is not possible to amend public changesets (see :hg:`help phases`)
1590 1590 or changesets that have children.
1591 1591
1592 1592 See :hg:`help dates` for a list of formats valid for -d/--date.
1593 1593
1594 1594 Returns 0 on success, 1 if nothing changed.
1595 1595
1596 1596 .. container:: verbose
1597 1597
1598 1598 Examples:
1599 1599
1600 1600 - commit all files ending in .py::
1601 1601
1602 1602 hg commit --include "set:**.py"
1603 1603
1604 1604 - commit all non-binary files::
1605 1605
1606 1606 hg commit --exclude "set:binary()"
1607 1607
1608 1608 - amend the current commit and set the date to now::
1609 1609
1610 1610 hg commit --amend --date now
1611 1611 """
1612 1612 wlock = lock = None
1613 1613 try:
1614 1614 wlock = repo.wlock()
1615 1615 lock = repo.lock()
1616 1616 return _docommit(ui, repo, *pats, **opts)
1617 1617 finally:
1618 1618 release(lock, wlock)
1619 1619
1620 1620 def _docommit(ui, repo, *pats, **opts):
1621 1621 if opts.get('interactive'):
1622 1622 opts.pop('interactive')
1623 1623 cmdutil.dorecord(ui, repo, commit, None, False,
1624 1624 cmdutil.recordfilter, *pats, **opts)
1625 1625 return
1626 1626
1627 1627 if opts.get('subrepos'):
1628 1628 if opts.get('amend'):
1629 1629 raise error.Abort(_('cannot amend with --subrepos'))
1630 1630 # Let --subrepos on the command line override config setting.
1631 1631 ui.setconfig('ui', 'commitsubrepos', True, 'commit')
1632 1632
1633 1633 cmdutil.checkunfinished(repo, commit=True)
1634 1634
1635 1635 branch = repo[None].branch()
1636 1636 bheads = repo.branchheads(branch)
1637 1637
1638 1638 extra = {}
1639 1639 if opts.get('close_branch'):
1640 1640 extra['close'] = 1
1641 1641
1642 1642 if not bheads:
1643 1643 raise error.Abort(_('can only close branch heads'))
1644 1644 elif opts.get('amend'):
1645 1645 if repo[None].parents()[0].p1().branch() != branch and \
1646 1646 repo[None].parents()[0].p2().branch() != branch:
1647 1647 raise error.Abort(_('can only close branch heads'))
1648 1648
1649 1649 if opts.get('amend'):
1650 1650 if ui.configbool('ui', 'commitsubrepos'):
1651 1651 raise error.Abort(_('cannot amend with ui.commitsubrepos enabled'))
1652 1652
1653 1653 old = repo['.']
1654 1654 if not old.mutable():
1655 1655 raise error.Abort(_('cannot amend public changesets'))
1656 1656 if len(repo[None].parents()) > 1:
1657 1657 raise error.Abort(_('cannot amend while merging'))
1658 1658 allowunstable = obsolete.isenabled(repo, obsolete.allowunstableopt)
1659 1659 if not allowunstable and old.children():
1660 1660 raise error.Abort(_('cannot amend changeset with children'))
1661 1661
1662 1662 newextra = extra.copy()
1663 1663 newextra['branch'] = branch
1664 1664 extra = newextra
1665 1665 # commitfunc is used only for temporary amend commit by cmdutil.amend
1666 1666 def commitfunc(ui, repo, message, match, opts):
1667 1667 return repo.commit(message,
1668 1668 opts.get('user') or old.user(),
1669 1669 opts.get('date') or old.date(),
1670 1670 match,
1671 1671 extra=extra)
1672 1672
1673 1673 node = cmdutil.amend(ui, repo, commitfunc, old, extra, pats, opts)
1674 1674 if node == old.node():
1675 1675 ui.status(_("nothing changed\n"))
1676 1676 return 1
1677 1677 else:
1678 1678 def commitfunc(ui, repo, message, match, opts):
1679 1679 backup = ui.backupconfig('phases', 'new-commit')
1680 1680 baseui = repo.baseui
1681 1681 basebackup = baseui.backupconfig('phases', 'new-commit')
1682 1682 try:
1683 1683 if opts.get('secret'):
1684 1684 ui.setconfig('phases', 'new-commit', 'secret', 'commit')
1685 1685 # Propagate to subrepos
1686 1686 baseui.setconfig('phases', 'new-commit', 'secret', 'commit')
1687 1687
1688 1688 editform = cmdutil.mergeeditform(repo[None], 'commit.normal')
1689 1689 editor = cmdutil.getcommiteditor(editform=editform, **opts)
1690 1690 return repo.commit(message, opts.get('user'), opts.get('date'),
1691 1691 match,
1692 1692 editor=editor,
1693 1693 extra=extra)
1694 1694 finally:
1695 1695 ui.restoreconfig(backup)
1696 1696 repo.baseui.restoreconfig(basebackup)
1697 1697
1698 1698
1699 1699 node = cmdutil.commit(ui, repo, commitfunc, pats, opts)
1700 1700
1701 1701 if not node:
1702 1702 stat = repo.status(match=scmutil.match(repo[None], pats, opts))
1703 1703 if stat[3]:
1704 1704 ui.status(_("nothing changed (%d missing files, see "
1705 1705 "'hg status')\n") % len(stat[3]))
1706 1706 else:
1707 1707 ui.status(_("nothing changed\n"))
1708 1708 return 1
1709 1709
1710 1710 cmdutil.commitstatus(repo, node, branch, bheads, opts)
1711 1711
1712 1712 @command('config|showconfig|debugconfig',
1713 1713 [('u', 'untrusted', None, _('show untrusted configuration options')),
1714 1714 ('e', 'edit', None, _('edit user config')),
1715 1715 ('l', 'local', None, _('edit repository config')),
1716 1716 ('g', 'global', None, _('edit global config'))],
1717 1717 _('[-u] [NAME]...'),
1718 1718 optionalrepo=True)
1719 1719 def config(ui, repo, *values, **opts):
1720 1720 """show combined config settings from all hgrc files
1721 1721
1722 1722 With no arguments, print names and values of all config items.
1723 1723
1724 1724 With one argument of the form section.name, print just the value
1725 1725 of that config item.
1726 1726
1727 1727 With multiple arguments, print names and values of all config
1728 1728 items with matching section names.
1729 1729
1730 1730 With --edit, start an editor on the user-level config file. With
1731 1731 --global, edit the system-wide config file. With --local, edit the
1732 1732 repository-level config file.
1733 1733
1734 1734 With --debug, the source (filename and line number) is printed
1735 1735 for each config item.
1736 1736
1737 1737 See :hg:`help config` for more information about config files.
1738 1738
1739 1739 Returns 0 on success, 1 if NAME does not exist.
1740 1740
1741 1741 """
1742 1742
1743 1743 if opts.get('edit') or opts.get('local') or opts.get('global'):
1744 1744 if opts.get('local') and opts.get('global'):
1745 1745 raise error.Abort(_("can't use --local and --global together"))
1746 1746
1747 1747 if opts.get('local'):
1748 1748 if not repo:
1749 1749 raise error.Abort(_("can't use --local outside a repository"))
1750 1750 paths = [repo.join('hgrc')]
1751 1751 elif opts.get('global'):
1752 1752 paths = scmutil.systemrcpath()
1753 1753 else:
1754 1754 paths = scmutil.userrcpath()
1755 1755
1756 1756 for f in paths:
1757 1757 if os.path.exists(f):
1758 1758 break
1759 1759 else:
1760 1760 if opts.get('global'):
1761 1761 samplehgrc = uimod.samplehgrcs['global']
1762 1762 elif opts.get('local'):
1763 1763 samplehgrc = uimod.samplehgrcs['local']
1764 1764 else:
1765 1765 samplehgrc = uimod.samplehgrcs['user']
1766 1766
1767 1767 f = paths[0]
1768 1768 fp = open(f, "w")
1769 1769 fp.write(samplehgrc)
1770 1770 fp.close()
1771 1771
1772 1772 editor = ui.geteditor()
1773 1773 ui.system("%s \"%s\"" % (editor, f),
1774 1774 onerr=error.Abort, errprefix=_("edit failed"))
1775 1775 return
1776 1776
1777 1777 for f in scmutil.rcpath():
1778 1778 ui.debug('read config from: %s\n' % f)
1779 1779 untrusted = bool(opts.get('untrusted'))
1780 1780 if values:
1781 1781 sections = [v for v in values if '.' not in v]
1782 1782 items = [v for v in values if '.' in v]
1783 1783 if len(items) > 1 or items and sections:
1784 1784 raise error.Abort(_('only one config item permitted'))
1785 1785 matched = False
1786 1786 for section, name, value in ui.walkconfig(untrusted=untrusted):
1787 1787 value = str(value).replace('\n', '\\n')
1788 1788 sectname = section + '.' + name
1789 1789 if values:
1790 1790 for v in values:
1791 1791 if v == section:
1792 1792 ui.debug('%s: ' %
1793 1793 ui.configsource(section, name, untrusted))
1794 1794 ui.write('%s=%s\n' % (sectname, value))
1795 1795 matched = True
1796 1796 elif v == sectname:
1797 1797 ui.debug('%s: ' %
1798 1798 ui.configsource(section, name, untrusted))
1799 1799 ui.write(value, '\n')
1800 1800 matched = True
1801 1801 else:
1802 1802 ui.debug('%s: ' %
1803 1803 ui.configsource(section, name, untrusted))
1804 1804 ui.write('%s=%s\n' % (sectname, value))
1805 1805 matched = True
1806 1806 if matched:
1807 1807 return 0
1808 1808 return 1
1809 1809
1810 1810 @command('copy|cp',
1811 1811 [('A', 'after', None, _('record a copy that has already occurred')),
1812 1812 ('f', 'force', None, _('forcibly copy over an existing managed file')),
1813 1813 ] + walkopts + dryrunopts,
1814 1814 _('[OPTION]... [SOURCE]... DEST'))
1815 1815 def copy(ui, repo, *pats, **opts):
1816 1816 """mark files as copied for the next commit
1817 1817
1818 1818 Mark dest as having copies of source files. If dest is a
1819 1819 directory, copies are put in that directory. If dest is a file,
1820 1820 the source must be a single file.
1821 1821
1822 1822 By default, this command copies the contents of files as they
1823 1823 exist in the working directory. If invoked with -A/--after, the
1824 1824 operation is recorded, but no copying is performed.
1825 1825
1826 1826 This command takes effect with the next commit. To undo a copy
1827 1827 before that, see :hg:`revert`.
1828 1828
1829 1829 Returns 0 on success, 1 if errors are encountered.
1830 1830 """
1831 1831 wlock = repo.wlock(False)
1832 1832 try:
1833 1833 return cmdutil.copy(ui, repo, pats, opts)
1834 1834 finally:
1835 1835 wlock.release()
1836 1836
1837 1837 @command('debugancestor', [], _('[INDEX] REV1 REV2'), optionalrepo=True)
1838 1838 def debugancestor(ui, repo, *args):
1839 1839 """find the ancestor revision of two revisions in a given index"""
1840 1840 if len(args) == 3:
1841 1841 index, rev1, rev2 = args
1842 1842 r = revlog.revlog(scmutil.opener(os.getcwd(), audit=False), index)
1843 1843 lookup = r.lookup
1844 1844 elif len(args) == 2:
1845 1845 if not repo:
1846 1846 raise error.Abort(_("there is no Mercurial repository here "
1847 1847 "(.hg not found)"))
1848 1848 rev1, rev2 = args
1849 1849 r = repo.changelog
1850 1850 lookup = repo.lookup
1851 1851 else:
1852 1852 raise error.Abort(_('either two or three arguments required'))
1853 1853 a = r.ancestor(lookup(rev1), lookup(rev2))
1854 1854 ui.write("%d:%s\n" % (r.rev(a), hex(a)))
1855 1855
1856 1856 @command('debugbuilddag',
1857 1857 [('m', 'mergeable-file', None, _('add single file mergeable changes')),
1858 1858 ('o', 'overwritten-file', None, _('add single file all revs overwrite')),
1859 1859 ('n', 'new-file', None, _('add new file at each rev'))],
1860 1860 _('[OPTION]... [TEXT]'))
1861 1861 def debugbuilddag(ui, repo, text=None,
1862 1862 mergeable_file=False,
1863 1863 overwritten_file=False,
1864 1864 new_file=False):
1865 1865 """builds a repo with a given DAG from scratch in the current empty repo
1866 1866
1867 1867 The description of the DAG is read from stdin if not given on the
1868 1868 command line.
1869 1869
1870 1870 Elements:
1871 1871
1872 1872 - "+n" is a linear run of n nodes based on the current default parent
1873 1873 - "." is a single node based on the current default parent
1874 1874 - "$" resets the default parent to null (implied at the start);
1875 1875 otherwise the default parent is always the last node created
1876 1876 - "<p" sets the default parent to the backref p
1877 1877 - "*p" is a fork at parent p, which is a backref
1878 1878 - "*p1/p2" is a merge of parents p1 and p2, which are backrefs
1879 1879 - "/p2" is a merge of the preceding node and p2
1880 1880 - ":tag" defines a local tag for the preceding node
1881 1881 - "@branch" sets the named branch for subsequent nodes
1882 1882 - "#...\\n" is a comment up to the end of the line
1883 1883
1884 1884 Whitespace between the above elements is ignored.
1885 1885
1886 1886 A backref is either
1887 1887
1888 1888 - a number n, which references the node curr-n, where curr is the current
1889 1889 node, or
1890 1890 - the name of a local tag you placed earlier using ":tag", or
1891 1891 - empty to denote the default parent.
1892 1892
1893 1893 All string valued-elements are either strictly alphanumeric, or must
1894 1894 be enclosed in double quotes ("..."), with "\\" as escape character.
1895 1895 """
1896 1896
1897 1897 if text is None:
1898 1898 ui.status(_("reading DAG from stdin\n"))
1899 1899 text = ui.fin.read()
1900 1900
1901 1901 cl = repo.changelog
1902 1902 if len(cl) > 0:
1903 1903 raise error.Abort(_('repository is not empty'))
1904 1904
1905 1905 # determine number of revs in DAG
1906 1906 total = 0
1907 1907 for type, data in dagparser.parsedag(text):
1908 1908 if type == 'n':
1909 1909 total += 1
1910 1910
1911 1911 if mergeable_file:
1912 1912 linesperrev = 2
1913 1913 # make a file with k lines per rev
1914 1914 initialmergedlines = [str(i) for i in xrange(0, total * linesperrev)]
1915 1915 initialmergedlines.append("")
1916 1916
1917 1917 tags = []
1918 1918
1919 1919 lock = tr = None
1920 1920 try:
1921 1921 lock = repo.lock()
1922 1922 tr = repo.transaction("builddag")
1923 1923
1924 1924 at = -1
1925 1925 atbranch = 'default'
1926 1926 nodeids = []
1927 1927 id = 0
1928 1928 ui.progress(_('building'), id, unit=_('revisions'), total=total)
1929 1929 for type, data in dagparser.parsedag(text):
1930 1930 if type == 'n':
1931 1931 ui.note(('node %s\n' % str(data)))
1932 1932 id, ps = data
1933 1933
1934 1934 files = []
1935 1935 fctxs = {}
1936 1936
1937 1937 p2 = None
1938 1938 if mergeable_file:
1939 1939 fn = "mf"
1940 1940 p1 = repo[ps[0]]
1941 1941 if len(ps) > 1:
1942 1942 p2 = repo[ps[1]]
1943 1943 pa = p1.ancestor(p2)
1944 1944 base, local, other = [x[fn].data() for x in (pa, p1,
1945 1945 p2)]
1946 1946 m3 = simplemerge.Merge3Text(base, local, other)
1947 1947 ml = [l.strip() for l in m3.merge_lines()]
1948 1948 ml.append("")
1949 1949 elif at > 0:
1950 1950 ml = p1[fn].data().split("\n")
1951 1951 else:
1952 1952 ml = initialmergedlines
1953 1953 ml[id * linesperrev] += " r%i" % id
1954 1954 mergedtext = "\n".join(ml)
1955 1955 files.append(fn)
1956 1956 fctxs[fn] = context.memfilectx(repo, fn, mergedtext)
1957 1957
1958 1958 if overwritten_file:
1959 1959 fn = "of"
1960 1960 files.append(fn)
1961 1961 fctxs[fn] = context.memfilectx(repo, fn, "r%i\n" % id)
1962 1962
1963 1963 if new_file:
1964 1964 fn = "nf%i" % id
1965 1965 files.append(fn)
1966 1966 fctxs[fn] = context.memfilectx(repo, fn, "r%i\n" % id)
1967 1967 if len(ps) > 1:
1968 1968 if not p2:
1969 1969 p2 = repo[ps[1]]
1970 1970 for fn in p2:
1971 1971 if fn.startswith("nf"):
1972 1972 files.append(fn)
1973 1973 fctxs[fn] = p2[fn]
1974 1974
1975 1975 def fctxfn(repo, cx, path):
1976 1976 return fctxs.get(path)
1977 1977
1978 1978 if len(ps) == 0 or ps[0] < 0:
1979 1979 pars = [None, None]
1980 1980 elif len(ps) == 1:
1981 1981 pars = [nodeids[ps[0]], None]
1982 1982 else:
1983 1983 pars = [nodeids[p] for p in ps]
1984 1984 cx = context.memctx(repo, pars, "r%i" % id, files, fctxfn,
1985 1985 date=(id, 0),
1986 1986 user="debugbuilddag",
1987 1987 extra={'branch': atbranch})
1988 1988 nodeid = repo.commitctx(cx)
1989 1989 nodeids.append(nodeid)
1990 1990 at = id
1991 1991 elif type == 'l':
1992 1992 id, name = data
1993 1993 ui.note(('tag %s\n' % name))
1994 1994 tags.append("%s %s\n" % (hex(repo.changelog.node(id)), name))
1995 1995 elif type == 'a':
1996 1996 ui.note(('branch %s\n' % data))
1997 1997 atbranch = data
1998 1998 ui.progress(_('building'), id, unit=_('revisions'), total=total)
1999 1999 tr.close()
2000 2000
2001 2001 if tags:
2002 2002 repo.vfs.write("localtags", "".join(tags))
2003 2003 finally:
2004 2004 ui.progress(_('building'), None)
2005 2005 release(tr, lock)
2006 2006
2007 2007 @command('debugbundle',
2008 2008 [('a', 'all', None, _('show all details'))],
2009 2009 _('FILE'),
2010 2010 norepo=True)
2011 2011 def debugbundle(ui, bundlepath, all=None, **opts):
2012 2012 """lists the contents of a bundle"""
2013 2013 f = hg.openpath(ui, bundlepath)
2014 2014 try:
2015 2015 gen = exchange.readbundle(ui, f, bundlepath)
2016 2016 if isinstance(gen, bundle2.unbundle20):
2017 2017 return _debugbundle2(ui, gen, all=all, **opts)
2018 2018 if all:
2019 2019 ui.write(("format: id, p1, p2, cset, delta base, len(delta)\n"))
2020 2020
2021 2021 def showchunks(named):
2022 2022 ui.write("\n%s\n" % named)
2023 2023 chain = None
2024 2024 while True:
2025 2025 chunkdata = gen.deltachunk(chain)
2026 2026 if not chunkdata:
2027 2027 break
2028 2028 node = chunkdata['node']
2029 2029 p1 = chunkdata['p1']
2030 2030 p2 = chunkdata['p2']
2031 2031 cs = chunkdata['cs']
2032 2032 deltabase = chunkdata['deltabase']
2033 2033 delta = chunkdata['delta']
2034 2034 ui.write("%s %s %s %s %s %s\n" %
2035 2035 (hex(node), hex(p1), hex(p2),
2036 2036 hex(cs), hex(deltabase), len(delta)))
2037 2037 chain = node
2038 2038
2039 2039 chunkdata = gen.changelogheader()
2040 2040 showchunks("changelog")
2041 2041 chunkdata = gen.manifestheader()
2042 2042 showchunks("manifest")
2043 2043 while True:
2044 2044 chunkdata = gen.filelogheader()
2045 2045 if not chunkdata:
2046 2046 break
2047 2047 fname = chunkdata['filename']
2048 2048 showchunks(fname)
2049 2049 else:
2050 2050 if isinstance(gen, bundle2.unbundle20):
2051 2051 raise error.Abort(_('use debugbundle2 for this file'))
2052 2052 chunkdata = gen.changelogheader()
2053 2053 chain = None
2054 2054 while True:
2055 2055 chunkdata = gen.deltachunk(chain)
2056 2056 if not chunkdata:
2057 2057 break
2058 2058 node = chunkdata['node']
2059 2059 ui.write("%s\n" % hex(node))
2060 2060 chain = node
2061 2061 finally:
2062 2062 f.close()
2063 2063
2064 2064 def _debugbundle2(ui, gen, **opts):
2065 2065 """lists the contents of a bundle2"""
2066 2066 if not isinstance(gen, bundle2.unbundle20):
2067 2067 raise error.Abort(_('not a bundle2 file'))
2068 2068 ui.write(('Stream params: %s\n' % repr(gen.params)))
2069 2069 for part in gen.iterparts():
2070 2070 ui.write('%s -- %r\n' % (part.type, repr(part.params)))
2071 2071 if part.type == 'changegroup':
2072 2072 version = part.params.get('version', '01')
2073 2073 cg = changegroup.packermap[version][1](part, 'UN')
2074 2074 chunkdata = cg.changelogheader()
2075 2075 chain = None
2076 2076 while True:
2077 2077 chunkdata = cg.deltachunk(chain)
2078 2078 if not chunkdata:
2079 2079 break
2080 2080 node = chunkdata['node']
2081 2081 ui.write(" %s\n" % hex(node))
2082 2082 chain = node
2083 2083
2084 2084 @command('debugcreatestreamclonebundle', [], 'FILE')
2085 2085 def debugcreatestreamclonebundle(ui, repo, fname):
2086 2086 """create a stream clone bundle file
2087 2087
2088 2088 Stream bundles are special bundles that are essentially archives of
2089 2089 revlog files. They are commonly used for cloning very quickly.
2090 2090 """
2091 2091 requirements, gen = streamclone.generatebundlev1(repo)
2092 2092 changegroup.writechunks(ui, gen, fname)
2093 2093
2094 2094 ui.write(_('bundle requirements: %s\n') % ', '.join(sorted(requirements)))
2095 2095
2096 2096 @command('debugapplystreamclonebundle', [], 'FILE')
2097 2097 def debugapplystreamclonebundle(ui, repo, fname):
2098 2098 """apply a stream clone bundle file"""
2099 2099 f = hg.openpath(ui, fname)
2100 2100 gen = exchange.readbundle(ui, f, fname)
2101 2101 gen.apply(repo)
2102 2102
2103 2103 @command('debugcheckstate', [], '')
2104 2104 def debugcheckstate(ui, repo):
2105 2105 """validate the correctness of the current dirstate"""
2106 2106 parent1, parent2 = repo.dirstate.parents()
2107 2107 m1 = repo[parent1].manifest()
2108 2108 m2 = repo[parent2].manifest()
2109 2109 errors = 0
2110 2110 for f in repo.dirstate:
2111 2111 state = repo.dirstate[f]
2112 2112 if state in "nr" and f not in m1:
2113 2113 ui.warn(_("%s in state %s, but not in manifest1\n") % (f, state))
2114 2114 errors += 1
2115 2115 if state in "a" and f in m1:
2116 2116 ui.warn(_("%s in state %s, but also in manifest1\n") % (f, state))
2117 2117 errors += 1
2118 2118 if state in "m" and f not in m1 and f not in m2:
2119 2119 ui.warn(_("%s in state %s, but not in either manifest\n") %
2120 2120 (f, state))
2121 2121 errors += 1
2122 2122 for f in m1:
2123 2123 state = repo.dirstate[f]
2124 2124 if state not in "nrm":
2125 2125 ui.warn(_("%s in manifest1, but listed as state %s") % (f, state))
2126 2126 errors += 1
2127 2127 if errors:
2128 2128 error = _(".hg/dirstate inconsistent with current parent's manifest")
2129 2129 raise error.Abort(error)
2130 2130
2131 2131 @command('debugcommands', [], _('[COMMAND]'), norepo=True)
2132 2132 def debugcommands(ui, cmd='', *args):
2133 2133 """list all available commands and options"""
2134 2134 for cmd, vals in sorted(table.iteritems()):
2135 2135 cmd = cmd.split('|')[0].strip('^')
2136 2136 opts = ', '.join([i[1] for i in vals[1]])
2137 2137 ui.write('%s: %s\n' % (cmd, opts))
2138 2138
2139 2139 @command('debugcomplete',
2140 2140 [('o', 'options', None, _('show the command options'))],
2141 2141 _('[-o] CMD'),
2142 2142 norepo=True)
2143 2143 def debugcomplete(ui, cmd='', **opts):
2144 2144 """returns the completion list associated with the given command"""
2145 2145
2146 2146 if opts.get('options'):
2147 2147 options = []
2148 2148 otables = [globalopts]
2149 2149 if cmd:
2150 2150 aliases, entry = cmdutil.findcmd(cmd, table, False)
2151 2151 otables.append(entry[1])
2152 2152 for t in otables:
2153 2153 for o in t:
2154 2154 if "(DEPRECATED)" in o[3]:
2155 2155 continue
2156 2156 if o[0]:
2157 2157 options.append('-%s' % o[0])
2158 2158 options.append('--%s' % o[1])
2159 2159 ui.write("%s\n" % "\n".join(options))
2160 2160 return
2161 2161
2162 2162 cmdlist, unused_allcmds = cmdutil.findpossible(cmd, table)
2163 2163 if ui.verbose:
2164 2164 cmdlist = [' '.join(c[0]) for c in cmdlist.values()]
2165 2165 ui.write("%s\n" % "\n".join(sorted(cmdlist)))
2166 2166
2167 2167 @command('debugdag',
2168 2168 [('t', 'tags', None, _('use tags as labels')),
2169 2169 ('b', 'branches', None, _('annotate with branch names')),
2170 2170 ('', 'dots', None, _('use dots for runs')),
2171 2171 ('s', 'spaces', None, _('separate elements by spaces'))],
2172 2172 _('[OPTION]... [FILE [REV]...]'),
2173 2173 optionalrepo=True)
2174 2174 def debugdag(ui, repo, file_=None, *revs, **opts):
2175 2175 """format the changelog or an index DAG as a concise textual description
2176 2176
2177 2177 If you pass a revlog index, the revlog's DAG is emitted. If you list
2178 2178 revision numbers, they get labeled in the output as rN.
2179 2179
2180 2180 Otherwise, the changelog DAG of the current repo is emitted.
2181 2181 """
2182 2182 spaces = opts.get('spaces')
2183 2183 dots = opts.get('dots')
2184 2184 if file_:
2185 2185 rlog = revlog.revlog(scmutil.opener(os.getcwd(), audit=False), file_)
2186 2186 revs = set((int(r) for r in revs))
2187 2187 def events():
2188 2188 for r in rlog:
2189 2189 yield 'n', (r, list(p for p in rlog.parentrevs(r)
2190 2190 if p != -1))
2191 2191 if r in revs:
2192 2192 yield 'l', (r, "r%i" % r)
2193 2193 elif repo:
2194 2194 cl = repo.changelog
2195 2195 tags = opts.get('tags')
2196 2196 branches = opts.get('branches')
2197 2197 if tags:
2198 2198 labels = {}
2199 2199 for l, n in repo.tags().items():
2200 2200 labels.setdefault(cl.rev(n), []).append(l)
2201 2201 def events():
2202 2202 b = "default"
2203 2203 for r in cl:
2204 2204 if branches:
2205 2205 newb = cl.read(cl.node(r))[5]['branch']
2206 2206 if newb != b:
2207 2207 yield 'a', newb
2208 2208 b = newb
2209 2209 yield 'n', (r, list(p for p in cl.parentrevs(r)
2210 2210 if p != -1))
2211 2211 if tags:
2212 2212 ls = labels.get(r)
2213 2213 if ls:
2214 2214 for l in ls:
2215 2215 yield 'l', (r, l)
2216 2216 else:
2217 2217 raise error.Abort(_('need repo for changelog dag'))
2218 2218
2219 2219 for line in dagparser.dagtextlines(events(),
2220 2220 addspaces=spaces,
2221 2221 wraplabels=True,
2222 2222 wrapannotations=True,
2223 2223 wrapnonlinear=dots,
2224 2224 usedots=dots,
2225 2225 maxlinewidth=70):
2226 2226 ui.write(line)
2227 2227 ui.write("\n")
2228 2228
2229 2229 @command('debugdata', debugrevlogopts, _('-c|-m|FILE REV'))
2230 2230 def debugdata(ui, repo, file_, rev=None, **opts):
2231 2231 """dump the contents of a data file revision"""
2232 2232 if opts.get('changelog') or opts.get('manifest'):
2233 2233 file_, rev = None, file_
2234 2234 elif rev is None:
2235 2235 raise error.CommandError('debugdata', _('invalid arguments'))
2236 2236 r = cmdutil.openrevlog(repo, 'debugdata', file_, opts)
2237 2237 try:
2238 2238 ui.write(r.revision(r.lookup(rev)))
2239 2239 except KeyError:
2240 2240 raise error.Abort(_('invalid revision identifier %s') % rev)
2241 2241
2242 2242 @command('debugdate',
2243 2243 [('e', 'extended', None, _('try extended date formats'))],
2244 2244 _('[-e] DATE [RANGE]'),
2245 2245 norepo=True, optionalrepo=True)
2246 2246 def debugdate(ui, date, range=None, **opts):
2247 2247 """parse and display a date"""
2248 2248 if opts["extended"]:
2249 2249 d = util.parsedate(date, util.extendeddateformats)
2250 2250 else:
2251 2251 d = util.parsedate(date)
2252 2252 ui.write(("internal: %s %s\n") % d)
2253 2253 ui.write(("standard: %s\n") % util.datestr(d))
2254 2254 if range:
2255 2255 m = util.matchdate(range)
2256 2256 ui.write(("match: %s\n") % m(d[0]))
2257 2257
2258 2258 @command('debugdiscovery',
2259 2259 [('', 'old', None, _('use old-style discovery')),
2260 2260 ('', 'nonheads', None,
2261 2261 _('use old-style discovery with non-heads included')),
2262 2262 ] + remoteopts,
2263 2263 _('[-l REV] [-r REV] [-b BRANCH]... [OTHER]'))
2264 2264 def debugdiscovery(ui, repo, remoteurl="default", **opts):
2265 2265 """runs the changeset discovery protocol in isolation"""
2266 2266 remoteurl, branches = hg.parseurl(ui.expandpath(remoteurl),
2267 2267 opts.get('branch'))
2268 2268 remote = hg.peer(repo, opts, remoteurl)
2269 2269 ui.status(_('comparing with %s\n') % util.hidepassword(remoteurl))
2270 2270
2271 2271 # make sure tests are repeatable
2272 2272 random.seed(12323)
2273 2273
2274 2274 def doit(localheads, remoteheads, remote=remote):
2275 2275 if opts.get('old'):
2276 2276 if localheads:
2277 2277 raise error.Abort('cannot use localheads with old style '
2278 2278 'discovery')
2279 2279 if not util.safehasattr(remote, 'branches'):
2280 2280 # enable in-client legacy support
2281 2281 remote = localrepo.locallegacypeer(remote.local())
2282 2282 common, _in, hds = treediscovery.findcommonincoming(repo, remote,
2283 2283 force=True)
2284 2284 common = set(common)
2285 2285 if not opts.get('nonheads'):
2286 2286 ui.write(("unpruned common: %s\n") %
2287 2287 " ".join(sorted(short(n) for n in common)))
2288 2288 dag = dagutil.revlogdag(repo.changelog)
2289 2289 all = dag.ancestorset(dag.internalizeall(common))
2290 2290 common = dag.externalizeall(dag.headsetofconnecteds(all))
2291 2291 else:
2292 2292 common, any, hds = setdiscovery.findcommonheads(ui, repo, remote)
2293 2293 common = set(common)
2294 2294 rheads = set(hds)
2295 2295 lheads = set(repo.heads())
2296 2296 ui.write(("common heads: %s\n") %
2297 2297 " ".join(sorted(short(n) for n in common)))
2298 2298 if lheads <= common:
2299 2299 ui.write(("local is subset\n"))
2300 2300 elif rheads <= common:
2301 2301 ui.write(("remote is subset\n"))
2302 2302
2303 2303 serverlogs = opts.get('serverlog')
2304 2304 if serverlogs:
2305 2305 for filename in serverlogs:
2306 2306 logfile = open(filename, 'r')
2307 2307 try:
2308 2308 line = logfile.readline()
2309 2309 while line:
2310 2310 parts = line.strip().split(';')
2311 2311 op = parts[1]
2312 2312 if op == 'cg':
2313 2313 pass
2314 2314 elif op == 'cgss':
2315 2315 doit(parts[2].split(' '), parts[3].split(' '))
2316 2316 elif op == 'unb':
2317 2317 doit(parts[3].split(' '), parts[2].split(' '))
2318 2318 line = logfile.readline()
2319 2319 finally:
2320 2320 logfile.close()
2321 2321
2322 2322 else:
2323 2323 remoterevs, _checkout = hg.addbranchrevs(repo, remote, branches,
2324 2324 opts.get('remote_head'))
2325 2325 localrevs = opts.get('local_head')
2326 2326 doit(localrevs, remoterevs)
2327 2327
2328 2328 @command('debugextensions', formatteropts, [], norepo=True)
2329 2329 def debugextensions(ui, **opts):
2330 2330 '''show information about active extensions'''
2331 2331 exts = extensions.extensions(ui)
2332 2332 fm = ui.formatter('debugextensions', opts)
2333 2333 for extname, extmod in sorted(exts, key=operator.itemgetter(0)):
2334 2334 extsource = extmod.__file__
2335 2335 exttestedwith = getattr(extmod, 'testedwith', None)
2336 2336 if exttestedwith is not None:
2337 2337 exttestedwith = exttestedwith.split()
2338 2338 extbuglink = getattr(extmod, 'buglink', None)
2339 2339
2340 2340 fm.startitem()
2341 2341
2342 2342 if ui.quiet or ui.verbose:
2343 2343 fm.write('name', '%s\n', extname)
2344 2344 else:
2345 2345 fm.write('name', '%s', extname)
2346 2346 if not exttestedwith:
2347 2347 fm.plain(_(' (untested!)\n'))
2348 2348 else:
2349 2349 if exttestedwith == ['internal'] or \
2350 2350 util.version() in exttestedwith:
2351 2351 fm.plain('\n')
2352 2352 else:
2353 2353 lasttestedversion = exttestedwith[-1]
2354 2354 fm.plain(' (%s!)\n' % lasttestedversion)
2355 2355
2356 2356 fm.condwrite(ui.verbose and extsource, 'source',
2357 2357 _(' location: %s\n'), extsource or "")
2358 2358
2359 2359 fm.condwrite(ui.verbose and exttestedwith, 'testedwith',
2360 2360 _(' tested with: %s\n'), ' '.join(exttestedwith or []))
2361 2361
2362 2362 fm.condwrite(ui.verbose and extbuglink, 'buglink',
2363 2363 _(' bug reporting: %s\n'), extbuglink or "")
2364 2364
2365 2365 fm.end()
2366 2366
2367 2367 @command('debugfileset',
2368 2368 [('r', 'rev', '', _('apply the filespec on this revision'), _('REV'))],
2369 2369 _('[-r REV] FILESPEC'))
2370 2370 def debugfileset(ui, repo, expr, **opts):
2371 2371 '''parse and apply a fileset specification'''
2372 2372 ctx = scmutil.revsingle(repo, opts.get('rev'), None)
2373 2373 if ui.verbose:
2374 2374 tree = fileset.parse(expr)
2375 2375 ui.note(fileset.prettyformat(tree), "\n")
2376 2376
2377 2377 for f in ctx.getfileset(expr):
2378 2378 ui.write("%s\n" % f)
2379 2379
2380 2380 @command('debugfsinfo', [], _('[PATH]'), norepo=True)
2381 2381 def debugfsinfo(ui, path="."):
2382 2382 """show information detected about current filesystem"""
2383 2383 util.writefile('.debugfsinfo', '')
2384 2384 ui.write(('exec: %s\n') % (util.checkexec(path) and 'yes' or 'no'))
2385 2385 ui.write(('symlink: %s\n') % (util.checklink(path) and 'yes' or 'no'))
2386 2386 ui.write(('hardlink: %s\n') % (util.checknlink(path) and 'yes' or 'no'))
2387 2387 ui.write(('case-sensitive: %s\n') % (util.checkcase('.debugfsinfo')
2388 2388 and 'yes' or 'no'))
2389 2389 os.unlink('.debugfsinfo')
2390 2390
2391 2391 @command('debuggetbundle',
2392 2392 [('H', 'head', [], _('id of head node'), _('ID')),
2393 2393 ('C', 'common', [], _('id of common node'), _('ID')),
2394 2394 ('t', 'type', 'bzip2', _('bundle compression type to use'), _('TYPE'))],
2395 2395 _('REPO FILE [-H|-C ID]...'),
2396 2396 norepo=True)
2397 2397 def debuggetbundle(ui, repopath, bundlepath, head=None, common=None, **opts):
2398 2398 """retrieves a bundle from a repo
2399 2399
2400 2400 Every ID must be a full-length hex node id string. Saves the bundle to the
2401 2401 given file.
2402 2402 """
2403 2403 repo = hg.peer(ui, opts, repopath)
2404 2404 if not repo.capable('getbundle'):
2405 2405 raise error.Abort("getbundle() not supported by target repository")
2406 2406 args = {}
2407 2407 if common:
2408 2408 args['common'] = [bin(s) for s in common]
2409 2409 if head:
2410 2410 args['heads'] = [bin(s) for s in head]
2411 2411 # TODO: get desired bundlecaps from command line.
2412 2412 args['bundlecaps'] = None
2413 2413 bundle = repo.getbundle('debug', **args)
2414 2414
2415 2415 bundletype = opts.get('type', 'bzip2').lower()
2416 2416 btypes = {'none': 'HG10UN',
2417 2417 'bzip2': 'HG10BZ',
2418 2418 'gzip': 'HG10GZ',
2419 2419 'bundle2': 'HG20'}
2420 2420 bundletype = btypes.get(bundletype)
2421 2421 if bundletype not in changegroup.bundletypes:
2422 2422 raise error.Abort(_('unknown bundle type specified with --type'))
2423 2423 changegroup.writebundle(ui, bundle, bundlepath, bundletype)
2424 2424
2425 2425 @command('debugignore', [], '')
2426 2426 def debugignore(ui, repo, *values, **opts):
2427 2427 """display the combined ignore pattern"""
2428 2428 ignore = repo.dirstate._ignore
2429 2429 includepat = getattr(ignore, 'includepat', None)
2430 2430 if includepat is not None:
2431 2431 ui.write("%s\n" % includepat)
2432 2432 else:
2433 2433 raise error.Abort(_("no ignore patterns found"))
2434 2434
2435 2435 @command('debugindex', debugrevlogopts +
2436 2436 [('f', 'format', 0, _('revlog format'), _('FORMAT'))],
2437 2437 _('[-f FORMAT] -c|-m|FILE'),
2438 2438 optionalrepo=True)
2439 2439 def debugindex(ui, repo, file_=None, **opts):
2440 2440 """dump the contents of an index file"""
2441 2441 r = cmdutil.openrevlog(repo, 'debugindex', file_, opts)
2442 2442 format = opts.get('format', 0)
2443 2443 if format not in (0, 1):
2444 2444 raise error.Abort(_("unknown format %d") % format)
2445 2445
2446 2446 generaldelta = r.version & revlog.REVLOGGENERALDELTA
2447 2447 if generaldelta:
2448 2448 basehdr = ' delta'
2449 2449 else:
2450 2450 basehdr = ' base'
2451 2451
2452 2452 if ui.debugflag:
2453 2453 shortfn = hex
2454 2454 else:
2455 2455 shortfn = short
2456 2456
2457 2457 # There might not be anything in r, so have a sane default
2458 2458 idlen = 12
2459 2459 for i in r:
2460 2460 idlen = len(shortfn(r.node(i)))
2461 2461 break
2462 2462
2463 2463 if format == 0:
2464 2464 ui.write(" rev offset length " + basehdr + " linkrev"
2465 2465 " %s %s p2\n" % ("nodeid".ljust(idlen), "p1".ljust(idlen)))
2466 2466 elif format == 1:
2467 2467 ui.write(" rev flag offset length"
2468 2468 " size " + basehdr + " link p1 p2"
2469 2469 " %s\n" % "nodeid".rjust(idlen))
2470 2470
2471 2471 for i in r:
2472 2472 node = r.node(i)
2473 2473 if generaldelta:
2474 2474 base = r.deltaparent(i)
2475 2475 else:
2476 2476 base = r.chainbase(i)
2477 2477 if format == 0:
2478 2478 try:
2479 2479 pp = r.parents(node)
2480 2480 except Exception:
2481 2481 pp = [nullid, nullid]
2482 2482 ui.write("% 6d % 9d % 7d % 6d % 7d %s %s %s\n" % (
2483 2483 i, r.start(i), r.length(i), base, r.linkrev(i),
2484 2484 shortfn(node), shortfn(pp[0]), shortfn(pp[1])))
2485 2485 elif format == 1:
2486 2486 pr = r.parentrevs(i)
2487 2487 ui.write("% 6d %04x % 8d % 8d % 8d % 6d % 6d % 6d % 6d %s\n" % (
2488 2488 i, r.flags(i), r.start(i), r.length(i), r.rawsize(i),
2489 2489 base, r.linkrev(i), pr[0], pr[1], shortfn(node)))
2490 2490
2491 2491 @command('debugindexdot', debugrevlogopts,
2492 2492 _('-c|-m|FILE'), optionalrepo=True)
2493 2493 def debugindexdot(ui, repo, file_=None, **opts):
2494 2494 """dump an index DAG as a graphviz dot file"""
2495 2495 r = cmdutil.openrevlog(repo, 'debugindexdot', file_, opts)
2496 2496 ui.write(("digraph G {\n"))
2497 2497 for i in r:
2498 2498 node = r.node(i)
2499 2499 pp = r.parents(node)
2500 2500 ui.write("\t%d -> %d\n" % (r.rev(pp[0]), i))
2501 2501 if pp[1] != nullid:
2502 2502 ui.write("\t%d -> %d\n" % (r.rev(pp[1]), i))
2503 2503 ui.write("}\n")
2504 2504
2505 2505 @command('debugdeltachain',
2506 2506 debugrevlogopts + formatteropts,
2507 2507 _('-c|-m|FILE'),
2508 2508 optionalrepo=True)
2509 2509 def debugdeltachain(ui, repo, file_=None, **opts):
2510 2510 """dump information about delta chains in a revlog
2511 2511
2512 2512 Output can be templatized. Available template keywords are:
2513 2513
2514 2514 rev revision number
2515 2515 chainid delta chain identifier (numbered by unique base)
2516 2516 chainlen delta chain length to this revision
2517 2517 prevrev previous revision in delta chain
2518 2518 deltatype role of delta / how it was computed
2519 2519 compsize compressed size of revision
2520 2520 uncompsize uncompressed size of revision
2521 2521 chainsize total size of compressed revisions in chain
2522 2522 chainratio total chain size divided by uncompressed revision size
2523 2523 (new delta chains typically start at ratio 2.00)
2524 2524 lindist linear distance from base revision in delta chain to end
2525 2525 of this revision
2526 2526 extradist total size of revisions not part of this delta chain from
2527 2527 base of delta chain to end of this revision; a measurement
2528 2528 of how much extra data we need to read/seek across to read
2529 2529 the delta chain for this revision
2530 2530 extraratio extradist divided by chainsize; another representation of
2531 2531 how much unrelated data is needed to load this delta chain
2532 2532 """
2533 2533 r = cmdutil.openrevlog(repo, 'debugdeltachain', file_, opts)
2534 2534 index = r.index
2535 2535 generaldelta = r.version & revlog.REVLOGGENERALDELTA
2536 2536
2537 2537 def revinfo(rev):
2538 2538 iterrev = rev
2539 2539 e = index[iterrev]
2540 2540 chain = []
2541 2541 compsize = e[1]
2542 2542 uncompsize = e[2]
2543 2543 chainsize = 0
2544 2544
2545 2545 if generaldelta:
2546 2546 if e[3] == e[5]:
2547 2547 deltatype = 'p1'
2548 2548 elif e[3] == e[6]:
2549 2549 deltatype = 'p2'
2550 2550 elif e[3] == rev - 1:
2551 2551 deltatype = 'prev'
2552 2552 elif e[3] == rev:
2553 2553 deltatype = 'base'
2554 2554 else:
2555 2555 deltatype = 'other'
2556 2556 else:
2557 2557 if e[3] == rev:
2558 2558 deltatype = 'base'
2559 2559 else:
2560 2560 deltatype = 'prev'
2561 2561
2562 2562 while iterrev != e[3]:
2563 2563 chain.append(iterrev)
2564 2564 chainsize += e[1]
2565 2565 if generaldelta:
2566 2566 iterrev = e[3]
2567 2567 else:
2568 2568 iterrev -= 1
2569 2569 e = index[iterrev]
2570 2570 else:
2571 2571 chainsize += e[1]
2572 2572 chain.append(iterrev)
2573 2573
2574 2574 chain.reverse()
2575 2575 return compsize, uncompsize, deltatype, chain, chainsize
2576 2576
2577 2577 fm = ui.formatter('debugdeltachain', opts)
2578 2578
2579 2579 fm.plain(' rev chain# chainlen prev delta '
2580 2580 'size rawsize chainsize ratio lindist extradist '
2581 2581 'extraratio\n')
2582 2582
2583 2583 chainbases = {}
2584 2584 for rev in r:
2585 2585 comp, uncomp, deltatype, chain, chainsize = revinfo(rev)
2586 2586 chainbase = chain[0]
2587 2587 chainid = chainbases.setdefault(chainbase, len(chainbases) + 1)
2588 2588 basestart = r.start(chainbase)
2589 2589 revstart = r.start(rev)
2590 2590 lineardist = revstart + comp - basestart
2591 2591 extradist = lineardist - chainsize
2592 2592 try:
2593 2593 prevrev = chain[-2]
2594 2594 except IndexError:
2595 2595 prevrev = -1
2596 2596
2597 2597 chainratio = float(chainsize) / float(uncomp)
2598 2598 extraratio = float(extradist) / float(chainsize)
2599 2599
2600 2600 fm.startitem()
2601 2601 fm.write('rev chainid chainlen prevrev deltatype compsize '
2602 2602 'uncompsize chainsize chainratio lindist extradist '
2603 2603 'extraratio',
2604 2604 '%7d %7d %8d %8d %7s %10d %10d %10d %9.5f %9d %9d %10.5f\n',
2605 2605 rev, chainid, len(chain), prevrev, deltatype, comp,
2606 2606 uncomp, chainsize, chainratio, lineardist, extradist,
2607 2607 extraratio,
2608 2608 rev=rev, chainid=chainid, chainlen=len(chain),
2609 2609 prevrev=prevrev, deltatype=deltatype, compsize=comp,
2610 2610 uncompsize=uncomp, chainsize=chainsize,
2611 2611 chainratio=chainratio, lindist=lineardist,
2612 2612 extradist=extradist, extraratio=extraratio)
2613 2613
2614 2614 fm.end()
2615 2615
2616 2616 @command('debuginstall', [], '', norepo=True)
2617 2617 def debuginstall(ui):
2618 2618 '''test Mercurial installation
2619 2619
2620 2620 Returns 0 on success.
2621 2621 '''
2622 2622
2623 2623 def writetemp(contents):
2624 2624 (fd, name) = tempfile.mkstemp(prefix="hg-debuginstall-")
2625 2625 f = os.fdopen(fd, "wb")
2626 2626 f.write(contents)
2627 2627 f.close()
2628 2628 return name
2629 2629
2630 2630 problems = 0
2631 2631
2632 2632 # encoding
2633 2633 ui.status(_("checking encoding (%s)...\n") % encoding.encoding)
2634 2634 try:
2635 2635 encoding.fromlocal("test")
2636 2636 except error.Abort as inst:
2637 2637 ui.write(" %s\n" % inst)
2638 2638 ui.write(_(" (check that your locale is properly set)\n"))
2639 2639 problems += 1
2640 2640
2641 2641 # Python
2642 2642 ui.status(_("checking Python executable (%s)\n") % sys.executable)
2643 2643 ui.status(_("checking Python version (%s)\n")
2644 2644 % ("%s.%s.%s" % sys.version_info[:3]))
2645 2645 ui.status(_("checking Python lib (%s)...\n")
2646 2646 % os.path.dirname(os.__file__))
2647 2647
2648 2648 # compiled modules
2649 2649 ui.status(_("checking installed modules (%s)...\n")
2650 2650 % os.path.dirname(__file__))
2651 2651 try:
2652 2652 import bdiff, mpatch, base85, osutil
2653 2653 dir(bdiff), dir(mpatch), dir(base85), dir(osutil) # quiet pyflakes
2654 2654 except Exception as inst:
2655 2655 ui.write(" %s\n" % inst)
2656 2656 ui.write(_(" One or more extensions could not be found"))
2657 2657 ui.write(_(" (check that you compiled the extensions)\n"))
2658 2658 problems += 1
2659 2659
2660 2660 # templates
2661 2661 import templater
2662 2662 p = templater.templatepaths()
2663 2663 ui.status(_("checking templates (%s)...\n") % ' '.join(p))
2664 2664 if p:
2665 2665 m = templater.templatepath("map-cmdline.default")
2666 2666 if m:
2667 2667 # template found, check if it is working
2668 2668 try:
2669 2669 templater.templater(m)
2670 2670 except Exception as inst:
2671 2671 ui.write(" %s\n" % inst)
2672 2672 p = None
2673 2673 else:
2674 2674 ui.write(_(" template 'default' not found\n"))
2675 2675 p = None
2676 2676 else:
2677 2677 ui.write(_(" no template directories found\n"))
2678 2678 if not p:
2679 2679 ui.write(_(" (templates seem to have been installed incorrectly)\n"))
2680 2680 problems += 1
2681 2681
2682 2682 # editor
2683 2683 ui.status(_("checking commit editor...\n"))
2684 2684 editor = ui.geteditor()
2685 2685 editor = util.expandpath(editor)
2686 2686 cmdpath = util.findexe(shlex.split(editor)[0])
2687 2687 if not cmdpath:
2688 2688 if editor == 'vi':
2689 2689 ui.write(_(" No commit editor set and can't find vi in PATH\n"))
2690 2690 ui.write(_(" (specify a commit editor in your configuration"
2691 2691 " file)\n"))
2692 2692 else:
2693 2693 ui.write(_(" Can't find editor '%s' in PATH\n") % editor)
2694 2694 ui.write(_(" (specify a commit editor in your configuration"
2695 2695 " file)\n"))
2696 2696 problems += 1
2697 2697
2698 2698 # check username
2699 2699 ui.status(_("checking username...\n"))
2700 2700 try:
2701 2701 ui.username()
2702 2702 except error.Abort as e:
2703 2703 ui.write(" %s\n" % e)
2704 2704 ui.write(_(" (specify a username in your configuration file)\n"))
2705 2705 problems += 1
2706 2706
2707 2707 if not problems:
2708 2708 ui.status(_("no problems detected\n"))
2709 2709 else:
2710 2710 ui.write(_("%s problems detected,"
2711 2711 " please check your install!\n") % problems)
2712 2712
2713 2713 return problems
2714 2714
2715 2715 @command('debugknown', [], _('REPO ID...'), norepo=True)
2716 2716 def debugknown(ui, repopath, *ids, **opts):
2717 2717 """test whether node ids are known to a repo
2718 2718
2719 2719 Every ID must be a full-length hex node id string. Returns a list of 0s
2720 2720 and 1s indicating unknown/known.
2721 2721 """
2722 2722 repo = hg.peer(ui, opts, repopath)
2723 2723 if not repo.capable('known'):
2724 2724 raise error.Abort("known() not supported by target repository")
2725 2725 flags = repo.known([bin(s) for s in ids])
2726 2726 ui.write("%s\n" % ("".join([f and "1" or "0" for f in flags])))
2727 2727
2728 2728 @command('debuglabelcomplete', [], _('LABEL...'))
2729 2729 def debuglabelcomplete(ui, repo, *args):
2730 2730 '''backwards compatibility with old bash completion scripts (DEPRECATED)'''
2731 2731 debugnamecomplete(ui, repo, *args)
2732 2732
2733 2733 @command('debugmergestate', [], '')
2734 2734 def debugmergestate(ui, repo, *args):
2735 2735 """print merge state
2736 2736
2737 2737 Use --verbose to print out information about whether v1 or v2 merge state
2738 2738 was chosen."""
2739 2739 def _hashornull(h):
2740 2740 if h == nullhex:
2741 2741 return 'null'
2742 2742 else:
2743 2743 return h
2744 2744
2745 2745 def printrecords(version):
2746 2746 ui.write(('* version %s records\n') % version)
2747 2747 if version == 1:
2748 2748 records = v1records
2749 2749 else:
2750 2750 records = v2records
2751 2751
2752 2752 for rtype, record in records:
2753 2753 # pretty print some record types
2754 2754 if rtype == 'L':
2755 2755 ui.write(('local: %s\n') % record)
2756 2756 elif rtype == 'O':
2757 2757 ui.write(('other: %s\n') % record)
2758 2758 elif rtype == 'm':
2759 2759 driver, mdstate = record.split('\0', 1)
2760 2760 ui.write(('merge driver: %s (state "%s")\n')
2761 2761 % (driver, mdstate))
2762 2762 elif rtype in 'FDC':
2763 2763 r = record.split('\0')
2764 2764 f, state, hash, lfile, afile, anode, ofile = r[0:7]
2765 2765 if version == 1:
2766 2766 onode = 'not stored in v1 format'
2767 2767 flags = r[7]
2768 2768 else:
2769 2769 onode, flags = r[7:9]
2770 2770 ui.write(('file: %s (record type "%s", state "%s", hash %s)\n')
2771 2771 % (f, rtype, state, _hashornull(hash)))
2772 2772 ui.write((' local path: %s (flags "%s")\n') % (lfile, flags))
2773 2773 ui.write((' ancestor path: %s (node %s)\n')
2774 2774 % (afile, _hashornull(anode)))
2775 2775 ui.write((' other path: %s (node %s)\n')
2776 2776 % (ofile, _hashornull(onode)))
2777 2777 else:
2778 2778 ui.write(('unrecognized entry: %s\t%s\n')
2779 2779 % (rtype, record.replace('\0', '\t')))
2780 2780
2781 2781 # Avoid mergestate.read() since it may raise an exception for unsupported
2782 2782 # merge state records. We shouldn't be doing this, but this is OK since this
2783 2783 # command is pretty low-level.
2784 2784 ms = mergemod.mergestate(repo)
2785 2785
2786 2786 # sort so that reasonable information is on top
2787 2787 v1records = ms._readrecordsv1()
2788 2788 v2records = ms._readrecordsv2()
2789 2789 order = 'LOm'
2790 2790 def key(r):
2791 2791 idx = order.find(r[0])
2792 2792 if idx == -1:
2793 2793 return (1, r[1])
2794 2794 else:
2795 2795 return (0, idx)
2796 2796 v1records.sort(key=key)
2797 2797 v2records.sort(key=key)
2798 2798
2799 2799 if not v1records and not v2records:
2800 2800 ui.write(('no merge state found\n'))
2801 2801 elif not v2records:
2802 2802 ui.note(('no version 2 merge state\n'))
2803 2803 printrecords(1)
2804 2804 elif ms._v1v2match(v1records, v2records):
2805 2805 ui.note(('v1 and v2 states match: using v2\n'))
2806 2806 printrecords(2)
2807 2807 else:
2808 2808 ui.note(('v1 and v2 states mismatch: using v1\n'))
2809 2809 printrecords(1)
2810 2810 if ui.verbose:
2811 2811 printrecords(2)
2812 2812
2813 2813 @command('debugnamecomplete', [], _('NAME...'))
2814 2814 def debugnamecomplete(ui, repo, *args):
2815 2815 '''complete "names" - tags, open branch names, bookmark names'''
2816 2816
2817 2817 names = set()
2818 2818 # since we previously only listed open branches, we will handle that
2819 2819 # specially (after this for loop)
2820 2820 for name, ns in repo.names.iteritems():
2821 2821 if name != 'branches':
2822 2822 names.update(ns.listnames(repo))
2823 2823 names.update(tag for (tag, heads, tip, closed)
2824 2824 in repo.branchmap().iterbranches() if not closed)
2825 2825 completions = set()
2826 2826 if not args:
2827 2827 args = ['']
2828 2828 for a in args:
2829 2829 completions.update(n for n in names if n.startswith(a))
2830 2830 ui.write('\n'.join(sorted(completions)))
2831 2831 ui.write('\n')
2832 2832
2833 2833 @command('debuglocks',
2834 2834 [('L', 'force-lock', None, _('free the store lock (DANGEROUS)')),
2835 2835 ('W', 'force-wlock', None,
2836 2836 _('free the working state lock (DANGEROUS)'))],
2837 2837 _('[OPTION]...'))
2838 2838 def debuglocks(ui, repo, **opts):
2839 2839 """show or modify state of locks
2840 2840
2841 2841 By default, this command will show which locks are held. This
2842 2842 includes the user and process holding the lock, the amount of time
2843 2843 the lock has been held, and the machine name where the process is
2844 2844 running if it's not local.
2845 2845
2846 2846 Locks protect the integrity of Mercurial's data, so should be
2847 2847 treated with care. System crashes or other interruptions may cause
2848 2848 locks to not be properly released, though Mercurial will usually
2849 2849 detect and remove such stale locks automatically.
2850 2850
2851 2851 However, detecting stale locks may not always be possible (for
2852 2852 instance, on a shared filesystem). Removing locks may also be
2853 2853 blocked by filesystem permissions.
2854 2854
2855 2855 Returns 0 if no locks are held.
2856 2856
2857 2857 """
2858 2858
2859 2859 if opts.get('force_lock'):
2860 2860 repo.svfs.unlink('lock')
2861 2861 if opts.get('force_wlock'):
2862 2862 repo.vfs.unlink('wlock')
2863 2863 if opts.get('force_lock') or opts.get('force_lock'):
2864 2864 return 0
2865 2865
2866 2866 now = time.time()
2867 2867 held = 0
2868 2868
2869 2869 def report(vfs, name, method):
2870 2870 # this causes stale locks to get reaped for more accurate reporting
2871 2871 try:
2872 2872 l = method(False)
2873 2873 except error.LockHeld:
2874 2874 l = None
2875 2875
2876 2876 if l:
2877 2877 l.release()
2878 2878 else:
2879 2879 try:
2880 2880 stat = vfs.lstat(name)
2881 2881 age = now - stat.st_mtime
2882 2882 user = util.username(stat.st_uid)
2883 2883 locker = vfs.readlock(name)
2884 2884 if ":" in locker:
2885 2885 host, pid = locker.split(':')
2886 2886 if host == socket.gethostname():
2887 2887 locker = 'user %s, process %s' % (user, pid)
2888 2888 else:
2889 2889 locker = 'user %s, process %s, host %s' \
2890 2890 % (user, pid, host)
2891 2891 ui.write("%-6s %s (%ds)\n" % (name + ":", locker, age))
2892 2892 return 1
2893 2893 except OSError as e:
2894 2894 if e.errno != errno.ENOENT:
2895 2895 raise
2896 2896
2897 2897 ui.write("%-6s free\n" % (name + ":"))
2898 2898 return 0
2899 2899
2900 2900 held += report(repo.svfs, "lock", repo.lock)
2901 2901 held += report(repo.vfs, "wlock", repo.wlock)
2902 2902
2903 2903 return held
2904 2904
2905 2905 @command('debugobsolete',
2906 2906 [('', 'flags', 0, _('markers flag')),
2907 2907 ('', 'record-parents', False,
2908 2908 _('record parent information for the precursor')),
2909 2909 ('r', 'rev', [], _('display markers relevant to REV')),
2910 2910 ] + commitopts2,
2911 2911 _('[OBSOLETED [REPLACEMENT ...]]'))
2912 2912 def debugobsolete(ui, repo, precursor=None, *successors, **opts):
2913 2913 """create arbitrary obsolete marker
2914 2914
2915 2915 With no arguments, displays the list of obsolescence markers."""
2916 2916
2917 2917 def parsenodeid(s):
2918 2918 try:
2919 2919 # We do not use revsingle/revrange functions here to accept
2920 2920 # arbitrary node identifiers, possibly not present in the
2921 2921 # local repository.
2922 2922 n = bin(s)
2923 2923 if len(n) != len(nullid):
2924 2924 raise TypeError()
2925 2925 return n
2926 2926 except TypeError:
2927 2927 raise error.Abort('changeset references must be full hexadecimal '
2928 2928 'node identifiers')
2929 2929
2930 2930 if precursor is not None:
2931 2931 if opts['rev']:
2932 2932 raise error.Abort('cannot select revision when creating marker')
2933 2933 metadata = {}
2934 2934 metadata['user'] = opts['user'] or ui.username()
2935 2935 succs = tuple(parsenodeid(succ) for succ in successors)
2936 2936 l = repo.lock()
2937 2937 try:
2938 2938 tr = repo.transaction('debugobsolete')
2939 2939 try:
2940 2940 date = opts.get('date')
2941 2941 if date:
2942 2942 date = util.parsedate(date)
2943 2943 else:
2944 2944 date = None
2945 2945 prec = parsenodeid(precursor)
2946 2946 parents = None
2947 2947 if opts['record_parents']:
2948 2948 if prec not in repo.unfiltered():
2949 2949 raise error.Abort('cannot used --record-parents on '
2950 2950 'unknown changesets')
2951 2951 parents = repo.unfiltered()[prec].parents()
2952 2952 parents = tuple(p.node() for p in parents)
2953 2953 repo.obsstore.create(tr, prec, succs, opts['flags'],
2954 2954 parents=parents, date=date,
2955 2955 metadata=metadata)
2956 2956 tr.close()
2957 2957 except ValueError as exc:
2958 2958 raise error.Abort(_('bad obsmarker input: %s') % exc)
2959 2959 finally:
2960 2960 tr.release()
2961 2961 finally:
2962 2962 l.release()
2963 2963 else:
2964 2964 if opts['rev']:
2965 2965 revs = scmutil.revrange(repo, opts['rev'])
2966 2966 nodes = [repo[r].node() for r in revs]
2967 2967 markers = list(obsolete.getmarkers(repo, nodes=nodes))
2968 2968 markers.sort(key=lambda x: x._data)
2969 2969 else:
2970 2970 markers = obsolete.getmarkers(repo)
2971 2971
2972 2972 for m in markers:
2973 2973 cmdutil.showmarker(ui, m)
2974 2974
2975 2975 @command('debugpathcomplete',
2976 2976 [('f', 'full', None, _('complete an entire path')),
2977 2977 ('n', 'normal', None, _('show only normal files')),
2978 2978 ('a', 'added', None, _('show only added files')),
2979 2979 ('r', 'removed', None, _('show only removed files'))],
2980 2980 _('FILESPEC...'))
2981 2981 def debugpathcomplete(ui, repo, *specs, **opts):
2982 2982 '''complete part or all of a tracked path
2983 2983
2984 2984 This command supports shells that offer path name completion. It
2985 2985 currently completes only files already known to the dirstate.
2986 2986
2987 2987 Completion extends only to the next path segment unless
2988 2988 --full is specified, in which case entire paths are used.'''
2989 2989
2990 2990 def complete(path, acceptable):
2991 2991 dirstate = repo.dirstate
2992 2992 spec = os.path.normpath(os.path.join(os.getcwd(), path))
2993 2993 rootdir = repo.root + os.sep
2994 2994 if spec != repo.root and not spec.startswith(rootdir):
2995 2995 return [], []
2996 2996 if os.path.isdir(spec):
2997 2997 spec += '/'
2998 2998 spec = spec[len(rootdir):]
2999 2999 fixpaths = os.sep != '/'
3000 3000 if fixpaths:
3001 3001 spec = spec.replace(os.sep, '/')
3002 3002 speclen = len(spec)
3003 3003 fullpaths = opts['full']
3004 3004 files, dirs = set(), set()
3005 3005 adddir, addfile = dirs.add, files.add
3006 3006 for f, st in dirstate.iteritems():
3007 3007 if f.startswith(spec) and st[0] in acceptable:
3008 3008 if fixpaths:
3009 3009 f = f.replace('/', os.sep)
3010 3010 if fullpaths:
3011 3011 addfile(f)
3012 3012 continue
3013 3013 s = f.find(os.sep, speclen)
3014 3014 if s >= 0:
3015 3015 adddir(f[:s])
3016 3016 else:
3017 3017 addfile(f)
3018 3018 return files, dirs
3019 3019
3020 3020 acceptable = ''
3021 3021 if opts['normal']:
3022 3022 acceptable += 'nm'
3023 3023 if opts['added']:
3024 3024 acceptable += 'a'
3025 3025 if opts['removed']:
3026 3026 acceptable += 'r'
3027 3027 cwd = repo.getcwd()
3028 3028 if not specs:
3029 3029 specs = ['.']
3030 3030
3031 3031 files, dirs = set(), set()
3032 3032 for spec in specs:
3033 3033 f, d = complete(spec, acceptable or 'nmar')
3034 3034 files.update(f)
3035 3035 dirs.update(d)
3036 3036 files.update(dirs)
3037 3037 ui.write('\n'.join(repo.pathto(p, cwd) for p in sorted(files)))
3038 3038 ui.write('\n')
3039 3039
3040 3040 @command('debugpushkey', [], _('REPO NAMESPACE [KEY OLD NEW]'), norepo=True)
3041 3041 def debugpushkey(ui, repopath, namespace, *keyinfo, **opts):
3042 3042 '''access the pushkey key/value protocol
3043 3043
3044 3044 With two args, list the keys in the given namespace.
3045 3045
3046 3046 With five args, set a key to new if it currently is set to old.
3047 3047 Reports success or failure.
3048 3048 '''
3049 3049
3050 3050 target = hg.peer(ui, {}, repopath)
3051 3051 if keyinfo:
3052 3052 key, old, new = keyinfo
3053 3053 r = target.pushkey(namespace, key, old, new)
3054 3054 ui.status(str(r) + '\n')
3055 3055 return not r
3056 3056 else:
3057 3057 for k, v in sorted(target.listkeys(namespace).iteritems()):
3058 3058 ui.write("%s\t%s\n" % (k.encode('string-escape'),
3059 3059 v.encode('string-escape')))
3060 3060
3061 3061 @command('debugpvec', [], _('A B'))
3062 3062 def debugpvec(ui, repo, a, b=None):
3063 3063 ca = scmutil.revsingle(repo, a)
3064 3064 cb = scmutil.revsingle(repo, b)
3065 3065 pa = pvec.ctxpvec(ca)
3066 3066 pb = pvec.ctxpvec(cb)
3067 3067 if pa == pb:
3068 3068 rel = "="
3069 3069 elif pa > pb:
3070 3070 rel = ">"
3071 3071 elif pa < pb:
3072 3072 rel = "<"
3073 3073 elif pa | pb:
3074 3074 rel = "|"
3075 3075 ui.write(_("a: %s\n") % pa)
3076 3076 ui.write(_("b: %s\n") % pb)
3077 3077 ui.write(_("depth(a): %d depth(b): %d\n") % (pa._depth, pb._depth))
3078 3078 ui.write(_("delta: %d hdist: %d distance: %d relation: %s\n") %
3079 3079 (abs(pa._depth - pb._depth), pvec._hamming(pa._vec, pb._vec),
3080 3080 pa.distance(pb), rel))
3081 3081
3082 3082 @command('debugrebuilddirstate|debugrebuildstate',
3083 3083 [('r', 'rev', '', _('revision to rebuild to'), _('REV')),
3084 3084 ('', 'minimal', None, _('only rebuild files that are inconsistent with '
3085 3085 'the working copy parent')),
3086 3086 ],
3087 3087 _('[-r REV]'))
3088 3088 def debugrebuilddirstate(ui, repo, rev, **opts):
3089 3089 """rebuild the dirstate as it would look like for the given revision
3090 3090
3091 3091 If no revision is specified the first current parent will be used.
3092 3092
3093 3093 The dirstate will be set to the files of the given revision.
3094 3094 The actual working directory content or existing dirstate
3095 3095 information such as adds or removes is not considered.
3096 3096
3097 3097 ``minimal`` will only rebuild the dirstate status for files that claim to be
3098 3098 tracked but are not in the parent manifest, or that exist in the parent
3099 3099 manifest but are not in the dirstate. It will not change adds, removes, or
3100 3100 modified files that are in the working copy parent.
3101 3101
3102 3102 One use of this command is to make the next :hg:`status` invocation
3103 3103 check the actual file content.
3104 3104 """
3105 3105 ctx = scmutil.revsingle(repo, rev)
3106 3106 wlock = repo.wlock()
3107 3107 try:
3108 3108 dirstate = repo.dirstate
3109 3109 changedfiles = None
3110 3110 # See command doc for what minimal does.
3111 3111 if opts.get('minimal'):
3112 3112 manifestfiles = set(ctx.manifest().keys())
3113 3113 dirstatefiles = set(dirstate)
3114 3114 manifestonly = manifestfiles - dirstatefiles
3115 3115 dsonly = dirstatefiles - manifestfiles
3116 3116 dsnotadded = set(f for f in dsonly if dirstate[f] != 'a')
3117 3117 changedfiles = manifestonly | dsnotadded
3118 3118
3119 3119 dirstate.rebuild(ctx.node(), ctx.manifest(), changedfiles)
3120 3120 finally:
3121 3121 wlock.release()
3122 3122
3123 3123 @command('debugrebuildfncache', [], '')
3124 3124 def debugrebuildfncache(ui, repo):
3125 3125 """rebuild the fncache file"""
3126 3126 repair.rebuildfncache(ui, repo)
3127 3127
3128 3128 @command('debugrename',
3129 3129 [('r', 'rev', '', _('revision to debug'), _('REV'))],
3130 3130 _('[-r REV] FILE'))
3131 3131 def debugrename(ui, repo, file1, *pats, **opts):
3132 3132 """dump rename information"""
3133 3133
3134 3134 ctx = scmutil.revsingle(repo, opts.get('rev'))
3135 3135 m = scmutil.match(ctx, (file1,) + pats, opts)
3136 3136 for abs in ctx.walk(m):
3137 3137 fctx = ctx[abs]
3138 3138 o = fctx.filelog().renamed(fctx.filenode())
3139 3139 rel = m.rel(abs)
3140 3140 if o:
3141 3141 ui.write(_("%s renamed from %s:%s\n") % (rel, o[0], hex(o[1])))
3142 3142 else:
3143 3143 ui.write(_("%s not renamed\n") % rel)
3144 3144
3145 3145 @command('debugrevlog', debugrevlogopts +
3146 3146 [('d', 'dump', False, _('dump index data'))],
3147 3147 _('-c|-m|FILE'),
3148 3148 optionalrepo=True)
3149 3149 def debugrevlog(ui, repo, file_=None, **opts):
3150 3150 """show data and statistics about a revlog"""
3151 3151 r = cmdutil.openrevlog(repo, 'debugrevlog', file_, opts)
3152 3152
3153 3153 if opts.get("dump"):
3154 3154 numrevs = len(r)
3155 3155 ui.write("# rev p1rev p2rev start end deltastart base p1 p2"
3156 3156 " rawsize totalsize compression heads chainlen\n")
3157 3157 ts = 0
3158 3158 heads = set()
3159 3159
3160 3160 for rev in xrange(numrevs):
3161 3161 dbase = r.deltaparent(rev)
3162 3162 if dbase == -1:
3163 3163 dbase = rev
3164 3164 cbase = r.chainbase(rev)
3165 3165 clen = r.chainlen(rev)
3166 3166 p1, p2 = r.parentrevs(rev)
3167 3167 rs = r.rawsize(rev)
3168 3168 ts = ts + rs
3169 3169 heads -= set(r.parentrevs(rev))
3170 3170 heads.add(rev)
3171 3171 ui.write("%5d %5d %5d %5d %5d %10d %4d %4d %4d %7d %9d "
3172 3172 "%11d %5d %8d\n" %
3173 3173 (rev, p1, p2, r.start(rev), r.end(rev),
3174 3174 r.start(dbase), r.start(cbase),
3175 3175 r.start(p1), r.start(p2),
3176 3176 rs, ts, ts / r.end(rev), len(heads), clen))
3177 3177 return 0
3178 3178
3179 3179 v = r.version
3180 3180 format = v & 0xFFFF
3181 3181 flags = []
3182 3182 gdelta = False
3183 3183 if v & revlog.REVLOGNGINLINEDATA:
3184 3184 flags.append('inline')
3185 3185 if v & revlog.REVLOGGENERALDELTA:
3186 3186 gdelta = True
3187 3187 flags.append('generaldelta')
3188 3188 if not flags:
3189 3189 flags = ['(none)']
3190 3190
3191 3191 nummerges = 0
3192 3192 numfull = 0
3193 3193 numprev = 0
3194 3194 nump1 = 0
3195 3195 nump2 = 0
3196 3196 numother = 0
3197 3197 nump1prev = 0
3198 3198 nump2prev = 0
3199 3199 chainlengths = []
3200 3200
3201 3201 datasize = [None, 0, 0L]
3202 3202 fullsize = [None, 0, 0L]
3203 3203 deltasize = [None, 0, 0L]
3204 3204
3205 3205 def addsize(size, l):
3206 3206 if l[0] is None or size < l[0]:
3207 3207 l[0] = size
3208 3208 if size > l[1]:
3209 3209 l[1] = size
3210 3210 l[2] += size
3211 3211
3212 3212 numrevs = len(r)
3213 3213 for rev in xrange(numrevs):
3214 3214 p1, p2 = r.parentrevs(rev)
3215 3215 delta = r.deltaparent(rev)
3216 3216 if format > 0:
3217 3217 addsize(r.rawsize(rev), datasize)
3218 3218 if p2 != nullrev:
3219 3219 nummerges += 1
3220 3220 size = r.length(rev)
3221 3221 if delta == nullrev:
3222 3222 chainlengths.append(0)
3223 3223 numfull += 1
3224 3224 addsize(size, fullsize)
3225 3225 else:
3226 3226 chainlengths.append(chainlengths[delta] + 1)
3227 3227 addsize(size, deltasize)
3228 3228 if delta == rev - 1:
3229 3229 numprev += 1
3230 3230 if delta == p1:
3231 3231 nump1prev += 1
3232 3232 elif delta == p2:
3233 3233 nump2prev += 1
3234 3234 elif delta == p1:
3235 3235 nump1 += 1
3236 3236 elif delta == p2:
3237 3237 nump2 += 1
3238 3238 elif delta != nullrev:
3239 3239 numother += 1
3240 3240
3241 3241 # Adjust size min value for empty cases
3242 3242 for size in (datasize, fullsize, deltasize):
3243 3243 if size[0] is None:
3244 3244 size[0] = 0
3245 3245
3246 3246 numdeltas = numrevs - numfull
3247 3247 numoprev = numprev - nump1prev - nump2prev
3248 3248 totalrawsize = datasize[2]
3249 3249 datasize[2] /= numrevs
3250 3250 fulltotal = fullsize[2]
3251 3251 fullsize[2] /= numfull
3252 3252 deltatotal = deltasize[2]
3253 3253 if numrevs - numfull > 0:
3254 3254 deltasize[2] /= numrevs - numfull
3255 3255 totalsize = fulltotal + deltatotal
3256 3256 avgchainlen = sum(chainlengths) / numrevs
3257 3257 maxchainlen = max(chainlengths)
3258 3258 compratio = 1
3259 3259 if totalsize:
3260 3260 compratio = totalrawsize / totalsize
3261 3261
3262 3262 basedfmtstr = '%%%dd\n'
3263 3263 basepcfmtstr = '%%%dd %s(%%5.2f%%%%)\n'
3264 3264
3265 3265 def dfmtstr(max):
3266 3266 return basedfmtstr % len(str(max))
3267 3267 def pcfmtstr(max, padding=0):
3268 3268 return basepcfmtstr % (len(str(max)), ' ' * padding)
3269 3269
3270 3270 def pcfmt(value, total):
3271 3271 if total:
3272 3272 return (value, 100 * float(value) / total)
3273 3273 else:
3274 3274 return value, 100.0
3275 3275
3276 3276 ui.write(('format : %d\n') % format)
3277 3277 ui.write(('flags : %s\n') % ', '.join(flags))
3278 3278
3279 3279 ui.write('\n')
3280 3280 fmt = pcfmtstr(totalsize)
3281 3281 fmt2 = dfmtstr(totalsize)
3282 3282 ui.write(('revisions : ') + fmt2 % numrevs)
3283 3283 ui.write((' merges : ') + fmt % pcfmt(nummerges, numrevs))
3284 3284 ui.write((' normal : ') + fmt % pcfmt(numrevs - nummerges, numrevs))
3285 3285 ui.write(('revisions : ') + fmt2 % numrevs)
3286 3286 ui.write((' full : ') + fmt % pcfmt(numfull, numrevs))
3287 3287 ui.write((' deltas : ') + fmt % pcfmt(numdeltas, numrevs))
3288 3288 ui.write(('revision size : ') + fmt2 % totalsize)
3289 3289 ui.write((' full : ') + fmt % pcfmt(fulltotal, totalsize))
3290 3290 ui.write((' deltas : ') + fmt % pcfmt(deltatotal, totalsize))
3291 3291
3292 3292 ui.write('\n')
3293 3293 fmt = dfmtstr(max(avgchainlen, compratio))
3294 3294 ui.write(('avg chain length : ') + fmt % avgchainlen)
3295 3295 ui.write(('max chain length : ') + fmt % maxchainlen)
3296 3296 ui.write(('compression ratio : ') + fmt % compratio)
3297 3297
3298 3298 if format > 0:
3299 3299 ui.write('\n')
3300 3300 ui.write(('uncompressed data size (min/max/avg) : %d / %d / %d\n')
3301 3301 % tuple(datasize))
3302 3302 ui.write(('full revision size (min/max/avg) : %d / %d / %d\n')
3303 3303 % tuple(fullsize))
3304 3304 ui.write(('delta size (min/max/avg) : %d / %d / %d\n')
3305 3305 % tuple(deltasize))
3306 3306
3307 3307 if numdeltas > 0:
3308 3308 ui.write('\n')
3309 3309 fmt = pcfmtstr(numdeltas)
3310 3310 fmt2 = pcfmtstr(numdeltas, 4)
3311 3311 ui.write(('deltas against prev : ') + fmt % pcfmt(numprev, numdeltas))
3312 3312 if numprev > 0:
3313 3313 ui.write((' where prev = p1 : ') + fmt2 % pcfmt(nump1prev,
3314 3314 numprev))
3315 3315 ui.write((' where prev = p2 : ') + fmt2 % pcfmt(nump2prev,
3316 3316 numprev))
3317 3317 ui.write((' other : ') + fmt2 % pcfmt(numoprev,
3318 3318 numprev))
3319 3319 if gdelta:
3320 3320 ui.write(('deltas against p1 : ')
3321 3321 + fmt % pcfmt(nump1, numdeltas))
3322 3322 ui.write(('deltas against p2 : ')
3323 3323 + fmt % pcfmt(nump2, numdeltas))
3324 3324 ui.write(('deltas against other : ') + fmt % pcfmt(numother,
3325 3325 numdeltas))
3326 3326
3327 3327 @command('debugrevspec',
3328 3328 [('', 'optimize', None, _('print parsed tree after optimizing'))],
3329 3329 ('REVSPEC'))
3330 3330 def debugrevspec(ui, repo, expr, **opts):
3331 3331 """parse and apply a revision specification
3332 3332
3333 3333 Use --verbose to print the parsed tree before and after aliases
3334 3334 expansion.
3335 3335 """
3336 3336 if ui.verbose:
3337 3337 tree = revset.parse(expr, lookup=repo.__contains__)
3338 3338 ui.note(revset.prettyformat(tree), "\n")
3339 3339 newtree = revset.findaliases(ui, tree)
3340 3340 if newtree != tree:
3341 3341 ui.note(revset.prettyformat(newtree), "\n")
3342 3342 tree = newtree
3343 3343 newtree = revset.foldconcat(tree)
3344 3344 if newtree != tree:
3345 3345 ui.note(revset.prettyformat(newtree), "\n")
3346 3346 if opts["optimize"]:
3347 3347 weight, optimizedtree = revset.optimize(newtree, True)
3348 3348 ui.note("* optimized:\n", revset.prettyformat(optimizedtree), "\n")
3349 3349 func = revset.match(ui, expr, repo)
3350 3350 revs = func(repo)
3351 3351 if ui.verbose:
3352 3352 ui.note("* set:\n", revset.prettyformatset(revs), "\n")
3353 3353 for c in revs:
3354 3354 ui.write("%s\n" % c)
3355 3355
3356 3356 @command('debugsetparents', [], _('REV1 [REV2]'))
3357 3357 def debugsetparents(ui, repo, rev1, rev2=None):
3358 3358 """manually set the parents of the current working directory
3359 3359
3360 3360 This is useful for writing repository conversion tools, but should
3361 3361 be used with care. For example, neither the working directory nor the
3362 3362 dirstate is updated, so file status may be incorrect after running this
3363 3363 command.
3364 3364
3365 3365 Returns 0 on success.
3366 3366 """
3367 3367
3368 3368 r1 = scmutil.revsingle(repo, rev1).node()
3369 3369 r2 = scmutil.revsingle(repo, rev2, 'null').node()
3370 3370
3371 3371 wlock = repo.wlock()
3372 3372 try:
3373 3373 repo.dirstate.beginparentchange()
3374 3374 repo.setparents(r1, r2)
3375 3375 repo.dirstate.endparentchange()
3376 3376 finally:
3377 3377 wlock.release()
3378 3378
3379 3379 @command('debugdirstate|debugstate',
3380 3380 [('', 'nodates', None, _('do not display the saved mtime')),
3381 3381 ('', 'datesort', None, _('sort by saved mtime'))],
3382 3382 _('[OPTION]...'))
3383 3383 def debugstate(ui, repo, **opts):
3384 3384 """show the contents of the current dirstate"""
3385 3385
3386 3386 nodates = opts.get('nodates')
3387 3387 datesort = opts.get('datesort')
3388 3388
3389 3389 timestr = ""
3390 3390 if datesort:
3391 3391 keyfunc = lambda x: (x[1][3], x[0]) # sort by mtime, then by filename
3392 3392 else:
3393 3393 keyfunc = None # sort by filename
3394 3394 for file_, ent in sorted(repo.dirstate._map.iteritems(), key=keyfunc):
3395 3395 if ent[3] == -1:
3396 3396 timestr = 'unset '
3397 3397 elif nodates:
3398 3398 timestr = 'set '
3399 3399 else:
3400 3400 timestr = time.strftime("%Y-%m-%d %H:%M:%S ",
3401 3401 time.localtime(ent[3]))
3402 3402 if ent[1] & 0o20000:
3403 3403 mode = 'lnk'
3404 3404 else:
3405 3405 mode = '%3o' % (ent[1] & 0o777 & ~util.umask)
3406 3406 ui.write("%c %s %10d %s%s\n" % (ent[0], mode, ent[2], timestr, file_))
3407 3407 for f in repo.dirstate.copies():
3408 3408 ui.write(_("copy: %s -> %s\n") % (repo.dirstate.copied(f), f))
3409 3409
3410 3410 @command('debugsub',
3411 3411 [('r', 'rev', '',
3412 3412 _('revision to check'), _('REV'))],
3413 3413 _('[-r REV] [REV]'))
3414 3414 def debugsub(ui, repo, rev=None):
3415 3415 ctx = scmutil.revsingle(repo, rev, None)
3416 3416 for k, v in sorted(ctx.substate.items()):
3417 3417 ui.write(('path %s\n') % k)
3418 3418 ui.write((' source %s\n') % v[0])
3419 3419 ui.write((' revision %s\n') % v[1])
3420 3420
3421 3421 @command('debugsuccessorssets',
3422 3422 [],
3423 3423 _('[REV]'))
3424 3424 def debugsuccessorssets(ui, repo, *revs):
3425 3425 """show set of successors for revision
3426 3426
3427 3427 A successors set of changeset A is a consistent group of revisions that
3428 3428 succeed A. It contains non-obsolete changesets only.
3429 3429
3430 3430 In most cases a changeset A has a single successors set containing a single
3431 3431 successor (changeset A replaced by A').
3432 3432
3433 3433 A changeset that is made obsolete with no successors are called "pruned".
3434 3434 Such changesets have no successors sets at all.
3435 3435
3436 3436 A changeset that has been "split" will have a successors set containing
3437 3437 more than one successor.
3438 3438
3439 3439 A changeset that has been rewritten in multiple different ways is called
3440 3440 "divergent". Such changesets have multiple successor sets (each of which
3441 3441 may also be split, i.e. have multiple successors).
3442 3442
3443 3443 Results are displayed as follows::
3444 3444
3445 3445 <rev1>
3446 3446 <successors-1A>
3447 3447 <rev2>
3448 3448 <successors-2A>
3449 3449 <successors-2B1> <successors-2B2> <successors-2B3>
3450 3450
3451 3451 Here rev2 has two possible (i.e. divergent) successors sets. The first
3452 3452 holds one element, whereas the second holds three (i.e. the changeset has
3453 3453 been split).
3454 3454 """
3455 3455 # passed to successorssets caching computation from one call to another
3456 3456 cache = {}
3457 3457 ctx2str = str
3458 3458 node2str = short
3459 3459 if ui.debug():
3460 3460 def ctx2str(ctx):
3461 3461 return ctx.hex()
3462 3462 node2str = hex
3463 3463 for rev in scmutil.revrange(repo, revs):
3464 3464 ctx = repo[rev]
3465 3465 ui.write('%s\n'% ctx2str(ctx))
3466 3466 for succsset in obsolete.successorssets(repo, ctx.node(), cache):
3467 3467 if succsset:
3468 3468 ui.write(' ')
3469 3469 ui.write(node2str(succsset[0]))
3470 3470 for node in succsset[1:]:
3471 3471 ui.write(' ')
3472 3472 ui.write(node2str(node))
3473 3473 ui.write('\n')
3474 3474
3475 3475 @command('debugwalk', walkopts, _('[OPTION]... [FILE]...'), inferrepo=True)
3476 3476 def debugwalk(ui, repo, *pats, **opts):
3477 3477 """show how files match on given patterns"""
3478 3478 m = scmutil.match(repo[None], pats, opts)
3479 3479 items = list(repo.walk(m))
3480 3480 if not items:
3481 3481 return
3482 3482 f = lambda fn: fn
3483 3483 if ui.configbool('ui', 'slash') and os.sep != '/':
3484 3484 f = lambda fn: util.normpath(fn)
3485 3485 fmt = 'f %%-%ds %%-%ds %%s' % (
3486 3486 max([len(abs) for abs in items]),
3487 3487 max([len(m.rel(abs)) for abs in items]))
3488 3488 for abs in items:
3489 3489 line = fmt % (abs, f(m.rel(abs)), m.exact(abs) and 'exact' or '')
3490 3490 ui.write("%s\n" % line.rstrip())
3491 3491
3492 3492 @command('debugwireargs',
3493 3493 [('', 'three', '', 'three'),
3494 3494 ('', 'four', '', 'four'),
3495 3495 ('', 'five', '', 'five'),
3496 3496 ] + remoteopts,
3497 3497 _('REPO [OPTIONS]... [ONE [TWO]]'),
3498 3498 norepo=True)
3499 3499 def debugwireargs(ui, repopath, *vals, **opts):
3500 3500 repo = hg.peer(ui, opts, repopath)
3501 3501 for opt in remoteopts:
3502 3502 del opts[opt[1]]
3503 3503 args = {}
3504 3504 for k, v in opts.iteritems():
3505 3505 if v:
3506 3506 args[k] = v
3507 3507 # run twice to check that we don't mess up the stream for the next command
3508 3508 res1 = repo.debugwireargs(*vals, **args)
3509 3509 res2 = repo.debugwireargs(*vals, **args)
3510 3510 ui.write("%s\n" % res1)
3511 3511 if res1 != res2:
3512 3512 ui.warn("%s\n" % res2)
3513 3513
3514 3514 @command('^diff',
3515 3515 [('r', 'rev', [], _('revision'), _('REV')),
3516 3516 ('c', 'change', '', _('change made by revision'), _('REV'))
3517 3517 ] + diffopts + diffopts2 + walkopts + subrepoopts,
3518 3518 _('[OPTION]... ([-c REV] | [-r REV1 [-r REV2]]) [FILE]...'),
3519 3519 inferrepo=True)
3520 3520 def diff(ui, repo, *pats, **opts):
3521 3521 """diff repository (or selected files)
3522 3522
3523 3523 Show differences between revisions for the specified files.
3524 3524
3525 3525 Differences between files are shown using the unified diff format.
3526 3526
3527 3527 .. note::
3528 3528
3529 3529 diff may generate unexpected results for merges, as it will
3530 3530 default to comparing against the working directory's first
3531 3531 parent changeset if no revisions are specified.
3532 3532
3533 3533 When two revision arguments are given, then changes are shown
3534 3534 between those revisions. If only one revision is specified then
3535 3535 that revision is compared to the working directory, and, when no
3536 3536 revisions are specified, the working directory files are compared
3537 3537 to its parent.
3538 3538
3539 3539 Alternatively you can specify -c/--change with a revision to see
3540 3540 the changes in that changeset relative to its first parent.
3541 3541
3542 3542 Without the -a/--text option, diff will avoid generating diffs of
3543 3543 files it detects as binary. With -a, diff will generate a diff
3544 3544 anyway, probably with undesirable results.
3545 3545
3546 3546 Use the -g/--git option to generate diffs in the git extended diff
3547 3547 format. For more information, read :hg:`help diffs`.
3548 3548
3549 3549 .. container:: verbose
3550 3550
3551 3551 Examples:
3552 3552
3553 3553 - compare a file in the current working directory to its parent::
3554 3554
3555 3555 hg diff foo.c
3556 3556
3557 3557 - compare two historical versions of a directory, with rename info::
3558 3558
3559 3559 hg diff --git -r 1.0:1.2 lib/
3560 3560
3561 3561 - get change stats relative to the last change on some date::
3562 3562
3563 3563 hg diff --stat -r "date('may 2')"
3564 3564
3565 3565 - diff all newly-added files that contain a keyword::
3566 3566
3567 3567 hg diff "set:added() and grep(GNU)"
3568 3568
3569 3569 - compare a revision and its parents::
3570 3570
3571 3571 hg diff -c 9353 # compare against first parent
3572 3572 hg diff -r 9353^:9353 # same using revset syntax
3573 3573 hg diff -r 9353^2:9353 # compare against the second parent
3574 3574
3575 3575 Returns 0 on success.
3576 3576 """
3577 3577
3578 3578 revs = opts.get('rev')
3579 3579 change = opts.get('change')
3580 3580 stat = opts.get('stat')
3581 3581 reverse = opts.get('reverse')
3582 3582
3583 3583 if revs and change:
3584 3584 msg = _('cannot specify --rev and --change at the same time')
3585 3585 raise error.Abort(msg)
3586 3586 elif change:
3587 3587 node2 = scmutil.revsingle(repo, change, None).node()
3588 3588 node1 = repo[node2].p1().node()
3589 3589 else:
3590 3590 node1, node2 = scmutil.revpair(repo, revs)
3591 3591
3592 3592 if reverse:
3593 3593 node1, node2 = node2, node1
3594 3594
3595 3595 diffopts = patch.diffallopts(ui, opts)
3596 3596 m = scmutil.match(repo[node2], pats, opts)
3597 3597 cmdutil.diffordiffstat(ui, repo, diffopts, node1, node2, m, stat=stat,
3598 3598 listsubrepos=opts.get('subrepos'),
3599 3599 root=opts.get('root'))
3600 3600
3601 3601 @command('^export',
3602 3602 [('o', 'output', '',
3603 3603 _('print output to file with formatted name'), _('FORMAT')),
3604 3604 ('', 'switch-parent', None, _('diff against the second parent')),
3605 3605 ('r', 'rev', [], _('revisions to export'), _('REV')),
3606 3606 ] + diffopts,
3607 3607 _('[OPTION]... [-o OUTFILESPEC] [-r] [REV]...'))
3608 3608 def export(ui, repo, *changesets, **opts):
3609 3609 """dump the header and diffs for one or more changesets
3610 3610
3611 3611 Print the changeset header and diffs for one or more revisions.
3612 3612 If no revision is given, the parent of the working directory is used.
3613 3613
3614 3614 The information shown in the changeset header is: author, date,
3615 3615 branch name (if non-default), changeset hash, parent(s) and commit
3616 3616 comment.
3617 3617
3618 3618 .. note::
3619 3619
3620 3620 export may generate unexpected diff output for merge
3621 3621 changesets, as it will compare the merge changeset against its
3622 3622 first parent only.
3623 3623
3624 3624 Output may be to a file, in which case the name of the file is
3625 3625 given using a format string. The formatting rules are as follows:
3626 3626
3627 3627 :``%%``: literal "%" character
3628 3628 :``%H``: changeset hash (40 hexadecimal digits)
3629 3629 :``%N``: number of patches being generated
3630 3630 :``%R``: changeset revision number
3631 3631 :``%b``: basename of the exporting repository
3632 3632 :``%h``: short-form changeset hash (12 hexadecimal digits)
3633 3633 :``%m``: first line of the commit message (only alphanumeric characters)
3634 3634 :``%n``: zero-padded sequence number, starting at 1
3635 3635 :``%r``: zero-padded changeset revision number
3636 3636
3637 3637 Without the -a/--text option, export will avoid generating diffs
3638 3638 of files it detects as binary. With -a, export will generate a
3639 3639 diff anyway, probably with undesirable results.
3640 3640
3641 3641 Use the -g/--git option to generate diffs in the git extended diff
3642 3642 format. See :hg:`help diffs` for more information.
3643 3643
3644 3644 With the --switch-parent option, the diff will be against the
3645 3645 second parent. It can be useful to review a merge.
3646 3646
3647 3647 .. container:: verbose
3648 3648
3649 3649 Examples:
3650 3650
3651 3651 - use export and import to transplant a bugfix to the current
3652 3652 branch::
3653 3653
3654 3654 hg export -r 9353 | hg import -
3655 3655
3656 3656 - export all the changesets between two revisions to a file with
3657 3657 rename information::
3658 3658
3659 3659 hg export --git -r 123:150 > changes.txt
3660 3660
3661 3661 - split outgoing changes into a series of patches with
3662 3662 descriptive names::
3663 3663
3664 3664 hg export -r "outgoing()" -o "%n-%m.patch"
3665 3665
3666 3666 Returns 0 on success.
3667 3667 """
3668 3668 changesets += tuple(opts.get('rev', []))
3669 3669 if not changesets:
3670 3670 changesets = ['.']
3671 3671 revs = scmutil.revrange(repo, changesets)
3672 3672 if not revs:
3673 3673 raise error.Abort(_("export requires at least one changeset"))
3674 3674 if len(revs) > 1:
3675 3675 ui.note(_('exporting patches:\n'))
3676 3676 else:
3677 3677 ui.note(_('exporting patch:\n'))
3678 3678 cmdutil.export(repo, revs, template=opts.get('output'),
3679 3679 switch_parent=opts.get('switch_parent'),
3680 3680 opts=patch.diffallopts(ui, opts))
3681 3681
3682 3682 @command('files',
3683 3683 [('r', 'rev', '', _('search the repository as it is in REV'), _('REV')),
3684 3684 ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
3685 3685 ] + walkopts + formatteropts + subrepoopts,
3686 3686 _('[OPTION]... [PATTERN]...'))
3687 3687 def files(ui, repo, *pats, **opts):
3688 3688 """list tracked files
3689 3689
3690 3690 Print files under Mercurial control in the working directory or
3691 3691 specified revision whose names match the given patterns (excluding
3692 3692 removed files).
3693 3693
3694 3694 If no patterns are given to match, this command prints the names
3695 3695 of all files under Mercurial control in the working directory.
3696 3696
3697 3697 .. container:: verbose
3698 3698
3699 3699 Examples:
3700 3700
3701 3701 - list all files under the current directory::
3702 3702
3703 3703 hg files .
3704 3704
3705 3705 - shows sizes and flags for current revision::
3706 3706
3707 3707 hg files -vr .
3708 3708
3709 3709 - list all files named README::
3710 3710
3711 3711 hg files -I "**/README"
3712 3712
3713 3713 - list all binary files::
3714 3714
3715 3715 hg files "set:binary()"
3716 3716
3717 3717 - find files containing a regular expression::
3718 3718
3719 3719 hg files "set:grep('bob')"
3720 3720
3721 3721 - search tracked file contents with xargs and grep::
3722 3722
3723 3723 hg files -0 | xargs -0 grep foo
3724 3724
3725 3725 See :hg:`help patterns` and :hg:`help filesets` for more information
3726 3726 on specifying file patterns.
3727 3727
3728 3728 Returns 0 if a match is found, 1 otherwise.
3729 3729
3730 3730 """
3731 3731 ctx = scmutil.revsingle(repo, opts.get('rev'), None)
3732 3732
3733 3733 end = '\n'
3734 3734 if opts.get('print0'):
3735 3735 end = '\0'
3736 3736 fm = ui.formatter('files', opts)
3737 3737 fmt = '%s' + end
3738 3738
3739 3739 m = scmutil.match(ctx, pats, opts)
3740 3740 ret = cmdutil.files(ui, ctx, m, fm, fmt, opts.get('subrepos'))
3741 3741
3742 3742 fm.end()
3743 3743
3744 3744 return ret
3745 3745
3746 3746 @command('^forget', walkopts, _('[OPTION]... FILE...'), inferrepo=True)
3747 3747 def forget(ui, repo, *pats, **opts):
3748 3748 """forget the specified files on the next commit
3749 3749
3750 3750 Mark the specified files so they will no longer be tracked
3751 3751 after the next commit.
3752 3752
3753 3753 This only removes files from the current branch, not from the
3754 3754 entire project history, and it does not delete them from the
3755 3755 working directory.
3756 3756
3757 3757 To delete the file from the working directory, see :hg:`remove`.
3758 3758
3759 3759 To undo a forget before the next commit, see :hg:`add`.
3760 3760
3761 3761 .. container:: verbose
3762 3762
3763 3763 Examples:
3764 3764
3765 3765 - forget newly-added binary files::
3766 3766
3767 3767 hg forget "set:added() and binary()"
3768 3768
3769 3769 - forget files that would be excluded by .hgignore::
3770 3770
3771 3771 hg forget "set:hgignore()"
3772 3772
3773 3773 Returns 0 on success.
3774 3774 """
3775 3775
3776 3776 if not pats:
3777 3777 raise error.Abort(_('no files specified'))
3778 3778
3779 3779 m = scmutil.match(repo[None], pats, opts)
3780 3780 rejected = cmdutil.forget(ui, repo, m, prefix="", explicitonly=False)[0]
3781 3781 return rejected and 1 or 0
3782 3782
3783 3783 @command(
3784 3784 'graft',
3785 3785 [('r', 'rev', [], _('revisions to graft'), _('REV')),
3786 3786 ('c', 'continue', False, _('resume interrupted graft')),
3787 3787 ('e', 'edit', False, _('invoke editor on commit messages')),
3788 3788 ('', 'log', None, _('append graft info to log message')),
3789 3789 ('f', 'force', False, _('force graft')),
3790 3790 ('D', 'currentdate', False,
3791 3791 _('record the current date as commit date')),
3792 3792 ('U', 'currentuser', False,
3793 3793 _('record the current user as committer'), _('DATE'))]
3794 3794 + commitopts2 + mergetoolopts + dryrunopts,
3795 3795 _('[OPTION]... [-r] REV...'))
3796 3796 def graft(ui, repo, *revs, **opts):
3797 3797 '''copy changes from other branches onto the current branch
3798 3798
3799 3799 This command uses Mercurial's merge logic to copy individual
3800 3800 changes from other branches without merging branches in the
3801 3801 history graph. This is sometimes known as 'backporting' or
3802 3802 'cherry-picking'. By default, graft will copy user, date, and
3803 3803 description from the source changesets.
3804 3804
3805 3805 Changesets that are ancestors of the current revision, that have
3806 3806 already been grafted, or that are merges will be skipped.
3807 3807
3808 3808 If --log is specified, log messages will have a comment appended
3809 3809 of the form::
3810 3810
3811 3811 (grafted from CHANGESETHASH)
3812 3812
3813 3813 If --force is specified, revisions will be grafted even if they
3814 3814 are already ancestors of or have been grafted to the destination.
3815 3815 This is useful when the revisions have since been backed out.
3816 3816
3817 3817 If a graft merge results in conflicts, the graft process is
3818 3818 interrupted so that the current merge can be manually resolved.
3819 3819 Once all conflicts are addressed, the graft process can be
3820 3820 continued with the -c/--continue option.
3821 3821
3822 3822 .. note::
3823 3823
3824 3824 The -c/--continue option does not reapply earlier options, except
3825 3825 for --force.
3826 3826
3827 3827 .. container:: verbose
3828 3828
3829 3829 Examples:
3830 3830
3831 3831 - copy a single change to the stable branch and edit its description::
3832 3832
3833 3833 hg update stable
3834 3834 hg graft --edit 9393
3835 3835
3836 3836 - graft a range of changesets with one exception, updating dates::
3837 3837
3838 3838 hg graft -D "2085::2093 and not 2091"
3839 3839
3840 3840 - continue a graft after resolving conflicts::
3841 3841
3842 3842 hg graft -c
3843 3843
3844 3844 - show the source of a grafted changeset::
3845 3845
3846 3846 hg log --debug -r .
3847 3847
3848 3848 See :hg:`help revisions` and :hg:`help revsets` for more about
3849 3849 specifying revisions.
3850 3850
3851 3851 Returns 0 on successful completion.
3852 3852 '''
3853 3853 wlock = None
3854 3854 try:
3855 3855 wlock = repo.wlock()
3856 3856 return _dograft(ui, repo, *revs, **opts)
3857 3857 finally:
3858 3858 release(wlock)
3859 3859
3860 3860 def _dograft(ui, repo, *revs, **opts):
3861 3861 revs = list(revs)
3862 3862 revs.extend(opts['rev'])
3863 3863
3864 3864 if not opts.get('user') and opts.get('currentuser'):
3865 3865 opts['user'] = ui.username()
3866 3866 if not opts.get('date') and opts.get('currentdate'):
3867 3867 opts['date'] = "%d %d" % util.makedate()
3868 3868
3869 3869 editor = cmdutil.getcommiteditor(editform='graft', **opts)
3870 3870
3871 3871 cont = False
3872 3872 if opts['continue']:
3873 3873 cont = True
3874 3874 if revs:
3875 3875 raise error.Abort(_("can't specify --continue and revisions"))
3876 3876 # read in unfinished revisions
3877 3877 try:
3878 3878 nodes = repo.vfs.read('graftstate').splitlines()
3879 3879 revs = [repo[node].rev() for node in nodes]
3880 3880 except IOError as inst:
3881 3881 if inst.errno != errno.ENOENT:
3882 3882 raise
3883 3883 raise error.Abort(_("no graft state found, can't continue"))
3884 3884 else:
3885 3885 cmdutil.checkunfinished(repo)
3886 3886 cmdutil.bailifchanged(repo)
3887 3887 if not revs:
3888 3888 raise error.Abort(_('no revisions specified'))
3889 3889 revs = scmutil.revrange(repo, revs)
3890 3890
3891 3891 skipped = set()
3892 3892 # check for merges
3893 3893 for rev in repo.revs('%ld and merge()', revs):
3894 3894 ui.warn(_('skipping ungraftable merge revision %s\n') % rev)
3895 3895 skipped.add(rev)
3896 3896 revs = [r for r in revs if r not in skipped]
3897 3897 if not revs:
3898 3898 return -1
3899 3899
3900 3900 # Don't check in the --continue case, in effect retaining --force across
3901 3901 # --continues. That's because without --force, any revisions we decided to
3902 3902 # skip would have been filtered out here, so they wouldn't have made their
3903 3903 # way to the graftstate. With --force, any revisions we would have otherwise
3904 3904 # skipped would not have been filtered out, and if they hadn't been applied
3905 3905 # already, they'd have been in the graftstate.
3906 3906 if not (cont or opts.get('force')):
3907 3907 # check for ancestors of dest branch
3908 3908 crev = repo['.'].rev()
3909 3909 ancestors = repo.changelog.ancestors([crev], inclusive=True)
3910 3910 # Cannot use x.remove(y) on smart set, this has to be a list.
3911 3911 # XXX make this lazy in the future
3912 3912 revs = list(revs)
3913 3913 # don't mutate while iterating, create a copy
3914 3914 for rev in list(revs):
3915 3915 if rev in ancestors:
3916 3916 ui.warn(_('skipping ancestor revision %d:%s\n') %
3917 3917 (rev, repo[rev]))
3918 3918 # XXX remove on list is slow
3919 3919 revs.remove(rev)
3920 3920 if not revs:
3921 3921 return -1
3922 3922
3923 3923 # analyze revs for earlier grafts
3924 3924 ids = {}
3925 3925 for ctx in repo.set("%ld", revs):
3926 3926 ids[ctx.hex()] = ctx.rev()
3927 3927 n = ctx.extra().get('source')
3928 3928 if n:
3929 3929 ids[n] = ctx.rev()
3930 3930
3931 3931 # check ancestors for earlier grafts
3932 3932 ui.debug('scanning for duplicate grafts\n')
3933 3933
3934 3934 for rev in repo.changelog.findmissingrevs(revs, [crev]):
3935 3935 ctx = repo[rev]
3936 3936 n = ctx.extra().get('source')
3937 3937 if n in ids:
3938 3938 try:
3939 3939 r = repo[n].rev()
3940 3940 except error.RepoLookupError:
3941 3941 r = None
3942 3942 if r in revs:
3943 3943 ui.warn(_('skipping revision %d:%s '
3944 3944 '(already grafted to %d:%s)\n')
3945 3945 % (r, repo[r], rev, ctx))
3946 3946 revs.remove(r)
3947 3947 elif ids[n] in revs:
3948 3948 if r is None:
3949 3949 ui.warn(_('skipping already grafted revision %d:%s '
3950 3950 '(%d:%s also has unknown origin %s)\n')
3951 3951 % (ids[n], repo[ids[n]], rev, ctx, n[:12]))
3952 3952 else:
3953 3953 ui.warn(_('skipping already grafted revision %d:%s '
3954 3954 '(%d:%s also has origin %d:%s)\n')
3955 3955 % (ids[n], repo[ids[n]], rev, ctx, r, n[:12]))
3956 3956 revs.remove(ids[n])
3957 3957 elif ctx.hex() in ids:
3958 3958 r = ids[ctx.hex()]
3959 3959 ui.warn(_('skipping already grafted revision %d:%s '
3960 3960 '(was grafted from %d:%s)\n') %
3961 3961 (r, repo[r], rev, ctx))
3962 3962 revs.remove(r)
3963 3963 if not revs:
3964 3964 return -1
3965 3965
3966 3966 try:
3967 3967 for pos, ctx in enumerate(repo.set("%ld", revs)):
3968 3968 desc = '%d:%s "%s"' % (ctx.rev(), ctx,
3969 3969 ctx.description().split('\n', 1)[0])
3970 3970 names = repo.nodetags(ctx.node()) + repo.nodebookmarks(ctx.node())
3971 3971 if names:
3972 3972 desc += ' (%s)' % ' '.join(names)
3973 3973 ui.status(_('grafting %s\n') % desc)
3974 3974 if opts.get('dry_run'):
3975 3975 continue
3976 3976
3977 3977 extra = ctx.extra().copy()
3978 3978 del extra['branch']
3979 3979 source = extra.get('source')
3980 3980 if source:
3981 3981 extra['intermediate-source'] = ctx.hex()
3982 3982 else:
3983 3983 extra['source'] = ctx.hex()
3984 3984 user = ctx.user()
3985 3985 if opts.get('user'):
3986 3986 user = opts['user']
3987 3987 date = ctx.date()
3988 3988 if opts.get('date'):
3989 3989 date = opts['date']
3990 3990 message = ctx.description()
3991 3991 if opts.get('log'):
3992 3992 message += '\n(grafted from %s)' % ctx.hex()
3993 3993
3994 3994 # we don't merge the first commit when continuing
3995 3995 if not cont:
3996 3996 # perform the graft merge with p1(rev) as 'ancestor'
3997 3997 try:
3998 3998 # ui.forcemerge is an internal variable, do not document
3999 3999 repo.ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
4000 4000 'graft')
4001 4001 stats = mergemod.graft(repo, ctx, ctx.p1(),
4002 4002 ['local', 'graft'])
4003 4003 finally:
4004 4004 repo.ui.setconfig('ui', 'forcemerge', '', 'graft')
4005 4005 # report any conflicts
4006 4006 if stats and stats[3] > 0:
4007 4007 # write out state for --continue
4008 4008 nodelines = [repo[rev].hex() + "\n" for rev in revs[pos:]]
4009 4009 repo.vfs.write('graftstate', ''.join(nodelines))
4010 4010 extra = ''
4011 4011 if opts.get('user'):
4012 4012 extra += ' --user %s' % opts['user']
4013 4013 if opts.get('date'):
4014 4014 extra += ' --date %s' % opts['date']
4015 4015 if opts.get('log'):
4016 4016 extra += ' --log'
4017 4017 hint=_('use hg resolve and hg graft --continue%s') % extra
4018 4018 raise error.Abort(
4019 4019 _("unresolved conflicts, can't continue"),
4020 4020 hint=hint)
4021 4021 else:
4022 4022 cont = False
4023 4023
4024 4024 # commit
4025 4025 node = repo.commit(text=message, user=user,
4026 4026 date=date, extra=extra, editor=editor)
4027 4027 if node is None:
4028 4028 ui.warn(
4029 4029 _('note: graft of %d:%s created no changes to commit\n') %
4030 4030 (ctx.rev(), ctx))
4031 4031 finally:
4032 4032 # TODO: get rid of this meaningless try/finally enclosing.
4033 4033 # this is kept only to reduce changes in a patch.
4034 4034 pass
4035 4035
4036 4036 # remove state when we complete successfully
4037 4037 if not opts.get('dry_run'):
4038 4038 util.unlinkpath(repo.join('graftstate'), ignoremissing=True)
4039 4039
4040 4040 return 0
4041 4041
4042 4042 @command('grep',
4043 4043 [('0', 'print0', None, _('end fields with NUL')),
4044 4044 ('', 'all', None, _('print all revisions that match')),
4045 4045 ('a', 'text', None, _('treat all files as text')),
4046 4046 ('f', 'follow', None,
4047 4047 _('follow changeset history,'
4048 4048 ' or file history across copies and renames')),
4049 4049 ('i', 'ignore-case', None, _('ignore case when matching')),
4050 4050 ('l', 'files-with-matches', None,
4051 4051 _('print only filenames and revisions that match')),
4052 4052 ('n', 'line-number', None, _('print matching line numbers')),
4053 4053 ('r', 'rev', [],
4054 4054 _('only search files changed within revision range'), _('REV')),
4055 4055 ('u', 'user', None, _('list the author (long with -v)')),
4056 4056 ('d', 'date', None, _('list the date (short with -q)')),
4057 4057 ] + walkopts,
4058 4058 _('[OPTION]... PATTERN [FILE]...'),
4059 4059 inferrepo=True)
4060 4060 def grep(ui, repo, pattern, *pats, **opts):
4061 4061 """search for a pattern in specified files and revisions
4062 4062
4063 4063 Search revisions of files for a regular expression.
4064 4064
4065 4065 This command behaves differently than Unix grep. It only accepts
4066 4066 Python/Perl regexps. It searches repository history, not the
4067 4067 working directory. It always prints the revision number in which a
4068 4068 match appears.
4069 4069
4070 4070 By default, grep only prints output for the first revision of a
4071 4071 file in which it finds a match. To get it to print every revision
4072 4072 that contains a change in match status ("-" for a match that
4073 4073 becomes a non-match, or "+" for a non-match that becomes a match),
4074 4074 use the --all flag.
4075 4075
4076 4076 Returns 0 if a match is found, 1 otherwise.
4077 4077 """
4078 4078 reflags = re.M
4079 4079 if opts.get('ignore_case'):
4080 4080 reflags |= re.I
4081 4081 try:
4082 4082 regexp = util.re.compile(pattern, reflags)
4083 4083 except re.error as inst:
4084 4084 ui.warn(_("grep: invalid match pattern: %s\n") % inst)
4085 4085 return 1
4086 4086 sep, eol = ':', '\n'
4087 4087 if opts.get('print0'):
4088 4088 sep = eol = '\0'
4089 4089
4090 4090 getfile = util.lrucachefunc(repo.file)
4091 4091
4092 4092 def matchlines(body):
4093 4093 begin = 0
4094 4094 linenum = 0
4095 4095 while begin < len(body):
4096 4096 match = regexp.search(body, begin)
4097 4097 if not match:
4098 4098 break
4099 4099 mstart, mend = match.span()
4100 4100 linenum += body.count('\n', begin, mstart) + 1
4101 4101 lstart = body.rfind('\n', begin, mstart) + 1 or begin
4102 4102 begin = body.find('\n', mend) + 1 or len(body) + 1
4103 4103 lend = begin - 1
4104 4104 yield linenum, mstart - lstart, mend - lstart, body[lstart:lend]
4105 4105
4106 4106 class linestate(object):
4107 4107 def __init__(self, line, linenum, colstart, colend):
4108 4108 self.line = line
4109 4109 self.linenum = linenum
4110 4110 self.colstart = colstart
4111 4111 self.colend = colend
4112 4112
4113 4113 def __hash__(self):
4114 4114 return hash((self.linenum, self.line))
4115 4115
4116 4116 def __eq__(self, other):
4117 4117 return self.line == other.line
4118 4118
4119 4119 def __iter__(self):
4120 4120 yield (self.line[:self.colstart], '')
4121 4121 yield (self.line[self.colstart:self.colend], 'grep.match')
4122 4122 rest = self.line[self.colend:]
4123 4123 while rest != '':
4124 4124 match = regexp.search(rest)
4125 4125 if not match:
4126 4126 yield (rest, '')
4127 4127 break
4128 4128 mstart, mend = match.span()
4129 4129 yield (rest[:mstart], '')
4130 4130 yield (rest[mstart:mend], 'grep.match')
4131 4131 rest = rest[mend:]
4132 4132
4133 4133 matches = {}
4134 4134 copies = {}
4135 4135 def grepbody(fn, rev, body):
4136 4136 matches[rev].setdefault(fn, [])
4137 4137 m = matches[rev][fn]
4138 4138 for lnum, cstart, cend, line in matchlines(body):
4139 4139 s = linestate(line, lnum, cstart, cend)
4140 4140 m.append(s)
4141 4141
4142 4142 def difflinestates(a, b):
4143 4143 sm = difflib.SequenceMatcher(None, a, b)
4144 4144 for tag, alo, ahi, blo, bhi in sm.get_opcodes():
4145 4145 if tag == 'insert':
4146 4146 for i in xrange(blo, bhi):
4147 4147 yield ('+', b[i])
4148 4148 elif tag == 'delete':
4149 4149 for i in xrange(alo, ahi):
4150 4150 yield ('-', a[i])
4151 4151 elif tag == 'replace':
4152 4152 for i in xrange(alo, ahi):
4153 4153 yield ('-', a[i])
4154 4154 for i in xrange(blo, bhi):
4155 4155 yield ('+', b[i])
4156 4156
4157 4157 def display(fn, ctx, pstates, states):
4158 4158 rev = ctx.rev()
4159 4159 if ui.quiet:
4160 4160 datefunc = util.shortdate
4161 4161 else:
4162 4162 datefunc = util.datestr
4163 4163 found = False
4164 4164 @util.cachefunc
4165 4165 def binary():
4166 4166 flog = getfile(fn)
4167 4167 return util.binary(flog.read(ctx.filenode(fn)))
4168 4168
4169 4169 if opts.get('all'):
4170 4170 iter = difflinestates(pstates, states)
4171 4171 else:
4172 4172 iter = [('', l) for l in states]
4173 4173 for change, l in iter:
4174 4174 cols = [(fn, 'grep.filename'), (str(rev), 'grep.rev')]
4175 4175
4176 4176 if opts.get('line_number'):
4177 4177 cols.append((str(l.linenum), 'grep.linenumber'))
4178 4178 if opts.get('all'):
4179 4179 cols.append((change, 'grep.change'))
4180 4180 if opts.get('user'):
4181 4181 cols.append((ui.shortuser(ctx.user()), 'grep.user'))
4182 4182 if opts.get('date'):
4183 4183 cols.append((datefunc(ctx.date()), 'grep.date'))
4184 4184 for col, label in cols[:-1]:
4185 4185 ui.write(col, label=label)
4186 4186 ui.write(sep, label='grep.sep')
4187 4187 ui.write(cols[-1][0], label=cols[-1][1])
4188 4188 if not opts.get('files_with_matches'):
4189 4189 ui.write(sep, label='grep.sep')
4190 4190 if not opts.get('text') and binary():
4191 4191 ui.write(" Binary file matches")
4192 4192 else:
4193 4193 for s, label in l:
4194 4194 ui.write(s, label=label)
4195 4195 ui.write(eol)
4196 4196 found = True
4197 4197 if opts.get('files_with_matches'):
4198 4198 break
4199 4199 return found
4200 4200
4201 4201 skip = {}
4202 4202 revfiles = {}
4203 4203 matchfn = scmutil.match(repo[None], pats, opts)
4204 4204 found = False
4205 4205 follow = opts.get('follow')
4206 4206
4207 4207 def prep(ctx, fns):
4208 4208 rev = ctx.rev()
4209 4209 pctx = ctx.p1()
4210 4210 parent = pctx.rev()
4211 4211 matches.setdefault(rev, {})
4212 4212 matches.setdefault(parent, {})
4213 4213 files = revfiles.setdefault(rev, [])
4214 4214 for fn in fns:
4215 4215 flog = getfile(fn)
4216 4216 try:
4217 4217 fnode = ctx.filenode(fn)
4218 4218 except error.LookupError:
4219 4219 continue
4220 4220
4221 4221 copied = flog.renamed(fnode)
4222 4222 copy = follow and copied and copied[0]
4223 4223 if copy:
4224 4224 copies.setdefault(rev, {})[fn] = copy
4225 4225 if fn in skip:
4226 4226 if copy:
4227 4227 skip[copy] = True
4228 4228 continue
4229 4229 files.append(fn)
4230 4230
4231 4231 if fn not in matches[rev]:
4232 4232 grepbody(fn, rev, flog.read(fnode))
4233 4233
4234 4234 pfn = copy or fn
4235 4235 if pfn not in matches[parent]:
4236 4236 try:
4237 4237 fnode = pctx.filenode(pfn)
4238 4238 grepbody(pfn, parent, flog.read(fnode))
4239 4239 except error.LookupError:
4240 4240 pass
4241 4241
4242 4242 for ctx in cmdutil.walkchangerevs(repo, matchfn, opts, prep):
4243 4243 rev = ctx.rev()
4244 4244 parent = ctx.p1().rev()
4245 4245 for fn in sorted(revfiles.get(rev, [])):
4246 4246 states = matches[rev][fn]
4247 4247 copy = copies.get(rev, {}).get(fn)
4248 4248 if fn in skip:
4249 4249 if copy:
4250 4250 skip[copy] = True
4251 4251 continue
4252 4252 pstates = matches.get(parent, {}).get(copy or fn, [])
4253 4253 if pstates or states:
4254 4254 r = display(fn, ctx, pstates, states)
4255 4255 found = found or r
4256 4256 if r and not opts.get('all'):
4257 4257 skip[fn] = True
4258 4258 if copy:
4259 4259 skip[copy] = True
4260 4260 del matches[rev]
4261 4261 del revfiles[rev]
4262 4262
4263 4263 return not found
4264 4264
4265 4265 @command('heads',
4266 4266 [('r', 'rev', '',
4267 4267 _('show only heads which are descendants of STARTREV'), _('STARTREV')),
4268 4268 ('t', 'topo', False, _('show topological heads only')),
4269 4269 ('a', 'active', False, _('show active branchheads only (DEPRECATED)')),
4270 4270 ('c', 'closed', False, _('show normal and closed branch heads')),
4271 4271 ] + templateopts,
4272 4272 _('[-ct] [-r STARTREV] [REV]...'))
4273 4273 def heads(ui, repo, *branchrevs, **opts):
4274 4274 """show branch heads
4275 4275
4276 4276 With no arguments, show all open branch heads in the repository.
4277 4277 Branch heads are changesets that have no descendants on the
4278 4278 same branch. They are where development generally takes place and
4279 4279 are the usual targets for update and merge operations.
4280 4280
4281 4281 If one or more REVs are given, only open branch heads on the
4282 4282 branches associated with the specified changesets are shown. This
4283 4283 means that you can use :hg:`heads .` to see the heads on the
4284 4284 currently checked-out branch.
4285 4285
4286 4286 If -c/--closed is specified, also show branch heads marked closed
4287 4287 (see :hg:`commit --close-branch`).
4288 4288
4289 4289 If STARTREV is specified, only those heads that are descendants of
4290 4290 STARTREV will be displayed.
4291 4291
4292 4292 If -t/--topo is specified, named branch mechanics will be ignored and only
4293 4293 topological heads (changesets with no children) will be shown.
4294 4294
4295 4295 Returns 0 if matching heads are found, 1 if not.
4296 4296 """
4297 4297
4298 4298 start = None
4299 4299 if 'rev' in opts:
4300 4300 start = scmutil.revsingle(repo, opts['rev'], None).node()
4301 4301
4302 4302 if opts.get('topo'):
4303 4303 heads = [repo[h] for h in repo.heads(start)]
4304 4304 else:
4305 4305 heads = []
4306 4306 for branch in repo.branchmap():
4307 4307 heads += repo.branchheads(branch, start, opts.get('closed'))
4308 4308 heads = [repo[h] for h in heads]
4309 4309
4310 4310 if branchrevs:
4311 4311 branches = set(repo[br].branch() for br in branchrevs)
4312 4312 heads = [h for h in heads if h.branch() in branches]
4313 4313
4314 4314 if opts.get('active') and branchrevs:
4315 4315 dagheads = repo.heads(start)
4316 4316 heads = [h for h in heads if h.node() in dagheads]
4317 4317
4318 4318 if branchrevs:
4319 4319 haveheads = set(h.branch() for h in heads)
4320 4320 if branches - haveheads:
4321 4321 headless = ', '.join(b for b in branches - haveheads)
4322 4322 msg = _('no open branch heads found on branches %s')
4323 4323 if opts.get('rev'):
4324 4324 msg += _(' (started at %s)') % opts['rev']
4325 4325 ui.warn((msg + '\n') % headless)
4326 4326
4327 4327 if not heads:
4328 4328 return 1
4329 4329
4330 4330 heads = sorted(heads, key=lambda x: -x.rev())
4331 4331 displayer = cmdutil.show_changeset(ui, repo, opts)
4332 4332 for ctx in heads:
4333 4333 displayer.show(ctx)
4334 4334 displayer.close()
4335 4335
4336 4336 @command('help',
4337 4337 [('e', 'extension', None, _('show only help for extensions')),
4338 4338 ('c', 'command', None, _('show only help for commands')),
4339 4339 ('k', 'keyword', None, _('show topics matching keyword')),
4340 4340 ],
4341 4341 _('[-eck] [TOPIC]'),
4342 4342 norepo=True)
4343 4343 def help_(ui, name=None, **opts):
4344 4344 """show help for a given topic or a help overview
4345 4345
4346 4346 With no arguments, print a list of commands with short help messages.
4347 4347
4348 4348 Given a topic, extension, or command name, print help for that
4349 4349 topic.
4350 4350
4351 4351 Returns 0 if successful.
4352 4352 """
4353 4353
4354 4354 textwidth = min(ui.termwidth(), 80) - 2
4355 4355
4356 4356 keep = []
4357 4357 if ui.verbose:
4358 4358 keep.append('verbose')
4359 4359 if sys.platform.startswith('win'):
4360 4360 keep.append('windows')
4361 4361 elif sys.platform == 'OpenVMS':
4362 4362 keep.append('vms')
4363 4363 elif sys.platform == 'plan9':
4364 4364 keep.append('plan9')
4365 4365 else:
4366 4366 keep.append('unix')
4367 4367 keep.append(sys.platform.lower())
4368 4368
4369 4369 section = None
4370 4370 subtopic = None
4371 4371 if name and '.' in name:
4372 4372 name, section = name.split('.', 1)
4373 4373 section = section.lower()
4374 4374 if '.' in section:
4375 4375 subtopic, section = section.split('.', 1)
4376 4376 else:
4377 4377 subtopic = section
4378 4378
4379 4379 text = help.help_(ui, name, subtopic=subtopic, **opts)
4380 4380
4381 4381 formatted, pruned = minirst.format(text, textwidth, keep=keep,
4382 4382 section=section)
4383 4383
4384 4384 # We could have been given a weird ".foo" section without a name
4385 4385 # to look for, or we could have simply failed to found "foo.bar"
4386 4386 # because bar isn't a section of foo
4387 4387 if section and not (formatted and name):
4388 4388 raise error.Abort(_("help section not found"))
4389 4389
4390 4390 if 'verbose' in pruned:
4391 4391 keep.append('omitted')
4392 4392 else:
4393 4393 keep.append('notomitted')
4394 4394 formatted, pruned = minirst.format(text, textwidth, keep=keep,
4395 4395 section=section)
4396 4396 ui.write(formatted)
4397 4397
4398 4398
4399 4399 @command('identify|id',
4400 4400 [('r', 'rev', '',
4401 4401 _('identify the specified revision'), _('REV')),
4402 4402 ('n', 'num', None, _('show local revision number')),
4403 4403 ('i', 'id', None, _('show global revision id')),
4404 4404 ('b', 'branch', None, _('show branch')),
4405 4405 ('t', 'tags', None, _('show tags')),
4406 4406 ('B', 'bookmarks', None, _('show bookmarks')),
4407 4407 ] + remoteopts,
4408 4408 _('[-nibtB] [-r REV] [SOURCE]'),
4409 4409 optionalrepo=True)
4410 4410 def identify(ui, repo, source=None, rev=None,
4411 4411 num=None, id=None, branch=None, tags=None, bookmarks=None, **opts):
4412 4412 """identify the working directory or specified revision
4413 4413
4414 4414 Print a summary identifying the repository state at REV using one or
4415 4415 two parent hash identifiers, followed by a "+" if the working
4416 4416 directory has uncommitted changes, the branch name (if not default),
4417 4417 a list of tags, and a list of bookmarks.
4418 4418
4419 4419 When REV is not given, print a summary of the current state of the
4420 4420 repository.
4421 4421
4422 4422 Specifying a path to a repository root or Mercurial bundle will
4423 4423 cause lookup to operate on that repository/bundle.
4424 4424
4425 4425 .. container:: verbose
4426 4426
4427 4427 Examples:
4428 4428
4429 4429 - generate a build identifier for the working directory::
4430 4430
4431 4431 hg id --id > build-id.dat
4432 4432
4433 4433 - find the revision corresponding to a tag::
4434 4434
4435 4435 hg id -n -r 1.3
4436 4436
4437 4437 - check the most recent revision of a remote repository::
4438 4438
4439 4439 hg id -r tip http://selenic.com/hg/
4440 4440
4441 4441 See :hg:`log` for generating more information about specific revisions,
4442 4442 including full hash identifiers.
4443 4443
4444 4444 Returns 0 if successful.
4445 4445 """
4446 4446
4447 4447 if not repo and not source:
4448 4448 raise error.Abort(_("there is no Mercurial repository here "
4449 4449 "(.hg not found)"))
4450 4450
4451 4451 if ui.debugflag:
4452 4452 hexfunc = hex
4453 4453 else:
4454 4454 hexfunc = short
4455 4455 default = not (num or id or branch or tags or bookmarks)
4456 4456 output = []
4457 4457 revs = []
4458 4458
4459 4459 if source:
4460 4460 source, branches = hg.parseurl(ui.expandpath(source))
4461 4461 peer = hg.peer(repo or ui, opts, source) # only pass ui when no repo
4462 4462 repo = peer.local()
4463 4463 revs, checkout = hg.addbranchrevs(repo, peer, branches, None)
4464 4464
4465 4465 if not repo:
4466 4466 if num or branch or tags:
4467 4467 raise error.Abort(
4468 4468 _("can't query remote revision number, branch, or tags"))
4469 4469 if not rev and revs:
4470 4470 rev = revs[0]
4471 4471 if not rev:
4472 4472 rev = "tip"
4473 4473
4474 4474 remoterev = peer.lookup(rev)
4475 4475 if default or id:
4476 4476 output = [hexfunc(remoterev)]
4477 4477
4478 4478 def getbms():
4479 4479 bms = []
4480 4480
4481 4481 if 'bookmarks' in peer.listkeys('namespaces'):
4482 4482 hexremoterev = hex(remoterev)
4483 4483 bms = [bm for bm, bmr in peer.listkeys('bookmarks').iteritems()
4484 4484 if bmr == hexremoterev]
4485 4485
4486 4486 return sorted(bms)
4487 4487
4488 4488 if bookmarks:
4489 4489 output.extend(getbms())
4490 4490 elif default and not ui.quiet:
4491 4491 # multiple bookmarks for a single parent separated by '/'
4492 4492 bm = '/'.join(getbms())
4493 4493 if bm:
4494 4494 output.append(bm)
4495 4495 else:
4496 4496 ctx = scmutil.revsingle(repo, rev, None)
4497 4497
4498 4498 if ctx.rev() is None:
4499 4499 ctx = repo[None]
4500 4500 parents = ctx.parents()
4501 4501 taglist = []
4502 4502 for p in parents:
4503 4503 taglist.extend(p.tags())
4504 4504
4505 4505 changed = ""
4506 4506 if default or id or num:
4507 4507 if (any(repo.status())
4508 4508 or any(ctx.sub(s).dirty() for s in ctx.substate)):
4509 4509 changed = '+'
4510 4510 if default or id:
4511 4511 output = ["%s%s" %
4512 4512 ('+'.join([hexfunc(p.node()) for p in parents]), changed)]
4513 4513 if num:
4514 4514 output.append("%s%s" %
4515 4515 ('+'.join([str(p.rev()) for p in parents]), changed))
4516 4516 else:
4517 4517 if default or id:
4518 4518 output = [hexfunc(ctx.node())]
4519 4519 if num:
4520 4520 output.append(str(ctx.rev()))
4521 4521 taglist = ctx.tags()
4522 4522
4523 4523 if default and not ui.quiet:
4524 4524 b = ctx.branch()
4525 4525 if b != 'default':
4526 4526 output.append("(%s)" % b)
4527 4527
4528 4528 # multiple tags for a single parent separated by '/'
4529 4529 t = '/'.join(taglist)
4530 4530 if t:
4531 4531 output.append(t)
4532 4532
4533 4533 # multiple bookmarks for a single parent separated by '/'
4534 4534 bm = '/'.join(ctx.bookmarks())
4535 4535 if bm:
4536 4536 output.append(bm)
4537 4537 else:
4538 4538 if branch:
4539 4539 output.append(ctx.branch())
4540 4540
4541 4541 if tags:
4542 4542 output.extend(taglist)
4543 4543
4544 4544 if bookmarks:
4545 4545 output.extend(ctx.bookmarks())
4546 4546
4547 4547 ui.write("%s\n" % ' '.join(output))
4548 4548
4549 4549 @command('import|patch',
4550 4550 [('p', 'strip', 1,
4551 4551 _('directory strip option for patch. This has the same '
4552 4552 'meaning as the corresponding patch option'), _('NUM')),
4553 4553 ('b', 'base', '', _('base path (DEPRECATED)'), _('PATH')),
4554 4554 ('e', 'edit', False, _('invoke editor on commit messages')),
4555 4555 ('f', 'force', None,
4556 4556 _('skip check for outstanding uncommitted changes (DEPRECATED)')),
4557 4557 ('', 'no-commit', None,
4558 4558 _("don't commit, just update the working directory")),
4559 4559 ('', 'bypass', None,
4560 4560 _("apply patch without touching the working directory")),
4561 4561 ('', 'partial', None,
4562 4562 _('commit even if some hunks fail')),
4563 4563 ('', 'exact', None,
4564 4564 _('apply patch to the nodes from which it was generated')),
4565 4565 ('', 'prefix', '',
4566 4566 _('apply patch to subdirectory'), _('DIR')),
4567 4567 ('', 'import-branch', None,
4568 4568 _('use any branch information in patch (implied by --exact)'))] +
4569 4569 commitopts + commitopts2 + similarityopts,
4570 4570 _('[OPTION]... PATCH...'))
4571 4571 def import_(ui, repo, patch1=None, *patches, **opts):
4572 4572 """import an ordered set of patches
4573 4573
4574 4574 Import a list of patches and commit them individually (unless
4575 4575 --no-commit is specified).
4576 4576
4577 Because import first applies changes to the working directory,
4578 import will abort if there are outstanding changes.
4577 To read a patch from standard input, use "-" as the patch name. If
4578 a URL is specified, the patch will be downloaded from there.
4579
4580 Import first applies changes to the working directory (unless
4581 --bypass is specified), import will abort if there are outstanding
4582 changes.
4583
4584 Use --bypass to apply and commit patches directly to the
4585 repository, without affecting the working directory. Without
4586 --exact, patches will be applied on top of the working directory
4587 parent revision.
4579 4588
4580 4589 You can import a patch straight from a mail message. Even patches
4581 4590 as attachments work (to use the body part, it must have type
4582 4591 text/plain or text/x-patch). From and Subject headers of email
4583 4592 message are used as default committer and commit message. All
4584 4593 text/plain body parts before first diff are added to the commit
4585 4594 message.
4586 4595
4587 4596 If the imported patch was generated by :hg:`export`, user and
4588 4597 description from patch override values from message headers and
4589 4598 body. Values given on command line with -m/--message and -u/--user
4590 4599 override these.
4591 4600
4592 4601 If --exact is specified, import will set the working directory to
4593 4602 the parent of each patch before applying it, and will abort if the
4594 4603 resulting changeset has a different ID than the one recorded in
4595 4604 the patch. This may happen due to character set problems or other
4596 4605 deficiencies in the text patch format.
4597 4606
4598 Use --bypass to apply and commit patches directly to the
4599 repository, not touching the working directory. Without --exact,
4600 patches will be applied on top of the working directory parent
4601 revision.
4602
4603 With -s/--similarity, hg will attempt to discover renames and
4604 copies in the patch in the same way as :hg:`addremove`.
4605
4606 4607 Use --partial to ensure a changeset will be created from the patch
4607 4608 even if some hunks fail to apply. Hunks that fail to apply will be
4608 4609 written to a <target-file>.rej file. Conflicts can then be resolved
4609 4610 by hand before :hg:`commit --amend` is run to update the created
4610 4611 changeset. This flag exists to let people import patches that
4611 4612 partially apply without losing the associated metadata (author,
4612 4613 date, description, ...). Note that when none of the hunk applies
4613 4614 cleanly, :hg:`import --partial` will create an empty changeset,
4614 4615 importing only the patch metadata.
4615 4616
4617 With -s/--similarity, hg will attempt to discover renames and
4618 copies in the patch in the same way as :hg:`addremove`.
4619
4616 4620 It is possible to use external patch programs to perform the patch
4617 4621 by setting the ``ui.patch`` configuration option. For the default
4618 4622 internal tool, the fuzz can also be configured via ``patch.fuzz``.
4619 4623 See :hg:`help config` for more information about configuration
4620 4624 files and how to use these options.
4621 4625
4622 To read a patch from standard input, use "-" as the patch name. If
4623 a URL is specified, the patch will be downloaded from it.
4624 4626 See :hg:`help dates` for a list of formats valid for -d/--date.
4625 4627
4626 4628 .. container:: verbose
4627 4629
4628 4630 Examples:
4629 4631
4630 4632 - import a traditional patch from a website and detect renames::
4631 4633
4632 4634 hg import -s 80 http://example.com/bugfix.patch
4633 4635
4634 4636 - import a changeset from an hgweb server::
4635 4637
4636 4638 hg import http://www.selenic.com/hg/rev/5ca8c111e9aa
4637 4639
4638 4640 - import all the patches in an Unix-style mbox::
4639 4641
4640 4642 hg import incoming-patches.mbox
4641 4643
4642 4644 - attempt to exactly restore an exported changeset (not always
4643 4645 possible)::
4644 4646
4645 4647 hg import --exact proposed-fix.patch
4646 4648
4647 4649 - use an external tool to apply a patch which is too fuzzy for
4648 4650 the default internal tool.
4649 4651
4650 4652 hg import --config ui.patch="patch --merge" fuzzy.patch
4651 4653
4652 4654 - change the default fuzzing from 2 to a less strict 7
4653 4655
4654 4656 hg import --config ui.fuzz=7 fuzz.patch
4655 4657
4656 4658 Returns 0 on success, 1 on partial success (see --partial).
4657 4659 """
4658 4660
4659 4661 if not patch1:
4660 4662 raise error.Abort(_('need at least one patch to import'))
4661 4663
4662 4664 patches = (patch1,) + patches
4663 4665
4664 4666 date = opts.get('date')
4665 4667 if date:
4666 4668 opts['date'] = util.parsedate(date)
4667 4669
4668 4670 exact = opts.get('exact')
4669 4671 update = not opts.get('bypass')
4670 4672 if not update and opts.get('no_commit'):
4671 4673 raise error.Abort(_('cannot use --no-commit with --bypass'))
4672 4674 try:
4673 4675 sim = float(opts.get('similarity') or 0)
4674 4676 except ValueError:
4675 4677 raise error.Abort(_('similarity must be a number'))
4676 4678 if sim < 0 or sim > 100:
4677 4679 raise error.Abort(_('similarity must be between 0 and 100'))
4678 4680 if sim and not update:
4679 4681 raise error.Abort(_('cannot use --similarity with --bypass'))
4680 4682 if exact:
4681 4683 if opts.get('edit'):
4682 4684 raise error.Abort(_('cannot use --exact with --edit'))
4683 4685 if opts.get('prefix'):
4684 4686 raise error.Abort(_('cannot use --exact with --prefix'))
4685 4687
4686 4688 base = opts["base"]
4687 4689 wlock = dsguard = lock = tr = None
4688 4690 msgs = []
4689 4691 ret = 0
4690 4692
4691 4693
4692 4694 try:
4693 4695 try:
4694 4696 wlock = repo.wlock()
4695 4697
4696 4698 if update:
4697 4699 cmdutil.checkunfinished(repo)
4698 4700 if (exact or not opts.get('force')):
4699 4701 cmdutil.bailifchanged(repo)
4700 4702
4701 4703 if not opts.get('no_commit'):
4702 4704 lock = repo.lock()
4703 4705 tr = repo.transaction('import')
4704 4706 else:
4705 4707 dsguard = cmdutil.dirstateguard(repo, 'import')
4706 4708 parents = repo[None].parents()
4707 4709 for patchurl in patches:
4708 4710 if patchurl == '-':
4709 4711 ui.status(_('applying patch from stdin\n'))
4710 4712 patchfile = ui.fin
4711 4713 patchurl = 'stdin' # for error message
4712 4714 else:
4713 4715 patchurl = os.path.join(base, patchurl)
4714 4716 ui.status(_('applying %s\n') % patchurl)
4715 4717 patchfile = hg.openpath(ui, patchurl)
4716 4718
4717 4719 haspatch = False
4718 4720 for hunk in patch.split(patchfile):
4719 4721 (msg, node, rej) = cmdutil.tryimportone(ui, repo, hunk,
4720 4722 parents, opts,
4721 4723 msgs, hg.clean)
4722 4724 if msg:
4723 4725 haspatch = True
4724 4726 ui.note(msg + '\n')
4725 4727 if update or exact:
4726 4728 parents = repo[None].parents()
4727 4729 else:
4728 4730 parents = [repo[node]]
4729 4731 if rej:
4730 4732 ui.write_err(_("patch applied partially\n"))
4731 4733 ui.write_err(_("(fix the .rej files and run "
4732 4734 "`hg commit --amend`)\n"))
4733 4735 ret = 1
4734 4736 break
4735 4737
4736 4738 if not haspatch:
4737 4739 raise error.Abort(_('%s: no diffs found') % patchurl)
4738 4740
4739 4741 if tr:
4740 4742 tr.close()
4741 4743 if msgs:
4742 4744 repo.savecommitmessage('\n* * *\n'.join(msgs))
4743 4745 if dsguard:
4744 4746 dsguard.close()
4745 4747 return ret
4746 4748 finally:
4747 4749 # TODO: get rid of this meaningless try/finally enclosing.
4748 4750 # this is kept only to reduce changes in a patch.
4749 4751 pass
4750 4752 finally:
4751 4753 if tr:
4752 4754 tr.release()
4753 4755 release(lock, dsguard, wlock)
4754 4756
4755 4757 @command('incoming|in',
4756 4758 [('f', 'force', None,
4757 4759 _('run even if remote repository is unrelated')),
4758 4760 ('n', 'newest-first', None, _('show newest record first')),
4759 4761 ('', 'bundle', '',
4760 4762 _('file to store the bundles into'), _('FILE')),
4761 4763 ('r', 'rev', [], _('a remote changeset intended to be added'), _('REV')),
4762 4764 ('B', 'bookmarks', False, _("compare bookmarks")),
4763 4765 ('b', 'branch', [],
4764 4766 _('a specific branch you would like to pull'), _('BRANCH')),
4765 4767 ] + logopts + remoteopts + subrepoopts,
4766 4768 _('[-p] [-n] [-M] [-f] [-r REV]... [--bundle FILENAME] [SOURCE]'))
4767 4769 def incoming(ui, repo, source="default", **opts):
4768 4770 """show new changesets found in source
4769 4771
4770 4772 Show new changesets found in the specified path/URL or the default
4771 4773 pull location. These are the changesets that would have been pulled
4772 4774 if a pull at the time you issued this command.
4773 4775
4774 4776 See pull for valid source format details.
4775 4777
4776 4778 .. container:: verbose
4777 4779
4778 4780 With -B/--bookmarks, the result of bookmark comparison between
4779 4781 local and remote repositories is displayed. With -v/--verbose,
4780 4782 status is also displayed for each bookmark like below::
4781 4783
4782 4784 BM1 01234567890a added
4783 4785 BM2 1234567890ab advanced
4784 4786 BM3 234567890abc diverged
4785 4787 BM4 34567890abcd changed
4786 4788
4787 4789 The action taken locally when pulling depends on the
4788 4790 status of each bookmark:
4789 4791
4790 4792 :``added``: pull will create it
4791 4793 :``advanced``: pull will update it
4792 4794 :``diverged``: pull will create a divergent bookmark
4793 4795 :``changed``: result depends on remote changesets
4794 4796
4795 4797 From the point of view of pulling behavior, bookmark
4796 4798 existing only in the remote repository are treated as ``added``,
4797 4799 even if it is in fact locally deleted.
4798 4800
4799 4801 .. container:: verbose
4800 4802
4801 4803 For remote repository, using --bundle avoids downloading the
4802 4804 changesets twice if the incoming is followed by a pull.
4803 4805
4804 4806 Examples:
4805 4807
4806 4808 - show incoming changes with patches and full description::
4807 4809
4808 4810 hg incoming -vp
4809 4811
4810 4812 - show incoming changes excluding merges, store a bundle::
4811 4813
4812 4814 hg in -vpM --bundle incoming.hg
4813 4815 hg pull incoming.hg
4814 4816
4815 4817 - briefly list changes inside a bundle::
4816 4818
4817 4819 hg in changes.hg -T "{desc|firstline}\\n"
4818 4820
4819 4821 Returns 0 if there are incoming changes, 1 otherwise.
4820 4822 """
4821 4823 if opts.get('graph'):
4822 4824 cmdutil.checkunsupportedgraphflags([], opts)
4823 4825 def display(other, chlist, displayer):
4824 4826 revdag = cmdutil.graphrevs(other, chlist, opts)
4825 4827 cmdutil.displaygraph(ui, repo, revdag, displayer,
4826 4828 graphmod.asciiedges)
4827 4829
4828 4830 hg._incoming(display, lambda: 1, ui, repo, source, opts, buffered=True)
4829 4831 return 0
4830 4832
4831 4833 if opts.get('bundle') and opts.get('subrepos'):
4832 4834 raise error.Abort(_('cannot combine --bundle and --subrepos'))
4833 4835
4834 4836 if opts.get('bookmarks'):
4835 4837 source, branches = hg.parseurl(ui.expandpath(source),
4836 4838 opts.get('branch'))
4837 4839 other = hg.peer(repo, opts, source)
4838 4840 if 'bookmarks' not in other.listkeys('namespaces'):
4839 4841 ui.warn(_("remote doesn't support bookmarks\n"))
4840 4842 return 0
4841 4843 ui.status(_('comparing with %s\n') % util.hidepassword(source))
4842 4844 return bookmarks.incoming(ui, repo, other)
4843 4845
4844 4846 repo._subtoppath = ui.expandpath(source)
4845 4847 try:
4846 4848 return hg.incoming(ui, repo, source, opts)
4847 4849 finally:
4848 4850 del repo._subtoppath
4849 4851
4850 4852
4851 4853 @command('^init', remoteopts, _('[-e CMD] [--remotecmd CMD] [DEST]'),
4852 4854 norepo=True)
4853 4855 def init(ui, dest=".", **opts):
4854 4856 """create a new repository in the given directory
4855 4857
4856 4858 Initialize a new repository in the given directory. If the given
4857 4859 directory does not exist, it will be created.
4858 4860
4859 4861 If no directory is given, the current directory is used.
4860 4862
4861 4863 It is possible to specify an ``ssh://`` URL as the destination.
4862 4864 See :hg:`help urls` for more information.
4863 4865
4864 4866 Returns 0 on success.
4865 4867 """
4866 4868 hg.peer(ui, opts, ui.expandpath(dest), create=True)
4867 4869
4868 4870 @command('locate',
4869 4871 [('r', 'rev', '', _('search the repository as it is in REV'), _('REV')),
4870 4872 ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
4871 4873 ('f', 'fullpath', None, _('print complete paths from the filesystem root')),
4872 4874 ] + walkopts,
4873 4875 _('[OPTION]... [PATTERN]...'))
4874 4876 def locate(ui, repo, *pats, **opts):
4875 4877 """locate files matching specific patterns (DEPRECATED)
4876 4878
4877 4879 Print files under Mercurial control in the working directory whose
4878 4880 names match the given patterns.
4879 4881
4880 4882 By default, this command searches all directories in the working
4881 4883 directory. To search just the current directory and its
4882 4884 subdirectories, use "--include .".
4883 4885
4884 4886 If no patterns are given to match, this command prints the names
4885 4887 of all files under Mercurial control in the working directory.
4886 4888
4887 4889 If you want to feed the output of this command into the "xargs"
4888 4890 command, use the -0 option to both this command and "xargs". This
4889 4891 will avoid the problem of "xargs" treating single filenames that
4890 4892 contain whitespace as multiple filenames.
4891 4893
4892 4894 See :hg:`help files` for a more versatile command.
4893 4895
4894 4896 Returns 0 if a match is found, 1 otherwise.
4895 4897 """
4896 4898 if opts.get('print0'):
4897 4899 end = '\0'
4898 4900 else:
4899 4901 end = '\n'
4900 4902 rev = scmutil.revsingle(repo, opts.get('rev'), None).node()
4901 4903
4902 4904 ret = 1
4903 4905 ctx = repo[rev]
4904 4906 m = scmutil.match(ctx, pats, opts, default='relglob',
4905 4907 badfn=lambda x, y: False)
4906 4908
4907 4909 for abs in ctx.matches(m):
4908 4910 if opts.get('fullpath'):
4909 4911 ui.write(repo.wjoin(abs), end)
4910 4912 else:
4911 4913 ui.write(((pats and m.rel(abs)) or abs), end)
4912 4914 ret = 0
4913 4915
4914 4916 return ret
4915 4917
4916 4918 @command('^log|history',
4917 4919 [('f', 'follow', None,
4918 4920 _('follow changeset history, or file history across copies and renames')),
4919 4921 ('', 'follow-first', None,
4920 4922 _('only follow the first parent of merge changesets (DEPRECATED)')),
4921 4923 ('d', 'date', '', _('show revisions matching date spec'), _('DATE')),
4922 4924 ('C', 'copies', None, _('show copied files')),
4923 4925 ('k', 'keyword', [],
4924 4926 _('do case-insensitive search for a given text'), _('TEXT')),
4925 4927 ('r', 'rev', [], _('show the specified revision or revset'), _('REV')),
4926 4928 ('', 'removed', None, _('include revisions where files were removed')),
4927 4929 ('m', 'only-merges', None, _('show only merges (DEPRECATED)')),
4928 4930 ('u', 'user', [], _('revisions committed by user'), _('USER')),
4929 4931 ('', 'only-branch', [],
4930 4932 _('show only changesets within the given named branch (DEPRECATED)'),
4931 4933 _('BRANCH')),
4932 4934 ('b', 'branch', [],
4933 4935 _('show changesets within the given named branch'), _('BRANCH')),
4934 4936 ('P', 'prune', [],
4935 4937 _('do not display revision or any of its ancestors'), _('REV')),
4936 4938 ] + logopts + walkopts,
4937 4939 _('[OPTION]... [FILE]'),
4938 4940 inferrepo=True)
4939 4941 def log(ui, repo, *pats, **opts):
4940 4942 """show revision history of entire repository or files
4941 4943
4942 4944 Print the revision history of the specified files or the entire
4943 4945 project.
4944 4946
4945 4947 If no revision range is specified, the default is ``tip:0`` unless
4946 4948 --follow is set, in which case the working directory parent is
4947 4949 used as the starting revision.
4948 4950
4949 4951 File history is shown without following rename or copy history of
4950 4952 files. Use -f/--follow with a filename to follow history across
4951 4953 renames and copies. --follow without a filename will only show
4952 4954 ancestors or descendants of the starting revision.
4953 4955
4954 4956 By default this command prints revision number and changeset id,
4955 4957 tags, non-trivial parents, user, date and time, and a summary for
4956 4958 each commit. When the -v/--verbose switch is used, the list of
4957 4959 changed files and full commit message are shown.
4958 4960
4959 4961 With --graph the revisions are shown as an ASCII art DAG with the most
4960 4962 recent changeset at the top.
4961 4963 'o' is a changeset, '@' is a working directory parent, 'x' is obsolete,
4962 4964 and '+' represents a fork where the changeset from the lines below is a
4963 4965 parent of the 'o' merge on the same line.
4964 4966
4965 4967 .. note::
4966 4968
4967 4969 log -p/--patch may generate unexpected diff output for merge
4968 4970 changesets, as it will only compare the merge changeset against
4969 4971 its first parent. Also, only files different from BOTH parents
4970 4972 will appear in files:.
4971 4973
4972 4974 .. note::
4973 4975
4974 4976 for performance reasons, log FILE may omit duplicate changes
4975 4977 made on branches and will not show removals or mode changes. To
4976 4978 see all such changes, use the --removed switch.
4977 4979
4978 4980 .. container:: verbose
4979 4981
4980 4982 Some examples:
4981 4983
4982 4984 - changesets with full descriptions and file lists::
4983 4985
4984 4986 hg log -v
4985 4987
4986 4988 - changesets ancestral to the working directory::
4987 4989
4988 4990 hg log -f
4989 4991
4990 4992 - last 10 commits on the current branch::
4991 4993
4992 4994 hg log -l 10 -b .
4993 4995
4994 4996 - changesets showing all modifications of a file, including removals::
4995 4997
4996 4998 hg log --removed file.c
4997 4999
4998 5000 - all changesets that touch a directory, with diffs, excluding merges::
4999 5001
5000 5002 hg log -Mp lib/
5001 5003
5002 5004 - all revision numbers that match a keyword::
5003 5005
5004 5006 hg log -k bug --template "{rev}\\n"
5005 5007
5006 5008 - the full hash identifier of the working directory parent::
5007 5009
5008 5010 hg log -r . --template "{node}\\n"
5009 5011
5010 5012 - list available log templates::
5011 5013
5012 5014 hg log -T list
5013 5015
5014 5016 - check if a given changeset is included in a tagged release::
5015 5017
5016 5018 hg log -r "a21ccf and ancestor(1.9)"
5017 5019
5018 5020 - find all changesets by some user in a date range::
5019 5021
5020 5022 hg log -k alice -d "may 2008 to jul 2008"
5021 5023
5022 5024 - summary of all changesets after the last tag::
5023 5025
5024 5026 hg log -r "last(tagged())::" --template "{desc|firstline}\\n"
5025 5027
5026 5028 See :hg:`help dates` for a list of formats valid for -d/--date.
5027 5029
5028 5030 See :hg:`help revisions` and :hg:`help revsets` for more about
5029 5031 specifying revisions.
5030 5032
5031 5033 See :hg:`help templates` for more about pre-packaged styles and
5032 5034 specifying custom templates.
5033 5035
5034 5036 Returns 0 on success.
5035 5037
5036 5038 """
5037 5039 if opts.get('follow') and opts.get('rev'):
5038 5040 opts['rev'] = [revset.formatspec('reverse(::%lr)', opts.get('rev'))]
5039 5041 del opts['follow']
5040 5042
5041 5043 if opts.get('graph'):
5042 5044 return cmdutil.graphlog(ui, repo, *pats, **opts)
5043 5045
5044 5046 revs, expr, filematcher = cmdutil.getlogrevs(repo, pats, opts)
5045 5047 limit = cmdutil.loglimit(opts)
5046 5048 count = 0
5047 5049
5048 5050 getrenamed = None
5049 5051 if opts.get('copies'):
5050 5052 endrev = None
5051 5053 if opts.get('rev'):
5052 5054 endrev = scmutil.revrange(repo, opts.get('rev')).max() + 1
5053 5055 getrenamed = templatekw.getrenamedfn(repo, endrev=endrev)
5054 5056
5055 5057 displayer = cmdutil.show_changeset(ui, repo, opts, buffered=True)
5056 5058 for rev in revs:
5057 5059 if count == limit:
5058 5060 break
5059 5061 ctx = repo[rev]
5060 5062 copies = None
5061 5063 if getrenamed is not None and rev:
5062 5064 copies = []
5063 5065 for fn in ctx.files():
5064 5066 rename = getrenamed(fn, rev)
5065 5067 if rename:
5066 5068 copies.append((fn, rename[0]))
5067 5069 if filematcher:
5068 5070 revmatchfn = filematcher(ctx.rev())
5069 5071 else:
5070 5072 revmatchfn = None
5071 5073 displayer.show(ctx, copies=copies, matchfn=revmatchfn)
5072 5074 if displayer.flush(ctx):
5073 5075 count += 1
5074 5076
5075 5077 displayer.close()
5076 5078
5077 5079 @command('manifest',
5078 5080 [('r', 'rev', '', _('revision to display'), _('REV')),
5079 5081 ('', 'all', False, _("list files from all revisions"))]
5080 5082 + formatteropts,
5081 5083 _('[-r REV]'))
5082 5084 def manifest(ui, repo, node=None, rev=None, **opts):
5083 5085 """output the current or given revision of the project manifest
5084 5086
5085 5087 Print a list of version controlled files for the given revision.
5086 5088 If no revision is given, the first parent of the working directory
5087 5089 is used, or the null revision if no revision is checked out.
5088 5090
5089 5091 With -v, print file permissions, symlink and executable bits.
5090 5092 With --debug, print file revision hashes.
5091 5093
5092 5094 If option --all is specified, the list of all files from all revisions
5093 5095 is printed. This includes deleted and renamed files.
5094 5096
5095 5097 Returns 0 on success.
5096 5098 """
5097 5099
5098 5100 fm = ui.formatter('manifest', opts)
5099 5101
5100 5102 if opts.get('all'):
5101 5103 if rev or node:
5102 5104 raise error.Abort(_("can't specify a revision with --all"))
5103 5105
5104 5106 res = []
5105 5107 prefix = "data/"
5106 5108 suffix = ".i"
5107 5109 plen = len(prefix)
5108 5110 slen = len(suffix)
5109 5111 lock = repo.lock()
5110 5112 try:
5111 5113 for fn, b, size in repo.store.datafiles():
5112 5114 if size != 0 and fn[-slen:] == suffix and fn[:plen] == prefix:
5113 5115 res.append(fn[plen:-slen])
5114 5116 finally:
5115 5117 lock.release()
5116 5118 for f in res:
5117 5119 fm.startitem()
5118 5120 fm.write("path", '%s\n', f)
5119 5121 fm.end()
5120 5122 return
5121 5123
5122 5124 if rev and node:
5123 5125 raise error.Abort(_("please specify just one revision"))
5124 5126
5125 5127 if not node:
5126 5128 node = rev
5127 5129
5128 5130 char = {'l': '@', 'x': '*', '': ''}
5129 5131 mode = {'l': '644', 'x': '755', '': '644'}
5130 5132 ctx = scmutil.revsingle(repo, node)
5131 5133 mf = ctx.manifest()
5132 5134 for f in ctx:
5133 5135 fm.startitem()
5134 5136 fl = ctx[f].flags()
5135 5137 fm.condwrite(ui.debugflag, 'hash', '%s ', hex(mf[f]))
5136 5138 fm.condwrite(ui.verbose, 'mode type', '%s %1s ', mode[fl], char[fl])
5137 5139 fm.write('path', '%s\n', f)
5138 5140 fm.end()
5139 5141
5140 5142 @command('^merge',
5141 5143 [('f', 'force', None,
5142 5144 _('force a merge including outstanding changes (DEPRECATED)')),
5143 5145 ('r', 'rev', '', _('revision to merge'), _('REV')),
5144 5146 ('P', 'preview', None,
5145 5147 _('review revisions to merge (no merge is performed)'))
5146 5148 ] + mergetoolopts,
5147 5149 _('[-P] [-f] [[-r] REV]'))
5148 5150 def merge(ui, repo, node=None, **opts):
5149 5151 """merge another revision into working directory
5150 5152
5151 5153 The current working directory is updated with all changes made in
5152 5154 the requested revision since the last common predecessor revision.
5153 5155
5154 5156 Files that changed between either parent are marked as changed for
5155 5157 the next commit and a commit must be performed before any further
5156 5158 updates to the repository are allowed. The next commit will have
5157 5159 two parents.
5158 5160
5159 5161 ``--tool`` can be used to specify the merge tool used for file
5160 5162 merges. It overrides the HGMERGE environment variable and your
5161 5163 configuration files. See :hg:`help merge-tools` for options.
5162 5164
5163 5165 If no revision is specified, the working directory's parent is a
5164 5166 head revision, and the current branch contains exactly one other
5165 5167 head, the other head is merged with by default. Otherwise, an
5166 5168 explicit revision with which to merge with must be provided.
5167 5169
5168 5170 :hg:`resolve` must be used to resolve unresolved files.
5169 5171
5170 5172 To undo an uncommitted merge, use :hg:`update --clean .` which
5171 5173 will check out a clean copy of the original merge parent, losing
5172 5174 all changes.
5173 5175
5174 5176 Returns 0 on success, 1 if there are unresolved files.
5175 5177 """
5176 5178
5177 5179 if opts.get('rev') and node:
5178 5180 raise error.Abort(_("please specify just one revision"))
5179 5181 if not node:
5180 5182 node = opts.get('rev')
5181 5183
5182 5184 if node:
5183 5185 node = scmutil.revsingle(repo, node).node()
5184 5186
5185 5187 if not node:
5186 5188 node = repo[destutil.destmerge(repo)].node()
5187 5189
5188 5190 if opts.get('preview'):
5189 5191 # find nodes that are ancestors of p2 but not of p1
5190 5192 p1 = repo.lookup('.')
5191 5193 p2 = repo.lookup(node)
5192 5194 nodes = repo.changelog.findmissing(common=[p1], heads=[p2])
5193 5195
5194 5196 displayer = cmdutil.show_changeset(ui, repo, opts)
5195 5197 for node in nodes:
5196 5198 displayer.show(repo[node])
5197 5199 displayer.close()
5198 5200 return 0
5199 5201
5200 5202 try:
5201 5203 # ui.forcemerge is an internal variable, do not document
5202 5204 repo.ui.setconfig('ui', 'forcemerge', opts.get('tool', ''), 'merge')
5203 5205 return hg.merge(repo, node, force=opts.get('force'))
5204 5206 finally:
5205 5207 ui.setconfig('ui', 'forcemerge', '', 'merge')
5206 5208
5207 5209 @command('outgoing|out',
5208 5210 [('f', 'force', None, _('run even when the destination is unrelated')),
5209 5211 ('r', 'rev', [],
5210 5212 _('a changeset intended to be included in the destination'), _('REV')),
5211 5213 ('n', 'newest-first', None, _('show newest record first')),
5212 5214 ('B', 'bookmarks', False, _('compare bookmarks')),
5213 5215 ('b', 'branch', [], _('a specific branch you would like to push'),
5214 5216 _('BRANCH')),
5215 5217 ] + logopts + remoteopts + subrepoopts,
5216 5218 _('[-M] [-p] [-n] [-f] [-r REV]... [DEST]'))
5217 5219 def outgoing(ui, repo, dest=None, **opts):
5218 5220 """show changesets not found in the destination
5219 5221
5220 5222 Show changesets not found in the specified destination repository
5221 5223 or the default push location. These are the changesets that would
5222 5224 be pushed if a push was requested.
5223 5225
5224 5226 See pull for details of valid destination formats.
5225 5227
5226 5228 .. container:: verbose
5227 5229
5228 5230 With -B/--bookmarks, the result of bookmark comparison between
5229 5231 local and remote repositories is displayed. With -v/--verbose,
5230 5232 status is also displayed for each bookmark like below::
5231 5233
5232 5234 BM1 01234567890a added
5233 5235 BM2 deleted
5234 5236 BM3 234567890abc advanced
5235 5237 BM4 34567890abcd diverged
5236 5238 BM5 4567890abcde changed
5237 5239
5238 5240 The action taken when pushing depends on the
5239 5241 status of each bookmark:
5240 5242
5241 5243 :``added``: push with ``-B`` will create it
5242 5244 :``deleted``: push with ``-B`` will delete it
5243 5245 :``advanced``: push will update it
5244 5246 :``diverged``: push with ``-B`` will update it
5245 5247 :``changed``: push with ``-B`` will update it
5246 5248
5247 5249 From the point of view of pushing behavior, bookmarks
5248 5250 existing only in the remote repository are treated as
5249 5251 ``deleted``, even if it is in fact added remotely.
5250 5252
5251 5253 Returns 0 if there are outgoing changes, 1 otherwise.
5252 5254 """
5253 5255 if opts.get('graph'):
5254 5256 cmdutil.checkunsupportedgraphflags([], opts)
5255 5257 o, other = hg._outgoing(ui, repo, dest, opts)
5256 5258 if not o:
5257 5259 cmdutil.outgoinghooks(ui, repo, other, opts, o)
5258 5260 return
5259 5261
5260 5262 revdag = cmdutil.graphrevs(repo, o, opts)
5261 5263 displayer = cmdutil.show_changeset(ui, repo, opts, buffered=True)
5262 5264 cmdutil.displaygraph(ui, repo, revdag, displayer, graphmod.asciiedges)
5263 5265 cmdutil.outgoinghooks(ui, repo, other, opts, o)
5264 5266 return 0
5265 5267
5266 5268 if opts.get('bookmarks'):
5267 5269 dest = ui.expandpath(dest or 'default-push', dest or 'default')
5268 5270 dest, branches = hg.parseurl(dest, opts.get('branch'))
5269 5271 other = hg.peer(repo, opts, dest)
5270 5272 if 'bookmarks' not in other.listkeys('namespaces'):
5271 5273 ui.warn(_("remote doesn't support bookmarks\n"))
5272 5274 return 0
5273 5275 ui.status(_('comparing with %s\n') % util.hidepassword(dest))
5274 5276 return bookmarks.outgoing(ui, repo, other)
5275 5277
5276 5278 repo._subtoppath = ui.expandpath(dest or 'default-push', dest or 'default')
5277 5279 try:
5278 5280 return hg.outgoing(ui, repo, dest, opts)
5279 5281 finally:
5280 5282 del repo._subtoppath
5281 5283
5282 5284 @command('parents',
5283 5285 [('r', 'rev', '', _('show parents of the specified revision'), _('REV')),
5284 5286 ] + templateopts,
5285 5287 _('[-r REV] [FILE]'),
5286 5288 inferrepo=True)
5287 5289 def parents(ui, repo, file_=None, **opts):
5288 5290 """show the parents of the working directory or revision (DEPRECATED)
5289 5291
5290 5292 Print the working directory's parent revisions. If a revision is
5291 5293 given via -r/--rev, the parent of that revision will be printed.
5292 5294 If a file argument is given, the revision in which the file was
5293 5295 last changed (before the working directory revision or the
5294 5296 argument to --rev if given) is printed.
5295 5297
5296 5298 This command is equivalent to::
5297 5299
5298 5300 hg log -r "parents()" or
5299 5301 hg log -r "parents(REV)" or
5300 5302 hg log -r "max(file(FILE))" or
5301 5303 hg log -r "max(::REV and file(FILE))"
5302 5304
5303 5305 See :hg:`summary` and :hg:`help revsets` for related information.
5304 5306
5305 5307 Returns 0 on success.
5306 5308 """
5307 5309
5308 5310 ctx = scmutil.revsingle(repo, opts.get('rev'), None)
5309 5311
5310 5312 if file_:
5311 5313 m = scmutil.match(ctx, (file_,), opts)
5312 5314 if m.anypats() or len(m.files()) != 1:
5313 5315 raise error.Abort(_('can only specify an explicit filename'))
5314 5316 file_ = m.files()[0]
5315 5317 filenodes = []
5316 5318 for cp in ctx.parents():
5317 5319 if not cp:
5318 5320 continue
5319 5321 try:
5320 5322 filenodes.append(cp.filenode(file_))
5321 5323 except error.LookupError:
5322 5324 pass
5323 5325 if not filenodes:
5324 5326 raise error.Abort(_("'%s' not found in manifest!") % file_)
5325 5327 p = []
5326 5328 for fn in filenodes:
5327 5329 fctx = repo.filectx(file_, fileid=fn)
5328 5330 p.append(fctx.node())
5329 5331 else:
5330 5332 p = [cp.node() for cp in ctx.parents()]
5331 5333
5332 5334 displayer = cmdutil.show_changeset(ui, repo, opts)
5333 5335 for n in p:
5334 5336 if n != nullid:
5335 5337 displayer.show(repo[n])
5336 5338 displayer.close()
5337 5339
5338 5340 @command('paths', [], _('[NAME]'), optionalrepo=True)
5339 5341 def paths(ui, repo, search=None):
5340 5342 """show aliases for remote repositories
5341 5343
5342 5344 Show definition of symbolic path name NAME. If no name is given,
5343 5345 show definition of all available names.
5344 5346
5345 5347 Option -q/--quiet suppresses all output when searching for NAME
5346 5348 and shows only the path names when listing all definitions.
5347 5349
5348 5350 Path names are defined in the [paths] section of your
5349 5351 configuration file and in ``/etc/mercurial/hgrc``. If run inside a
5350 5352 repository, ``.hg/hgrc`` is used, too.
5351 5353
5352 5354 The path names ``default`` and ``default-push`` have a special
5353 5355 meaning. When performing a push or pull operation, they are used
5354 5356 as fallbacks if no location is specified on the command-line.
5355 5357 When ``default-push`` is set, it will be used for push and
5356 5358 ``default`` will be used for pull; otherwise ``default`` is used
5357 5359 as the fallback for both. When cloning a repository, the clone
5358 5360 source is written as ``default`` in ``.hg/hgrc``. Note that
5359 5361 ``default`` and ``default-push`` apply to all inbound (e.g.
5360 5362 :hg:`incoming`) and outbound (e.g. :hg:`outgoing`, :hg:`email` and
5361 5363 :hg:`bundle`) operations.
5362 5364
5363 5365 See :hg:`help urls` for more information.
5364 5366
5365 5367 Returns 0 on success.
5366 5368 """
5367 5369 if search:
5368 5370 for name, path in sorted(ui.paths.iteritems()):
5369 5371 if name == search:
5370 5372 ui.status("%s\n" % util.hidepassword(path.rawloc))
5371 5373 return
5372 5374 if not ui.quiet:
5373 5375 ui.warn(_("not found!\n"))
5374 5376 return 1
5375 5377 else:
5376 5378 for name, path in sorted(ui.paths.iteritems()):
5377 5379 if ui.quiet:
5378 5380 ui.write("%s\n" % name)
5379 5381 else:
5380 5382 ui.write("%s = %s\n" % (name,
5381 5383 util.hidepassword(path.rawloc)))
5382 5384 for subopt, value in sorted(path.suboptions.items()):
5383 5385 ui.write('%s:%s = %s\n' % (name, subopt, value))
5384 5386
5385 5387 @command('phase',
5386 5388 [('p', 'public', False, _('set changeset phase to public')),
5387 5389 ('d', 'draft', False, _('set changeset phase to draft')),
5388 5390 ('s', 'secret', False, _('set changeset phase to secret')),
5389 5391 ('f', 'force', False, _('allow to move boundary backward')),
5390 5392 ('r', 'rev', [], _('target revision'), _('REV')),
5391 5393 ],
5392 5394 _('[-p|-d|-s] [-f] [-r] [REV...]'))
5393 5395 def phase(ui, repo, *revs, **opts):
5394 5396 """set or show the current phase name
5395 5397
5396 5398 With no argument, show the phase name of the current revision(s).
5397 5399
5398 5400 With one of -p/--public, -d/--draft or -s/--secret, change the
5399 5401 phase value of the specified revisions.
5400 5402
5401 5403 Unless -f/--force is specified, :hg:`phase` won't move changeset from a
5402 5404 lower phase to an higher phase. Phases are ordered as follows::
5403 5405
5404 5406 public < draft < secret
5405 5407
5406 5408 Returns 0 on success, 1 if some phases could not be changed.
5407 5409
5408 5410 (For more information about the phases concept, see :hg:`help phases`.)
5409 5411 """
5410 5412 # search for a unique phase argument
5411 5413 targetphase = None
5412 5414 for idx, name in enumerate(phases.phasenames):
5413 5415 if opts[name]:
5414 5416 if targetphase is not None:
5415 5417 raise error.Abort(_('only one phase can be specified'))
5416 5418 targetphase = idx
5417 5419
5418 5420 # look for specified revision
5419 5421 revs = list(revs)
5420 5422 revs.extend(opts['rev'])
5421 5423 if not revs:
5422 5424 # display both parents as the second parent phase can influence
5423 5425 # the phase of a merge commit
5424 5426 revs = [c.rev() for c in repo[None].parents()]
5425 5427
5426 5428 revs = scmutil.revrange(repo, revs)
5427 5429
5428 5430 lock = None
5429 5431 ret = 0
5430 5432 if targetphase is None:
5431 5433 # display
5432 5434 for r in revs:
5433 5435 ctx = repo[r]
5434 5436 ui.write('%i: %s\n' % (ctx.rev(), ctx.phasestr()))
5435 5437 else:
5436 5438 tr = None
5437 5439 lock = repo.lock()
5438 5440 try:
5439 5441 tr = repo.transaction("phase")
5440 5442 # set phase
5441 5443 if not revs:
5442 5444 raise error.Abort(_('empty revision set'))
5443 5445 nodes = [repo[r].node() for r in revs]
5444 5446 # moving revision from public to draft may hide them
5445 5447 # We have to check result on an unfiltered repository
5446 5448 unfi = repo.unfiltered()
5447 5449 getphase = unfi._phasecache.phase
5448 5450 olddata = [getphase(unfi, r) for r in unfi]
5449 5451 phases.advanceboundary(repo, tr, targetphase, nodes)
5450 5452 if opts['force']:
5451 5453 phases.retractboundary(repo, tr, targetphase, nodes)
5452 5454 tr.close()
5453 5455 finally:
5454 5456 if tr is not None:
5455 5457 tr.release()
5456 5458 lock.release()
5457 5459 getphase = unfi._phasecache.phase
5458 5460 newdata = [getphase(unfi, r) for r in unfi]
5459 5461 changes = sum(newdata[r] != olddata[r] for r in unfi)
5460 5462 cl = unfi.changelog
5461 5463 rejected = [n for n in nodes
5462 5464 if newdata[cl.rev(n)] < targetphase]
5463 5465 if rejected:
5464 5466 ui.warn(_('cannot move %i changesets to a higher '
5465 5467 'phase, use --force\n') % len(rejected))
5466 5468 ret = 1
5467 5469 if changes:
5468 5470 msg = _('phase changed for %i changesets\n') % changes
5469 5471 if ret:
5470 5472 ui.status(msg)
5471 5473 else:
5472 5474 ui.note(msg)
5473 5475 else:
5474 5476 ui.warn(_('no phases changed\n'))
5475 5477 return ret
5476 5478
5477 5479 def postincoming(ui, repo, modheads, optupdate, checkout):
5478 5480 if modheads == 0:
5479 5481 return
5480 5482 if optupdate:
5481 5483 try:
5482 5484 brev = checkout
5483 5485 movemarkfrom = None
5484 5486 if not checkout:
5485 5487 updata = destutil.destupdate(repo)
5486 5488 checkout, movemarkfrom, brev = updata
5487 5489 ret = hg.update(repo, checkout)
5488 5490 except error.UpdateAbort as inst:
5489 5491 msg = _("not updating: %s") % str(inst)
5490 5492 hint = inst.hint
5491 5493 raise error.UpdateAbort(msg, hint=hint)
5492 5494 if not ret and not checkout:
5493 5495 if bookmarks.update(repo, [movemarkfrom], repo['.'].node()):
5494 5496 ui.status(_("updating bookmark %s\n") % repo._activebookmark)
5495 5497 return ret
5496 5498 if modheads > 1:
5497 5499 currentbranchheads = len(repo.branchheads())
5498 5500 if currentbranchheads == modheads:
5499 5501 ui.status(_("(run 'hg heads' to see heads, 'hg merge' to merge)\n"))
5500 5502 elif currentbranchheads > 1:
5501 5503 ui.status(_("(run 'hg heads .' to see heads, 'hg merge' to "
5502 5504 "merge)\n"))
5503 5505 else:
5504 5506 ui.status(_("(run 'hg heads' to see heads)\n"))
5505 5507 else:
5506 5508 ui.status(_("(run 'hg update' to get a working copy)\n"))
5507 5509
5508 5510 @command('^pull',
5509 5511 [('u', 'update', None,
5510 5512 _('update to new branch head if changesets were pulled')),
5511 5513 ('f', 'force', None, _('run even when remote repository is unrelated')),
5512 5514 ('r', 'rev', [], _('a remote changeset intended to be added'), _('REV')),
5513 5515 ('B', 'bookmark', [], _("bookmark to pull"), _('BOOKMARK')),
5514 5516 ('b', 'branch', [], _('a specific branch you would like to pull'),
5515 5517 _('BRANCH')),
5516 5518 ] + remoteopts,
5517 5519 _('[-u] [-f] [-r REV]... [-e CMD] [--remotecmd CMD] [SOURCE]'))
5518 5520 def pull(ui, repo, source="default", **opts):
5519 5521 """pull changes from the specified source
5520 5522
5521 5523 Pull changes from a remote repository to a local one.
5522 5524
5523 5525 This finds all changes from the repository at the specified path
5524 5526 or URL and adds them to a local repository (the current one unless
5525 5527 -R is specified). By default, this does not update the copy of the
5526 5528 project in the working directory.
5527 5529
5528 5530 Use :hg:`incoming` if you want to see what would have been added
5529 5531 by a pull at the time you issued this command. If you then decide
5530 5532 to add those changes to the repository, you should use :hg:`pull
5531 5533 -r X` where ``X`` is the last changeset listed by :hg:`incoming`.
5532 5534
5533 5535 If SOURCE is omitted, the 'default' path will be used.
5534 5536 See :hg:`help urls` for more information.
5535 5537
5536 5538 Returns 0 on success, 1 if an update had unresolved files.
5537 5539 """
5538 5540 source, branches = hg.parseurl(ui.expandpath(source), opts.get('branch'))
5539 5541 ui.status(_('pulling from %s\n') % util.hidepassword(source))
5540 5542 other = hg.peer(repo, opts, source)
5541 5543 try:
5542 5544 revs, checkout = hg.addbranchrevs(repo, other, branches,
5543 5545 opts.get('rev'))
5544 5546
5545 5547
5546 5548 pullopargs = {}
5547 5549 if opts.get('bookmark'):
5548 5550 if not revs:
5549 5551 revs = []
5550 5552 # The list of bookmark used here is not the one used to actually
5551 5553 # update the bookmark name. This can result in the revision pulled
5552 5554 # not ending up with the name of the bookmark because of a race
5553 5555 # condition on the server. (See issue 4689 for details)
5554 5556 remotebookmarks = other.listkeys('bookmarks')
5555 5557 pullopargs['remotebookmarks'] = remotebookmarks
5556 5558 for b in opts['bookmark']:
5557 5559 if b not in remotebookmarks:
5558 5560 raise error.Abort(_('remote bookmark %s not found!') % b)
5559 5561 revs.append(remotebookmarks[b])
5560 5562
5561 5563 if revs:
5562 5564 try:
5563 5565 # When 'rev' is a bookmark name, we cannot guarantee that it
5564 5566 # will be updated with that name because of a race condition
5565 5567 # server side. (See issue 4689 for details)
5566 5568 oldrevs = revs
5567 5569 revs = [] # actually, nodes
5568 5570 for r in oldrevs:
5569 5571 node = other.lookup(r)
5570 5572 revs.append(node)
5571 5573 if r == checkout:
5572 5574 checkout = node
5573 5575 except error.CapabilityError:
5574 5576 err = _("other repository doesn't support revision lookup, "
5575 5577 "so a rev cannot be specified.")
5576 5578 raise error.Abort(err)
5577 5579
5578 5580 pullopargs.update(opts.get('opargs', {}))
5579 5581 modheads = exchange.pull(repo, other, heads=revs,
5580 5582 force=opts.get('force'),
5581 5583 bookmarks=opts.get('bookmark', ()),
5582 5584 opargs=pullopargs).cgresult
5583 5585 if checkout:
5584 5586 checkout = str(repo.changelog.rev(checkout))
5585 5587 repo._subtoppath = source
5586 5588 try:
5587 5589 ret = postincoming(ui, repo, modheads, opts.get('update'), checkout)
5588 5590
5589 5591 finally:
5590 5592 del repo._subtoppath
5591 5593
5592 5594 finally:
5593 5595 other.close()
5594 5596 return ret
5595 5597
5596 5598 @command('^push',
5597 5599 [('f', 'force', None, _('force push')),
5598 5600 ('r', 'rev', [],
5599 5601 _('a changeset intended to be included in the destination'),
5600 5602 _('REV')),
5601 5603 ('B', 'bookmark', [], _("bookmark to push"), _('BOOKMARK')),
5602 5604 ('b', 'branch', [],
5603 5605 _('a specific branch you would like to push'), _('BRANCH')),
5604 5606 ('', 'new-branch', False, _('allow pushing a new branch')),
5605 5607 ] + remoteopts,
5606 5608 _('[-f] [-r REV]... [-e CMD] [--remotecmd CMD] [DEST]'))
5607 5609 def push(ui, repo, dest=None, **opts):
5608 5610 """push changes to the specified destination
5609 5611
5610 5612 Push changesets from the local repository to the specified
5611 5613 destination.
5612 5614
5613 5615 This operation is symmetrical to pull: it is identical to a pull
5614 5616 in the destination repository from the current one.
5615 5617
5616 5618 By default, push will not allow creation of new heads at the
5617 5619 destination, since multiple heads would make it unclear which head
5618 5620 to use. In this situation, it is recommended to pull and merge
5619 5621 before pushing.
5620 5622
5621 5623 Use --new-branch if you want to allow push to create a new named
5622 5624 branch that is not present at the destination. This allows you to
5623 5625 only create a new branch without forcing other changes.
5624 5626
5625 5627 .. note::
5626 5628
5627 5629 Extra care should be taken with the -f/--force option,
5628 5630 which will push all new heads on all branches, an action which will
5629 5631 almost always cause confusion for collaborators.
5630 5632
5631 5633 If -r/--rev is used, the specified revision and all its ancestors
5632 5634 will be pushed to the remote repository.
5633 5635
5634 5636 If -B/--bookmark is used, the specified bookmarked revision, its
5635 5637 ancestors, and the bookmark will be pushed to the remote
5636 5638 repository.
5637 5639
5638 5640 Please see :hg:`help urls` for important details about ``ssh://``
5639 5641 URLs. If DESTINATION is omitted, a default path will be used.
5640 5642
5641 5643 Returns 0 if push was successful, 1 if nothing to push.
5642 5644 """
5643 5645
5644 5646 if opts.get('bookmark'):
5645 5647 ui.setconfig('bookmarks', 'pushing', opts['bookmark'], 'push')
5646 5648 for b in opts['bookmark']:
5647 5649 # translate -B options to -r so changesets get pushed
5648 5650 if b in repo._bookmarks:
5649 5651 opts.setdefault('rev', []).append(b)
5650 5652 else:
5651 5653 # if we try to push a deleted bookmark, translate it to null
5652 5654 # this lets simultaneous -r, -b options continue working
5653 5655 opts.setdefault('rev', []).append("null")
5654 5656
5655 5657 path = ui.paths.getpath(dest, default='default')
5656 5658 if not path:
5657 5659 raise error.Abort(_('default repository not configured!'),
5658 5660 hint=_('see the "path" section in "hg help config"'))
5659 5661 dest = path.pushloc or path.loc
5660 5662 branches = (path.branch, opts.get('branch') or [])
5661 5663 ui.status(_('pushing to %s\n') % util.hidepassword(dest))
5662 5664 revs, checkout = hg.addbranchrevs(repo, repo, branches, opts.get('rev'))
5663 5665 other = hg.peer(repo, opts, dest)
5664 5666
5665 5667 if revs:
5666 5668 revs = [repo.lookup(r) for r in scmutil.revrange(repo, revs)]
5667 5669 if not revs:
5668 5670 raise error.Abort(_("specified revisions evaluate to an empty set"),
5669 5671 hint=_("use different revision arguments"))
5670 5672
5671 5673 repo._subtoppath = dest
5672 5674 try:
5673 5675 # push subrepos depth-first for coherent ordering
5674 5676 c = repo['']
5675 5677 subs = c.substate # only repos that are committed
5676 5678 for s in sorted(subs):
5677 5679 result = c.sub(s).push(opts)
5678 5680 if result == 0:
5679 5681 return not result
5680 5682 finally:
5681 5683 del repo._subtoppath
5682 5684 pushop = exchange.push(repo, other, opts.get('force'), revs=revs,
5683 5685 newbranch=opts.get('new_branch'),
5684 5686 bookmarks=opts.get('bookmark', ()),
5685 5687 opargs=opts.get('opargs'))
5686 5688
5687 5689 result = not pushop.cgresult
5688 5690
5689 5691 if pushop.bkresult is not None:
5690 5692 if pushop.bkresult == 2:
5691 5693 result = 2
5692 5694 elif not result and pushop.bkresult:
5693 5695 result = 2
5694 5696
5695 5697 return result
5696 5698
5697 5699 @command('recover', [])
5698 5700 def recover(ui, repo):
5699 5701 """roll back an interrupted transaction
5700 5702
5701 5703 Recover from an interrupted commit or pull.
5702 5704
5703 5705 This command tries to fix the repository status after an
5704 5706 interrupted operation. It should only be necessary when Mercurial
5705 5707 suggests it.
5706 5708
5707 5709 Returns 0 if successful, 1 if nothing to recover or verify fails.
5708 5710 """
5709 5711 if repo.recover():
5710 5712 return hg.verify(repo)
5711 5713 return 1
5712 5714
5713 5715 @command('^remove|rm',
5714 5716 [('A', 'after', None, _('record delete for missing files')),
5715 5717 ('f', 'force', None,
5716 5718 _('remove (and delete) file even if added or modified')),
5717 5719 ] + subrepoopts + walkopts,
5718 5720 _('[OPTION]... FILE...'),
5719 5721 inferrepo=True)
5720 5722 def remove(ui, repo, *pats, **opts):
5721 5723 """remove the specified files on the next commit
5722 5724
5723 5725 Schedule the indicated files for removal from the current branch.
5724 5726
5725 5727 This command schedules the files to be removed at the next commit.
5726 5728 To undo a remove before that, see :hg:`revert`. To undo added
5727 5729 files, see :hg:`forget`.
5728 5730
5729 5731 .. container:: verbose
5730 5732
5731 5733 -A/--after can be used to remove only files that have already
5732 5734 been deleted, -f/--force can be used to force deletion, and -Af
5733 5735 can be used to remove files from the next revision without
5734 5736 deleting them from the working directory.
5735 5737
5736 5738 The following table details the behavior of remove for different
5737 5739 file states (columns) and option combinations (rows). The file
5738 5740 states are Added [A], Clean [C], Modified [M] and Missing [!]
5739 5741 (as reported by :hg:`status`). The actions are Warn, Remove
5740 5742 (from branch) and Delete (from disk):
5741 5743
5742 5744 ========= == == == ==
5743 5745 opt/state A C M !
5744 5746 ========= == == == ==
5745 5747 none W RD W R
5746 5748 -f R RD RD R
5747 5749 -A W W W R
5748 5750 -Af R R R R
5749 5751 ========= == == == ==
5750 5752
5751 5753 Note that remove never deletes files in Added [A] state from the
5752 5754 working directory, not even if option --force is specified.
5753 5755
5754 5756 Returns 0 on success, 1 if any warnings encountered.
5755 5757 """
5756 5758
5757 5759 after, force = opts.get('after'), opts.get('force')
5758 5760 if not pats and not after:
5759 5761 raise error.Abort(_('no files specified'))
5760 5762
5761 5763 m = scmutil.match(repo[None], pats, opts)
5762 5764 subrepos = opts.get('subrepos')
5763 5765 return cmdutil.remove(ui, repo, m, "", after, force, subrepos)
5764 5766
5765 5767 @command('rename|move|mv',
5766 5768 [('A', 'after', None, _('record a rename that has already occurred')),
5767 5769 ('f', 'force', None, _('forcibly copy over an existing managed file')),
5768 5770 ] + walkopts + dryrunopts,
5769 5771 _('[OPTION]... SOURCE... DEST'))
5770 5772 def rename(ui, repo, *pats, **opts):
5771 5773 """rename files; equivalent of copy + remove
5772 5774
5773 5775 Mark dest as copies of sources; mark sources for deletion. If dest
5774 5776 is a directory, copies are put in that directory. If dest is a
5775 5777 file, there can only be one source.
5776 5778
5777 5779 By default, this command copies the contents of files as they
5778 5780 exist in the working directory. If invoked with -A/--after, the
5779 5781 operation is recorded, but no copying is performed.
5780 5782
5781 5783 This command takes effect at the next commit. To undo a rename
5782 5784 before that, see :hg:`revert`.
5783 5785
5784 5786 Returns 0 on success, 1 if errors are encountered.
5785 5787 """
5786 5788 wlock = repo.wlock(False)
5787 5789 try:
5788 5790 return cmdutil.copy(ui, repo, pats, opts, rename=True)
5789 5791 finally:
5790 5792 wlock.release()
5791 5793
5792 5794 @command('resolve',
5793 5795 [('a', 'all', None, _('select all unresolved files')),
5794 5796 ('l', 'list', None, _('list state of files needing merge')),
5795 5797 ('m', 'mark', None, _('mark files as resolved')),
5796 5798 ('u', 'unmark', None, _('mark files as unresolved')),
5797 5799 ('n', 'no-status', None, _('hide status prefix'))]
5798 5800 + mergetoolopts + walkopts + formatteropts,
5799 5801 _('[OPTION]... [FILE]...'),
5800 5802 inferrepo=True)
5801 5803 def resolve(ui, repo, *pats, **opts):
5802 5804 """redo merges or set/view the merge status of files
5803 5805
5804 5806 Merges with unresolved conflicts are often the result of
5805 5807 non-interactive merging using the ``internal:merge`` configuration
5806 5808 setting, or a command-line merge tool like ``diff3``. The resolve
5807 5809 command is used to manage the files involved in a merge, after
5808 5810 :hg:`merge` has been run, and before :hg:`commit` is run (i.e. the
5809 5811 working directory must have two parents). See :hg:`help
5810 5812 merge-tools` for information on configuring merge tools.
5811 5813
5812 5814 The resolve command can be used in the following ways:
5813 5815
5814 5816 - :hg:`resolve [--tool TOOL] FILE...`: attempt to re-merge the specified
5815 5817 files, discarding any previous merge attempts. Re-merging is not
5816 5818 performed for files already marked as resolved. Use ``--all/-a``
5817 5819 to select all unresolved files. ``--tool`` can be used to specify
5818 5820 the merge tool used for the given files. It overrides the HGMERGE
5819 5821 environment variable and your configuration files. Previous file
5820 5822 contents are saved with a ``.orig`` suffix.
5821 5823
5822 5824 - :hg:`resolve -m [FILE]`: mark a file as having been resolved
5823 5825 (e.g. after having manually fixed-up the files). The default is
5824 5826 to mark all unresolved files.
5825 5827
5826 5828 - :hg:`resolve -u [FILE]...`: mark a file as unresolved. The
5827 5829 default is to mark all resolved files.
5828 5830
5829 5831 - :hg:`resolve -l`: list files which had or still have conflicts.
5830 5832 In the printed list, ``U`` = unresolved and ``R`` = resolved.
5831 5833
5832 5834 Note that Mercurial will not let you commit files with unresolved
5833 5835 merge conflicts. You must use :hg:`resolve -m ...` before you can
5834 5836 commit after a conflicting merge.
5835 5837
5836 5838 Returns 0 on success, 1 if any files fail a resolve attempt.
5837 5839 """
5838 5840
5839 5841 all, mark, unmark, show, nostatus = \
5840 5842 [opts.get(o) for o in 'all mark unmark list no_status'.split()]
5841 5843
5842 5844 if (show and (mark or unmark)) or (mark and unmark):
5843 5845 raise error.Abort(_("too many options specified"))
5844 5846 if pats and all:
5845 5847 raise error.Abort(_("can't specify --all and patterns"))
5846 5848 if not (all or pats or show or mark or unmark):
5847 5849 raise error.Abort(_('no files or directories specified'),
5848 5850 hint=('use --all to re-merge all unresolved files'))
5849 5851
5850 5852 if show:
5851 5853 fm = ui.formatter('resolve', opts)
5852 5854 ms = mergemod.mergestate.read(repo)
5853 5855 m = scmutil.match(repo[None], pats, opts)
5854 5856 for f in ms:
5855 5857 if not m(f):
5856 5858 continue
5857 5859 l = 'resolve.' + {'u': 'unresolved', 'r': 'resolved',
5858 5860 'd': 'driverresolved'}[ms[f]]
5859 5861 fm.startitem()
5860 5862 fm.condwrite(not nostatus, 'status', '%s ', ms[f].upper(), label=l)
5861 5863 fm.write('path', '%s\n', f, label=l)
5862 5864 fm.end()
5863 5865 return 0
5864 5866
5865 5867 wlock = repo.wlock()
5866 5868 try:
5867 5869 ms = mergemod.mergestate.read(repo)
5868 5870
5869 5871 if not (ms.active() or repo.dirstate.p2() != nullid):
5870 5872 raise error.Abort(
5871 5873 _('resolve command not applicable when not merging'))
5872 5874
5873 5875 wctx = repo[None]
5874 5876
5875 5877 if ms.mergedriver and ms.mdstate() == 'u':
5876 5878 proceed = mergemod.driverpreprocess(repo, ms, wctx)
5877 5879 ms.commit()
5878 5880 # allow mark and unmark to go through
5879 5881 if not mark and not unmark and not proceed:
5880 5882 return 1
5881 5883
5882 5884 m = scmutil.match(wctx, pats, opts)
5883 5885 ret = 0
5884 5886 didwork = False
5885 5887 runconclude = False
5886 5888
5887 5889 tocomplete = []
5888 5890 for f in ms:
5889 5891 if not m(f):
5890 5892 continue
5891 5893
5892 5894 didwork = True
5893 5895
5894 5896 # don't let driver-resolved files be marked, and run the conclude
5895 5897 # step if asked to resolve
5896 5898 if ms[f] == "d":
5897 5899 exact = m.exact(f)
5898 5900 if mark:
5899 5901 if exact:
5900 5902 ui.warn(_('not marking %s as it is driver-resolved\n')
5901 5903 % f)
5902 5904 elif unmark:
5903 5905 if exact:
5904 5906 ui.warn(_('not unmarking %s as it is driver-resolved\n')
5905 5907 % f)
5906 5908 else:
5907 5909 runconclude = True
5908 5910 continue
5909 5911
5910 5912 if mark:
5911 5913 ms.mark(f, "r")
5912 5914 elif unmark:
5913 5915 ms.mark(f, "u")
5914 5916 else:
5915 5917 # backup pre-resolve (merge uses .orig for its own purposes)
5916 5918 a = repo.wjoin(f)
5917 5919 try:
5918 5920 util.copyfile(a, a + ".resolve")
5919 5921 except (IOError, OSError) as inst:
5920 5922 if inst.errno != errno.ENOENT:
5921 5923 raise
5922 5924
5923 5925 try:
5924 5926 # preresolve file
5925 5927 ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
5926 5928 'resolve')
5927 5929 complete, r = ms.preresolve(f, wctx)
5928 5930 if not complete:
5929 5931 tocomplete.append(f)
5930 5932 elif r:
5931 5933 ret = 1
5932 5934 finally:
5933 5935 ui.setconfig('ui', 'forcemerge', '', 'resolve')
5934 5936 ms.commit()
5935 5937
5936 5938 # replace filemerge's .orig file with our resolve file, but only
5937 5939 # for merges that are complete
5938 5940 if complete:
5939 5941 try:
5940 5942 util.rename(a + ".resolve",
5941 5943 cmdutil.origpath(ui, repo, a))
5942 5944 except OSError as inst:
5943 5945 if inst.errno != errno.ENOENT:
5944 5946 raise
5945 5947
5946 5948 for f in tocomplete:
5947 5949 try:
5948 5950 # resolve file
5949 5951 ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
5950 5952 'resolve')
5951 5953 r = ms.resolve(f, wctx)
5952 5954 if r:
5953 5955 ret = 1
5954 5956 finally:
5955 5957 ui.setconfig('ui', 'forcemerge', '', 'resolve')
5956 5958 ms.commit()
5957 5959
5958 5960 # replace filemerge's .orig file with our resolve file
5959 5961 a = repo.wjoin(f)
5960 5962 try:
5961 5963 util.rename(a + ".resolve", cmdutil.origpath(ui, repo, a))
5962 5964 except OSError as inst:
5963 5965 if inst.errno != errno.ENOENT:
5964 5966 raise
5965 5967
5966 5968 ms.commit()
5967 5969 ms.recordactions()
5968 5970
5969 5971 if not didwork and pats:
5970 5972 ui.warn(_("arguments do not match paths that need resolving\n"))
5971 5973 elif ms.mergedriver and ms.mdstate() != 's':
5972 5974 # run conclude step when either a driver-resolved file is requested
5973 5975 # or there are no driver-resolved files
5974 5976 # we can't use 'ret' to determine whether any files are unresolved
5975 5977 # because we might not have tried to resolve some
5976 5978 if ((runconclude or not list(ms.driverresolved()))
5977 5979 and not list(ms.unresolved())):
5978 5980 proceed = mergemod.driverconclude(repo, ms, wctx)
5979 5981 ms.commit()
5980 5982 if not proceed:
5981 5983 return 1
5982 5984
5983 5985 finally:
5984 5986 wlock.release()
5985 5987
5986 5988 # Nudge users into finishing an unfinished operation
5987 5989 unresolvedf = list(ms.unresolved())
5988 5990 driverresolvedf = list(ms.driverresolved())
5989 5991 if not unresolvedf and not driverresolvedf:
5990 5992 ui.status(_('(no more unresolved files)\n'))
5991 5993 elif not unresolvedf:
5992 5994 ui.status(_('(no more unresolved files -- '
5993 5995 'run "hg resolve --all" to conclude)\n'))
5994 5996
5995 5997 return ret
5996 5998
5997 5999 @command('revert',
5998 6000 [('a', 'all', None, _('revert all changes when no arguments given')),
5999 6001 ('d', 'date', '', _('tipmost revision matching date'), _('DATE')),
6000 6002 ('r', 'rev', '', _('revert to the specified revision'), _('REV')),
6001 6003 ('C', 'no-backup', None, _('do not save backup copies of files')),
6002 6004 ('i', 'interactive', None,
6003 6005 _('interactively select the changes (EXPERIMENTAL)')),
6004 6006 ] + walkopts + dryrunopts,
6005 6007 _('[OPTION]... [-r REV] [NAME]...'))
6006 6008 def revert(ui, repo, *pats, **opts):
6007 6009 """restore files to their checkout state
6008 6010
6009 6011 .. note::
6010 6012
6011 6013 To check out earlier revisions, you should use :hg:`update REV`.
6012 6014 To cancel an uncommitted merge (and lose your changes),
6013 6015 use :hg:`update --clean .`.
6014 6016
6015 6017 With no revision specified, revert the specified files or directories
6016 6018 to the contents they had in the parent of the working directory.
6017 6019 This restores the contents of files to an unmodified
6018 6020 state and unschedules adds, removes, copies, and renames. If the
6019 6021 working directory has two parents, you must explicitly specify a
6020 6022 revision.
6021 6023
6022 6024 Using the -r/--rev or -d/--date options, revert the given files or
6023 6025 directories to their states as of a specific revision. Because
6024 6026 revert does not change the working directory parents, this will
6025 6027 cause these files to appear modified. This can be helpful to "back
6026 6028 out" some or all of an earlier change. See :hg:`backout` for a
6027 6029 related method.
6028 6030
6029 6031 Modified files are saved with a .orig suffix before reverting.
6030 6032 To disable these backups, use --no-backup.
6031 6033
6032 6034 See :hg:`help dates` for a list of formats valid for -d/--date.
6033 6035
6034 6036 See :hg:`help backout` for a way to reverse the effect of an
6035 6037 earlier changeset.
6036 6038
6037 6039 Returns 0 on success.
6038 6040 """
6039 6041
6040 6042 if opts.get("date"):
6041 6043 if opts.get("rev"):
6042 6044 raise error.Abort(_("you can't specify a revision and a date"))
6043 6045 opts["rev"] = cmdutil.finddate(ui, repo, opts["date"])
6044 6046
6045 6047 parent, p2 = repo.dirstate.parents()
6046 6048 if not opts.get('rev') and p2 != nullid:
6047 6049 # revert after merge is a trap for new users (issue2915)
6048 6050 raise error.Abort(_('uncommitted merge with no revision specified'),
6049 6051 hint=_('use "hg update" or see "hg help revert"'))
6050 6052
6051 6053 ctx = scmutil.revsingle(repo, opts.get('rev'))
6052 6054
6053 6055 if (not (pats or opts.get('include') or opts.get('exclude') or
6054 6056 opts.get('all') or opts.get('interactive'))):
6055 6057 msg = _("no files or directories specified")
6056 6058 if p2 != nullid:
6057 6059 hint = _("uncommitted merge, use --all to discard all changes,"
6058 6060 " or 'hg update -C .' to abort the merge")
6059 6061 raise error.Abort(msg, hint=hint)
6060 6062 dirty = any(repo.status())
6061 6063 node = ctx.node()
6062 6064 if node != parent:
6063 6065 if dirty:
6064 6066 hint = _("uncommitted changes, use --all to discard all"
6065 6067 " changes, or 'hg update %s' to update") % ctx.rev()
6066 6068 else:
6067 6069 hint = _("use --all to revert all files,"
6068 6070 " or 'hg update %s' to update") % ctx.rev()
6069 6071 elif dirty:
6070 6072 hint = _("uncommitted changes, use --all to discard all changes")
6071 6073 else:
6072 6074 hint = _("use --all to revert all files")
6073 6075 raise error.Abort(msg, hint=hint)
6074 6076
6075 6077 return cmdutil.revert(ui, repo, ctx, (parent, p2), *pats, **opts)
6076 6078
6077 6079 @command('rollback', dryrunopts +
6078 6080 [('f', 'force', False, _('ignore safety measures'))])
6079 6081 def rollback(ui, repo, **opts):
6080 6082 """roll back the last transaction (DANGEROUS) (DEPRECATED)
6081 6083
6082 6084 Please use :hg:`commit --amend` instead of rollback to correct
6083 6085 mistakes in the last commit.
6084 6086
6085 6087 This command should be used with care. There is only one level of
6086 6088 rollback, and there is no way to undo a rollback. It will also
6087 6089 restore the dirstate at the time of the last transaction, losing
6088 6090 any dirstate changes since that time. This command does not alter
6089 6091 the working directory.
6090 6092
6091 6093 Transactions are used to encapsulate the effects of all commands
6092 6094 that create new changesets or propagate existing changesets into a
6093 6095 repository.
6094 6096
6095 6097 .. container:: verbose
6096 6098
6097 6099 For example, the following commands are transactional, and their
6098 6100 effects can be rolled back:
6099 6101
6100 6102 - commit
6101 6103 - import
6102 6104 - pull
6103 6105 - push (with this repository as the destination)
6104 6106 - unbundle
6105 6107
6106 6108 To avoid permanent data loss, rollback will refuse to rollback a
6107 6109 commit transaction if it isn't checked out. Use --force to
6108 6110 override this protection.
6109 6111
6110 6112 This command is not intended for use on public repositories. Once
6111 6113 changes are visible for pull by other users, rolling a transaction
6112 6114 back locally is ineffective (someone else may already have pulled
6113 6115 the changes). Furthermore, a race is possible with readers of the
6114 6116 repository; for example an in-progress pull from the repository
6115 6117 may fail if a rollback is performed.
6116 6118
6117 6119 Returns 0 on success, 1 if no rollback data is available.
6118 6120 """
6119 6121 return repo.rollback(dryrun=opts.get('dry_run'),
6120 6122 force=opts.get('force'))
6121 6123
6122 6124 @command('root', [])
6123 6125 def root(ui, repo):
6124 6126 """print the root (top) of the current working directory
6125 6127
6126 6128 Print the root directory of the current repository.
6127 6129
6128 6130 Returns 0 on success.
6129 6131 """
6130 6132 ui.write(repo.root + "\n")
6131 6133
6132 6134 @command('^serve',
6133 6135 [('A', 'accesslog', '', _('name of access log file to write to'),
6134 6136 _('FILE')),
6135 6137 ('d', 'daemon', None, _('run server in background')),
6136 6138 ('', 'daemon-pipefds', '', _('used internally by daemon mode'), _('FILE')),
6137 6139 ('E', 'errorlog', '', _('name of error log file to write to'), _('FILE')),
6138 6140 # use string type, then we can check if something was passed
6139 6141 ('p', 'port', '', _('port to listen on (default: 8000)'), _('PORT')),
6140 6142 ('a', 'address', '', _('address to listen on (default: all interfaces)'),
6141 6143 _('ADDR')),
6142 6144 ('', 'prefix', '', _('prefix path to serve from (default: server root)'),
6143 6145 _('PREFIX')),
6144 6146 ('n', 'name', '',
6145 6147 _('name to show in web pages (default: working directory)'), _('NAME')),
6146 6148 ('', 'web-conf', '',
6147 6149 _('name of the hgweb config file (see "hg help hgweb")'), _('FILE')),
6148 6150 ('', 'webdir-conf', '', _('name of the hgweb config file (DEPRECATED)'),
6149 6151 _('FILE')),
6150 6152 ('', 'pid-file', '', _('name of file to write process ID to'), _('FILE')),
6151 6153 ('', 'stdio', None, _('for remote clients')),
6152 6154 ('', 'cmdserver', '', _('for remote clients'), _('MODE')),
6153 6155 ('t', 'templates', '', _('web templates to use'), _('TEMPLATE')),
6154 6156 ('', 'style', '', _('template style to use'), _('STYLE')),
6155 6157 ('6', 'ipv6', None, _('use IPv6 in addition to IPv4')),
6156 6158 ('', 'certificate', '', _('SSL certificate file'), _('FILE'))],
6157 6159 _('[OPTION]...'),
6158 6160 optionalrepo=True)
6159 6161 def serve(ui, repo, **opts):
6160 6162 """start stand-alone webserver
6161 6163
6162 6164 Start a local HTTP repository browser and pull server. You can use
6163 6165 this for ad-hoc sharing and browsing of repositories. It is
6164 6166 recommended to use a real web server to serve a repository for
6165 6167 longer periods of time.
6166 6168
6167 6169 Please note that the server does not implement access control.
6168 6170 This means that, by default, anybody can read from the server and
6169 6171 nobody can write to it by default. Set the ``web.allow_push``
6170 6172 option to ``*`` to allow everybody to push to the server. You
6171 6173 should use a real web server if you need to authenticate users.
6172 6174
6173 6175 By default, the server logs accesses to stdout and errors to
6174 6176 stderr. Use the -A/--accesslog and -E/--errorlog options to log to
6175 6177 files.
6176 6178
6177 6179 To have the server choose a free port number to listen on, specify
6178 6180 a port number of 0; in this case, the server will print the port
6179 6181 number it uses.
6180 6182
6181 6183 Returns 0 on success.
6182 6184 """
6183 6185
6184 6186 if opts["stdio"] and opts["cmdserver"]:
6185 6187 raise error.Abort(_("cannot use --stdio with --cmdserver"))
6186 6188
6187 6189 if opts["stdio"]:
6188 6190 if repo is None:
6189 6191 raise error.RepoError(_("there is no Mercurial repository here"
6190 6192 " (.hg not found)"))
6191 6193 s = sshserver.sshserver(ui, repo)
6192 6194 s.serve_forever()
6193 6195
6194 6196 if opts["cmdserver"]:
6195 6197 service = commandserver.createservice(ui, repo, opts)
6196 6198 else:
6197 6199 service = hgweb.createservice(ui, repo, opts)
6198 6200 return cmdutil.service(opts, initfn=service.init, runfn=service.run)
6199 6201
6200 6202 @command('^status|st',
6201 6203 [('A', 'all', None, _('show status of all files')),
6202 6204 ('m', 'modified', None, _('show only modified files')),
6203 6205 ('a', 'added', None, _('show only added files')),
6204 6206 ('r', 'removed', None, _('show only removed files')),
6205 6207 ('d', 'deleted', None, _('show only deleted (but tracked) files')),
6206 6208 ('c', 'clean', None, _('show only files without changes')),
6207 6209 ('u', 'unknown', None, _('show only unknown (not tracked) files')),
6208 6210 ('i', 'ignored', None, _('show only ignored files')),
6209 6211 ('n', 'no-status', None, _('hide status prefix')),
6210 6212 ('C', 'copies', None, _('show source of copied files')),
6211 6213 ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
6212 6214 ('', 'rev', [], _('show difference from revision'), _('REV')),
6213 6215 ('', 'change', '', _('list the changed files of a revision'), _('REV')),
6214 6216 ] + walkopts + subrepoopts + formatteropts,
6215 6217 _('[OPTION]... [FILE]...'),
6216 6218 inferrepo=True)
6217 6219 def status(ui, repo, *pats, **opts):
6218 6220 """show changed files in the working directory
6219 6221
6220 6222 Show status of files in the repository. If names are given, only
6221 6223 files that match are shown. Files that are clean or ignored or
6222 6224 the source of a copy/move operation, are not listed unless
6223 6225 -c/--clean, -i/--ignored, -C/--copies or -A/--all are given.
6224 6226 Unless options described with "show only ..." are given, the
6225 6227 options -mardu are used.
6226 6228
6227 6229 Option -q/--quiet hides untracked (unknown and ignored) files
6228 6230 unless explicitly requested with -u/--unknown or -i/--ignored.
6229 6231
6230 6232 .. note::
6231 6233
6232 6234 status may appear to disagree with diff if permissions have
6233 6235 changed or a merge has occurred. The standard diff format does
6234 6236 not report permission changes and diff only reports changes
6235 6237 relative to one merge parent.
6236 6238
6237 6239 If one revision is given, it is used as the base revision.
6238 6240 If two revisions are given, the differences between them are
6239 6241 shown. The --change option can also be used as a shortcut to list
6240 6242 the changed files of a revision from its first parent.
6241 6243
6242 6244 The codes used to show the status of files are::
6243 6245
6244 6246 M = modified
6245 6247 A = added
6246 6248 R = removed
6247 6249 C = clean
6248 6250 ! = missing (deleted by non-hg command, but still tracked)
6249 6251 ? = not tracked
6250 6252 I = ignored
6251 6253 = origin of the previous file (with --copies)
6252 6254
6253 6255 .. container:: verbose
6254 6256
6255 6257 Examples:
6256 6258
6257 6259 - show changes in the working directory relative to a
6258 6260 changeset::
6259 6261
6260 6262 hg status --rev 9353
6261 6263
6262 6264 - show changes in the working directory relative to the
6263 6265 current directory (see :hg:`help patterns` for more information)::
6264 6266
6265 6267 hg status re:
6266 6268
6267 6269 - show all changes including copies in an existing changeset::
6268 6270
6269 6271 hg status --copies --change 9353
6270 6272
6271 6273 - get a NUL separated list of added files, suitable for xargs::
6272 6274
6273 6275 hg status -an0
6274 6276
6275 6277 Returns 0 on success.
6276 6278 """
6277 6279
6278 6280 revs = opts.get('rev')
6279 6281 change = opts.get('change')
6280 6282
6281 6283 if revs and change:
6282 6284 msg = _('cannot specify --rev and --change at the same time')
6283 6285 raise error.Abort(msg)
6284 6286 elif change:
6285 6287 node2 = scmutil.revsingle(repo, change, None).node()
6286 6288 node1 = repo[node2].p1().node()
6287 6289 else:
6288 6290 node1, node2 = scmutil.revpair(repo, revs)
6289 6291
6290 6292 if pats:
6291 6293 cwd = repo.getcwd()
6292 6294 else:
6293 6295 cwd = ''
6294 6296
6295 6297 if opts.get('print0'):
6296 6298 end = '\0'
6297 6299 else:
6298 6300 end = '\n'
6299 6301 copy = {}
6300 6302 states = 'modified added removed deleted unknown ignored clean'.split()
6301 6303 show = [k for k in states if opts.get(k)]
6302 6304 if opts.get('all'):
6303 6305 show += ui.quiet and (states[:4] + ['clean']) or states
6304 6306 if not show:
6305 6307 if ui.quiet:
6306 6308 show = states[:4]
6307 6309 else:
6308 6310 show = states[:5]
6309 6311
6310 6312 m = scmutil.match(repo[node2], pats, opts)
6311 6313 stat = repo.status(node1, node2, m,
6312 6314 'ignored' in show, 'clean' in show, 'unknown' in show,
6313 6315 opts.get('subrepos'))
6314 6316 changestates = zip(states, 'MAR!?IC', stat)
6315 6317
6316 6318 if (opts.get('all') or opts.get('copies')
6317 6319 or ui.configbool('ui', 'statuscopies')) and not opts.get('no_status'):
6318 6320 copy = copies.pathcopies(repo[node1], repo[node2], m)
6319 6321
6320 6322 fm = ui.formatter('status', opts)
6321 6323 fmt = '%s' + end
6322 6324 showchar = not opts.get('no_status')
6323 6325
6324 6326 for state, char, files in changestates:
6325 6327 if state in show:
6326 6328 label = 'status.' + state
6327 6329 for f in files:
6328 6330 fm.startitem()
6329 6331 fm.condwrite(showchar, 'status', '%s ', char, label=label)
6330 6332 fm.write('path', fmt, repo.pathto(f, cwd), label=label)
6331 6333 if f in copy:
6332 6334 fm.write("copy", ' %s' + end, repo.pathto(copy[f], cwd),
6333 6335 label='status.copied')
6334 6336 fm.end()
6335 6337
6336 6338 @command('^summary|sum',
6337 6339 [('', 'remote', None, _('check for push and pull'))], '[--remote]')
6338 6340 def summary(ui, repo, **opts):
6339 6341 """summarize working directory state
6340 6342
6341 6343 This generates a brief summary of the working directory state,
6342 6344 including parents, branch, commit status, phase and available updates.
6343 6345
6344 6346 With the --remote option, this will check the default paths for
6345 6347 incoming and outgoing changes. This can be time-consuming.
6346 6348
6347 6349 Returns 0 on success.
6348 6350 """
6349 6351
6350 6352 ctx = repo[None]
6351 6353 parents = ctx.parents()
6352 6354 pnode = parents[0].node()
6353 6355 marks = []
6354 6356
6355 6357 for p in parents:
6356 6358 # label with log.changeset (instead of log.parent) since this
6357 6359 # shows a working directory parent *changeset*:
6358 6360 # i18n: column positioning for "hg summary"
6359 6361 ui.write(_('parent: %d:%s ') % (p.rev(), str(p)),
6360 6362 label='log.changeset changeset.%s' % p.phasestr())
6361 6363 ui.write(' '.join(p.tags()), label='log.tag')
6362 6364 if p.bookmarks():
6363 6365 marks.extend(p.bookmarks())
6364 6366 if p.rev() == -1:
6365 6367 if not len(repo):
6366 6368 ui.write(_(' (empty repository)'))
6367 6369 else:
6368 6370 ui.write(_(' (no revision checked out)'))
6369 6371 ui.write('\n')
6370 6372 if p.description():
6371 6373 ui.status(' ' + p.description().splitlines()[0].strip() + '\n',
6372 6374 label='log.summary')
6373 6375
6374 6376 branch = ctx.branch()
6375 6377 bheads = repo.branchheads(branch)
6376 6378 # i18n: column positioning for "hg summary"
6377 6379 m = _('branch: %s\n') % branch
6378 6380 if branch != 'default':
6379 6381 ui.write(m, label='log.branch')
6380 6382 else:
6381 6383 ui.status(m, label='log.branch')
6382 6384
6383 6385 if marks:
6384 6386 active = repo._activebookmark
6385 6387 # i18n: column positioning for "hg summary"
6386 6388 ui.write(_('bookmarks:'), label='log.bookmark')
6387 6389 if active is not None:
6388 6390 if active in marks:
6389 6391 ui.write(' *' + active, label=activebookmarklabel)
6390 6392 marks.remove(active)
6391 6393 else:
6392 6394 ui.write(' [%s]' % active, label=activebookmarklabel)
6393 6395 for m in marks:
6394 6396 ui.write(' ' + m, label='log.bookmark')
6395 6397 ui.write('\n', label='log.bookmark')
6396 6398
6397 6399 status = repo.status(unknown=True)
6398 6400
6399 6401 c = repo.dirstate.copies()
6400 6402 copied, renamed = [], []
6401 6403 for d, s in c.iteritems():
6402 6404 if s in status.removed:
6403 6405 status.removed.remove(s)
6404 6406 renamed.append(d)
6405 6407 else:
6406 6408 copied.append(d)
6407 6409 if d in status.added:
6408 6410 status.added.remove(d)
6409 6411
6410 6412 try:
6411 6413 ms = mergemod.mergestate.read(repo)
6412 6414 except error.UnsupportedMergeRecords as e:
6413 6415 s = ' '.join(e.recordtypes)
6414 6416 ui.warn(
6415 6417 _('warning: merge state has unsupported record types: %s\n') % s)
6416 6418 unresolved = 0
6417 6419 else:
6418 6420 unresolved = [f for f in ms if ms[f] == 'u']
6419 6421
6420 6422 subs = [s for s in ctx.substate if ctx.sub(s).dirty()]
6421 6423
6422 6424 labels = [(ui.label(_('%d modified'), 'status.modified'), status.modified),
6423 6425 (ui.label(_('%d added'), 'status.added'), status.added),
6424 6426 (ui.label(_('%d removed'), 'status.removed'), status.removed),
6425 6427 (ui.label(_('%d renamed'), 'status.copied'), renamed),
6426 6428 (ui.label(_('%d copied'), 'status.copied'), copied),
6427 6429 (ui.label(_('%d deleted'), 'status.deleted'), status.deleted),
6428 6430 (ui.label(_('%d unknown'), 'status.unknown'), status.unknown),
6429 6431 (ui.label(_('%d unresolved'), 'resolve.unresolved'), unresolved),
6430 6432 (ui.label(_('%d subrepos'), 'status.modified'), subs)]
6431 6433 t = []
6432 6434 for l, s in labels:
6433 6435 if s:
6434 6436 t.append(l % len(s))
6435 6437
6436 6438 t = ', '.join(t)
6437 6439 cleanworkdir = False
6438 6440
6439 6441 if repo.vfs.exists('graftstate'):
6440 6442 t += _(' (graft in progress)')
6441 6443 if repo.vfs.exists('updatestate'):
6442 6444 t += _(' (interrupted update)')
6443 6445 elif len(parents) > 1:
6444 6446 t += _(' (merge)')
6445 6447 elif branch != parents[0].branch():
6446 6448 t += _(' (new branch)')
6447 6449 elif (parents[0].closesbranch() and
6448 6450 pnode in repo.branchheads(branch, closed=True)):
6449 6451 t += _(' (head closed)')
6450 6452 elif not (status.modified or status.added or status.removed or renamed or
6451 6453 copied or subs):
6452 6454 t += _(' (clean)')
6453 6455 cleanworkdir = True
6454 6456 elif pnode not in bheads:
6455 6457 t += _(' (new branch head)')
6456 6458
6457 6459 if parents:
6458 6460 pendingphase = max(p.phase() for p in parents)
6459 6461 else:
6460 6462 pendingphase = phases.public
6461 6463
6462 6464 if pendingphase > phases.newcommitphase(ui):
6463 6465 t += ' (%s)' % phases.phasenames[pendingphase]
6464 6466
6465 6467 if cleanworkdir:
6466 6468 # i18n: column positioning for "hg summary"
6467 6469 ui.status(_('commit: %s\n') % t.strip())
6468 6470 else:
6469 6471 # i18n: column positioning for "hg summary"
6470 6472 ui.write(_('commit: %s\n') % t.strip())
6471 6473
6472 6474 # all ancestors of branch heads - all ancestors of parent = new csets
6473 6475 new = len(repo.changelog.findmissing([pctx.node() for pctx in parents],
6474 6476 bheads))
6475 6477
6476 6478 if new == 0:
6477 6479 # i18n: column positioning for "hg summary"
6478 6480 ui.status(_('update: (current)\n'))
6479 6481 elif pnode not in bheads:
6480 6482 # i18n: column positioning for "hg summary"
6481 6483 ui.write(_('update: %d new changesets (update)\n') % new)
6482 6484 else:
6483 6485 # i18n: column positioning for "hg summary"
6484 6486 ui.write(_('update: %d new changesets, %d branch heads (merge)\n') %
6485 6487 (new, len(bheads)))
6486 6488
6487 6489 t = []
6488 6490 draft = len(repo.revs('draft()'))
6489 6491 if draft:
6490 6492 t.append(_('%d draft') % draft)
6491 6493 secret = len(repo.revs('secret()'))
6492 6494 if secret:
6493 6495 t.append(_('%d secret') % secret)
6494 6496
6495 6497 if draft or secret:
6496 6498 ui.status(_('phases: %s\n') % ', '.join(t))
6497 6499
6498 6500 if obsolete.isenabled(repo, obsolete.createmarkersopt):
6499 6501 for trouble in ("unstable", "divergent", "bumped"):
6500 6502 numtrouble = len(repo.revs(trouble + "()"))
6501 6503 # We write all the possibilities to ease translation
6502 6504 troublemsg = {
6503 6505 "unstable": _("unstable: %d changeset"),
6504 6506 "divergent": _("divergent: %d changeset"),
6505 6507 "bumped": _("bumped: %d changeset"),
6506 6508 }
6507 6509 if numtrouble > 0:
6508 6510 ui.status(troublemsg[trouble] % numtrouble + "\n")
6509 6511
6510 6512 cmdutil.summaryhooks(ui, repo)
6511 6513
6512 6514 if opts.get('remote'):
6513 6515 needsincoming, needsoutgoing = True, True
6514 6516 else:
6515 6517 needsincoming, needsoutgoing = False, False
6516 6518 for i, o in cmdutil.summaryremotehooks(ui, repo, opts, None):
6517 6519 if i:
6518 6520 needsincoming = True
6519 6521 if o:
6520 6522 needsoutgoing = True
6521 6523 if not needsincoming and not needsoutgoing:
6522 6524 return
6523 6525
6524 6526 def getincoming():
6525 6527 source, branches = hg.parseurl(ui.expandpath('default'))
6526 6528 sbranch = branches[0]
6527 6529 try:
6528 6530 other = hg.peer(repo, {}, source)
6529 6531 except error.RepoError:
6530 6532 if opts.get('remote'):
6531 6533 raise
6532 6534 return source, sbranch, None, None, None
6533 6535 revs, checkout = hg.addbranchrevs(repo, other, branches, None)
6534 6536 if revs:
6535 6537 revs = [other.lookup(rev) for rev in revs]
6536 6538 ui.debug('comparing with %s\n' % util.hidepassword(source))
6537 6539 repo.ui.pushbuffer()
6538 6540 commoninc = discovery.findcommonincoming(repo, other, heads=revs)
6539 6541 repo.ui.popbuffer()
6540 6542 return source, sbranch, other, commoninc, commoninc[1]
6541 6543
6542 6544 if needsincoming:
6543 6545 source, sbranch, sother, commoninc, incoming = getincoming()
6544 6546 else:
6545 6547 source = sbranch = sother = commoninc = incoming = None
6546 6548
6547 6549 def getoutgoing():
6548 6550 dest, branches = hg.parseurl(ui.expandpath('default-push', 'default'))
6549 6551 dbranch = branches[0]
6550 6552 revs, checkout = hg.addbranchrevs(repo, repo, branches, None)
6551 6553 if source != dest:
6552 6554 try:
6553 6555 dother = hg.peer(repo, {}, dest)
6554 6556 except error.RepoError:
6555 6557 if opts.get('remote'):
6556 6558 raise
6557 6559 return dest, dbranch, None, None
6558 6560 ui.debug('comparing with %s\n' % util.hidepassword(dest))
6559 6561 elif sother is None:
6560 6562 # there is no explicit destination peer, but source one is invalid
6561 6563 return dest, dbranch, None, None
6562 6564 else:
6563 6565 dother = sother
6564 6566 if (source != dest or (sbranch is not None and sbranch != dbranch)):
6565 6567 common = None
6566 6568 else:
6567 6569 common = commoninc
6568 6570 if revs:
6569 6571 revs = [repo.lookup(rev) for rev in revs]
6570 6572 repo.ui.pushbuffer()
6571 6573 outgoing = discovery.findcommonoutgoing(repo, dother, onlyheads=revs,
6572 6574 commoninc=common)
6573 6575 repo.ui.popbuffer()
6574 6576 return dest, dbranch, dother, outgoing
6575 6577
6576 6578 if needsoutgoing:
6577 6579 dest, dbranch, dother, outgoing = getoutgoing()
6578 6580 else:
6579 6581 dest = dbranch = dother = outgoing = None
6580 6582
6581 6583 if opts.get('remote'):
6582 6584 t = []
6583 6585 if incoming:
6584 6586 t.append(_('1 or more incoming'))
6585 6587 o = outgoing.missing
6586 6588 if o:
6587 6589 t.append(_('%d outgoing') % len(o))
6588 6590 other = dother or sother
6589 6591 if 'bookmarks' in other.listkeys('namespaces'):
6590 6592 counts = bookmarks.summary(repo, other)
6591 6593 if counts[0] > 0:
6592 6594 t.append(_('%d incoming bookmarks') % counts[0])
6593 6595 if counts[1] > 0:
6594 6596 t.append(_('%d outgoing bookmarks') % counts[1])
6595 6597
6596 6598 if t:
6597 6599 # i18n: column positioning for "hg summary"
6598 6600 ui.write(_('remote: %s\n') % (', '.join(t)))
6599 6601 else:
6600 6602 # i18n: column positioning for "hg summary"
6601 6603 ui.status(_('remote: (synced)\n'))
6602 6604
6603 6605 cmdutil.summaryremotehooks(ui, repo, opts,
6604 6606 ((source, sbranch, sother, commoninc),
6605 6607 (dest, dbranch, dother, outgoing)))
6606 6608
6607 6609 @command('tag',
6608 6610 [('f', 'force', None, _('force tag')),
6609 6611 ('l', 'local', None, _('make the tag local')),
6610 6612 ('r', 'rev', '', _('revision to tag'), _('REV')),
6611 6613 ('', 'remove', None, _('remove a tag')),
6612 6614 # -l/--local is already there, commitopts cannot be used
6613 6615 ('e', 'edit', None, _('invoke editor on commit messages')),
6614 6616 ('m', 'message', '', _('use text as commit message'), _('TEXT')),
6615 6617 ] + commitopts2,
6616 6618 _('[-f] [-l] [-m TEXT] [-d DATE] [-u USER] [-r REV] NAME...'))
6617 6619 def tag(ui, repo, name1, *names, **opts):
6618 6620 """add one or more tags for the current or given revision
6619 6621
6620 6622 Name a particular revision using <name>.
6621 6623
6622 6624 Tags are used to name particular revisions of the repository and are
6623 6625 very useful to compare different revisions, to go back to significant
6624 6626 earlier versions or to mark branch points as releases, etc. Changing
6625 6627 an existing tag is normally disallowed; use -f/--force to override.
6626 6628
6627 6629 If no revision is given, the parent of the working directory is
6628 6630 used.
6629 6631
6630 6632 To facilitate version control, distribution, and merging of tags,
6631 6633 they are stored as a file named ".hgtags" which is managed similarly
6632 6634 to other project files and can be hand-edited if necessary. This
6633 6635 also means that tagging creates a new commit. The file
6634 6636 ".hg/localtags" is used for local tags (not shared among
6635 6637 repositories).
6636 6638
6637 6639 Tag commits are usually made at the head of a branch. If the parent
6638 6640 of the working directory is not a branch head, :hg:`tag` aborts; use
6639 6641 -f/--force to force the tag commit to be based on a non-head
6640 6642 changeset.
6641 6643
6642 6644 See :hg:`help dates` for a list of formats valid for -d/--date.
6643 6645
6644 6646 Since tag names have priority over branch names during revision
6645 6647 lookup, using an existing branch name as a tag name is discouraged.
6646 6648
6647 6649 Returns 0 on success.
6648 6650 """
6649 6651 wlock = lock = None
6650 6652 try:
6651 6653 wlock = repo.wlock()
6652 6654 lock = repo.lock()
6653 6655 rev_ = "."
6654 6656 names = [t.strip() for t in (name1,) + names]
6655 6657 if len(names) != len(set(names)):
6656 6658 raise error.Abort(_('tag names must be unique'))
6657 6659 for n in names:
6658 6660 scmutil.checknewlabel(repo, n, 'tag')
6659 6661 if not n:
6660 6662 raise error.Abort(_('tag names cannot consist entirely of '
6661 6663 'whitespace'))
6662 6664 if opts.get('rev') and opts.get('remove'):
6663 6665 raise error.Abort(_("--rev and --remove are incompatible"))
6664 6666 if opts.get('rev'):
6665 6667 rev_ = opts['rev']
6666 6668 message = opts.get('message')
6667 6669 if opts.get('remove'):
6668 6670 if opts.get('local'):
6669 6671 expectedtype = 'local'
6670 6672 else:
6671 6673 expectedtype = 'global'
6672 6674
6673 6675 for n in names:
6674 6676 if not repo.tagtype(n):
6675 6677 raise error.Abort(_("tag '%s' does not exist") % n)
6676 6678 if repo.tagtype(n) != expectedtype:
6677 6679 if expectedtype == 'global':
6678 6680 raise error.Abort(_("tag '%s' is not a global tag") % n)
6679 6681 else:
6680 6682 raise error.Abort(_("tag '%s' is not a local tag") % n)
6681 6683 rev_ = 'null'
6682 6684 if not message:
6683 6685 # we don't translate commit messages
6684 6686 message = 'Removed tag %s' % ', '.join(names)
6685 6687 elif not opts.get('force'):
6686 6688 for n in names:
6687 6689 if n in repo.tags():
6688 6690 raise error.Abort(_("tag '%s' already exists "
6689 6691 "(use -f to force)") % n)
6690 6692 if not opts.get('local'):
6691 6693 p1, p2 = repo.dirstate.parents()
6692 6694 if p2 != nullid:
6693 6695 raise error.Abort(_('uncommitted merge'))
6694 6696 bheads = repo.branchheads()
6695 6697 if not opts.get('force') and bheads and p1 not in bheads:
6696 6698 raise error.Abort(_('not at a branch head (use -f to force)'))
6697 6699 r = scmutil.revsingle(repo, rev_).node()
6698 6700
6699 6701 if not message:
6700 6702 # we don't translate commit messages
6701 6703 message = ('Added tag %s for changeset %s' %
6702 6704 (', '.join(names), short(r)))
6703 6705
6704 6706 date = opts.get('date')
6705 6707 if date:
6706 6708 date = util.parsedate(date)
6707 6709
6708 6710 if opts.get('remove'):
6709 6711 editform = 'tag.remove'
6710 6712 else:
6711 6713 editform = 'tag.add'
6712 6714 editor = cmdutil.getcommiteditor(editform=editform, **opts)
6713 6715
6714 6716 # don't allow tagging the null rev
6715 6717 if (not opts.get('remove') and
6716 6718 scmutil.revsingle(repo, rev_).rev() == nullrev):
6717 6719 raise error.Abort(_("cannot tag null revision"))
6718 6720
6719 6721 repo.tag(names, r, message, opts.get('local'), opts.get('user'), date,
6720 6722 editor=editor)
6721 6723 finally:
6722 6724 release(lock, wlock)
6723 6725
6724 6726 @command('tags', formatteropts, '')
6725 6727 def tags(ui, repo, **opts):
6726 6728 """list repository tags
6727 6729
6728 6730 This lists both regular and local tags. When the -v/--verbose
6729 6731 switch is used, a third column "local" is printed for local tags.
6730 6732
6731 6733 Returns 0 on success.
6732 6734 """
6733 6735
6734 6736 fm = ui.formatter('tags', opts)
6735 6737 hexfunc = fm.hexfunc
6736 6738 tagtype = ""
6737 6739
6738 6740 for t, n in reversed(repo.tagslist()):
6739 6741 hn = hexfunc(n)
6740 6742 label = 'tags.normal'
6741 6743 tagtype = ''
6742 6744 if repo.tagtype(t) == 'local':
6743 6745 label = 'tags.local'
6744 6746 tagtype = 'local'
6745 6747
6746 6748 fm.startitem()
6747 6749 fm.write('tag', '%s', t, label=label)
6748 6750 fmt = " " * (30 - encoding.colwidth(t)) + ' %5d:%s'
6749 6751 fm.condwrite(not ui.quiet, 'rev node', fmt,
6750 6752 repo.changelog.rev(n), hn, label=label)
6751 6753 fm.condwrite(ui.verbose and tagtype, 'type', ' %s',
6752 6754 tagtype, label=label)
6753 6755 fm.plain('\n')
6754 6756 fm.end()
6755 6757
6756 6758 @command('tip',
6757 6759 [('p', 'patch', None, _('show patch')),
6758 6760 ('g', 'git', None, _('use git extended diff format')),
6759 6761 ] + templateopts,
6760 6762 _('[-p] [-g]'))
6761 6763 def tip(ui, repo, **opts):
6762 6764 """show the tip revision (DEPRECATED)
6763 6765
6764 6766 The tip revision (usually just called the tip) is the changeset
6765 6767 most recently added to the repository (and therefore the most
6766 6768 recently changed head).
6767 6769
6768 6770 If you have just made a commit, that commit will be the tip. If
6769 6771 you have just pulled changes from another repository, the tip of
6770 6772 that repository becomes the current tip. The "tip" tag is special
6771 6773 and cannot be renamed or assigned to a different changeset.
6772 6774
6773 6775 This command is deprecated, please use :hg:`heads` instead.
6774 6776
6775 6777 Returns 0 on success.
6776 6778 """
6777 6779 displayer = cmdutil.show_changeset(ui, repo, opts)
6778 6780 displayer.show(repo['tip'])
6779 6781 displayer.close()
6780 6782
6781 6783 @command('unbundle',
6782 6784 [('u', 'update', None,
6783 6785 _('update to new branch head if changesets were unbundled'))],
6784 6786 _('[-u] FILE...'))
6785 6787 def unbundle(ui, repo, fname1, *fnames, **opts):
6786 6788 """apply one or more changegroup files
6787 6789
6788 6790 Apply one or more compressed changegroup files generated by the
6789 6791 bundle command.
6790 6792
6791 6793 Returns 0 on success, 1 if an update has unresolved files.
6792 6794 """
6793 6795 fnames = (fname1,) + fnames
6794 6796
6795 6797 lock = repo.lock()
6796 6798 try:
6797 6799 for fname in fnames:
6798 6800 f = hg.openpath(ui, fname)
6799 6801 gen = exchange.readbundle(ui, f, fname)
6800 6802 if isinstance(gen, bundle2.unbundle20):
6801 6803 tr = repo.transaction('unbundle')
6802 6804 try:
6803 6805 op = bundle2.applybundle(repo, gen, tr, source='unbundle',
6804 6806 url='bundle:' + fname)
6805 6807 tr.close()
6806 6808 except error.BundleUnknownFeatureError as exc:
6807 6809 raise error.Abort(_('%s: unknown bundle feature, %s')
6808 6810 % (fname, exc),
6809 6811 hint=_("see https://mercurial-scm.org/"
6810 6812 "wiki/BundleFeature for more "
6811 6813 "information"))
6812 6814 finally:
6813 6815 if tr:
6814 6816 tr.release()
6815 6817 changes = [r.get('return', 0)
6816 6818 for r in op.records['changegroup']]
6817 6819 modheads = changegroup.combineresults(changes)
6818 6820 elif isinstance(gen, streamclone.streamcloneapplier):
6819 6821 raise error.Abort(
6820 6822 _('packed bundles cannot be applied with '
6821 6823 '"hg unbundle"'),
6822 6824 hint=_('use "hg debugapplystreamclonebundle"'))
6823 6825 else:
6824 6826 modheads = gen.apply(repo, 'unbundle', 'bundle:' + fname)
6825 6827 finally:
6826 6828 lock.release()
6827 6829
6828 6830 return postincoming(ui, repo, modheads, opts.get('update'), None)
6829 6831
6830 6832 @command('^update|up|checkout|co',
6831 6833 [('C', 'clean', None, _('discard uncommitted changes (no backup)')),
6832 6834 ('c', 'check', None,
6833 6835 _('update across branches if no uncommitted changes')),
6834 6836 ('d', 'date', '', _('tipmost revision matching date'), _('DATE')),
6835 6837 ('r', 'rev', '', _('revision'), _('REV'))
6836 6838 ] + mergetoolopts,
6837 6839 _('[-c] [-C] [-d DATE] [[-r] REV]'))
6838 6840 def update(ui, repo, node=None, rev=None, clean=False, date=None, check=False,
6839 6841 tool=None):
6840 6842 """update working directory (or switch revisions)
6841 6843
6842 6844 Update the repository's working directory to the specified
6843 6845 changeset. If no changeset is specified, update to the tip of the
6844 6846 current named branch and move the active bookmark (see :hg:`help
6845 6847 bookmarks`).
6846 6848
6847 6849 Update sets the working directory's parent revision to the specified
6848 6850 changeset (see :hg:`help parents`).
6849 6851
6850 6852 If the changeset is not a descendant or ancestor of the working
6851 6853 directory's parent, the update is aborted. With the -c/--check
6852 6854 option, the working directory is checked for uncommitted changes; if
6853 6855 none are found, the working directory is updated to the specified
6854 6856 changeset.
6855 6857
6856 6858 .. container:: verbose
6857 6859
6858 6860 The following rules apply when the working directory contains
6859 6861 uncommitted changes:
6860 6862
6861 6863 1. If neither -c/--check nor -C/--clean is specified, and if
6862 6864 the requested changeset is an ancestor or descendant of
6863 6865 the working directory's parent, the uncommitted changes
6864 6866 are merged into the requested changeset and the merged
6865 6867 result is left uncommitted. If the requested changeset is
6866 6868 not an ancestor or descendant (that is, it is on another
6867 6869 branch), the update is aborted and the uncommitted changes
6868 6870 are preserved.
6869 6871
6870 6872 2. With the -c/--check option, the update is aborted and the
6871 6873 uncommitted changes are preserved.
6872 6874
6873 6875 3. With the -C/--clean option, uncommitted changes are discarded and
6874 6876 the working directory is updated to the requested changeset.
6875 6877
6876 6878 To cancel an uncommitted merge (and lose your changes), use
6877 6879 :hg:`update --clean .`.
6878 6880
6879 6881 Use null as the changeset to remove the working directory (like
6880 6882 :hg:`clone -U`).
6881 6883
6882 6884 If you want to revert just one file to an older revision, use
6883 6885 :hg:`revert [-r REV] NAME`.
6884 6886
6885 6887 See :hg:`help dates` for a list of formats valid for -d/--date.
6886 6888
6887 6889 Returns 0 on success, 1 if there are unresolved files.
6888 6890 """
6889 6891 movemarkfrom = None
6890 6892 if rev and node:
6891 6893 raise error.Abort(_("please specify just one revision"))
6892 6894
6893 6895 if rev is None or rev == '':
6894 6896 rev = node
6895 6897
6896 6898 wlock = repo.wlock()
6897 6899 try:
6898 6900 cmdutil.clearunfinished(repo)
6899 6901
6900 6902 if date:
6901 6903 if rev is not None:
6902 6904 raise error.Abort(_("you can't specify a revision and a date"))
6903 6905 rev = cmdutil.finddate(ui, repo, date)
6904 6906
6905 6907 # if we defined a bookmark, we have to remember the original name
6906 6908 brev = rev
6907 6909 rev = scmutil.revsingle(repo, rev, rev).rev()
6908 6910
6909 6911 if check and clean:
6910 6912 raise error.Abort(_("cannot specify both -c/--check and -C/--clean")
6911 6913 )
6912 6914
6913 6915 if check:
6914 6916 cmdutil.bailifchanged(repo, merge=False)
6915 6917 if rev is None:
6916 6918 updata = destutil.destupdate(repo, clean=clean, check=check)
6917 6919 rev, movemarkfrom, brev = updata
6918 6920
6919 6921 repo.ui.setconfig('ui', 'forcemerge', tool, 'update')
6920 6922
6921 6923 if clean:
6922 6924 ret = hg.clean(repo, rev)
6923 6925 else:
6924 6926 ret = hg.update(repo, rev)
6925 6927
6926 6928 if not ret and movemarkfrom:
6927 6929 if movemarkfrom == repo['.'].node():
6928 6930 pass # no-op update
6929 6931 elif bookmarks.update(repo, [movemarkfrom], repo['.'].node()):
6930 6932 ui.status(_("updating bookmark %s\n") % repo._activebookmark)
6931 6933 else:
6932 6934 # this can happen with a non-linear update
6933 6935 ui.status(_("(leaving bookmark %s)\n") %
6934 6936 repo._activebookmark)
6935 6937 bookmarks.deactivate(repo)
6936 6938 elif brev in repo._bookmarks:
6937 6939 bookmarks.activate(repo, brev)
6938 6940 ui.status(_("(activating bookmark %s)\n") % brev)
6939 6941 elif brev:
6940 6942 if repo._activebookmark:
6941 6943 ui.status(_("(leaving bookmark %s)\n") %
6942 6944 repo._activebookmark)
6943 6945 bookmarks.deactivate(repo)
6944 6946 finally:
6945 6947 wlock.release()
6946 6948
6947 6949 return ret
6948 6950
6949 6951 @command('verify', [])
6950 6952 def verify(ui, repo):
6951 6953 """verify the integrity of the repository
6952 6954
6953 6955 Verify the integrity of the current repository.
6954 6956
6955 6957 This will perform an extensive check of the repository's
6956 6958 integrity, validating the hashes and checksums of each entry in
6957 6959 the changelog, manifest, and tracked files, as well as the
6958 6960 integrity of their crosslinks and indices.
6959 6961
6960 6962 Please see https://mercurial-scm.org/wiki/RepositoryCorruption
6961 6963 for more information about recovery from corruption of the
6962 6964 repository.
6963 6965
6964 6966 Returns 0 on success, 1 if errors are encountered.
6965 6967 """
6966 6968 return hg.verify(repo)
6967 6969
6968 6970 @command('version', [], norepo=True)
6969 6971 def version_(ui):
6970 6972 """output version and copyright information"""
6971 6973 ui.write(_("Mercurial Distributed SCM (version %s)\n")
6972 6974 % util.version())
6973 6975 ui.status(_(
6974 6976 "(see https://mercurial-scm.org for more information)\n"
6975 6977 "\nCopyright (C) 2005-2015 Matt Mackall and others\n"
6976 6978 "This is free software; see the source for copying conditions. "
6977 6979 "There is NO\nwarranty; "
6978 6980 "not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
6979 6981 ))
6980 6982
6981 6983 ui.note(_("\nEnabled extensions:\n\n"))
6982 6984 if ui.verbose:
6983 6985 # format names and versions into columns
6984 6986 names = []
6985 6987 vers = []
6986 6988 for name, module in extensions.extensions():
6987 6989 names.append(name)
6988 6990 vers.append(extensions.moduleversion(module))
6989 6991 if names:
6990 6992 maxnamelen = max(len(n) for n in names)
6991 6993 for i, name in enumerate(names):
6992 6994 ui.write(" %-*s %s\n" % (maxnamelen, name, vers[i]))
General Comments 0
You need to be logged in to leave comments. Login now