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