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