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