##// END OF EJS Templates
dirstate-item: use item's property instead of `state` in revert...
marmoute -
r48916:e8d62615 default
parent child Browse files
Show More
@@ -1,3942 +1,3946
1 1 # cmdutil.py - help for command processing in mercurial
2 2 #
3 3 # Copyright 2005-2007 Olivia Mackall <olivia@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 copy as copymod
11 11 import errno
12 12 import os
13 13 import re
14 14
15 15 from .i18n import _
16 16 from .node import (
17 17 hex,
18 18 nullrev,
19 19 short,
20 20 )
21 21 from .pycompat import (
22 22 getattr,
23 23 open,
24 24 setattr,
25 25 )
26 26 from .thirdparty import attr
27 27
28 28 from . import (
29 29 bookmarks,
30 30 changelog,
31 31 copies,
32 32 crecord as crecordmod,
33 33 dirstateguard,
34 34 encoding,
35 35 error,
36 36 formatter,
37 37 logcmdutil,
38 38 match as matchmod,
39 39 merge as mergemod,
40 40 mergestate as mergestatemod,
41 41 mergeutil,
42 42 obsolete,
43 43 patch,
44 44 pathutil,
45 45 phases,
46 46 pycompat,
47 47 repair,
48 48 revlog,
49 49 rewriteutil,
50 50 scmutil,
51 51 state as statemod,
52 52 subrepoutil,
53 53 templatekw,
54 54 templater,
55 55 util,
56 56 vfs as vfsmod,
57 57 )
58 58
59 59 from .utils import (
60 60 dateutil,
61 61 stringutil,
62 62 )
63 63
64 64 from .revlogutils import (
65 65 constants as revlog_constants,
66 66 )
67 67
68 68 if pycompat.TYPE_CHECKING:
69 69 from typing import (
70 70 Any,
71 71 Dict,
72 72 )
73 73
74 74 for t in (Any, Dict):
75 75 assert t
76 76
77 77 stringio = util.stringio
78 78
79 79 # templates of common command options
80 80
81 81 dryrunopts = [
82 82 (b'n', b'dry-run', None, _(b'do not perform actions, just print output')),
83 83 ]
84 84
85 85 confirmopts = [
86 86 (b'', b'confirm', None, _(b'ask before applying actions')),
87 87 ]
88 88
89 89 remoteopts = [
90 90 (b'e', b'ssh', b'', _(b'specify ssh command to use'), _(b'CMD')),
91 91 (
92 92 b'',
93 93 b'remotecmd',
94 94 b'',
95 95 _(b'specify hg command to run on the remote side'),
96 96 _(b'CMD'),
97 97 ),
98 98 (
99 99 b'',
100 100 b'insecure',
101 101 None,
102 102 _(b'do not verify server certificate (ignoring web.cacerts config)'),
103 103 ),
104 104 ]
105 105
106 106 walkopts = [
107 107 (
108 108 b'I',
109 109 b'include',
110 110 [],
111 111 _(b'include names matching the given patterns'),
112 112 _(b'PATTERN'),
113 113 ),
114 114 (
115 115 b'X',
116 116 b'exclude',
117 117 [],
118 118 _(b'exclude names matching the given patterns'),
119 119 _(b'PATTERN'),
120 120 ),
121 121 ]
122 122
123 123 commitopts = [
124 124 (b'm', b'message', b'', _(b'use text as commit message'), _(b'TEXT')),
125 125 (b'l', b'logfile', b'', _(b'read commit message from file'), _(b'FILE')),
126 126 ]
127 127
128 128 commitopts2 = [
129 129 (
130 130 b'd',
131 131 b'date',
132 132 b'',
133 133 _(b'record the specified date as commit date'),
134 134 _(b'DATE'),
135 135 ),
136 136 (
137 137 b'u',
138 138 b'user',
139 139 b'',
140 140 _(b'record the specified user as committer'),
141 141 _(b'USER'),
142 142 ),
143 143 ]
144 144
145 145 commitopts3 = [
146 146 (b'D', b'currentdate', None, _(b'record the current date as commit date')),
147 147 (b'U', b'currentuser', None, _(b'record the current user as committer')),
148 148 ]
149 149
150 150 formatteropts = [
151 151 (b'T', b'template', b'', _(b'display with template'), _(b'TEMPLATE')),
152 152 ]
153 153
154 154 templateopts = [
155 155 (
156 156 b'',
157 157 b'style',
158 158 b'',
159 159 _(b'display using template map file (DEPRECATED)'),
160 160 _(b'STYLE'),
161 161 ),
162 162 (b'T', b'template', b'', _(b'display with template'), _(b'TEMPLATE')),
163 163 ]
164 164
165 165 logopts = [
166 166 (b'p', b'patch', None, _(b'show patch')),
167 167 (b'g', b'git', None, _(b'use git extended diff format')),
168 168 (b'l', b'limit', b'', _(b'limit number of changes displayed'), _(b'NUM')),
169 169 (b'M', b'no-merges', None, _(b'do not show merges')),
170 170 (b'', b'stat', None, _(b'output diffstat-style summary of changes')),
171 171 (b'G', b'graph', None, _(b"show the revision DAG")),
172 172 ] + templateopts
173 173
174 174 diffopts = [
175 175 (b'a', b'text', None, _(b'treat all files as text')),
176 176 (
177 177 b'g',
178 178 b'git',
179 179 None,
180 180 _(b'use git extended diff format (DEFAULT: diff.git)'),
181 181 ),
182 182 (b'', b'binary', None, _(b'generate binary diffs in git mode (default)')),
183 183 (b'', b'nodates', None, _(b'omit dates from diff headers')),
184 184 ]
185 185
186 186 diffwsopts = [
187 187 (
188 188 b'w',
189 189 b'ignore-all-space',
190 190 None,
191 191 _(b'ignore white space when comparing lines'),
192 192 ),
193 193 (
194 194 b'b',
195 195 b'ignore-space-change',
196 196 None,
197 197 _(b'ignore changes in the amount of white space'),
198 198 ),
199 199 (
200 200 b'B',
201 201 b'ignore-blank-lines',
202 202 None,
203 203 _(b'ignore changes whose lines are all blank'),
204 204 ),
205 205 (
206 206 b'Z',
207 207 b'ignore-space-at-eol',
208 208 None,
209 209 _(b'ignore changes in whitespace at EOL'),
210 210 ),
211 211 ]
212 212
213 213 diffopts2 = (
214 214 [
215 215 (b'', b'noprefix', None, _(b'omit a/ and b/ prefixes from filenames')),
216 216 (
217 217 b'p',
218 218 b'show-function',
219 219 None,
220 220 _(
221 221 b'show which function each change is in (DEFAULT: diff.showfunc)'
222 222 ),
223 223 ),
224 224 (b'', b'reverse', None, _(b'produce a diff that undoes the changes')),
225 225 ]
226 226 + diffwsopts
227 227 + [
228 228 (
229 229 b'U',
230 230 b'unified',
231 231 b'',
232 232 _(b'number of lines of context to show'),
233 233 _(b'NUM'),
234 234 ),
235 235 (b'', b'stat', None, _(b'output diffstat-style summary of changes')),
236 236 (
237 237 b'',
238 238 b'root',
239 239 b'',
240 240 _(b'produce diffs relative to subdirectory'),
241 241 _(b'DIR'),
242 242 ),
243 243 ]
244 244 )
245 245
246 246 mergetoolopts = [
247 247 (b't', b'tool', b'', _(b'specify merge tool'), _(b'TOOL')),
248 248 ]
249 249
250 250 similarityopts = [
251 251 (
252 252 b's',
253 253 b'similarity',
254 254 b'',
255 255 _(b'guess renamed files by similarity (0<=s<=100)'),
256 256 _(b'SIMILARITY'),
257 257 )
258 258 ]
259 259
260 260 subrepoopts = [(b'S', b'subrepos', None, _(b'recurse into subrepositories'))]
261 261
262 262 debugrevlogopts = [
263 263 (b'c', b'changelog', False, _(b'open changelog')),
264 264 (b'm', b'manifest', False, _(b'open manifest')),
265 265 (b'', b'dir', b'', _(b'open directory manifest')),
266 266 ]
267 267
268 268 # special string such that everything below this line will be ingored in the
269 269 # editor text
270 270 _linebelow = b"^HG: ------------------------ >8 ------------------------$"
271 271
272 272
273 273 def check_at_most_one_arg(opts, *args):
274 274 """abort if more than one of the arguments are in opts
275 275
276 276 Returns the unique argument or None if none of them were specified.
277 277 """
278 278
279 279 def to_display(name):
280 280 return pycompat.sysbytes(name).replace(b'_', b'-')
281 281
282 282 previous = None
283 283 for x in args:
284 284 if opts.get(x):
285 285 if previous:
286 286 raise error.InputError(
287 287 _(b'cannot specify both --%s and --%s')
288 288 % (to_display(previous), to_display(x))
289 289 )
290 290 previous = x
291 291 return previous
292 292
293 293
294 294 def check_incompatible_arguments(opts, first, others):
295 295 """abort if the first argument is given along with any of the others
296 296
297 297 Unlike check_at_most_one_arg(), `others` are not mutually exclusive
298 298 among themselves, and they're passed as a single collection.
299 299 """
300 300 for other in others:
301 301 check_at_most_one_arg(opts, first, other)
302 302
303 303
304 304 def resolve_commit_options(ui, opts):
305 305 """modify commit options dict to handle related options
306 306
307 307 The return value indicates that ``rewrite.update-timestamp`` is the reason
308 308 the ``date`` option is set.
309 309 """
310 310 check_at_most_one_arg(opts, 'date', 'currentdate')
311 311 check_at_most_one_arg(opts, 'user', 'currentuser')
312 312
313 313 datemaydiffer = False # date-only change should be ignored?
314 314
315 315 if opts.get('currentdate'):
316 316 opts['date'] = b'%d %d' % dateutil.makedate()
317 317 elif (
318 318 not opts.get('date')
319 319 and ui.configbool(b'rewrite', b'update-timestamp')
320 320 and opts.get('currentdate') is None
321 321 ):
322 322 opts['date'] = b'%d %d' % dateutil.makedate()
323 323 datemaydiffer = True
324 324
325 325 if opts.get('currentuser'):
326 326 opts['user'] = ui.username()
327 327
328 328 return datemaydiffer
329 329
330 330
331 331 def check_note_size(opts):
332 332 """make sure note is of valid format"""
333 333
334 334 note = opts.get('note')
335 335 if not note:
336 336 return
337 337
338 338 if len(note) > 255:
339 339 raise error.InputError(_(b"cannot store a note of more than 255 bytes"))
340 340 if b'\n' in note:
341 341 raise error.InputError(_(b"note cannot contain a newline"))
342 342
343 343
344 344 def ishunk(x):
345 345 hunkclasses = (crecordmod.uihunk, patch.recordhunk)
346 346 return isinstance(x, hunkclasses)
347 347
348 348
349 349 def isheader(x):
350 350 headerclasses = (crecordmod.uiheader, patch.header)
351 351 return isinstance(x, headerclasses)
352 352
353 353
354 354 def newandmodified(chunks):
355 355 newlyaddedandmodifiedfiles = set()
356 356 alsorestore = set()
357 357 for chunk in chunks:
358 358 if isheader(chunk) and chunk.isnewfile():
359 359 newlyaddedandmodifiedfiles.add(chunk.filename())
360 360 alsorestore.update(set(chunk.files()) - {chunk.filename()})
361 361 return newlyaddedandmodifiedfiles, alsorestore
362 362
363 363
364 364 def parsealiases(cmd):
365 365 base_aliases = cmd.split(b"|")
366 366 all_aliases = set(base_aliases)
367 367 extra_aliases = []
368 368 for alias in base_aliases:
369 369 if b'-' in alias:
370 370 folded_alias = alias.replace(b'-', b'')
371 371 if folded_alias not in all_aliases:
372 372 all_aliases.add(folded_alias)
373 373 extra_aliases.append(folded_alias)
374 374 base_aliases.extend(extra_aliases)
375 375 return base_aliases
376 376
377 377
378 378 def setupwrapcolorwrite(ui):
379 379 # wrap ui.write so diff output can be labeled/colorized
380 380 def wrapwrite(orig, *args, **kw):
381 381 label = kw.pop('label', b'')
382 382 for chunk, l in patch.difflabel(lambda: args):
383 383 orig(chunk, label=label + l)
384 384
385 385 oldwrite = ui.write
386 386
387 387 def wrap(*args, **kwargs):
388 388 return wrapwrite(oldwrite, *args, **kwargs)
389 389
390 390 setattr(ui, 'write', wrap)
391 391 return oldwrite
392 392
393 393
394 394 def filterchunks(ui, originalhunks, usecurses, testfile, match, operation=None):
395 395 try:
396 396 if usecurses:
397 397 if testfile:
398 398 recordfn = crecordmod.testdecorator(
399 399 testfile, crecordmod.testchunkselector
400 400 )
401 401 else:
402 402 recordfn = crecordmod.chunkselector
403 403
404 404 return crecordmod.filterpatch(
405 405 ui, originalhunks, recordfn, operation
406 406 )
407 407 except crecordmod.fallbackerror as e:
408 408 ui.warn(b'%s\n' % e)
409 409 ui.warn(_(b'falling back to text mode\n'))
410 410
411 411 return patch.filterpatch(ui, originalhunks, match, operation)
412 412
413 413
414 414 def recordfilter(ui, originalhunks, match, operation=None):
415 415 """Prompts the user to filter the originalhunks and return a list of
416 416 selected hunks.
417 417 *operation* is used for to build ui messages to indicate the user what
418 418 kind of filtering they are doing: reverting, committing, shelving, etc.
419 419 (see patch.filterpatch).
420 420 """
421 421 usecurses = crecordmod.checkcurses(ui)
422 422 testfile = ui.config(b'experimental', b'crecordtest')
423 423 oldwrite = setupwrapcolorwrite(ui)
424 424 try:
425 425 newchunks, newopts = filterchunks(
426 426 ui, originalhunks, usecurses, testfile, match, operation
427 427 )
428 428 finally:
429 429 ui.write = oldwrite
430 430 return newchunks, newopts
431 431
432 432
433 433 def dorecord(
434 434 ui, repo, commitfunc, cmdsuggest, backupall, filterfn, *pats, **opts
435 435 ):
436 436 opts = pycompat.byteskwargs(opts)
437 437 if not ui.interactive():
438 438 if cmdsuggest:
439 439 msg = _(b'running non-interactively, use %s instead') % cmdsuggest
440 440 else:
441 441 msg = _(b'running non-interactively')
442 442 raise error.InputError(msg)
443 443
444 444 # make sure username is set before going interactive
445 445 if not opts.get(b'user'):
446 446 ui.username() # raise exception, username not provided
447 447
448 448 def recordfunc(ui, repo, message, match, opts):
449 449 """This is generic record driver.
450 450
451 451 Its job is to interactively filter local changes, and
452 452 accordingly prepare working directory into a state in which the
453 453 job can be delegated to a non-interactive commit command such as
454 454 'commit' or 'qrefresh'.
455 455
456 456 After the actual job is done by non-interactive command, the
457 457 working directory is restored to its original state.
458 458
459 459 In the end we'll record interesting changes, and everything else
460 460 will be left in place, so the user can continue working.
461 461 """
462 462 if not opts.get(b'interactive-unshelve'):
463 463 checkunfinished(repo, commit=True)
464 464 wctx = repo[None]
465 465 merge = len(wctx.parents()) > 1
466 466 if merge:
467 467 raise error.InputError(
468 468 _(
469 469 b'cannot partially commit a merge '
470 470 b'(use "hg commit" instead)'
471 471 )
472 472 )
473 473
474 474 def fail(f, msg):
475 475 raise error.InputError(b'%s: %s' % (f, msg))
476 476
477 477 force = opts.get(b'force')
478 478 if not force:
479 479 match = matchmod.badmatch(match, fail)
480 480
481 481 status = repo.status(match=match)
482 482
483 483 overrides = {(b'ui', b'commitsubrepos'): True}
484 484
485 485 with repo.ui.configoverride(overrides, b'record'):
486 486 # subrepoutil.precommit() modifies the status
487 487 tmpstatus = scmutil.status(
488 488 copymod.copy(status.modified),
489 489 copymod.copy(status.added),
490 490 copymod.copy(status.removed),
491 491 copymod.copy(status.deleted),
492 492 copymod.copy(status.unknown),
493 493 copymod.copy(status.ignored),
494 494 copymod.copy(status.clean), # pytype: disable=wrong-arg-count
495 495 )
496 496
497 497 # Force allows -X subrepo to skip the subrepo.
498 498 subs, commitsubs, newstate = subrepoutil.precommit(
499 499 repo.ui, wctx, tmpstatus, match, force=True
500 500 )
501 501 for s in subs:
502 502 if s in commitsubs:
503 503 dirtyreason = wctx.sub(s).dirtyreason(True)
504 504 raise error.Abort(dirtyreason)
505 505
506 506 if not force:
507 507 repo.checkcommitpatterns(wctx, match, status, fail)
508 508 diffopts = patch.difffeatureopts(
509 509 ui,
510 510 opts=opts,
511 511 whitespace=True,
512 512 section=b'commands',
513 513 configprefix=b'commit.interactive.',
514 514 )
515 515 diffopts.nodates = True
516 516 diffopts.git = True
517 517 diffopts.showfunc = True
518 518 originaldiff = patch.diff(repo, changes=status, opts=diffopts)
519 519 original_headers = patch.parsepatch(originaldiff)
520 520 match = scmutil.match(repo[None], pats)
521 521
522 522 # 1. filter patch, since we are intending to apply subset of it
523 523 try:
524 524 chunks, newopts = filterfn(ui, original_headers, match)
525 525 except error.PatchError as err:
526 526 raise error.InputError(_(b'error parsing patch: %s') % err)
527 527 opts.update(newopts)
528 528
529 529 # We need to keep a backup of files that have been newly added and
530 530 # modified during the recording process because there is a previous
531 531 # version without the edit in the workdir. We also will need to restore
532 532 # files that were the sources of renames so that the patch application
533 533 # works.
534 534 newlyaddedandmodifiedfiles, alsorestore = newandmodified(chunks)
535 535 contenders = set()
536 536 for h in chunks:
537 537 if isheader(h):
538 538 contenders.update(set(h.files()))
539 539
540 540 changed = status.modified + status.added + status.removed
541 541 newfiles = [f for f in changed if f in contenders]
542 542 if not newfiles:
543 543 ui.status(_(b'no changes to record\n'))
544 544 return 0
545 545
546 546 modified = set(status.modified)
547 547
548 548 # 2. backup changed files, so we can restore them in the end
549 549
550 550 if backupall:
551 551 tobackup = changed
552 552 else:
553 553 tobackup = [
554 554 f
555 555 for f in newfiles
556 556 if f in modified or f in newlyaddedandmodifiedfiles
557 557 ]
558 558 backups = {}
559 559 if tobackup:
560 560 backupdir = repo.vfs.join(b'record-backups')
561 561 try:
562 562 os.mkdir(backupdir)
563 563 except OSError as err:
564 564 if err.errno != errno.EEXIST:
565 565 raise
566 566 try:
567 567 # backup continues
568 568 for f in tobackup:
569 569 fd, tmpname = pycompat.mkstemp(
570 570 prefix=os.path.basename(f) + b'.', dir=backupdir
571 571 )
572 572 os.close(fd)
573 573 ui.debug(b'backup %r as %r\n' % (f, tmpname))
574 574 util.copyfile(repo.wjoin(f), tmpname, copystat=True)
575 575 backups[f] = tmpname
576 576
577 577 fp = stringio()
578 578 for c in chunks:
579 579 fname = c.filename()
580 580 if fname in backups:
581 581 c.write(fp)
582 582 dopatch = fp.tell()
583 583 fp.seek(0)
584 584
585 585 # 2.5 optionally review / modify patch in text editor
586 586 if opts.get(b'review', False):
587 587 patchtext = (
588 588 crecordmod.diffhelptext
589 589 + crecordmod.patchhelptext
590 590 + fp.read()
591 591 )
592 592 reviewedpatch = ui.edit(
593 593 patchtext, b"", action=b"diff", repopath=repo.path
594 594 )
595 595 fp.truncate(0)
596 596 fp.write(reviewedpatch)
597 597 fp.seek(0)
598 598
599 599 [os.unlink(repo.wjoin(c)) for c in newlyaddedandmodifiedfiles]
600 600 # 3a. apply filtered patch to clean repo (clean)
601 601 if backups:
602 602 m = scmutil.matchfiles(repo, set(backups.keys()) | alsorestore)
603 603 mergemod.revert_to(repo[b'.'], matcher=m)
604 604
605 605 # 3b. (apply)
606 606 if dopatch:
607 607 try:
608 608 ui.debug(b'applying patch\n')
609 609 ui.debug(fp.getvalue())
610 610 patch.internalpatch(ui, repo, fp, 1, eolmode=None)
611 611 except error.PatchError as err:
612 612 raise error.InputError(pycompat.bytestr(err))
613 613 del fp
614 614
615 615 # 4. We prepared working directory according to filtered
616 616 # patch. Now is the time to delegate the job to
617 617 # commit/qrefresh or the like!
618 618
619 619 # Make all of the pathnames absolute.
620 620 newfiles = [repo.wjoin(nf) for nf in newfiles]
621 621 return commitfunc(ui, repo, *newfiles, **pycompat.strkwargs(opts))
622 622 finally:
623 623 # 5. finally restore backed-up files
624 624 try:
625 625 dirstate = repo.dirstate
626 626 for realname, tmpname in pycompat.iteritems(backups):
627 627 ui.debug(b'restoring %r to %r\n' % (tmpname, realname))
628 628
629 629 if dirstate.get_entry(realname).maybe_clean:
630 630 # without normallookup, restoring timestamp
631 631 # may cause partially committed files
632 632 # to be treated as unmodified
633 633
634 634 # XXX-PENDINGCHANGE: We should clarify the context in
635 635 # which this function is called to make sure it
636 636 # already called within a `pendingchange`, However we
637 637 # are taking a shortcut here in order to be able to
638 638 # quickly deprecated the older API.
639 639 with dirstate.parentchange():
640 640 dirstate.update_file(
641 641 realname,
642 642 p1_tracked=True,
643 643 wc_tracked=True,
644 644 possibly_dirty=True,
645 645 )
646 646
647 647 # copystat=True here and above are a hack to trick any
648 648 # editors that have f open that we haven't modified them.
649 649 #
650 650 # Also note that this racy as an editor could notice the
651 651 # file's mtime before we've finished writing it.
652 652 util.copyfile(tmpname, repo.wjoin(realname), copystat=True)
653 653 os.unlink(tmpname)
654 654 if tobackup:
655 655 os.rmdir(backupdir)
656 656 except OSError:
657 657 pass
658 658
659 659 def recordinwlock(ui, repo, message, match, opts):
660 660 with repo.wlock():
661 661 return recordfunc(ui, repo, message, match, opts)
662 662
663 663 return commit(ui, repo, recordinwlock, pats, opts)
664 664
665 665
666 666 class dirnode(object):
667 667 """
668 668 Represent a directory in user working copy with information required for
669 669 the purpose of tersing its status.
670 670
671 671 path is the path to the directory, without a trailing '/'
672 672
673 673 statuses is a set of statuses of all files in this directory (this includes
674 674 all the files in all the subdirectories too)
675 675
676 676 files is a list of files which are direct child of this directory
677 677
678 678 subdirs is a dictionary of sub-directory name as the key and it's own
679 679 dirnode object as the value
680 680 """
681 681
682 682 def __init__(self, dirpath):
683 683 self.path = dirpath
684 684 self.statuses = set()
685 685 self.files = []
686 686 self.subdirs = {}
687 687
688 688 def _addfileindir(self, filename, status):
689 689 """Add a file in this directory as a direct child."""
690 690 self.files.append((filename, status))
691 691
692 692 def addfile(self, filename, status):
693 693 """
694 694 Add a file to this directory or to its direct parent directory.
695 695
696 696 If the file is not direct child of this directory, we traverse to the
697 697 directory of which this file is a direct child of and add the file
698 698 there.
699 699 """
700 700
701 701 # the filename contains a path separator, it means it's not the direct
702 702 # child of this directory
703 703 if b'/' in filename:
704 704 subdir, filep = filename.split(b'/', 1)
705 705
706 706 # does the dirnode object for subdir exists
707 707 if subdir not in self.subdirs:
708 708 subdirpath = pathutil.join(self.path, subdir)
709 709 self.subdirs[subdir] = dirnode(subdirpath)
710 710
711 711 # try adding the file in subdir
712 712 self.subdirs[subdir].addfile(filep, status)
713 713
714 714 else:
715 715 self._addfileindir(filename, status)
716 716
717 717 if status not in self.statuses:
718 718 self.statuses.add(status)
719 719
720 720 def iterfilepaths(self):
721 721 """Yield (status, path) for files directly under this directory."""
722 722 for f, st in self.files:
723 723 yield st, pathutil.join(self.path, f)
724 724
725 725 def tersewalk(self, terseargs):
726 726 """
727 727 Yield (status, path) obtained by processing the status of this
728 728 dirnode.
729 729
730 730 terseargs is the string of arguments passed by the user with `--terse`
731 731 flag.
732 732
733 733 Following are the cases which can happen:
734 734
735 735 1) All the files in the directory (including all the files in its
736 736 subdirectories) share the same status and the user has asked us to terse
737 737 that status. -> yield (status, dirpath). dirpath will end in '/'.
738 738
739 739 2) Otherwise, we do following:
740 740
741 741 a) Yield (status, filepath) for all the files which are in this
742 742 directory (only the ones in this directory, not the subdirs)
743 743
744 744 b) Recurse the function on all the subdirectories of this
745 745 directory
746 746 """
747 747
748 748 if len(self.statuses) == 1:
749 749 onlyst = self.statuses.pop()
750 750
751 751 # Making sure we terse only when the status abbreviation is
752 752 # passed as terse argument
753 753 if onlyst in terseargs:
754 754 yield onlyst, self.path + b'/'
755 755 return
756 756
757 757 # add the files to status list
758 758 for st, fpath in self.iterfilepaths():
759 759 yield st, fpath
760 760
761 761 # recurse on the subdirs
762 762 for dirobj in self.subdirs.values():
763 763 for st, fpath in dirobj.tersewalk(terseargs):
764 764 yield st, fpath
765 765
766 766
767 767 def tersedir(statuslist, terseargs):
768 768 """
769 769 Terse the status if all the files in a directory shares the same status.
770 770
771 771 statuslist is scmutil.status() object which contains a list of files for
772 772 each status.
773 773 terseargs is string which is passed by the user as the argument to `--terse`
774 774 flag.
775 775
776 776 The function makes a tree of objects of dirnode class, and at each node it
777 777 stores the information required to know whether we can terse a certain
778 778 directory or not.
779 779 """
780 780 # the order matters here as that is used to produce final list
781 781 allst = (b'm', b'a', b'r', b'd', b'u', b'i', b'c')
782 782
783 783 # checking the argument validity
784 784 for s in pycompat.bytestr(terseargs):
785 785 if s not in allst:
786 786 raise error.InputError(_(b"'%s' not recognized") % s)
787 787
788 788 # creating a dirnode object for the root of the repo
789 789 rootobj = dirnode(b'')
790 790 pstatus = (
791 791 b'modified',
792 792 b'added',
793 793 b'deleted',
794 794 b'clean',
795 795 b'unknown',
796 796 b'ignored',
797 797 b'removed',
798 798 )
799 799
800 800 tersedict = {}
801 801 for attrname in pstatus:
802 802 statuschar = attrname[0:1]
803 803 for f in getattr(statuslist, attrname):
804 804 rootobj.addfile(f, statuschar)
805 805 tersedict[statuschar] = []
806 806
807 807 # we won't be tersing the root dir, so add files in it
808 808 for st, fpath in rootobj.iterfilepaths():
809 809 tersedict[st].append(fpath)
810 810
811 811 # process each sub-directory and build tersedict
812 812 for subdir in rootobj.subdirs.values():
813 813 for st, f in subdir.tersewalk(terseargs):
814 814 tersedict[st].append(f)
815 815
816 816 tersedlist = []
817 817 for st in allst:
818 818 tersedict[st].sort()
819 819 tersedlist.append(tersedict[st])
820 820
821 821 return scmutil.status(*tersedlist)
822 822
823 823
824 824 def _commentlines(raw):
825 825 '''Surround lineswith a comment char and a new line'''
826 826 lines = raw.splitlines()
827 827 commentedlines = [b'# %s' % line for line in lines]
828 828 return b'\n'.join(commentedlines) + b'\n'
829 829
830 830
831 831 @attr.s(frozen=True)
832 832 class morestatus(object):
833 833 reporoot = attr.ib()
834 834 unfinishedop = attr.ib()
835 835 unfinishedmsg = attr.ib()
836 836 activemerge = attr.ib()
837 837 unresolvedpaths = attr.ib()
838 838 _formattedpaths = attr.ib(init=False, default=set())
839 839 _label = b'status.morestatus'
840 840
841 841 def formatfile(self, path, fm):
842 842 self._formattedpaths.add(path)
843 843 if self.activemerge and path in self.unresolvedpaths:
844 844 fm.data(unresolved=True)
845 845
846 846 def formatfooter(self, fm):
847 847 if self.unfinishedop or self.unfinishedmsg:
848 848 fm.startitem()
849 849 fm.data(itemtype=b'morestatus')
850 850
851 851 if self.unfinishedop:
852 852 fm.data(unfinished=self.unfinishedop)
853 853 statemsg = (
854 854 _(b'The repository is in an unfinished *%s* state.')
855 855 % self.unfinishedop
856 856 )
857 857 fm.plain(b'%s\n' % _commentlines(statemsg), label=self._label)
858 858 if self.unfinishedmsg:
859 859 fm.data(unfinishedmsg=self.unfinishedmsg)
860 860
861 861 # May also start new data items.
862 862 self._formatconflicts(fm)
863 863
864 864 if self.unfinishedmsg:
865 865 fm.plain(
866 866 b'%s\n' % _commentlines(self.unfinishedmsg), label=self._label
867 867 )
868 868
869 869 def _formatconflicts(self, fm):
870 870 if not self.activemerge:
871 871 return
872 872
873 873 if self.unresolvedpaths:
874 874 mergeliststr = b'\n'.join(
875 875 [
876 876 b' %s'
877 877 % util.pathto(self.reporoot, encoding.getcwd(), path)
878 878 for path in self.unresolvedpaths
879 879 ]
880 880 )
881 881 msg = (
882 882 _(
883 883 b'''Unresolved merge conflicts:
884 884
885 885 %s
886 886
887 887 To mark files as resolved: hg resolve --mark FILE'''
888 888 )
889 889 % mergeliststr
890 890 )
891 891
892 892 # If any paths with unresolved conflicts were not previously
893 893 # formatted, output them now.
894 894 for f in self.unresolvedpaths:
895 895 if f in self._formattedpaths:
896 896 # Already output.
897 897 continue
898 898 fm.startitem()
899 899 # We can't claim to know the status of the file - it may just
900 900 # have been in one of the states that were not requested for
901 901 # display, so it could be anything.
902 902 fm.data(itemtype=b'file', path=f, unresolved=True)
903 903
904 904 else:
905 905 msg = _(b'No unresolved merge conflicts.')
906 906
907 907 fm.plain(b'%s\n' % _commentlines(msg), label=self._label)
908 908
909 909
910 910 def readmorestatus(repo):
911 911 """Returns a morestatus object if the repo has unfinished state."""
912 912 statetuple = statemod.getrepostate(repo)
913 913 mergestate = mergestatemod.mergestate.read(repo)
914 914 activemerge = mergestate.active()
915 915 if not statetuple and not activemerge:
916 916 return None
917 917
918 918 unfinishedop = unfinishedmsg = unresolved = None
919 919 if statetuple:
920 920 unfinishedop, unfinishedmsg = statetuple
921 921 if activemerge:
922 922 unresolved = sorted(mergestate.unresolved())
923 923 return morestatus(
924 924 repo.root, unfinishedop, unfinishedmsg, activemerge, unresolved
925 925 )
926 926
927 927
928 928 def findpossible(cmd, table, strict=False):
929 929 """
930 930 Return cmd -> (aliases, command table entry)
931 931 for each matching command.
932 932 Return debug commands (or their aliases) only if no normal command matches.
933 933 """
934 934 choice = {}
935 935 debugchoice = {}
936 936
937 937 if cmd in table:
938 938 # short-circuit exact matches, "log" alias beats "log|history"
939 939 keys = [cmd]
940 940 else:
941 941 keys = table.keys()
942 942
943 943 allcmds = []
944 944 for e in keys:
945 945 aliases = parsealiases(e)
946 946 allcmds.extend(aliases)
947 947 found = None
948 948 if cmd in aliases:
949 949 found = cmd
950 950 elif not strict:
951 951 for a in aliases:
952 952 if a.startswith(cmd):
953 953 found = a
954 954 break
955 955 if found is not None:
956 956 if aliases[0].startswith(b"debug") or found.startswith(b"debug"):
957 957 debugchoice[found] = (aliases, table[e])
958 958 else:
959 959 choice[found] = (aliases, table[e])
960 960
961 961 if not choice and debugchoice:
962 962 choice = debugchoice
963 963
964 964 return choice, allcmds
965 965
966 966
967 967 def findcmd(cmd, table, strict=True):
968 968 """Return (aliases, command table entry) for command string."""
969 969 choice, allcmds = findpossible(cmd, table, strict)
970 970
971 971 if cmd in choice:
972 972 return choice[cmd]
973 973
974 974 if len(choice) > 1:
975 975 clist = sorted(choice)
976 976 raise error.AmbiguousCommand(cmd, clist)
977 977
978 978 if choice:
979 979 return list(choice.values())[0]
980 980
981 981 raise error.UnknownCommand(cmd, allcmds)
982 982
983 983
984 984 def changebranch(ui, repo, revs, label, opts):
985 985 """Change the branch name of given revs to label"""
986 986
987 987 with repo.wlock(), repo.lock(), repo.transaction(b'branches'):
988 988 # abort in case of uncommitted merge or dirty wdir
989 989 bailifchanged(repo)
990 990 revs = scmutil.revrange(repo, revs)
991 991 if not revs:
992 992 raise error.InputError(b"empty revision set")
993 993 roots = repo.revs(b'roots(%ld)', revs)
994 994 if len(roots) > 1:
995 995 raise error.InputError(
996 996 _(b"cannot change branch of non-linear revisions")
997 997 )
998 998 rewriteutil.precheck(repo, revs, b'change branch of')
999 999
1000 1000 root = repo[roots.first()]
1001 1001 rpb = {parent.branch() for parent in root.parents()}
1002 1002 if (
1003 1003 not opts.get(b'force')
1004 1004 and label not in rpb
1005 1005 and label in repo.branchmap()
1006 1006 ):
1007 1007 raise error.InputError(
1008 1008 _(b"a branch of the same name already exists")
1009 1009 )
1010 1010
1011 1011 # make sure only topological heads
1012 1012 if repo.revs(b'heads(%ld) - head()', revs):
1013 1013 raise error.InputError(
1014 1014 _(b"cannot change branch in middle of a stack")
1015 1015 )
1016 1016
1017 1017 replacements = {}
1018 1018 # avoid import cycle mercurial.cmdutil -> mercurial.context ->
1019 1019 # mercurial.subrepo -> mercurial.cmdutil
1020 1020 from . import context
1021 1021
1022 1022 for rev in revs:
1023 1023 ctx = repo[rev]
1024 1024 oldbranch = ctx.branch()
1025 1025 # check if ctx has same branch
1026 1026 if oldbranch == label:
1027 1027 continue
1028 1028
1029 1029 def filectxfn(repo, newctx, path):
1030 1030 try:
1031 1031 return ctx[path]
1032 1032 except error.ManifestLookupError:
1033 1033 return None
1034 1034
1035 1035 ui.debug(
1036 1036 b"changing branch of '%s' from '%s' to '%s'\n"
1037 1037 % (hex(ctx.node()), oldbranch, label)
1038 1038 )
1039 1039 extra = ctx.extra()
1040 1040 extra[b'branch_change'] = hex(ctx.node())
1041 1041 # While changing branch of set of linear commits, make sure that
1042 1042 # we base our commits on new parent rather than old parent which
1043 1043 # was obsoleted while changing the branch
1044 1044 p1 = ctx.p1().node()
1045 1045 p2 = ctx.p2().node()
1046 1046 if p1 in replacements:
1047 1047 p1 = replacements[p1][0]
1048 1048 if p2 in replacements:
1049 1049 p2 = replacements[p2][0]
1050 1050
1051 1051 mc = context.memctx(
1052 1052 repo,
1053 1053 (p1, p2),
1054 1054 ctx.description(),
1055 1055 ctx.files(),
1056 1056 filectxfn,
1057 1057 user=ctx.user(),
1058 1058 date=ctx.date(),
1059 1059 extra=extra,
1060 1060 branch=label,
1061 1061 )
1062 1062
1063 1063 newnode = repo.commitctx(mc)
1064 1064 replacements[ctx.node()] = (newnode,)
1065 1065 ui.debug(b'new node id is %s\n' % hex(newnode))
1066 1066
1067 1067 # create obsmarkers and move bookmarks
1068 1068 scmutil.cleanupnodes(
1069 1069 repo, replacements, b'branch-change', fixphase=True
1070 1070 )
1071 1071
1072 1072 # move the working copy too
1073 1073 wctx = repo[None]
1074 1074 # in-progress merge is a bit too complex for now.
1075 1075 if len(wctx.parents()) == 1:
1076 1076 newid = replacements.get(wctx.p1().node())
1077 1077 if newid is not None:
1078 1078 # avoid import cycle mercurial.cmdutil -> mercurial.hg ->
1079 1079 # mercurial.cmdutil
1080 1080 from . import hg
1081 1081
1082 1082 hg.update(repo, newid[0], quietempty=True)
1083 1083
1084 1084 ui.status(_(b"changed branch on %d changesets\n") % len(replacements))
1085 1085
1086 1086
1087 1087 def findrepo(p):
1088 1088 while not os.path.isdir(os.path.join(p, b".hg")):
1089 1089 oldp, p = p, os.path.dirname(p)
1090 1090 if p == oldp:
1091 1091 return None
1092 1092
1093 1093 return p
1094 1094
1095 1095
1096 1096 def bailifchanged(repo, merge=True, hint=None):
1097 1097 """enforce the precondition that working directory must be clean.
1098 1098
1099 1099 'merge' can be set to false if a pending uncommitted merge should be
1100 1100 ignored (such as when 'update --check' runs).
1101 1101
1102 1102 'hint' is the usual hint given to Abort exception.
1103 1103 """
1104 1104
1105 1105 if merge and repo.dirstate.p2() != repo.nullid:
1106 1106 raise error.StateError(_(b'outstanding uncommitted merge'), hint=hint)
1107 1107 st = repo.status()
1108 1108 if st.modified or st.added or st.removed or st.deleted:
1109 1109 raise error.StateError(_(b'uncommitted changes'), hint=hint)
1110 1110 ctx = repo[None]
1111 1111 for s in sorted(ctx.substate):
1112 1112 ctx.sub(s).bailifchanged(hint=hint)
1113 1113
1114 1114
1115 1115 def logmessage(ui, opts):
1116 1116 """get the log message according to -m and -l option"""
1117 1117
1118 1118 check_at_most_one_arg(opts, b'message', b'logfile')
1119 1119
1120 1120 message = opts.get(b'message')
1121 1121 logfile = opts.get(b'logfile')
1122 1122
1123 1123 if not message and logfile:
1124 1124 try:
1125 1125 if isstdiofilename(logfile):
1126 1126 message = ui.fin.read()
1127 1127 else:
1128 1128 message = b'\n'.join(util.readfile(logfile).splitlines())
1129 1129 except IOError as inst:
1130 1130 raise error.Abort(
1131 1131 _(b"can't read commit message '%s': %s")
1132 1132 % (logfile, encoding.strtolocal(inst.strerror))
1133 1133 )
1134 1134 return message
1135 1135
1136 1136
1137 1137 def mergeeditform(ctxorbool, baseformname):
1138 1138 """return appropriate editform name (referencing a committemplate)
1139 1139
1140 1140 'ctxorbool' is either a ctx to be committed, or a bool indicating whether
1141 1141 merging is committed.
1142 1142
1143 1143 This returns baseformname with '.merge' appended if it is a merge,
1144 1144 otherwise '.normal' is appended.
1145 1145 """
1146 1146 if isinstance(ctxorbool, bool):
1147 1147 if ctxorbool:
1148 1148 return baseformname + b".merge"
1149 1149 elif len(ctxorbool.parents()) > 1:
1150 1150 return baseformname + b".merge"
1151 1151
1152 1152 return baseformname + b".normal"
1153 1153
1154 1154
1155 1155 def getcommiteditor(
1156 1156 edit=False, finishdesc=None, extramsg=None, editform=b'', **opts
1157 1157 ):
1158 1158 """get appropriate commit message editor according to '--edit' option
1159 1159
1160 1160 'finishdesc' is a function to be called with edited commit message
1161 1161 (= 'description' of the new changeset) just after editing, but
1162 1162 before checking empty-ness. It should return actual text to be
1163 1163 stored into history. This allows to change description before
1164 1164 storing.
1165 1165
1166 1166 'extramsg' is a extra message to be shown in the editor instead of
1167 1167 'Leave message empty to abort commit' line. 'HG: ' prefix and EOL
1168 1168 is automatically added.
1169 1169
1170 1170 'editform' is a dot-separated list of names, to distinguish
1171 1171 the purpose of commit text editing.
1172 1172
1173 1173 'getcommiteditor' returns 'commitforceeditor' regardless of
1174 1174 'edit', if one of 'finishdesc' or 'extramsg' is specified, because
1175 1175 they are specific for usage in MQ.
1176 1176 """
1177 1177 if edit or finishdesc or extramsg:
1178 1178 return lambda r, c, s: commitforceeditor(
1179 1179 r, c, s, finishdesc=finishdesc, extramsg=extramsg, editform=editform
1180 1180 )
1181 1181 elif editform:
1182 1182 return lambda r, c, s: commiteditor(r, c, s, editform=editform)
1183 1183 else:
1184 1184 return commiteditor
1185 1185
1186 1186
1187 1187 def _escapecommandtemplate(tmpl):
1188 1188 parts = []
1189 1189 for typ, start, end in templater.scantemplate(tmpl, raw=True):
1190 1190 if typ == b'string':
1191 1191 parts.append(stringutil.escapestr(tmpl[start:end]))
1192 1192 else:
1193 1193 parts.append(tmpl[start:end])
1194 1194 return b''.join(parts)
1195 1195
1196 1196
1197 1197 def rendercommandtemplate(ui, tmpl, props):
1198 1198 r"""Expand a literal template 'tmpl' in a way suitable for command line
1199 1199
1200 1200 '\' in outermost string is not taken as an escape character because it
1201 1201 is a directory separator on Windows.
1202 1202
1203 1203 >>> from . import ui as uimod
1204 1204 >>> ui = uimod.ui()
1205 1205 >>> rendercommandtemplate(ui, b'c:\\{path}', {b'path': b'foo'})
1206 1206 'c:\\foo'
1207 1207 >>> rendercommandtemplate(ui, b'{"c:\\{path}"}', {'path': b'foo'})
1208 1208 'c:{path}'
1209 1209 """
1210 1210 if not tmpl:
1211 1211 return tmpl
1212 1212 t = formatter.maketemplater(ui, _escapecommandtemplate(tmpl))
1213 1213 return t.renderdefault(props)
1214 1214
1215 1215
1216 1216 def rendertemplate(ctx, tmpl, props=None):
1217 1217 """Expand a literal template 'tmpl' byte-string against one changeset
1218 1218
1219 1219 Each props item must be a stringify-able value or a callable returning
1220 1220 such value, i.e. no bare list nor dict should be passed.
1221 1221 """
1222 1222 repo = ctx.repo()
1223 1223 tres = formatter.templateresources(repo.ui, repo)
1224 1224 t = formatter.maketemplater(
1225 1225 repo.ui, tmpl, defaults=templatekw.keywords, resources=tres
1226 1226 )
1227 1227 mapping = {b'ctx': ctx}
1228 1228 if props:
1229 1229 mapping.update(props)
1230 1230 return t.renderdefault(mapping)
1231 1231
1232 1232
1233 1233 def format_changeset_summary(ui, ctx, command=None, default_spec=None):
1234 1234 """Format a changeset summary (one line)."""
1235 1235 spec = None
1236 1236 if command:
1237 1237 spec = ui.config(
1238 1238 b'command-templates', b'oneline-summary.%s' % command, None
1239 1239 )
1240 1240 if not spec:
1241 1241 spec = ui.config(b'command-templates', b'oneline-summary')
1242 1242 if not spec:
1243 1243 spec = default_spec
1244 1244 if not spec:
1245 1245 spec = (
1246 1246 b'{separate(" ", '
1247 1247 b'label("oneline-summary.changeset", "{rev}:{node|short}")'
1248 1248 b', '
1249 1249 b'join(filter(namespaces % "{ifeq(namespace, "branches", "", join(names % "{label("oneline-summary.{namespace}", name)}", " "))}"), " ")'
1250 1250 b')} '
1251 1251 b'"{label("oneline-summary.desc", desc|firstline)}"'
1252 1252 )
1253 1253 text = rendertemplate(ctx, spec)
1254 1254 return text.split(b'\n')[0]
1255 1255
1256 1256
1257 1257 def _buildfntemplate(pat, total=None, seqno=None, revwidth=None, pathname=None):
1258 1258 r"""Convert old-style filename format string to template string
1259 1259
1260 1260 >>> _buildfntemplate(b'foo-%b-%n.patch', seqno=0)
1261 1261 'foo-{reporoot|basename}-{seqno}.patch'
1262 1262 >>> _buildfntemplate(b'%R{tags % "{tag}"}%H')
1263 1263 '{rev}{tags % "{tag}"}{node}'
1264 1264
1265 1265 '\' in outermost strings has to be escaped because it is a directory
1266 1266 separator on Windows:
1267 1267
1268 1268 >>> _buildfntemplate(b'c:\\tmp\\%R\\%n.patch', seqno=0)
1269 1269 'c:\\\\tmp\\\\{rev}\\\\{seqno}.patch'
1270 1270 >>> _buildfntemplate(b'\\\\foo\\bar.patch')
1271 1271 '\\\\\\\\foo\\\\bar.patch'
1272 1272 >>> _buildfntemplate(b'\\{tags % "{tag}"}')
1273 1273 '\\\\{tags % "{tag}"}'
1274 1274
1275 1275 but inner strings follow the template rules (i.e. '\' is taken as an
1276 1276 escape character):
1277 1277
1278 1278 >>> _buildfntemplate(br'{"c:\tmp"}', seqno=0)
1279 1279 '{"c:\\tmp"}'
1280 1280 """
1281 1281 expander = {
1282 1282 b'H': b'{node}',
1283 1283 b'R': b'{rev}',
1284 1284 b'h': b'{node|short}',
1285 1285 b'm': br'{sub(r"[^\w]", "_", desc|firstline)}',
1286 1286 b'r': b'{if(revwidth, pad(rev, revwidth, "0", left=True), rev)}',
1287 1287 b'%': b'%',
1288 1288 b'b': b'{reporoot|basename}',
1289 1289 }
1290 1290 if total is not None:
1291 1291 expander[b'N'] = b'{total}'
1292 1292 if seqno is not None:
1293 1293 expander[b'n'] = b'{seqno}'
1294 1294 if total is not None and seqno is not None:
1295 1295 expander[b'n'] = b'{pad(seqno, total|stringify|count, "0", left=True)}'
1296 1296 if pathname is not None:
1297 1297 expander[b's'] = b'{pathname|basename}'
1298 1298 expander[b'd'] = b'{if(pathname|dirname, pathname|dirname, ".")}'
1299 1299 expander[b'p'] = b'{pathname}'
1300 1300
1301 1301 newname = []
1302 1302 for typ, start, end in templater.scantemplate(pat, raw=True):
1303 1303 if typ != b'string':
1304 1304 newname.append(pat[start:end])
1305 1305 continue
1306 1306 i = start
1307 1307 while i < end:
1308 1308 n = pat.find(b'%', i, end)
1309 1309 if n < 0:
1310 1310 newname.append(stringutil.escapestr(pat[i:end]))
1311 1311 break
1312 1312 newname.append(stringutil.escapestr(pat[i:n]))
1313 1313 if n + 2 > end:
1314 1314 raise error.Abort(
1315 1315 _(b"incomplete format spec in output filename")
1316 1316 )
1317 1317 c = pat[n + 1 : n + 2]
1318 1318 i = n + 2
1319 1319 try:
1320 1320 newname.append(expander[c])
1321 1321 except KeyError:
1322 1322 raise error.Abort(
1323 1323 _(b"invalid format spec '%%%s' in output filename") % c
1324 1324 )
1325 1325 return b''.join(newname)
1326 1326
1327 1327
1328 1328 def makefilename(ctx, pat, **props):
1329 1329 if not pat:
1330 1330 return pat
1331 1331 tmpl = _buildfntemplate(pat, **props)
1332 1332 # BUG: alias expansion shouldn't be made against template fragments
1333 1333 # rewritten from %-format strings, but we have no easy way to partially
1334 1334 # disable the expansion.
1335 1335 return rendertemplate(ctx, tmpl, pycompat.byteskwargs(props))
1336 1336
1337 1337
1338 1338 def isstdiofilename(pat):
1339 1339 """True if the given pat looks like a filename denoting stdin/stdout"""
1340 1340 return not pat or pat == b'-'
1341 1341
1342 1342
1343 1343 class _unclosablefile(object):
1344 1344 def __init__(self, fp):
1345 1345 self._fp = fp
1346 1346
1347 1347 def close(self):
1348 1348 pass
1349 1349
1350 1350 def __iter__(self):
1351 1351 return iter(self._fp)
1352 1352
1353 1353 def __getattr__(self, attr):
1354 1354 return getattr(self._fp, attr)
1355 1355
1356 1356 def __enter__(self):
1357 1357 return self
1358 1358
1359 1359 def __exit__(self, exc_type, exc_value, exc_tb):
1360 1360 pass
1361 1361
1362 1362
1363 1363 def makefileobj(ctx, pat, mode=b'wb', **props):
1364 1364 writable = mode not in (b'r', b'rb')
1365 1365
1366 1366 if isstdiofilename(pat):
1367 1367 repo = ctx.repo()
1368 1368 if writable:
1369 1369 fp = repo.ui.fout
1370 1370 else:
1371 1371 fp = repo.ui.fin
1372 1372 return _unclosablefile(fp)
1373 1373 fn = makefilename(ctx, pat, **props)
1374 1374 return open(fn, mode)
1375 1375
1376 1376
1377 1377 def openstorage(repo, cmd, file_, opts, returnrevlog=False):
1378 1378 """opens the changelog, manifest, a filelog or a given revlog"""
1379 1379 cl = opts[b'changelog']
1380 1380 mf = opts[b'manifest']
1381 1381 dir = opts[b'dir']
1382 1382 msg = None
1383 1383 if cl and mf:
1384 1384 msg = _(b'cannot specify --changelog and --manifest at the same time')
1385 1385 elif cl and dir:
1386 1386 msg = _(b'cannot specify --changelog and --dir at the same time')
1387 1387 elif cl or mf or dir:
1388 1388 if file_:
1389 1389 msg = _(b'cannot specify filename with --changelog or --manifest')
1390 1390 elif not repo:
1391 1391 msg = _(
1392 1392 b'cannot specify --changelog or --manifest or --dir '
1393 1393 b'without a repository'
1394 1394 )
1395 1395 if msg:
1396 1396 raise error.InputError(msg)
1397 1397
1398 1398 r = None
1399 1399 if repo:
1400 1400 if cl:
1401 1401 r = repo.unfiltered().changelog
1402 1402 elif dir:
1403 1403 if not scmutil.istreemanifest(repo):
1404 1404 raise error.InputError(
1405 1405 _(
1406 1406 b"--dir can only be used on repos with "
1407 1407 b"treemanifest enabled"
1408 1408 )
1409 1409 )
1410 1410 if not dir.endswith(b'/'):
1411 1411 dir = dir + b'/'
1412 1412 dirlog = repo.manifestlog.getstorage(dir)
1413 1413 if len(dirlog):
1414 1414 r = dirlog
1415 1415 elif mf:
1416 1416 r = repo.manifestlog.getstorage(b'')
1417 1417 elif file_:
1418 1418 filelog = repo.file(file_)
1419 1419 if len(filelog):
1420 1420 r = filelog
1421 1421
1422 1422 # Not all storage may be revlogs. If requested, try to return an actual
1423 1423 # revlog instance.
1424 1424 if returnrevlog:
1425 1425 if isinstance(r, revlog.revlog):
1426 1426 pass
1427 1427 elif util.safehasattr(r, b'_revlog'):
1428 1428 r = r._revlog # pytype: disable=attribute-error
1429 1429 elif r is not None:
1430 1430 raise error.InputError(
1431 1431 _(b'%r does not appear to be a revlog') % r
1432 1432 )
1433 1433
1434 1434 if not r:
1435 1435 if not returnrevlog:
1436 1436 raise error.InputError(_(b'cannot give path to non-revlog'))
1437 1437
1438 1438 if not file_:
1439 1439 raise error.CommandError(cmd, _(b'invalid arguments'))
1440 1440 if not os.path.isfile(file_):
1441 1441 raise error.InputError(_(b"revlog '%s' not found") % file_)
1442 1442
1443 1443 target = (revlog_constants.KIND_OTHER, b'free-form:%s' % file_)
1444 1444 r = revlog.revlog(
1445 1445 vfsmod.vfs(encoding.getcwd(), audit=False),
1446 1446 target=target,
1447 1447 radix=file_[:-2],
1448 1448 )
1449 1449 return r
1450 1450
1451 1451
1452 1452 def openrevlog(repo, cmd, file_, opts):
1453 1453 """Obtain a revlog backing storage of an item.
1454 1454
1455 1455 This is similar to ``openstorage()`` except it always returns a revlog.
1456 1456
1457 1457 In most cases, a caller cares about the main storage object - not the
1458 1458 revlog backing it. Therefore, this function should only be used by code
1459 1459 that needs to examine low-level revlog implementation details. e.g. debug
1460 1460 commands.
1461 1461 """
1462 1462 return openstorage(repo, cmd, file_, opts, returnrevlog=True)
1463 1463
1464 1464
1465 1465 def copy(ui, repo, pats, opts, rename=False):
1466 1466 check_incompatible_arguments(opts, b'forget', [b'dry_run'])
1467 1467
1468 1468 # called with the repo lock held
1469 1469 #
1470 1470 # hgsep => pathname that uses "/" to separate directories
1471 1471 # ossep => pathname that uses os.sep to separate directories
1472 1472 cwd = repo.getcwd()
1473 1473 targets = {}
1474 1474 forget = opts.get(b"forget")
1475 1475 after = opts.get(b"after")
1476 1476 dryrun = opts.get(b"dry_run")
1477 1477 rev = opts.get(b'at_rev')
1478 1478 if rev:
1479 1479 if not forget and not after:
1480 1480 # TODO: Remove this restriction and make it also create the copy
1481 1481 # targets (and remove the rename source if rename==True).
1482 1482 raise error.InputError(_(b'--at-rev requires --after'))
1483 1483 ctx = scmutil.revsingle(repo, rev)
1484 1484 if len(ctx.parents()) > 1:
1485 1485 raise error.InputError(
1486 1486 _(b'cannot mark/unmark copy in merge commit')
1487 1487 )
1488 1488 else:
1489 1489 ctx = repo[None]
1490 1490
1491 1491 pctx = ctx.p1()
1492 1492
1493 1493 uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)
1494 1494
1495 1495 if forget:
1496 1496 if ctx.rev() is None:
1497 1497 new_ctx = ctx
1498 1498 else:
1499 1499 if len(ctx.parents()) > 1:
1500 1500 raise error.InputError(_(b'cannot unmark copy in merge commit'))
1501 1501 # avoid cycle context -> subrepo -> cmdutil
1502 1502 from . import context
1503 1503
1504 1504 rewriteutil.precheck(repo, [ctx.rev()], b'uncopy')
1505 1505 new_ctx = context.overlayworkingctx(repo)
1506 1506 new_ctx.setbase(ctx.p1())
1507 1507 mergemod.graft(repo, ctx, wctx=new_ctx)
1508 1508
1509 1509 match = scmutil.match(ctx, pats, opts)
1510 1510
1511 1511 current_copies = ctx.p1copies()
1512 1512 current_copies.update(ctx.p2copies())
1513 1513
1514 1514 uipathfn = scmutil.getuipathfn(repo)
1515 1515 for f in ctx.walk(match):
1516 1516 if f in current_copies:
1517 1517 new_ctx[f].markcopied(None)
1518 1518 elif match.exact(f):
1519 1519 ui.warn(
1520 1520 _(
1521 1521 b'%s: not unmarking as copy - file is not marked as copied\n'
1522 1522 )
1523 1523 % uipathfn(f)
1524 1524 )
1525 1525
1526 1526 if ctx.rev() is not None:
1527 1527 with repo.lock():
1528 1528 mem_ctx = new_ctx.tomemctx_for_amend(ctx)
1529 1529 new_node = mem_ctx.commit()
1530 1530
1531 1531 if repo.dirstate.p1() == ctx.node():
1532 1532 with repo.dirstate.parentchange():
1533 1533 scmutil.movedirstate(repo, repo[new_node])
1534 1534 replacements = {ctx.node(): [new_node]}
1535 1535 scmutil.cleanupnodes(
1536 1536 repo, replacements, b'uncopy', fixphase=True
1537 1537 )
1538 1538
1539 1539 return
1540 1540
1541 1541 pats = scmutil.expandpats(pats)
1542 1542 if not pats:
1543 1543 raise error.InputError(_(b'no source or destination specified'))
1544 1544 if len(pats) == 1:
1545 1545 raise error.InputError(_(b'no destination specified'))
1546 1546 dest = pats.pop()
1547 1547
1548 1548 def walkpat(pat):
1549 1549 srcs = []
1550 1550 # TODO: Inline and simplify the non-working-copy version of this code
1551 1551 # since it shares very little with the working-copy version of it.
1552 1552 ctx_to_walk = ctx if ctx.rev() is None else pctx
1553 1553 m = scmutil.match(ctx_to_walk, [pat], opts, globbed=True)
1554 1554 for abs in ctx_to_walk.walk(m):
1555 1555 rel = uipathfn(abs)
1556 1556 exact = m.exact(abs)
1557 1557 if abs not in ctx:
1558 1558 if abs in pctx:
1559 1559 if not after:
1560 1560 if exact:
1561 1561 ui.warn(
1562 1562 _(
1563 1563 b'%s: not copying - file has been marked '
1564 1564 b'for remove\n'
1565 1565 )
1566 1566 % rel
1567 1567 )
1568 1568 continue
1569 1569 else:
1570 1570 if exact:
1571 1571 ui.warn(
1572 1572 _(b'%s: not copying - file is not managed\n') % rel
1573 1573 )
1574 1574 continue
1575 1575
1576 1576 # abs: hgsep
1577 1577 # rel: ossep
1578 1578 srcs.append((abs, rel, exact))
1579 1579 return srcs
1580 1580
1581 1581 if ctx.rev() is not None:
1582 1582 rewriteutil.precheck(repo, [ctx.rev()], b'uncopy')
1583 1583 absdest = pathutil.canonpath(repo.root, cwd, dest)
1584 1584 if ctx.hasdir(absdest):
1585 1585 raise error.InputError(
1586 1586 _(b'%s: --at-rev does not support a directory as destination')
1587 1587 % uipathfn(absdest)
1588 1588 )
1589 1589 if absdest not in ctx:
1590 1590 raise error.InputError(
1591 1591 _(b'%s: copy destination does not exist in %s')
1592 1592 % (uipathfn(absdest), ctx)
1593 1593 )
1594 1594
1595 1595 # avoid cycle context -> subrepo -> cmdutil
1596 1596 from . import context
1597 1597
1598 1598 copylist = []
1599 1599 for pat in pats:
1600 1600 srcs = walkpat(pat)
1601 1601 if not srcs:
1602 1602 continue
1603 1603 for abs, rel, exact in srcs:
1604 1604 copylist.append(abs)
1605 1605
1606 1606 if not copylist:
1607 1607 raise error.InputError(_(b'no files to copy'))
1608 1608 # TODO: Add support for `hg cp --at-rev . foo bar dir` and
1609 1609 # `hg cp --at-rev . dir1 dir2`, preferably unifying the code with the
1610 1610 # existing functions below.
1611 1611 if len(copylist) != 1:
1612 1612 raise error.InputError(_(b'--at-rev requires a single source'))
1613 1613
1614 1614 new_ctx = context.overlayworkingctx(repo)
1615 1615 new_ctx.setbase(ctx.p1())
1616 1616 mergemod.graft(repo, ctx, wctx=new_ctx)
1617 1617
1618 1618 new_ctx.markcopied(absdest, copylist[0])
1619 1619
1620 1620 with repo.lock():
1621 1621 mem_ctx = new_ctx.tomemctx_for_amend(ctx)
1622 1622 new_node = mem_ctx.commit()
1623 1623
1624 1624 if repo.dirstate.p1() == ctx.node():
1625 1625 with repo.dirstate.parentchange():
1626 1626 scmutil.movedirstate(repo, repo[new_node])
1627 1627 replacements = {ctx.node(): [new_node]}
1628 1628 scmutil.cleanupnodes(repo, replacements, b'copy', fixphase=True)
1629 1629
1630 1630 return
1631 1631
1632 1632 # abssrc: hgsep
1633 1633 # relsrc: ossep
1634 1634 # otarget: ossep
1635 1635 def copyfile(abssrc, relsrc, otarget, exact):
1636 1636 abstarget = pathutil.canonpath(repo.root, cwd, otarget)
1637 1637 if b'/' in abstarget:
1638 1638 # We cannot normalize abstarget itself, this would prevent
1639 1639 # case only renames, like a => A.
1640 1640 abspath, absname = abstarget.rsplit(b'/', 1)
1641 1641 abstarget = repo.dirstate.normalize(abspath) + b'/' + absname
1642 1642 reltarget = repo.pathto(abstarget, cwd)
1643 1643 target = repo.wjoin(abstarget)
1644 1644 src = repo.wjoin(abssrc)
1645 1645 entry = repo.dirstate.get_entry(abstarget)
1646 1646
1647 1647 already_commited = entry.tracked and not entry.added
1648 1648
1649 1649 scmutil.checkportable(ui, abstarget)
1650 1650
1651 1651 # check for collisions
1652 1652 prevsrc = targets.get(abstarget)
1653 1653 if prevsrc is not None:
1654 1654 ui.warn(
1655 1655 _(b'%s: not overwriting - %s collides with %s\n')
1656 1656 % (
1657 1657 reltarget,
1658 1658 repo.pathto(abssrc, cwd),
1659 1659 repo.pathto(prevsrc, cwd),
1660 1660 )
1661 1661 )
1662 1662 return True # report a failure
1663 1663
1664 1664 # check for overwrites
1665 1665 exists = os.path.lexists(target)
1666 1666 samefile = False
1667 1667 if exists and abssrc != abstarget:
1668 1668 if repo.dirstate.normalize(abssrc) == repo.dirstate.normalize(
1669 1669 abstarget
1670 1670 ):
1671 1671 if not rename:
1672 1672 ui.warn(_(b"%s: can't copy - same file\n") % reltarget)
1673 1673 return True # report a failure
1674 1674 exists = False
1675 1675 samefile = True
1676 1676
1677 1677 if not after and exists or after and already_commited:
1678 1678 if not opts[b'force']:
1679 1679 if already_commited:
1680 1680 msg = _(b'%s: not overwriting - file already committed\n')
1681 1681 if after:
1682 1682 flags = b'--after --force'
1683 1683 else:
1684 1684 flags = b'--force'
1685 1685 if rename:
1686 1686 hint = (
1687 1687 _(
1688 1688 b"('hg rename %s' to replace the file by "
1689 1689 b'recording a rename)\n'
1690 1690 )
1691 1691 % flags
1692 1692 )
1693 1693 else:
1694 1694 hint = (
1695 1695 _(
1696 1696 b"('hg copy %s' to replace the file by "
1697 1697 b'recording a copy)\n'
1698 1698 )
1699 1699 % flags
1700 1700 )
1701 1701 else:
1702 1702 msg = _(b'%s: not overwriting - file exists\n')
1703 1703 if rename:
1704 1704 hint = _(
1705 1705 b"('hg rename --after' to record the rename)\n"
1706 1706 )
1707 1707 else:
1708 1708 hint = _(b"('hg copy --after' to record the copy)\n")
1709 1709 ui.warn(msg % reltarget)
1710 1710 ui.warn(hint)
1711 1711 return True # report a failure
1712 1712
1713 1713 if after:
1714 1714 if not exists:
1715 1715 if rename:
1716 1716 ui.warn(
1717 1717 _(b'%s: not recording move - %s does not exist\n')
1718 1718 % (relsrc, reltarget)
1719 1719 )
1720 1720 else:
1721 1721 ui.warn(
1722 1722 _(b'%s: not recording copy - %s does not exist\n')
1723 1723 % (relsrc, reltarget)
1724 1724 )
1725 1725 return True # report a failure
1726 1726 elif not dryrun:
1727 1727 try:
1728 1728 if exists:
1729 1729 os.unlink(target)
1730 1730 targetdir = os.path.dirname(target) or b'.'
1731 1731 if not os.path.isdir(targetdir):
1732 1732 os.makedirs(targetdir)
1733 1733 if samefile:
1734 1734 tmp = target + b"~hgrename"
1735 1735 os.rename(src, tmp)
1736 1736 os.rename(tmp, target)
1737 1737 else:
1738 1738 # Preserve stat info on renames, not on copies; this matches
1739 1739 # Linux CLI behavior.
1740 1740 util.copyfile(src, target, copystat=rename)
1741 1741 srcexists = True
1742 1742 except IOError as inst:
1743 1743 if inst.errno == errno.ENOENT:
1744 1744 ui.warn(_(b'%s: deleted in working directory\n') % relsrc)
1745 1745 srcexists = False
1746 1746 else:
1747 1747 ui.warn(
1748 1748 _(b'%s: cannot copy - %s\n')
1749 1749 % (relsrc, encoding.strtolocal(inst.strerror))
1750 1750 )
1751 1751 return True # report a failure
1752 1752
1753 1753 if ui.verbose or not exact:
1754 1754 if rename:
1755 1755 ui.status(_(b'moving %s to %s\n') % (relsrc, reltarget))
1756 1756 else:
1757 1757 ui.status(_(b'copying %s to %s\n') % (relsrc, reltarget))
1758 1758
1759 1759 targets[abstarget] = abssrc
1760 1760
1761 1761 # fix up dirstate
1762 1762 scmutil.dirstatecopy(
1763 1763 ui, repo, ctx, abssrc, abstarget, dryrun=dryrun, cwd=cwd
1764 1764 )
1765 1765 if rename and not dryrun:
1766 1766 if not after and srcexists and not samefile:
1767 1767 rmdir = repo.ui.configbool(b'experimental', b'removeemptydirs')
1768 1768 repo.wvfs.unlinkpath(abssrc, rmdir=rmdir)
1769 1769 ctx.forget([abssrc])
1770 1770
1771 1771 # pat: ossep
1772 1772 # dest ossep
1773 1773 # srcs: list of (hgsep, hgsep, ossep, bool)
1774 1774 # return: function that takes hgsep and returns ossep
1775 1775 def targetpathfn(pat, dest, srcs):
1776 1776 if os.path.isdir(pat):
1777 1777 abspfx = pathutil.canonpath(repo.root, cwd, pat)
1778 1778 abspfx = util.localpath(abspfx)
1779 1779 if destdirexists:
1780 1780 striplen = len(os.path.split(abspfx)[0])
1781 1781 else:
1782 1782 striplen = len(abspfx)
1783 1783 if striplen:
1784 1784 striplen += len(pycompat.ossep)
1785 1785 res = lambda p: os.path.join(dest, util.localpath(p)[striplen:])
1786 1786 elif destdirexists:
1787 1787 res = lambda p: os.path.join(
1788 1788 dest, os.path.basename(util.localpath(p))
1789 1789 )
1790 1790 else:
1791 1791 res = lambda p: dest
1792 1792 return res
1793 1793
1794 1794 # pat: ossep
1795 1795 # dest ossep
1796 1796 # srcs: list of (hgsep, hgsep, ossep, bool)
1797 1797 # return: function that takes hgsep and returns ossep
1798 1798 def targetpathafterfn(pat, dest, srcs):
1799 1799 if matchmod.patkind(pat):
1800 1800 # a mercurial pattern
1801 1801 res = lambda p: os.path.join(
1802 1802 dest, os.path.basename(util.localpath(p))
1803 1803 )
1804 1804 else:
1805 1805 abspfx = pathutil.canonpath(repo.root, cwd, pat)
1806 1806 if len(abspfx) < len(srcs[0][0]):
1807 1807 # A directory. Either the target path contains the last
1808 1808 # component of the source path or it does not.
1809 1809 def evalpath(striplen):
1810 1810 score = 0
1811 1811 for s in srcs:
1812 1812 t = os.path.join(dest, util.localpath(s[0])[striplen:])
1813 1813 if os.path.lexists(t):
1814 1814 score += 1
1815 1815 return score
1816 1816
1817 1817 abspfx = util.localpath(abspfx)
1818 1818 striplen = len(abspfx)
1819 1819 if striplen:
1820 1820 striplen += len(pycompat.ossep)
1821 1821 if os.path.isdir(os.path.join(dest, os.path.split(abspfx)[1])):
1822 1822 score = evalpath(striplen)
1823 1823 striplen1 = len(os.path.split(abspfx)[0])
1824 1824 if striplen1:
1825 1825 striplen1 += len(pycompat.ossep)
1826 1826 if evalpath(striplen1) > score:
1827 1827 striplen = striplen1
1828 1828 res = lambda p: os.path.join(dest, util.localpath(p)[striplen:])
1829 1829 else:
1830 1830 # a file
1831 1831 if destdirexists:
1832 1832 res = lambda p: os.path.join(
1833 1833 dest, os.path.basename(util.localpath(p))
1834 1834 )
1835 1835 else:
1836 1836 res = lambda p: dest
1837 1837 return res
1838 1838
1839 1839 destdirexists = os.path.isdir(dest) and not os.path.islink(dest)
1840 1840 if not destdirexists:
1841 1841 if len(pats) > 1 or matchmod.patkind(pats[0]):
1842 1842 raise error.InputError(
1843 1843 _(
1844 1844 b'with multiple sources, destination must be an '
1845 1845 b'existing directory'
1846 1846 )
1847 1847 )
1848 1848 if util.endswithsep(dest):
1849 1849 raise error.InputError(
1850 1850 _(b'destination %s is not a directory') % dest
1851 1851 )
1852 1852
1853 1853 tfn = targetpathfn
1854 1854 if after:
1855 1855 tfn = targetpathafterfn
1856 1856 copylist = []
1857 1857 for pat in pats:
1858 1858 srcs = walkpat(pat)
1859 1859 if not srcs:
1860 1860 continue
1861 1861 copylist.append((tfn(pat, dest, srcs), srcs))
1862 1862 if not copylist:
1863 1863 hint = None
1864 1864 if rename:
1865 1865 hint = _(b'maybe you meant to use --after --at-rev=.')
1866 1866 raise error.InputError(_(b'no files to copy'), hint=hint)
1867 1867
1868 1868 errors = 0
1869 1869 for targetpath, srcs in copylist:
1870 1870 for abssrc, relsrc, exact in srcs:
1871 1871 if copyfile(abssrc, relsrc, targetpath(abssrc), exact):
1872 1872 errors += 1
1873 1873
1874 1874 return errors != 0
1875 1875
1876 1876
1877 1877 ## facility to let extension process additional data into an import patch
1878 1878 # list of identifier to be executed in order
1879 1879 extrapreimport = [] # run before commit
1880 1880 extrapostimport = [] # run after commit
1881 1881 # mapping from identifier to actual import function
1882 1882 #
1883 1883 # 'preimport' are run before the commit is made and are provided the following
1884 1884 # arguments:
1885 1885 # - repo: the localrepository instance,
1886 1886 # - patchdata: data extracted from patch header (cf m.patch.patchheadermap),
1887 1887 # - extra: the future extra dictionary of the changeset, please mutate it,
1888 1888 # - opts: the import options.
1889 1889 # XXX ideally, we would just pass an ctx ready to be computed, that would allow
1890 1890 # mutation of in memory commit and more. Feel free to rework the code to get
1891 1891 # there.
1892 1892 extrapreimportmap = {}
1893 1893 # 'postimport' are run after the commit is made and are provided the following
1894 1894 # argument:
1895 1895 # - ctx: the changectx created by import.
1896 1896 extrapostimportmap = {}
1897 1897
1898 1898
1899 1899 def tryimportone(ui, repo, patchdata, parents, opts, msgs, updatefunc):
1900 1900 """Utility function used by commands.import to import a single patch
1901 1901
1902 1902 This function is explicitly defined here to help the evolve extension to
1903 1903 wrap this part of the import logic.
1904 1904
1905 1905 The API is currently a bit ugly because it a simple code translation from
1906 1906 the import command. Feel free to make it better.
1907 1907
1908 1908 :patchdata: a dictionary containing parsed patch data (such as from
1909 1909 ``patch.extract()``)
1910 1910 :parents: nodes that will be parent of the created commit
1911 1911 :opts: the full dict of option passed to the import command
1912 1912 :msgs: list to save commit message to.
1913 1913 (used in case we need to save it when failing)
1914 1914 :updatefunc: a function that update a repo to a given node
1915 1915 updatefunc(<repo>, <node>)
1916 1916 """
1917 1917 # avoid cycle context -> subrepo -> cmdutil
1918 1918 from . import context
1919 1919
1920 1920 tmpname = patchdata.get(b'filename')
1921 1921 message = patchdata.get(b'message')
1922 1922 user = opts.get(b'user') or patchdata.get(b'user')
1923 1923 date = opts.get(b'date') or patchdata.get(b'date')
1924 1924 branch = patchdata.get(b'branch')
1925 1925 nodeid = patchdata.get(b'nodeid')
1926 1926 p1 = patchdata.get(b'p1')
1927 1927 p2 = patchdata.get(b'p2')
1928 1928
1929 1929 nocommit = opts.get(b'no_commit')
1930 1930 importbranch = opts.get(b'import_branch')
1931 1931 update = not opts.get(b'bypass')
1932 1932 strip = opts[b"strip"]
1933 1933 prefix = opts[b"prefix"]
1934 1934 sim = float(opts.get(b'similarity') or 0)
1935 1935
1936 1936 if not tmpname:
1937 1937 return None, None, False
1938 1938
1939 1939 rejects = False
1940 1940
1941 1941 cmdline_message = logmessage(ui, opts)
1942 1942 if cmdline_message:
1943 1943 # pickup the cmdline msg
1944 1944 message = cmdline_message
1945 1945 elif message:
1946 1946 # pickup the patch msg
1947 1947 message = message.strip()
1948 1948 else:
1949 1949 # launch the editor
1950 1950 message = None
1951 1951 ui.debug(b'message:\n%s\n' % (message or b''))
1952 1952
1953 1953 if len(parents) == 1:
1954 1954 parents.append(repo[nullrev])
1955 1955 if opts.get(b'exact'):
1956 1956 if not nodeid or not p1:
1957 1957 raise error.InputError(_(b'not a Mercurial patch'))
1958 1958 p1 = repo[p1]
1959 1959 p2 = repo[p2 or nullrev]
1960 1960 elif p2:
1961 1961 try:
1962 1962 p1 = repo[p1]
1963 1963 p2 = repo[p2]
1964 1964 # Without any options, consider p2 only if the
1965 1965 # patch is being applied on top of the recorded
1966 1966 # first parent.
1967 1967 if p1 != parents[0]:
1968 1968 p1 = parents[0]
1969 1969 p2 = repo[nullrev]
1970 1970 except error.RepoError:
1971 1971 p1, p2 = parents
1972 1972 if p2.rev() == nullrev:
1973 1973 ui.warn(
1974 1974 _(
1975 1975 b"warning: import the patch as a normal revision\n"
1976 1976 b"(use --exact to import the patch as a merge)\n"
1977 1977 )
1978 1978 )
1979 1979 else:
1980 1980 p1, p2 = parents
1981 1981
1982 1982 n = None
1983 1983 if update:
1984 1984 if p1 != parents[0]:
1985 1985 updatefunc(repo, p1.node())
1986 1986 if p2 != parents[1]:
1987 1987 repo.setparents(p1.node(), p2.node())
1988 1988
1989 1989 if opts.get(b'exact') or importbranch:
1990 1990 repo.dirstate.setbranch(branch or b'default')
1991 1991
1992 1992 partial = opts.get(b'partial', False)
1993 1993 files = set()
1994 1994 try:
1995 1995 patch.patch(
1996 1996 ui,
1997 1997 repo,
1998 1998 tmpname,
1999 1999 strip=strip,
2000 2000 prefix=prefix,
2001 2001 files=files,
2002 2002 eolmode=None,
2003 2003 similarity=sim / 100.0,
2004 2004 )
2005 2005 except error.PatchError as e:
2006 2006 if not partial:
2007 2007 raise error.Abort(pycompat.bytestr(e))
2008 2008 if partial:
2009 2009 rejects = True
2010 2010
2011 2011 files = list(files)
2012 2012 if nocommit:
2013 2013 if message:
2014 2014 msgs.append(message)
2015 2015 else:
2016 2016 if opts.get(b'exact') or p2:
2017 2017 # If you got here, you either use --force and know what
2018 2018 # you are doing or used --exact or a merge patch while
2019 2019 # being updated to its first parent.
2020 2020 m = None
2021 2021 else:
2022 2022 m = scmutil.matchfiles(repo, files or [])
2023 2023 editform = mergeeditform(repo[None], b'import.normal')
2024 2024 if opts.get(b'exact'):
2025 2025 editor = None
2026 2026 else:
2027 2027 editor = getcommiteditor(
2028 2028 editform=editform, **pycompat.strkwargs(opts)
2029 2029 )
2030 2030 extra = {}
2031 2031 for idfunc in extrapreimport:
2032 2032 extrapreimportmap[idfunc](repo, patchdata, extra, opts)
2033 2033 overrides = {}
2034 2034 if partial:
2035 2035 overrides[(b'ui', b'allowemptycommit')] = True
2036 2036 if opts.get(b'secret'):
2037 2037 overrides[(b'phases', b'new-commit')] = b'secret'
2038 2038 with repo.ui.configoverride(overrides, b'import'):
2039 2039 n = repo.commit(
2040 2040 message, user, date, match=m, editor=editor, extra=extra
2041 2041 )
2042 2042 for idfunc in extrapostimport:
2043 2043 extrapostimportmap[idfunc](repo[n])
2044 2044 else:
2045 2045 if opts.get(b'exact') or importbranch:
2046 2046 branch = branch or b'default'
2047 2047 else:
2048 2048 branch = p1.branch()
2049 2049 store = patch.filestore()
2050 2050 try:
2051 2051 files = set()
2052 2052 try:
2053 2053 patch.patchrepo(
2054 2054 ui,
2055 2055 repo,
2056 2056 p1,
2057 2057 store,
2058 2058 tmpname,
2059 2059 strip,
2060 2060 prefix,
2061 2061 files,
2062 2062 eolmode=None,
2063 2063 )
2064 2064 except error.PatchError as e:
2065 2065 raise error.Abort(stringutil.forcebytestr(e))
2066 2066 if opts.get(b'exact'):
2067 2067 editor = None
2068 2068 else:
2069 2069 editor = getcommiteditor(editform=b'import.bypass')
2070 2070 memctx = context.memctx(
2071 2071 repo,
2072 2072 (p1.node(), p2.node()),
2073 2073 message,
2074 2074 files=files,
2075 2075 filectxfn=store,
2076 2076 user=user,
2077 2077 date=date,
2078 2078 branch=branch,
2079 2079 editor=editor,
2080 2080 )
2081 2081
2082 2082 overrides = {}
2083 2083 if opts.get(b'secret'):
2084 2084 overrides[(b'phases', b'new-commit')] = b'secret'
2085 2085 with repo.ui.configoverride(overrides, b'import'):
2086 2086 n = memctx.commit()
2087 2087 finally:
2088 2088 store.close()
2089 2089 if opts.get(b'exact') and nocommit:
2090 2090 # --exact with --no-commit is still useful in that it does merge
2091 2091 # and branch bits
2092 2092 ui.warn(_(b"warning: can't check exact import with --no-commit\n"))
2093 2093 elif opts.get(b'exact') and (not n or hex(n) != nodeid):
2094 2094 raise error.Abort(_(b'patch is damaged or loses information'))
2095 2095 msg = _(b'applied to working directory')
2096 2096 if n:
2097 2097 # i18n: refers to a short changeset id
2098 2098 msg = _(b'created %s') % short(n)
2099 2099 return msg, n, rejects
2100 2100
2101 2101
2102 2102 # facility to let extensions include additional data in an exported patch
2103 2103 # list of identifiers to be executed in order
2104 2104 extraexport = []
2105 2105 # mapping from identifier to actual export function
2106 2106 # function as to return a string to be added to the header or None
2107 2107 # it is given two arguments (sequencenumber, changectx)
2108 2108 extraexportmap = {}
2109 2109
2110 2110
2111 2111 def _exportsingle(repo, ctx, fm, match, switch_parent, seqno, diffopts):
2112 2112 node = scmutil.binnode(ctx)
2113 2113 parents = [p.node() for p in ctx.parents() if p]
2114 2114 branch = ctx.branch()
2115 2115 if switch_parent:
2116 2116 parents.reverse()
2117 2117
2118 2118 if parents:
2119 2119 prev = parents[0]
2120 2120 else:
2121 2121 prev = repo.nullid
2122 2122
2123 2123 fm.context(ctx=ctx)
2124 2124 fm.plain(b'# HG changeset patch\n')
2125 2125 fm.write(b'user', b'# User %s\n', ctx.user())
2126 2126 fm.plain(b'# Date %d %d\n' % ctx.date())
2127 2127 fm.write(b'date', b'# %s\n', fm.formatdate(ctx.date()))
2128 2128 fm.condwrite(
2129 2129 branch and branch != b'default', b'branch', b'# Branch %s\n', branch
2130 2130 )
2131 2131 fm.write(b'node', b'# Node ID %s\n', hex(node))
2132 2132 fm.plain(b'# Parent %s\n' % hex(prev))
2133 2133 if len(parents) > 1:
2134 2134 fm.plain(b'# Parent %s\n' % hex(parents[1]))
2135 2135 fm.data(parents=fm.formatlist(pycompat.maplist(hex, parents), name=b'node'))
2136 2136
2137 2137 # TODO: redesign extraexportmap function to support formatter
2138 2138 for headerid in extraexport:
2139 2139 header = extraexportmap[headerid](seqno, ctx)
2140 2140 if header is not None:
2141 2141 fm.plain(b'# %s\n' % header)
2142 2142
2143 2143 fm.write(b'desc', b'%s\n', ctx.description().rstrip())
2144 2144 fm.plain(b'\n')
2145 2145
2146 2146 if fm.isplain():
2147 2147 chunkiter = patch.diffui(repo, prev, node, match, opts=diffopts)
2148 2148 for chunk, label in chunkiter:
2149 2149 fm.plain(chunk, label=label)
2150 2150 else:
2151 2151 chunkiter = patch.diff(repo, prev, node, match, opts=diffopts)
2152 2152 # TODO: make it structured?
2153 2153 fm.data(diff=b''.join(chunkiter))
2154 2154
2155 2155
2156 2156 def _exportfile(repo, revs, fm, dest, switch_parent, diffopts, match):
2157 2157 """Export changesets to stdout or a single file"""
2158 2158 for seqno, rev in enumerate(revs, 1):
2159 2159 ctx = repo[rev]
2160 2160 if not dest.startswith(b'<'):
2161 2161 repo.ui.note(b"%s\n" % dest)
2162 2162 fm.startitem()
2163 2163 _exportsingle(repo, ctx, fm, match, switch_parent, seqno, diffopts)
2164 2164
2165 2165
2166 2166 def _exportfntemplate(
2167 2167 repo, revs, basefm, fntemplate, switch_parent, diffopts, match
2168 2168 ):
2169 2169 """Export changesets to possibly multiple files"""
2170 2170 total = len(revs)
2171 2171 revwidth = max(len(str(rev)) for rev in revs)
2172 2172 filemap = util.sortdict() # filename: [(seqno, rev), ...]
2173 2173
2174 2174 for seqno, rev in enumerate(revs, 1):
2175 2175 ctx = repo[rev]
2176 2176 dest = makefilename(
2177 2177 ctx, fntemplate, total=total, seqno=seqno, revwidth=revwidth
2178 2178 )
2179 2179 filemap.setdefault(dest, []).append((seqno, rev))
2180 2180
2181 2181 for dest in filemap:
2182 2182 with formatter.maybereopen(basefm, dest) as fm:
2183 2183 repo.ui.note(b"%s\n" % dest)
2184 2184 for seqno, rev in filemap[dest]:
2185 2185 fm.startitem()
2186 2186 ctx = repo[rev]
2187 2187 _exportsingle(
2188 2188 repo, ctx, fm, match, switch_parent, seqno, diffopts
2189 2189 )
2190 2190
2191 2191
2192 2192 def _prefetchchangedfiles(repo, revs, match):
2193 2193 allfiles = set()
2194 2194 for rev in revs:
2195 2195 for file in repo[rev].files():
2196 2196 if not match or match(file):
2197 2197 allfiles.add(file)
2198 2198 match = scmutil.matchfiles(repo, allfiles)
2199 2199 revmatches = [(rev, match) for rev in revs]
2200 2200 scmutil.prefetchfiles(repo, revmatches)
2201 2201
2202 2202
2203 2203 def export(
2204 2204 repo,
2205 2205 revs,
2206 2206 basefm,
2207 2207 fntemplate=b'hg-%h.patch',
2208 2208 switch_parent=False,
2209 2209 opts=None,
2210 2210 match=None,
2211 2211 ):
2212 2212 """export changesets as hg patches
2213 2213
2214 2214 Args:
2215 2215 repo: The repository from which we're exporting revisions.
2216 2216 revs: A list of revisions to export as revision numbers.
2217 2217 basefm: A formatter to which patches should be written.
2218 2218 fntemplate: An optional string to use for generating patch file names.
2219 2219 switch_parent: If True, show diffs against second parent when not nullid.
2220 2220 Default is false, which always shows diff against p1.
2221 2221 opts: diff options to use for generating the patch.
2222 2222 match: If specified, only export changes to files matching this matcher.
2223 2223
2224 2224 Returns:
2225 2225 Nothing.
2226 2226
2227 2227 Side Effect:
2228 2228 "HG Changeset Patch" data is emitted to one of the following
2229 2229 destinations:
2230 2230 fntemplate specified: Each rev is written to a unique file named using
2231 2231 the given template.
2232 2232 Otherwise: All revs will be written to basefm.
2233 2233 """
2234 2234 _prefetchchangedfiles(repo, revs, match)
2235 2235
2236 2236 if not fntemplate:
2237 2237 _exportfile(
2238 2238 repo, revs, basefm, b'<unnamed>', switch_parent, opts, match
2239 2239 )
2240 2240 else:
2241 2241 _exportfntemplate(
2242 2242 repo, revs, basefm, fntemplate, switch_parent, opts, match
2243 2243 )
2244 2244
2245 2245
2246 2246 def exportfile(repo, revs, fp, switch_parent=False, opts=None, match=None):
2247 2247 """Export changesets to the given file stream"""
2248 2248 _prefetchchangedfiles(repo, revs, match)
2249 2249
2250 2250 dest = getattr(fp, 'name', b'<unnamed>')
2251 2251 with formatter.formatter(repo.ui, fp, b'export', {}) as fm:
2252 2252 _exportfile(repo, revs, fm, dest, switch_parent, opts, match)
2253 2253
2254 2254
2255 2255 def showmarker(fm, marker, index=None):
2256 2256 """utility function to display obsolescence marker in a readable way
2257 2257
2258 2258 To be used by debug function."""
2259 2259 if index is not None:
2260 2260 fm.write(b'index', b'%i ', index)
2261 2261 fm.write(b'prednode', b'%s ', hex(marker.prednode()))
2262 2262 succs = marker.succnodes()
2263 2263 fm.condwrite(
2264 2264 succs,
2265 2265 b'succnodes',
2266 2266 b'%s ',
2267 2267 fm.formatlist(map(hex, succs), name=b'node'),
2268 2268 )
2269 2269 fm.write(b'flag', b'%X ', marker.flags())
2270 2270 parents = marker.parentnodes()
2271 2271 if parents is not None:
2272 2272 fm.write(
2273 2273 b'parentnodes',
2274 2274 b'{%s} ',
2275 2275 fm.formatlist(map(hex, parents), name=b'node', sep=b', '),
2276 2276 )
2277 2277 fm.write(b'date', b'(%s) ', fm.formatdate(marker.date()))
2278 2278 meta = marker.metadata().copy()
2279 2279 meta.pop(b'date', None)
2280 2280 smeta = pycompat.rapply(pycompat.maybebytestr, meta)
2281 2281 fm.write(
2282 2282 b'metadata', b'{%s}', fm.formatdict(smeta, fmt=b'%r: %r', sep=b', ')
2283 2283 )
2284 2284 fm.plain(b'\n')
2285 2285
2286 2286
2287 2287 def finddate(ui, repo, date):
2288 2288 """Find the tipmost changeset that matches the given date spec"""
2289 2289 mrevs = repo.revs(b'date(%s)', date)
2290 2290 try:
2291 2291 rev = mrevs.max()
2292 2292 except ValueError:
2293 2293 raise error.InputError(_(b"revision matching date not found"))
2294 2294
2295 2295 ui.status(
2296 2296 _(b"found revision %d from %s\n")
2297 2297 % (rev, dateutil.datestr(repo[rev].date()))
2298 2298 )
2299 2299 return b'%d' % rev
2300 2300
2301 2301
2302 2302 def add(ui, repo, match, prefix, uipathfn, explicitonly, **opts):
2303 2303 bad = []
2304 2304
2305 2305 badfn = lambda x, y: bad.append(x) or match.bad(x, y)
2306 2306 names = []
2307 2307 wctx = repo[None]
2308 2308 cca = None
2309 2309 abort, warn = scmutil.checkportabilityalert(ui)
2310 2310 if abort or warn:
2311 2311 cca = scmutil.casecollisionauditor(ui, abort, repo.dirstate)
2312 2312
2313 2313 match = repo.narrowmatch(match, includeexact=True)
2314 2314 badmatch = matchmod.badmatch(match, badfn)
2315 2315 dirstate = repo.dirstate
2316 2316 # We don't want to just call wctx.walk here, since it would return a lot of
2317 2317 # clean files, which we aren't interested in and takes time.
2318 2318 for f in sorted(
2319 2319 dirstate.walk(
2320 2320 badmatch,
2321 2321 subrepos=sorted(wctx.substate),
2322 2322 unknown=True,
2323 2323 ignored=False,
2324 2324 full=False,
2325 2325 )
2326 2326 ):
2327 2327 exact = match.exact(f)
2328 2328 if exact or not explicitonly and f not in wctx and repo.wvfs.lexists(f):
2329 2329 if cca:
2330 2330 cca(f)
2331 2331 names.append(f)
2332 2332 if ui.verbose or not exact:
2333 2333 ui.status(
2334 2334 _(b'adding %s\n') % uipathfn(f), label=b'ui.addremove.added'
2335 2335 )
2336 2336
2337 2337 for subpath in sorted(wctx.substate):
2338 2338 sub = wctx.sub(subpath)
2339 2339 try:
2340 2340 submatch = matchmod.subdirmatcher(subpath, match)
2341 2341 subprefix = repo.wvfs.reljoin(prefix, subpath)
2342 2342 subuipathfn = scmutil.subdiruipathfn(subpath, uipathfn)
2343 2343 if opts.get('subrepos'):
2344 2344 bad.extend(
2345 2345 sub.add(ui, submatch, subprefix, subuipathfn, False, **opts)
2346 2346 )
2347 2347 else:
2348 2348 bad.extend(
2349 2349 sub.add(ui, submatch, subprefix, subuipathfn, True, **opts)
2350 2350 )
2351 2351 except error.LookupError:
2352 2352 ui.status(
2353 2353 _(b"skipping missing subrepository: %s\n") % uipathfn(subpath)
2354 2354 )
2355 2355
2356 2356 if not opts.get('dry_run'):
2357 2357 rejected = wctx.add(names, prefix)
2358 2358 bad.extend(f for f in rejected if f in match.files())
2359 2359 return bad
2360 2360
2361 2361
2362 2362 def addwebdirpath(repo, serverpath, webconf):
2363 2363 webconf[serverpath] = repo.root
2364 2364 repo.ui.debug(b'adding %s = %s\n' % (serverpath, repo.root))
2365 2365
2366 2366 for r in repo.revs(b'filelog("path:.hgsub")'):
2367 2367 ctx = repo[r]
2368 2368 for subpath in ctx.substate:
2369 2369 ctx.sub(subpath).addwebdirpath(serverpath, webconf)
2370 2370
2371 2371
2372 2372 def forget(
2373 2373 ui, repo, match, prefix, uipathfn, explicitonly, dryrun, interactive
2374 2374 ):
2375 2375 if dryrun and interactive:
2376 2376 raise error.InputError(
2377 2377 _(b"cannot specify both --dry-run and --interactive")
2378 2378 )
2379 2379 bad = []
2380 2380 badfn = lambda x, y: bad.append(x) or match.bad(x, y)
2381 2381 wctx = repo[None]
2382 2382 forgot = []
2383 2383
2384 2384 s = repo.status(match=matchmod.badmatch(match, badfn), clean=True)
2385 2385 forget = sorted(s.modified + s.added + s.deleted + s.clean)
2386 2386 if explicitonly:
2387 2387 forget = [f for f in forget if match.exact(f)]
2388 2388
2389 2389 for subpath in sorted(wctx.substate):
2390 2390 sub = wctx.sub(subpath)
2391 2391 submatch = matchmod.subdirmatcher(subpath, match)
2392 2392 subprefix = repo.wvfs.reljoin(prefix, subpath)
2393 2393 subuipathfn = scmutil.subdiruipathfn(subpath, uipathfn)
2394 2394 try:
2395 2395 subbad, subforgot = sub.forget(
2396 2396 submatch,
2397 2397 subprefix,
2398 2398 subuipathfn,
2399 2399 dryrun=dryrun,
2400 2400 interactive=interactive,
2401 2401 )
2402 2402 bad.extend([subpath + b'/' + f for f in subbad])
2403 2403 forgot.extend([subpath + b'/' + f for f in subforgot])
2404 2404 except error.LookupError:
2405 2405 ui.status(
2406 2406 _(b"skipping missing subrepository: %s\n") % uipathfn(subpath)
2407 2407 )
2408 2408
2409 2409 if not explicitonly:
2410 2410 for f in match.files():
2411 2411 if f not in repo.dirstate and not repo.wvfs.isdir(f):
2412 2412 if f not in forgot:
2413 2413 if repo.wvfs.exists(f):
2414 2414 # Don't complain if the exact case match wasn't given.
2415 2415 # But don't do this until after checking 'forgot', so
2416 2416 # that subrepo files aren't normalized, and this op is
2417 2417 # purely from data cached by the status walk above.
2418 2418 if repo.dirstate.normalize(f) in repo.dirstate:
2419 2419 continue
2420 2420 ui.warn(
2421 2421 _(
2422 2422 b'not removing %s: '
2423 2423 b'file is already untracked\n'
2424 2424 )
2425 2425 % uipathfn(f)
2426 2426 )
2427 2427 bad.append(f)
2428 2428
2429 2429 if interactive:
2430 2430 responses = _(
2431 2431 b'[Ynsa?]'
2432 2432 b'$$ &Yes, forget this file'
2433 2433 b'$$ &No, skip this file'
2434 2434 b'$$ &Skip remaining files'
2435 2435 b'$$ Include &all remaining files'
2436 2436 b'$$ &? (display help)'
2437 2437 )
2438 2438 for filename in forget[:]:
2439 2439 r = ui.promptchoice(
2440 2440 _(b'forget %s %s') % (uipathfn(filename), responses)
2441 2441 )
2442 2442 if r == 4: # ?
2443 2443 while r == 4:
2444 2444 for c, t in ui.extractchoices(responses)[1]:
2445 2445 ui.write(b'%s - %s\n' % (c, encoding.lower(t)))
2446 2446 r = ui.promptchoice(
2447 2447 _(b'forget %s %s') % (uipathfn(filename), responses)
2448 2448 )
2449 2449 if r == 0: # yes
2450 2450 continue
2451 2451 elif r == 1: # no
2452 2452 forget.remove(filename)
2453 2453 elif r == 2: # Skip
2454 2454 fnindex = forget.index(filename)
2455 2455 del forget[fnindex:]
2456 2456 break
2457 2457 elif r == 3: # All
2458 2458 break
2459 2459
2460 2460 for f in forget:
2461 2461 if ui.verbose or not match.exact(f) or interactive:
2462 2462 ui.status(
2463 2463 _(b'removing %s\n') % uipathfn(f), label=b'ui.addremove.removed'
2464 2464 )
2465 2465
2466 2466 if not dryrun:
2467 2467 rejected = wctx.forget(forget, prefix)
2468 2468 bad.extend(f for f in rejected if f in match.files())
2469 2469 forgot.extend(f for f in forget if f not in rejected)
2470 2470 return bad, forgot
2471 2471
2472 2472
2473 2473 def files(ui, ctx, m, uipathfn, fm, fmt, subrepos):
2474 2474 ret = 1
2475 2475
2476 2476 needsfctx = ui.verbose or {b'size', b'flags'} & fm.datahint()
2477 2477 if fm.isplain() and not needsfctx:
2478 2478 # Fast path. The speed-up comes from skipping the formatter, and batching
2479 2479 # calls to ui.write.
2480 2480 buf = []
2481 2481 for f in ctx.matches(m):
2482 2482 buf.append(fmt % uipathfn(f))
2483 2483 if len(buf) > 100:
2484 2484 ui.write(b''.join(buf))
2485 2485 del buf[:]
2486 2486 ret = 0
2487 2487 if buf:
2488 2488 ui.write(b''.join(buf))
2489 2489 else:
2490 2490 for f in ctx.matches(m):
2491 2491 fm.startitem()
2492 2492 fm.context(ctx=ctx)
2493 2493 if needsfctx:
2494 2494 fc = ctx[f]
2495 2495 fm.write(b'size flags', b'% 10d % 1s ', fc.size(), fc.flags())
2496 2496 fm.data(path=f)
2497 2497 fm.plain(fmt % uipathfn(f))
2498 2498 ret = 0
2499 2499
2500 2500 for subpath in sorted(ctx.substate):
2501 2501 submatch = matchmod.subdirmatcher(subpath, m)
2502 2502 subuipathfn = scmutil.subdiruipathfn(subpath, uipathfn)
2503 2503 if subrepos or m.exact(subpath) or any(submatch.files()):
2504 2504 sub = ctx.sub(subpath)
2505 2505 try:
2506 2506 recurse = m.exact(subpath) or subrepos
2507 2507 if (
2508 2508 sub.printfiles(ui, submatch, subuipathfn, fm, fmt, recurse)
2509 2509 == 0
2510 2510 ):
2511 2511 ret = 0
2512 2512 except error.LookupError:
2513 2513 ui.status(
2514 2514 _(b"skipping missing subrepository: %s\n")
2515 2515 % uipathfn(subpath)
2516 2516 )
2517 2517
2518 2518 return ret
2519 2519
2520 2520
2521 2521 def remove(
2522 2522 ui, repo, m, prefix, uipathfn, after, force, subrepos, dryrun, warnings=None
2523 2523 ):
2524 2524 ret = 0
2525 2525 s = repo.status(match=m, clean=True)
2526 2526 modified, added, deleted, clean = s.modified, s.added, s.deleted, s.clean
2527 2527
2528 2528 wctx = repo[None]
2529 2529
2530 2530 if warnings is None:
2531 2531 warnings = []
2532 2532 warn = True
2533 2533 else:
2534 2534 warn = False
2535 2535
2536 2536 subs = sorted(wctx.substate)
2537 2537 progress = ui.makeprogress(
2538 2538 _(b'searching'), total=len(subs), unit=_(b'subrepos')
2539 2539 )
2540 2540 for subpath in subs:
2541 2541 submatch = matchmod.subdirmatcher(subpath, m)
2542 2542 subprefix = repo.wvfs.reljoin(prefix, subpath)
2543 2543 subuipathfn = scmutil.subdiruipathfn(subpath, uipathfn)
2544 2544 if subrepos or m.exact(subpath) or any(submatch.files()):
2545 2545 progress.increment()
2546 2546 sub = wctx.sub(subpath)
2547 2547 try:
2548 2548 if sub.removefiles(
2549 2549 submatch,
2550 2550 subprefix,
2551 2551 subuipathfn,
2552 2552 after,
2553 2553 force,
2554 2554 subrepos,
2555 2555 dryrun,
2556 2556 warnings,
2557 2557 ):
2558 2558 ret = 1
2559 2559 except error.LookupError:
2560 2560 warnings.append(
2561 2561 _(b"skipping missing subrepository: %s\n")
2562 2562 % uipathfn(subpath)
2563 2563 )
2564 2564 progress.complete()
2565 2565
2566 2566 # warn about failure to delete explicit files/dirs
2567 2567 deleteddirs = pathutil.dirs(deleted)
2568 2568 files = m.files()
2569 2569 progress = ui.makeprogress(
2570 2570 _(b'deleting'), total=len(files), unit=_(b'files')
2571 2571 )
2572 2572 for f in files:
2573 2573
2574 2574 def insubrepo():
2575 2575 for subpath in wctx.substate:
2576 2576 if f.startswith(subpath + b'/'):
2577 2577 return True
2578 2578 return False
2579 2579
2580 2580 progress.increment()
2581 2581 isdir = f in deleteddirs or wctx.hasdir(f)
2582 2582 if f in repo.dirstate or isdir or f == b'.' or insubrepo() or f in subs:
2583 2583 continue
2584 2584
2585 2585 if repo.wvfs.exists(f):
2586 2586 if repo.wvfs.isdir(f):
2587 2587 warnings.append(
2588 2588 _(b'not removing %s: no tracked files\n') % uipathfn(f)
2589 2589 )
2590 2590 else:
2591 2591 warnings.append(
2592 2592 _(b'not removing %s: file is untracked\n') % uipathfn(f)
2593 2593 )
2594 2594 # missing files will generate a warning elsewhere
2595 2595 ret = 1
2596 2596 progress.complete()
2597 2597
2598 2598 if force:
2599 2599 list = modified + deleted + clean + added
2600 2600 elif after:
2601 2601 list = deleted
2602 2602 remaining = modified + added + clean
2603 2603 progress = ui.makeprogress(
2604 2604 _(b'skipping'), total=len(remaining), unit=_(b'files')
2605 2605 )
2606 2606 for f in remaining:
2607 2607 progress.increment()
2608 2608 if ui.verbose or (f in files):
2609 2609 warnings.append(
2610 2610 _(b'not removing %s: file still exists\n') % uipathfn(f)
2611 2611 )
2612 2612 ret = 1
2613 2613 progress.complete()
2614 2614 else:
2615 2615 list = deleted + clean
2616 2616 progress = ui.makeprogress(
2617 2617 _(b'skipping'), total=(len(modified) + len(added)), unit=_(b'files')
2618 2618 )
2619 2619 for f in modified:
2620 2620 progress.increment()
2621 2621 warnings.append(
2622 2622 _(
2623 2623 b'not removing %s: file is modified (use -f'
2624 2624 b' to force removal)\n'
2625 2625 )
2626 2626 % uipathfn(f)
2627 2627 )
2628 2628 ret = 1
2629 2629 for f in added:
2630 2630 progress.increment()
2631 2631 warnings.append(
2632 2632 _(
2633 2633 b"not removing %s: file has been marked for add"
2634 2634 b" (use 'hg forget' to undo add)\n"
2635 2635 )
2636 2636 % uipathfn(f)
2637 2637 )
2638 2638 ret = 1
2639 2639 progress.complete()
2640 2640
2641 2641 list = sorted(list)
2642 2642 progress = ui.makeprogress(
2643 2643 _(b'deleting'), total=len(list), unit=_(b'files')
2644 2644 )
2645 2645 for f in list:
2646 2646 if ui.verbose or not m.exact(f):
2647 2647 progress.increment()
2648 2648 ui.status(
2649 2649 _(b'removing %s\n') % uipathfn(f), label=b'ui.addremove.removed'
2650 2650 )
2651 2651 progress.complete()
2652 2652
2653 2653 if not dryrun:
2654 2654 with repo.wlock():
2655 2655 if not after:
2656 2656 for f in list:
2657 2657 if f in added:
2658 2658 continue # we never unlink added files on remove
2659 2659 rmdir = repo.ui.configbool(
2660 2660 b'experimental', b'removeemptydirs'
2661 2661 )
2662 2662 repo.wvfs.unlinkpath(f, ignoremissing=True, rmdir=rmdir)
2663 2663 repo[None].forget(list)
2664 2664
2665 2665 if warn:
2666 2666 for warning in warnings:
2667 2667 ui.warn(warning)
2668 2668
2669 2669 return ret
2670 2670
2671 2671
2672 2672 def _catfmtneedsdata(fm):
2673 2673 return not fm.datahint() or b'data' in fm.datahint()
2674 2674
2675 2675
2676 2676 def _updatecatformatter(fm, ctx, matcher, path, decode):
2677 2677 """Hook for adding data to the formatter used by ``hg cat``.
2678 2678
2679 2679 Extensions (e.g., lfs) can wrap this to inject keywords/data, but must call
2680 2680 this method first."""
2681 2681
2682 2682 # data() can be expensive to fetch (e.g. lfs), so don't fetch it if it
2683 2683 # wasn't requested.
2684 2684 data = b''
2685 2685 if _catfmtneedsdata(fm):
2686 2686 data = ctx[path].data()
2687 2687 if decode:
2688 2688 data = ctx.repo().wwritedata(path, data)
2689 2689 fm.startitem()
2690 2690 fm.context(ctx=ctx)
2691 2691 fm.write(b'data', b'%s', data)
2692 2692 fm.data(path=path)
2693 2693
2694 2694
2695 2695 def cat(ui, repo, ctx, matcher, basefm, fntemplate, prefix, **opts):
2696 2696 err = 1
2697 2697 opts = pycompat.byteskwargs(opts)
2698 2698
2699 2699 def write(path):
2700 2700 filename = None
2701 2701 if fntemplate:
2702 2702 filename = makefilename(
2703 2703 ctx, fntemplate, pathname=os.path.join(prefix, path)
2704 2704 )
2705 2705 # attempt to create the directory if it does not already exist
2706 2706 try:
2707 2707 os.makedirs(os.path.dirname(filename))
2708 2708 except OSError:
2709 2709 pass
2710 2710 with formatter.maybereopen(basefm, filename) as fm:
2711 2711 _updatecatformatter(fm, ctx, matcher, path, opts.get(b'decode'))
2712 2712
2713 2713 # Automation often uses hg cat on single files, so special case it
2714 2714 # for performance to avoid the cost of parsing the manifest.
2715 2715 if len(matcher.files()) == 1 and not matcher.anypats():
2716 2716 file = matcher.files()[0]
2717 2717 mfl = repo.manifestlog
2718 2718 mfnode = ctx.manifestnode()
2719 2719 try:
2720 2720 if mfnode and mfl[mfnode].find(file)[0]:
2721 2721 if _catfmtneedsdata(basefm):
2722 2722 scmutil.prefetchfiles(repo, [(ctx.rev(), matcher)])
2723 2723 write(file)
2724 2724 return 0
2725 2725 except KeyError:
2726 2726 pass
2727 2727
2728 2728 if _catfmtneedsdata(basefm):
2729 2729 scmutil.prefetchfiles(repo, [(ctx.rev(), matcher)])
2730 2730
2731 2731 for abs in ctx.walk(matcher):
2732 2732 write(abs)
2733 2733 err = 0
2734 2734
2735 2735 uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)
2736 2736 for subpath in sorted(ctx.substate):
2737 2737 sub = ctx.sub(subpath)
2738 2738 try:
2739 2739 submatch = matchmod.subdirmatcher(subpath, matcher)
2740 2740 subprefix = os.path.join(prefix, subpath)
2741 2741 if not sub.cat(
2742 2742 submatch,
2743 2743 basefm,
2744 2744 fntemplate,
2745 2745 subprefix,
2746 2746 **pycompat.strkwargs(opts)
2747 2747 ):
2748 2748 err = 0
2749 2749 except error.RepoLookupError:
2750 2750 ui.status(
2751 2751 _(b"skipping missing subrepository: %s\n") % uipathfn(subpath)
2752 2752 )
2753 2753
2754 2754 return err
2755 2755
2756 2756
2757 2757 def commit(ui, repo, commitfunc, pats, opts):
2758 2758 '''commit the specified files or all outstanding changes'''
2759 2759 date = opts.get(b'date')
2760 2760 if date:
2761 2761 opts[b'date'] = dateutil.parsedate(date)
2762 2762 message = logmessage(ui, opts)
2763 2763 matcher = scmutil.match(repo[None], pats, opts)
2764 2764
2765 2765 dsguard = None
2766 2766 # extract addremove carefully -- this function can be called from a command
2767 2767 # that doesn't support addremove
2768 2768 if opts.get(b'addremove'):
2769 2769 dsguard = dirstateguard.dirstateguard(repo, b'commit')
2770 2770 with dsguard or util.nullcontextmanager():
2771 2771 if dsguard:
2772 2772 relative = scmutil.anypats(pats, opts)
2773 2773 uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=relative)
2774 2774 if scmutil.addremove(repo, matcher, b"", uipathfn, opts) != 0:
2775 2775 raise error.Abort(
2776 2776 _(b"failed to mark all new/missing files as added/removed")
2777 2777 )
2778 2778
2779 2779 return commitfunc(ui, repo, message, matcher, opts)
2780 2780
2781 2781
2782 2782 def samefile(f, ctx1, ctx2):
2783 2783 if f in ctx1.manifest():
2784 2784 a = ctx1.filectx(f)
2785 2785 if f in ctx2.manifest():
2786 2786 b = ctx2.filectx(f)
2787 2787 return not a.cmp(b) and a.flags() == b.flags()
2788 2788 else:
2789 2789 return False
2790 2790 else:
2791 2791 return f not in ctx2.manifest()
2792 2792
2793 2793
2794 2794 def amend(ui, repo, old, extra, pats, opts):
2795 2795 # avoid cycle context -> subrepo -> cmdutil
2796 2796 from . import context
2797 2797
2798 2798 # amend will reuse the existing user if not specified, but the obsolete
2799 2799 # marker creation requires that the current user's name is specified.
2800 2800 if obsolete.isenabled(repo, obsolete.createmarkersopt):
2801 2801 ui.username() # raise exception if username not set
2802 2802
2803 2803 ui.note(_(b'amending changeset %s\n') % old)
2804 2804 base = old.p1()
2805 2805
2806 2806 with repo.wlock(), repo.lock(), repo.transaction(b'amend'):
2807 2807 # Participating changesets:
2808 2808 #
2809 2809 # wctx o - workingctx that contains changes from working copy
2810 2810 # | to go into amending commit
2811 2811 # |
2812 2812 # old o - changeset to amend
2813 2813 # |
2814 2814 # base o - first parent of the changeset to amend
2815 2815 wctx = repo[None]
2816 2816
2817 2817 # Copy to avoid mutating input
2818 2818 extra = extra.copy()
2819 2819 # Update extra dict from amended commit (e.g. to preserve graft
2820 2820 # source)
2821 2821 extra.update(old.extra())
2822 2822
2823 2823 # Also update it from the from the wctx
2824 2824 extra.update(wctx.extra())
2825 2825
2826 2826 # date-only change should be ignored?
2827 2827 datemaydiffer = resolve_commit_options(ui, opts)
2828 2828 opts = pycompat.byteskwargs(opts)
2829 2829
2830 2830 date = old.date()
2831 2831 if opts.get(b'date'):
2832 2832 date = dateutil.parsedate(opts.get(b'date'))
2833 2833 user = opts.get(b'user') or old.user()
2834 2834
2835 2835 if len(old.parents()) > 1:
2836 2836 # ctx.files() isn't reliable for merges, so fall back to the
2837 2837 # slower repo.status() method
2838 2838 st = base.status(old)
2839 2839 files = set(st.modified) | set(st.added) | set(st.removed)
2840 2840 else:
2841 2841 files = set(old.files())
2842 2842
2843 2843 # add/remove the files to the working copy if the "addremove" option
2844 2844 # was specified.
2845 2845 matcher = scmutil.match(wctx, pats, opts)
2846 2846 relative = scmutil.anypats(pats, opts)
2847 2847 uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=relative)
2848 2848 if opts.get(b'addremove') and scmutil.addremove(
2849 2849 repo, matcher, b"", uipathfn, opts
2850 2850 ):
2851 2851 raise error.Abort(
2852 2852 _(b"failed to mark all new/missing files as added/removed")
2853 2853 )
2854 2854
2855 2855 # Check subrepos. This depends on in-place wctx._status update in
2856 2856 # subrepo.precommit(). To minimize the risk of this hack, we do
2857 2857 # nothing if .hgsub does not exist.
2858 2858 if b'.hgsub' in wctx or b'.hgsub' in old:
2859 2859 subs, commitsubs, newsubstate = subrepoutil.precommit(
2860 2860 ui, wctx, wctx._status, matcher
2861 2861 )
2862 2862 # amend should abort if commitsubrepos is enabled
2863 2863 assert not commitsubs
2864 2864 if subs:
2865 2865 subrepoutil.writestate(repo, newsubstate)
2866 2866
2867 2867 ms = mergestatemod.mergestate.read(repo)
2868 2868 mergeutil.checkunresolved(ms)
2869 2869
2870 2870 filestoamend = {f for f in wctx.files() if matcher(f)}
2871 2871
2872 2872 changes = len(filestoamend) > 0
2873 2873 if changes:
2874 2874 # Recompute copies (avoid recording a -> b -> a)
2875 2875 copied = copies.pathcopies(base, wctx, matcher)
2876 2876 if old.p2:
2877 2877 copied.update(copies.pathcopies(old.p2(), wctx, matcher))
2878 2878
2879 2879 # Prune files which were reverted by the updates: if old
2880 2880 # introduced file X and the file was renamed in the working
2881 2881 # copy, then those two files are the same and
2882 2882 # we can discard X from our list of files. Likewise if X
2883 2883 # was removed, it's no longer relevant. If X is missing (aka
2884 2884 # deleted), old X must be preserved.
2885 2885 files.update(filestoamend)
2886 2886 files = [
2887 2887 f
2888 2888 for f in files
2889 2889 if (f not in filestoamend or not samefile(f, wctx, base))
2890 2890 ]
2891 2891
2892 2892 def filectxfn(repo, ctx_, path):
2893 2893 try:
2894 2894 # If the file being considered is not amongst the files
2895 2895 # to be amended, we should return the file context from the
2896 2896 # old changeset. This avoids issues when only some files in
2897 2897 # the working copy are being amended but there are also
2898 2898 # changes to other files from the old changeset.
2899 2899 if path not in filestoamend:
2900 2900 return old.filectx(path)
2901 2901
2902 2902 # Return None for removed files.
2903 2903 if path in wctx.removed():
2904 2904 return None
2905 2905
2906 2906 fctx = wctx[path]
2907 2907 flags = fctx.flags()
2908 2908 mctx = context.memfilectx(
2909 2909 repo,
2910 2910 ctx_,
2911 2911 fctx.path(),
2912 2912 fctx.data(),
2913 2913 islink=b'l' in flags,
2914 2914 isexec=b'x' in flags,
2915 2915 copysource=copied.get(path),
2916 2916 )
2917 2917 return mctx
2918 2918 except KeyError:
2919 2919 return None
2920 2920
2921 2921 else:
2922 2922 ui.note(_(b'copying changeset %s to %s\n') % (old, base))
2923 2923
2924 2924 # Use version of files as in the old cset
2925 2925 def filectxfn(repo, ctx_, path):
2926 2926 try:
2927 2927 return old.filectx(path)
2928 2928 except KeyError:
2929 2929 return None
2930 2930
2931 2931 # See if we got a message from -m or -l, if not, open the editor with
2932 2932 # the message of the changeset to amend.
2933 2933 message = logmessage(ui, opts)
2934 2934
2935 2935 editform = mergeeditform(old, b'commit.amend')
2936 2936
2937 2937 if not message:
2938 2938 message = old.description()
2939 2939 # Default if message isn't provided and --edit is not passed is to
2940 2940 # invoke editor, but allow --no-edit. If somehow we don't have any
2941 2941 # description, let's always start the editor.
2942 2942 doedit = not message or opts.get(b'edit') in [True, None]
2943 2943 else:
2944 2944 # Default if message is provided is to not invoke editor, but allow
2945 2945 # --edit.
2946 2946 doedit = opts.get(b'edit') is True
2947 2947 editor = getcommiteditor(edit=doedit, editform=editform)
2948 2948
2949 2949 pureextra = extra.copy()
2950 2950 extra[b'amend_source'] = old.hex()
2951 2951
2952 2952 new = context.memctx(
2953 2953 repo,
2954 2954 parents=[base.node(), old.p2().node()],
2955 2955 text=message,
2956 2956 files=files,
2957 2957 filectxfn=filectxfn,
2958 2958 user=user,
2959 2959 date=date,
2960 2960 extra=extra,
2961 2961 editor=editor,
2962 2962 )
2963 2963
2964 2964 newdesc = changelog.stripdesc(new.description())
2965 2965 if (
2966 2966 (not changes)
2967 2967 and newdesc == old.description()
2968 2968 and user == old.user()
2969 2969 and (date == old.date() or datemaydiffer)
2970 2970 and pureextra == old.extra()
2971 2971 ):
2972 2972 # nothing changed. continuing here would create a new node
2973 2973 # anyway because of the amend_source noise.
2974 2974 #
2975 2975 # This not what we expect from amend.
2976 2976 return old.node()
2977 2977
2978 2978 commitphase = None
2979 2979 if opts.get(b'secret'):
2980 2980 commitphase = phases.secret
2981 2981 newid = repo.commitctx(new)
2982 2982 ms.reset()
2983 2983
2984 2984 with repo.dirstate.parentchange():
2985 2985 # Reroute the working copy parent to the new changeset
2986 2986 repo.setparents(newid, repo.nullid)
2987 2987
2988 2988 # Fixing the dirstate because localrepo.commitctx does not update
2989 2989 # it. This is rather convenient because we did not need to update
2990 2990 # the dirstate for all the files in the new commit which commitctx
2991 2991 # could have done if it updated the dirstate. Now, we can
2992 2992 # selectively update the dirstate only for the amended files.
2993 2993 dirstate = repo.dirstate
2994 2994
2995 2995 # Update the state of the files which were added and modified in the
2996 2996 # amend to "normal" in the dirstate. We need to use "normallookup" since
2997 2997 # the files may have changed since the command started; using "normal"
2998 2998 # would mark them as clean but with uncommitted contents.
2999 2999 normalfiles = set(wctx.modified() + wctx.added()) & filestoamend
3000 3000 for f in normalfiles:
3001 3001 dirstate.update_file(
3002 3002 f, p1_tracked=True, wc_tracked=True, possibly_dirty=True
3003 3003 )
3004 3004
3005 3005 # Update the state of files which were removed in the amend
3006 3006 # to "removed" in the dirstate.
3007 3007 removedfiles = set(wctx.removed()) & filestoamend
3008 3008 for f in removedfiles:
3009 3009 dirstate.update_file(f, p1_tracked=False, wc_tracked=False)
3010 3010
3011 3011 mapping = {old.node(): (newid,)}
3012 3012 obsmetadata = None
3013 3013 if opts.get(b'note'):
3014 3014 obsmetadata = {b'note': encoding.fromlocal(opts[b'note'])}
3015 3015 backup = ui.configbool(b'rewrite', b'backup-bundle')
3016 3016 scmutil.cleanupnodes(
3017 3017 repo,
3018 3018 mapping,
3019 3019 b'amend',
3020 3020 metadata=obsmetadata,
3021 3021 fixphase=True,
3022 3022 targetphase=commitphase,
3023 3023 backup=backup,
3024 3024 )
3025 3025
3026 3026 return newid
3027 3027
3028 3028
3029 3029 def commiteditor(repo, ctx, subs, editform=b''):
3030 3030 if ctx.description():
3031 3031 return ctx.description()
3032 3032 return commitforceeditor(
3033 3033 repo, ctx, subs, editform=editform, unchangedmessagedetection=True
3034 3034 )
3035 3035
3036 3036
3037 3037 def commitforceeditor(
3038 3038 repo,
3039 3039 ctx,
3040 3040 subs,
3041 3041 finishdesc=None,
3042 3042 extramsg=None,
3043 3043 editform=b'',
3044 3044 unchangedmessagedetection=False,
3045 3045 ):
3046 3046 if not extramsg:
3047 3047 extramsg = _(b"Leave message empty to abort commit.")
3048 3048
3049 3049 forms = [e for e in editform.split(b'.') if e]
3050 3050 forms.insert(0, b'changeset')
3051 3051 templatetext = None
3052 3052 while forms:
3053 3053 ref = b'.'.join(forms)
3054 3054 if repo.ui.config(b'committemplate', ref):
3055 3055 templatetext = committext = buildcommittemplate(
3056 3056 repo, ctx, subs, extramsg, ref
3057 3057 )
3058 3058 break
3059 3059 forms.pop()
3060 3060 else:
3061 3061 committext = buildcommittext(repo, ctx, subs, extramsg)
3062 3062
3063 3063 # run editor in the repository root
3064 3064 olddir = encoding.getcwd()
3065 3065 os.chdir(repo.root)
3066 3066
3067 3067 # make in-memory changes visible to external process
3068 3068 tr = repo.currenttransaction()
3069 3069 repo.dirstate.write(tr)
3070 3070 pending = tr and tr.writepending() and repo.root
3071 3071
3072 3072 editortext = repo.ui.edit(
3073 3073 committext,
3074 3074 ctx.user(),
3075 3075 ctx.extra(),
3076 3076 editform=editform,
3077 3077 pending=pending,
3078 3078 repopath=repo.path,
3079 3079 action=b'commit',
3080 3080 )
3081 3081 text = editortext
3082 3082
3083 3083 # strip away anything below this special string (used for editors that want
3084 3084 # to display the diff)
3085 3085 stripbelow = re.search(_linebelow, text, flags=re.MULTILINE)
3086 3086 if stripbelow:
3087 3087 text = text[: stripbelow.start()]
3088 3088
3089 3089 text = re.sub(b"(?m)^HG:.*(\n|$)", b"", text)
3090 3090 os.chdir(olddir)
3091 3091
3092 3092 if finishdesc:
3093 3093 text = finishdesc(text)
3094 3094 if not text.strip():
3095 3095 raise error.InputError(_(b"empty commit message"))
3096 3096 if unchangedmessagedetection and editortext == templatetext:
3097 3097 raise error.InputError(_(b"commit message unchanged"))
3098 3098
3099 3099 return text
3100 3100
3101 3101
3102 3102 def buildcommittemplate(repo, ctx, subs, extramsg, ref):
3103 3103 ui = repo.ui
3104 3104 spec = formatter.reference_templatespec(ref)
3105 3105 t = logcmdutil.changesettemplater(ui, repo, spec)
3106 3106 t.t.cache.update(
3107 3107 (k, templater.unquotestring(v))
3108 3108 for k, v in repo.ui.configitems(b'committemplate')
3109 3109 )
3110 3110
3111 3111 if not extramsg:
3112 3112 extramsg = b'' # ensure that extramsg is string
3113 3113
3114 3114 ui.pushbuffer()
3115 3115 t.show(ctx, extramsg=extramsg)
3116 3116 return ui.popbuffer()
3117 3117
3118 3118
3119 3119 def hgprefix(msg):
3120 3120 return b"\n".join([b"HG: %s" % a for a in msg.split(b"\n") if a])
3121 3121
3122 3122
3123 3123 def buildcommittext(repo, ctx, subs, extramsg):
3124 3124 edittext = []
3125 3125 modified, added, removed = ctx.modified(), ctx.added(), ctx.removed()
3126 3126 if ctx.description():
3127 3127 edittext.append(ctx.description())
3128 3128 edittext.append(b"")
3129 3129 edittext.append(b"") # Empty line between message and comments.
3130 3130 edittext.append(
3131 3131 hgprefix(
3132 3132 _(
3133 3133 b"Enter commit message."
3134 3134 b" Lines beginning with 'HG:' are removed."
3135 3135 )
3136 3136 )
3137 3137 )
3138 3138 edittext.append(hgprefix(extramsg))
3139 3139 edittext.append(b"HG: --")
3140 3140 edittext.append(hgprefix(_(b"user: %s") % ctx.user()))
3141 3141 if ctx.p2():
3142 3142 edittext.append(hgprefix(_(b"branch merge")))
3143 3143 if ctx.branch():
3144 3144 edittext.append(hgprefix(_(b"branch '%s'") % ctx.branch()))
3145 3145 if bookmarks.isactivewdirparent(repo):
3146 3146 edittext.append(hgprefix(_(b"bookmark '%s'") % repo._activebookmark))
3147 3147 edittext.extend([hgprefix(_(b"subrepo %s") % s) for s in subs])
3148 3148 edittext.extend([hgprefix(_(b"added %s") % f) for f in added])
3149 3149 edittext.extend([hgprefix(_(b"changed %s") % f) for f in modified])
3150 3150 edittext.extend([hgprefix(_(b"removed %s") % f) for f in removed])
3151 3151 if not added and not modified and not removed:
3152 3152 edittext.append(hgprefix(_(b"no files changed")))
3153 3153 edittext.append(b"")
3154 3154
3155 3155 return b"\n".join(edittext)
3156 3156
3157 3157
3158 3158 def commitstatus(repo, node, branch, bheads=None, tip=None, opts=None):
3159 3159 if opts is None:
3160 3160 opts = {}
3161 3161 ctx = repo[node]
3162 3162 parents = ctx.parents()
3163 3163
3164 3164 if tip is not None and repo.changelog.tip() == tip:
3165 3165 # avoid reporting something like "committed new head" when
3166 3166 # recommitting old changesets, and issue a helpful warning
3167 3167 # for most instances
3168 3168 repo.ui.warn(_(b"warning: commit already existed in the repository!\n"))
3169 3169 elif (
3170 3170 not opts.get(b'amend')
3171 3171 and bheads
3172 3172 and node not in bheads
3173 3173 and not any(
3174 3174 p.node() in bheads and p.branch() == branch for p in parents
3175 3175 )
3176 3176 ):
3177 3177 repo.ui.status(_(b'created new head\n'))
3178 3178 # The message is not printed for initial roots. For the other
3179 3179 # changesets, it is printed in the following situations:
3180 3180 #
3181 3181 # Par column: for the 2 parents with ...
3182 3182 # N: null or no parent
3183 3183 # B: parent is on another named branch
3184 3184 # C: parent is a regular non head changeset
3185 3185 # H: parent was a branch head of the current branch
3186 3186 # Msg column: whether we print "created new head" message
3187 3187 # In the following, it is assumed that there already exists some
3188 3188 # initial branch heads of the current branch, otherwise nothing is
3189 3189 # printed anyway.
3190 3190 #
3191 3191 # Par Msg Comment
3192 3192 # N N y additional topo root
3193 3193 #
3194 3194 # B N y additional branch root
3195 3195 # C N y additional topo head
3196 3196 # H N n usual case
3197 3197 #
3198 3198 # B B y weird additional branch root
3199 3199 # C B y branch merge
3200 3200 # H B n merge with named branch
3201 3201 #
3202 3202 # C C y additional head from merge
3203 3203 # C H n merge with a head
3204 3204 #
3205 3205 # H H n head merge: head count decreases
3206 3206
3207 3207 if not opts.get(b'close_branch'):
3208 3208 for r in parents:
3209 3209 if r.closesbranch() and r.branch() == branch:
3210 3210 repo.ui.status(
3211 3211 _(b'reopening closed branch head %d\n') % r.rev()
3212 3212 )
3213 3213
3214 3214 if repo.ui.debugflag:
3215 3215 repo.ui.write(
3216 3216 _(b'committed changeset %d:%s\n') % (ctx.rev(), ctx.hex())
3217 3217 )
3218 3218 elif repo.ui.verbose:
3219 3219 repo.ui.write(_(b'committed changeset %d:%s\n') % (ctx.rev(), ctx))
3220 3220
3221 3221
3222 3222 def postcommitstatus(repo, pats, opts):
3223 3223 return repo.status(match=scmutil.match(repo[None], pats, opts))
3224 3224
3225 3225
3226 3226 def revert(ui, repo, ctx, *pats, **opts):
3227 3227 opts = pycompat.byteskwargs(opts)
3228 3228 parent, p2 = repo.dirstate.parents()
3229 3229 node = ctx.node()
3230 3230
3231 3231 mf = ctx.manifest()
3232 3232 if node == p2:
3233 3233 parent = p2
3234 3234
3235 3235 # need all matching names in dirstate and manifest of target rev,
3236 3236 # so have to walk both. do not print errors if files exist in one
3237 3237 # but not other. in both cases, filesets should be evaluated against
3238 3238 # workingctx to get consistent result (issue4497). this means 'set:**'
3239 3239 # cannot be used to select missing files from target rev.
3240 3240
3241 3241 # `names` is a mapping for all elements in working copy and target revision
3242 3242 # The mapping is in the form:
3243 3243 # <abs path in repo> -> (<path from CWD>, <exactly specified by matcher?>)
3244 3244 names = {}
3245 3245 uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)
3246 3246
3247 3247 with repo.wlock():
3248 3248 ## filling of the `names` mapping
3249 3249 # walk dirstate to fill `names`
3250 3250
3251 3251 interactive = opts.get(b'interactive', False)
3252 3252 wctx = repo[None]
3253 3253 m = scmutil.match(wctx, pats, opts)
3254 3254
3255 3255 # we'll need this later
3256 3256 targetsubs = sorted(s for s in wctx.substate if m(s))
3257 3257
3258 3258 if not m.always():
3259 3259 matcher = matchmod.badmatch(m, lambda x, y: False)
3260 3260 for abs in wctx.walk(matcher):
3261 3261 names[abs] = m.exact(abs)
3262 3262
3263 3263 # walk target manifest to fill `names`
3264 3264
3265 3265 def badfn(path, msg):
3266 3266 if path in names:
3267 3267 return
3268 3268 if path in ctx.substate:
3269 3269 return
3270 3270 path_ = path + b'/'
3271 3271 for f in names:
3272 3272 if f.startswith(path_):
3273 3273 return
3274 3274 ui.warn(b"%s: %s\n" % (uipathfn(path), msg))
3275 3275
3276 3276 for abs in ctx.walk(matchmod.badmatch(m, badfn)):
3277 3277 if abs not in names:
3278 3278 names[abs] = m.exact(abs)
3279 3279
3280 3280 # Find status of all file in `names`.
3281 3281 m = scmutil.matchfiles(repo, names)
3282 3282
3283 3283 changes = repo.status(
3284 3284 node1=node, match=m, unknown=True, ignored=True, clean=True
3285 3285 )
3286 3286 else:
3287 3287 changes = repo.status(node1=node, match=m)
3288 3288 for kind in changes:
3289 3289 for abs in kind:
3290 3290 names[abs] = m.exact(abs)
3291 3291
3292 3292 m = scmutil.matchfiles(repo, names)
3293 3293
3294 3294 modified = set(changes.modified)
3295 3295 added = set(changes.added)
3296 3296 removed = set(changes.removed)
3297 3297 _deleted = set(changes.deleted)
3298 3298 unknown = set(changes.unknown)
3299 3299 unknown.update(changes.ignored)
3300 3300 clean = set(changes.clean)
3301 3301 modadded = set()
3302 3302
3303 3303 # We need to account for the state of the file in the dirstate,
3304 3304 # even when we revert against something else than parent. This will
3305 3305 # slightly alter the behavior of revert (doing back up or not, delete
3306 3306 # or just forget etc).
3307 3307 if parent == node:
3308 3308 dsmodified = modified
3309 3309 dsadded = added
3310 3310 dsremoved = removed
3311 3311 # store all local modifications, useful later for rename detection
3312 3312 localchanges = dsmodified | dsadded
3313 3313 modified, added, removed = set(), set(), set()
3314 3314 else:
3315 3315 changes = repo.status(node1=parent, match=m)
3316 3316 dsmodified = set(changes.modified)
3317 3317 dsadded = set(changes.added)
3318 3318 dsremoved = set(changes.removed)
3319 3319 # store all local modifications, useful later for rename detection
3320 3320 localchanges = dsmodified | dsadded
3321 3321
3322 3322 # only take into account for removes between wc and target
3323 3323 clean |= dsremoved - removed
3324 3324 dsremoved &= removed
3325 3325 # distinct between dirstate remove and other
3326 3326 removed -= dsremoved
3327 3327
3328 3328 modadded = added & dsmodified
3329 3329 added -= modadded
3330 3330
3331 3331 # tell newly modified apart.
3332 3332 dsmodified &= modified
3333 3333 dsmodified |= modified & dsadded # dirstate added may need backup
3334 3334 modified -= dsmodified
3335 3335
3336 3336 # We need to wait for some post-processing to update this set
3337 3337 # before making the distinction. The dirstate will be used for
3338 3338 # that purpose.
3339 3339 dsadded = added
3340 3340
3341 3341 # in case of merge, files that are actually added can be reported as
3342 3342 # modified, we need to post process the result
3343 3343 if p2 != repo.nullid:
3344 3344 mergeadd = set(dsmodified)
3345 3345 for path in dsmodified:
3346 3346 if path in mf:
3347 3347 mergeadd.remove(path)
3348 3348 dsadded |= mergeadd
3349 3349 dsmodified -= mergeadd
3350 3350
3351 3351 # if f is a rename, update `names` to also revert the source
3352 3352 for f in localchanges:
3353 3353 src = repo.dirstate.copied(f)
3354 3354 # XXX should we check for rename down to target node?
3355 if src and src not in names and repo.dirstate[src] == b'r':
3355 if (
3356 src
3357 and src not in names
3358 and repo.dirstate.get_entry(src).removed
3359 ):
3356 3360 dsremoved.add(src)
3357 3361 names[src] = True
3358 3362
3359 3363 # determine the exact nature of the deleted changesets
3360 3364 deladded = set(_deleted)
3361 3365 for path in _deleted:
3362 3366 if path in mf:
3363 3367 deladded.remove(path)
3364 3368 deleted = _deleted - deladded
3365 3369
3366 3370 # distinguish between file to forget and the other
3367 3371 added = set()
3368 3372 for abs in dsadded:
3369 if repo.dirstate[abs] != b'a':
3373 if not repo.dirstate.get_entry(abs).added:
3370 3374 added.add(abs)
3371 3375 dsadded -= added
3372 3376
3373 3377 for abs in deladded:
3374 if repo.dirstate[abs] == b'a':
3378 if repo.dirstate.get_entry(abs).added:
3375 3379 dsadded.add(abs)
3376 3380 deladded -= dsadded
3377 3381
3378 3382 # For files marked as removed, we check if an unknown file is present at
3379 3383 # the same path. If a such file exists it may need to be backed up.
3380 3384 # Making the distinction at this stage helps have simpler backup
3381 3385 # logic.
3382 3386 removunk = set()
3383 3387 for abs in removed:
3384 3388 target = repo.wjoin(abs)
3385 3389 if os.path.lexists(target):
3386 3390 removunk.add(abs)
3387 3391 removed -= removunk
3388 3392
3389 3393 dsremovunk = set()
3390 3394 for abs in dsremoved:
3391 3395 target = repo.wjoin(abs)
3392 3396 if os.path.lexists(target):
3393 3397 dsremovunk.add(abs)
3394 3398 dsremoved -= dsremovunk
3395 3399
3396 3400 # action to be actually performed by revert
3397 3401 # (<list of file>, message>) tuple
3398 3402 actions = {
3399 3403 b'revert': ([], _(b'reverting %s\n')),
3400 3404 b'add': ([], _(b'adding %s\n')),
3401 3405 b'remove': ([], _(b'removing %s\n')),
3402 3406 b'drop': ([], _(b'removing %s\n')),
3403 3407 b'forget': ([], _(b'forgetting %s\n')),
3404 3408 b'undelete': ([], _(b'undeleting %s\n')),
3405 3409 b'noop': (None, _(b'no changes needed to %s\n')),
3406 3410 b'unknown': (None, _(b'file not managed: %s\n')),
3407 3411 }
3408 3412
3409 3413 # "constant" that convey the backup strategy.
3410 3414 # All set to `discard` if `no-backup` is set do avoid checking
3411 3415 # no_backup lower in the code.
3412 3416 # These values are ordered for comparison purposes
3413 3417 backupinteractive = 3 # do backup if interactively modified
3414 3418 backup = 2 # unconditionally do backup
3415 3419 check = 1 # check if the existing file differs from target
3416 3420 discard = 0 # never do backup
3417 3421 if opts.get(b'no_backup'):
3418 3422 backupinteractive = backup = check = discard
3419 3423 if interactive:
3420 3424 dsmodifiedbackup = backupinteractive
3421 3425 else:
3422 3426 dsmodifiedbackup = backup
3423 3427 tobackup = set()
3424 3428
3425 3429 backupanddel = actions[b'remove']
3426 3430 if not opts.get(b'no_backup'):
3427 3431 backupanddel = actions[b'drop']
3428 3432
3429 3433 disptable = (
3430 3434 # dispatch table:
3431 3435 # file state
3432 3436 # action
3433 3437 # make backup
3434 3438 ## Sets that results that will change file on disk
3435 3439 # Modified compared to target, no local change
3436 3440 (modified, actions[b'revert'], discard),
3437 3441 # Modified compared to target, but local file is deleted
3438 3442 (deleted, actions[b'revert'], discard),
3439 3443 # Modified compared to target, local change
3440 3444 (dsmodified, actions[b'revert'], dsmodifiedbackup),
3441 3445 # Added since target
3442 3446 (added, actions[b'remove'], discard),
3443 3447 # Added in working directory
3444 3448 (dsadded, actions[b'forget'], discard),
3445 3449 # Added since target, have local modification
3446 3450 (modadded, backupanddel, backup),
3447 3451 # Added since target but file is missing in working directory
3448 3452 (deladded, actions[b'drop'], discard),
3449 3453 # Removed since target, before working copy parent
3450 3454 (removed, actions[b'add'], discard),
3451 3455 # Same as `removed` but an unknown file exists at the same path
3452 3456 (removunk, actions[b'add'], check),
3453 3457 # Removed since targe, marked as such in working copy parent
3454 3458 (dsremoved, actions[b'undelete'], discard),
3455 3459 # Same as `dsremoved` but an unknown file exists at the same path
3456 3460 (dsremovunk, actions[b'undelete'], check),
3457 3461 ## the following sets does not result in any file changes
3458 3462 # File with no modification
3459 3463 (clean, actions[b'noop'], discard),
3460 3464 # Existing file, not tracked anywhere
3461 3465 (unknown, actions[b'unknown'], discard),
3462 3466 )
3463 3467
3464 3468 for abs, exact in sorted(names.items()):
3465 3469 # target file to be touch on disk (relative to cwd)
3466 3470 target = repo.wjoin(abs)
3467 3471 # search the entry in the dispatch table.
3468 3472 # if the file is in any of these sets, it was touched in the working
3469 3473 # directory parent and we are sure it needs to be reverted.
3470 3474 for table, (xlist, msg), dobackup in disptable:
3471 3475 if abs not in table:
3472 3476 continue
3473 3477 if xlist is not None:
3474 3478 xlist.append(abs)
3475 3479 if dobackup:
3476 3480 # If in interactive mode, don't automatically create
3477 3481 # .orig files (issue4793)
3478 3482 if dobackup == backupinteractive:
3479 3483 tobackup.add(abs)
3480 3484 elif backup <= dobackup or wctx[abs].cmp(ctx[abs]):
3481 3485 absbakname = scmutil.backuppath(ui, repo, abs)
3482 3486 bakname = os.path.relpath(
3483 3487 absbakname, start=repo.root
3484 3488 )
3485 3489 ui.note(
3486 3490 _(b'saving current version of %s as %s\n')
3487 3491 % (uipathfn(abs), uipathfn(bakname))
3488 3492 )
3489 3493 if not opts.get(b'dry_run'):
3490 3494 if interactive:
3491 3495 util.copyfile(target, absbakname)
3492 3496 else:
3493 3497 util.rename(target, absbakname)
3494 3498 if opts.get(b'dry_run'):
3495 3499 if ui.verbose or not exact:
3496 3500 ui.status(msg % uipathfn(abs))
3497 3501 elif exact:
3498 3502 ui.warn(msg % uipathfn(abs))
3499 3503 break
3500 3504
3501 3505 if not opts.get(b'dry_run'):
3502 3506 needdata = (b'revert', b'add', b'undelete')
3503 3507 oplist = [actions[name][0] for name in needdata]
3504 3508 prefetch = scmutil.prefetchfiles
3505 3509 matchfiles = scmutil.matchfiles(
3506 3510 repo, [f for sublist in oplist for f in sublist]
3507 3511 )
3508 3512 prefetch(
3509 3513 repo,
3510 3514 [(ctx.rev(), matchfiles)],
3511 3515 )
3512 3516 match = scmutil.match(repo[None], pats)
3513 3517 _performrevert(
3514 3518 repo,
3515 3519 ctx,
3516 3520 names,
3517 3521 uipathfn,
3518 3522 actions,
3519 3523 match,
3520 3524 interactive,
3521 3525 tobackup,
3522 3526 )
3523 3527
3524 3528 if targetsubs:
3525 3529 # Revert the subrepos on the revert list
3526 3530 for sub in targetsubs:
3527 3531 try:
3528 3532 wctx.sub(sub).revert(
3529 3533 ctx.substate[sub], *pats, **pycompat.strkwargs(opts)
3530 3534 )
3531 3535 except KeyError:
3532 3536 raise error.Abort(
3533 3537 b"subrepository '%s' does not exist in %s!"
3534 3538 % (sub, short(ctx.node()))
3535 3539 )
3536 3540
3537 3541
3538 3542 def _performrevert(
3539 3543 repo,
3540 3544 ctx,
3541 3545 names,
3542 3546 uipathfn,
3543 3547 actions,
3544 3548 match,
3545 3549 interactive=False,
3546 3550 tobackup=None,
3547 3551 ):
3548 3552 """function that actually perform all the actions computed for revert
3549 3553
3550 3554 This is an independent function to let extension to plug in and react to
3551 3555 the imminent revert.
3552 3556
3553 3557 Make sure you have the working directory locked when calling this function.
3554 3558 """
3555 3559 parent, p2 = repo.dirstate.parents()
3556 3560 node = ctx.node()
3557 3561 excluded_files = []
3558 3562
3559 3563 def checkout(f):
3560 3564 fc = ctx[f]
3561 3565 repo.wwrite(f, fc.data(), fc.flags())
3562 3566
3563 3567 def doremove(f):
3564 3568 try:
3565 3569 rmdir = repo.ui.configbool(b'experimental', b'removeemptydirs')
3566 3570 repo.wvfs.unlinkpath(f, rmdir=rmdir)
3567 3571 except OSError:
3568 3572 pass
3569 3573 repo.dirstate.set_untracked(f)
3570 3574
3571 3575 def prntstatusmsg(action, f):
3572 3576 exact = names[f]
3573 3577 if repo.ui.verbose or not exact:
3574 3578 repo.ui.status(actions[action][1] % uipathfn(f))
3575 3579
3576 3580 audit_path = pathutil.pathauditor(repo.root, cached=True)
3577 3581 for f in actions[b'forget'][0]:
3578 3582 if interactive:
3579 3583 choice = repo.ui.promptchoice(
3580 3584 _(b"forget added file %s (Yn)?$$ &Yes $$ &No") % uipathfn(f)
3581 3585 )
3582 3586 if choice == 0:
3583 3587 prntstatusmsg(b'forget', f)
3584 3588 repo.dirstate.set_untracked(f)
3585 3589 else:
3586 3590 excluded_files.append(f)
3587 3591 else:
3588 3592 prntstatusmsg(b'forget', f)
3589 3593 repo.dirstate.set_untracked(f)
3590 3594 for f in actions[b'remove'][0]:
3591 3595 audit_path(f)
3592 3596 if interactive:
3593 3597 choice = repo.ui.promptchoice(
3594 3598 _(b"remove added file %s (Yn)?$$ &Yes $$ &No") % uipathfn(f)
3595 3599 )
3596 3600 if choice == 0:
3597 3601 prntstatusmsg(b'remove', f)
3598 3602 doremove(f)
3599 3603 else:
3600 3604 excluded_files.append(f)
3601 3605 else:
3602 3606 prntstatusmsg(b'remove', f)
3603 3607 doremove(f)
3604 3608 for f in actions[b'drop'][0]:
3605 3609 audit_path(f)
3606 3610 prntstatusmsg(b'drop', f)
3607 3611 repo.dirstate.set_untracked(f)
3608 3612
3609 3613 normal = None
3610 3614 if node == parent:
3611 3615 # We're reverting to our parent. If possible, we'd like status
3612 3616 # to report the file as clean. We have to use normallookup for
3613 3617 # merges to avoid losing information about merged/dirty files.
3614 3618 if p2 != repo.nullid:
3615 3619 normal = repo.dirstate.set_tracked
3616 3620 else:
3617 3621 normal = repo.dirstate.set_clean
3618 3622
3619 3623 newlyaddedandmodifiedfiles = set()
3620 3624 if interactive:
3621 3625 # Prompt the user for changes to revert
3622 3626 torevert = [f for f in actions[b'revert'][0] if f not in excluded_files]
3623 3627 m = scmutil.matchfiles(repo, torevert)
3624 3628 diffopts = patch.difffeatureopts(
3625 3629 repo.ui,
3626 3630 whitespace=True,
3627 3631 section=b'commands',
3628 3632 configprefix=b'revert.interactive.',
3629 3633 )
3630 3634 diffopts.nodates = True
3631 3635 diffopts.git = True
3632 3636 operation = b'apply'
3633 3637 if node == parent:
3634 3638 if repo.ui.configbool(
3635 3639 b'experimental', b'revert.interactive.select-to-keep'
3636 3640 ):
3637 3641 operation = b'keep'
3638 3642 else:
3639 3643 operation = b'discard'
3640 3644
3641 3645 if operation == b'apply':
3642 3646 diff = patch.diff(repo, None, ctx.node(), m, opts=diffopts)
3643 3647 else:
3644 3648 diff = patch.diff(repo, ctx.node(), None, m, opts=diffopts)
3645 3649 original_headers = patch.parsepatch(diff)
3646 3650
3647 3651 try:
3648 3652
3649 3653 chunks, opts = recordfilter(
3650 3654 repo.ui, original_headers, match, operation=operation
3651 3655 )
3652 3656 if operation == b'discard':
3653 3657 chunks = patch.reversehunks(chunks)
3654 3658
3655 3659 except error.PatchError as err:
3656 3660 raise error.Abort(_(b'error parsing patch: %s') % err)
3657 3661
3658 3662 # FIXME: when doing an interactive revert of a copy, there's no way of
3659 3663 # performing a partial revert of the added file, the only option is
3660 3664 # "remove added file <name> (Yn)?", so we don't need to worry about the
3661 3665 # alsorestore value. Ideally we'd be able to partially revert
3662 3666 # copied/renamed files.
3663 3667 newlyaddedandmodifiedfiles, unusedalsorestore = newandmodified(chunks)
3664 3668 if tobackup is None:
3665 3669 tobackup = set()
3666 3670 # Apply changes
3667 3671 fp = stringio()
3668 3672 # chunks are serialized per file, but files aren't sorted
3669 3673 for f in sorted({c.header.filename() for c in chunks if ishunk(c)}):
3670 3674 prntstatusmsg(b'revert', f)
3671 3675 files = set()
3672 3676 for c in chunks:
3673 3677 if ishunk(c):
3674 3678 abs = c.header.filename()
3675 3679 # Create a backup file only if this hunk should be backed up
3676 3680 if c.header.filename() in tobackup:
3677 3681 target = repo.wjoin(abs)
3678 3682 bakname = scmutil.backuppath(repo.ui, repo, abs)
3679 3683 util.copyfile(target, bakname)
3680 3684 tobackup.remove(abs)
3681 3685 if abs not in files:
3682 3686 files.add(abs)
3683 3687 if operation == b'keep':
3684 3688 checkout(abs)
3685 3689 c.write(fp)
3686 3690 dopatch = fp.tell()
3687 3691 fp.seek(0)
3688 3692 if dopatch:
3689 3693 try:
3690 3694 patch.internalpatch(repo.ui, repo, fp, 1, eolmode=None)
3691 3695 except error.PatchError as err:
3692 3696 raise error.Abort(pycompat.bytestr(err))
3693 3697 del fp
3694 3698 else:
3695 3699 for f in actions[b'revert'][0]:
3696 3700 prntstatusmsg(b'revert', f)
3697 3701 checkout(f)
3698 3702 if normal:
3699 3703 normal(f)
3700 3704
3701 3705 for f in actions[b'add'][0]:
3702 3706 # Don't checkout modified files, they are already created by the diff
3703 3707 if f not in newlyaddedandmodifiedfiles:
3704 3708 prntstatusmsg(b'add', f)
3705 3709 checkout(f)
3706 3710 repo.dirstate.set_tracked(f)
3707 3711
3708 3712 normal = repo.dirstate.set_tracked
3709 3713 if node == parent and p2 == repo.nullid:
3710 3714 normal = repo.dirstate.set_clean
3711 3715 for f in actions[b'undelete'][0]:
3712 3716 if interactive:
3713 3717 choice = repo.ui.promptchoice(
3714 3718 _(b"add back removed file %s (Yn)?$$ &Yes $$ &No") % f
3715 3719 )
3716 3720 if choice == 0:
3717 3721 prntstatusmsg(b'undelete', f)
3718 3722 checkout(f)
3719 3723 normal(f)
3720 3724 else:
3721 3725 excluded_files.append(f)
3722 3726 else:
3723 3727 prntstatusmsg(b'undelete', f)
3724 3728 checkout(f)
3725 3729 normal(f)
3726 3730
3727 3731 copied = copies.pathcopies(repo[parent], ctx)
3728 3732
3729 3733 for f in (
3730 3734 actions[b'add'][0] + actions[b'undelete'][0] + actions[b'revert'][0]
3731 3735 ):
3732 3736 if f in copied:
3733 3737 repo.dirstate.copy(copied[f], f)
3734 3738
3735 3739
3736 3740 # a list of (ui, repo, otherpeer, opts, missing) functions called by
3737 3741 # commands.outgoing. "missing" is "missing" of the result of
3738 3742 # "findcommonoutgoing()"
3739 3743 outgoinghooks = util.hooks()
3740 3744
3741 3745 # a list of (ui, repo) functions called by commands.summary
3742 3746 summaryhooks = util.hooks()
3743 3747
3744 3748 # a list of (ui, repo, opts, changes) functions called by commands.summary.
3745 3749 #
3746 3750 # functions should return tuple of booleans below, if 'changes' is None:
3747 3751 # (whether-incomings-are-needed, whether-outgoings-are-needed)
3748 3752 #
3749 3753 # otherwise, 'changes' is a tuple of tuples below:
3750 3754 # - (sourceurl, sourcebranch, sourcepeer, incoming)
3751 3755 # - (desturl, destbranch, destpeer, outgoing)
3752 3756 summaryremotehooks = util.hooks()
3753 3757
3754 3758
3755 3759 def checkunfinished(repo, commit=False, skipmerge=False):
3756 3760 """Look for an unfinished multistep operation, like graft, and abort
3757 3761 if found. It's probably good to check this right before
3758 3762 bailifchanged().
3759 3763 """
3760 3764 # Check for non-clearable states first, so things like rebase will take
3761 3765 # precedence over update.
3762 3766 for state in statemod._unfinishedstates:
3763 3767 if (
3764 3768 state._clearable
3765 3769 or (commit and state._allowcommit)
3766 3770 or state._reportonly
3767 3771 ):
3768 3772 continue
3769 3773 if state.isunfinished(repo):
3770 3774 raise error.StateError(state.msg(), hint=state.hint())
3771 3775
3772 3776 for s in statemod._unfinishedstates:
3773 3777 if (
3774 3778 not s._clearable
3775 3779 or (commit and s._allowcommit)
3776 3780 or (s._opname == b'merge' and skipmerge)
3777 3781 or s._reportonly
3778 3782 ):
3779 3783 continue
3780 3784 if s.isunfinished(repo):
3781 3785 raise error.StateError(s.msg(), hint=s.hint())
3782 3786
3783 3787
3784 3788 def clearunfinished(repo):
3785 3789 """Check for unfinished operations (as above), and clear the ones
3786 3790 that are clearable.
3787 3791 """
3788 3792 for state in statemod._unfinishedstates:
3789 3793 if state._reportonly:
3790 3794 continue
3791 3795 if not state._clearable and state.isunfinished(repo):
3792 3796 raise error.StateError(state.msg(), hint=state.hint())
3793 3797
3794 3798 for s in statemod._unfinishedstates:
3795 3799 if s._opname == b'merge' or s._reportonly:
3796 3800 continue
3797 3801 if s._clearable and s.isunfinished(repo):
3798 3802 util.unlink(repo.vfs.join(s._fname))
3799 3803
3800 3804
3801 3805 def getunfinishedstate(repo):
3802 3806 """Checks for unfinished operations and returns statecheck object
3803 3807 for it"""
3804 3808 for state in statemod._unfinishedstates:
3805 3809 if state.isunfinished(repo):
3806 3810 return state
3807 3811 return None
3808 3812
3809 3813
3810 3814 def howtocontinue(repo):
3811 3815 """Check for an unfinished operation and return the command to finish
3812 3816 it.
3813 3817
3814 3818 statemod._unfinishedstates list is checked for an unfinished operation
3815 3819 and the corresponding message to finish it is generated if a method to
3816 3820 continue is supported by the operation.
3817 3821
3818 3822 Returns a (msg, warning) tuple. 'msg' is a string and 'warning' is
3819 3823 a boolean.
3820 3824 """
3821 3825 contmsg = _(b"continue: %s")
3822 3826 for state in statemod._unfinishedstates:
3823 3827 if not state._continueflag:
3824 3828 continue
3825 3829 if state.isunfinished(repo):
3826 3830 return contmsg % state.continuemsg(), True
3827 3831 if repo[None].dirty(missing=True, merge=False, branch=False):
3828 3832 return contmsg % _(b"hg commit"), False
3829 3833 return None, None
3830 3834
3831 3835
3832 3836 def checkafterresolved(repo):
3833 3837 """Inform the user about the next action after completing hg resolve
3834 3838
3835 3839 If there's a an unfinished operation that supports continue flag,
3836 3840 howtocontinue will yield repo.ui.warn as the reporter.
3837 3841
3838 3842 Otherwise, it will yield repo.ui.note.
3839 3843 """
3840 3844 msg, warning = howtocontinue(repo)
3841 3845 if msg is not None:
3842 3846 if warning:
3843 3847 repo.ui.warn(b"%s\n" % msg)
3844 3848 else:
3845 3849 repo.ui.note(b"%s\n" % msg)
3846 3850
3847 3851
3848 3852 def wrongtooltocontinue(repo, task):
3849 3853 """Raise an abort suggesting how to properly continue if there is an
3850 3854 active task.
3851 3855
3852 3856 Uses howtocontinue() to find the active task.
3853 3857
3854 3858 If there's no task (repo.ui.note for 'hg commit'), it does not offer
3855 3859 a hint.
3856 3860 """
3857 3861 after = howtocontinue(repo)
3858 3862 hint = None
3859 3863 if after[1]:
3860 3864 hint = after[0]
3861 3865 raise error.StateError(_(b'no %s in progress') % task, hint=hint)
3862 3866
3863 3867
3864 3868 def abortgraft(ui, repo, graftstate):
3865 3869 """abort the interrupted graft and rollbacks to the state before interrupted
3866 3870 graft"""
3867 3871 if not graftstate.exists():
3868 3872 raise error.StateError(_(b"no interrupted graft to abort"))
3869 3873 statedata = readgraftstate(repo, graftstate)
3870 3874 newnodes = statedata.get(b'newnodes')
3871 3875 if newnodes is None:
3872 3876 # and old graft state which does not have all the data required to abort
3873 3877 # the graft
3874 3878 raise error.Abort(_(b"cannot abort using an old graftstate"))
3875 3879
3876 3880 # changeset from which graft operation was started
3877 3881 if len(newnodes) > 0:
3878 3882 startctx = repo[newnodes[0]].p1()
3879 3883 else:
3880 3884 startctx = repo[b'.']
3881 3885 # whether to strip or not
3882 3886 cleanup = False
3883 3887
3884 3888 if newnodes:
3885 3889 newnodes = [repo[r].rev() for r in newnodes]
3886 3890 cleanup = True
3887 3891 # checking that none of the newnodes turned public or is public
3888 3892 immutable = [c for c in newnodes if not repo[c].mutable()]
3889 3893 if immutable:
3890 3894 repo.ui.warn(
3891 3895 _(b"cannot clean up public changesets %s\n")
3892 3896 % b', '.join(bytes(repo[r]) for r in immutable),
3893 3897 hint=_(b"see 'hg help phases' for details"),
3894 3898 )
3895 3899 cleanup = False
3896 3900
3897 3901 # checking that no new nodes are created on top of grafted revs
3898 3902 desc = set(repo.changelog.descendants(newnodes))
3899 3903 if desc - set(newnodes):
3900 3904 repo.ui.warn(
3901 3905 _(
3902 3906 b"new changesets detected on destination "
3903 3907 b"branch, can't strip\n"
3904 3908 )
3905 3909 )
3906 3910 cleanup = False
3907 3911
3908 3912 if cleanup:
3909 3913 with repo.wlock(), repo.lock():
3910 3914 mergemod.clean_update(startctx)
3911 3915 # stripping the new nodes created
3912 3916 strippoints = [
3913 3917 c.node() for c in repo.set(b"roots(%ld)", newnodes)
3914 3918 ]
3915 3919 repair.strip(repo.ui, repo, strippoints, backup=False)
3916 3920
3917 3921 if not cleanup:
3918 3922 # we don't update to the startnode if we can't strip
3919 3923 startctx = repo[b'.']
3920 3924 mergemod.clean_update(startctx)
3921 3925
3922 3926 ui.status(_(b"graft aborted\n"))
3923 3927 ui.status(_(b"working directory is now at %s\n") % startctx.hex()[:12])
3924 3928 graftstate.delete()
3925 3929 return 0
3926 3930
3927 3931
3928 3932 def readgraftstate(repo, graftstate):
3929 3933 # type: (Any, statemod.cmdstate) -> Dict[bytes, Any]
3930 3934 """read the graft state file and return a dict of the data stored in it"""
3931 3935 try:
3932 3936 return graftstate.read()
3933 3937 except error.CorruptedState:
3934 3938 nodes = repo.vfs.read(b'graftstate').splitlines()
3935 3939 return {b'nodes': nodes}
3936 3940
3937 3941
3938 3942 def hgabortgraft(ui, repo):
3939 3943 """abort logic for aborting graft using 'hg abort'"""
3940 3944 with repo.wlock():
3941 3945 graftstate = statemod.cmdstate(repo, b'graftstate')
3942 3946 return abortgraft(ui, repo, graftstate)
General Comments 0
You need to be logged in to leave comments. Login now