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