##// END OF EJS Templates
cmdutil: pass ctx to makefileobj() in place of repo/node pair (API)
Yuya Nishihara -
r36223:976e1cfb default
parent child Browse files
Show More
@@ -1,1493 +1,1492 b''
1 1 # Copyright 2009-2010 Gregory P. Ward
2 2 # Copyright 2009-2010 Intelerad Medical Systems Incorporated
3 3 # Copyright 2010-2011 Fog Creek Software
4 4 # Copyright 2010-2011 Unity Technologies
5 5 #
6 6 # This software may be used and distributed according to the terms of the
7 7 # GNU General Public License version 2 or any later version.
8 8
9 9 '''Overridden Mercurial commands and functions for the largefiles extension'''
10 10 from __future__ import absolute_import
11 11
12 12 import copy
13 13 import os
14 14
15 15 from mercurial.i18n import _
16 16
17 17 from mercurial import (
18 18 archival,
19 19 cmdutil,
20 20 error,
21 21 hg,
22 22 logcmdutil,
23 23 match as matchmod,
24 24 pathutil,
25 25 pycompat,
26 26 registrar,
27 27 scmutil,
28 28 smartset,
29 29 util,
30 30 )
31 31
32 32 from . import (
33 33 lfcommands,
34 34 lfutil,
35 35 storefactory,
36 36 )
37 37
38 38 # -- Utility functions: commonly/repeatedly needed functionality ---------------
39 39
40 40 def composelargefilematcher(match, manifest):
41 41 '''create a matcher that matches only the largefiles in the original
42 42 matcher'''
43 43 m = copy.copy(match)
44 44 lfile = lambda f: lfutil.standin(f) in manifest
45 45 m._files = filter(lfile, m._files)
46 46 m._fileset = set(m._files)
47 47 m.always = lambda: False
48 48 origmatchfn = m.matchfn
49 49 m.matchfn = lambda f: lfile(f) and origmatchfn(f)
50 50 return m
51 51
52 52 def composenormalfilematcher(match, manifest, exclude=None):
53 53 excluded = set()
54 54 if exclude is not None:
55 55 excluded.update(exclude)
56 56
57 57 m = copy.copy(match)
58 58 notlfile = lambda f: not (lfutil.isstandin(f) or lfutil.standin(f) in
59 59 manifest or f in excluded)
60 60 m._files = filter(notlfile, m._files)
61 61 m._fileset = set(m._files)
62 62 m.always = lambda: False
63 63 origmatchfn = m.matchfn
64 64 m.matchfn = lambda f: notlfile(f) and origmatchfn(f)
65 65 return m
66 66
67 67 def installnormalfilesmatchfn(manifest):
68 68 '''installmatchfn with a matchfn that ignores all largefiles'''
69 69 def overridematch(ctx, pats=(), opts=None, globbed=False,
70 70 default='relpath', badfn=None):
71 71 if opts is None:
72 72 opts = {}
73 73 match = oldmatch(ctx, pats, opts, globbed, default, badfn=badfn)
74 74 return composenormalfilematcher(match, manifest)
75 75 oldmatch = installmatchfn(overridematch)
76 76
77 77 def installmatchfn(f):
78 78 '''monkey patch the scmutil module with a custom match function.
79 79 Warning: it is monkey patching the _module_ on runtime! Not thread safe!'''
80 80 oldmatch = scmutil.match
81 81 setattr(f, 'oldmatch', oldmatch)
82 82 scmutil.match = f
83 83 return oldmatch
84 84
85 85 def restorematchfn():
86 86 '''restores scmutil.match to what it was before installmatchfn
87 87 was called. no-op if scmutil.match is its original function.
88 88
89 89 Note that n calls to installmatchfn will require n calls to
90 90 restore the original matchfn.'''
91 91 scmutil.match = getattr(scmutil.match, 'oldmatch')
92 92
93 93 def installmatchandpatsfn(f):
94 94 oldmatchandpats = scmutil.matchandpats
95 95 setattr(f, 'oldmatchandpats', oldmatchandpats)
96 96 scmutil.matchandpats = f
97 97 return oldmatchandpats
98 98
99 99 def restorematchandpatsfn():
100 100 '''restores scmutil.matchandpats to what it was before
101 101 installmatchandpatsfn was called. No-op if scmutil.matchandpats
102 102 is its original function.
103 103
104 104 Note that n calls to installmatchandpatsfn will require n calls
105 105 to restore the original matchfn.'''
106 106 scmutil.matchandpats = getattr(scmutil.matchandpats, 'oldmatchandpats',
107 107 scmutil.matchandpats)
108 108
109 109 def addlargefiles(ui, repo, isaddremove, matcher, **opts):
110 110 large = opts.get(r'large')
111 111 lfsize = lfutil.getminsize(
112 112 ui, lfutil.islfilesrepo(repo), opts.get(r'lfsize'))
113 113
114 114 lfmatcher = None
115 115 if lfutil.islfilesrepo(repo):
116 116 lfpats = ui.configlist(lfutil.longname, 'patterns')
117 117 if lfpats:
118 118 lfmatcher = matchmod.match(repo.root, '', list(lfpats))
119 119
120 120 lfnames = []
121 121 m = matcher
122 122
123 123 wctx = repo[None]
124 124 for f in wctx.walk(matchmod.badmatch(m, lambda x, y: None)):
125 125 exact = m.exact(f)
126 126 lfile = lfutil.standin(f) in wctx
127 127 nfile = f in wctx
128 128 exists = lfile or nfile
129 129
130 130 # addremove in core gets fancy with the name, add doesn't
131 131 if isaddremove:
132 132 name = m.uipath(f)
133 133 else:
134 134 name = m.rel(f)
135 135
136 136 # Don't warn the user when they attempt to add a normal tracked file.
137 137 # The normal add code will do that for us.
138 138 if exact and exists:
139 139 if lfile:
140 140 ui.warn(_('%s already a largefile\n') % name)
141 141 continue
142 142
143 143 if (exact or not exists) and not lfutil.isstandin(f):
144 144 # In case the file was removed previously, but not committed
145 145 # (issue3507)
146 146 if not repo.wvfs.exists(f):
147 147 continue
148 148
149 149 abovemin = (lfsize and
150 150 repo.wvfs.lstat(f).st_size >= lfsize * 1024 * 1024)
151 151 if large or abovemin or (lfmatcher and lfmatcher(f)):
152 152 lfnames.append(f)
153 153 if ui.verbose or not exact:
154 154 ui.status(_('adding %s as a largefile\n') % name)
155 155
156 156 bad = []
157 157
158 158 # Need to lock, otherwise there could be a race condition between
159 159 # when standins are created and added to the repo.
160 160 with repo.wlock():
161 161 if not opts.get(r'dry_run'):
162 162 standins = []
163 163 lfdirstate = lfutil.openlfdirstate(ui, repo)
164 164 for f in lfnames:
165 165 standinname = lfutil.standin(f)
166 166 lfutil.writestandin(repo, standinname, hash='',
167 167 executable=lfutil.getexecutable(repo.wjoin(f)))
168 168 standins.append(standinname)
169 169 if lfdirstate[f] == 'r':
170 170 lfdirstate.normallookup(f)
171 171 else:
172 172 lfdirstate.add(f)
173 173 lfdirstate.write()
174 174 bad += [lfutil.splitstandin(f)
175 175 for f in repo[None].add(standins)
176 176 if f in m.files()]
177 177
178 178 added = [f for f in lfnames if f not in bad]
179 179 return added, bad
180 180
181 181 def removelargefiles(ui, repo, isaddremove, matcher, **opts):
182 182 after = opts.get(r'after')
183 183 m = composelargefilematcher(matcher, repo[None].manifest())
184 184 try:
185 185 repo.lfstatus = True
186 186 s = repo.status(match=m, clean=not isaddremove)
187 187 finally:
188 188 repo.lfstatus = False
189 189 manifest = repo[None].manifest()
190 190 modified, added, deleted, clean = [[f for f in list
191 191 if lfutil.standin(f) in manifest]
192 192 for list in (s.modified, s.added,
193 193 s.deleted, s.clean)]
194 194
195 195 def warn(files, msg):
196 196 for f in files:
197 197 ui.warn(msg % m.rel(f))
198 198 return int(len(files) > 0)
199 199
200 200 result = 0
201 201
202 202 if after:
203 203 remove = deleted
204 204 result = warn(modified + added + clean,
205 205 _('not removing %s: file still exists\n'))
206 206 else:
207 207 remove = deleted + clean
208 208 result = warn(modified, _('not removing %s: file is modified (use -f'
209 209 ' to force removal)\n'))
210 210 result = warn(added, _('not removing %s: file has been marked for add'
211 211 ' (use forget to undo)\n')) or result
212 212
213 213 # Need to lock because standin files are deleted then removed from the
214 214 # repository and we could race in-between.
215 215 with repo.wlock():
216 216 lfdirstate = lfutil.openlfdirstate(ui, repo)
217 217 for f in sorted(remove):
218 218 if ui.verbose or not m.exact(f):
219 219 # addremove in core gets fancy with the name, remove doesn't
220 220 if isaddremove:
221 221 name = m.uipath(f)
222 222 else:
223 223 name = m.rel(f)
224 224 ui.status(_('removing %s\n') % name)
225 225
226 226 if not opts.get(r'dry_run'):
227 227 if not after:
228 228 repo.wvfs.unlinkpath(f, ignoremissing=True)
229 229
230 230 if opts.get(r'dry_run'):
231 231 return result
232 232
233 233 remove = [lfutil.standin(f) for f in remove]
234 234 # If this is being called by addremove, let the original addremove
235 235 # function handle this.
236 236 if not isaddremove:
237 237 for f in remove:
238 238 repo.wvfs.unlinkpath(f, ignoremissing=True)
239 239 repo[None].forget(remove)
240 240
241 241 for f in remove:
242 242 lfutil.synclfdirstate(repo, lfdirstate, lfutil.splitstandin(f),
243 243 False)
244 244
245 245 lfdirstate.write()
246 246
247 247 return result
248 248
249 249 # For overriding mercurial.hgweb.webcommands so that largefiles will
250 250 # appear at their right place in the manifests.
251 251 def decodepath(orig, path):
252 252 return lfutil.splitstandin(path) or path
253 253
254 254 # -- Wrappers: modify existing commands --------------------------------
255 255
256 256 def overrideadd(orig, ui, repo, *pats, **opts):
257 257 if opts.get(r'normal') and opts.get(r'large'):
258 258 raise error.Abort(_('--normal cannot be used with --large'))
259 259 return orig(ui, repo, *pats, **opts)
260 260
261 261 def cmdutiladd(orig, ui, repo, matcher, prefix, explicitonly, **opts):
262 262 # The --normal flag short circuits this override
263 263 if opts.get(r'normal'):
264 264 return orig(ui, repo, matcher, prefix, explicitonly, **opts)
265 265
266 266 ladded, lbad = addlargefiles(ui, repo, False, matcher, **opts)
267 267 normalmatcher = composenormalfilematcher(matcher, repo[None].manifest(),
268 268 ladded)
269 269 bad = orig(ui, repo, normalmatcher, prefix, explicitonly, **opts)
270 270
271 271 bad.extend(f for f in lbad)
272 272 return bad
273 273
274 274 def cmdutilremove(orig, ui, repo, matcher, prefix, after, force, subrepos):
275 275 normalmatcher = composenormalfilematcher(matcher, repo[None].manifest())
276 276 result = orig(ui, repo, normalmatcher, prefix, after, force, subrepos)
277 277 return removelargefiles(ui, repo, False, matcher, after=after,
278 278 force=force) or result
279 279
280 280 def overridestatusfn(orig, repo, rev2, **opts):
281 281 try:
282 282 repo._repo.lfstatus = True
283 283 return orig(repo, rev2, **opts)
284 284 finally:
285 285 repo._repo.lfstatus = False
286 286
287 287 def overridestatus(orig, ui, repo, *pats, **opts):
288 288 try:
289 289 repo.lfstatus = True
290 290 return orig(ui, repo, *pats, **opts)
291 291 finally:
292 292 repo.lfstatus = False
293 293
294 294 def overridedirty(orig, repo, ignoreupdate=False, missing=False):
295 295 try:
296 296 repo._repo.lfstatus = True
297 297 return orig(repo, ignoreupdate=ignoreupdate, missing=missing)
298 298 finally:
299 299 repo._repo.lfstatus = False
300 300
301 301 def overridelog(orig, ui, repo, *pats, **opts):
302 302 def overridematchandpats(ctx, pats=(), opts=None, globbed=False,
303 303 default='relpath', badfn=None):
304 304 """Matcher that merges root directory with .hglf, suitable for log.
305 305 It is still possible to match .hglf directly.
306 306 For any listed files run log on the standin too.
307 307 matchfn tries both the given filename and with .hglf stripped.
308 308 """
309 309 if opts is None:
310 310 opts = {}
311 311 matchandpats = oldmatchandpats(ctx, pats, opts, globbed, default,
312 312 badfn=badfn)
313 313 m, p = copy.copy(matchandpats)
314 314
315 315 if m.always():
316 316 # We want to match everything anyway, so there's no benefit trying
317 317 # to add standins.
318 318 return matchandpats
319 319
320 320 pats = set(p)
321 321
322 322 def fixpats(pat, tostandin=lfutil.standin):
323 323 if pat.startswith('set:'):
324 324 return pat
325 325
326 326 kindpat = matchmod._patsplit(pat, None)
327 327
328 328 if kindpat[0] is not None:
329 329 return kindpat[0] + ':' + tostandin(kindpat[1])
330 330 return tostandin(kindpat[1])
331 331
332 332 if m._cwd:
333 333 hglf = lfutil.shortname
334 334 back = util.pconvert(m.rel(hglf)[:-len(hglf)])
335 335
336 336 def tostandin(f):
337 337 # The file may already be a standin, so truncate the back
338 338 # prefix and test before mangling it. This avoids turning
339 339 # 'glob:../.hglf/foo*' into 'glob:../.hglf/../.hglf/foo*'.
340 340 if f.startswith(back) and lfutil.splitstandin(f[len(back):]):
341 341 return f
342 342
343 343 # An absolute path is from outside the repo, so truncate the
344 344 # path to the root before building the standin. Otherwise cwd
345 345 # is somewhere in the repo, relative to root, and needs to be
346 346 # prepended before building the standin.
347 347 if os.path.isabs(m._cwd):
348 348 f = f[len(back):]
349 349 else:
350 350 f = m._cwd + '/' + f
351 351 return back + lfutil.standin(f)
352 352 else:
353 353 def tostandin(f):
354 354 if lfutil.isstandin(f):
355 355 return f
356 356 return lfutil.standin(f)
357 357 pats.update(fixpats(f, tostandin) for f in p)
358 358
359 359 for i in range(0, len(m._files)):
360 360 # Don't add '.hglf' to m.files, since that is already covered by '.'
361 361 if m._files[i] == '.':
362 362 continue
363 363 standin = lfutil.standin(m._files[i])
364 364 # If the "standin" is a directory, append instead of replace to
365 365 # support naming a directory on the command line with only
366 366 # largefiles. The original directory is kept to support normal
367 367 # files.
368 368 if standin in ctx:
369 369 m._files[i] = standin
370 370 elif m._files[i] not in ctx and repo.wvfs.isdir(standin):
371 371 m._files.append(standin)
372 372
373 373 m._fileset = set(m._files)
374 374 m.always = lambda: False
375 375 origmatchfn = m.matchfn
376 376 def lfmatchfn(f):
377 377 lf = lfutil.splitstandin(f)
378 378 if lf is not None and origmatchfn(lf):
379 379 return True
380 380 r = origmatchfn(f)
381 381 return r
382 382 m.matchfn = lfmatchfn
383 383
384 384 ui.debug('updated patterns: %s\n' % ', '.join(sorted(pats)))
385 385 return m, pats
386 386
387 387 # For hg log --patch, the match object is used in two different senses:
388 388 # (1) to determine what revisions should be printed out, and
389 389 # (2) to determine what files to print out diffs for.
390 390 # The magic matchandpats override should be used for case (1) but not for
391 391 # case (2).
392 392 def overridemakefilematcher(repo, pats, opts, badfn=None):
393 393 wctx = repo[None]
394 394 match, pats = oldmatchandpats(wctx, pats, opts, badfn=badfn)
395 395 return lambda ctx: match
396 396
397 397 oldmatchandpats = installmatchandpatsfn(overridematchandpats)
398 398 oldmakefilematcher = logcmdutil._makenofollowfilematcher
399 399 setattr(logcmdutil, '_makenofollowfilematcher', overridemakefilematcher)
400 400
401 401 try:
402 402 return orig(ui, repo, *pats, **opts)
403 403 finally:
404 404 restorematchandpatsfn()
405 405 setattr(logcmdutil, '_makenofollowfilematcher', oldmakefilematcher)
406 406
407 407 def overrideverify(orig, ui, repo, *pats, **opts):
408 408 large = opts.pop(r'large', False)
409 409 all = opts.pop(r'lfa', False)
410 410 contents = opts.pop(r'lfc', False)
411 411
412 412 result = orig(ui, repo, *pats, **opts)
413 413 if large or all or contents:
414 414 result = result or lfcommands.verifylfiles(ui, repo, all, contents)
415 415 return result
416 416
417 417 def overridedebugstate(orig, ui, repo, *pats, **opts):
418 418 large = opts.pop(r'large', False)
419 419 if large:
420 420 class fakerepo(object):
421 421 dirstate = lfutil.openlfdirstate(ui, repo)
422 422 orig(ui, fakerepo, *pats, **opts)
423 423 else:
424 424 orig(ui, repo, *pats, **opts)
425 425
426 426 # Before starting the manifest merge, merge.updates will call
427 427 # _checkunknownfile to check if there are any files in the merged-in
428 428 # changeset that collide with unknown files in the working copy.
429 429 #
430 430 # The largefiles are seen as unknown, so this prevents us from merging
431 431 # in a file 'foo' if we already have a largefile with the same name.
432 432 #
433 433 # The overridden function filters the unknown files by removing any
434 434 # largefiles. This makes the merge proceed and we can then handle this
435 435 # case further in the overridden calculateupdates function below.
436 436 def overridecheckunknownfile(origfn, repo, wctx, mctx, f, f2=None):
437 437 if lfutil.standin(repo.dirstate.normalize(f)) in wctx:
438 438 return False
439 439 return origfn(repo, wctx, mctx, f, f2)
440 440
441 441 # The manifest merge handles conflicts on the manifest level. We want
442 442 # to handle changes in largefile-ness of files at this level too.
443 443 #
444 444 # The strategy is to run the original calculateupdates and then process
445 445 # the action list it outputs. There are two cases we need to deal with:
446 446 #
447 447 # 1. Normal file in p1, largefile in p2. Here the largefile is
448 448 # detected via its standin file, which will enter the working copy
449 449 # with a "get" action. It is not "merge" since the standin is all
450 450 # Mercurial is concerned with at this level -- the link to the
451 451 # existing normal file is not relevant here.
452 452 #
453 453 # 2. Largefile in p1, normal file in p2. Here we get a "merge" action
454 454 # since the largefile will be present in the working copy and
455 455 # different from the normal file in p2. Mercurial therefore
456 456 # triggers a merge action.
457 457 #
458 458 # In both cases, we prompt the user and emit new actions to either
459 459 # remove the standin (if the normal file was kept) or to remove the
460 460 # normal file and get the standin (if the largefile was kept). The
461 461 # default prompt answer is to use the largefile version since it was
462 462 # presumably changed on purpose.
463 463 #
464 464 # Finally, the merge.applyupdates function will then take care of
465 465 # writing the files into the working copy and lfcommands.updatelfiles
466 466 # will update the largefiles.
467 467 def overridecalculateupdates(origfn, repo, p1, p2, pas, branchmerge, force,
468 468 acceptremote, *args, **kwargs):
469 469 overwrite = force and not branchmerge
470 470 actions, diverge, renamedelete = origfn(
471 471 repo, p1, p2, pas, branchmerge, force, acceptremote, *args, **kwargs)
472 472
473 473 if overwrite:
474 474 return actions, diverge, renamedelete
475 475
476 476 # Convert to dictionary with filename as key and action as value.
477 477 lfiles = set()
478 478 for f in actions:
479 479 splitstandin = lfutil.splitstandin(f)
480 480 if splitstandin in p1:
481 481 lfiles.add(splitstandin)
482 482 elif lfutil.standin(f) in p1:
483 483 lfiles.add(f)
484 484
485 485 for lfile in sorted(lfiles):
486 486 standin = lfutil.standin(lfile)
487 487 (lm, largs, lmsg) = actions.get(lfile, (None, None, None))
488 488 (sm, sargs, smsg) = actions.get(standin, (None, None, None))
489 489 if sm in ('g', 'dc') and lm != 'r':
490 490 if sm == 'dc':
491 491 f1, f2, fa, move, anc = sargs
492 492 sargs = (p2[f2].flags(), False)
493 493 # Case 1: normal file in the working copy, largefile in
494 494 # the second parent
495 495 usermsg = _('remote turned local normal file %s into a largefile\n'
496 496 'use (l)argefile or keep (n)ormal file?'
497 497 '$$ &Largefile $$ &Normal file') % lfile
498 498 if repo.ui.promptchoice(usermsg, 0) == 0: # pick remote largefile
499 499 actions[lfile] = ('r', None, 'replaced by standin')
500 500 actions[standin] = ('g', sargs, 'replaces standin')
501 501 else: # keep local normal file
502 502 actions[lfile] = ('k', None, 'replaces standin')
503 503 if branchmerge:
504 504 actions[standin] = ('k', None, 'replaced by non-standin')
505 505 else:
506 506 actions[standin] = ('r', None, 'replaced by non-standin')
507 507 elif lm in ('g', 'dc') and sm != 'r':
508 508 if lm == 'dc':
509 509 f1, f2, fa, move, anc = largs
510 510 largs = (p2[f2].flags(), False)
511 511 # Case 2: largefile in the working copy, normal file in
512 512 # the second parent
513 513 usermsg = _('remote turned local largefile %s into a normal file\n'
514 514 'keep (l)argefile or use (n)ormal file?'
515 515 '$$ &Largefile $$ &Normal file') % lfile
516 516 if repo.ui.promptchoice(usermsg, 0) == 0: # keep local largefile
517 517 if branchmerge:
518 518 # largefile can be restored from standin safely
519 519 actions[lfile] = ('k', None, 'replaced by standin')
520 520 actions[standin] = ('k', None, 'replaces standin')
521 521 else:
522 522 # "lfile" should be marked as "removed" without
523 523 # removal of itself
524 524 actions[lfile] = ('lfmr', None,
525 525 'forget non-standin largefile')
526 526
527 527 # linear-merge should treat this largefile as 're-added'
528 528 actions[standin] = ('a', None, 'keep standin')
529 529 else: # pick remote normal file
530 530 actions[lfile] = ('g', largs, 'replaces standin')
531 531 actions[standin] = ('r', None, 'replaced by non-standin')
532 532
533 533 return actions, diverge, renamedelete
534 534
535 535 def mergerecordupdates(orig, repo, actions, branchmerge):
536 536 if 'lfmr' in actions:
537 537 lfdirstate = lfutil.openlfdirstate(repo.ui, repo)
538 538 for lfile, args, msg in actions['lfmr']:
539 539 # this should be executed before 'orig', to execute 'remove'
540 540 # before all other actions
541 541 repo.dirstate.remove(lfile)
542 542 # make sure lfile doesn't get synclfdirstate'd as normal
543 543 lfdirstate.add(lfile)
544 544 lfdirstate.write()
545 545
546 546 return orig(repo, actions, branchmerge)
547 547
548 548 # Override filemerge to prompt the user about how they wish to merge
549 549 # largefiles. This will handle identical edits without prompting the user.
550 550 def overridefilemerge(origfn, premerge, repo, wctx, mynode, orig, fcd, fco, fca,
551 551 labels=None):
552 552 if not lfutil.isstandin(orig) or fcd.isabsent() or fco.isabsent():
553 553 return origfn(premerge, repo, wctx, mynode, orig, fcd, fco, fca,
554 554 labels=labels)
555 555
556 556 ahash = lfutil.readasstandin(fca).lower()
557 557 dhash = lfutil.readasstandin(fcd).lower()
558 558 ohash = lfutil.readasstandin(fco).lower()
559 559 if (ohash != ahash and
560 560 ohash != dhash and
561 561 (dhash == ahash or
562 562 repo.ui.promptchoice(
563 563 _('largefile %s has a merge conflict\nancestor was %s\n'
564 564 'keep (l)ocal %s or\ntake (o)ther %s?'
565 565 '$$ &Local $$ &Other') %
566 566 (lfutil.splitstandin(orig), ahash, dhash, ohash),
567 567 0) == 1)):
568 568 repo.wwrite(fcd.path(), fco.data(), fco.flags())
569 569 return True, 0, False
570 570
571 571 def copiespathcopies(orig, ctx1, ctx2, match=None):
572 572 copies = orig(ctx1, ctx2, match=match)
573 573 updated = {}
574 574
575 575 for k, v in copies.iteritems():
576 576 updated[lfutil.splitstandin(k) or k] = lfutil.splitstandin(v) or v
577 577
578 578 return updated
579 579
580 580 # Copy first changes the matchers to match standins instead of
581 581 # largefiles. Then it overrides util.copyfile in that function it
582 582 # checks if the destination largefile already exists. It also keeps a
583 583 # list of copied files so that the largefiles can be copied and the
584 584 # dirstate updated.
585 585 def overridecopy(orig, ui, repo, pats, opts, rename=False):
586 586 # doesn't remove largefile on rename
587 587 if len(pats) < 2:
588 588 # this isn't legal, let the original function deal with it
589 589 return orig(ui, repo, pats, opts, rename)
590 590
591 591 # This could copy both lfiles and normal files in one command,
592 592 # but we don't want to do that. First replace their matcher to
593 593 # only match normal files and run it, then replace it to just
594 594 # match largefiles and run it again.
595 595 nonormalfiles = False
596 596 nolfiles = False
597 597 installnormalfilesmatchfn(repo[None].manifest())
598 598 try:
599 599 result = orig(ui, repo, pats, opts, rename)
600 600 except error.Abort as e:
601 601 if str(e) != _('no files to copy'):
602 602 raise e
603 603 else:
604 604 nonormalfiles = True
605 605 result = 0
606 606 finally:
607 607 restorematchfn()
608 608
609 609 # The first rename can cause our current working directory to be removed.
610 610 # In that case there is nothing left to copy/rename so just quit.
611 611 try:
612 612 repo.getcwd()
613 613 except OSError:
614 614 return result
615 615
616 616 def makestandin(relpath):
617 617 path = pathutil.canonpath(repo.root, repo.getcwd(), relpath)
618 618 return repo.wvfs.join(lfutil.standin(path))
619 619
620 620 fullpats = scmutil.expandpats(pats)
621 621 dest = fullpats[-1]
622 622
623 623 if os.path.isdir(dest):
624 624 if not os.path.isdir(makestandin(dest)):
625 625 os.makedirs(makestandin(dest))
626 626
627 627 try:
628 628 # When we call orig below it creates the standins but we don't add
629 629 # them to the dir state until later so lock during that time.
630 630 wlock = repo.wlock()
631 631
632 632 manifest = repo[None].manifest()
633 633 def overridematch(ctx, pats=(), opts=None, globbed=False,
634 634 default='relpath', badfn=None):
635 635 if opts is None:
636 636 opts = {}
637 637 newpats = []
638 638 # The patterns were previously mangled to add the standin
639 639 # directory; we need to remove that now
640 640 for pat in pats:
641 641 if matchmod.patkind(pat) is None and lfutil.shortname in pat:
642 642 newpats.append(pat.replace(lfutil.shortname, ''))
643 643 else:
644 644 newpats.append(pat)
645 645 match = oldmatch(ctx, newpats, opts, globbed, default, badfn=badfn)
646 646 m = copy.copy(match)
647 647 lfile = lambda f: lfutil.standin(f) in manifest
648 648 m._files = [lfutil.standin(f) for f in m._files if lfile(f)]
649 649 m._fileset = set(m._files)
650 650 origmatchfn = m.matchfn
651 651 def matchfn(f):
652 652 lfile = lfutil.splitstandin(f)
653 653 return (lfile is not None and
654 654 (f in manifest) and
655 655 origmatchfn(lfile) or
656 656 None)
657 657 m.matchfn = matchfn
658 658 return m
659 659 oldmatch = installmatchfn(overridematch)
660 660 listpats = []
661 661 for pat in pats:
662 662 if matchmod.patkind(pat) is not None:
663 663 listpats.append(pat)
664 664 else:
665 665 listpats.append(makestandin(pat))
666 666
667 667 try:
668 668 origcopyfile = util.copyfile
669 669 copiedfiles = []
670 670 def overridecopyfile(src, dest):
671 671 if (lfutil.shortname in src and
672 672 dest.startswith(repo.wjoin(lfutil.shortname))):
673 673 destlfile = dest.replace(lfutil.shortname, '')
674 674 if not opts['force'] and os.path.exists(destlfile):
675 675 raise IOError('',
676 676 _('destination largefile already exists'))
677 677 copiedfiles.append((src, dest))
678 678 origcopyfile(src, dest)
679 679
680 680 util.copyfile = overridecopyfile
681 681 result += orig(ui, repo, listpats, opts, rename)
682 682 finally:
683 683 util.copyfile = origcopyfile
684 684
685 685 lfdirstate = lfutil.openlfdirstate(ui, repo)
686 686 for (src, dest) in copiedfiles:
687 687 if (lfutil.shortname in src and
688 688 dest.startswith(repo.wjoin(lfutil.shortname))):
689 689 srclfile = src.replace(repo.wjoin(lfutil.standin('')), '')
690 690 destlfile = dest.replace(repo.wjoin(lfutil.standin('')), '')
691 691 destlfiledir = repo.wvfs.dirname(repo.wjoin(destlfile)) or '.'
692 692 if not os.path.isdir(destlfiledir):
693 693 os.makedirs(destlfiledir)
694 694 if rename:
695 695 os.rename(repo.wjoin(srclfile), repo.wjoin(destlfile))
696 696
697 697 # The file is gone, but this deletes any empty parent
698 698 # directories as a side-effect.
699 699 repo.wvfs.unlinkpath(srclfile, ignoremissing=True)
700 700 lfdirstate.remove(srclfile)
701 701 else:
702 702 util.copyfile(repo.wjoin(srclfile),
703 703 repo.wjoin(destlfile))
704 704
705 705 lfdirstate.add(destlfile)
706 706 lfdirstate.write()
707 707 except error.Abort as e:
708 708 if str(e) != _('no files to copy'):
709 709 raise e
710 710 else:
711 711 nolfiles = True
712 712 finally:
713 713 restorematchfn()
714 714 wlock.release()
715 715
716 716 if nolfiles and nonormalfiles:
717 717 raise error.Abort(_('no files to copy'))
718 718
719 719 return result
720 720
721 721 # When the user calls revert, we have to be careful to not revert any
722 722 # changes to other largefiles accidentally. This means we have to keep
723 723 # track of the largefiles that are being reverted so we only pull down
724 724 # the necessary largefiles.
725 725 #
726 726 # Standins are only updated (to match the hash of largefiles) before
727 727 # commits. Update the standins then run the original revert, changing
728 728 # the matcher to hit standins instead of largefiles. Based on the
729 729 # resulting standins update the largefiles.
730 730 def overriderevert(orig, ui, repo, ctx, parents, *pats, **opts):
731 731 # Because we put the standins in a bad state (by updating them)
732 732 # and then return them to a correct state we need to lock to
733 733 # prevent others from changing them in their incorrect state.
734 734 with repo.wlock():
735 735 lfdirstate = lfutil.openlfdirstate(ui, repo)
736 736 s = lfutil.lfdirstatestatus(lfdirstate, repo)
737 737 lfdirstate.write()
738 738 for lfile in s.modified:
739 739 lfutil.updatestandin(repo, lfile, lfutil.standin(lfile))
740 740 for lfile in s.deleted:
741 741 fstandin = lfutil.standin(lfile)
742 742 if (repo.wvfs.exists(fstandin)):
743 743 repo.wvfs.unlink(fstandin)
744 744
745 745 oldstandins = lfutil.getstandinsstate(repo)
746 746
747 747 def overridematch(mctx, pats=(), opts=None, globbed=False,
748 748 default='relpath', badfn=None):
749 749 if opts is None:
750 750 opts = {}
751 751 match = oldmatch(mctx, pats, opts, globbed, default, badfn=badfn)
752 752 m = copy.copy(match)
753 753
754 754 # revert supports recursing into subrepos, and though largefiles
755 755 # currently doesn't work correctly in that case, this match is
756 756 # called, so the lfdirstate above may not be the correct one for
757 757 # this invocation of match.
758 758 lfdirstate = lfutil.openlfdirstate(mctx.repo().ui, mctx.repo(),
759 759 False)
760 760
761 761 wctx = repo[None]
762 762 matchfiles = []
763 763 for f in m._files:
764 764 standin = lfutil.standin(f)
765 765 if standin in ctx or standin in mctx:
766 766 matchfiles.append(standin)
767 767 elif standin in wctx or lfdirstate[f] == 'r':
768 768 continue
769 769 else:
770 770 matchfiles.append(f)
771 771 m._files = matchfiles
772 772 m._fileset = set(m._files)
773 773 origmatchfn = m.matchfn
774 774 def matchfn(f):
775 775 lfile = lfutil.splitstandin(f)
776 776 if lfile is not None:
777 777 return (origmatchfn(lfile) and
778 778 (f in ctx or f in mctx))
779 779 return origmatchfn(f)
780 780 m.matchfn = matchfn
781 781 return m
782 782 oldmatch = installmatchfn(overridematch)
783 783 try:
784 784 orig(ui, repo, ctx, parents, *pats, **opts)
785 785 finally:
786 786 restorematchfn()
787 787
788 788 newstandins = lfutil.getstandinsstate(repo)
789 789 filelist = lfutil.getlfilestoupdate(oldstandins, newstandins)
790 790 # lfdirstate should be 'normallookup'-ed for updated files,
791 791 # because reverting doesn't touch dirstate for 'normal' files
792 792 # when target revision is explicitly specified: in such case,
793 793 # 'n' and valid timestamp in dirstate doesn't ensure 'clean'
794 794 # of target (standin) file.
795 795 lfcommands.updatelfiles(ui, repo, filelist, printmessage=False,
796 796 normallookup=True)
797 797
798 798 # after pulling changesets, we need to take some extra care to get
799 799 # largefiles updated remotely
800 800 def overridepull(orig, ui, repo, source=None, **opts):
801 801 revsprepull = len(repo)
802 802 if not source:
803 803 source = 'default'
804 804 repo.lfpullsource = source
805 805 result = orig(ui, repo, source, **opts)
806 806 revspostpull = len(repo)
807 807 lfrevs = opts.get(r'lfrev', [])
808 808 if opts.get(r'all_largefiles'):
809 809 lfrevs.append('pulled()')
810 810 if lfrevs and revspostpull > revsprepull:
811 811 numcached = 0
812 812 repo.firstpulled = revsprepull # for pulled() revset expression
813 813 try:
814 814 for rev in scmutil.revrange(repo, lfrevs):
815 815 ui.note(_('pulling largefiles for revision %s\n') % rev)
816 816 (cached, missing) = lfcommands.cachelfiles(ui, repo, rev)
817 817 numcached += len(cached)
818 818 finally:
819 819 del repo.firstpulled
820 820 ui.status(_("%d largefiles cached\n") % numcached)
821 821 return result
822 822
823 823 def overridepush(orig, ui, repo, *args, **kwargs):
824 824 """Override push command and store --lfrev parameters in opargs"""
825 825 lfrevs = kwargs.pop(r'lfrev', None)
826 826 if lfrevs:
827 827 opargs = kwargs.setdefault('opargs', {})
828 828 opargs['lfrevs'] = scmutil.revrange(repo, lfrevs)
829 829 return orig(ui, repo, *args, **kwargs)
830 830
831 831 def exchangepushoperation(orig, *args, **kwargs):
832 832 """Override pushoperation constructor and store lfrevs parameter"""
833 833 lfrevs = kwargs.pop(r'lfrevs', None)
834 834 pushop = orig(*args, **kwargs)
835 835 pushop.lfrevs = lfrevs
836 836 return pushop
837 837
838 838 revsetpredicate = registrar.revsetpredicate()
839 839
840 840 @revsetpredicate('pulled()')
841 841 def pulledrevsetsymbol(repo, subset, x):
842 842 """Changesets that just has been pulled.
843 843
844 844 Only available with largefiles from pull --lfrev expressions.
845 845
846 846 .. container:: verbose
847 847
848 848 Some examples:
849 849
850 850 - pull largefiles for all new changesets::
851 851
852 852 hg pull -lfrev "pulled()"
853 853
854 854 - pull largefiles for all new branch heads::
855 855
856 856 hg pull -lfrev "head(pulled()) and not closed()"
857 857
858 858 """
859 859
860 860 try:
861 861 firstpulled = repo.firstpulled
862 862 except AttributeError:
863 863 raise error.Abort(_("pulled() only available in --lfrev"))
864 864 return smartset.baseset([r for r in subset if r >= firstpulled])
865 865
866 866 def overrideclone(orig, ui, source, dest=None, **opts):
867 867 d = dest
868 868 if d is None:
869 869 d = hg.defaultdest(source)
870 870 if opts.get(r'all_largefiles') and not hg.islocal(d):
871 871 raise error.Abort(_(
872 872 '--all-largefiles is incompatible with non-local destination %s') %
873 873 d)
874 874
875 875 return orig(ui, source, dest, **opts)
876 876
877 877 def hgclone(orig, ui, opts, *args, **kwargs):
878 878 result = orig(ui, opts, *args, **kwargs)
879 879
880 880 if result is not None:
881 881 sourcerepo, destrepo = result
882 882 repo = destrepo.local()
883 883
884 884 # When cloning to a remote repo (like through SSH), no repo is available
885 885 # from the peer. Therefore the largefiles can't be downloaded and the
886 886 # hgrc can't be updated.
887 887 if not repo:
888 888 return result
889 889
890 890 # If largefiles is required for this repo, permanently enable it locally
891 891 if 'largefiles' in repo.requirements:
892 892 repo.vfs.append('hgrc',
893 893 util.tonativeeol('\n[extensions]\nlargefiles=\n'))
894 894
895 895 # Caching is implicitly limited to 'rev' option, since the dest repo was
896 896 # truncated at that point. The user may expect a download count with
897 897 # this option, so attempt whether or not this is a largefile repo.
898 898 if opts.get(r'all_largefiles'):
899 899 success, missing = lfcommands.downloadlfiles(ui, repo, None)
900 900
901 901 if missing != 0:
902 902 return None
903 903
904 904 return result
905 905
906 906 def hgpostshare(orig, sourcerepo, destrepo, bookmarks=True, defaultpath=None):
907 907 orig(sourcerepo, destrepo, bookmarks, defaultpath)
908 908
909 909 # If largefiles is required for this repo, permanently enable it locally
910 910 if 'largefiles' in destrepo.requirements:
911 911 destrepo.vfs.append('hgrc',
912 912 util.tonativeeol('\n[extensions]\nlargefiles=\n'))
913 913
914 914 def overriderebase(orig, ui, repo, **opts):
915 915 if not util.safehasattr(repo, '_largefilesenabled'):
916 916 return orig(ui, repo, **opts)
917 917
918 918 resuming = opts.get(r'continue')
919 919 repo._lfcommithooks.append(lfutil.automatedcommithook(resuming))
920 920 repo._lfstatuswriters.append(lambda *msg, **opts: None)
921 921 try:
922 922 return orig(ui, repo, **opts)
923 923 finally:
924 924 repo._lfstatuswriters.pop()
925 925 repo._lfcommithooks.pop()
926 926
927 927 def overridearchivecmd(orig, ui, repo, dest, **opts):
928 928 repo.unfiltered().lfstatus = True
929 929
930 930 try:
931 931 return orig(ui, repo.unfiltered(), dest, **opts)
932 932 finally:
933 933 repo.unfiltered().lfstatus = False
934 934
935 935 def hgwebarchive(orig, web, req, tmpl):
936 936 web.repo.lfstatus = True
937 937
938 938 try:
939 939 return orig(web, req, tmpl)
940 940 finally:
941 941 web.repo.lfstatus = False
942 942
943 943 def overridearchive(orig, repo, dest, node, kind, decode=True, matchfn=None,
944 944 prefix='', mtime=None, subrepos=None):
945 945 # For some reason setting repo.lfstatus in hgwebarchive only changes the
946 946 # unfiltered repo's attr, so check that as well.
947 947 if not repo.lfstatus and not repo.unfiltered().lfstatus:
948 948 return orig(repo, dest, node, kind, decode, matchfn, prefix, mtime,
949 949 subrepos)
950 950
951 951 # No need to lock because we are only reading history and
952 952 # largefile caches, neither of which are modified.
953 953 if node is not None:
954 954 lfcommands.cachelfiles(repo.ui, repo, node)
955 955
956 956 if kind not in archival.archivers:
957 957 raise error.Abort(_("unknown archive type '%s'") % kind)
958 958
959 959 ctx = repo[node]
960 960
961 961 if kind == 'files':
962 962 if prefix:
963 963 raise error.Abort(
964 964 _('cannot give prefix when archiving to files'))
965 965 else:
966 966 prefix = archival.tidyprefix(dest, kind, prefix)
967 967
968 968 def write(name, mode, islink, getdata):
969 969 if matchfn and not matchfn(name):
970 970 return
971 971 data = getdata()
972 972 if decode:
973 973 data = repo.wwritedata(name, data)
974 974 archiver.addfile(prefix + name, mode, islink, data)
975 975
976 976 archiver = archival.archivers[kind](dest, mtime or ctx.date()[0])
977 977
978 978 if repo.ui.configbool("ui", "archivemeta"):
979 979 write('.hg_archival.txt', 0o644, False,
980 980 lambda: archival.buildmetadata(ctx))
981 981
982 982 for f in ctx:
983 983 ff = ctx.flags(f)
984 984 getdata = ctx[f].data
985 985 lfile = lfutil.splitstandin(f)
986 986 if lfile is not None:
987 987 if node is not None:
988 988 path = lfutil.findfile(repo, getdata().strip())
989 989
990 990 if path is None:
991 991 raise error.Abort(
992 992 _('largefile %s not found in repo store or system cache')
993 993 % lfile)
994 994 else:
995 995 path = lfile
996 996
997 997 f = lfile
998 998
999 999 getdata = lambda: util.readfile(path)
1000 1000 write(f, 'x' in ff and 0o755 or 0o644, 'l' in ff, getdata)
1001 1001
1002 1002 if subrepos:
1003 1003 for subpath in sorted(ctx.substate):
1004 1004 sub = ctx.workingsub(subpath)
1005 1005 submatch = matchmod.subdirmatcher(subpath, matchfn)
1006 1006 sub._repo.lfstatus = True
1007 1007 sub.archive(archiver, prefix, submatch)
1008 1008
1009 1009 archiver.done()
1010 1010
1011 1011 def hgsubrepoarchive(orig, repo, archiver, prefix, match=None, decode=True):
1012 1012 lfenabled = util.safehasattr(repo._repo, '_largefilesenabled')
1013 1013 if not lfenabled or not repo._repo.lfstatus:
1014 1014 return orig(repo, archiver, prefix, match, decode)
1015 1015
1016 1016 repo._get(repo._state + ('hg',))
1017 1017 rev = repo._state[1]
1018 1018 ctx = repo._repo[rev]
1019 1019
1020 1020 if ctx.node() is not None:
1021 1021 lfcommands.cachelfiles(repo.ui, repo._repo, ctx.node())
1022 1022
1023 1023 def write(name, mode, islink, getdata):
1024 1024 # At this point, the standin has been replaced with the largefile name,
1025 1025 # so the normal matcher works here without the lfutil variants.
1026 1026 if match and not match(f):
1027 1027 return
1028 1028 data = getdata()
1029 1029 if decode:
1030 1030 data = repo._repo.wwritedata(name, data)
1031 1031
1032 1032 archiver.addfile(prefix + repo._path + '/' + name, mode, islink, data)
1033 1033
1034 1034 for f in ctx:
1035 1035 ff = ctx.flags(f)
1036 1036 getdata = ctx[f].data
1037 1037 lfile = lfutil.splitstandin(f)
1038 1038 if lfile is not None:
1039 1039 if ctx.node() is not None:
1040 1040 path = lfutil.findfile(repo._repo, getdata().strip())
1041 1041
1042 1042 if path is None:
1043 1043 raise error.Abort(
1044 1044 _('largefile %s not found in repo store or system cache')
1045 1045 % lfile)
1046 1046 else:
1047 1047 path = lfile
1048 1048
1049 1049 f = lfile
1050 1050
1051 1051 getdata = lambda: util.readfile(os.path.join(prefix, path))
1052 1052
1053 1053 write(f, 'x' in ff and 0o755 or 0o644, 'l' in ff, getdata)
1054 1054
1055 1055 for subpath in sorted(ctx.substate):
1056 1056 sub = ctx.workingsub(subpath)
1057 1057 submatch = matchmod.subdirmatcher(subpath, match)
1058 1058 sub._repo.lfstatus = True
1059 1059 sub.archive(archiver, prefix + repo._path + '/', submatch, decode)
1060 1060
1061 1061 # If a largefile is modified, the change is not reflected in its
1062 1062 # standin until a commit. cmdutil.bailifchanged() raises an exception
1063 1063 # if the repo has uncommitted changes. Wrap it to also check if
1064 1064 # largefiles were changed. This is used by bisect, backout and fetch.
1065 1065 def overridebailifchanged(orig, repo, *args, **kwargs):
1066 1066 orig(repo, *args, **kwargs)
1067 1067 repo.lfstatus = True
1068 1068 s = repo.status()
1069 1069 repo.lfstatus = False
1070 1070 if s.modified or s.added or s.removed or s.deleted:
1071 1071 raise error.Abort(_('uncommitted changes'))
1072 1072
1073 1073 def postcommitstatus(orig, repo, *args, **kwargs):
1074 1074 repo.lfstatus = True
1075 1075 try:
1076 1076 return orig(repo, *args, **kwargs)
1077 1077 finally:
1078 1078 repo.lfstatus = False
1079 1079
1080 1080 def cmdutilforget(orig, ui, repo, match, prefix, explicitonly):
1081 1081 normalmatcher = composenormalfilematcher(match, repo[None].manifest())
1082 1082 bad, forgot = orig(ui, repo, normalmatcher, prefix, explicitonly)
1083 1083 m = composelargefilematcher(match, repo[None].manifest())
1084 1084
1085 1085 try:
1086 1086 repo.lfstatus = True
1087 1087 s = repo.status(match=m, clean=True)
1088 1088 finally:
1089 1089 repo.lfstatus = False
1090 1090 manifest = repo[None].manifest()
1091 1091 forget = sorted(s.modified + s.added + s.deleted + s.clean)
1092 1092 forget = [f for f in forget if lfutil.standin(f) in manifest]
1093 1093
1094 1094 for f in forget:
1095 1095 fstandin = lfutil.standin(f)
1096 1096 if fstandin not in repo.dirstate and not repo.wvfs.isdir(fstandin):
1097 1097 ui.warn(_('not removing %s: file is already untracked\n')
1098 1098 % m.rel(f))
1099 1099 bad.append(f)
1100 1100
1101 1101 for f in forget:
1102 1102 if ui.verbose or not m.exact(f):
1103 1103 ui.status(_('removing %s\n') % m.rel(f))
1104 1104
1105 1105 # Need to lock because standin files are deleted then removed from the
1106 1106 # repository and we could race in-between.
1107 1107 with repo.wlock():
1108 1108 lfdirstate = lfutil.openlfdirstate(ui, repo)
1109 1109 for f in forget:
1110 1110 if lfdirstate[f] == 'a':
1111 1111 lfdirstate.drop(f)
1112 1112 else:
1113 1113 lfdirstate.remove(f)
1114 1114 lfdirstate.write()
1115 1115 standins = [lfutil.standin(f) for f in forget]
1116 1116 for f in standins:
1117 1117 repo.wvfs.unlinkpath(f, ignoremissing=True)
1118 1118 rejected = repo[None].forget(standins)
1119 1119
1120 1120 bad.extend(f for f in rejected if f in m.files())
1121 1121 forgot.extend(f for f in forget if f not in rejected)
1122 1122 return bad, forgot
1123 1123
1124 1124 def _getoutgoings(repo, other, missing, addfunc):
1125 1125 """get pairs of filename and largefile hash in outgoing revisions
1126 1126 in 'missing'.
1127 1127
1128 1128 largefiles already existing on 'other' repository are ignored.
1129 1129
1130 1130 'addfunc' is invoked with each unique pairs of filename and
1131 1131 largefile hash value.
1132 1132 """
1133 1133 knowns = set()
1134 1134 lfhashes = set()
1135 1135 def dedup(fn, lfhash):
1136 1136 k = (fn, lfhash)
1137 1137 if k not in knowns:
1138 1138 knowns.add(k)
1139 1139 lfhashes.add(lfhash)
1140 1140 lfutil.getlfilestoupload(repo, missing, dedup)
1141 1141 if lfhashes:
1142 1142 lfexists = storefactory.openstore(repo, other).exists(lfhashes)
1143 1143 for fn, lfhash in knowns:
1144 1144 if not lfexists[lfhash]: # lfhash doesn't exist on "other"
1145 1145 addfunc(fn, lfhash)
1146 1146
1147 1147 def outgoinghook(ui, repo, other, opts, missing):
1148 1148 if opts.pop('large', None):
1149 1149 lfhashes = set()
1150 1150 if ui.debugflag:
1151 1151 toupload = {}
1152 1152 def addfunc(fn, lfhash):
1153 1153 if fn not in toupload:
1154 1154 toupload[fn] = []
1155 1155 toupload[fn].append(lfhash)
1156 1156 lfhashes.add(lfhash)
1157 1157 def showhashes(fn):
1158 1158 for lfhash in sorted(toupload[fn]):
1159 1159 ui.debug(' %s\n' % (lfhash))
1160 1160 else:
1161 1161 toupload = set()
1162 1162 def addfunc(fn, lfhash):
1163 1163 toupload.add(fn)
1164 1164 lfhashes.add(lfhash)
1165 1165 def showhashes(fn):
1166 1166 pass
1167 1167 _getoutgoings(repo, other, missing, addfunc)
1168 1168
1169 1169 if not toupload:
1170 1170 ui.status(_('largefiles: no files to upload\n'))
1171 1171 else:
1172 1172 ui.status(_('largefiles to upload (%d entities):\n')
1173 1173 % (len(lfhashes)))
1174 1174 for file in sorted(toupload):
1175 1175 ui.status(lfutil.splitstandin(file) + '\n')
1176 1176 showhashes(file)
1177 1177 ui.status('\n')
1178 1178
1179 1179 def summaryremotehook(ui, repo, opts, changes):
1180 1180 largeopt = opts.get('large', False)
1181 1181 if changes is None:
1182 1182 if largeopt:
1183 1183 return (False, True) # only outgoing check is needed
1184 1184 else:
1185 1185 return (False, False)
1186 1186 elif largeopt:
1187 1187 url, branch, peer, outgoing = changes[1]
1188 1188 if peer is None:
1189 1189 # i18n: column positioning for "hg summary"
1190 1190 ui.status(_('largefiles: (no remote repo)\n'))
1191 1191 return
1192 1192
1193 1193 toupload = set()
1194 1194 lfhashes = set()
1195 1195 def addfunc(fn, lfhash):
1196 1196 toupload.add(fn)
1197 1197 lfhashes.add(lfhash)
1198 1198 _getoutgoings(repo, peer, outgoing.missing, addfunc)
1199 1199
1200 1200 if not toupload:
1201 1201 # i18n: column positioning for "hg summary"
1202 1202 ui.status(_('largefiles: (no files to upload)\n'))
1203 1203 else:
1204 1204 # i18n: column positioning for "hg summary"
1205 1205 ui.status(_('largefiles: %d entities for %d files to upload\n')
1206 1206 % (len(lfhashes), len(toupload)))
1207 1207
1208 1208 def overridesummary(orig, ui, repo, *pats, **opts):
1209 1209 try:
1210 1210 repo.lfstatus = True
1211 1211 orig(ui, repo, *pats, **opts)
1212 1212 finally:
1213 1213 repo.lfstatus = False
1214 1214
1215 1215 def scmutiladdremove(orig, repo, matcher, prefix, opts=None, dry_run=None,
1216 1216 similarity=None):
1217 1217 if opts is None:
1218 1218 opts = {}
1219 1219 if not lfutil.islfilesrepo(repo):
1220 1220 return orig(repo, matcher, prefix, opts, dry_run, similarity)
1221 1221 # Get the list of missing largefiles so we can remove them
1222 1222 lfdirstate = lfutil.openlfdirstate(repo.ui, repo)
1223 1223 unsure, s = lfdirstate.status(matchmod.always(repo.root, repo.getcwd()),
1224 1224 subrepos=[], ignored=False, clean=False,
1225 1225 unknown=False)
1226 1226
1227 1227 # Call into the normal remove code, but the removing of the standin, we want
1228 1228 # to have handled by original addremove. Monkey patching here makes sure
1229 1229 # we don't remove the standin in the largefiles code, preventing a very
1230 1230 # confused state later.
1231 1231 if s.deleted:
1232 1232 m = copy.copy(matcher)
1233 1233
1234 1234 # The m._files and m._map attributes are not changed to the deleted list
1235 1235 # because that affects the m.exact() test, which in turn governs whether
1236 1236 # or not the file name is printed, and how. Simply limit the original
1237 1237 # matches to those in the deleted status list.
1238 1238 matchfn = m.matchfn
1239 1239 m.matchfn = lambda f: f in s.deleted and matchfn(f)
1240 1240
1241 1241 removelargefiles(repo.ui, repo, True, m, **opts)
1242 1242 # Call into the normal add code, and any files that *should* be added as
1243 1243 # largefiles will be
1244 1244 added, bad = addlargefiles(repo.ui, repo, True, matcher, **opts)
1245 1245 # Now that we've handled largefiles, hand off to the original addremove
1246 1246 # function to take care of the rest. Make sure it doesn't do anything with
1247 1247 # largefiles by passing a matcher that will ignore them.
1248 1248 matcher = composenormalfilematcher(matcher, repo[None].manifest(), added)
1249 1249 return orig(repo, matcher, prefix, opts, dry_run, similarity)
1250 1250
1251 1251 # Calling purge with --all will cause the largefiles to be deleted.
1252 1252 # Override repo.status to prevent this from happening.
1253 1253 def overridepurge(orig, ui, repo, *dirs, **opts):
1254 1254 # XXX Monkey patching a repoview will not work. The assigned attribute will
1255 1255 # be set on the unfiltered repo, but we will only lookup attributes in the
1256 1256 # unfiltered repo if the lookup in the repoview object itself fails. As the
1257 1257 # monkey patched method exists on the repoview class the lookup will not
1258 1258 # fail. As a result, the original version will shadow the monkey patched
1259 1259 # one, defeating the monkey patch.
1260 1260 #
1261 1261 # As a work around we use an unfiltered repo here. We should do something
1262 1262 # cleaner instead.
1263 1263 repo = repo.unfiltered()
1264 1264 oldstatus = repo.status
1265 1265 def overridestatus(node1='.', node2=None, match=None, ignored=False,
1266 1266 clean=False, unknown=False, listsubrepos=False):
1267 1267 r = oldstatus(node1, node2, match, ignored, clean, unknown,
1268 1268 listsubrepos)
1269 1269 lfdirstate = lfutil.openlfdirstate(ui, repo)
1270 1270 unknown = [f for f in r.unknown if lfdirstate[f] == '?']
1271 1271 ignored = [f for f in r.ignored if lfdirstate[f] == '?']
1272 1272 return scmutil.status(r.modified, r.added, r.removed, r.deleted,
1273 1273 unknown, ignored, r.clean)
1274 1274 repo.status = overridestatus
1275 1275 orig(ui, repo, *dirs, **opts)
1276 1276 repo.status = oldstatus
1277 1277
1278 1278 def overriderollback(orig, ui, repo, **opts):
1279 1279 with repo.wlock():
1280 1280 before = repo.dirstate.parents()
1281 1281 orphans = set(f for f in repo.dirstate
1282 1282 if lfutil.isstandin(f) and repo.dirstate[f] != 'r')
1283 1283 result = orig(ui, repo, **opts)
1284 1284 after = repo.dirstate.parents()
1285 1285 if before == after:
1286 1286 return result # no need to restore standins
1287 1287
1288 1288 pctx = repo['.']
1289 1289 for f in repo.dirstate:
1290 1290 if lfutil.isstandin(f):
1291 1291 orphans.discard(f)
1292 1292 if repo.dirstate[f] == 'r':
1293 1293 repo.wvfs.unlinkpath(f, ignoremissing=True)
1294 1294 elif f in pctx:
1295 1295 fctx = pctx[f]
1296 1296 repo.wwrite(f, fctx.data(), fctx.flags())
1297 1297 else:
1298 1298 # content of standin is not so important in 'a',
1299 1299 # 'm' or 'n' (coming from the 2nd parent) cases
1300 1300 lfutil.writestandin(repo, f, '', False)
1301 1301 for standin in orphans:
1302 1302 repo.wvfs.unlinkpath(standin, ignoremissing=True)
1303 1303
1304 1304 lfdirstate = lfutil.openlfdirstate(ui, repo)
1305 1305 orphans = set(lfdirstate)
1306 1306 lfiles = lfutil.listlfiles(repo)
1307 1307 for file in lfiles:
1308 1308 lfutil.synclfdirstate(repo, lfdirstate, file, True)
1309 1309 orphans.discard(file)
1310 1310 for lfile in orphans:
1311 1311 lfdirstate.drop(lfile)
1312 1312 lfdirstate.write()
1313 1313 return result
1314 1314
1315 1315 def overridetransplant(orig, ui, repo, *revs, **opts):
1316 1316 resuming = opts.get(r'continue')
1317 1317 repo._lfcommithooks.append(lfutil.automatedcommithook(resuming))
1318 1318 repo._lfstatuswriters.append(lambda *msg, **opts: None)
1319 1319 try:
1320 1320 result = orig(ui, repo, *revs, **opts)
1321 1321 finally:
1322 1322 repo._lfstatuswriters.pop()
1323 1323 repo._lfcommithooks.pop()
1324 1324 return result
1325 1325
1326 1326 def overridecat(orig, ui, repo, file1, *pats, **opts):
1327 1327 opts = pycompat.byteskwargs(opts)
1328 1328 ctx = scmutil.revsingle(repo, opts.get('rev'))
1329 1329 err = 1
1330 1330 notbad = set()
1331 1331 m = scmutil.match(ctx, (file1,) + pats, opts)
1332 1332 origmatchfn = m.matchfn
1333 1333 def lfmatchfn(f):
1334 1334 if origmatchfn(f):
1335 1335 return True
1336 1336 lf = lfutil.splitstandin(f)
1337 1337 if lf is None:
1338 1338 return False
1339 1339 notbad.add(lf)
1340 1340 return origmatchfn(lf)
1341 1341 m.matchfn = lfmatchfn
1342 1342 origbadfn = m.bad
1343 1343 def lfbadfn(f, msg):
1344 1344 if not f in notbad:
1345 1345 origbadfn(f, msg)
1346 1346 m.bad = lfbadfn
1347 1347
1348 1348 origvisitdirfn = m.visitdir
1349 1349 def lfvisitdirfn(dir):
1350 1350 if dir == lfutil.shortname:
1351 1351 return True
1352 1352 ret = origvisitdirfn(dir)
1353 1353 if ret:
1354 1354 return ret
1355 1355 lf = lfutil.splitstandin(dir)
1356 1356 if lf is None:
1357 1357 return False
1358 1358 return origvisitdirfn(lf)
1359 1359 m.visitdir = lfvisitdirfn
1360 1360
1361 1361 for f in ctx.walk(m):
1362 with cmdutil.makefileobj(repo, opts.get('output'), ctx.node(),
1363 pathname=f) as fp:
1362 with cmdutil.makefileobj(ctx, opts.get('output'), pathname=f) as fp:
1364 1363 lf = lfutil.splitstandin(f)
1365 1364 if lf is None or origmatchfn(f):
1366 1365 # duplicating unreachable code from commands.cat
1367 1366 data = ctx[f].data()
1368 1367 if opts.get('decode'):
1369 1368 data = repo.wwritedata(f, data)
1370 1369 fp.write(data)
1371 1370 else:
1372 1371 hash = lfutil.readasstandin(ctx[f])
1373 1372 if not lfutil.inusercache(repo.ui, hash):
1374 1373 store = storefactory.openstore(repo)
1375 1374 success, missing = store.get([(lf, hash)])
1376 1375 if len(success) != 1:
1377 1376 raise error.Abort(
1378 1377 _('largefile %s is not in cache and could not be '
1379 1378 'downloaded') % lf)
1380 1379 path = lfutil.usercachepath(repo.ui, hash)
1381 1380 with open(path, "rb") as fpin:
1382 1381 for chunk in util.filechunkiter(fpin):
1383 1382 fp.write(chunk)
1384 1383 err = 0
1385 1384 return err
1386 1385
1387 1386 def mergeupdate(orig, repo, node, branchmerge, force,
1388 1387 *args, **kwargs):
1389 1388 matcher = kwargs.get(r'matcher', None)
1390 1389 # note if this is a partial update
1391 1390 partial = matcher and not matcher.always()
1392 1391 with repo.wlock():
1393 1392 # branch | | |
1394 1393 # merge | force | partial | action
1395 1394 # -------+-------+---------+--------------
1396 1395 # x | x | x | linear-merge
1397 1396 # o | x | x | branch-merge
1398 1397 # x | o | x | overwrite (as clean update)
1399 1398 # o | o | x | force-branch-merge (*1)
1400 1399 # x | x | o | (*)
1401 1400 # o | x | o | (*)
1402 1401 # x | o | o | overwrite (as revert)
1403 1402 # o | o | o | (*)
1404 1403 #
1405 1404 # (*) don't care
1406 1405 # (*1) deprecated, but used internally (e.g: "rebase --collapse")
1407 1406
1408 1407 lfdirstate = lfutil.openlfdirstate(repo.ui, repo)
1409 1408 unsure, s = lfdirstate.status(matchmod.always(repo.root,
1410 1409 repo.getcwd()),
1411 1410 subrepos=[], ignored=False,
1412 1411 clean=True, unknown=False)
1413 1412 oldclean = set(s.clean)
1414 1413 pctx = repo['.']
1415 1414 dctx = repo[node]
1416 1415 for lfile in unsure + s.modified:
1417 1416 lfileabs = repo.wvfs.join(lfile)
1418 1417 if not repo.wvfs.exists(lfileabs):
1419 1418 continue
1420 1419 lfhash = lfutil.hashfile(lfileabs)
1421 1420 standin = lfutil.standin(lfile)
1422 1421 lfutil.writestandin(repo, standin, lfhash,
1423 1422 lfutil.getexecutable(lfileabs))
1424 1423 if (standin in pctx and
1425 1424 lfhash == lfutil.readasstandin(pctx[standin])):
1426 1425 oldclean.add(lfile)
1427 1426 for lfile in s.added:
1428 1427 fstandin = lfutil.standin(lfile)
1429 1428 if fstandin not in dctx:
1430 1429 # in this case, content of standin file is meaningless
1431 1430 # (in dctx, lfile is unknown, or normal file)
1432 1431 continue
1433 1432 lfutil.updatestandin(repo, lfile, fstandin)
1434 1433 # mark all clean largefiles as dirty, just in case the update gets
1435 1434 # interrupted before largefiles and lfdirstate are synchronized
1436 1435 for lfile in oldclean:
1437 1436 lfdirstate.normallookup(lfile)
1438 1437 lfdirstate.write()
1439 1438
1440 1439 oldstandins = lfutil.getstandinsstate(repo)
1441 1440 # Make sure the merge runs on disk, not in-memory. largefiles is not a
1442 1441 # good candidate for in-memory merge (large files, custom dirstate,
1443 1442 # matcher usage).
1444 1443 kwargs[r'wc'] = repo[None]
1445 1444 result = orig(repo, node, branchmerge, force, *args, **kwargs)
1446 1445
1447 1446 newstandins = lfutil.getstandinsstate(repo)
1448 1447 filelist = lfutil.getlfilestoupdate(oldstandins, newstandins)
1449 1448
1450 1449 # to avoid leaving all largefiles as dirty and thus rehash them, mark
1451 1450 # all the ones that didn't change as clean
1452 1451 for lfile in oldclean.difference(filelist):
1453 1452 lfdirstate.normal(lfile)
1454 1453 lfdirstate.write()
1455 1454
1456 1455 if branchmerge or force or partial:
1457 1456 filelist.extend(s.deleted + s.removed)
1458 1457
1459 1458 lfcommands.updatelfiles(repo.ui, repo, filelist=filelist,
1460 1459 normallookup=partial)
1461 1460
1462 1461 return result
1463 1462
1464 1463 def scmutilmarktouched(orig, repo, files, *args, **kwargs):
1465 1464 result = orig(repo, files, *args, **kwargs)
1466 1465
1467 1466 filelist = []
1468 1467 for f in files:
1469 1468 lf = lfutil.splitstandin(f)
1470 1469 if lf is not None:
1471 1470 filelist.append(lf)
1472 1471 if filelist:
1473 1472 lfcommands.updatelfiles(repo.ui, repo, filelist=filelist,
1474 1473 printmessage=False, normallookup=True)
1475 1474
1476 1475 return result
1477 1476
1478 1477 def upgraderequirements(orig, repo):
1479 1478 reqs = orig(repo)
1480 1479 if 'largefiles' in repo.requirements:
1481 1480 reqs.add('largefiles')
1482 1481 return reqs
1483 1482
1484 1483 _lfscheme = 'largefile://'
1485 1484 def openlargefile(orig, ui, url_, data=None):
1486 1485 if url_.startswith(_lfscheme):
1487 1486 if data:
1488 1487 msg = "cannot use data on a 'largefile://' url"
1489 1488 raise error.ProgrammingError(msg)
1490 1489 lfid = url_[len(_lfscheme):]
1491 1490 return storefactory.getlfile(ui, lfid)
1492 1491 else:
1493 1492 return orig(ui, url_, data=data)
@@ -1,3155 +1,3155 b''
1 1 # cmdutil.py - help for command processing in mercurial
2 2 #
3 3 # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
4 4 #
5 5 # This software may be used and distributed according to the terms of the
6 6 # GNU General Public License version 2 or any later version.
7 7
8 8 from __future__ import absolute_import
9 9
10 10 import errno
11 11 import os
12 12 import re
13 13 import tempfile
14 14
15 15 from .i18n import _
16 16 from .node import (
17 17 hex,
18 18 nullid,
19 19 nullrev,
20 20 short,
21 21 )
22 22
23 23 from . import (
24 24 bookmarks,
25 25 changelog,
26 26 copies,
27 27 crecord as crecordmod,
28 28 dirstateguard,
29 29 encoding,
30 30 error,
31 31 formatter,
32 32 logcmdutil,
33 33 match as matchmod,
34 34 merge as mergemod,
35 35 obsolete,
36 36 patch,
37 37 pathutil,
38 38 pycompat,
39 39 registrar,
40 40 revlog,
41 41 rewriteutil,
42 42 scmutil,
43 43 smartset,
44 44 subrepoutil,
45 45 templater,
46 46 util,
47 47 vfs as vfsmod,
48 48 )
49 49 stringio = util.stringio
50 50
51 51 # templates of common command options
52 52
53 53 dryrunopts = [
54 54 ('n', 'dry-run', None,
55 55 _('do not perform actions, just print output')),
56 56 ]
57 57
58 58 remoteopts = [
59 59 ('e', 'ssh', '',
60 60 _('specify ssh command to use'), _('CMD')),
61 61 ('', 'remotecmd', '',
62 62 _('specify hg command to run on the remote side'), _('CMD')),
63 63 ('', 'insecure', None,
64 64 _('do not verify server certificate (ignoring web.cacerts config)')),
65 65 ]
66 66
67 67 walkopts = [
68 68 ('I', 'include', [],
69 69 _('include names matching the given patterns'), _('PATTERN')),
70 70 ('X', 'exclude', [],
71 71 _('exclude names matching the given patterns'), _('PATTERN')),
72 72 ]
73 73
74 74 commitopts = [
75 75 ('m', 'message', '',
76 76 _('use text as commit message'), _('TEXT')),
77 77 ('l', 'logfile', '',
78 78 _('read commit message from file'), _('FILE')),
79 79 ]
80 80
81 81 commitopts2 = [
82 82 ('d', 'date', '',
83 83 _('record the specified date as commit date'), _('DATE')),
84 84 ('u', 'user', '',
85 85 _('record the specified user as committer'), _('USER')),
86 86 ]
87 87
88 88 # hidden for now
89 89 formatteropts = [
90 90 ('T', 'template', '',
91 91 _('display with template (EXPERIMENTAL)'), _('TEMPLATE')),
92 92 ]
93 93
94 94 templateopts = [
95 95 ('', 'style', '',
96 96 _('display using template map file (DEPRECATED)'), _('STYLE')),
97 97 ('T', 'template', '',
98 98 _('display with template'), _('TEMPLATE')),
99 99 ]
100 100
101 101 logopts = [
102 102 ('p', 'patch', None, _('show patch')),
103 103 ('g', 'git', None, _('use git extended diff format')),
104 104 ('l', 'limit', '',
105 105 _('limit number of changes displayed'), _('NUM')),
106 106 ('M', 'no-merges', None, _('do not show merges')),
107 107 ('', 'stat', None, _('output diffstat-style summary of changes')),
108 108 ('G', 'graph', None, _("show the revision DAG")),
109 109 ] + templateopts
110 110
111 111 diffopts = [
112 112 ('a', 'text', None, _('treat all files as text')),
113 113 ('g', 'git', None, _('use git extended diff format')),
114 114 ('', 'binary', None, _('generate binary diffs in git mode (default)')),
115 115 ('', 'nodates', None, _('omit dates from diff headers'))
116 116 ]
117 117
118 118 diffwsopts = [
119 119 ('w', 'ignore-all-space', None,
120 120 _('ignore white space when comparing lines')),
121 121 ('b', 'ignore-space-change', None,
122 122 _('ignore changes in the amount of white space')),
123 123 ('B', 'ignore-blank-lines', None,
124 124 _('ignore changes whose lines are all blank')),
125 125 ('Z', 'ignore-space-at-eol', None,
126 126 _('ignore changes in whitespace at EOL')),
127 127 ]
128 128
129 129 diffopts2 = [
130 130 ('', 'noprefix', None, _('omit a/ and b/ prefixes from filenames')),
131 131 ('p', 'show-function', None, _('show which function each change is in')),
132 132 ('', 'reverse', None, _('produce a diff that undoes the changes')),
133 133 ] + diffwsopts + [
134 134 ('U', 'unified', '',
135 135 _('number of lines of context to show'), _('NUM')),
136 136 ('', 'stat', None, _('output diffstat-style summary of changes')),
137 137 ('', 'root', '', _('produce diffs relative to subdirectory'), _('DIR')),
138 138 ]
139 139
140 140 mergetoolopts = [
141 141 ('t', 'tool', '', _('specify merge tool')),
142 142 ]
143 143
144 144 similarityopts = [
145 145 ('s', 'similarity', '',
146 146 _('guess renamed files by similarity (0<=s<=100)'), _('SIMILARITY'))
147 147 ]
148 148
149 149 subrepoopts = [
150 150 ('S', 'subrepos', None,
151 151 _('recurse into subrepositories'))
152 152 ]
153 153
154 154 debugrevlogopts = [
155 155 ('c', 'changelog', False, _('open changelog')),
156 156 ('m', 'manifest', False, _('open manifest')),
157 157 ('', 'dir', '', _('open directory manifest')),
158 158 ]
159 159
160 160 # special string such that everything below this line will be ingored in the
161 161 # editor text
162 162 _linebelow = "^HG: ------------------------ >8 ------------------------$"
163 163
164 164 def ishunk(x):
165 165 hunkclasses = (crecordmod.uihunk, patch.recordhunk)
166 166 return isinstance(x, hunkclasses)
167 167
168 168 def newandmodified(chunks, originalchunks):
169 169 newlyaddedandmodifiedfiles = set()
170 170 for chunk in chunks:
171 171 if ishunk(chunk) and chunk.header.isnewfile() and chunk not in \
172 172 originalchunks:
173 173 newlyaddedandmodifiedfiles.add(chunk.header.filename())
174 174 return newlyaddedandmodifiedfiles
175 175
176 176 def parsealiases(cmd):
177 177 return cmd.lstrip("^").split("|")
178 178
179 179 def setupwrapcolorwrite(ui):
180 180 # wrap ui.write so diff output can be labeled/colorized
181 181 def wrapwrite(orig, *args, **kw):
182 182 label = kw.pop(r'label', '')
183 183 for chunk, l in patch.difflabel(lambda: args):
184 184 orig(chunk, label=label + l)
185 185
186 186 oldwrite = ui.write
187 187 def wrap(*args, **kwargs):
188 188 return wrapwrite(oldwrite, *args, **kwargs)
189 189 setattr(ui, 'write', wrap)
190 190 return oldwrite
191 191
192 192 def filterchunks(ui, originalhunks, usecurses, testfile, operation=None):
193 193 if usecurses:
194 194 if testfile:
195 195 recordfn = crecordmod.testdecorator(testfile,
196 196 crecordmod.testchunkselector)
197 197 else:
198 198 recordfn = crecordmod.chunkselector
199 199
200 200 return crecordmod.filterpatch(ui, originalhunks, recordfn, operation)
201 201
202 202 else:
203 203 return patch.filterpatch(ui, originalhunks, operation)
204 204
205 205 def recordfilter(ui, originalhunks, operation=None):
206 206 """ Prompts the user to filter the originalhunks and return a list of
207 207 selected hunks.
208 208 *operation* is used for to build ui messages to indicate the user what
209 209 kind of filtering they are doing: reverting, committing, shelving, etc.
210 210 (see patch.filterpatch).
211 211 """
212 212 usecurses = crecordmod.checkcurses(ui)
213 213 testfile = ui.config('experimental', 'crecordtest')
214 214 oldwrite = setupwrapcolorwrite(ui)
215 215 try:
216 216 newchunks, newopts = filterchunks(ui, originalhunks, usecurses,
217 217 testfile, operation)
218 218 finally:
219 219 ui.write = oldwrite
220 220 return newchunks, newopts
221 221
222 222 def dorecord(ui, repo, commitfunc, cmdsuggest, backupall,
223 223 filterfn, *pats, **opts):
224 224 opts = pycompat.byteskwargs(opts)
225 225 if not ui.interactive():
226 226 if cmdsuggest:
227 227 msg = _('running non-interactively, use %s instead') % cmdsuggest
228 228 else:
229 229 msg = _('running non-interactively')
230 230 raise error.Abort(msg)
231 231
232 232 # make sure username is set before going interactive
233 233 if not opts.get('user'):
234 234 ui.username() # raise exception, username not provided
235 235
236 236 def recordfunc(ui, repo, message, match, opts):
237 237 """This is generic record driver.
238 238
239 239 Its job is to interactively filter local changes, and
240 240 accordingly prepare working directory into a state in which the
241 241 job can be delegated to a non-interactive commit command such as
242 242 'commit' or 'qrefresh'.
243 243
244 244 After the actual job is done by non-interactive command, the
245 245 working directory is restored to its original state.
246 246
247 247 In the end we'll record interesting changes, and everything else
248 248 will be left in place, so the user can continue working.
249 249 """
250 250
251 251 checkunfinished(repo, commit=True)
252 252 wctx = repo[None]
253 253 merge = len(wctx.parents()) > 1
254 254 if merge:
255 255 raise error.Abort(_('cannot partially commit a merge '
256 256 '(use "hg commit" instead)'))
257 257
258 258 def fail(f, msg):
259 259 raise error.Abort('%s: %s' % (f, msg))
260 260
261 261 force = opts.get('force')
262 262 if not force:
263 263 vdirs = []
264 264 match.explicitdir = vdirs.append
265 265 match.bad = fail
266 266
267 267 status = repo.status(match=match)
268 268 if not force:
269 269 repo.checkcommitpatterns(wctx, vdirs, match, status, fail)
270 270 diffopts = patch.difffeatureopts(ui, opts=opts, whitespace=True)
271 271 diffopts.nodates = True
272 272 diffopts.git = True
273 273 diffopts.showfunc = True
274 274 originaldiff = patch.diff(repo, changes=status, opts=diffopts)
275 275 originalchunks = patch.parsepatch(originaldiff)
276 276
277 277 # 1. filter patch, since we are intending to apply subset of it
278 278 try:
279 279 chunks, newopts = filterfn(ui, originalchunks)
280 280 except error.PatchError as err:
281 281 raise error.Abort(_('error parsing patch: %s') % err)
282 282 opts.update(newopts)
283 283
284 284 # We need to keep a backup of files that have been newly added and
285 285 # modified during the recording process because there is a previous
286 286 # version without the edit in the workdir
287 287 newlyaddedandmodifiedfiles = newandmodified(chunks, originalchunks)
288 288 contenders = set()
289 289 for h in chunks:
290 290 try:
291 291 contenders.update(set(h.files()))
292 292 except AttributeError:
293 293 pass
294 294
295 295 changed = status.modified + status.added + status.removed
296 296 newfiles = [f for f in changed if f in contenders]
297 297 if not newfiles:
298 298 ui.status(_('no changes to record\n'))
299 299 return 0
300 300
301 301 modified = set(status.modified)
302 302
303 303 # 2. backup changed files, so we can restore them in the end
304 304
305 305 if backupall:
306 306 tobackup = changed
307 307 else:
308 308 tobackup = [f for f in newfiles if f in modified or f in \
309 309 newlyaddedandmodifiedfiles]
310 310 backups = {}
311 311 if tobackup:
312 312 backupdir = repo.vfs.join('record-backups')
313 313 try:
314 314 os.mkdir(backupdir)
315 315 except OSError as err:
316 316 if err.errno != errno.EEXIST:
317 317 raise
318 318 try:
319 319 # backup continues
320 320 for f in tobackup:
321 321 fd, tmpname = tempfile.mkstemp(prefix=f.replace('/', '_')+'.',
322 322 dir=backupdir)
323 323 os.close(fd)
324 324 ui.debug('backup %r as %r\n' % (f, tmpname))
325 325 util.copyfile(repo.wjoin(f), tmpname, copystat=True)
326 326 backups[f] = tmpname
327 327
328 328 fp = stringio()
329 329 for c in chunks:
330 330 fname = c.filename()
331 331 if fname in backups:
332 332 c.write(fp)
333 333 dopatch = fp.tell()
334 334 fp.seek(0)
335 335
336 336 # 2.5 optionally review / modify patch in text editor
337 337 if opts.get('review', False):
338 338 patchtext = (crecordmod.diffhelptext
339 339 + crecordmod.patchhelptext
340 340 + fp.read())
341 341 reviewedpatch = ui.edit(patchtext, "",
342 342 action="diff",
343 343 repopath=repo.path)
344 344 fp.truncate(0)
345 345 fp.write(reviewedpatch)
346 346 fp.seek(0)
347 347
348 348 [os.unlink(repo.wjoin(c)) for c in newlyaddedandmodifiedfiles]
349 349 # 3a. apply filtered patch to clean repo (clean)
350 350 if backups:
351 351 # Equivalent to hg.revert
352 352 m = scmutil.matchfiles(repo, backups.keys())
353 353 mergemod.update(repo, repo.dirstate.p1(),
354 354 False, True, matcher=m)
355 355
356 356 # 3b. (apply)
357 357 if dopatch:
358 358 try:
359 359 ui.debug('applying patch\n')
360 360 ui.debug(fp.getvalue())
361 361 patch.internalpatch(ui, repo, fp, 1, eolmode=None)
362 362 except error.PatchError as err:
363 363 raise error.Abort(str(err))
364 364 del fp
365 365
366 366 # 4. We prepared working directory according to filtered
367 367 # patch. Now is the time to delegate the job to
368 368 # commit/qrefresh or the like!
369 369
370 370 # Make all of the pathnames absolute.
371 371 newfiles = [repo.wjoin(nf) for nf in newfiles]
372 372 return commitfunc(ui, repo, *newfiles, **pycompat.strkwargs(opts))
373 373 finally:
374 374 # 5. finally restore backed-up files
375 375 try:
376 376 dirstate = repo.dirstate
377 377 for realname, tmpname in backups.iteritems():
378 378 ui.debug('restoring %r to %r\n' % (tmpname, realname))
379 379
380 380 if dirstate[realname] == 'n':
381 381 # without normallookup, restoring timestamp
382 382 # may cause partially committed files
383 383 # to be treated as unmodified
384 384 dirstate.normallookup(realname)
385 385
386 386 # copystat=True here and above are a hack to trick any
387 387 # editors that have f open that we haven't modified them.
388 388 #
389 389 # Also note that this racy as an editor could notice the
390 390 # file's mtime before we've finished writing it.
391 391 util.copyfile(tmpname, repo.wjoin(realname), copystat=True)
392 392 os.unlink(tmpname)
393 393 if tobackup:
394 394 os.rmdir(backupdir)
395 395 except OSError:
396 396 pass
397 397
398 398 def recordinwlock(ui, repo, message, match, opts):
399 399 with repo.wlock():
400 400 return recordfunc(ui, repo, message, match, opts)
401 401
402 402 return commit(ui, repo, recordinwlock, pats, opts)
403 403
404 404 class dirnode(object):
405 405 """
406 406 Represent a directory in user working copy with information required for
407 407 the purpose of tersing its status.
408 408
409 409 path is the path to the directory
410 410
411 411 statuses is a set of statuses of all files in this directory (this includes
412 412 all the files in all the subdirectories too)
413 413
414 414 files is a list of files which are direct child of this directory
415 415
416 416 subdirs is a dictionary of sub-directory name as the key and it's own
417 417 dirnode object as the value
418 418 """
419 419
420 420 def __init__(self, dirpath):
421 421 self.path = dirpath
422 422 self.statuses = set([])
423 423 self.files = []
424 424 self.subdirs = {}
425 425
426 426 def _addfileindir(self, filename, status):
427 427 """Add a file in this directory as a direct child."""
428 428 self.files.append((filename, status))
429 429
430 430 def addfile(self, filename, status):
431 431 """
432 432 Add a file to this directory or to its direct parent directory.
433 433
434 434 If the file is not direct child of this directory, we traverse to the
435 435 directory of which this file is a direct child of and add the file
436 436 there.
437 437 """
438 438
439 439 # the filename contains a path separator, it means it's not the direct
440 440 # child of this directory
441 441 if '/' in filename:
442 442 subdir, filep = filename.split('/', 1)
443 443
444 444 # does the dirnode object for subdir exists
445 445 if subdir not in self.subdirs:
446 446 subdirpath = os.path.join(self.path, subdir)
447 447 self.subdirs[subdir] = dirnode(subdirpath)
448 448
449 449 # try adding the file in subdir
450 450 self.subdirs[subdir].addfile(filep, status)
451 451
452 452 else:
453 453 self._addfileindir(filename, status)
454 454
455 455 if status not in self.statuses:
456 456 self.statuses.add(status)
457 457
458 458 def iterfilepaths(self):
459 459 """Yield (status, path) for files directly under this directory."""
460 460 for f, st in self.files:
461 461 yield st, os.path.join(self.path, f)
462 462
463 463 def tersewalk(self, terseargs):
464 464 """
465 465 Yield (status, path) obtained by processing the status of this
466 466 dirnode.
467 467
468 468 terseargs is the string of arguments passed by the user with `--terse`
469 469 flag.
470 470
471 471 Following are the cases which can happen:
472 472
473 473 1) All the files in the directory (including all the files in its
474 474 subdirectories) share the same status and the user has asked us to terse
475 475 that status. -> yield (status, dirpath)
476 476
477 477 2) Otherwise, we do following:
478 478
479 479 a) Yield (status, filepath) for all the files which are in this
480 480 directory (only the ones in this directory, not the subdirs)
481 481
482 482 b) Recurse the function on all the subdirectories of this
483 483 directory
484 484 """
485 485
486 486 if len(self.statuses) == 1:
487 487 onlyst = self.statuses.pop()
488 488
489 489 # Making sure we terse only when the status abbreviation is
490 490 # passed as terse argument
491 491 if onlyst in terseargs:
492 492 yield onlyst, self.path + pycompat.ossep
493 493 return
494 494
495 495 # add the files to status list
496 496 for st, fpath in self.iterfilepaths():
497 497 yield st, fpath
498 498
499 499 #recurse on the subdirs
500 500 for dirobj in self.subdirs.values():
501 501 for st, fpath in dirobj.tersewalk(terseargs):
502 502 yield st, fpath
503 503
504 504 def tersedir(statuslist, terseargs):
505 505 """
506 506 Terse the status if all the files in a directory shares the same status.
507 507
508 508 statuslist is scmutil.status() object which contains a list of files for
509 509 each status.
510 510 terseargs is string which is passed by the user as the argument to `--terse`
511 511 flag.
512 512
513 513 The function makes a tree of objects of dirnode class, and at each node it
514 514 stores the information required to know whether we can terse a certain
515 515 directory or not.
516 516 """
517 517 # the order matters here as that is used to produce final list
518 518 allst = ('m', 'a', 'r', 'd', 'u', 'i', 'c')
519 519
520 520 # checking the argument validity
521 521 for s in pycompat.bytestr(terseargs):
522 522 if s not in allst:
523 523 raise error.Abort(_("'%s' not recognized") % s)
524 524
525 525 # creating a dirnode object for the root of the repo
526 526 rootobj = dirnode('')
527 527 pstatus = ('modified', 'added', 'deleted', 'clean', 'unknown',
528 528 'ignored', 'removed')
529 529
530 530 tersedict = {}
531 531 for attrname in pstatus:
532 532 statuschar = attrname[0:1]
533 533 for f in getattr(statuslist, attrname):
534 534 rootobj.addfile(f, statuschar)
535 535 tersedict[statuschar] = []
536 536
537 537 # we won't be tersing the root dir, so add files in it
538 538 for st, fpath in rootobj.iterfilepaths():
539 539 tersedict[st].append(fpath)
540 540
541 541 # process each sub-directory and build tersedict
542 542 for subdir in rootobj.subdirs.values():
543 543 for st, f in subdir.tersewalk(terseargs):
544 544 tersedict[st].append(f)
545 545
546 546 tersedlist = []
547 547 for st in allst:
548 548 tersedict[st].sort()
549 549 tersedlist.append(tersedict[st])
550 550
551 551 return tersedlist
552 552
553 553 def _commentlines(raw):
554 554 '''Surround lineswith a comment char and a new line'''
555 555 lines = raw.splitlines()
556 556 commentedlines = ['# %s' % line for line in lines]
557 557 return '\n'.join(commentedlines) + '\n'
558 558
559 559 def _conflictsmsg(repo):
560 560 mergestate = mergemod.mergestate.read(repo)
561 561 if not mergestate.active():
562 562 return
563 563
564 564 m = scmutil.match(repo[None])
565 565 unresolvedlist = [f for f in mergestate.unresolved() if m(f)]
566 566 if unresolvedlist:
567 567 mergeliststr = '\n'.join(
568 568 [' %s' % util.pathto(repo.root, pycompat.getcwd(), path)
569 569 for path in unresolvedlist])
570 570 msg = _('''Unresolved merge conflicts:
571 571
572 572 %s
573 573
574 574 To mark files as resolved: hg resolve --mark FILE''') % mergeliststr
575 575 else:
576 576 msg = _('No unresolved merge conflicts.')
577 577
578 578 return _commentlines(msg)
579 579
580 580 def _helpmessage(continuecmd, abortcmd):
581 581 msg = _('To continue: %s\n'
582 582 'To abort: %s') % (continuecmd, abortcmd)
583 583 return _commentlines(msg)
584 584
585 585 def _rebasemsg():
586 586 return _helpmessage('hg rebase --continue', 'hg rebase --abort')
587 587
588 588 def _histeditmsg():
589 589 return _helpmessage('hg histedit --continue', 'hg histedit --abort')
590 590
591 591 def _unshelvemsg():
592 592 return _helpmessage('hg unshelve --continue', 'hg unshelve --abort')
593 593
594 594 def _updatecleanmsg(dest=None):
595 595 warning = _('warning: this will discard uncommitted changes')
596 596 return 'hg update --clean %s (%s)' % (dest or '.', warning)
597 597
598 598 def _graftmsg():
599 599 # tweakdefaults requires `update` to have a rev hence the `.`
600 600 return _helpmessage('hg graft --continue', _updatecleanmsg())
601 601
602 602 def _mergemsg():
603 603 # tweakdefaults requires `update` to have a rev hence the `.`
604 604 return _helpmessage('hg commit', _updatecleanmsg())
605 605
606 606 def _bisectmsg():
607 607 msg = _('To mark the changeset good: hg bisect --good\n'
608 608 'To mark the changeset bad: hg bisect --bad\n'
609 609 'To abort: hg bisect --reset\n')
610 610 return _commentlines(msg)
611 611
612 612 def fileexistspredicate(filename):
613 613 return lambda repo: repo.vfs.exists(filename)
614 614
615 615 def _mergepredicate(repo):
616 616 return len(repo[None].parents()) > 1
617 617
618 618 STATES = (
619 619 # (state, predicate to detect states, helpful message function)
620 620 ('histedit', fileexistspredicate('histedit-state'), _histeditmsg),
621 621 ('bisect', fileexistspredicate('bisect.state'), _bisectmsg),
622 622 ('graft', fileexistspredicate('graftstate'), _graftmsg),
623 623 ('unshelve', fileexistspredicate('unshelverebasestate'), _unshelvemsg),
624 624 ('rebase', fileexistspredicate('rebasestate'), _rebasemsg),
625 625 # The merge state is part of a list that will be iterated over.
626 626 # They need to be last because some of the other unfinished states may also
627 627 # be in a merge or update state (eg. rebase, histedit, graft, etc).
628 628 # We want those to have priority.
629 629 ('merge', _mergepredicate, _mergemsg),
630 630 )
631 631
632 632 def _getrepostate(repo):
633 633 # experimental config: commands.status.skipstates
634 634 skip = set(repo.ui.configlist('commands', 'status.skipstates'))
635 635 for state, statedetectionpredicate, msgfn in STATES:
636 636 if state in skip:
637 637 continue
638 638 if statedetectionpredicate(repo):
639 639 return (state, statedetectionpredicate, msgfn)
640 640
641 641 def morestatus(repo, fm):
642 642 statetuple = _getrepostate(repo)
643 643 label = 'status.morestatus'
644 644 if statetuple:
645 645 fm.startitem()
646 646 state, statedetectionpredicate, helpfulmsg = statetuple
647 647 statemsg = _('The repository is in an unfinished *%s* state.') % state
648 648 fm.write('statemsg', '%s\n', _commentlines(statemsg), label=label)
649 649 conmsg = _conflictsmsg(repo)
650 650 if conmsg:
651 651 fm.write('conflictsmsg', '%s\n', conmsg, label=label)
652 652 if helpfulmsg:
653 653 helpmsg = helpfulmsg()
654 654 fm.write('helpmsg', '%s\n', helpmsg, label=label)
655 655
656 656 def findpossible(cmd, table, strict=False):
657 657 """
658 658 Return cmd -> (aliases, command table entry)
659 659 for each matching command.
660 660 Return debug commands (or their aliases) only if no normal command matches.
661 661 """
662 662 choice = {}
663 663 debugchoice = {}
664 664
665 665 if cmd in table:
666 666 # short-circuit exact matches, "log" alias beats "^log|history"
667 667 keys = [cmd]
668 668 else:
669 669 keys = table.keys()
670 670
671 671 allcmds = []
672 672 for e in keys:
673 673 aliases = parsealiases(e)
674 674 allcmds.extend(aliases)
675 675 found = None
676 676 if cmd in aliases:
677 677 found = cmd
678 678 elif not strict:
679 679 for a in aliases:
680 680 if a.startswith(cmd):
681 681 found = a
682 682 break
683 683 if found is not None:
684 684 if aliases[0].startswith("debug") or found.startswith("debug"):
685 685 debugchoice[found] = (aliases, table[e])
686 686 else:
687 687 choice[found] = (aliases, table[e])
688 688
689 689 if not choice and debugchoice:
690 690 choice = debugchoice
691 691
692 692 return choice, allcmds
693 693
694 694 def findcmd(cmd, table, strict=True):
695 695 """Return (aliases, command table entry) for command string."""
696 696 choice, allcmds = findpossible(cmd, table, strict)
697 697
698 698 if cmd in choice:
699 699 return choice[cmd]
700 700
701 701 if len(choice) > 1:
702 702 clist = sorted(choice)
703 703 raise error.AmbiguousCommand(cmd, clist)
704 704
705 705 if choice:
706 706 return list(choice.values())[0]
707 707
708 708 raise error.UnknownCommand(cmd, allcmds)
709 709
710 710 def changebranch(ui, repo, revs, label):
711 711 """ Change the branch name of given revs to label """
712 712
713 713 with repo.wlock(), repo.lock(), repo.transaction('branches'):
714 714 # abort in case of uncommitted merge or dirty wdir
715 715 bailifchanged(repo)
716 716 revs = scmutil.revrange(repo, revs)
717 717 if not revs:
718 718 raise error.Abort("empty revision set")
719 719 roots = repo.revs('roots(%ld)', revs)
720 720 if len(roots) > 1:
721 721 raise error.Abort(_("cannot change branch of non-linear revisions"))
722 722 rewriteutil.precheck(repo, revs, 'change branch of')
723 723
724 724 root = repo[roots.first()]
725 725 if not root.p1().branch() == label and label in repo.branchmap():
726 726 raise error.Abort(_("a branch of the same name already exists"))
727 727
728 728 if repo.revs('merge() and %ld', revs):
729 729 raise error.Abort(_("cannot change branch of a merge commit"))
730 730 if repo.revs('obsolete() and %ld', revs):
731 731 raise error.Abort(_("cannot change branch of a obsolete changeset"))
732 732
733 733 # make sure only topological heads
734 734 if repo.revs('heads(%ld) - head()', revs):
735 735 raise error.Abort(_("cannot change branch in middle of a stack"))
736 736
737 737 replacements = {}
738 738 # avoid import cycle mercurial.cmdutil -> mercurial.context ->
739 739 # mercurial.subrepo -> mercurial.cmdutil
740 740 from . import context
741 741 for rev in revs:
742 742 ctx = repo[rev]
743 743 oldbranch = ctx.branch()
744 744 # check if ctx has same branch
745 745 if oldbranch == label:
746 746 continue
747 747
748 748 def filectxfn(repo, newctx, path):
749 749 try:
750 750 return ctx[path]
751 751 except error.ManifestLookupError:
752 752 return None
753 753
754 754 ui.debug("changing branch of '%s' from '%s' to '%s'\n"
755 755 % (hex(ctx.node()), oldbranch, label))
756 756 extra = ctx.extra()
757 757 extra['branch_change'] = hex(ctx.node())
758 758 # While changing branch of set of linear commits, make sure that
759 759 # we base our commits on new parent rather than old parent which
760 760 # was obsoleted while changing the branch
761 761 p1 = ctx.p1().node()
762 762 p2 = ctx.p2().node()
763 763 if p1 in replacements:
764 764 p1 = replacements[p1][0]
765 765 if p2 in replacements:
766 766 p2 = replacements[p2][0]
767 767
768 768 mc = context.memctx(repo, (p1, p2),
769 769 ctx.description(),
770 770 ctx.files(),
771 771 filectxfn,
772 772 user=ctx.user(),
773 773 date=ctx.date(),
774 774 extra=extra,
775 775 branch=label)
776 776
777 777 commitphase = ctx.phase()
778 778 overrides = {('phases', 'new-commit'): commitphase}
779 779 with repo.ui.configoverride(overrides, 'branch-change'):
780 780 newnode = repo.commitctx(mc)
781 781
782 782 replacements[ctx.node()] = (newnode,)
783 783 ui.debug('new node id is %s\n' % hex(newnode))
784 784
785 785 # create obsmarkers and move bookmarks
786 786 scmutil.cleanupnodes(repo, replacements, 'branch-change')
787 787
788 788 # move the working copy too
789 789 wctx = repo[None]
790 790 # in-progress merge is a bit too complex for now.
791 791 if len(wctx.parents()) == 1:
792 792 newid = replacements.get(wctx.p1().node())
793 793 if newid is not None:
794 794 # avoid import cycle mercurial.cmdutil -> mercurial.hg ->
795 795 # mercurial.cmdutil
796 796 from . import hg
797 797 hg.update(repo, newid[0], quietempty=True)
798 798
799 799 ui.status(_("changed branch on %d changesets\n") % len(replacements))
800 800
801 801 def findrepo(p):
802 802 while not os.path.isdir(os.path.join(p, ".hg")):
803 803 oldp, p = p, os.path.dirname(p)
804 804 if p == oldp:
805 805 return None
806 806
807 807 return p
808 808
809 809 def bailifchanged(repo, merge=True, hint=None):
810 810 """ enforce the precondition that working directory must be clean.
811 811
812 812 'merge' can be set to false if a pending uncommitted merge should be
813 813 ignored (such as when 'update --check' runs).
814 814
815 815 'hint' is the usual hint given to Abort exception.
816 816 """
817 817
818 818 if merge and repo.dirstate.p2() != nullid:
819 819 raise error.Abort(_('outstanding uncommitted merge'), hint=hint)
820 820 modified, added, removed, deleted = repo.status()[:4]
821 821 if modified or added or removed or deleted:
822 822 raise error.Abort(_('uncommitted changes'), hint=hint)
823 823 ctx = repo[None]
824 824 for s in sorted(ctx.substate):
825 825 ctx.sub(s).bailifchanged(hint=hint)
826 826
827 827 def logmessage(ui, opts):
828 828 """ get the log message according to -m and -l option """
829 829 message = opts.get('message')
830 830 logfile = opts.get('logfile')
831 831
832 832 if message and logfile:
833 833 raise error.Abort(_('options --message and --logfile are mutually '
834 834 'exclusive'))
835 835 if not message and logfile:
836 836 try:
837 837 if isstdiofilename(logfile):
838 838 message = ui.fin.read()
839 839 else:
840 840 message = '\n'.join(util.readfile(logfile).splitlines())
841 841 except IOError as inst:
842 842 raise error.Abort(_("can't read commit message '%s': %s") %
843 843 (logfile, encoding.strtolocal(inst.strerror)))
844 844 return message
845 845
846 846 def mergeeditform(ctxorbool, baseformname):
847 847 """return appropriate editform name (referencing a committemplate)
848 848
849 849 'ctxorbool' is either a ctx to be committed, or a bool indicating whether
850 850 merging is committed.
851 851
852 852 This returns baseformname with '.merge' appended if it is a merge,
853 853 otherwise '.normal' is appended.
854 854 """
855 855 if isinstance(ctxorbool, bool):
856 856 if ctxorbool:
857 857 return baseformname + ".merge"
858 858 elif 1 < len(ctxorbool.parents()):
859 859 return baseformname + ".merge"
860 860
861 861 return baseformname + ".normal"
862 862
863 863 def getcommiteditor(edit=False, finishdesc=None, extramsg=None,
864 864 editform='', **opts):
865 865 """get appropriate commit message editor according to '--edit' option
866 866
867 867 'finishdesc' is a function to be called with edited commit message
868 868 (= 'description' of the new changeset) just after editing, but
869 869 before checking empty-ness. It should return actual text to be
870 870 stored into history. This allows to change description before
871 871 storing.
872 872
873 873 'extramsg' is a extra message to be shown in the editor instead of
874 874 'Leave message empty to abort commit' line. 'HG: ' prefix and EOL
875 875 is automatically added.
876 876
877 877 'editform' is a dot-separated list of names, to distinguish
878 878 the purpose of commit text editing.
879 879
880 880 'getcommiteditor' returns 'commitforceeditor' regardless of
881 881 'edit', if one of 'finishdesc' or 'extramsg' is specified, because
882 882 they are specific for usage in MQ.
883 883 """
884 884 if edit or finishdesc or extramsg:
885 885 return lambda r, c, s: commitforceeditor(r, c, s,
886 886 finishdesc=finishdesc,
887 887 extramsg=extramsg,
888 888 editform=editform)
889 889 elif editform:
890 890 return lambda r, c, s: commiteditor(r, c, s, editform=editform)
891 891 else:
892 892 return commiteditor
893 893
894 894 def makefilename(ctx, pat, desc=None,
895 895 total=None, seqno=None, revwidth=None, pathname=None):
896 896 repo = ctx.repo()
897 897 node = ctx.node()
898 898 expander = {
899 899 'H': lambda: hex(node),
900 900 'R': lambda: '%d' % repo.changelog.rev(node),
901 901 'h': lambda: short(node),
902 902 'm': lambda: re.sub('[^\w]', '_', desc or ''),
903 903 'r': lambda: ('%d' % repo.changelog.rev(node)).zfill(revwidth or 0),
904 904 '%': lambda: '%',
905 905 'b': lambda: os.path.basename(repo.root),
906 906 }
907 907
908 908 try:
909 909 if total is not None:
910 910 expander['N'] = lambda: '%d' % total
911 911 if seqno is not None:
912 912 expander['n'] = lambda: '%d' % seqno
913 913 if total is not None and seqno is not None:
914 914 expander['n'] = (lambda: ('%d' % seqno).zfill(len('%d' % total)))
915 915 if pathname is not None:
916 916 expander['s'] = lambda: os.path.basename(pathname)
917 917 expander['d'] = lambda: os.path.dirname(pathname) or '.'
918 918 expander['p'] = lambda: pathname
919 919
920 920 newname = []
921 921 patlen = len(pat)
922 922 i = 0
923 923 while i < patlen:
924 924 c = pat[i:i + 1]
925 925 if c == '%':
926 926 i += 1
927 927 c = pat[i:i + 1]
928 928 c = expander[c]()
929 929 newname.append(c)
930 930 i += 1
931 931 return ''.join(newname)
932 932 except KeyError as inst:
933 933 raise error.Abort(_("invalid format spec '%%%s' in output filename") %
934 934 inst.args[0])
935 935
936 936 def isstdiofilename(pat):
937 937 """True if the given pat looks like a filename denoting stdin/stdout"""
938 938 return not pat or pat == '-'
939 939
940 940 class _unclosablefile(object):
941 941 def __init__(self, fp):
942 942 self._fp = fp
943 943
944 944 def close(self):
945 945 pass
946 946
947 947 def __iter__(self):
948 948 return iter(self._fp)
949 949
950 950 def __getattr__(self, attr):
951 951 return getattr(self._fp, attr)
952 952
953 953 def __enter__(self):
954 954 return self
955 955
956 956 def __exit__(self, exc_type, exc_value, exc_tb):
957 957 pass
958 958
959 def makefileobj(repo, pat, node, desc=None, total=None,
959 def makefileobj(ctx, pat, desc=None, total=None,
960 960 seqno=None, revwidth=None, mode='wb', modemap=None,
961 961 pathname=None):
962 962
963 963 writable = mode not in ('r', 'rb')
964 964
965 965 if isstdiofilename(pat):
966 repo = ctx.repo()
966 967 if writable:
967 968 fp = repo.ui.fout
968 969 else:
969 970 fp = repo.ui.fin
970 971 return _unclosablefile(fp)
971 ctx = repo[node]
972 972 fn = makefilename(ctx, pat, desc, total, seqno, revwidth, pathname)
973 973 if modemap is not None:
974 974 mode = modemap.get(fn, mode)
975 975 if mode == 'wb':
976 976 modemap[fn] = 'ab'
977 977 return open(fn, mode)
978 978
979 979 def openrevlog(repo, cmd, file_, opts):
980 980 """opens the changelog, manifest, a filelog or a given revlog"""
981 981 cl = opts['changelog']
982 982 mf = opts['manifest']
983 983 dir = opts['dir']
984 984 msg = None
985 985 if cl and mf:
986 986 msg = _('cannot specify --changelog and --manifest at the same time')
987 987 elif cl and dir:
988 988 msg = _('cannot specify --changelog and --dir at the same time')
989 989 elif cl or mf or dir:
990 990 if file_:
991 991 msg = _('cannot specify filename with --changelog or --manifest')
992 992 elif not repo:
993 993 msg = _('cannot specify --changelog or --manifest or --dir '
994 994 'without a repository')
995 995 if msg:
996 996 raise error.Abort(msg)
997 997
998 998 r = None
999 999 if repo:
1000 1000 if cl:
1001 1001 r = repo.unfiltered().changelog
1002 1002 elif dir:
1003 1003 if 'treemanifest' not in repo.requirements:
1004 1004 raise error.Abort(_("--dir can only be used on repos with "
1005 1005 "treemanifest enabled"))
1006 1006 dirlog = repo.manifestlog._revlog.dirlog(dir)
1007 1007 if len(dirlog):
1008 1008 r = dirlog
1009 1009 elif mf:
1010 1010 r = repo.manifestlog._revlog
1011 1011 elif file_:
1012 1012 filelog = repo.file(file_)
1013 1013 if len(filelog):
1014 1014 r = filelog
1015 1015 if not r:
1016 1016 if not file_:
1017 1017 raise error.CommandError(cmd, _('invalid arguments'))
1018 1018 if not os.path.isfile(file_):
1019 1019 raise error.Abort(_("revlog '%s' not found") % file_)
1020 1020 r = revlog.revlog(vfsmod.vfs(pycompat.getcwd(), audit=False),
1021 1021 file_[:-2] + ".i")
1022 1022 return r
1023 1023
1024 1024 def copy(ui, repo, pats, opts, rename=False):
1025 1025 # called with the repo lock held
1026 1026 #
1027 1027 # hgsep => pathname that uses "/" to separate directories
1028 1028 # ossep => pathname that uses os.sep to separate directories
1029 1029 cwd = repo.getcwd()
1030 1030 targets = {}
1031 1031 after = opts.get("after")
1032 1032 dryrun = opts.get("dry_run")
1033 1033 wctx = repo[None]
1034 1034
1035 1035 def walkpat(pat):
1036 1036 srcs = []
1037 1037 if after:
1038 1038 badstates = '?'
1039 1039 else:
1040 1040 badstates = '?r'
1041 1041 m = scmutil.match(wctx, [pat], opts, globbed=True)
1042 1042 for abs in wctx.walk(m):
1043 1043 state = repo.dirstate[abs]
1044 1044 rel = m.rel(abs)
1045 1045 exact = m.exact(abs)
1046 1046 if state in badstates:
1047 1047 if exact and state == '?':
1048 1048 ui.warn(_('%s: not copying - file is not managed\n') % rel)
1049 1049 if exact and state == 'r':
1050 1050 ui.warn(_('%s: not copying - file has been marked for'
1051 1051 ' remove\n') % rel)
1052 1052 continue
1053 1053 # abs: hgsep
1054 1054 # rel: ossep
1055 1055 srcs.append((abs, rel, exact))
1056 1056 return srcs
1057 1057
1058 1058 # abssrc: hgsep
1059 1059 # relsrc: ossep
1060 1060 # otarget: ossep
1061 1061 def copyfile(abssrc, relsrc, otarget, exact):
1062 1062 abstarget = pathutil.canonpath(repo.root, cwd, otarget)
1063 1063 if '/' in abstarget:
1064 1064 # We cannot normalize abstarget itself, this would prevent
1065 1065 # case only renames, like a => A.
1066 1066 abspath, absname = abstarget.rsplit('/', 1)
1067 1067 abstarget = repo.dirstate.normalize(abspath) + '/' + absname
1068 1068 reltarget = repo.pathto(abstarget, cwd)
1069 1069 target = repo.wjoin(abstarget)
1070 1070 src = repo.wjoin(abssrc)
1071 1071 state = repo.dirstate[abstarget]
1072 1072
1073 1073 scmutil.checkportable(ui, abstarget)
1074 1074
1075 1075 # check for collisions
1076 1076 prevsrc = targets.get(abstarget)
1077 1077 if prevsrc is not None:
1078 1078 ui.warn(_('%s: not overwriting - %s collides with %s\n') %
1079 1079 (reltarget, repo.pathto(abssrc, cwd),
1080 1080 repo.pathto(prevsrc, cwd)))
1081 1081 return
1082 1082
1083 1083 # check for overwrites
1084 1084 exists = os.path.lexists(target)
1085 1085 samefile = False
1086 1086 if exists and abssrc != abstarget:
1087 1087 if (repo.dirstate.normalize(abssrc) ==
1088 1088 repo.dirstate.normalize(abstarget)):
1089 1089 if not rename:
1090 1090 ui.warn(_("%s: can't copy - same file\n") % reltarget)
1091 1091 return
1092 1092 exists = False
1093 1093 samefile = True
1094 1094
1095 1095 if not after and exists or after and state in 'mn':
1096 1096 if not opts['force']:
1097 1097 if state in 'mn':
1098 1098 msg = _('%s: not overwriting - file already committed\n')
1099 1099 if after:
1100 1100 flags = '--after --force'
1101 1101 else:
1102 1102 flags = '--force'
1103 1103 if rename:
1104 1104 hint = _('(hg rename %s to replace the file by '
1105 1105 'recording a rename)\n') % flags
1106 1106 else:
1107 1107 hint = _('(hg copy %s to replace the file by '
1108 1108 'recording a copy)\n') % flags
1109 1109 else:
1110 1110 msg = _('%s: not overwriting - file exists\n')
1111 1111 if rename:
1112 1112 hint = _('(hg rename --after to record the rename)\n')
1113 1113 else:
1114 1114 hint = _('(hg copy --after to record the copy)\n')
1115 1115 ui.warn(msg % reltarget)
1116 1116 ui.warn(hint)
1117 1117 return
1118 1118
1119 1119 if after:
1120 1120 if not exists:
1121 1121 if rename:
1122 1122 ui.warn(_('%s: not recording move - %s does not exist\n') %
1123 1123 (relsrc, reltarget))
1124 1124 else:
1125 1125 ui.warn(_('%s: not recording copy - %s does not exist\n') %
1126 1126 (relsrc, reltarget))
1127 1127 return
1128 1128 elif not dryrun:
1129 1129 try:
1130 1130 if exists:
1131 1131 os.unlink(target)
1132 1132 targetdir = os.path.dirname(target) or '.'
1133 1133 if not os.path.isdir(targetdir):
1134 1134 os.makedirs(targetdir)
1135 1135 if samefile:
1136 1136 tmp = target + "~hgrename"
1137 1137 os.rename(src, tmp)
1138 1138 os.rename(tmp, target)
1139 1139 else:
1140 1140 util.copyfile(src, target)
1141 1141 srcexists = True
1142 1142 except IOError as inst:
1143 1143 if inst.errno == errno.ENOENT:
1144 1144 ui.warn(_('%s: deleted in working directory\n') % relsrc)
1145 1145 srcexists = False
1146 1146 else:
1147 1147 ui.warn(_('%s: cannot copy - %s\n') %
1148 1148 (relsrc, encoding.strtolocal(inst.strerror)))
1149 1149 return True # report a failure
1150 1150
1151 1151 if ui.verbose or not exact:
1152 1152 if rename:
1153 1153 ui.status(_('moving %s to %s\n') % (relsrc, reltarget))
1154 1154 else:
1155 1155 ui.status(_('copying %s to %s\n') % (relsrc, reltarget))
1156 1156
1157 1157 targets[abstarget] = abssrc
1158 1158
1159 1159 # fix up dirstate
1160 1160 scmutil.dirstatecopy(ui, repo, wctx, abssrc, abstarget,
1161 1161 dryrun=dryrun, cwd=cwd)
1162 1162 if rename and not dryrun:
1163 1163 if not after and srcexists and not samefile:
1164 1164 repo.wvfs.unlinkpath(abssrc)
1165 1165 wctx.forget([abssrc])
1166 1166
1167 1167 # pat: ossep
1168 1168 # dest ossep
1169 1169 # srcs: list of (hgsep, hgsep, ossep, bool)
1170 1170 # return: function that takes hgsep and returns ossep
1171 1171 def targetpathfn(pat, dest, srcs):
1172 1172 if os.path.isdir(pat):
1173 1173 abspfx = pathutil.canonpath(repo.root, cwd, pat)
1174 1174 abspfx = util.localpath(abspfx)
1175 1175 if destdirexists:
1176 1176 striplen = len(os.path.split(abspfx)[0])
1177 1177 else:
1178 1178 striplen = len(abspfx)
1179 1179 if striplen:
1180 1180 striplen += len(pycompat.ossep)
1181 1181 res = lambda p: os.path.join(dest, util.localpath(p)[striplen:])
1182 1182 elif destdirexists:
1183 1183 res = lambda p: os.path.join(dest,
1184 1184 os.path.basename(util.localpath(p)))
1185 1185 else:
1186 1186 res = lambda p: dest
1187 1187 return res
1188 1188
1189 1189 # pat: ossep
1190 1190 # dest ossep
1191 1191 # srcs: list of (hgsep, hgsep, ossep, bool)
1192 1192 # return: function that takes hgsep and returns ossep
1193 1193 def targetpathafterfn(pat, dest, srcs):
1194 1194 if matchmod.patkind(pat):
1195 1195 # a mercurial pattern
1196 1196 res = lambda p: os.path.join(dest,
1197 1197 os.path.basename(util.localpath(p)))
1198 1198 else:
1199 1199 abspfx = pathutil.canonpath(repo.root, cwd, pat)
1200 1200 if len(abspfx) < len(srcs[0][0]):
1201 1201 # A directory. Either the target path contains the last
1202 1202 # component of the source path or it does not.
1203 1203 def evalpath(striplen):
1204 1204 score = 0
1205 1205 for s in srcs:
1206 1206 t = os.path.join(dest, util.localpath(s[0])[striplen:])
1207 1207 if os.path.lexists(t):
1208 1208 score += 1
1209 1209 return score
1210 1210
1211 1211 abspfx = util.localpath(abspfx)
1212 1212 striplen = len(abspfx)
1213 1213 if striplen:
1214 1214 striplen += len(pycompat.ossep)
1215 1215 if os.path.isdir(os.path.join(dest, os.path.split(abspfx)[1])):
1216 1216 score = evalpath(striplen)
1217 1217 striplen1 = len(os.path.split(abspfx)[0])
1218 1218 if striplen1:
1219 1219 striplen1 += len(pycompat.ossep)
1220 1220 if evalpath(striplen1) > score:
1221 1221 striplen = striplen1
1222 1222 res = lambda p: os.path.join(dest,
1223 1223 util.localpath(p)[striplen:])
1224 1224 else:
1225 1225 # a file
1226 1226 if destdirexists:
1227 1227 res = lambda p: os.path.join(dest,
1228 1228 os.path.basename(util.localpath(p)))
1229 1229 else:
1230 1230 res = lambda p: dest
1231 1231 return res
1232 1232
1233 1233 pats = scmutil.expandpats(pats)
1234 1234 if not pats:
1235 1235 raise error.Abort(_('no source or destination specified'))
1236 1236 if len(pats) == 1:
1237 1237 raise error.Abort(_('no destination specified'))
1238 1238 dest = pats.pop()
1239 1239 destdirexists = os.path.isdir(dest) and not os.path.islink(dest)
1240 1240 if not destdirexists:
1241 1241 if len(pats) > 1 or matchmod.patkind(pats[0]):
1242 1242 raise error.Abort(_('with multiple sources, destination must be an '
1243 1243 'existing directory'))
1244 1244 if util.endswithsep(dest):
1245 1245 raise error.Abort(_('destination %s is not a directory') % dest)
1246 1246
1247 1247 tfn = targetpathfn
1248 1248 if after:
1249 1249 tfn = targetpathafterfn
1250 1250 copylist = []
1251 1251 for pat in pats:
1252 1252 srcs = walkpat(pat)
1253 1253 if not srcs:
1254 1254 continue
1255 1255 copylist.append((tfn(pat, dest, srcs), srcs))
1256 1256 if not copylist:
1257 1257 raise error.Abort(_('no files to copy'))
1258 1258
1259 1259 errors = 0
1260 1260 for targetpath, srcs in copylist:
1261 1261 for abssrc, relsrc, exact in srcs:
1262 1262 if copyfile(abssrc, relsrc, targetpath(abssrc), exact):
1263 1263 errors += 1
1264 1264
1265 1265 if errors:
1266 1266 ui.warn(_('(consider using --after)\n'))
1267 1267
1268 1268 return errors != 0
1269 1269
1270 1270 ## facility to let extension process additional data into an import patch
1271 1271 # list of identifier to be executed in order
1272 1272 extrapreimport = [] # run before commit
1273 1273 extrapostimport = [] # run after commit
1274 1274 # mapping from identifier to actual import function
1275 1275 #
1276 1276 # 'preimport' are run before the commit is made and are provided the following
1277 1277 # arguments:
1278 1278 # - repo: the localrepository instance,
1279 1279 # - patchdata: data extracted from patch header (cf m.patch.patchheadermap),
1280 1280 # - extra: the future extra dictionary of the changeset, please mutate it,
1281 1281 # - opts: the import options.
1282 1282 # XXX ideally, we would just pass an ctx ready to be computed, that would allow
1283 1283 # mutation of in memory commit and more. Feel free to rework the code to get
1284 1284 # there.
1285 1285 extrapreimportmap = {}
1286 1286 # 'postimport' are run after the commit is made and are provided the following
1287 1287 # argument:
1288 1288 # - ctx: the changectx created by import.
1289 1289 extrapostimportmap = {}
1290 1290
1291 1291 def tryimportone(ui, repo, hunk, parents, opts, msgs, updatefunc):
1292 1292 """Utility function used by commands.import to import a single patch
1293 1293
1294 1294 This function is explicitly defined here to help the evolve extension to
1295 1295 wrap this part of the import logic.
1296 1296
1297 1297 The API is currently a bit ugly because it a simple code translation from
1298 1298 the import command. Feel free to make it better.
1299 1299
1300 1300 :hunk: a patch (as a binary string)
1301 1301 :parents: nodes that will be parent of the created commit
1302 1302 :opts: the full dict of option passed to the import command
1303 1303 :msgs: list to save commit message to.
1304 1304 (used in case we need to save it when failing)
1305 1305 :updatefunc: a function that update a repo to a given node
1306 1306 updatefunc(<repo>, <node>)
1307 1307 """
1308 1308 # avoid cycle context -> subrepo -> cmdutil
1309 1309 from . import context
1310 1310 extractdata = patch.extract(ui, hunk)
1311 1311 tmpname = extractdata.get('filename')
1312 1312 message = extractdata.get('message')
1313 1313 user = opts.get('user') or extractdata.get('user')
1314 1314 date = opts.get('date') or extractdata.get('date')
1315 1315 branch = extractdata.get('branch')
1316 1316 nodeid = extractdata.get('nodeid')
1317 1317 p1 = extractdata.get('p1')
1318 1318 p2 = extractdata.get('p2')
1319 1319
1320 1320 nocommit = opts.get('no_commit')
1321 1321 importbranch = opts.get('import_branch')
1322 1322 update = not opts.get('bypass')
1323 1323 strip = opts["strip"]
1324 1324 prefix = opts["prefix"]
1325 1325 sim = float(opts.get('similarity') or 0)
1326 1326 if not tmpname:
1327 1327 return (None, None, False)
1328 1328
1329 1329 rejects = False
1330 1330
1331 1331 try:
1332 1332 cmdline_message = logmessage(ui, opts)
1333 1333 if cmdline_message:
1334 1334 # pickup the cmdline msg
1335 1335 message = cmdline_message
1336 1336 elif message:
1337 1337 # pickup the patch msg
1338 1338 message = message.strip()
1339 1339 else:
1340 1340 # launch the editor
1341 1341 message = None
1342 1342 ui.debug('message:\n%s\n' % message)
1343 1343
1344 1344 if len(parents) == 1:
1345 1345 parents.append(repo[nullid])
1346 1346 if opts.get('exact'):
1347 1347 if not nodeid or not p1:
1348 1348 raise error.Abort(_('not a Mercurial patch'))
1349 1349 p1 = repo[p1]
1350 1350 p2 = repo[p2 or nullid]
1351 1351 elif p2:
1352 1352 try:
1353 1353 p1 = repo[p1]
1354 1354 p2 = repo[p2]
1355 1355 # Without any options, consider p2 only if the
1356 1356 # patch is being applied on top of the recorded
1357 1357 # first parent.
1358 1358 if p1 != parents[0]:
1359 1359 p1 = parents[0]
1360 1360 p2 = repo[nullid]
1361 1361 except error.RepoError:
1362 1362 p1, p2 = parents
1363 1363 if p2.node() == nullid:
1364 1364 ui.warn(_("warning: import the patch as a normal revision\n"
1365 1365 "(use --exact to import the patch as a merge)\n"))
1366 1366 else:
1367 1367 p1, p2 = parents
1368 1368
1369 1369 n = None
1370 1370 if update:
1371 1371 if p1 != parents[0]:
1372 1372 updatefunc(repo, p1.node())
1373 1373 if p2 != parents[1]:
1374 1374 repo.setparents(p1.node(), p2.node())
1375 1375
1376 1376 if opts.get('exact') or importbranch:
1377 1377 repo.dirstate.setbranch(branch or 'default')
1378 1378
1379 1379 partial = opts.get('partial', False)
1380 1380 files = set()
1381 1381 try:
1382 1382 patch.patch(ui, repo, tmpname, strip=strip, prefix=prefix,
1383 1383 files=files, eolmode=None, similarity=sim / 100.0)
1384 1384 except error.PatchError as e:
1385 1385 if not partial:
1386 1386 raise error.Abort(str(e))
1387 1387 if partial:
1388 1388 rejects = True
1389 1389
1390 1390 files = list(files)
1391 1391 if nocommit:
1392 1392 if message:
1393 1393 msgs.append(message)
1394 1394 else:
1395 1395 if opts.get('exact') or p2:
1396 1396 # If you got here, you either use --force and know what
1397 1397 # you are doing or used --exact or a merge patch while
1398 1398 # being updated to its first parent.
1399 1399 m = None
1400 1400 else:
1401 1401 m = scmutil.matchfiles(repo, files or [])
1402 1402 editform = mergeeditform(repo[None], 'import.normal')
1403 1403 if opts.get('exact'):
1404 1404 editor = None
1405 1405 else:
1406 1406 editor = getcommiteditor(editform=editform,
1407 1407 **pycompat.strkwargs(opts))
1408 1408 extra = {}
1409 1409 for idfunc in extrapreimport:
1410 1410 extrapreimportmap[idfunc](repo, extractdata, extra, opts)
1411 1411 overrides = {}
1412 1412 if partial:
1413 1413 overrides[('ui', 'allowemptycommit')] = True
1414 1414 with repo.ui.configoverride(overrides, 'import'):
1415 1415 n = repo.commit(message, user,
1416 1416 date, match=m,
1417 1417 editor=editor, extra=extra)
1418 1418 for idfunc in extrapostimport:
1419 1419 extrapostimportmap[idfunc](repo[n])
1420 1420 else:
1421 1421 if opts.get('exact') or importbranch:
1422 1422 branch = branch or 'default'
1423 1423 else:
1424 1424 branch = p1.branch()
1425 1425 store = patch.filestore()
1426 1426 try:
1427 1427 files = set()
1428 1428 try:
1429 1429 patch.patchrepo(ui, repo, p1, store, tmpname, strip, prefix,
1430 1430 files, eolmode=None)
1431 1431 except error.PatchError as e:
1432 1432 raise error.Abort(str(e))
1433 1433 if opts.get('exact'):
1434 1434 editor = None
1435 1435 else:
1436 1436 editor = getcommiteditor(editform='import.bypass')
1437 1437 memctx = context.memctx(repo, (p1.node(), p2.node()),
1438 1438 message,
1439 1439 files=files,
1440 1440 filectxfn=store,
1441 1441 user=user,
1442 1442 date=date,
1443 1443 branch=branch,
1444 1444 editor=editor)
1445 1445 n = memctx.commit()
1446 1446 finally:
1447 1447 store.close()
1448 1448 if opts.get('exact') and nocommit:
1449 1449 # --exact with --no-commit is still useful in that it does merge
1450 1450 # and branch bits
1451 1451 ui.warn(_("warning: can't check exact import with --no-commit\n"))
1452 1452 elif opts.get('exact') and hex(n) != nodeid:
1453 1453 raise error.Abort(_('patch is damaged or loses information'))
1454 1454 msg = _('applied to working directory')
1455 1455 if n:
1456 1456 # i18n: refers to a short changeset id
1457 1457 msg = _('created %s') % short(n)
1458 1458 return (msg, n, rejects)
1459 1459 finally:
1460 1460 os.unlink(tmpname)
1461 1461
1462 1462 # facility to let extensions include additional data in an exported patch
1463 1463 # list of identifiers to be executed in order
1464 1464 extraexport = []
1465 1465 # mapping from identifier to actual export function
1466 1466 # function as to return a string to be added to the header or None
1467 1467 # it is given two arguments (sequencenumber, changectx)
1468 1468 extraexportmap = {}
1469 1469
1470 1470 def _exportsingle(repo, ctx, match, switch_parent, rev, seqno, write, diffopts):
1471 1471 node = scmutil.binnode(ctx)
1472 1472 parents = [p.node() for p in ctx.parents() if p]
1473 1473 branch = ctx.branch()
1474 1474 if switch_parent:
1475 1475 parents.reverse()
1476 1476
1477 1477 if parents:
1478 1478 prev = parents[0]
1479 1479 else:
1480 1480 prev = nullid
1481 1481
1482 1482 write("# HG changeset patch\n")
1483 1483 write("# User %s\n" % ctx.user())
1484 1484 write("# Date %d %d\n" % ctx.date())
1485 1485 write("# %s\n" % util.datestr(ctx.date()))
1486 1486 if branch and branch != 'default':
1487 1487 write("# Branch %s\n" % branch)
1488 1488 write("# Node ID %s\n" % hex(node))
1489 1489 write("# Parent %s\n" % hex(prev))
1490 1490 if len(parents) > 1:
1491 1491 write("# Parent %s\n" % hex(parents[1]))
1492 1492
1493 1493 for headerid in extraexport:
1494 1494 header = extraexportmap[headerid](seqno, ctx)
1495 1495 if header is not None:
1496 1496 write('# %s\n' % header)
1497 1497 write(ctx.description().rstrip())
1498 1498 write("\n\n")
1499 1499
1500 1500 for chunk, label in patch.diffui(repo, prev, node, match, opts=diffopts):
1501 1501 write(chunk, label=label)
1502 1502
1503 1503 def export(repo, revs, fntemplate='hg-%h.patch', fp=None, switch_parent=False,
1504 1504 opts=None, match=None):
1505 1505 '''export changesets as hg patches
1506 1506
1507 1507 Args:
1508 1508 repo: The repository from which we're exporting revisions.
1509 1509 revs: A list of revisions to export as revision numbers.
1510 1510 fntemplate: An optional string to use for generating patch file names.
1511 1511 fp: An optional file-like object to which patches should be written.
1512 1512 switch_parent: If True, show diffs against second parent when not nullid.
1513 1513 Default is false, which always shows diff against p1.
1514 1514 opts: diff options to use for generating the patch.
1515 1515 match: If specified, only export changes to files matching this matcher.
1516 1516
1517 1517 Returns:
1518 1518 Nothing.
1519 1519
1520 1520 Side Effect:
1521 1521 "HG Changeset Patch" data is emitted to one of the following
1522 1522 destinations:
1523 1523 fp is specified: All revs are written to the specified
1524 1524 file-like object.
1525 1525 fntemplate specified: Each rev is written to a unique file named using
1526 1526 the given template.
1527 1527 Neither fp nor template specified: All revs written to repo.ui.write()
1528 1528 '''
1529 1529
1530 1530 total = len(revs)
1531 1531 revwidth = max(len(str(rev)) for rev in revs)
1532 1532 filemode = {}
1533 1533
1534 1534 write = None
1535 1535 dest = '<unnamed>'
1536 1536 if fp:
1537 1537 dest = getattr(fp, 'name', dest)
1538 1538 def write(s, **kw):
1539 1539 fp.write(s)
1540 1540 elif not fntemplate:
1541 1541 write = repo.ui.write
1542 1542
1543 1543 for seqno, rev in enumerate(revs, 1):
1544 1544 ctx = repo[rev]
1545 1545 fo = None
1546 1546 if not fp and fntemplate:
1547 1547 desc_lines = ctx.description().rstrip().split('\n')
1548 1548 desc = desc_lines[0] #Commit always has a first line.
1549 fo = makefileobj(repo, fntemplate, ctx.node(), desc=desc,
1549 fo = makefileobj(ctx, fntemplate, desc=desc,
1550 1550 total=total, seqno=seqno, revwidth=revwidth,
1551 1551 mode='wb', modemap=filemode)
1552 1552 dest = fo.name
1553 1553 def write(s, **kw):
1554 1554 fo.write(s)
1555 1555 if not dest.startswith('<'):
1556 1556 repo.ui.note("%s\n" % dest)
1557 1557 _exportsingle(
1558 1558 repo, ctx, match, switch_parent, rev, seqno, write, opts)
1559 1559 if fo is not None:
1560 1560 fo.close()
1561 1561
1562 1562 def showmarker(fm, marker, index=None):
1563 1563 """utility function to display obsolescence marker in a readable way
1564 1564
1565 1565 To be used by debug function."""
1566 1566 if index is not None:
1567 1567 fm.write('index', '%i ', index)
1568 1568 fm.write('prednode', '%s ', hex(marker.prednode()))
1569 1569 succs = marker.succnodes()
1570 1570 fm.condwrite(succs, 'succnodes', '%s ',
1571 1571 fm.formatlist(map(hex, succs), name='node'))
1572 1572 fm.write('flag', '%X ', marker.flags())
1573 1573 parents = marker.parentnodes()
1574 1574 if parents is not None:
1575 1575 fm.write('parentnodes', '{%s} ',
1576 1576 fm.formatlist(map(hex, parents), name='node', sep=', '))
1577 1577 fm.write('date', '(%s) ', fm.formatdate(marker.date()))
1578 1578 meta = marker.metadata().copy()
1579 1579 meta.pop('date', None)
1580 1580 smeta = util.rapply(pycompat.maybebytestr, meta)
1581 1581 fm.write('metadata', '{%s}', fm.formatdict(smeta, fmt='%r: %r', sep=', '))
1582 1582 fm.plain('\n')
1583 1583
1584 1584 def finddate(ui, repo, date):
1585 1585 """Find the tipmost changeset that matches the given date spec"""
1586 1586
1587 1587 df = util.matchdate(date)
1588 1588 m = scmutil.matchall(repo)
1589 1589 results = {}
1590 1590
1591 1591 def prep(ctx, fns):
1592 1592 d = ctx.date()
1593 1593 if df(d[0]):
1594 1594 results[ctx.rev()] = d
1595 1595
1596 1596 for ctx in walkchangerevs(repo, m, {'rev': None}, prep):
1597 1597 rev = ctx.rev()
1598 1598 if rev in results:
1599 1599 ui.status(_("found revision %s from %s\n") %
1600 1600 (rev, util.datestr(results[rev])))
1601 1601 return '%d' % rev
1602 1602
1603 1603 raise error.Abort(_("revision matching date not found"))
1604 1604
1605 1605 def increasingwindows(windowsize=8, sizelimit=512):
1606 1606 while True:
1607 1607 yield windowsize
1608 1608 if windowsize < sizelimit:
1609 1609 windowsize *= 2
1610 1610
1611 1611 def _walkrevs(repo, opts):
1612 1612 # Default --rev value depends on --follow but --follow behavior
1613 1613 # depends on revisions resolved from --rev...
1614 1614 follow = opts.get('follow') or opts.get('follow_first')
1615 1615 if opts.get('rev'):
1616 1616 revs = scmutil.revrange(repo, opts['rev'])
1617 1617 elif follow and repo.dirstate.p1() == nullid:
1618 1618 revs = smartset.baseset()
1619 1619 elif follow:
1620 1620 revs = repo.revs('reverse(:.)')
1621 1621 else:
1622 1622 revs = smartset.spanset(repo)
1623 1623 revs.reverse()
1624 1624 return revs
1625 1625
1626 1626 class FileWalkError(Exception):
1627 1627 pass
1628 1628
1629 1629 def walkfilerevs(repo, match, follow, revs, fncache):
1630 1630 '''Walks the file history for the matched files.
1631 1631
1632 1632 Returns the changeset revs that are involved in the file history.
1633 1633
1634 1634 Throws FileWalkError if the file history can't be walked using
1635 1635 filelogs alone.
1636 1636 '''
1637 1637 wanted = set()
1638 1638 copies = []
1639 1639 minrev, maxrev = min(revs), max(revs)
1640 1640 def filerevgen(filelog, last):
1641 1641 """
1642 1642 Only files, no patterns. Check the history of each file.
1643 1643
1644 1644 Examines filelog entries within minrev, maxrev linkrev range
1645 1645 Returns an iterator yielding (linkrev, parentlinkrevs, copied)
1646 1646 tuples in backwards order
1647 1647 """
1648 1648 cl_count = len(repo)
1649 1649 revs = []
1650 1650 for j in xrange(0, last + 1):
1651 1651 linkrev = filelog.linkrev(j)
1652 1652 if linkrev < minrev:
1653 1653 continue
1654 1654 # only yield rev for which we have the changelog, it can
1655 1655 # happen while doing "hg log" during a pull or commit
1656 1656 if linkrev >= cl_count:
1657 1657 break
1658 1658
1659 1659 parentlinkrevs = []
1660 1660 for p in filelog.parentrevs(j):
1661 1661 if p != nullrev:
1662 1662 parentlinkrevs.append(filelog.linkrev(p))
1663 1663 n = filelog.node(j)
1664 1664 revs.append((linkrev, parentlinkrevs,
1665 1665 follow and filelog.renamed(n)))
1666 1666
1667 1667 return reversed(revs)
1668 1668 def iterfiles():
1669 1669 pctx = repo['.']
1670 1670 for filename in match.files():
1671 1671 if follow:
1672 1672 if filename not in pctx:
1673 1673 raise error.Abort(_('cannot follow file not in parent '
1674 1674 'revision: "%s"') % filename)
1675 1675 yield filename, pctx[filename].filenode()
1676 1676 else:
1677 1677 yield filename, None
1678 1678 for filename_node in copies:
1679 1679 yield filename_node
1680 1680
1681 1681 for file_, node in iterfiles():
1682 1682 filelog = repo.file(file_)
1683 1683 if not len(filelog):
1684 1684 if node is None:
1685 1685 # A zero count may be a directory or deleted file, so
1686 1686 # try to find matching entries on the slow path.
1687 1687 if follow:
1688 1688 raise error.Abort(
1689 1689 _('cannot follow nonexistent file: "%s"') % file_)
1690 1690 raise FileWalkError("Cannot walk via filelog")
1691 1691 else:
1692 1692 continue
1693 1693
1694 1694 if node is None:
1695 1695 last = len(filelog) - 1
1696 1696 else:
1697 1697 last = filelog.rev(node)
1698 1698
1699 1699 # keep track of all ancestors of the file
1700 1700 ancestors = {filelog.linkrev(last)}
1701 1701
1702 1702 # iterate from latest to oldest revision
1703 1703 for rev, flparentlinkrevs, copied in filerevgen(filelog, last):
1704 1704 if not follow:
1705 1705 if rev > maxrev:
1706 1706 continue
1707 1707 else:
1708 1708 # Note that last might not be the first interesting
1709 1709 # rev to us:
1710 1710 # if the file has been changed after maxrev, we'll
1711 1711 # have linkrev(last) > maxrev, and we still need
1712 1712 # to explore the file graph
1713 1713 if rev not in ancestors:
1714 1714 continue
1715 1715 # XXX insert 1327 fix here
1716 1716 if flparentlinkrevs:
1717 1717 ancestors.update(flparentlinkrevs)
1718 1718
1719 1719 fncache.setdefault(rev, []).append(file_)
1720 1720 wanted.add(rev)
1721 1721 if copied:
1722 1722 copies.append(copied)
1723 1723
1724 1724 return wanted
1725 1725
1726 1726 class _followfilter(object):
1727 1727 def __init__(self, repo, onlyfirst=False):
1728 1728 self.repo = repo
1729 1729 self.startrev = nullrev
1730 1730 self.roots = set()
1731 1731 self.onlyfirst = onlyfirst
1732 1732
1733 1733 def match(self, rev):
1734 1734 def realparents(rev):
1735 1735 if self.onlyfirst:
1736 1736 return self.repo.changelog.parentrevs(rev)[0:1]
1737 1737 else:
1738 1738 return filter(lambda x: x != nullrev,
1739 1739 self.repo.changelog.parentrevs(rev))
1740 1740
1741 1741 if self.startrev == nullrev:
1742 1742 self.startrev = rev
1743 1743 return True
1744 1744
1745 1745 if rev > self.startrev:
1746 1746 # forward: all descendants
1747 1747 if not self.roots:
1748 1748 self.roots.add(self.startrev)
1749 1749 for parent in realparents(rev):
1750 1750 if parent in self.roots:
1751 1751 self.roots.add(rev)
1752 1752 return True
1753 1753 else:
1754 1754 # backwards: all parents
1755 1755 if not self.roots:
1756 1756 self.roots.update(realparents(self.startrev))
1757 1757 if rev in self.roots:
1758 1758 self.roots.remove(rev)
1759 1759 self.roots.update(realparents(rev))
1760 1760 return True
1761 1761
1762 1762 return False
1763 1763
1764 1764 def walkchangerevs(repo, match, opts, prepare):
1765 1765 '''Iterate over files and the revs in which they changed.
1766 1766
1767 1767 Callers most commonly need to iterate backwards over the history
1768 1768 in which they are interested. Doing so has awful (quadratic-looking)
1769 1769 performance, so we use iterators in a "windowed" way.
1770 1770
1771 1771 We walk a window of revisions in the desired order. Within the
1772 1772 window, we first walk forwards to gather data, then in the desired
1773 1773 order (usually backwards) to display it.
1774 1774
1775 1775 This function returns an iterator yielding contexts. Before
1776 1776 yielding each context, the iterator will first call the prepare
1777 1777 function on each context in the window in forward order.'''
1778 1778
1779 1779 follow = opts.get('follow') or opts.get('follow_first')
1780 1780 revs = _walkrevs(repo, opts)
1781 1781 if not revs:
1782 1782 return []
1783 1783 wanted = set()
1784 1784 slowpath = match.anypats() or (not match.always() and opts.get('removed'))
1785 1785 fncache = {}
1786 1786 change = repo.changectx
1787 1787
1788 1788 # First step is to fill wanted, the set of revisions that we want to yield.
1789 1789 # When it does not induce extra cost, we also fill fncache for revisions in
1790 1790 # wanted: a cache of filenames that were changed (ctx.files()) and that
1791 1791 # match the file filtering conditions.
1792 1792
1793 1793 if match.always():
1794 1794 # No files, no patterns. Display all revs.
1795 1795 wanted = revs
1796 1796 elif not slowpath:
1797 1797 # We only have to read through the filelog to find wanted revisions
1798 1798
1799 1799 try:
1800 1800 wanted = walkfilerevs(repo, match, follow, revs, fncache)
1801 1801 except FileWalkError:
1802 1802 slowpath = True
1803 1803
1804 1804 # We decided to fall back to the slowpath because at least one
1805 1805 # of the paths was not a file. Check to see if at least one of them
1806 1806 # existed in history, otherwise simply return
1807 1807 for path in match.files():
1808 1808 if path == '.' or path in repo.store:
1809 1809 break
1810 1810 else:
1811 1811 return []
1812 1812
1813 1813 if slowpath:
1814 1814 # We have to read the changelog to match filenames against
1815 1815 # changed files
1816 1816
1817 1817 if follow:
1818 1818 raise error.Abort(_('can only follow copies/renames for explicit '
1819 1819 'filenames'))
1820 1820
1821 1821 # The slow path checks files modified in every changeset.
1822 1822 # This is really slow on large repos, so compute the set lazily.
1823 1823 class lazywantedset(object):
1824 1824 def __init__(self):
1825 1825 self.set = set()
1826 1826 self.revs = set(revs)
1827 1827
1828 1828 # No need to worry about locality here because it will be accessed
1829 1829 # in the same order as the increasing window below.
1830 1830 def __contains__(self, value):
1831 1831 if value in self.set:
1832 1832 return True
1833 1833 elif not value in self.revs:
1834 1834 return False
1835 1835 else:
1836 1836 self.revs.discard(value)
1837 1837 ctx = change(value)
1838 1838 matches = filter(match, ctx.files())
1839 1839 if matches:
1840 1840 fncache[value] = matches
1841 1841 self.set.add(value)
1842 1842 return True
1843 1843 return False
1844 1844
1845 1845 def discard(self, value):
1846 1846 self.revs.discard(value)
1847 1847 self.set.discard(value)
1848 1848
1849 1849 wanted = lazywantedset()
1850 1850
1851 1851 # it might be worthwhile to do this in the iterator if the rev range
1852 1852 # is descending and the prune args are all within that range
1853 1853 for rev in opts.get('prune', ()):
1854 1854 rev = repo[rev].rev()
1855 1855 ff = _followfilter(repo)
1856 1856 stop = min(revs[0], revs[-1])
1857 1857 for x in xrange(rev, stop - 1, -1):
1858 1858 if ff.match(x):
1859 1859 wanted = wanted - [x]
1860 1860
1861 1861 # Now that wanted is correctly initialized, we can iterate over the
1862 1862 # revision range, yielding only revisions in wanted.
1863 1863 def iterate():
1864 1864 if follow and match.always():
1865 1865 ff = _followfilter(repo, onlyfirst=opts.get('follow_first'))
1866 1866 def want(rev):
1867 1867 return ff.match(rev) and rev in wanted
1868 1868 else:
1869 1869 def want(rev):
1870 1870 return rev in wanted
1871 1871
1872 1872 it = iter(revs)
1873 1873 stopiteration = False
1874 1874 for windowsize in increasingwindows():
1875 1875 nrevs = []
1876 1876 for i in xrange(windowsize):
1877 1877 rev = next(it, None)
1878 1878 if rev is None:
1879 1879 stopiteration = True
1880 1880 break
1881 1881 elif want(rev):
1882 1882 nrevs.append(rev)
1883 1883 for rev in sorted(nrevs):
1884 1884 fns = fncache.get(rev)
1885 1885 ctx = change(rev)
1886 1886 if not fns:
1887 1887 def fns_generator():
1888 1888 for f in ctx.files():
1889 1889 if match(f):
1890 1890 yield f
1891 1891 fns = fns_generator()
1892 1892 prepare(ctx, fns)
1893 1893 for rev in nrevs:
1894 1894 yield change(rev)
1895 1895
1896 1896 if stopiteration:
1897 1897 break
1898 1898
1899 1899 return iterate()
1900 1900
1901 1901 def add(ui, repo, match, prefix, explicitonly, **opts):
1902 1902 join = lambda f: os.path.join(prefix, f)
1903 1903 bad = []
1904 1904
1905 1905 badfn = lambda x, y: bad.append(x) or match.bad(x, y)
1906 1906 names = []
1907 1907 wctx = repo[None]
1908 1908 cca = None
1909 1909 abort, warn = scmutil.checkportabilityalert(ui)
1910 1910 if abort or warn:
1911 1911 cca = scmutil.casecollisionauditor(ui, abort, repo.dirstate)
1912 1912
1913 1913 badmatch = matchmod.badmatch(match, badfn)
1914 1914 dirstate = repo.dirstate
1915 1915 # We don't want to just call wctx.walk here, since it would return a lot of
1916 1916 # clean files, which we aren't interested in and takes time.
1917 1917 for f in sorted(dirstate.walk(badmatch, subrepos=sorted(wctx.substate),
1918 1918 unknown=True, ignored=False, full=False)):
1919 1919 exact = match.exact(f)
1920 1920 if exact or not explicitonly and f not in wctx and repo.wvfs.lexists(f):
1921 1921 if cca:
1922 1922 cca(f)
1923 1923 names.append(f)
1924 1924 if ui.verbose or not exact:
1925 1925 ui.status(_('adding %s\n') % match.rel(f))
1926 1926
1927 1927 for subpath in sorted(wctx.substate):
1928 1928 sub = wctx.sub(subpath)
1929 1929 try:
1930 1930 submatch = matchmod.subdirmatcher(subpath, match)
1931 1931 if opts.get(r'subrepos'):
1932 1932 bad.extend(sub.add(ui, submatch, prefix, False, **opts))
1933 1933 else:
1934 1934 bad.extend(sub.add(ui, submatch, prefix, True, **opts))
1935 1935 except error.LookupError:
1936 1936 ui.status(_("skipping missing subrepository: %s\n")
1937 1937 % join(subpath))
1938 1938
1939 1939 if not opts.get(r'dry_run'):
1940 1940 rejected = wctx.add(names, prefix)
1941 1941 bad.extend(f for f in rejected if f in match.files())
1942 1942 return bad
1943 1943
1944 1944 def addwebdirpath(repo, serverpath, webconf):
1945 1945 webconf[serverpath] = repo.root
1946 1946 repo.ui.debug('adding %s = %s\n' % (serverpath, repo.root))
1947 1947
1948 1948 for r in repo.revs('filelog("path:.hgsub")'):
1949 1949 ctx = repo[r]
1950 1950 for subpath in ctx.substate:
1951 1951 ctx.sub(subpath).addwebdirpath(serverpath, webconf)
1952 1952
1953 1953 def forget(ui, repo, match, prefix, explicitonly):
1954 1954 join = lambda f: os.path.join(prefix, f)
1955 1955 bad = []
1956 1956 badfn = lambda x, y: bad.append(x) or match.bad(x, y)
1957 1957 wctx = repo[None]
1958 1958 forgot = []
1959 1959
1960 1960 s = repo.status(match=matchmod.badmatch(match, badfn), clean=True)
1961 1961 forget = sorted(s.modified + s.added + s.deleted + s.clean)
1962 1962 if explicitonly:
1963 1963 forget = [f for f in forget if match.exact(f)]
1964 1964
1965 1965 for subpath in sorted(wctx.substate):
1966 1966 sub = wctx.sub(subpath)
1967 1967 try:
1968 1968 submatch = matchmod.subdirmatcher(subpath, match)
1969 1969 subbad, subforgot = sub.forget(submatch, prefix)
1970 1970 bad.extend([subpath + '/' + f for f in subbad])
1971 1971 forgot.extend([subpath + '/' + f for f in subforgot])
1972 1972 except error.LookupError:
1973 1973 ui.status(_("skipping missing subrepository: %s\n")
1974 1974 % join(subpath))
1975 1975
1976 1976 if not explicitonly:
1977 1977 for f in match.files():
1978 1978 if f not in repo.dirstate and not repo.wvfs.isdir(f):
1979 1979 if f not in forgot:
1980 1980 if repo.wvfs.exists(f):
1981 1981 # Don't complain if the exact case match wasn't given.
1982 1982 # But don't do this until after checking 'forgot', so
1983 1983 # that subrepo files aren't normalized, and this op is
1984 1984 # purely from data cached by the status walk above.
1985 1985 if repo.dirstate.normalize(f) in repo.dirstate:
1986 1986 continue
1987 1987 ui.warn(_('not removing %s: '
1988 1988 'file is already untracked\n')
1989 1989 % match.rel(f))
1990 1990 bad.append(f)
1991 1991
1992 1992 for f in forget:
1993 1993 if ui.verbose or not match.exact(f):
1994 1994 ui.status(_('removing %s\n') % match.rel(f))
1995 1995
1996 1996 rejected = wctx.forget(forget, prefix)
1997 1997 bad.extend(f for f in rejected if f in match.files())
1998 1998 forgot.extend(f for f in forget if f not in rejected)
1999 1999 return bad, forgot
2000 2000
2001 2001 def files(ui, ctx, m, fm, fmt, subrepos):
2002 2002 rev = ctx.rev()
2003 2003 ret = 1
2004 2004 ds = ctx.repo().dirstate
2005 2005
2006 2006 for f in ctx.matches(m):
2007 2007 if rev is None and ds[f] == 'r':
2008 2008 continue
2009 2009 fm.startitem()
2010 2010 if ui.verbose:
2011 2011 fc = ctx[f]
2012 2012 fm.write('size flags', '% 10d % 1s ', fc.size(), fc.flags())
2013 2013 fm.data(abspath=f)
2014 2014 fm.write('path', fmt, m.rel(f))
2015 2015 ret = 0
2016 2016
2017 2017 for subpath in sorted(ctx.substate):
2018 2018 submatch = matchmod.subdirmatcher(subpath, m)
2019 2019 if (subrepos or m.exact(subpath) or any(submatch.files())):
2020 2020 sub = ctx.sub(subpath)
2021 2021 try:
2022 2022 recurse = m.exact(subpath) or subrepos
2023 2023 if sub.printfiles(ui, submatch, fm, fmt, recurse) == 0:
2024 2024 ret = 0
2025 2025 except error.LookupError:
2026 2026 ui.status(_("skipping missing subrepository: %s\n")
2027 2027 % m.abs(subpath))
2028 2028
2029 2029 return ret
2030 2030
2031 2031 def remove(ui, repo, m, prefix, after, force, subrepos, warnings=None):
2032 2032 join = lambda f: os.path.join(prefix, f)
2033 2033 ret = 0
2034 2034 s = repo.status(match=m, clean=True)
2035 2035 modified, added, deleted, clean = s[0], s[1], s[3], s[6]
2036 2036
2037 2037 wctx = repo[None]
2038 2038
2039 2039 if warnings is None:
2040 2040 warnings = []
2041 2041 warn = True
2042 2042 else:
2043 2043 warn = False
2044 2044
2045 2045 subs = sorted(wctx.substate)
2046 2046 total = len(subs)
2047 2047 count = 0
2048 2048 for subpath in subs:
2049 2049 count += 1
2050 2050 submatch = matchmod.subdirmatcher(subpath, m)
2051 2051 if subrepos or m.exact(subpath) or any(submatch.files()):
2052 2052 ui.progress(_('searching'), count, total=total, unit=_('subrepos'))
2053 2053 sub = wctx.sub(subpath)
2054 2054 try:
2055 2055 if sub.removefiles(submatch, prefix, after, force, subrepos,
2056 2056 warnings):
2057 2057 ret = 1
2058 2058 except error.LookupError:
2059 2059 warnings.append(_("skipping missing subrepository: %s\n")
2060 2060 % join(subpath))
2061 2061 ui.progress(_('searching'), None)
2062 2062
2063 2063 # warn about failure to delete explicit files/dirs
2064 2064 deleteddirs = util.dirs(deleted)
2065 2065 files = m.files()
2066 2066 total = len(files)
2067 2067 count = 0
2068 2068 for f in files:
2069 2069 def insubrepo():
2070 2070 for subpath in wctx.substate:
2071 2071 if f.startswith(subpath + '/'):
2072 2072 return True
2073 2073 return False
2074 2074
2075 2075 count += 1
2076 2076 ui.progress(_('deleting'), count, total=total, unit=_('files'))
2077 2077 isdir = f in deleteddirs or wctx.hasdir(f)
2078 2078 if (f in repo.dirstate or isdir or f == '.'
2079 2079 or insubrepo() or f in subs):
2080 2080 continue
2081 2081
2082 2082 if repo.wvfs.exists(f):
2083 2083 if repo.wvfs.isdir(f):
2084 2084 warnings.append(_('not removing %s: no tracked files\n')
2085 2085 % m.rel(f))
2086 2086 else:
2087 2087 warnings.append(_('not removing %s: file is untracked\n')
2088 2088 % m.rel(f))
2089 2089 # missing files will generate a warning elsewhere
2090 2090 ret = 1
2091 2091 ui.progress(_('deleting'), None)
2092 2092
2093 2093 if force:
2094 2094 list = modified + deleted + clean + added
2095 2095 elif after:
2096 2096 list = deleted
2097 2097 remaining = modified + added + clean
2098 2098 total = len(remaining)
2099 2099 count = 0
2100 2100 for f in remaining:
2101 2101 count += 1
2102 2102 ui.progress(_('skipping'), count, total=total, unit=_('files'))
2103 2103 if ui.verbose or (f in files):
2104 2104 warnings.append(_('not removing %s: file still exists\n')
2105 2105 % m.rel(f))
2106 2106 ret = 1
2107 2107 ui.progress(_('skipping'), None)
2108 2108 else:
2109 2109 list = deleted + clean
2110 2110 total = len(modified) + len(added)
2111 2111 count = 0
2112 2112 for f in modified:
2113 2113 count += 1
2114 2114 ui.progress(_('skipping'), count, total=total, unit=_('files'))
2115 2115 warnings.append(_('not removing %s: file is modified (use -f'
2116 2116 ' to force removal)\n') % m.rel(f))
2117 2117 ret = 1
2118 2118 for f in added:
2119 2119 count += 1
2120 2120 ui.progress(_('skipping'), count, total=total, unit=_('files'))
2121 2121 warnings.append(_("not removing %s: file has been marked for add"
2122 2122 " (use 'hg forget' to undo add)\n") % m.rel(f))
2123 2123 ret = 1
2124 2124 ui.progress(_('skipping'), None)
2125 2125
2126 2126 list = sorted(list)
2127 2127 total = len(list)
2128 2128 count = 0
2129 2129 for f in list:
2130 2130 count += 1
2131 2131 if ui.verbose or not m.exact(f):
2132 2132 ui.progress(_('deleting'), count, total=total, unit=_('files'))
2133 2133 ui.status(_('removing %s\n') % m.rel(f))
2134 2134 ui.progress(_('deleting'), None)
2135 2135
2136 2136 with repo.wlock():
2137 2137 if not after:
2138 2138 for f in list:
2139 2139 if f in added:
2140 2140 continue # we never unlink added files on remove
2141 2141 repo.wvfs.unlinkpath(f, ignoremissing=True)
2142 2142 repo[None].forget(list)
2143 2143
2144 2144 if warn:
2145 2145 for warning in warnings:
2146 2146 ui.warn(warning)
2147 2147
2148 2148 return ret
2149 2149
2150 2150 def _updatecatformatter(fm, ctx, matcher, path, decode):
2151 2151 """Hook for adding data to the formatter used by ``hg cat``.
2152 2152
2153 2153 Extensions (e.g., lfs) can wrap this to inject keywords/data, but must call
2154 2154 this method first."""
2155 2155 data = ctx[path].data()
2156 2156 if decode:
2157 2157 data = ctx.repo().wwritedata(path, data)
2158 2158 fm.startitem()
2159 2159 fm.write('data', '%s', data)
2160 2160 fm.data(abspath=path, path=matcher.rel(path))
2161 2161
2162 2162 def cat(ui, repo, ctx, matcher, basefm, fntemplate, prefix, **opts):
2163 2163 err = 1
2164 2164 opts = pycompat.byteskwargs(opts)
2165 2165
2166 2166 def write(path):
2167 2167 filename = None
2168 2168 if fntemplate:
2169 2169 filename = makefilename(ctx, fntemplate,
2170 2170 pathname=os.path.join(prefix, path))
2171 2171 # attempt to create the directory if it does not already exist
2172 2172 try:
2173 2173 os.makedirs(os.path.dirname(filename))
2174 2174 except OSError:
2175 2175 pass
2176 2176 with formatter.maybereopen(basefm, filename, opts) as fm:
2177 2177 _updatecatformatter(fm, ctx, matcher, path, opts.get('decode'))
2178 2178
2179 2179 # Automation often uses hg cat on single files, so special case it
2180 2180 # for performance to avoid the cost of parsing the manifest.
2181 2181 if len(matcher.files()) == 1 and not matcher.anypats():
2182 2182 file = matcher.files()[0]
2183 2183 mfl = repo.manifestlog
2184 2184 mfnode = ctx.manifestnode()
2185 2185 try:
2186 2186 if mfnode and mfl[mfnode].find(file)[0]:
2187 2187 scmutil.fileprefetchhooks(repo, ctx, [file])
2188 2188 write(file)
2189 2189 return 0
2190 2190 except KeyError:
2191 2191 pass
2192 2192
2193 2193 files = [f for f in ctx.walk(matcher)]
2194 2194 scmutil.fileprefetchhooks(repo, ctx, files)
2195 2195
2196 2196 for abs in files:
2197 2197 write(abs)
2198 2198 err = 0
2199 2199
2200 2200 for subpath in sorted(ctx.substate):
2201 2201 sub = ctx.sub(subpath)
2202 2202 try:
2203 2203 submatch = matchmod.subdirmatcher(subpath, matcher)
2204 2204
2205 2205 if not sub.cat(submatch, basefm, fntemplate,
2206 2206 os.path.join(prefix, sub._path),
2207 2207 **pycompat.strkwargs(opts)):
2208 2208 err = 0
2209 2209 except error.RepoLookupError:
2210 2210 ui.status(_("skipping missing subrepository: %s\n")
2211 2211 % os.path.join(prefix, subpath))
2212 2212
2213 2213 return err
2214 2214
2215 2215 def commit(ui, repo, commitfunc, pats, opts):
2216 2216 '''commit the specified files or all outstanding changes'''
2217 2217 date = opts.get('date')
2218 2218 if date:
2219 2219 opts['date'] = util.parsedate(date)
2220 2220 message = logmessage(ui, opts)
2221 2221 matcher = scmutil.match(repo[None], pats, opts)
2222 2222
2223 2223 dsguard = None
2224 2224 # extract addremove carefully -- this function can be called from a command
2225 2225 # that doesn't support addremove
2226 2226 if opts.get('addremove'):
2227 2227 dsguard = dirstateguard.dirstateguard(repo, 'commit')
2228 2228 with dsguard or util.nullcontextmanager():
2229 2229 if dsguard:
2230 2230 if scmutil.addremove(repo, matcher, "", opts) != 0:
2231 2231 raise error.Abort(
2232 2232 _("failed to mark all new/missing files as added/removed"))
2233 2233
2234 2234 return commitfunc(ui, repo, message, matcher, opts)
2235 2235
2236 2236 def samefile(f, ctx1, ctx2):
2237 2237 if f in ctx1.manifest():
2238 2238 a = ctx1.filectx(f)
2239 2239 if f in ctx2.manifest():
2240 2240 b = ctx2.filectx(f)
2241 2241 return (not a.cmp(b)
2242 2242 and a.flags() == b.flags())
2243 2243 else:
2244 2244 return False
2245 2245 else:
2246 2246 return f not in ctx2.manifest()
2247 2247
2248 2248 def amend(ui, repo, old, extra, pats, opts):
2249 2249 # avoid cycle context -> subrepo -> cmdutil
2250 2250 from . import context
2251 2251
2252 2252 # amend will reuse the existing user if not specified, but the obsolete
2253 2253 # marker creation requires that the current user's name is specified.
2254 2254 if obsolete.isenabled(repo, obsolete.createmarkersopt):
2255 2255 ui.username() # raise exception if username not set
2256 2256
2257 2257 ui.note(_('amending changeset %s\n') % old)
2258 2258 base = old.p1()
2259 2259
2260 2260 with repo.wlock(), repo.lock(), repo.transaction('amend'):
2261 2261 # Participating changesets:
2262 2262 #
2263 2263 # wctx o - workingctx that contains changes from working copy
2264 2264 # | to go into amending commit
2265 2265 # |
2266 2266 # old o - changeset to amend
2267 2267 # |
2268 2268 # base o - first parent of the changeset to amend
2269 2269 wctx = repo[None]
2270 2270
2271 2271 # Copy to avoid mutating input
2272 2272 extra = extra.copy()
2273 2273 # Update extra dict from amended commit (e.g. to preserve graft
2274 2274 # source)
2275 2275 extra.update(old.extra())
2276 2276
2277 2277 # Also update it from the from the wctx
2278 2278 extra.update(wctx.extra())
2279 2279
2280 2280 user = opts.get('user') or old.user()
2281 2281 date = opts.get('date') or old.date()
2282 2282
2283 2283 # Parse the date to allow comparison between date and old.date()
2284 2284 date = util.parsedate(date)
2285 2285
2286 2286 if len(old.parents()) > 1:
2287 2287 # ctx.files() isn't reliable for merges, so fall back to the
2288 2288 # slower repo.status() method
2289 2289 files = set([fn for st in repo.status(base, old)[:3]
2290 2290 for fn in st])
2291 2291 else:
2292 2292 files = set(old.files())
2293 2293
2294 2294 # add/remove the files to the working copy if the "addremove" option
2295 2295 # was specified.
2296 2296 matcher = scmutil.match(wctx, pats, opts)
2297 2297 if (opts.get('addremove')
2298 2298 and scmutil.addremove(repo, matcher, "", opts)):
2299 2299 raise error.Abort(
2300 2300 _("failed to mark all new/missing files as added/removed"))
2301 2301
2302 2302 # Check subrepos. This depends on in-place wctx._status update in
2303 2303 # subrepo.precommit(). To minimize the risk of this hack, we do
2304 2304 # nothing if .hgsub does not exist.
2305 2305 if '.hgsub' in wctx or '.hgsub' in old:
2306 2306 subs, commitsubs, newsubstate = subrepoutil.precommit(
2307 2307 ui, wctx, wctx._status, matcher)
2308 2308 # amend should abort if commitsubrepos is enabled
2309 2309 assert not commitsubs
2310 2310 if subs:
2311 2311 subrepoutil.writestate(repo, newsubstate)
2312 2312
2313 2313 filestoamend = set(f for f in wctx.files() if matcher(f))
2314 2314
2315 2315 changes = (len(filestoamend) > 0)
2316 2316 if changes:
2317 2317 # Recompute copies (avoid recording a -> b -> a)
2318 2318 copied = copies.pathcopies(base, wctx, matcher)
2319 2319 if old.p2:
2320 2320 copied.update(copies.pathcopies(old.p2(), wctx, matcher))
2321 2321
2322 2322 # Prune files which were reverted by the updates: if old
2323 2323 # introduced file X and the file was renamed in the working
2324 2324 # copy, then those two files are the same and
2325 2325 # we can discard X from our list of files. Likewise if X
2326 2326 # was removed, it's no longer relevant. If X is missing (aka
2327 2327 # deleted), old X must be preserved.
2328 2328 files.update(filestoamend)
2329 2329 files = [f for f in files if (not samefile(f, wctx, base)
2330 2330 or f in wctx.deleted())]
2331 2331
2332 2332 def filectxfn(repo, ctx_, path):
2333 2333 try:
2334 2334 # If the file being considered is not amongst the files
2335 2335 # to be amended, we should return the file context from the
2336 2336 # old changeset. This avoids issues when only some files in
2337 2337 # the working copy are being amended but there are also
2338 2338 # changes to other files from the old changeset.
2339 2339 if path not in filestoamend:
2340 2340 return old.filectx(path)
2341 2341
2342 2342 # Return None for removed files.
2343 2343 if path in wctx.removed():
2344 2344 return None
2345 2345
2346 2346 fctx = wctx[path]
2347 2347 flags = fctx.flags()
2348 2348 mctx = context.memfilectx(repo, ctx_,
2349 2349 fctx.path(), fctx.data(),
2350 2350 islink='l' in flags,
2351 2351 isexec='x' in flags,
2352 2352 copied=copied.get(path))
2353 2353 return mctx
2354 2354 except KeyError:
2355 2355 return None
2356 2356 else:
2357 2357 ui.note(_('copying changeset %s to %s\n') % (old, base))
2358 2358
2359 2359 # Use version of files as in the old cset
2360 2360 def filectxfn(repo, ctx_, path):
2361 2361 try:
2362 2362 return old.filectx(path)
2363 2363 except KeyError:
2364 2364 return None
2365 2365
2366 2366 # See if we got a message from -m or -l, if not, open the editor with
2367 2367 # the message of the changeset to amend.
2368 2368 message = logmessage(ui, opts)
2369 2369
2370 2370 editform = mergeeditform(old, 'commit.amend')
2371 2371 editor = getcommiteditor(editform=editform,
2372 2372 **pycompat.strkwargs(opts))
2373 2373
2374 2374 if not message:
2375 2375 editor = getcommiteditor(edit=True, editform=editform)
2376 2376 message = old.description()
2377 2377
2378 2378 pureextra = extra.copy()
2379 2379 extra['amend_source'] = old.hex()
2380 2380
2381 2381 new = context.memctx(repo,
2382 2382 parents=[base.node(), old.p2().node()],
2383 2383 text=message,
2384 2384 files=files,
2385 2385 filectxfn=filectxfn,
2386 2386 user=user,
2387 2387 date=date,
2388 2388 extra=extra,
2389 2389 editor=editor)
2390 2390
2391 2391 newdesc = changelog.stripdesc(new.description())
2392 2392 if ((not changes)
2393 2393 and newdesc == old.description()
2394 2394 and user == old.user()
2395 2395 and date == old.date()
2396 2396 and pureextra == old.extra()):
2397 2397 # nothing changed. continuing here would create a new node
2398 2398 # anyway because of the amend_source noise.
2399 2399 #
2400 2400 # This not what we expect from amend.
2401 2401 return old.node()
2402 2402
2403 2403 if opts.get('secret'):
2404 2404 commitphase = 'secret'
2405 2405 else:
2406 2406 commitphase = old.phase()
2407 2407 overrides = {('phases', 'new-commit'): commitphase}
2408 2408 with ui.configoverride(overrides, 'amend'):
2409 2409 newid = repo.commitctx(new)
2410 2410
2411 2411 # Reroute the working copy parent to the new changeset
2412 2412 repo.setparents(newid, nullid)
2413 2413 mapping = {old.node(): (newid,)}
2414 2414 obsmetadata = None
2415 2415 if opts.get('note'):
2416 2416 obsmetadata = {'note': opts['note']}
2417 2417 scmutil.cleanupnodes(repo, mapping, 'amend', metadata=obsmetadata)
2418 2418
2419 2419 # Fixing the dirstate because localrepo.commitctx does not update
2420 2420 # it. This is rather convenient because we did not need to update
2421 2421 # the dirstate for all the files in the new commit which commitctx
2422 2422 # could have done if it updated the dirstate. Now, we can
2423 2423 # selectively update the dirstate only for the amended files.
2424 2424 dirstate = repo.dirstate
2425 2425
2426 2426 # Update the state of the files which were added and
2427 2427 # and modified in the amend to "normal" in the dirstate.
2428 2428 normalfiles = set(wctx.modified() + wctx.added()) & filestoamend
2429 2429 for f in normalfiles:
2430 2430 dirstate.normal(f)
2431 2431
2432 2432 # Update the state of files which were removed in the amend
2433 2433 # to "removed" in the dirstate.
2434 2434 removedfiles = set(wctx.removed()) & filestoamend
2435 2435 for f in removedfiles:
2436 2436 dirstate.drop(f)
2437 2437
2438 2438 return newid
2439 2439
2440 2440 def commiteditor(repo, ctx, subs, editform=''):
2441 2441 if ctx.description():
2442 2442 return ctx.description()
2443 2443 return commitforceeditor(repo, ctx, subs, editform=editform,
2444 2444 unchangedmessagedetection=True)
2445 2445
2446 2446 def commitforceeditor(repo, ctx, subs, finishdesc=None, extramsg=None,
2447 2447 editform='', unchangedmessagedetection=False):
2448 2448 if not extramsg:
2449 2449 extramsg = _("Leave message empty to abort commit.")
2450 2450
2451 2451 forms = [e for e in editform.split('.') if e]
2452 2452 forms.insert(0, 'changeset')
2453 2453 templatetext = None
2454 2454 while forms:
2455 2455 ref = '.'.join(forms)
2456 2456 if repo.ui.config('committemplate', ref):
2457 2457 templatetext = committext = buildcommittemplate(
2458 2458 repo, ctx, subs, extramsg, ref)
2459 2459 break
2460 2460 forms.pop()
2461 2461 else:
2462 2462 committext = buildcommittext(repo, ctx, subs, extramsg)
2463 2463
2464 2464 # run editor in the repository root
2465 2465 olddir = pycompat.getcwd()
2466 2466 os.chdir(repo.root)
2467 2467
2468 2468 # make in-memory changes visible to external process
2469 2469 tr = repo.currenttransaction()
2470 2470 repo.dirstate.write(tr)
2471 2471 pending = tr and tr.writepending() and repo.root
2472 2472
2473 2473 editortext = repo.ui.edit(committext, ctx.user(), ctx.extra(),
2474 2474 editform=editform, pending=pending,
2475 2475 repopath=repo.path, action='commit')
2476 2476 text = editortext
2477 2477
2478 2478 # strip away anything below this special string (used for editors that want
2479 2479 # to display the diff)
2480 2480 stripbelow = re.search(_linebelow, text, flags=re.MULTILINE)
2481 2481 if stripbelow:
2482 2482 text = text[:stripbelow.start()]
2483 2483
2484 2484 text = re.sub("(?m)^HG:.*(\n|$)", "", text)
2485 2485 os.chdir(olddir)
2486 2486
2487 2487 if finishdesc:
2488 2488 text = finishdesc(text)
2489 2489 if not text.strip():
2490 2490 raise error.Abort(_("empty commit message"))
2491 2491 if unchangedmessagedetection and editortext == templatetext:
2492 2492 raise error.Abort(_("commit message unchanged"))
2493 2493
2494 2494 return text
2495 2495
2496 2496 def buildcommittemplate(repo, ctx, subs, extramsg, ref):
2497 2497 ui = repo.ui
2498 2498 spec = formatter.templatespec(ref, None, None)
2499 2499 t = logcmdutil.changesettemplater(ui, repo, spec)
2500 2500 t.t.cache.update((k, templater.unquotestring(v))
2501 2501 for k, v in repo.ui.configitems('committemplate'))
2502 2502
2503 2503 if not extramsg:
2504 2504 extramsg = '' # ensure that extramsg is string
2505 2505
2506 2506 ui.pushbuffer()
2507 2507 t.show(ctx, extramsg=extramsg)
2508 2508 return ui.popbuffer()
2509 2509
2510 2510 def hgprefix(msg):
2511 2511 return "\n".join(["HG: %s" % a for a in msg.split("\n") if a])
2512 2512
2513 2513 def buildcommittext(repo, ctx, subs, extramsg):
2514 2514 edittext = []
2515 2515 modified, added, removed = ctx.modified(), ctx.added(), ctx.removed()
2516 2516 if ctx.description():
2517 2517 edittext.append(ctx.description())
2518 2518 edittext.append("")
2519 2519 edittext.append("") # Empty line between message and comments.
2520 2520 edittext.append(hgprefix(_("Enter commit message."
2521 2521 " Lines beginning with 'HG:' are removed.")))
2522 2522 edittext.append(hgprefix(extramsg))
2523 2523 edittext.append("HG: --")
2524 2524 edittext.append(hgprefix(_("user: %s") % ctx.user()))
2525 2525 if ctx.p2():
2526 2526 edittext.append(hgprefix(_("branch merge")))
2527 2527 if ctx.branch():
2528 2528 edittext.append(hgprefix(_("branch '%s'") % ctx.branch()))
2529 2529 if bookmarks.isactivewdirparent(repo):
2530 2530 edittext.append(hgprefix(_("bookmark '%s'") % repo._activebookmark))
2531 2531 edittext.extend([hgprefix(_("subrepo %s") % s) for s in subs])
2532 2532 edittext.extend([hgprefix(_("added %s") % f) for f in added])
2533 2533 edittext.extend([hgprefix(_("changed %s") % f) for f in modified])
2534 2534 edittext.extend([hgprefix(_("removed %s") % f) for f in removed])
2535 2535 if not added and not modified and not removed:
2536 2536 edittext.append(hgprefix(_("no files changed")))
2537 2537 edittext.append("")
2538 2538
2539 2539 return "\n".join(edittext)
2540 2540
2541 2541 def commitstatus(repo, node, branch, bheads=None, opts=None):
2542 2542 if opts is None:
2543 2543 opts = {}
2544 2544 ctx = repo[node]
2545 2545 parents = ctx.parents()
2546 2546
2547 2547 if (not opts.get('amend') and bheads and node not in bheads and not
2548 2548 [x for x in parents if x.node() in bheads and x.branch() == branch]):
2549 2549 repo.ui.status(_('created new head\n'))
2550 2550 # The message is not printed for initial roots. For the other
2551 2551 # changesets, it is printed in the following situations:
2552 2552 #
2553 2553 # Par column: for the 2 parents with ...
2554 2554 # N: null or no parent
2555 2555 # B: parent is on another named branch
2556 2556 # C: parent is a regular non head changeset
2557 2557 # H: parent was a branch head of the current branch
2558 2558 # Msg column: whether we print "created new head" message
2559 2559 # In the following, it is assumed that there already exists some
2560 2560 # initial branch heads of the current branch, otherwise nothing is
2561 2561 # printed anyway.
2562 2562 #
2563 2563 # Par Msg Comment
2564 2564 # N N y additional topo root
2565 2565 #
2566 2566 # B N y additional branch root
2567 2567 # C N y additional topo head
2568 2568 # H N n usual case
2569 2569 #
2570 2570 # B B y weird additional branch root
2571 2571 # C B y branch merge
2572 2572 # H B n merge with named branch
2573 2573 #
2574 2574 # C C y additional head from merge
2575 2575 # C H n merge with a head
2576 2576 #
2577 2577 # H H n head merge: head count decreases
2578 2578
2579 2579 if not opts.get('close_branch'):
2580 2580 for r in parents:
2581 2581 if r.closesbranch() and r.branch() == branch:
2582 2582 repo.ui.status(_('reopening closed branch head %d\n') % r)
2583 2583
2584 2584 if repo.ui.debugflag:
2585 2585 repo.ui.write(_('committed changeset %d:%s\n') % (int(ctx), ctx.hex()))
2586 2586 elif repo.ui.verbose:
2587 2587 repo.ui.write(_('committed changeset %d:%s\n') % (int(ctx), ctx))
2588 2588
2589 2589 def postcommitstatus(repo, pats, opts):
2590 2590 return repo.status(match=scmutil.match(repo[None], pats, opts))
2591 2591
2592 2592 def revert(ui, repo, ctx, parents, *pats, **opts):
2593 2593 opts = pycompat.byteskwargs(opts)
2594 2594 parent, p2 = parents
2595 2595 node = ctx.node()
2596 2596
2597 2597 mf = ctx.manifest()
2598 2598 if node == p2:
2599 2599 parent = p2
2600 2600
2601 2601 # need all matching names in dirstate and manifest of target rev,
2602 2602 # so have to walk both. do not print errors if files exist in one
2603 2603 # but not other. in both cases, filesets should be evaluated against
2604 2604 # workingctx to get consistent result (issue4497). this means 'set:**'
2605 2605 # cannot be used to select missing files from target rev.
2606 2606
2607 2607 # `names` is a mapping for all elements in working copy and target revision
2608 2608 # The mapping is in the form:
2609 2609 # <asb path in repo> -> (<path from CWD>, <exactly specified by matcher?>)
2610 2610 names = {}
2611 2611
2612 2612 with repo.wlock():
2613 2613 ## filling of the `names` mapping
2614 2614 # walk dirstate to fill `names`
2615 2615
2616 2616 interactive = opts.get('interactive', False)
2617 2617 wctx = repo[None]
2618 2618 m = scmutil.match(wctx, pats, opts)
2619 2619
2620 2620 # we'll need this later
2621 2621 targetsubs = sorted(s for s in wctx.substate if m(s))
2622 2622
2623 2623 if not m.always():
2624 2624 matcher = matchmod.badmatch(m, lambda x, y: False)
2625 2625 for abs in wctx.walk(matcher):
2626 2626 names[abs] = m.rel(abs), m.exact(abs)
2627 2627
2628 2628 # walk target manifest to fill `names`
2629 2629
2630 2630 def badfn(path, msg):
2631 2631 if path in names:
2632 2632 return
2633 2633 if path in ctx.substate:
2634 2634 return
2635 2635 path_ = path + '/'
2636 2636 for f in names:
2637 2637 if f.startswith(path_):
2638 2638 return
2639 2639 ui.warn("%s: %s\n" % (m.rel(path), msg))
2640 2640
2641 2641 for abs in ctx.walk(matchmod.badmatch(m, badfn)):
2642 2642 if abs not in names:
2643 2643 names[abs] = m.rel(abs), m.exact(abs)
2644 2644
2645 2645 # Find status of all file in `names`.
2646 2646 m = scmutil.matchfiles(repo, names)
2647 2647
2648 2648 changes = repo.status(node1=node, match=m,
2649 2649 unknown=True, ignored=True, clean=True)
2650 2650 else:
2651 2651 changes = repo.status(node1=node, match=m)
2652 2652 for kind in changes:
2653 2653 for abs in kind:
2654 2654 names[abs] = m.rel(abs), m.exact(abs)
2655 2655
2656 2656 m = scmutil.matchfiles(repo, names)
2657 2657
2658 2658 modified = set(changes.modified)
2659 2659 added = set(changes.added)
2660 2660 removed = set(changes.removed)
2661 2661 _deleted = set(changes.deleted)
2662 2662 unknown = set(changes.unknown)
2663 2663 unknown.update(changes.ignored)
2664 2664 clean = set(changes.clean)
2665 2665 modadded = set()
2666 2666
2667 2667 # We need to account for the state of the file in the dirstate,
2668 2668 # even when we revert against something else than parent. This will
2669 2669 # slightly alter the behavior of revert (doing back up or not, delete
2670 2670 # or just forget etc).
2671 2671 if parent == node:
2672 2672 dsmodified = modified
2673 2673 dsadded = added
2674 2674 dsremoved = removed
2675 2675 # store all local modifications, useful later for rename detection
2676 2676 localchanges = dsmodified | dsadded
2677 2677 modified, added, removed = set(), set(), set()
2678 2678 else:
2679 2679 changes = repo.status(node1=parent, match=m)
2680 2680 dsmodified = set(changes.modified)
2681 2681 dsadded = set(changes.added)
2682 2682 dsremoved = set(changes.removed)
2683 2683 # store all local modifications, useful later for rename detection
2684 2684 localchanges = dsmodified | dsadded
2685 2685
2686 2686 # only take into account for removes between wc and target
2687 2687 clean |= dsremoved - removed
2688 2688 dsremoved &= removed
2689 2689 # distinct between dirstate remove and other
2690 2690 removed -= dsremoved
2691 2691
2692 2692 modadded = added & dsmodified
2693 2693 added -= modadded
2694 2694
2695 2695 # tell newly modified apart.
2696 2696 dsmodified &= modified
2697 2697 dsmodified |= modified & dsadded # dirstate added may need backup
2698 2698 modified -= dsmodified
2699 2699
2700 2700 # We need to wait for some post-processing to update this set
2701 2701 # before making the distinction. The dirstate will be used for
2702 2702 # that purpose.
2703 2703 dsadded = added
2704 2704
2705 2705 # in case of merge, files that are actually added can be reported as
2706 2706 # modified, we need to post process the result
2707 2707 if p2 != nullid:
2708 2708 mergeadd = set(dsmodified)
2709 2709 for path in dsmodified:
2710 2710 if path in mf:
2711 2711 mergeadd.remove(path)
2712 2712 dsadded |= mergeadd
2713 2713 dsmodified -= mergeadd
2714 2714
2715 2715 # if f is a rename, update `names` to also revert the source
2716 2716 cwd = repo.getcwd()
2717 2717 for f in localchanges:
2718 2718 src = repo.dirstate.copied(f)
2719 2719 # XXX should we check for rename down to target node?
2720 2720 if src and src not in names and repo.dirstate[src] == 'r':
2721 2721 dsremoved.add(src)
2722 2722 names[src] = (repo.pathto(src, cwd), True)
2723 2723
2724 2724 # determine the exact nature of the deleted changesets
2725 2725 deladded = set(_deleted)
2726 2726 for path in _deleted:
2727 2727 if path in mf:
2728 2728 deladded.remove(path)
2729 2729 deleted = _deleted - deladded
2730 2730
2731 2731 # distinguish between file to forget and the other
2732 2732 added = set()
2733 2733 for abs in dsadded:
2734 2734 if repo.dirstate[abs] != 'a':
2735 2735 added.add(abs)
2736 2736 dsadded -= added
2737 2737
2738 2738 for abs in deladded:
2739 2739 if repo.dirstate[abs] == 'a':
2740 2740 dsadded.add(abs)
2741 2741 deladded -= dsadded
2742 2742
2743 2743 # For files marked as removed, we check if an unknown file is present at
2744 2744 # the same path. If a such file exists it may need to be backed up.
2745 2745 # Making the distinction at this stage helps have simpler backup
2746 2746 # logic.
2747 2747 removunk = set()
2748 2748 for abs in removed:
2749 2749 target = repo.wjoin(abs)
2750 2750 if os.path.lexists(target):
2751 2751 removunk.add(abs)
2752 2752 removed -= removunk
2753 2753
2754 2754 dsremovunk = set()
2755 2755 for abs in dsremoved:
2756 2756 target = repo.wjoin(abs)
2757 2757 if os.path.lexists(target):
2758 2758 dsremovunk.add(abs)
2759 2759 dsremoved -= dsremovunk
2760 2760
2761 2761 # action to be actually performed by revert
2762 2762 # (<list of file>, message>) tuple
2763 2763 actions = {'revert': ([], _('reverting %s\n')),
2764 2764 'add': ([], _('adding %s\n')),
2765 2765 'remove': ([], _('removing %s\n')),
2766 2766 'drop': ([], _('removing %s\n')),
2767 2767 'forget': ([], _('forgetting %s\n')),
2768 2768 'undelete': ([], _('undeleting %s\n')),
2769 2769 'noop': (None, _('no changes needed to %s\n')),
2770 2770 'unknown': (None, _('file not managed: %s\n')),
2771 2771 }
2772 2772
2773 2773 # "constant" that convey the backup strategy.
2774 2774 # All set to `discard` if `no-backup` is set do avoid checking
2775 2775 # no_backup lower in the code.
2776 2776 # These values are ordered for comparison purposes
2777 2777 backupinteractive = 3 # do backup if interactively modified
2778 2778 backup = 2 # unconditionally do backup
2779 2779 check = 1 # check if the existing file differs from target
2780 2780 discard = 0 # never do backup
2781 2781 if opts.get('no_backup'):
2782 2782 backupinteractive = backup = check = discard
2783 2783 if interactive:
2784 2784 dsmodifiedbackup = backupinteractive
2785 2785 else:
2786 2786 dsmodifiedbackup = backup
2787 2787 tobackup = set()
2788 2788
2789 2789 backupanddel = actions['remove']
2790 2790 if not opts.get('no_backup'):
2791 2791 backupanddel = actions['drop']
2792 2792
2793 2793 disptable = (
2794 2794 # dispatch table:
2795 2795 # file state
2796 2796 # action
2797 2797 # make backup
2798 2798
2799 2799 ## Sets that results that will change file on disk
2800 2800 # Modified compared to target, no local change
2801 2801 (modified, actions['revert'], discard),
2802 2802 # Modified compared to target, but local file is deleted
2803 2803 (deleted, actions['revert'], discard),
2804 2804 # Modified compared to target, local change
2805 2805 (dsmodified, actions['revert'], dsmodifiedbackup),
2806 2806 # Added since target
2807 2807 (added, actions['remove'], discard),
2808 2808 # Added in working directory
2809 2809 (dsadded, actions['forget'], discard),
2810 2810 # Added since target, have local modification
2811 2811 (modadded, backupanddel, backup),
2812 2812 # Added since target but file is missing in working directory
2813 2813 (deladded, actions['drop'], discard),
2814 2814 # Removed since target, before working copy parent
2815 2815 (removed, actions['add'], discard),
2816 2816 # Same as `removed` but an unknown file exists at the same path
2817 2817 (removunk, actions['add'], check),
2818 2818 # Removed since targe, marked as such in working copy parent
2819 2819 (dsremoved, actions['undelete'], discard),
2820 2820 # Same as `dsremoved` but an unknown file exists at the same path
2821 2821 (dsremovunk, actions['undelete'], check),
2822 2822 ## the following sets does not result in any file changes
2823 2823 # File with no modification
2824 2824 (clean, actions['noop'], discard),
2825 2825 # Existing file, not tracked anywhere
2826 2826 (unknown, actions['unknown'], discard),
2827 2827 )
2828 2828
2829 2829 for abs, (rel, exact) in sorted(names.items()):
2830 2830 # target file to be touch on disk (relative to cwd)
2831 2831 target = repo.wjoin(abs)
2832 2832 # search the entry in the dispatch table.
2833 2833 # if the file is in any of these sets, it was touched in the working
2834 2834 # directory parent and we are sure it needs to be reverted.
2835 2835 for table, (xlist, msg), dobackup in disptable:
2836 2836 if abs not in table:
2837 2837 continue
2838 2838 if xlist is not None:
2839 2839 xlist.append(abs)
2840 2840 if dobackup:
2841 2841 # If in interactive mode, don't automatically create
2842 2842 # .orig files (issue4793)
2843 2843 if dobackup == backupinteractive:
2844 2844 tobackup.add(abs)
2845 2845 elif (backup <= dobackup or wctx[abs].cmp(ctx[abs])):
2846 2846 bakname = scmutil.origpath(ui, repo, rel)
2847 2847 ui.note(_('saving current version of %s as %s\n') %
2848 2848 (rel, bakname))
2849 2849 if not opts.get('dry_run'):
2850 2850 if interactive:
2851 2851 util.copyfile(target, bakname)
2852 2852 else:
2853 2853 util.rename(target, bakname)
2854 2854 if ui.verbose or not exact:
2855 2855 if not isinstance(msg, bytes):
2856 2856 msg = msg(abs)
2857 2857 ui.status(msg % rel)
2858 2858 elif exact:
2859 2859 ui.warn(msg % rel)
2860 2860 break
2861 2861
2862 2862 if not opts.get('dry_run'):
2863 2863 needdata = ('revert', 'add', 'undelete')
2864 2864 if _revertprefetch is not _revertprefetchstub:
2865 2865 ui.deprecwarn("'cmdutil._revertprefetch' is deprecated, "
2866 2866 "add a callback to 'scmutil.fileprefetchhooks'",
2867 2867 '4.6', stacklevel=1)
2868 2868 _revertprefetch(repo, ctx,
2869 2869 *[actions[name][0] for name in needdata])
2870 2870 oplist = [actions[name][0] for name in needdata]
2871 2871 prefetch = scmutil.fileprefetchhooks
2872 2872 prefetch(repo, ctx, [f for sublist in oplist for f in sublist])
2873 2873 _performrevert(repo, parents, ctx, actions, interactive, tobackup)
2874 2874
2875 2875 if targetsubs:
2876 2876 # Revert the subrepos on the revert list
2877 2877 for sub in targetsubs:
2878 2878 try:
2879 2879 wctx.sub(sub).revert(ctx.substate[sub], *pats,
2880 2880 **pycompat.strkwargs(opts))
2881 2881 except KeyError:
2882 2882 raise error.Abort("subrepository '%s' does not exist in %s!"
2883 2883 % (sub, short(ctx.node())))
2884 2884
2885 2885 def _revertprefetchstub(repo, ctx, *files):
2886 2886 """Stub method for detecting extension wrapping of _revertprefetch(), to
2887 2887 issue a deprecation warning."""
2888 2888
2889 2889 _revertprefetch = _revertprefetchstub
2890 2890
2891 2891 def _performrevert(repo, parents, ctx, actions, interactive=False,
2892 2892 tobackup=None):
2893 2893 """function that actually perform all the actions computed for revert
2894 2894
2895 2895 This is an independent function to let extension to plug in and react to
2896 2896 the imminent revert.
2897 2897
2898 2898 Make sure you have the working directory locked when calling this function.
2899 2899 """
2900 2900 parent, p2 = parents
2901 2901 node = ctx.node()
2902 2902 excluded_files = []
2903 2903
2904 2904 def checkout(f):
2905 2905 fc = ctx[f]
2906 2906 repo.wwrite(f, fc.data(), fc.flags())
2907 2907
2908 2908 def doremove(f):
2909 2909 try:
2910 2910 repo.wvfs.unlinkpath(f)
2911 2911 except OSError:
2912 2912 pass
2913 2913 repo.dirstate.remove(f)
2914 2914
2915 2915 audit_path = pathutil.pathauditor(repo.root, cached=True)
2916 2916 for f in actions['forget'][0]:
2917 2917 if interactive:
2918 2918 choice = repo.ui.promptchoice(
2919 2919 _("forget added file %s (Yn)?$$ &Yes $$ &No") % f)
2920 2920 if choice == 0:
2921 2921 repo.dirstate.drop(f)
2922 2922 else:
2923 2923 excluded_files.append(f)
2924 2924 else:
2925 2925 repo.dirstate.drop(f)
2926 2926 for f in actions['remove'][0]:
2927 2927 audit_path(f)
2928 2928 if interactive:
2929 2929 choice = repo.ui.promptchoice(
2930 2930 _("remove added file %s (Yn)?$$ &Yes $$ &No") % f)
2931 2931 if choice == 0:
2932 2932 doremove(f)
2933 2933 else:
2934 2934 excluded_files.append(f)
2935 2935 else:
2936 2936 doremove(f)
2937 2937 for f in actions['drop'][0]:
2938 2938 audit_path(f)
2939 2939 repo.dirstate.remove(f)
2940 2940
2941 2941 normal = None
2942 2942 if node == parent:
2943 2943 # We're reverting to our parent. If possible, we'd like status
2944 2944 # to report the file as clean. We have to use normallookup for
2945 2945 # merges to avoid losing information about merged/dirty files.
2946 2946 if p2 != nullid:
2947 2947 normal = repo.dirstate.normallookup
2948 2948 else:
2949 2949 normal = repo.dirstate.normal
2950 2950
2951 2951 newlyaddedandmodifiedfiles = set()
2952 2952 if interactive:
2953 2953 # Prompt the user for changes to revert
2954 2954 torevert = [f for f in actions['revert'][0] if f not in excluded_files]
2955 2955 m = scmutil.matchfiles(repo, torevert)
2956 2956 diffopts = patch.difffeatureopts(repo.ui, whitespace=True)
2957 2957 diffopts.nodates = True
2958 2958 diffopts.git = True
2959 2959 operation = 'discard'
2960 2960 reversehunks = True
2961 2961 if node != parent:
2962 2962 operation = 'apply'
2963 2963 reversehunks = False
2964 2964 if reversehunks:
2965 2965 diff = patch.diff(repo, ctx.node(), None, m, opts=diffopts)
2966 2966 else:
2967 2967 diff = patch.diff(repo, None, ctx.node(), m, opts=diffopts)
2968 2968 originalchunks = patch.parsepatch(diff)
2969 2969
2970 2970 try:
2971 2971
2972 2972 chunks, opts = recordfilter(repo.ui, originalchunks,
2973 2973 operation=operation)
2974 2974 if reversehunks:
2975 2975 chunks = patch.reversehunks(chunks)
2976 2976
2977 2977 except error.PatchError as err:
2978 2978 raise error.Abort(_('error parsing patch: %s') % err)
2979 2979
2980 2980 newlyaddedandmodifiedfiles = newandmodified(chunks, originalchunks)
2981 2981 if tobackup is None:
2982 2982 tobackup = set()
2983 2983 # Apply changes
2984 2984 fp = stringio()
2985 2985 for c in chunks:
2986 2986 # Create a backup file only if this hunk should be backed up
2987 2987 if ishunk(c) and c.header.filename() in tobackup:
2988 2988 abs = c.header.filename()
2989 2989 target = repo.wjoin(abs)
2990 2990 bakname = scmutil.origpath(repo.ui, repo, m.rel(abs))
2991 2991 util.copyfile(target, bakname)
2992 2992 tobackup.remove(abs)
2993 2993 c.write(fp)
2994 2994 dopatch = fp.tell()
2995 2995 fp.seek(0)
2996 2996 if dopatch:
2997 2997 try:
2998 2998 patch.internalpatch(repo.ui, repo, fp, 1, eolmode=None)
2999 2999 except error.PatchError as err:
3000 3000 raise error.Abort(str(err))
3001 3001 del fp
3002 3002 else:
3003 3003 for f in actions['revert'][0]:
3004 3004 checkout(f)
3005 3005 if normal:
3006 3006 normal(f)
3007 3007
3008 3008 for f in actions['add'][0]:
3009 3009 # Don't checkout modified files, they are already created by the diff
3010 3010 if f not in newlyaddedandmodifiedfiles:
3011 3011 checkout(f)
3012 3012 repo.dirstate.add(f)
3013 3013
3014 3014 normal = repo.dirstate.normallookup
3015 3015 if node == parent and p2 == nullid:
3016 3016 normal = repo.dirstate.normal
3017 3017 for f in actions['undelete'][0]:
3018 3018 checkout(f)
3019 3019 normal(f)
3020 3020
3021 3021 copied = copies.pathcopies(repo[parent], ctx)
3022 3022
3023 3023 for f in actions['add'][0] + actions['undelete'][0] + actions['revert'][0]:
3024 3024 if f in copied:
3025 3025 repo.dirstate.copy(copied[f], f)
3026 3026
3027 3027 class command(registrar.command):
3028 3028 """deprecated: used registrar.command instead"""
3029 3029 def _doregister(self, func, name, *args, **kwargs):
3030 3030 func._deprecatedregistrar = True # flag for deprecwarn in extensions.py
3031 3031 return super(command, self)._doregister(func, name, *args, **kwargs)
3032 3032
3033 3033 # a list of (ui, repo, otherpeer, opts, missing) functions called by
3034 3034 # commands.outgoing. "missing" is "missing" of the result of
3035 3035 # "findcommonoutgoing()"
3036 3036 outgoinghooks = util.hooks()
3037 3037
3038 3038 # a list of (ui, repo) functions called by commands.summary
3039 3039 summaryhooks = util.hooks()
3040 3040
3041 3041 # a list of (ui, repo, opts, changes) functions called by commands.summary.
3042 3042 #
3043 3043 # functions should return tuple of booleans below, if 'changes' is None:
3044 3044 # (whether-incomings-are-needed, whether-outgoings-are-needed)
3045 3045 #
3046 3046 # otherwise, 'changes' is a tuple of tuples below:
3047 3047 # - (sourceurl, sourcebranch, sourcepeer, incoming)
3048 3048 # - (desturl, destbranch, destpeer, outgoing)
3049 3049 summaryremotehooks = util.hooks()
3050 3050
3051 3051 # A list of state files kept by multistep operations like graft.
3052 3052 # Since graft cannot be aborted, it is considered 'clearable' by update.
3053 3053 # note: bisect is intentionally excluded
3054 3054 # (state file, clearable, allowcommit, error, hint)
3055 3055 unfinishedstates = [
3056 3056 ('graftstate', True, False, _('graft in progress'),
3057 3057 _("use 'hg graft --continue' or 'hg update' to abort")),
3058 3058 ('updatestate', True, False, _('last update was interrupted'),
3059 3059 _("use 'hg update' to get a consistent checkout"))
3060 3060 ]
3061 3061
3062 3062 def checkunfinished(repo, commit=False):
3063 3063 '''Look for an unfinished multistep operation, like graft, and abort
3064 3064 if found. It's probably good to check this right before
3065 3065 bailifchanged().
3066 3066 '''
3067 3067 for f, clearable, allowcommit, msg, hint in unfinishedstates:
3068 3068 if commit and allowcommit:
3069 3069 continue
3070 3070 if repo.vfs.exists(f):
3071 3071 raise error.Abort(msg, hint=hint)
3072 3072
3073 3073 def clearunfinished(repo):
3074 3074 '''Check for unfinished operations (as above), and clear the ones
3075 3075 that are clearable.
3076 3076 '''
3077 3077 for f, clearable, allowcommit, msg, hint in unfinishedstates:
3078 3078 if not clearable and repo.vfs.exists(f):
3079 3079 raise error.Abort(msg, hint=hint)
3080 3080 for f, clearable, allowcommit, msg, hint in unfinishedstates:
3081 3081 if clearable and repo.vfs.exists(f):
3082 3082 util.unlink(repo.vfs.join(f))
3083 3083
3084 3084 afterresolvedstates = [
3085 3085 ('graftstate',
3086 3086 _('hg graft --continue')),
3087 3087 ]
3088 3088
3089 3089 def howtocontinue(repo):
3090 3090 '''Check for an unfinished operation and return the command to finish
3091 3091 it.
3092 3092
3093 3093 afterresolvedstates tuples define a .hg/{file} and the corresponding
3094 3094 command needed to finish it.
3095 3095
3096 3096 Returns a (msg, warning) tuple. 'msg' is a string and 'warning' is
3097 3097 a boolean.
3098 3098 '''
3099 3099 contmsg = _("continue: %s")
3100 3100 for f, msg in afterresolvedstates:
3101 3101 if repo.vfs.exists(f):
3102 3102 return contmsg % msg, True
3103 3103 if repo[None].dirty(missing=True, merge=False, branch=False):
3104 3104 return contmsg % _("hg commit"), False
3105 3105 return None, None
3106 3106
3107 3107 def checkafterresolved(repo):
3108 3108 '''Inform the user about the next action after completing hg resolve
3109 3109
3110 3110 If there's a matching afterresolvedstates, howtocontinue will yield
3111 3111 repo.ui.warn as the reporter.
3112 3112
3113 3113 Otherwise, it will yield repo.ui.note.
3114 3114 '''
3115 3115 msg, warning = howtocontinue(repo)
3116 3116 if msg is not None:
3117 3117 if warning:
3118 3118 repo.ui.warn("%s\n" % msg)
3119 3119 else:
3120 3120 repo.ui.note("%s\n" % msg)
3121 3121
3122 3122 def wrongtooltocontinue(repo, task):
3123 3123 '''Raise an abort suggesting how to properly continue if there is an
3124 3124 active task.
3125 3125
3126 3126 Uses howtocontinue() to find the active task.
3127 3127
3128 3128 If there's no task (repo.ui.note for 'hg commit'), it does not offer
3129 3129 a hint.
3130 3130 '''
3131 3131 after = howtocontinue(repo)
3132 3132 hint = None
3133 3133 if after[1]:
3134 3134 hint = after[0]
3135 3135 raise error.Abort(_('no %s in progress') % task, hint=hint)
3136 3136
3137 3137 class changeset_printer(logcmdutil.changesetprinter):
3138 3138
3139 3139 def __init__(self, ui, *args, **kwargs):
3140 3140 msg = ("'cmdutil.changeset_printer' is deprecated, "
3141 3141 "use 'logcmdutil.logcmdutil'")
3142 3142 ui.deprecwarn(msg, "4.6")
3143 3143 super(changeset_printer, self).__init__(ui, *args, **kwargs)
3144 3144
3145 3145 def displaygraph(ui, *args, **kwargs):
3146 3146 msg = ("'cmdutil.displaygraph' is deprecated, "
3147 3147 "use 'logcmdutil.displaygraph'")
3148 3148 ui.deprecwarn(msg, "4.6")
3149 3149 return logcmdutil.displaygraph(ui, *args, **kwargs)
3150 3150
3151 3151 def show_changeset(ui, *args, **kwargs):
3152 3152 msg = ("'cmdutil.show_changeset' is deprecated, "
3153 3153 "use 'logcmdutil.changesetdisplayer'")
3154 3154 ui.deprecwarn(msg, "4.6")
3155 3155 return logcmdutil.changesetdisplayer(ui, *args, **kwargs)
@@ -1,5607 +1,5607 b''
1 1 # commands.py - command processing for mercurial
2 2 #
3 3 # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
4 4 #
5 5 # This software may be used and distributed according to the terms of the
6 6 # GNU General Public License version 2 or any later version.
7 7
8 8 from __future__ import absolute_import
9 9
10 10 import difflib
11 11 import errno
12 12 import os
13 13 import re
14 14 import sys
15 15
16 16 from .i18n import _
17 17 from .node import (
18 18 hex,
19 19 nullid,
20 20 nullrev,
21 21 short,
22 22 )
23 23 from . import (
24 24 archival,
25 25 bookmarks,
26 26 bundle2,
27 27 changegroup,
28 28 cmdutil,
29 29 copies,
30 30 debugcommands as debugcommandsmod,
31 31 destutil,
32 32 dirstateguard,
33 33 discovery,
34 34 encoding,
35 35 error,
36 36 exchange,
37 37 extensions,
38 38 formatter,
39 39 graphmod,
40 40 hbisect,
41 41 help,
42 42 hg,
43 43 lock as lockmod,
44 44 logcmdutil,
45 45 merge as mergemod,
46 46 obsolete,
47 47 obsutil,
48 48 patch,
49 49 phases,
50 50 pycompat,
51 51 rcutil,
52 52 registrar,
53 53 revsetlang,
54 54 rewriteutil,
55 55 scmutil,
56 56 server,
57 57 streamclone,
58 58 tags as tagsmod,
59 59 templatekw,
60 60 ui as uimod,
61 61 util,
62 62 wireprotoserver,
63 63 )
64 64
65 65 release = lockmod.release
66 66
67 67 table = {}
68 68 table.update(debugcommandsmod.command._table)
69 69
70 70 command = registrar.command(table)
71 71 readonly = registrar.command.readonly
72 72
73 73 # common command options
74 74
75 75 globalopts = [
76 76 ('R', 'repository', '',
77 77 _('repository root directory or name of overlay bundle file'),
78 78 _('REPO')),
79 79 ('', 'cwd', '',
80 80 _('change working directory'), _('DIR')),
81 81 ('y', 'noninteractive', None,
82 82 _('do not prompt, automatically pick the first choice for all prompts')),
83 83 ('q', 'quiet', None, _('suppress output')),
84 84 ('v', 'verbose', None, _('enable additional output')),
85 85 ('', 'color', '',
86 86 # i18n: 'always', 'auto', 'never', and 'debug' are keywords
87 87 # and should not be translated
88 88 _("when to colorize (boolean, always, auto, never, or debug)"),
89 89 _('TYPE')),
90 90 ('', 'config', [],
91 91 _('set/override config option (use \'section.name=value\')'),
92 92 _('CONFIG')),
93 93 ('', 'debug', None, _('enable debugging output')),
94 94 ('', 'debugger', None, _('start debugger')),
95 95 ('', 'encoding', encoding.encoding, _('set the charset encoding'),
96 96 _('ENCODE')),
97 97 ('', 'encodingmode', encoding.encodingmode,
98 98 _('set the charset encoding mode'), _('MODE')),
99 99 ('', 'traceback', None, _('always print a traceback on exception')),
100 100 ('', 'time', None, _('time how long the command takes')),
101 101 ('', 'profile', None, _('print command execution profile')),
102 102 ('', 'version', None, _('output version information and exit')),
103 103 ('h', 'help', None, _('display help and exit')),
104 104 ('', 'hidden', False, _('consider hidden changesets')),
105 105 ('', 'pager', 'auto',
106 106 _("when to paginate (boolean, always, auto, or never)"), _('TYPE')),
107 107 ]
108 108
109 109 dryrunopts = cmdutil.dryrunopts
110 110 remoteopts = cmdutil.remoteopts
111 111 walkopts = cmdutil.walkopts
112 112 commitopts = cmdutil.commitopts
113 113 commitopts2 = cmdutil.commitopts2
114 114 formatteropts = cmdutil.formatteropts
115 115 templateopts = cmdutil.templateopts
116 116 logopts = cmdutil.logopts
117 117 diffopts = cmdutil.diffopts
118 118 diffwsopts = cmdutil.diffwsopts
119 119 diffopts2 = cmdutil.diffopts2
120 120 mergetoolopts = cmdutil.mergetoolopts
121 121 similarityopts = cmdutil.similarityopts
122 122 subrepoopts = cmdutil.subrepoopts
123 123 debugrevlogopts = cmdutil.debugrevlogopts
124 124
125 125 # Commands start here, listed alphabetically
126 126
127 127 @command('^add',
128 128 walkopts + subrepoopts + dryrunopts,
129 129 _('[OPTION]... [FILE]...'),
130 130 inferrepo=True)
131 131 def add(ui, repo, *pats, **opts):
132 132 """add the specified files on the next commit
133 133
134 134 Schedule files to be version controlled and added to the
135 135 repository.
136 136
137 137 The files will be added to the repository at the next commit. To
138 138 undo an add before that, see :hg:`forget`.
139 139
140 140 If no names are given, add all files to the repository (except
141 141 files matching ``.hgignore``).
142 142
143 143 .. container:: verbose
144 144
145 145 Examples:
146 146
147 147 - New (unknown) files are added
148 148 automatically by :hg:`add`::
149 149
150 150 $ ls
151 151 foo.c
152 152 $ hg status
153 153 ? foo.c
154 154 $ hg add
155 155 adding foo.c
156 156 $ hg status
157 157 A foo.c
158 158
159 159 - Specific files to be added can be specified::
160 160
161 161 $ ls
162 162 bar.c foo.c
163 163 $ hg status
164 164 ? bar.c
165 165 ? foo.c
166 166 $ hg add bar.c
167 167 $ hg status
168 168 A bar.c
169 169 ? foo.c
170 170
171 171 Returns 0 if all files are successfully added.
172 172 """
173 173
174 174 m = scmutil.match(repo[None], pats, pycompat.byteskwargs(opts))
175 175 rejected = cmdutil.add(ui, repo, m, "", False, **opts)
176 176 return rejected and 1 or 0
177 177
178 178 @command('addremove',
179 179 similarityopts + subrepoopts + walkopts + dryrunopts,
180 180 _('[OPTION]... [FILE]...'),
181 181 inferrepo=True)
182 182 def addremove(ui, repo, *pats, **opts):
183 183 """add all new files, delete all missing files
184 184
185 185 Add all new files and remove all missing files from the
186 186 repository.
187 187
188 188 Unless names are given, new files are ignored if they match any of
189 189 the patterns in ``.hgignore``. As with add, these changes take
190 190 effect at the next commit.
191 191
192 192 Use the -s/--similarity option to detect renamed files. This
193 193 option takes a percentage between 0 (disabled) and 100 (files must
194 194 be identical) as its parameter. With a parameter greater than 0,
195 195 this compares every removed file with every added file and records
196 196 those similar enough as renames. Detecting renamed files this way
197 197 can be expensive. After using this option, :hg:`status -C` can be
198 198 used to check which files were identified as moved or renamed. If
199 199 not specified, -s/--similarity defaults to 100 and only renames of
200 200 identical files are detected.
201 201
202 202 .. container:: verbose
203 203
204 204 Examples:
205 205
206 206 - A number of files (bar.c and foo.c) are new,
207 207 while foobar.c has been removed (without using :hg:`remove`)
208 208 from the repository::
209 209
210 210 $ ls
211 211 bar.c foo.c
212 212 $ hg status
213 213 ! foobar.c
214 214 ? bar.c
215 215 ? foo.c
216 216 $ hg addremove
217 217 adding bar.c
218 218 adding foo.c
219 219 removing foobar.c
220 220 $ hg status
221 221 A bar.c
222 222 A foo.c
223 223 R foobar.c
224 224
225 225 - A file foobar.c was moved to foo.c without using :hg:`rename`.
226 226 Afterwards, it was edited slightly::
227 227
228 228 $ ls
229 229 foo.c
230 230 $ hg status
231 231 ! foobar.c
232 232 ? foo.c
233 233 $ hg addremove --similarity 90
234 234 removing foobar.c
235 235 adding foo.c
236 236 recording removal of foobar.c as rename to foo.c (94% similar)
237 237 $ hg status -C
238 238 A foo.c
239 239 foobar.c
240 240 R foobar.c
241 241
242 242 Returns 0 if all files are successfully added.
243 243 """
244 244 opts = pycompat.byteskwargs(opts)
245 245 try:
246 246 sim = float(opts.get('similarity') or 100)
247 247 except ValueError:
248 248 raise error.Abort(_('similarity must be a number'))
249 249 if sim < 0 or sim > 100:
250 250 raise error.Abort(_('similarity must be between 0 and 100'))
251 251 matcher = scmutil.match(repo[None], pats, opts)
252 252 return scmutil.addremove(repo, matcher, "", opts, similarity=sim / 100.0)
253 253
254 254 @command('^annotate|blame',
255 255 [('r', 'rev', '', _('annotate the specified revision'), _('REV')),
256 256 ('', 'follow', None,
257 257 _('follow copies/renames and list the filename (DEPRECATED)')),
258 258 ('', 'no-follow', None, _("don't follow copies and renames")),
259 259 ('a', 'text', None, _('treat all files as text')),
260 260 ('u', 'user', None, _('list the author (long with -v)')),
261 261 ('f', 'file', None, _('list the filename')),
262 262 ('d', 'date', None, _('list the date (short with -q)')),
263 263 ('n', 'number', None, _('list the revision number (default)')),
264 264 ('c', 'changeset', None, _('list the changeset')),
265 265 ('l', 'line-number', None, _('show line number at the first appearance')),
266 266 ('', 'skip', [], _('revision to not display (EXPERIMENTAL)'), _('REV')),
267 267 ] + diffwsopts + walkopts + formatteropts,
268 268 _('[-r REV] [-f] [-a] [-u] [-d] [-n] [-c] [-l] FILE...'),
269 269 inferrepo=True)
270 270 def annotate(ui, repo, *pats, **opts):
271 271 """show changeset information by line for each file
272 272
273 273 List changes in files, showing the revision id responsible for
274 274 each line.
275 275
276 276 This command is useful for discovering when a change was made and
277 277 by whom.
278 278
279 279 If you include --file, --user, or --date, the revision number is
280 280 suppressed unless you also include --number.
281 281
282 282 Without the -a/--text option, annotate will avoid processing files
283 283 it detects as binary. With -a, annotate will annotate the file
284 284 anyway, although the results will probably be neither useful
285 285 nor desirable.
286 286
287 287 Returns 0 on success.
288 288 """
289 289 opts = pycompat.byteskwargs(opts)
290 290 if not pats:
291 291 raise error.Abort(_('at least one filename or pattern is required'))
292 292
293 293 if opts.get('follow'):
294 294 # --follow is deprecated and now just an alias for -f/--file
295 295 # to mimic the behavior of Mercurial before version 1.5
296 296 opts['file'] = True
297 297
298 298 rev = opts.get('rev')
299 299 if rev:
300 300 repo = scmutil.unhidehashlikerevs(repo, [rev], 'nowarn')
301 301 ctx = scmutil.revsingle(repo, rev)
302 302
303 303 rootfm = ui.formatter('annotate', opts)
304 304 if ui.quiet:
305 305 datefunc = util.shortdate
306 306 else:
307 307 datefunc = util.datestr
308 308 if ctx.rev() is None:
309 309 def hexfn(node):
310 310 if node is None:
311 311 return None
312 312 else:
313 313 return rootfm.hexfunc(node)
314 314 if opts.get('changeset'):
315 315 # omit "+" suffix which is appended to node hex
316 316 def formatrev(rev):
317 317 if rev is None:
318 318 return '%d' % ctx.p1().rev()
319 319 else:
320 320 return '%d' % rev
321 321 else:
322 322 def formatrev(rev):
323 323 if rev is None:
324 324 return '%d+' % ctx.p1().rev()
325 325 else:
326 326 return '%d ' % rev
327 327 def formathex(hex):
328 328 if hex is None:
329 329 return '%s+' % rootfm.hexfunc(ctx.p1().node())
330 330 else:
331 331 return '%s ' % hex
332 332 else:
333 333 hexfn = rootfm.hexfunc
334 334 formatrev = formathex = pycompat.bytestr
335 335
336 336 opmap = [('user', ' ', lambda x: x.fctx.user(), ui.shortuser),
337 337 ('number', ' ', lambda x: x.fctx.rev(), formatrev),
338 338 ('changeset', ' ', lambda x: hexfn(x.fctx.node()), formathex),
339 339 ('date', ' ', lambda x: x.fctx.date(), util.cachefunc(datefunc)),
340 340 ('file', ' ', lambda x: x.fctx.path(), pycompat.bytestr),
341 341 ('line_number', ':', lambda x: x.lineno, pycompat.bytestr),
342 342 ]
343 343 fieldnamemap = {'number': 'rev', 'changeset': 'node'}
344 344
345 345 if (not opts.get('user') and not opts.get('changeset')
346 346 and not opts.get('date') and not opts.get('file')):
347 347 opts['number'] = True
348 348
349 349 linenumber = opts.get('line_number') is not None
350 350 if linenumber and (not opts.get('changeset')) and (not opts.get('number')):
351 351 raise error.Abort(_('at least one of -n/-c is required for -l'))
352 352
353 353 ui.pager('annotate')
354 354
355 355 if rootfm.isplain():
356 356 def makefunc(get, fmt):
357 357 return lambda x: fmt(get(x))
358 358 else:
359 359 def makefunc(get, fmt):
360 360 return get
361 361 funcmap = [(makefunc(get, fmt), sep) for op, sep, get, fmt in opmap
362 362 if opts.get(op)]
363 363 funcmap[0] = (funcmap[0][0], '') # no separator in front of first column
364 364 fields = ' '.join(fieldnamemap.get(op, op) for op, sep, get, fmt in opmap
365 365 if opts.get(op))
366 366
367 367 def bad(x, y):
368 368 raise error.Abort("%s: %s" % (x, y))
369 369
370 370 m = scmutil.match(ctx, pats, opts, badfn=bad)
371 371
372 372 follow = not opts.get('no_follow')
373 373 diffopts = patch.difffeatureopts(ui, opts, section='annotate',
374 374 whitespace=True)
375 375 skiprevs = opts.get('skip')
376 376 if skiprevs:
377 377 skiprevs = scmutil.revrange(repo, skiprevs)
378 378
379 379 for abs in ctx.walk(m):
380 380 fctx = ctx[abs]
381 381 rootfm.startitem()
382 382 rootfm.data(abspath=abs, path=m.rel(abs))
383 383 if not opts.get('text') and fctx.isbinary():
384 384 rootfm.plain(_("%s: binary file\n")
385 385 % ((pats and m.rel(abs)) or abs))
386 386 continue
387 387
388 388 fm = rootfm.nested('lines')
389 389 lines = fctx.annotate(follow=follow, linenumber=linenumber,
390 390 skiprevs=skiprevs, diffopts=diffopts)
391 391 if not lines:
392 392 fm.end()
393 393 continue
394 394 formats = []
395 395 pieces = []
396 396
397 397 for f, sep in funcmap:
398 398 l = [f(n) for n, dummy in lines]
399 399 if fm.isplain():
400 400 sizes = [encoding.colwidth(x) for x in l]
401 401 ml = max(sizes)
402 402 formats.append([sep + ' ' * (ml - w) + '%s' for w in sizes])
403 403 else:
404 404 formats.append(['%s' for x in l])
405 405 pieces.append(l)
406 406
407 407 for f, p, l in zip(zip(*formats), zip(*pieces), lines):
408 408 fm.startitem()
409 409 fm.write(fields, "".join(f), *p)
410 410 if l[0].skip:
411 411 fmt = "* %s"
412 412 else:
413 413 fmt = ": %s"
414 414 fm.write('line', fmt, l[1])
415 415
416 416 if not lines[-1][1].endswith('\n'):
417 417 fm.plain('\n')
418 418 fm.end()
419 419
420 420 rootfm.end()
421 421
422 422 @command('archive',
423 423 [('', 'no-decode', None, _('do not pass files through decoders')),
424 424 ('p', 'prefix', '', _('directory prefix for files in archive'),
425 425 _('PREFIX')),
426 426 ('r', 'rev', '', _('revision to distribute'), _('REV')),
427 427 ('t', 'type', '', _('type of distribution to create'), _('TYPE')),
428 428 ] + subrepoopts + walkopts,
429 429 _('[OPTION]... DEST'))
430 430 def archive(ui, repo, dest, **opts):
431 431 '''create an unversioned archive of a repository revision
432 432
433 433 By default, the revision used is the parent of the working
434 434 directory; use -r/--rev to specify a different revision.
435 435
436 436 The archive type is automatically detected based on file
437 437 extension (to override, use -t/--type).
438 438
439 439 .. container:: verbose
440 440
441 441 Examples:
442 442
443 443 - create a zip file containing the 1.0 release::
444 444
445 445 hg archive -r 1.0 project-1.0.zip
446 446
447 447 - create a tarball excluding .hg files::
448 448
449 449 hg archive project.tar.gz -X ".hg*"
450 450
451 451 Valid types are:
452 452
453 453 :``files``: a directory full of files (default)
454 454 :``tar``: tar archive, uncompressed
455 455 :``tbz2``: tar archive, compressed using bzip2
456 456 :``tgz``: tar archive, compressed using gzip
457 457 :``uzip``: zip archive, uncompressed
458 458 :``zip``: zip archive, compressed using deflate
459 459
460 460 The exact name of the destination archive or directory is given
461 461 using a format string; see :hg:`help export` for details.
462 462
463 463 Each member added to an archive file has a directory prefix
464 464 prepended. Use -p/--prefix to specify a format string for the
465 465 prefix. The default is the basename of the archive, with suffixes
466 466 removed.
467 467
468 468 Returns 0 on success.
469 469 '''
470 470
471 471 opts = pycompat.byteskwargs(opts)
472 472 rev = opts.get('rev')
473 473 if rev:
474 474 repo = scmutil.unhidehashlikerevs(repo, [rev], 'nowarn')
475 475 ctx = scmutil.revsingle(repo, rev)
476 476 if not ctx:
477 477 raise error.Abort(_('no working directory: please specify a revision'))
478 478 node = ctx.node()
479 479 dest = cmdutil.makefilename(ctx, dest)
480 480 if os.path.realpath(dest) == repo.root:
481 481 raise error.Abort(_('repository root cannot be destination'))
482 482
483 483 kind = opts.get('type') or archival.guesskind(dest) or 'files'
484 484 prefix = opts.get('prefix')
485 485
486 486 if dest == '-':
487 487 if kind == 'files':
488 488 raise error.Abort(_('cannot archive plain files to stdout'))
489 dest = cmdutil.makefileobj(repo, dest, node)
489 dest = cmdutil.makefileobj(ctx, dest)
490 490 if not prefix:
491 491 prefix = os.path.basename(repo.root) + '-%h'
492 492
493 493 prefix = cmdutil.makefilename(ctx, prefix)
494 494 match = scmutil.match(ctx, [], opts)
495 495 archival.archive(repo, dest, node, kind, not opts.get('no_decode'),
496 496 match, prefix, subrepos=opts.get('subrepos'))
497 497
498 498 @command('backout',
499 499 [('', 'merge', None, _('merge with old dirstate parent after backout')),
500 500 ('', 'commit', None,
501 501 _('commit if no conflicts were encountered (DEPRECATED)')),
502 502 ('', 'no-commit', None, _('do not commit')),
503 503 ('', 'parent', '',
504 504 _('parent to choose when backing out merge (DEPRECATED)'), _('REV')),
505 505 ('r', 'rev', '', _('revision to backout'), _('REV')),
506 506 ('e', 'edit', False, _('invoke editor on commit messages')),
507 507 ] + mergetoolopts + walkopts + commitopts + commitopts2,
508 508 _('[OPTION]... [-r] REV'))
509 509 def backout(ui, repo, node=None, rev=None, **opts):
510 510 '''reverse effect of earlier changeset
511 511
512 512 Prepare a new changeset with the effect of REV undone in the
513 513 current working directory. If no conflicts were encountered,
514 514 it will be committed immediately.
515 515
516 516 If REV is the parent of the working directory, then this new changeset
517 517 is committed automatically (unless --no-commit is specified).
518 518
519 519 .. note::
520 520
521 521 :hg:`backout` cannot be used to fix either an unwanted or
522 522 incorrect merge.
523 523
524 524 .. container:: verbose
525 525
526 526 Examples:
527 527
528 528 - Reverse the effect of the parent of the working directory.
529 529 This backout will be committed immediately::
530 530
531 531 hg backout -r .
532 532
533 533 - Reverse the effect of previous bad revision 23::
534 534
535 535 hg backout -r 23
536 536
537 537 - Reverse the effect of previous bad revision 23 and
538 538 leave changes uncommitted::
539 539
540 540 hg backout -r 23 --no-commit
541 541 hg commit -m "Backout revision 23"
542 542
543 543 By default, the pending changeset will have one parent,
544 544 maintaining a linear history. With --merge, the pending
545 545 changeset will instead have two parents: the old parent of the
546 546 working directory and a new child of REV that simply undoes REV.
547 547
548 548 Before version 1.7, the behavior without --merge was equivalent
549 549 to specifying --merge followed by :hg:`update --clean .` to
550 550 cancel the merge and leave the child of REV as a head to be
551 551 merged separately.
552 552
553 553 See :hg:`help dates` for a list of formats valid for -d/--date.
554 554
555 555 See :hg:`help revert` for a way to restore files to the state
556 556 of another revision.
557 557
558 558 Returns 0 on success, 1 if nothing to backout or there are unresolved
559 559 files.
560 560 '''
561 561 wlock = lock = None
562 562 try:
563 563 wlock = repo.wlock()
564 564 lock = repo.lock()
565 565 return _dobackout(ui, repo, node, rev, **opts)
566 566 finally:
567 567 release(lock, wlock)
568 568
569 569 def _dobackout(ui, repo, node=None, rev=None, **opts):
570 570 opts = pycompat.byteskwargs(opts)
571 571 if opts.get('commit') and opts.get('no_commit'):
572 572 raise error.Abort(_("cannot use --commit with --no-commit"))
573 573 if opts.get('merge') and opts.get('no_commit'):
574 574 raise error.Abort(_("cannot use --merge with --no-commit"))
575 575
576 576 if rev and node:
577 577 raise error.Abort(_("please specify just one revision"))
578 578
579 579 if not rev:
580 580 rev = node
581 581
582 582 if not rev:
583 583 raise error.Abort(_("please specify a revision to backout"))
584 584
585 585 date = opts.get('date')
586 586 if date:
587 587 opts['date'] = util.parsedate(date)
588 588
589 589 cmdutil.checkunfinished(repo)
590 590 cmdutil.bailifchanged(repo)
591 591 node = scmutil.revsingle(repo, rev).node()
592 592
593 593 op1, op2 = repo.dirstate.parents()
594 594 if not repo.changelog.isancestor(node, op1):
595 595 raise error.Abort(_('cannot backout change that is not an ancestor'))
596 596
597 597 p1, p2 = repo.changelog.parents(node)
598 598 if p1 == nullid:
599 599 raise error.Abort(_('cannot backout a change with no parents'))
600 600 if p2 != nullid:
601 601 if not opts.get('parent'):
602 602 raise error.Abort(_('cannot backout a merge changeset'))
603 603 p = repo.lookup(opts['parent'])
604 604 if p not in (p1, p2):
605 605 raise error.Abort(_('%s is not a parent of %s') %
606 606 (short(p), short(node)))
607 607 parent = p
608 608 else:
609 609 if opts.get('parent'):
610 610 raise error.Abort(_('cannot use --parent on non-merge changeset'))
611 611 parent = p1
612 612
613 613 # the backout should appear on the same branch
614 614 branch = repo.dirstate.branch()
615 615 bheads = repo.branchheads(branch)
616 616 rctx = scmutil.revsingle(repo, hex(parent))
617 617 if not opts.get('merge') and op1 != node:
618 618 dsguard = dirstateguard.dirstateguard(repo, 'backout')
619 619 try:
620 620 ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
621 621 'backout')
622 622 stats = mergemod.update(repo, parent, True, True, node, False)
623 623 repo.setparents(op1, op2)
624 624 dsguard.close()
625 625 hg._showstats(repo, stats)
626 626 if stats[3]:
627 627 repo.ui.status(_("use 'hg resolve' to retry unresolved "
628 628 "file merges\n"))
629 629 return 1
630 630 finally:
631 631 ui.setconfig('ui', 'forcemerge', '', '')
632 632 lockmod.release(dsguard)
633 633 else:
634 634 hg.clean(repo, node, show_stats=False)
635 635 repo.dirstate.setbranch(branch)
636 636 cmdutil.revert(ui, repo, rctx, repo.dirstate.parents())
637 637
638 638 if opts.get('no_commit'):
639 639 msg = _("changeset %s backed out, "
640 640 "don't forget to commit.\n")
641 641 ui.status(msg % short(node))
642 642 return 0
643 643
644 644 def commitfunc(ui, repo, message, match, opts):
645 645 editform = 'backout'
646 646 e = cmdutil.getcommiteditor(editform=editform,
647 647 **pycompat.strkwargs(opts))
648 648 if not message:
649 649 # we don't translate commit messages
650 650 message = "Backed out changeset %s" % short(node)
651 651 e = cmdutil.getcommiteditor(edit=True, editform=editform)
652 652 return repo.commit(message, opts.get('user'), opts.get('date'),
653 653 match, editor=e)
654 654 newnode = cmdutil.commit(ui, repo, commitfunc, [], opts)
655 655 if not newnode:
656 656 ui.status(_("nothing changed\n"))
657 657 return 1
658 658 cmdutil.commitstatus(repo, newnode, branch, bheads)
659 659
660 660 def nice(node):
661 661 return '%d:%s' % (repo.changelog.rev(node), short(node))
662 662 ui.status(_('changeset %s backs out changeset %s\n') %
663 663 (nice(repo.changelog.tip()), nice(node)))
664 664 if opts.get('merge') and op1 != node:
665 665 hg.clean(repo, op1, show_stats=False)
666 666 ui.status(_('merging with changeset %s\n')
667 667 % nice(repo.changelog.tip()))
668 668 try:
669 669 ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
670 670 'backout')
671 671 return hg.merge(repo, hex(repo.changelog.tip()))
672 672 finally:
673 673 ui.setconfig('ui', 'forcemerge', '', '')
674 674 return 0
675 675
676 676 @command('bisect',
677 677 [('r', 'reset', False, _('reset bisect state')),
678 678 ('g', 'good', False, _('mark changeset good')),
679 679 ('b', 'bad', False, _('mark changeset bad')),
680 680 ('s', 'skip', False, _('skip testing changeset')),
681 681 ('e', 'extend', False, _('extend the bisect range')),
682 682 ('c', 'command', '', _('use command to check changeset state'), _('CMD')),
683 683 ('U', 'noupdate', False, _('do not update to target'))],
684 684 _("[-gbsr] [-U] [-c CMD] [REV]"))
685 685 def bisect(ui, repo, rev=None, extra=None, command=None,
686 686 reset=None, good=None, bad=None, skip=None, extend=None,
687 687 noupdate=None):
688 688 """subdivision search of changesets
689 689
690 690 This command helps to find changesets which introduce problems. To
691 691 use, mark the earliest changeset you know exhibits the problem as
692 692 bad, then mark the latest changeset which is free from the problem
693 693 as good. Bisect will update your working directory to a revision
694 694 for testing (unless the -U/--noupdate option is specified). Once
695 695 you have performed tests, mark the working directory as good or
696 696 bad, and bisect will either update to another candidate changeset
697 697 or announce that it has found the bad revision.
698 698
699 699 As a shortcut, you can also use the revision argument to mark a
700 700 revision as good or bad without checking it out first.
701 701
702 702 If you supply a command, it will be used for automatic bisection.
703 703 The environment variable HG_NODE will contain the ID of the
704 704 changeset being tested. The exit status of the command will be
705 705 used to mark revisions as good or bad: status 0 means good, 125
706 706 means to skip the revision, 127 (command not found) will abort the
707 707 bisection, and any other non-zero exit status means the revision
708 708 is bad.
709 709
710 710 .. container:: verbose
711 711
712 712 Some examples:
713 713
714 714 - start a bisection with known bad revision 34, and good revision 12::
715 715
716 716 hg bisect --bad 34
717 717 hg bisect --good 12
718 718
719 719 - advance the current bisection by marking current revision as good or
720 720 bad::
721 721
722 722 hg bisect --good
723 723 hg bisect --bad
724 724
725 725 - mark the current revision, or a known revision, to be skipped (e.g. if
726 726 that revision is not usable because of another issue)::
727 727
728 728 hg bisect --skip
729 729 hg bisect --skip 23
730 730
731 731 - skip all revisions that do not touch directories ``foo`` or ``bar``::
732 732
733 733 hg bisect --skip "!( file('path:foo') & file('path:bar') )"
734 734
735 735 - forget the current bisection::
736 736
737 737 hg bisect --reset
738 738
739 739 - use 'make && make tests' to automatically find the first broken
740 740 revision::
741 741
742 742 hg bisect --reset
743 743 hg bisect --bad 34
744 744 hg bisect --good 12
745 745 hg bisect --command "make && make tests"
746 746
747 747 - see all changesets whose states are already known in the current
748 748 bisection::
749 749
750 750 hg log -r "bisect(pruned)"
751 751
752 752 - see the changeset currently being bisected (especially useful
753 753 if running with -U/--noupdate)::
754 754
755 755 hg log -r "bisect(current)"
756 756
757 757 - see all changesets that took part in the current bisection::
758 758
759 759 hg log -r "bisect(range)"
760 760
761 761 - you can even get a nice graph::
762 762
763 763 hg log --graph -r "bisect(range)"
764 764
765 765 See :hg:`help revisions.bisect` for more about the `bisect()` predicate.
766 766
767 767 Returns 0 on success.
768 768 """
769 769 # backward compatibility
770 770 if rev in "good bad reset init".split():
771 771 ui.warn(_("(use of 'hg bisect <cmd>' is deprecated)\n"))
772 772 cmd, rev, extra = rev, extra, None
773 773 if cmd == "good":
774 774 good = True
775 775 elif cmd == "bad":
776 776 bad = True
777 777 else:
778 778 reset = True
779 779 elif extra:
780 780 raise error.Abort(_('incompatible arguments'))
781 781
782 782 incompatibles = {
783 783 '--bad': bad,
784 784 '--command': bool(command),
785 785 '--extend': extend,
786 786 '--good': good,
787 787 '--reset': reset,
788 788 '--skip': skip,
789 789 }
790 790
791 791 enabled = [x for x in incompatibles if incompatibles[x]]
792 792
793 793 if len(enabled) > 1:
794 794 raise error.Abort(_('%s and %s are incompatible') %
795 795 tuple(sorted(enabled)[0:2]))
796 796
797 797 if reset:
798 798 hbisect.resetstate(repo)
799 799 return
800 800
801 801 state = hbisect.load_state(repo)
802 802
803 803 # update state
804 804 if good or bad or skip:
805 805 if rev:
806 806 nodes = [repo.lookup(i) for i in scmutil.revrange(repo, [rev])]
807 807 else:
808 808 nodes = [repo.lookup('.')]
809 809 if good:
810 810 state['good'] += nodes
811 811 elif bad:
812 812 state['bad'] += nodes
813 813 elif skip:
814 814 state['skip'] += nodes
815 815 hbisect.save_state(repo, state)
816 816 if not (state['good'] and state['bad']):
817 817 return
818 818
819 819 def mayupdate(repo, node, show_stats=True):
820 820 """common used update sequence"""
821 821 if noupdate:
822 822 return
823 823 cmdutil.checkunfinished(repo)
824 824 cmdutil.bailifchanged(repo)
825 825 return hg.clean(repo, node, show_stats=show_stats)
826 826
827 827 displayer = logcmdutil.changesetdisplayer(ui, repo, {})
828 828
829 829 if command:
830 830 changesets = 1
831 831 if noupdate:
832 832 try:
833 833 node = state['current'][0]
834 834 except LookupError:
835 835 raise error.Abort(_('current bisect revision is unknown - '
836 836 'start a new bisect to fix'))
837 837 else:
838 838 node, p2 = repo.dirstate.parents()
839 839 if p2 != nullid:
840 840 raise error.Abort(_('current bisect revision is a merge'))
841 841 if rev:
842 842 node = repo[scmutil.revsingle(repo, rev, node)].node()
843 843 try:
844 844 while changesets:
845 845 # update state
846 846 state['current'] = [node]
847 847 hbisect.save_state(repo, state)
848 848 status = ui.system(command, environ={'HG_NODE': hex(node)},
849 849 blockedtag='bisect_check')
850 850 if status == 125:
851 851 transition = "skip"
852 852 elif status == 0:
853 853 transition = "good"
854 854 # status < 0 means process was killed
855 855 elif status == 127:
856 856 raise error.Abort(_("failed to execute %s") % command)
857 857 elif status < 0:
858 858 raise error.Abort(_("%s killed") % command)
859 859 else:
860 860 transition = "bad"
861 861 state[transition].append(node)
862 862 ctx = repo[node]
863 863 ui.status(_('changeset %d:%s: %s\n') % (ctx, ctx, transition))
864 864 hbisect.checkstate(state)
865 865 # bisect
866 866 nodes, changesets, bgood = hbisect.bisect(repo, state)
867 867 # update to next check
868 868 node = nodes[0]
869 869 mayupdate(repo, node, show_stats=False)
870 870 finally:
871 871 state['current'] = [node]
872 872 hbisect.save_state(repo, state)
873 873 hbisect.printresult(ui, repo, state, displayer, nodes, bgood)
874 874 return
875 875
876 876 hbisect.checkstate(state)
877 877
878 878 # actually bisect
879 879 nodes, changesets, good = hbisect.bisect(repo, state)
880 880 if extend:
881 881 if not changesets:
882 882 extendnode = hbisect.extendrange(repo, state, nodes, good)
883 883 if extendnode is not None:
884 884 ui.write(_("Extending search to changeset %d:%s\n")
885 885 % (extendnode.rev(), extendnode))
886 886 state['current'] = [extendnode.node()]
887 887 hbisect.save_state(repo, state)
888 888 return mayupdate(repo, extendnode.node())
889 889 raise error.Abort(_("nothing to extend"))
890 890
891 891 if changesets == 0:
892 892 hbisect.printresult(ui, repo, state, displayer, nodes, good)
893 893 else:
894 894 assert len(nodes) == 1 # only a single node can be tested next
895 895 node = nodes[0]
896 896 # compute the approximate number of remaining tests
897 897 tests, size = 0, 2
898 898 while size <= changesets:
899 899 tests, size = tests + 1, size * 2
900 900 rev = repo.changelog.rev(node)
901 901 ui.write(_("Testing changeset %d:%s "
902 902 "(%d changesets remaining, ~%d tests)\n")
903 903 % (rev, short(node), changesets, tests))
904 904 state['current'] = [node]
905 905 hbisect.save_state(repo, state)
906 906 return mayupdate(repo, node)
907 907
908 908 @command('bookmarks|bookmark',
909 909 [('f', 'force', False, _('force')),
910 910 ('r', 'rev', '', _('revision for bookmark action'), _('REV')),
911 911 ('d', 'delete', False, _('delete a given bookmark')),
912 912 ('m', 'rename', '', _('rename a given bookmark'), _('OLD')),
913 913 ('i', 'inactive', False, _('mark a bookmark inactive')),
914 914 ] + formatteropts,
915 915 _('hg bookmarks [OPTIONS]... [NAME]...'))
916 916 def bookmark(ui, repo, *names, **opts):
917 917 '''create a new bookmark or list existing bookmarks
918 918
919 919 Bookmarks are labels on changesets to help track lines of development.
920 920 Bookmarks are unversioned and can be moved, renamed and deleted.
921 921 Deleting or moving a bookmark has no effect on the associated changesets.
922 922
923 923 Creating or updating to a bookmark causes it to be marked as 'active'.
924 924 The active bookmark is indicated with a '*'.
925 925 When a commit is made, the active bookmark will advance to the new commit.
926 926 A plain :hg:`update` will also advance an active bookmark, if possible.
927 927 Updating away from a bookmark will cause it to be deactivated.
928 928
929 929 Bookmarks can be pushed and pulled between repositories (see
930 930 :hg:`help push` and :hg:`help pull`). If a shared bookmark has
931 931 diverged, a new 'divergent bookmark' of the form 'name@path' will
932 932 be created. Using :hg:`merge` will resolve the divergence.
933 933
934 934 Specifying bookmark as '.' to -m or -d options is equivalent to specifying
935 935 the active bookmark's name.
936 936
937 937 A bookmark named '@' has the special property that :hg:`clone` will
938 938 check it out by default if it exists.
939 939
940 940 .. container:: verbose
941 941
942 942 Examples:
943 943
944 944 - create an active bookmark for a new line of development::
945 945
946 946 hg book new-feature
947 947
948 948 - create an inactive bookmark as a place marker::
949 949
950 950 hg book -i reviewed
951 951
952 952 - create an inactive bookmark on another changeset::
953 953
954 954 hg book -r .^ tested
955 955
956 956 - rename bookmark turkey to dinner::
957 957
958 958 hg book -m turkey dinner
959 959
960 960 - move the '@' bookmark from another branch::
961 961
962 962 hg book -f @
963 963 '''
964 964 force = opts.get(r'force')
965 965 rev = opts.get(r'rev')
966 966 delete = opts.get(r'delete')
967 967 rename = opts.get(r'rename')
968 968 inactive = opts.get(r'inactive')
969 969
970 970 if delete and rename:
971 971 raise error.Abort(_("--delete and --rename are incompatible"))
972 972 if delete and rev:
973 973 raise error.Abort(_("--rev is incompatible with --delete"))
974 974 if rename and rev:
975 975 raise error.Abort(_("--rev is incompatible with --rename"))
976 976 if not names and (delete or rev):
977 977 raise error.Abort(_("bookmark name required"))
978 978
979 979 if delete or rename or names or inactive:
980 980 with repo.wlock(), repo.lock(), repo.transaction('bookmark') as tr:
981 981 if delete:
982 982 names = pycompat.maplist(repo._bookmarks.expandname, names)
983 983 bookmarks.delete(repo, tr, names)
984 984 elif rename:
985 985 if not names:
986 986 raise error.Abort(_("new bookmark name required"))
987 987 elif len(names) > 1:
988 988 raise error.Abort(_("only one new bookmark name allowed"))
989 989 rename = repo._bookmarks.expandname(rename)
990 990 bookmarks.rename(repo, tr, rename, names[0], force, inactive)
991 991 elif names:
992 992 bookmarks.addbookmarks(repo, tr, names, rev, force, inactive)
993 993 elif inactive:
994 994 if len(repo._bookmarks) == 0:
995 995 ui.status(_("no bookmarks set\n"))
996 996 elif not repo._activebookmark:
997 997 ui.status(_("no active bookmark\n"))
998 998 else:
999 999 bookmarks.deactivate(repo)
1000 1000 else: # show bookmarks
1001 1001 bookmarks.printbookmarks(ui, repo, **opts)
1002 1002
1003 1003 @command('branch',
1004 1004 [('f', 'force', None,
1005 1005 _('set branch name even if it shadows an existing branch')),
1006 1006 ('C', 'clean', None, _('reset branch name to parent branch name')),
1007 1007 ('r', 'rev', [], _('change branches of the given revs (EXPERIMENTAL)')),
1008 1008 ],
1009 1009 _('[-fC] [NAME]'))
1010 1010 def branch(ui, repo, label=None, **opts):
1011 1011 """set or show the current branch name
1012 1012
1013 1013 .. note::
1014 1014
1015 1015 Branch names are permanent and global. Use :hg:`bookmark` to create a
1016 1016 light-weight bookmark instead. See :hg:`help glossary` for more
1017 1017 information about named branches and bookmarks.
1018 1018
1019 1019 With no argument, show the current branch name. With one argument,
1020 1020 set the working directory branch name (the branch will not exist
1021 1021 in the repository until the next commit). Standard practice
1022 1022 recommends that primary development take place on the 'default'
1023 1023 branch.
1024 1024
1025 1025 Unless -f/--force is specified, branch will not let you set a
1026 1026 branch name that already exists.
1027 1027
1028 1028 Use -C/--clean to reset the working directory branch to that of
1029 1029 the parent of the working directory, negating a previous branch
1030 1030 change.
1031 1031
1032 1032 Use the command :hg:`update` to switch to an existing branch. Use
1033 1033 :hg:`commit --close-branch` to mark this branch head as closed.
1034 1034 When all heads of a branch are closed, the branch will be
1035 1035 considered closed.
1036 1036
1037 1037 Returns 0 on success.
1038 1038 """
1039 1039 opts = pycompat.byteskwargs(opts)
1040 1040 revs = opts.get('rev')
1041 1041 if label:
1042 1042 label = label.strip()
1043 1043
1044 1044 if not opts.get('clean') and not label:
1045 1045 if revs:
1046 1046 raise error.Abort(_("no branch name specified for the revisions"))
1047 1047 ui.write("%s\n" % repo.dirstate.branch())
1048 1048 return
1049 1049
1050 1050 with repo.wlock():
1051 1051 if opts.get('clean'):
1052 1052 label = repo[None].p1().branch()
1053 1053 repo.dirstate.setbranch(label)
1054 1054 ui.status(_('reset working directory to branch %s\n') % label)
1055 1055 elif label:
1056 1056
1057 1057 scmutil.checknewlabel(repo, label, 'branch')
1058 1058 if revs:
1059 1059 return cmdutil.changebranch(ui, repo, revs, label)
1060 1060
1061 1061 if not opts.get('force') and label in repo.branchmap():
1062 1062 if label not in [p.branch() for p in repo[None].parents()]:
1063 1063 raise error.Abort(_('a branch of the same name already'
1064 1064 ' exists'),
1065 1065 # i18n: "it" refers to an existing branch
1066 1066 hint=_("use 'hg update' to switch to it"))
1067 1067
1068 1068 repo.dirstate.setbranch(label)
1069 1069 ui.status(_('marked working directory as branch %s\n') % label)
1070 1070
1071 1071 # find any open named branches aside from default
1072 1072 others = [n for n, h, t, c in repo.branchmap().iterbranches()
1073 1073 if n != "default" and not c]
1074 1074 if not others:
1075 1075 ui.status(_('(branches are permanent and global, '
1076 1076 'did you want a bookmark?)\n'))
1077 1077
1078 1078 @command('branches',
1079 1079 [('a', 'active', False,
1080 1080 _('show only branches that have unmerged heads (DEPRECATED)')),
1081 1081 ('c', 'closed', False, _('show normal and closed branches')),
1082 1082 ] + formatteropts,
1083 1083 _('[-c]'), cmdtype=readonly)
1084 1084 def branches(ui, repo, active=False, closed=False, **opts):
1085 1085 """list repository named branches
1086 1086
1087 1087 List the repository's named branches, indicating which ones are
1088 1088 inactive. If -c/--closed is specified, also list branches which have
1089 1089 been marked closed (see :hg:`commit --close-branch`).
1090 1090
1091 1091 Use the command :hg:`update` to switch to an existing branch.
1092 1092
1093 1093 Returns 0.
1094 1094 """
1095 1095
1096 1096 opts = pycompat.byteskwargs(opts)
1097 1097 ui.pager('branches')
1098 1098 fm = ui.formatter('branches', opts)
1099 1099 hexfunc = fm.hexfunc
1100 1100
1101 1101 allheads = set(repo.heads())
1102 1102 branches = []
1103 1103 for tag, heads, tip, isclosed in repo.branchmap().iterbranches():
1104 1104 isactive = False
1105 1105 if not isclosed:
1106 1106 openheads = set(repo.branchmap().iteropen(heads))
1107 1107 isactive = bool(openheads & allheads)
1108 1108 branches.append((tag, repo[tip], isactive, not isclosed))
1109 1109 branches.sort(key=lambda i: (i[2], i[1].rev(), i[0], i[3]),
1110 1110 reverse=True)
1111 1111
1112 1112 for tag, ctx, isactive, isopen in branches:
1113 1113 if active and not isactive:
1114 1114 continue
1115 1115 if isactive:
1116 1116 label = 'branches.active'
1117 1117 notice = ''
1118 1118 elif not isopen:
1119 1119 if not closed:
1120 1120 continue
1121 1121 label = 'branches.closed'
1122 1122 notice = _(' (closed)')
1123 1123 else:
1124 1124 label = 'branches.inactive'
1125 1125 notice = _(' (inactive)')
1126 1126 current = (tag == repo.dirstate.branch())
1127 1127 if current:
1128 1128 label = 'branches.current'
1129 1129
1130 1130 fm.startitem()
1131 1131 fm.write('branch', '%s', tag, label=label)
1132 1132 rev = ctx.rev()
1133 1133 padsize = max(31 - len(str(rev)) - encoding.colwidth(tag), 0)
1134 1134 fmt = ' ' * padsize + ' %d:%s'
1135 1135 fm.condwrite(not ui.quiet, 'rev node', fmt, rev, hexfunc(ctx.node()),
1136 1136 label='log.changeset changeset.%s' % ctx.phasestr())
1137 1137 fm.context(ctx=ctx)
1138 1138 fm.data(active=isactive, closed=not isopen, current=current)
1139 1139 if not ui.quiet:
1140 1140 fm.plain(notice)
1141 1141 fm.plain('\n')
1142 1142 fm.end()
1143 1143
1144 1144 @command('bundle',
1145 1145 [('f', 'force', None, _('run even when the destination is unrelated')),
1146 1146 ('r', 'rev', [], _('a changeset intended to be added to the destination'),
1147 1147 _('REV')),
1148 1148 ('b', 'branch', [], _('a specific branch you would like to bundle'),
1149 1149 _('BRANCH')),
1150 1150 ('', 'base', [],
1151 1151 _('a base changeset assumed to be available at the destination'),
1152 1152 _('REV')),
1153 1153 ('a', 'all', None, _('bundle all changesets in the repository')),
1154 1154 ('t', 'type', 'bzip2', _('bundle compression type to use'), _('TYPE')),
1155 1155 ] + remoteopts,
1156 1156 _('[-f] [-t BUNDLESPEC] [-a] [-r REV]... [--base REV]... FILE [DEST]'))
1157 1157 def bundle(ui, repo, fname, dest=None, **opts):
1158 1158 """create a bundle file
1159 1159
1160 1160 Generate a bundle file containing data to be added to a repository.
1161 1161
1162 1162 To create a bundle containing all changesets, use -a/--all
1163 1163 (or --base null). Otherwise, hg assumes the destination will have
1164 1164 all the nodes you specify with --base parameters. Otherwise, hg
1165 1165 will assume the repository has all the nodes in destination, or
1166 1166 default-push/default if no destination is specified.
1167 1167
1168 1168 You can change bundle format with the -t/--type option. See
1169 1169 :hg:`help bundlespec` for documentation on this format. By default,
1170 1170 the most appropriate format is used and compression defaults to
1171 1171 bzip2.
1172 1172
1173 1173 The bundle file can then be transferred using conventional means
1174 1174 and applied to another repository with the unbundle or pull
1175 1175 command. This is useful when direct push and pull are not
1176 1176 available or when exporting an entire repository is undesirable.
1177 1177
1178 1178 Applying bundles preserves all changeset contents including
1179 1179 permissions, copy/rename information, and revision history.
1180 1180
1181 1181 Returns 0 on success, 1 if no changes found.
1182 1182 """
1183 1183 opts = pycompat.byteskwargs(opts)
1184 1184 revs = None
1185 1185 if 'rev' in opts:
1186 1186 revstrings = opts['rev']
1187 1187 revs = scmutil.revrange(repo, revstrings)
1188 1188 if revstrings and not revs:
1189 1189 raise error.Abort(_('no commits to bundle'))
1190 1190
1191 1191 bundletype = opts.get('type', 'bzip2').lower()
1192 1192 try:
1193 1193 bcompression, cgversion, params = exchange.parsebundlespec(
1194 1194 repo, bundletype, strict=False)
1195 1195 except error.UnsupportedBundleSpecification as e:
1196 1196 raise error.Abort(str(e),
1197 1197 hint=_("see 'hg help bundlespec' for supported "
1198 1198 "values for --type"))
1199 1199
1200 1200 # Packed bundles are a pseudo bundle format for now.
1201 1201 if cgversion == 's1':
1202 1202 raise error.Abort(_('packed bundles cannot be produced by "hg bundle"'),
1203 1203 hint=_("use 'hg debugcreatestreamclonebundle'"))
1204 1204
1205 1205 if opts.get('all'):
1206 1206 if dest:
1207 1207 raise error.Abort(_("--all is incompatible with specifying "
1208 1208 "a destination"))
1209 1209 if opts.get('base'):
1210 1210 ui.warn(_("ignoring --base because --all was specified\n"))
1211 1211 base = ['null']
1212 1212 else:
1213 1213 base = scmutil.revrange(repo, opts.get('base'))
1214 1214 if cgversion not in changegroup.supportedoutgoingversions(repo):
1215 1215 raise error.Abort(_("repository does not support bundle version %s") %
1216 1216 cgversion)
1217 1217
1218 1218 if base:
1219 1219 if dest:
1220 1220 raise error.Abort(_("--base is incompatible with specifying "
1221 1221 "a destination"))
1222 1222 common = [repo.lookup(rev) for rev in base]
1223 1223 heads = [repo.lookup(r) for r in revs] if revs else None
1224 1224 outgoing = discovery.outgoing(repo, common, heads)
1225 1225 else:
1226 1226 dest = ui.expandpath(dest or 'default-push', dest or 'default')
1227 1227 dest, branches = hg.parseurl(dest, opts.get('branch'))
1228 1228 other = hg.peer(repo, opts, dest)
1229 1229 revs, checkout = hg.addbranchrevs(repo, repo, branches, revs)
1230 1230 heads = revs and map(repo.lookup, revs) or revs
1231 1231 outgoing = discovery.findcommonoutgoing(repo, other,
1232 1232 onlyheads=heads,
1233 1233 force=opts.get('force'),
1234 1234 portable=True)
1235 1235
1236 1236 if not outgoing.missing:
1237 1237 scmutil.nochangesfound(ui, repo, not base and outgoing.excluded)
1238 1238 return 1
1239 1239
1240 1240 if cgversion == '01': #bundle1
1241 1241 if bcompression is None:
1242 1242 bcompression = 'UN'
1243 1243 bversion = 'HG10' + bcompression
1244 1244 bcompression = None
1245 1245 elif cgversion in ('02', '03'):
1246 1246 bversion = 'HG20'
1247 1247 else:
1248 1248 raise error.ProgrammingError(
1249 1249 'bundle: unexpected changegroup version %s' % cgversion)
1250 1250
1251 1251 # TODO compression options should be derived from bundlespec parsing.
1252 1252 # This is a temporary hack to allow adjusting bundle compression
1253 1253 # level without a) formalizing the bundlespec changes to declare it
1254 1254 # b) introducing a command flag.
1255 1255 compopts = {}
1256 1256 complevel = ui.configint('experimental', 'bundlecomplevel')
1257 1257 if complevel is not None:
1258 1258 compopts['level'] = complevel
1259 1259
1260 1260
1261 1261 contentopts = {'cg.version': cgversion}
1262 1262 if repo.ui.configbool('experimental', 'evolution.bundle-obsmarker'):
1263 1263 contentopts['obsolescence'] = True
1264 1264 if repo.ui.configbool('experimental', 'bundle-phases'):
1265 1265 contentopts['phases'] = True
1266 1266 bundle2.writenewbundle(ui, repo, 'bundle', fname, bversion, outgoing,
1267 1267 contentopts, compression=bcompression,
1268 1268 compopts=compopts)
1269 1269
1270 1270 @command('cat',
1271 1271 [('o', 'output', '',
1272 1272 _('print output to file with formatted name'), _('FORMAT')),
1273 1273 ('r', 'rev', '', _('print the given revision'), _('REV')),
1274 1274 ('', 'decode', None, _('apply any matching decode filter')),
1275 1275 ] + walkopts + formatteropts,
1276 1276 _('[OPTION]... FILE...'),
1277 1277 inferrepo=True, cmdtype=readonly)
1278 1278 def cat(ui, repo, file1, *pats, **opts):
1279 1279 """output the current or given revision of files
1280 1280
1281 1281 Print the specified files as they were at the given revision. If
1282 1282 no revision is given, the parent of the working directory is used.
1283 1283
1284 1284 Output may be to a file, in which case the name of the file is
1285 1285 given using a format string. The formatting rules as follows:
1286 1286
1287 1287 :``%%``: literal "%" character
1288 1288 :``%s``: basename of file being printed
1289 1289 :``%d``: dirname of file being printed, or '.' if in repository root
1290 1290 :``%p``: root-relative path name of file being printed
1291 1291 :``%H``: changeset hash (40 hexadecimal digits)
1292 1292 :``%R``: changeset revision number
1293 1293 :``%h``: short-form changeset hash (12 hexadecimal digits)
1294 1294 :``%r``: zero-padded changeset revision number
1295 1295 :``%b``: basename of the exporting repository
1296 1296
1297 1297 Returns 0 on success.
1298 1298 """
1299 1299 opts = pycompat.byteskwargs(opts)
1300 1300 rev = opts.get('rev')
1301 1301 if rev:
1302 1302 repo = scmutil.unhidehashlikerevs(repo, [rev], 'nowarn')
1303 1303 ctx = scmutil.revsingle(repo, rev)
1304 1304 m = scmutil.match(ctx, (file1,) + pats, opts)
1305 1305 fntemplate = opts.pop('output', '')
1306 1306 if cmdutil.isstdiofilename(fntemplate):
1307 1307 fntemplate = ''
1308 1308
1309 1309 if fntemplate:
1310 1310 fm = formatter.nullformatter(ui, 'cat')
1311 1311 else:
1312 1312 ui.pager('cat')
1313 1313 fm = ui.formatter('cat', opts)
1314 1314 with fm:
1315 1315 return cmdutil.cat(ui, repo, ctx, m, fm, fntemplate, '',
1316 1316 **pycompat.strkwargs(opts))
1317 1317
1318 1318 @command('^clone',
1319 1319 [('U', 'noupdate', None, _('the clone will include an empty working '
1320 1320 'directory (only a repository)')),
1321 1321 ('u', 'updaterev', '', _('revision, tag, or branch to check out'),
1322 1322 _('REV')),
1323 1323 ('r', 'rev', [], _('include the specified changeset'), _('REV')),
1324 1324 ('b', 'branch', [], _('clone only the specified branch'), _('BRANCH')),
1325 1325 ('', 'pull', None, _('use pull protocol to copy metadata')),
1326 1326 ('', 'uncompressed', None,
1327 1327 _('an alias to --stream (DEPRECATED)')),
1328 1328 ('', 'stream', None,
1329 1329 _('clone with minimal data processing')),
1330 1330 ] + remoteopts,
1331 1331 _('[OPTION]... SOURCE [DEST]'),
1332 1332 norepo=True)
1333 1333 def clone(ui, source, dest=None, **opts):
1334 1334 """make a copy of an existing repository
1335 1335
1336 1336 Create a copy of an existing repository in a new directory.
1337 1337
1338 1338 If no destination directory name is specified, it defaults to the
1339 1339 basename of the source.
1340 1340
1341 1341 The location of the source is added to the new repository's
1342 1342 ``.hg/hgrc`` file, as the default to be used for future pulls.
1343 1343
1344 1344 Only local paths and ``ssh://`` URLs are supported as
1345 1345 destinations. For ``ssh://`` destinations, no working directory or
1346 1346 ``.hg/hgrc`` will be created on the remote side.
1347 1347
1348 1348 If the source repository has a bookmark called '@' set, that
1349 1349 revision will be checked out in the new repository by default.
1350 1350
1351 1351 To check out a particular version, use -u/--update, or
1352 1352 -U/--noupdate to create a clone with no working directory.
1353 1353
1354 1354 To pull only a subset of changesets, specify one or more revisions
1355 1355 identifiers with -r/--rev or branches with -b/--branch. The
1356 1356 resulting clone will contain only the specified changesets and
1357 1357 their ancestors. These options (or 'clone src#rev dest') imply
1358 1358 --pull, even for local source repositories.
1359 1359
1360 1360 In normal clone mode, the remote normalizes repository data into a common
1361 1361 exchange format and the receiving end translates this data into its local
1362 1362 storage format. --stream activates a different clone mode that essentially
1363 1363 copies repository files from the remote with minimal data processing. This
1364 1364 significantly reduces the CPU cost of a clone both remotely and locally.
1365 1365 However, it often increases the transferred data size by 30-40%. This can
1366 1366 result in substantially faster clones where I/O throughput is plentiful,
1367 1367 especially for larger repositories. A side-effect of --stream clones is
1368 1368 that storage settings and requirements on the remote are applied locally:
1369 1369 a modern client may inherit legacy or inefficient storage used by the
1370 1370 remote or a legacy Mercurial client may not be able to clone from a
1371 1371 modern Mercurial remote.
1372 1372
1373 1373 .. note::
1374 1374
1375 1375 Specifying a tag will include the tagged changeset but not the
1376 1376 changeset containing the tag.
1377 1377
1378 1378 .. container:: verbose
1379 1379
1380 1380 For efficiency, hardlinks are used for cloning whenever the
1381 1381 source and destination are on the same filesystem (note this
1382 1382 applies only to the repository data, not to the working
1383 1383 directory). Some filesystems, such as AFS, implement hardlinking
1384 1384 incorrectly, but do not report errors. In these cases, use the
1385 1385 --pull option to avoid hardlinking.
1386 1386
1387 1387 Mercurial will update the working directory to the first applicable
1388 1388 revision from this list:
1389 1389
1390 1390 a) null if -U or the source repository has no changesets
1391 1391 b) if -u . and the source repository is local, the first parent of
1392 1392 the source repository's working directory
1393 1393 c) the changeset specified with -u (if a branch name, this means the
1394 1394 latest head of that branch)
1395 1395 d) the changeset specified with -r
1396 1396 e) the tipmost head specified with -b
1397 1397 f) the tipmost head specified with the url#branch source syntax
1398 1398 g) the revision marked with the '@' bookmark, if present
1399 1399 h) the tipmost head of the default branch
1400 1400 i) tip
1401 1401
1402 1402 When cloning from servers that support it, Mercurial may fetch
1403 1403 pre-generated data from a server-advertised URL. When this is done,
1404 1404 hooks operating on incoming changesets and changegroups may fire twice,
1405 1405 once for the bundle fetched from the URL and another for any additional
1406 1406 data not fetched from this URL. In addition, if an error occurs, the
1407 1407 repository may be rolled back to a partial clone. This behavior may
1408 1408 change in future releases. See :hg:`help -e clonebundles` for more.
1409 1409
1410 1410 Examples:
1411 1411
1412 1412 - clone a remote repository to a new directory named hg/::
1413 1413
1414 1414 hg clone https://www.mercurial-scm.org/repo/hg/
1415 1415
1416 1416 - create a lightweight local clone::
1417 1417
1418 1418 hg clone project/ project-feature/
1419 1419
1420 1420 - clone from an absolute path on an ssh server (note double-slash)::
1421 1421
1422 1422 hg clone ssh://user@server//home/projects/alpha/
1423 1423
1424 1424 - do a streaming clone while checking out a specified version::
1425 1425
1426 1426 hg clone --stream http://server/repo -u 1.5
1427 1427
1428 1428 - create a repository without changesets after a particular revision::
1429 1429
1430 1430 hg clone -r 04e544 experimental/ good/
1431 1431
1432 1432 - clone (and track) a particular named branch::
1433 1433
1434 1434 hg clone https://www.mercurial-scm.org/repo/hg/#stable
1435 1435
1436 1436 See :hg:`help urls` for details on specifying URLs.
1437 1437
1438 1438 Returns 0 on success.
1439 1439 """
1440 1440 opts = pycompat.byteskwargs(opts)
1441 1441 if opts.get('noupdate') and opts.get('updaterev'):
1442 1442 raise error.Abort(_("cannot specify both --noupdate and --updaterev"))
1443 1443
1444 1444 r = hg.clone(ui, opts, source, dest,
1445 1445 pull=opts.get('pull'),
1446 1446 stream=opts.get('stream') or opts.get('uncompressed'),
1447 1447 rev=opts.get('rev'),
1448 1448 update=opts.get('updaterev') or not opts.get('noupdate'),
1449 1449 branch=opts.get('branch'),
1450 1450 shareopts=opts.get('shareopts'))
1451 1451
1452 1452 return r is None
1453 1453
1454 1454 @command('^commit|ci',
1455 1455 [('A', 'addremove', None,
1456 1456 _('mark new/missing files as added/removed before committing')),
1457 1457 ('', 'close-branch', None,
1458 1458 _('mark a branch head as closed')),
1459 1459 ('', 'amend', None, _('amend the parent of the working directory')),
1460 1460 ('s', 'secret', None, _('use the secret phase for committing')),
1461 1461 ('e', 'edit', None, _('invoke editor on commit messages')),
1462 1462 ('i', 'interactive', None, _('use interactive mode')),
1463 1463 ] + walkopts + commitopts + commitopts2 + subrepoopts,
1464 1464 _('[OPTION]... [FILE]...'),
1465 1465 inferrepo=True)
1466 1466 def commit(ui, repo, *pats, **opts):
1467 1467 """commit the specified files or all outstanding changes
1468 1468
1469 1469 Commit changes to the given files into the repository. Unlike a
1470 1470 centralized SCM, this operation is a local operation. See
1471 1471 :hg:`push` for a way to actively distribute your changes.
1472 1472
1473 1473 If a list of files is omitted, all changes reported by :hg:`status`
1474 1474 will be committed.
1475 1475
1476 1476 If you are committing the result of a merge, do not provide any
1477 1477 filenames or -I/-X filters.
1478 1478
1479 1479 If no commit message is specified, Mercurial starts your
1480 1480 configured editor where you can enter a message. In case your
1481 1481 commit fails, you will find a backup of your message in
1482 1482 ``.hg/last-message.txt``.
1483 1483
1484 1484 The --close-branch flag can be used to mark the current branch
1485 1485 head closed. When all heads of a branch are closed, the branch
1486 1486 will be considered closed and no longer listed.
1487 1487
1488 1488 The --amend flag can be used to amend the parent of the
1489 1489 working directory with a new commit that contains the changes
1490 1490 in the parent in addition to those currently reported by :hg:`status`,
1491 1491 if there are any. The old commit is stored in a backup bundle in
1492 1492 ``.hg/strip-backup`` (see :hg:`help bundle` and :hg:`help unbundle`
1493 1493 on how to restore it).
1494 1494
1495 1495 Message, user and date are taken from the amended commit unless
1496 1496 specified. When a message isn't specified on the command line,
1497 1497 the editor will open with the message of the amended commit.
1498 1498
1499 1499 It is not possible to amend public changesets (see :hg:`help phases`)
1500 1500 or changesets that have children.
1501 1501
1502 1502 See :hg:`help dates` for a list of formats valid for -d/--date.
1503 1503
1504 1504 Returns 0 on success, 1 if nothing changed.
1505 1505
1506 1506 .. container:: verbose
1507 1507
1508 1508 Examples:
1509 1509
1510 1510 - commit all files ending in .py::
1511 1511
1512 1512 hg commit --include "set:**.py"
1513 1513
1514 1514 - commit all non-binary files::
1515 1515
1516 1516 hg commit --exclude "set:binary()"
1517 1517
1518 1518 - amend the current commit and set the date to now::
1519 1519
1520 1520 hg commit --amend --date now
1521 1521 """
1522 1522 wlock = lock = None
1523 1523 try:
1524 1524 wlock = repo.wlock()
1525 1525 lock = repo.lock()
1526 1526 return _docommit(ui, repo, *pats, **opts)
1527 1527 finally:
1528 1528 release(lock, wlock)
1529 1529
1530 1530 def _docommit(ui, repo, *pats, **opts):
1531 1531 if opts.get(r'interactive'):
1532 1532 opts.pop(r'interactive')
1533 1533 ret = cmdutil.dorecord(ui, repo, commit, None, False,
1534 1534 cmdutil.recordfilter, *pats,
1535 1535 **opts)
1536 1536 # ret can be 0 (no changes to record) or the value returned by
1537 1537 # commit(), 1 if nothing changed or None on success.
1538 1538 return 1 if ret == 0 else ret
1539 1539
1540 1540 opts = pycompat.byteskwargs(opts)
1541 1541 if opts.get('subrepos'):
1542 1542 if opts.get('amend'):
1543 1543 raise error.Abort(_('cannot amend with --subrepos'))
1544 1544 # Let --subrepos on the command line override config setting.
1545 1545 ui.setconfig('ui', 'commitsubrepos', True, 'commit')
1546 1546
1547 1547 cmdutil.checkunfinished(repo, commit=True)
1548 1548
1549 1549 branch = repo[None].branch()
1550 1550 bheads = repo.branchheads(branch)
1551 1551
1552 1552 extra = {}
1553 1553 if opts.get('close_branch'):
1554 1554 extra['close'] = '1'
1555 1555
1556 1556 if not bheads:
1557 1557 raise error.Abort(_('can only close branch heads'))
1558 1558 elif opts.get('amend'):
1559 1559 if repo[None].parents()[0].p1().branch() != branch and \
1560 1560 repo[None].parents()[0].p2().branch() != branch:
1561 1561 raise error.Abort(_('can only close branch heads'))
1562 1562
1563 1563 if opts.get('amend'):
1564 1564 if ui.configbool('ui', 'commitsubrepos'):
1565 1565 raise error.Abort(_('cannot amend with ui.commitsubrepos enabled'))
1566 1566
1567 1567 old = repo['.']
1568 1568 rewriteutil.precheck(repo, [old.rev()], 'amend')
1569 1569
1570 1570 # Currently histedit gets confused if an amend happens while histedit
1571 1571 # is in progress. Since we have a checkunfinished command, we are
1572 1572 # temporarily honoring it.
1573 1573 #
1574 1574 # Note: eventually this guard will be removed. Please do not expect
1575 1575 # this behavior to remain.
1576 1576 if not obsolete.isenabled(repo, obsolete.createmarkersopt):
1577 1577 cmdutil.checkunfinished(repo)
1578 1578
1579 1579 node = cmdutil.amend(ui, repo, old, extra, pats, opts)
1580 1580 if node == old.node():
1581 1581 ui.status(_("nothing changed\n"))
1582 1582 return 1
1583 1583 else:
1584 1584 def commitfunc(ui, repo, message, match, opts):
1585 1585 overrides = {}
1586 1586 if opts.get('secret'):
1587 1587 overrides[('phases', 'new-commit')] = 'secret'
1588 1588
1589 1589 baseui = repo.baseui
1590 1590 with baseui.configoverride(overrides, 'commit'):
1591 1591 with ui.configoverride(overrides, 'commit'):
1592 1592 editform = cmdutil.mergeeditform(repo[None],
1593 1593 'commit.normal')
1594 1594 editor = cmdutil.getcommiteditor(
1595 1595 editform=editform, **pycompat.strkwargs(opts))
1596 1596 return repo.commit(message,
1597 1597 opts.get('user'),
1598 1598 opts.get('date'),
1599 1599 match,
1600 1600 editor=editor,
1601 1601 extra=extra)
1602 1602
1603 1603 node = cmdutil.commit(ui, repo, commitfunc, pats, opts)
1604 1604
1605 1605 if not node:
1606 1606 stat = cmdutil.postcommitstatus(repo, pats, opts)
1607 1607 if stat[3]:
1608 1608 ui.status(_("nothing changed (%d missing files, see "
1609 1609 "'hg status')\n") % len(stat[3]))
1610 1610 else:
1611 1611 ui.status(_("nothing changed\n"))
1612 1612 return 1
1613 1613
1614 1614 cmdutil.commitstatus(repo, node, branch, bheads, opts)
1615 1615
1616 1616 @command('config|showconfig|debugconfig',
1617 1617 [('u', 'untrusted', None, _('show untrusted configuration options')),
1618 1618 ('e', 'edit', None, _('edit user config')),
1619 1619 ('l', 'local', None, _('edit repository config')),
1620 1620 ('g', 'global', None, _('edit global config'))] + formatteropts,
1621 1621 _('[-u] [NAME]...'),
1622 1622 optionalrepo=True, cmdtype=readonly)
1623 1623 def config(ui, repo, *values, **opts):
1624 1624 """show combined config settings from all hgrc files
1625 1625
1626 1626 With no arguments, print names and values of all config items.
1627 1627
1628 1628 With one argument of the form section.name, print just the value
1629 1629 of that config item.
1630 1630
1631 1631 With multiple arguments, print names and values of all config
1632 1632 items with matching section names.
1633 1633
1634 1634 With --edit, start an editor on the user-level config file. With
1635 1635 --global, edit the system-wide config file. With --local, edit the
1636 1636 repository-level config file.
1637 1637
1638 1638 With --debug, the source (filename and line number) is printed
1639 1639 for each config item.
1640 1640
1641 1641 See :hg:`help config` for more information about config files.
1642 1642
1643 1643 Returns 0 on success, 1 if NAME does not exist.
1644 1644
1645 1645 """
1646 1646
1647 1647 opts = pycompat.byteskwargs(opts)
1648 1648 if opts.get('edit') or opts.get('local') or opts.get('global'):
1649 1649 if opts.get('local') and opts.get('global'):
1650 1650 raise error.Abort(_("can't use --local and --global together"))
1651 1651
1652 1652 if opts.get('local'):
1653 1653 if not repo:
1654 1654 raise error.Abort(_("can't use --local outside a repository"))
1655 1655 paths = [repo.vfs.join('hgrc')]
1656 1656 elif opts.get('global'):
1657 1657 paths = rcutil.systemrcpath()
1658 1658 else:
1659 1659 paths = rcutil.userrcpath()
1660 1660
1661 1661 for f in paths:
1662 1662 if os.path.exists(f):
1663 1663 break
1664 1664 else:
1665 1665 if opts.get('global'):
1666 1666 samplehgrc = uimod.samplehgrcs['global']
1667 1667 elif opts.get('local'):
1668 1668 samplehgrc = uimod.samplehgrcs['local']
1669 1669 else:
1670 1670 samplehgrc = uimod.samplehgrcs['user']
1671 1671
1672 1672 f = paths[0]
1673 1673 fp = open(f, "wb")
1674 1674 fp.write(util.tonativeeol(samplehgrc))
1675 1675 fp.close()
1676 1676
1677 1677 editor = ui.geteditor()
1678 1678 ui.system("%s \"%s\"" % (editor, f),
1679 1679 onerr=error.Abort, errprefix=_("edit failed"),
1680 1680 blockedtag='config_edit')
1681 1681 return
1682 1682 ui.pager('config')
1683 1683 fm = ui.formatter('config', opts)
1684 1684 for t, f in rcutil.rccomponents():
1685 1685 if t == 'path':
1686 1686 ui.debug('read config from: %s\n' % f)
1687 1687 elif t == 'items':
1688 1688 for section, name, value, source in f:
1689 1689 ui.debug('set config by: %s\n' % source)
1690 1690 else:
1691 1691 raise error.ProgrammingError('unknown rctype: %s' % t)
1692 1692 untrusted = bool(opts.get('untrusted'))
1693 1693 if values:
1694 1694 sections = [v for v in values if '.' not in v]
1695 1695 items = [v for v in values if '.' in v]
1696 1696 if len(items) > 1 or items and sections:
1697 1697 raise error.Abort(_('only one config item permitted'))
1698 1698 matched = False
1699 1699 for section, name, value in ui.walkconfig(untrusted=untrusted):
1700 1700 source = ui.configsource(section, name, untrusted)
1701 1701 value = pycompat.bytestr(value)
1702 1702 if fm.isplain():
1703 1703 source = source or 'none'
1704 1704 value = value.replace('\n', '\\n')
1705 1705 entryname = section + '.' + name
1706 1706 if values:
1707 1707 for v in values:
1708 1708 if v == section:
1709 1709 fm.startitem()
1710 1710 fm.condwrite(ui.debugflag, 'source', '%s: ', source)
1711 1711 fm.write('name value', '%s=%s\n', entryname, value)
1712 1712 matched = True
1713 1713 elif v == entryname:
1714 1714 fm.startitem()
1715 1715 fm.condwrite(ui.debugflag, 'source', '%s: ', source)
1716 1716 fm.write('value', '%s\n', value)
1717 1717 fm.data(name=entryname)
1718 1718 matched = True
1719 1719 else:
1720 1720 fm.startitem()
1721 1721 fm.condwrite(ui.debugflag, 'source', '%s: ', source)
1722 1722 fm.write('name value', '%s=%s\n', entryname, value)
1723 1723 matched = True
1724 1724 fm.end()
1725 1725 if matched:
1726 1726 return 0
1727 1727 return 1
1728 1728
1729 1729 @command('copy|cp',
1730 1730 [('A', 'after', None, _('record a copy that has already occurred')),
1731 1731 ('f', 'force', None, _('forcibly copy over an existing managed file')),
1732 1732 ] + walkopts + dryrunopts,
1733 1733 _('[OPTION]... [SOURCE]... DEST'))
1734 1734 def copy(ui, repo, *pats, **opts):
1735 1735 """mark files as copied for the next commit
1736 1736
1737 1737 Mark dest as having copies of source files. If dest is a
1738 1738 directory, copies are put in that directory. If dest is a file,
1739 1739 the source must be a single file.
1740 1740
1741 1741 By default, this command copies the contents of files as they
1742 1742 exist in the working directory. If invoked with -A/--after, the
1743 1743 operation is recorded, but no copying is performed.
1744 1744
1745 1745 This command takes effect with the next commit. To undo a copy
1746 1746 before that, see :hg:`revert`.
1747 1747
1748 1748 Returns 0 on success, 1 if errors are encountered.
1749 1749 """
1750 1750 opts = pycompat.byteskwargs(opts)
1751 1751 with repo.wlock(False):
1752 1752 return cmdutil.copy(ui, repo, pats, opts)
1753 1753
1754 1754 @command('debugcommands', [], _('[COMMAND]'), norepo=True)
1755 1755 def debugcommands(ui, cmd='', *args):
1756 1756 """list all available commands and options"""
1757 1757 for cmd, vals in sorted(table.iteritems()):
1758 1758 cmd = cmd.split('|')[0].strip('^')
1759 1759 opts = ', '.join([i[1] for i in vals[1]])
1760 1760 ui.write('%s: %s\n' % (cmd, opts))
1761 1761
1762 1762 @command('debugcomplete',
1763 1763 [('o', 'options', None, _('show the command options'))],
1764 1764 _('[-o] CMD'),
1765 1765 norepo=True)
1766 1766 def debugcomplete(ui, cmd='', **opts):
1767 1767 """returns the completion list associated with the given command"""
1768 1768
1769 1769 if opts.get(r'options'):
1770 1770 options = []
1771 1771 otables = [globalopts]
1772 1772 if cmd:
1773 1773 aliases, entry = cmdutil.findcmd(cmd, table, False)
1774 1774 otables.append(entry[1])
1775 1775 for t in otables:
1776 1776 for o in t:
1777 1777 if "(DEPRECATED)" in o[3]:
1778 1778 continue
1779 1779 if o[0]:
1780 1780 options.append('-%s' % o[0])
1781 1781 options.append('--%s' % o[1])
1782 1782 ui.write("%s\n" % "\n".join(options))
1783 1783 return
1784 1784
1785 1785 cmdlist, unused_allcmds = cmdutil.findpossible(cmd, table)
1786 1786 if ui.verbose:
1787 1787 cmdlist = [' '.join(c[0]) for c in cmdlist.values()]
1788 1788 ui.write("%s\n" % "\n".join(sorted(cmdlist)))
1789 1789
1790 1790 @command('^diff',
1791 1791 [('r', 'rev', [], _('revision'), _('REV')),
1792 1792 ('c', 'change', '', _('change made by revision'), _('REV'))
1793 1793 ] + diffopts + diffopts2 + walkopts + subrepoopts,
1794 1794 _('[OPTION]... ([-c REV] | [-r REV1 [-r REV2]]) [FILE]...'),
1795 1795 inferrepo=True, cmdtype=readonly)
1796 1796 def diff(ui, repo, *pats, **opts):
1797 1797 """diff repository (or selected files)
1798 1798
1799 1799 Show differences between revisions for the specified files.
1800 1800
1801 1801 Differences between files are shown using the unified diff format.
1802 1802
1803 1803 .. note::
1804 1804
1805 1805 :hg:`diff` may generate unexpected results for merges, as it will
1806 1806 default to comparing against the working directory's first
1807 1807 parent changeset if no revisions are specified.
1808 1808
1809 1809 When two revision arguments are given, then changes are shown
1810 1810 between those revisions. If only one revision is specified then
1811 1811 that revision is compared to the working directory, and, when no
1812 1812 revisions are specified, the working directory files are compared
1813 1813 to its first parent.
1814 1814
1815 1815 Alternatively you can specify -c/--change with a revision to see
1816 1816 the changes in that changeset relative to its first parent.
1817 1817
1818 1818 Without the -a/--text option, diff will avoid generating diffs of
1819 1819 files it detects as binary. With -a, diff will generate a diff
1820 1820 anyway, probably with undesirable results.
1821 1821
1822 1822 Use the -g/--git option to generate diffs in the git extended diff
1823 1823 format. For more information, read :hg:`help diffs`.
1824 1824
1825 1825 .. container:: verbose
1826 1826
1827 1827 Examples:
1828 1828
1829 1829 - compare a file in the current working directory to its parent::
1830 1830
1831 1831 hg diff foo.c
1832 1832
1833 1833 - compare two historical versions of a directory, with rename info::
1834 1834
1835 1835 hg diff --git -r 1.0:1.2 lib/
1836 1836
1837 1837 - get change stats relative to the last change on some date::
1838 1838
1839 1839 hg diff --stat -r "date('may 2')"
1840 1840
1841 1841 - diff all newly-added files that contain a keyword::
1842 1842
1843 1843 hg diff "set:added() and grep(GNU)"
1844 1844
1845 1845 - compare a revision and its parents::
1846 1846
1847 1847 hg diff -c 9353 # compare against first parent
1848 1848 hg diff -r 9353^:9353 # same using revset syntax
1849 1849 hg diff -r 9353^2:9353 # compare against the second parent
1850 1850
1851 1851 Returns 0 on success.
1852 1852 """
1853 1853
1854 1854 opts = pycompat.byteskwargs(opts)
1855 1855 revs = opts.get('rev')
1856 1856 change = opts.get('change')
1857 1857 stat = opts.get('stat')
1858 1858 reverse = opts.get('reverse')
1859 1859
1860 1860 if revs and change:
1861 1861 msg = _('cannot specify --rev and --change at the same time')
1862 1862 raise error.Abort(msg)
1863 1863 elif change:
1864 1864 repo = scmutil.unhidehashlikerevs(repo, [change], 'nowarn')
1865 1865 node2 = scmutil.revsingle(repo, change, None).node()
1866 1866 node1 = repo[node2].p1().node()
1867 1867 else:
1868 1868 repo = scmutil.unhidehashlikerevs(repo, revs, 'nowarn')
1869 1869 node1, node2 = scmutil.revpair(repo, revs)
1870 1870
1871 1871 if reverse:
1872 1872 node1, node2 = node2, node1
1873 1873
1874 1874 diffopts = patch.diffallopts(ui, opts)
1875 1875 m = scmutil.match(repo[node2], pats, opts)
1876 1876 ui.pager('diff')
1877 1877 logcmdutil.diffordiffstat(ui, repo, diffopts, node1, node2, m, stat=stat,
1878 1878 listsubrepos=opts.get('subrepos'),
1879 1879 root=opts.get('root'))
1880 1880
1881 1881 @command('^export',
1882 1882 [('o', 'output', '',
1883 1883 _('print output to file with formatted name'), _('FORMAT')),
1884 1884 ('', 'switch-parent', None, _('diff against the second parent')),
1885 1885 ('r', 'rev', [], _('revisions to export'), _('REV')),
1886 1886 ] + diffopts,
1887 1887 _('[OPTION]... [-o OUTFILESPEC] [-r] [REV]...'), cmdtype=readonly)
1888 1888 def export(ui, repo, *changesets, **opts):
1889 1889 """dump the header and diffs for one or more changesets
1890 1890
1891 1891 Print the changeset header and diffs for one or more revisions.
1892 1892 If no revision is given, the parent of the working directory is used.
1893 1893
1894 1894 The information shown in the changeset header is: author, date,
1895 1895 branch name (if non-default), changeset hash, parent(s) and commit
1896 1896 comment.
1897 1897
1898 1898 .. note::
1899 1899
1900 1900 :hg:`export` may generate unexpected diff output for merge
1901 1901 changesets, as it will compare the merge changeset against its
1902 1902 first parent only.
1903 1903
1904 1904 Output may be to a file, in which case the name of the file is
1905 1905 given using a format string. The formatting rules are as follows:
1906 1906
1907 1907 :``%%``: literal "%" character
1908 1908 :``%H``: changeset hash (40 hexadecimal digits)
1909 1909 :``%N``: number of patches being generated
1910 1910 :``%R``: changeset revision number
1911 1911 :``%b``: basename of the exporting repository
1912 1912 :``%h``: short-form changeset hash (12 hexadecimal digits)
1913 1913 :``%m``: first line of the commit message (only alphanumeric characters)
1914 1914 :``%n``: zero-padded sequence number, starting at 1
1915 1915 :``%r``: zero-padded changeset revision number
1916 1916
1917 1917 Without the -a/--text option, export will avoid generating diffs
1918 1918 of files it detects as binary. With -a, export will generate a
1919 1919 diff anyway, probably with undesirable results.
1920 1920
1921 1921 Use the -g/--git option to generate diffs in the git extended diff
1922 1922 format. See :hg:`help diffs` for more information.
1923 1923
1924 1924 With the --switch-parent option, the diff will be against the
1925 1925 second parent. It can be useful to review a merge.
1926 1926
1927 1927 .. container:: verbose
1928 1928
1929 1929 Examples:
1930 1930
1931 1931 - use export and import to transplant a bugfix to the current
1932 1932 branch::
1933 1933
1934 1934 hg export -r 9353 | hg import -
1935 1935
1936 1936 - export all the changesets between two revisions to a file with
1937 1937 rename information::
1938 1938
1939 1939 hg export --git -r 123:150 > changes.txt
1940 1940
1941 1941 - split outgoing changes into a series of patches with
1942 1942 descriptive names::
1943 1943
1944 1944 hg export -r "outgoing()" -o "%n-%m.patch"
1945 1945
1946 1946 Returns 0 on success.
1947 1947 """
1948 1948 opts = pycompat.byteskwargs(opts)
1949 1949 changesets += tuple(opts.get('rev', []))
1950 1950 if not changesets:
1951 1951 changesets = ['.']
1952 1952 repo = scmutil.unhidehashlikerevs(repo, changesets, 'nowarn')
1953 1953 revs = scmutil.revrange(repo, changesets)
1954 1954 if not revs:
1955 1955 raise error.Abort(_("export requires at least one changeset"))
1956 1956 if len(revs) > 1:
1957 1957 ui.note(_('exporting patches:\n'))
1958 1958 else:
1959 1959 ui.note(_('exporting patch:\n'))
1960 1960 ui.pager('export')
1961 1961 cmdutil.export(repo, revs, fntemplate=opts.get('output'),
1962 1962 switch_parent=opts.get('switch_parent'),
1963 1963 opts=patch.diffallopts(ui, opts))
1964 1964
1965 1965 @command('files',
1966 1966 [('r', 'rev', '', _('search the repository as it is in REV'), _('REV')),
1967 1967 ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
1968 1968 ] + walkopts + formatteropts + subrepoopts,
1969 1969 _('[OPTION]... [FILE]...'), cmdtype=readonly)
1970 1970 def files(ui, repo, *pats, **opts):
1971 1971 """list tracked files
1972 1972
1973 1973 Print files under Mercurial control in the working directory or
1974 1974 specified revision for given files (excluding removed files).
1975 1975 Files can be specified as filenames or filesets.
1976 1976
1977 1977 If no files are given to match, this command prints the names
1978 1978 of all files under Mercurial control.
1979 1979
1980 1980 .. container:: verbose
1981 1981
1982 1982 Examples:
1983 1983
1984 1984 - list all files under the current directory::
1985 1985
1986 1986 hg files .
1987 1987
1988 1988 - shows sizes and flags for current revision::
1989 1989
1990 1990 hg files -vr .
1991 1991
1992 1992 - list all files named README::
1993 1993
1994 1994 hg files -I "**/README"
1995 1995
1996 1996 - list all binary files::
1997 1997
1998 1998 hg files "set:binary()"
1999 1999
2000 2000 - find files containing a regular expression::
2001 2001
2002 2002 hg files "set:grep('bob')"
2003 2003
2004 2004 - search tracked file contents with xargs and grep::
2005 2005
2006 2006 hg files -0 | xargs -0 grep foo
2007 2007
2008 2008 See :hg:`help patterns` and :hg:`help filesets` for more information
2009 2009 on specifying file patterns.
2010 2010
2011 2011 Returns 0 if a match is found, 1 otherwise.
2012 2012
2013 2013 """
2014 2014
2015 2015 opts = pycompat.byteskwargs(opts)
2016 2016 rev = opts.get('rev')
2017 2017 if rev:
2018 2018 repo = scmutil.unhidehashlikerevs(repo, [rev], 'nowarn')
2019 2019 ctx = scmutil.revsingle(repo, rev, None)
2020 2020
2021 2021 end = '\n'
2022 2022 if opts.get('print0'):
2023 2023 end = '\0'
2024 2024 fmt = '%s' + end
2025 2025
2026 2026 m = scmutil.match(ctx, pats, opts)
2027 2027 ui.pager('files')
2028 2028 with ui.formatter('files', opts) as fm:
2029 2029 return cmdutil.files(ui, ctx, m, fm, fmt, opts.get('subrepos'))
2030 2030
2031 2031 @command('^forget', walkopts, _('[OPTION]... FILE...'), inferrepo=True)
2032 2032 def forget(ui, repo, *pats, **opts):
2033 2033 """forget the specified files on the next commit
2034 2034
2035 2035 Mark the specified files so they will no longer be tracked
2036 2036 after the next commit.
2037 2037
2038 2038 This only removes files from the current branch, not from the
2039 2039 entire project history, and it does not delete them from the
2040 2040 working directory.
2041 2041
2042 2042 To delete the file from the working directory, see :hg:`remove`.
2043 2043
2044 2044 To undo a forget before the next commit, see :hg:`add`.
2045 2045
2046 2046 .. container:: verbose
2047 2047
2048 2048 Examples:
2049 2049
2050 2050 - forget newly-added binary files::
2051 2051
2052 2052 hg forget "set:added() and binary()"
2053 2053
2054 2054 - forget files that would be excluded by .hgignore::
2055 2055
2056 2056 hg forget "set:hgignore()"
2057 2057
2058 2058 Returns 0 on success.
2059 2059 """
2060 2060
2061 2061 opts = pycompat.byteskwargs(opts)
2062 2062 if not pats:
2063 2063 raise error.Abort(_('no files specified'))
2064 2064
2065 2065 m = scmutil.match(repo[None], pats, opts)
2066 2066 rejected = cmdutil.forget(ui, repo, m, prefix="", explicitonly=False)[0]
2067 2067 return rejected and 1 or 0
2068 2068
2069 2069 @command(
2070 2070 'graft',
2071 2071 [('r', 'rev', [], _('revisions to graft'), _('REV')),
2072 2072 ('c', 'continue', False, _('resume interrupted graft')),
2073 2073 ('e', 'edit', False, _('invoke editor on commit messages')),
2074 2074 ('', 'log', None, _('append graft info to log message')),
2075 2075 ('f', 'force', False, _('force graft')),
2076 2076 ('D', 'currentdate', False,
2077 2077 _('record the current date as commit date')),
2078 2078 ('U', 'currentuser', False,
2079 2079 _('record the current user as committer'), _('DATE'))]
2080 2080 + commitopts2 + mergetoolopts + dryrunopts,
2081 2081 _('[OPTION]... [-r REV]... REV...'))
2082 2082 def graft(ui, repo, *revs, **opts):
2083 2083 '''copy changes from other branches onto the current branch
2084 2084
2085 2085 This command uses Mercurial's merge logic to copy individual
2086 2086 changes from other branches without merging branches in the
2087 2087 history graph. This is sometimes known as 'backporting' or
2088 2088 'cherry-picking'. By default, graft will copy user, date, and
2089 2089 description from the source changesets.
2090 2090
2091 2091 Changesets that are ancestors of the current revision, that have
2092 2092 already been grafted, or that are merges will be skipped.
2093 2093
2094 2094 If --log is specified, log messages will have a comment appended
2095 2095 of the form::
2096 2096
2097 2097 (grafted from CHANGESETHASH)
2098 2098
2099 2099 If --force is specified, revisions will be grafted even if they
2100 2100 are already ancestors of, or have been grafted to, the destination.
2101 2101 This is useful when the revisions have since been backed out.
2102 2102
2103 2103 If a graft merge results in conflicts, the graft process is
2104 2104 interrupted so that the current merge can be manually resolved.
2105 2105 Once all conflicts are addressed, the graft process can be
2106 2106 continued with the -c/--continue option.
2107 2107
2108 2108 .. note::
2109 2109
2110 2110 The -c/--continue option does not reapply earlier options, except
2111 2111 for --force.
2112 2112
2113 2113 .. container:: verbose
2114 2114
2115 2115 Examples:
2116 2116
2117 2117 - copy a single change to the stable branch and edit its description::
2118 2118
2119 2119 hg update stable
2120 2120 hg graft --edit 9393
2121 2121
2122 2122 - graft a range of changesets with one exception, updating dates::
2123 2123
2124 2124 hg graft -D "2085::2093 and not 2091"
2125 2125
2126 2126 - continue a graft after resolving conflicts::
2127 2127
2128 2128 hg graft -c
2129 2129
2130 2130 - show the source of a grafted changeset::
2131 2131
2132 2132 hg log --debug -r .
2133 2133
2134 2134 - show revisions sorted by date::
2135 2135
2136 2136 hg log -r "sort(all(), date)"
2137 2137
2138 2138 See :hg:`help revisions` for more about specifying revisions.
2139 2139
2140 2140 Returns 0 on successful completion.
2141 2141 '''
2142 2142 with repo.wlock():
2143 2143 return _dograft(ui, repo, *revs, **opts)
2144 2144
2145 2145 def _dograft(ui, repo, *revs, **opts):
2146 2146 opts = pycompat.byteskwargs(opts)
2147 2147 if revs and opts.get('rev'):
2148 2148 ui.warn(_('warning: inconsistent use of --rev might give unexpected '
2149 2149 'revision ordering!\n'))
2150 2150
2151 2151 revs = list(revs)
2152 2152 revs.extend(opts.get('rev'))
2153 2153
2154 2154 if not opts.get('user') and opts.get('currentuser'):
2155 2155 opts['user'] = ui.username()
2156 2156 if not opts.get('date') and opts.get('currentdate'):
2157 2157 opts['date'] = "%d %d" % util.makedate()
2158 2158
2159 2159 editor = cmdutil.getcommiteditor(editform='graft',
2160 2160 **pycompat.strkwargs(opts))
2161 2161
2162 2162 cont = False
2163 2163 if opts.get('continue'):
2164 2164 cont = True
2165 2165 if revs:
2166 2166 raise error.Abort(_("can't specify --continue and revisions"))
2167 2167 # read in unfinished revisions
2168 2168 try:
2169 2169 nodes = repo.vfs.read('graftstate').splitlines()
2170 2170 revs = [repo[node].rev() for node in nodes]
2171 2171 except IOError as inst:
2172 2172 if inst.errno != errno.ENOENT:
2173 2173 raise
2174 2174 cmdutil.wrongtooltocontinue(repo, _('graft'))
2175 2175 else:
2176 2176 cmdutil.checkunfinished(repo)
2177 2177 cmdutil.bailifchanged(repo)
2178 2178 if not revs:
2179 2179 raise error.Abort(_('no revisions specified'))
2180 2180 revs = scmutil.revrange(repo, revs)
2181 2181
2182 2182 skipped = set()
2183 2183 # check for merges
2184 2184 for rev in repo.revs('%ld and merge()', revs):
2185 2185 ui.warn(_('skipping ungraftable merge revision %d\n') % rev)
2186 2186 skipped.add(rev)
2187 2187 revs = [r for r in revs if r not in skipped]
2188 2188 if not revs:
2189 2189 return -1
2190 2190
2191 2191 # Don't check in the --continue case, in effect retaining --force across
2192 2192 # --continues. That's because without --force, any revisions we decided to
2193 2193 # skip would have been filtered out here, so they wouldn't have made their
2194 2194 # way to the graftstate. With --force, any revisions we would have otherwise
2195 2195 # skipped would not have been filtered out, and if they hadn't been applied
2196 2196 # already, they'd have been in the graftstate.
2197 2197 if not (cont or opts.get('force')):
2198 2198 # check for ancestors of dest branch
2199 2199 crev = repo['.'].rev()
2200 2200 ancestors = repo.changelog.ancestors([crev], inclusive=True)
2201 2201 # XXX make this lazy in the future
2202 2202 # don't mutate while iterating, create a copy
2203 2203 for rev in list(revs):
2204 2204 if rev in ancestors:
2205 2205 ui.warn(_('skipping ancestor revision %d:%s\n') %
2206 2206 (rev, repo[rev]))
2207 2207 # XXX remove on list is slow
2208 2208 revs.remove(rev)
2209 2209 if not revs:
2210 2210 return -1
2211 2211
2212 2212 # analyze revs for earlier grafts
2213 2213 ids = {}
2214 2214 for ctx in repo.set("%ld", revs):
2215 2215 ids[ctx.hex()] = ctx.rev()
2216 2216 n = ctx.extra().get('source')
2217 2217 if n:
2218 2218 ids[n] = ctx.rev()
2219 2219
2220 2220 # check ancestors for earlier grafts
2221 2221 ui.debug('scanning for duplicate grafts\n')
2222 2222
2223 2223 # The only changesets we can be sure doesn't contain grafts of any
2224 2224 # revs, are the ones that are common ancestors of *all* revs:
2225 2225 for rev in repo.revs('only(%d,ancestor(%ld))', crev, revs):
2226 2226 ctx = repo[rev]
2227 2227 n = ctx.extra().get('source')
2228 2228 if n in ids:
2229 2229 try:
2230 2230 r = repo[n].rev()
2231 2231 except error.RepoLookupError:
2232 2232 r = None
2233 2233 if r in revs:
2234 2234 ui.warn(_('skipping revision %d:%s '
2235 2235 '(already grafted to %d:%s)\n')
2236 2236 % (r, repo[r], rev, ctx))
2237 2237 revs.remove(r)
2238 2238 elif ids[n] in revs:
2239 2239 if r is None:
2240 2240 ui.warn(_('skipping already grafted revision %d:%s '
2241 2241 '(%d:%s also has unknown origin %s)\n')
2242 2242 % (ids[n], repo[ids[n]], rev, ctx, n[:12]))
2243 2243 else:
2244 2244 ui.warn(_('skipping already grafted revision %d:%s '
2245 2245 '(%d:%s also has origin %d:%s)\n')
2246 2246 % (ids[n], repo[ids[n]], rev, ctx, r, n[:12]))
2247 2247 revs.remove(ids[n])
2248 2248 elif ctx.hex() in ids:
2249 2249 r = ids[ctx.hex()]
2250 2250 ui.warn(_('skipping already grafted revision %d:%s '
2251 2251 '(was grafted from %d:%s)\n') %
2252 2252 (r, repo[r], rev, ctx))
2253 2253 revs.remove(r)
2254 2254 if not revs:
2255 2255 return -1
2256 2256
2257 2257 for pos, ctx in enumerate(repo.set("%ld", revs)):
2258 2258 desc = '%d:%s "%s"' % (ctx.rev(), ctx,
2259 2259 ctx.description().split('\n', 1)[0])
2260 2260 names = repo.nodetags(ctx.node()) + repo.nodebookmarks(ctx.node())
2261 2261 if names:
2262 2262 desc += ' (%s)' % ' '.join(names)
2263 2263 ui.status(_('grafting %s\n') % desc)
2264 2264 if opts.get('dry_run'):
2265 2265 continue
2266 2266
2267 2267 source = ctx.extra().get('source')
2268 2268 extra = {}
2269 2269 if source:
2270 2270 extra['source'] = source
2271 2271 extra['intermediate-source'] = ctx.hex()
2272 2272 else:
2273 2273 extra['source'] = ctx.hex()
2274 2274 user = ctx.user()
2275 2275 if opts.get('user'):
2276 2276 user = opts['user']
2277 2277 date = ctx.date()
2278 2278 if opts.get('date'):
2279 2279 date = opts['date']
2280 2280 message = ctx.description()
2281 2281 if opts.get('log'):
2282 2282 message += '\n(grafted from %s)' % ctx.hex()
2283 2283
2284 2284 # we don't merge the first commit when continuing
2285 2285 if not cont:
2286 2286 # perform the graft merge with p1(rev) as 'ancestor'
2287 2287 try:
2288 2288 # ui.forcemerge is an internal variable, do not document
2289 2289 repo.ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
2290 2290 'graft')
2291 2291 stats = mergemod.graft(repo, ctx, ctx.p1(),
2292 2292 ['local', 'graft'])
2293 2293 finally:
2294 2294 repo.ui.setconfig('ui', 'forcemerge', '', 'graft')
2295 2295 # report any conflicts
2296 2296 if stats and stats[3] > 0:
2297 2297 # write out state for --continue
2298 2298 nodelines = [repo[rev].hex() + "\n" for rev in revs[pos:]]
2299 2299 repo.vfs.write('graftstate', ''.join(nodelines))
2300 2300 extra = ''
2301 2301 if opts.get('user'):
2302 2302 extra += ' --user %s' % util.shellquote(opts['user'])
2303 2303 if opts.get('date'):
2304 2304 extra += ' --date %s' % util.shellquote(opts['date'])
2305 2305 if opts.get('log'):
2306 2306 extra += ' --log'
2307 2307 hint=_("use 'hg resolve' and 'hg graft --continue%s'") % extra
2308 2308 raise error.Abort(
2309 2309 _("unresolved conflicts, can't continue"),
2310 2310 hint=hint)
2311 2311 else:
2312 2312 cont = False
2313 2313
2314 2314 # commit
2315 2315 node = repo.commit(text=message, user=user,
2316 2316 date=date, extra=extra, editor=editor)
2317 2317 if node is None:
2318 2318 ui.warn(
2319 2319 _('note: graft of %d:%s created no changes to commit\n') %
2320 2320 (ctx.rev(), ctx))
2321 2321
2322 2322 # remove state when we complete successfully
2323 2323 if not opts.get('dry_run'):
2324 2324 repo.vfs.unlinkpath('graftstate', ignoremissing=True)
2325 2325
2326 2326 return 0
2327 2327
2328 2328 @command('grep',
2329 2329 [('0', 'print0', None, _('end fields with NUL')),
2330 2330 ('', 'all', None, _('print all revisions that match')),
2331 2331 ('a', 'text', None, _('treat all files as text')),
2332 2332 ('f', 'follow', None,
2333 2333 _('follow changeset history,'
2334 2334 ' or file history across copies and renames')),
2335 2335 ('i', 'ignore-case', None, _('ignore case when matching')),
2336 2336 ('l', 'files-with-matches', None,
2337 2337 _('print only filenames and revisions that match')),
2338 2338 ('n', 'line-number', None, _('print matching line numbers')),
2339 2339 ('r', 'rev', [],
2340 2340 _('only search files changed within revision range'), _('REV')),
2341 2341 ('u', 'user', None, _('list the author (long with -v)')),
2342 2342 ('d', 'date', None, _('list the date (short with -q)')),
2343 2343 ] + formatteropts + walkopts,
2344 2344 _('[OPTION]... PATTERN [FILE]...'),
2345 2345 inferrepo=True, cmdtype=readonly)
2346 2346 def grep(ui, repo, pattern, *pats, **opts):
2347 2347 """search revision history for a pattern in specified files
2348 2348
2349 2349 Search revision history for a regular expression in the specified
2350 2350 files or the entire project.
2351 2351
2352 2352 By default, grep prints the most recent revision number for each
2353 2353 file in which it finds a match. To get it to print every revision
2354 2354 that contains a change in match status ("-" for a match that becomes
2355 2355 a non-match, or "+" for a non-match that becomes a match), use the
2356 2356 --all flag.
2357 2357
2358 2358 PATTERN can be any Python (roughly Perl-compatible) regular
2359 2359 expression.
2360 2360
2361 2361 If no FILEs are specified (and -f/--follow isn't set), all files in
2362 2362 the repository are searched, including those that don't exist in the
2363 2363 current branch or have been deleted in a prior changeset.
2364 2364
2365 2365 Returns 0 if a match is found, 1 otherwise.
2366 2366 """
2367 2367 opts = pycompat.byteskwargs(opts)
2368 2368 reflags = re.M
2369 2369 if opts.get('ignore_case'):
2370 2370 reflags |= re.I
2371 2371 try:
2372 2372 regexp = util.re.compile(pattern, reflags)
2373 2373 except re.error as inst:
2374 2374 ui.warn(_("grep: invalid match pattern: %s\n") % inst)
2375 2375 return 1
2376 2376 sep, eol = ':', '\n'
2377 2377 if opts.get('print0'):
2378 2378 sep = eol = '\0'
2379 2379
2380 2380 getfile = util.lrucachefunc(repo.file)
2381 2381
2382 2382 def matchlines(body):
2383 2383 begin = 0
2384 2384 linenum = 0
2385 2385 while begin < len(body):
2386 2386 match = regexp.search(body, begin)
2387 2387 if not match:
2388 2388 break
2389 2389 mstart, mend = match.span()
2390 2390 linenum += body.count('\n', begin, mstart) + 1
2391 2391 lstart = body.rfind('\n', begin, mstart) + 1 or begin
2392 2392 begin = body.find('\n', mend) + 1 or len(body) + 1
2393 2393 lend = begin - 1
2394 2394 yield linenum, mstart - lstart, mend - lstart, body[lstart:lend]
2395 2395
2396 2396 class linestate(object):
2397 2397 def __init__(self, line, linenum, colstart, colend):
2398 2398 self.line = line
2399 2399 self.linenum = linenum
2400 2400 self.colstart = colstart
2401 2401 self.colend = colend
2402 2402
2403 2403 def __hash__(self):
2404 2404 return hash((self.linenum, self.line))
2405 2405
2406 2406 def __eq__(self, other):
2407 2407 return self.line == other.line
2408 2408
2409 2409 def findpos(self):
2410 2410 """Iterate all (start, end) indices of matches"""
2411 2411 yield self.colstart, self.colend
2412 2412 p = self.colend
2413 2413 while p < len(self.line):
2414 2414 m = regexp.search(self.line, p)
2415 2415 if not m:
2416 2416 break
2417 2417 yield m.span()
2418 2418 p = m.end()
2419 2419
2420 2420 matches = {}
2421 2421 copies = {}
2422 2422 def grepbody(fn, rev, body):
2423 2423 matches[rev].setdefault(fn, [])
2424 2424 m = matches[rev][fn]
2425 2425 for lnum, cstart, cend, line in matchlines(body):
2426 2426 s = linestate(line, lnum, cstart, cend)
2427 2427 m.append(s)
2428 2428
2429 2429 def difflinestates(a, b):
2430 2430 sm = difflib.SequenceMatcher(None, a, b)
2431 2431 for tag, alo, ahi, blo, bhi in sm.get_opcodes():
2432 2432 if tag == 'insert':
2433 2433 for i in xrange(blo, bhi):
2434 2434 yield ('+', b[i])
2435 2435 elif tag == 'delete':
2436 2436 for i in xrange(alo, ahi):
2437 2437 yield ('-', a[i])
2438 2438 elif tag == 'replace':
2439 2439 for i in xrange(alo, ahi):
2440 2440 yield ('-', a[i])
2441 2441 for i in xrange(blo, bhi):
2442 2442 yield ('+', b[i])
2443 2443
2444 2444 def display(fm, fn, ctx, pstates, states):
2445 2445 rev = ctx.rev()
2446 2446 if fm.isplain():
2447 2447 formatuser = ui.shortuser
2448 2448 else:
2449 2449 formatuser = str
2450 2450 if ui.quiet:
2451 2451 datefmt = '%Y-%m-%d'
2452 2452 else:
2453 2453 datefmt = '%a %b %d %H:%M:%S %Y %1%2'
2454 2454 found = False
2455 2455 @util.cachefunc
2456 2456 def binary():
2457 2457 flog = getfile(fn)
2458 2458 return util.binary(flog.read(ctx.filenode(fn)))
2459 2459
2460 2460 fieldnamemap = {'filename': 'file', 'linenumber': 'line_number'}
2461 2461 if opts.get('all'):
2462 2462 iter = difflinestates(pstates, states)
2463 2463 else:
2464 2464 iter = [('', l) for l in states]
2465 2465 for change, l in iter:
2466 2466 fm.startitem()
2467 2467 fm.data(node=fm.hexfunc(ctx.node()))
2468 2468 cols = [
2469 2469 ('filename', fn, True),
2470 2470 ('rev', rev, True),
2471 2471 ('linenumber', l.linenum, opts.get('line_number')),
2472 2472 ]
2473 2473 if opts.get('all'):
2474 2474 cols.append(('change', change, True))
2475 2475 cols.extend([
2476 2476 ('user', formatuser(ctx.user()), opts.get('user')),
2477 2477 ('date', fm.formatdate(ctx.date(), datefmt), opts.get('date')),
2478 2478 ])
2479 2479 lastcol = next(name for name, data, cond in reversed(cols) if cond)
2480 2480 for name, data, cond in cols:
2481 2481 field = fieldnamemap.get(name, name)
2482 2482 fm.condwrite(cond, field, '%s', data, label='grep.%s' % name)
2483 2483 if cond and name != lastcol:
2484 2484 fm.plain(sep, label='grep.sep')
2485 2485 if not opts.get('files_with_matches'):
2486 2486 fm.plain(sep, label='grep.sep')
2487 2487 if not opts.get('text') and binary():
2488 2488 fm.plain(_(" Binary file matches"))
2489 2489 else:
2490 2490 displaymatches(fm.nested('texts'), l)
2491 2491 fm.plain(eol)
2492 2492 found = True
2493 2493 if opts.get('files_with_matches'):
2494 2494 break
2495 2495 return found
2496 2496
2497 2497 def displaymatches(fm, l):
2498 2498 p = 0
2499 2499 for s, e in l.findpos():
2500 2500 if p < s:
2501 2501 fm.startitem()
2502 2502 fm.write('text', '%s', l.line[p:s])
2503 2503 fm.data(matched=False)
2504 2504 fm.startitem()
2505 2505 fm.write('text', '%s', l.line[s:e], label='grep.match')
2506 2506 fm.data(matched=True)
2507 2507 p = e
2508 2508 if p < len(l.line):
2509 2509 fm.startitem()
2510 2510 fm.write('text', '%s', l.line[p:])
2511 2511 fm.data(matched=False)
2512 2512 fm.end()
2513 2513
2514 2514 skip = {}
2515 2515 revfiles = {}
2516 2516 match = scmutil.match(repo[None], pats, opts)
2517 2517 found = False
2518 2518 follow = opts.get('follow')
2519 2519
2520 2520 def prep(ctx, fns):
2521 2521 rev = ctx.rev()
2522 2522 pctx = ctx.p1()
2523 2523 parent = pctx.rev()
2524 2524 matches.setdefault(rev, {})
2525 2525 matches.setdefault(parent, {})
2526 2526 files = revfiles.setdefault(rev, [])
2527 2527 for fn in fns:
2528 2528 flog = getfile(fn)
2529 2529 try:
2530 2530 fnode = ctx.filenode(fn)
2531 2531 except error.LookupError:
2532 2532 continue
2533 2533
2534 2534 copied = flog.renamed(fnode)
2535 2535 copy = follow and copied and copied[0]
2536 2536 if copy:
2537 2537 copies.setdefault(rev, {})[fn] = copy
2538 2538 if fn in skip:
2539 2539 if copy:
2540 2540 skip[copy] = True
2541 2541 continue
2542 2542 files.append(fn)
2543 2543
2544 2544 if fn not in matches[rev]:
2545 2545 grepbody(fn, rev, flog.read(fnode))
2546 2546
2547 2547 pfn = copy or fn
2548 2548 if pfn not in matches[parent]:
2549 2549 try:
2550 2550 fnode = pctx.filenode(pfn)
2551 2551 grepbody(pfn, parent, flog.read(fnode))
2552 2552 except error.LookupError:
2553 2553 pass
2554 2554
2555 2555 ui.pager('grep')
2556 2556 fm = ui.formatter('grep', opts)
2557 2557 for ctx in cmdutil.walkchangerevs(repo, match, opts, prep):
2558 2558 rev = ctx.rev()
2559 2559 parent = ctx.p1().rev()
2560 2560 for fn in sorted(revfiles.get(rev, [])):
2561 2561 states = matches[rev][fn]
2562 2562 copy = copies.get(rev, {}).get(fn)
2563 2563 if fn in skip:
2564 2564 if copy:
2565 2565 skip[copy] = True
2566 2566 continue
2567 2567 pstates = matches.get(parent, {}).get(copy or fn, [])
2568 2568 if pstates or states:
2569 2569 r = display(fm, fn, ctx, pstates, states)
2570 2570 found = found or r
2571 2571 if r and not opts.get('all'):
2572 2572 skip[fn] = True
2573 2573 if copy:
2574 2574 skip[copy] = True
2575 2575 del matches[rev]
2576 2576 del revfiles[rev]
2577 2577 fm.end()
2578 2578
2579 2579 return not found
2580 2580
2581 2581 @command('heads',
2582 2582 [('r', 'rev', '',
2583 2583 _('show only heads which are descendants of STARTREV'), _('STARTREV')),
2584 2584 ('t', 'topo', False, _('show topological heads only')),
2585 2585 ('a', 'active', False, _('show active branchheads only (DEPRECATED)')),
2586 2586 ('c', 'closed', False, _('show normal and closed branch heads')),
2587 2587 ] + templateopts,
2588 2588 _('[-ct] [-r STARTREV] [REV]...'), cmdtype=readonly)
2589 2589 def heads(ui, repo, *branchrevs, **opts):
2590 2590 """show branch heads
2591 2591
2592 2592 With no arguments, show all open branch heads in the repository.
2593 2593 Branch heads are changesets that have no descendants on the
2594 2594 same branch. They are where development generally takes place and
2595 2595 are the usual targets for update and merge operations.
2596 2596
2597 2597 If one or more REVs are given, only open branch heads on the
2598 2598 branches associated with the specified changesets are shown. This
2599 2599 means that you can use :hg:`heads .` to see the heads on the
2600 2600 currently checked-out branch.
2601 2601
2602 2602 If -c/--closed is specified, also show branch heads marked closed
2603 2603 (see :hg:`commit --close-branch`).
2604 2604
2605 2605 If STARTREV is specified, only those heads that are descendants of
2606 2606 STARTREV will be displayed.
2607 2607
2608 2608 If -t/--topo is specified, named branch mechanics will be ignored and only
2609 2609 topological heads (changesets with no children) will be shown.
2610 2610
2611 2611 Returns 0 if matching heads are found, 1 if not.
2612 2612 """
2613 2613
2614 2614 opts = pycompat.byteskwargs(opts)
2615 2615 start = None
2616 2616 rev = opts.get('rev')
2617 2617 if rev:
2618 2618 repo = scmutil.unhidehashlikerevs(repo, [rev], 'nowarn')
2619 2619 start = scmutil.revsingle(repo, rev, None).node()
2620 2620
2621 2621 if opts.get('topo'):
2622 2622 heads = [repo[h] for h in repo.heads(start)]
2623 2623 else:
2624 2624 heads = []
2625 2625 for branch in repo.branchmap():
2626 2626 heads += repo.branchheads(branch, start, opts.get('closed'))
2627 2627 heads = [repo[h] for h in heads]
2628 2628
2629 2629 if branchrevs:
2630 2630 branches = set(repo[br].branch() for br in branchrevs)
2631 2631 heads = [h for h in heads if h.branch() in branches]
2632 2632
2633 2633 if opts.get('active') and branchrevs:
2634 2634 dagheads = repo.heads(start)
2635 2635 heads = [h for h in heads if h.node() in dagheads]
2636 2636
2637 2637 if branchrevs:
2638 2638 haveheads = set(h.branch() for h in heads)
2639 2639 if branches - haveheads:
2640 2640 headless = ', '.join(b for b in branches - haveheads)
2641 2641 msg = _('no open branch heads found on branches %s')
2642 2642 if opts.get('rev'):
2643 2643 msg += _(' (started at %s)') % opts['rev']
2644 2644 ui.warn((msg + '\n') % headless)
2645 2645
2646 2646 if not heads:
2647 2647 return 1
2648 2648
2649 2649 ui.pager('heads')
2650 2650 heads = sorted(heads, key=lambda x: -x.rev())
2651 2651 displayer = logcmdutil.changesetdisplayer(ui, repo, opts)
2652 2652 for ctx in heads:
2653 2653 displayer.show(ctx)
2654 2654 displayer.close()
2655 2655
2656 2656 @command('help',
2657 2657 [('e', 'extension', None, _('show only help for extensions')),
2658 2658 ('c', 'command', None, _('show only help for commands')),
2659 2659 ('k', 'keyword', None, _('show topics matching keyword')),
2660 2660 ('s', 'system', [], _('show help for specific platform(s)')),
2661 2661 ],
2662 2662 _('[-ecks] [TOPIC]'),
2663 2663 norepo=True, cmdtype=readonly)
2664 2664 def help_(ui, name=None, **opts):
2665 2665 """show help for a given topic or a help overview
2666 2666
2667 2667 With no arguments, print a list of commands with short help messages.
2668 2668
2669 2669 Given a topic, extension, or command name, print help for that
2670 2670 topic.
2671 2671
2672 2672 Returns 0 if successful.
2673 2673 """
2674 2674
2675 2675 keep = opts.get(r'system') or []
2676 2676 if len(keep) == 0:
2677 2677 if pycompat.sysplatform.startswith('win'):
2678 2678 keep.append('windows')
2679 2679 elif pycompat.sysplatform == 'OpenVMS':
2680 2680 keep.append('vms')
2681 2681 elif pycompat.sysplatform == 'plan9':
2682 2682 keep.append('plan9')
2683 2683 else:
2684 2684 keep.append('unix')
2685 2685 keep.append(pycompat.sysplatform.lower())
2686 2686 if ui.verbose:
2687 2687 keep.append('verbose')
2688 2688
2689 2689 commands = sys.modules[__name__]
2690 2690 formatted = help.formattedhelp(ui, commands, name, keep=keep, **opts)
2691 2691 ui.pager('help')
2692 2692 ui.write(formatted)
2693 2693
2694 2694
2695 2695 @command('identify|id',
2696 2696 [('r', 'rev', '',
2697 2697 _('identify the specified revision'), _('REV')),
2698 2698 ('n', 'num', None, _('show local revision number')),
2699 2699 ('i', 'id', None, _('show global revision id')),
2700 2700 ('b', 'branch', None, _('show branch')),
2701 2701 ('t', 'tags', None, _('show tags')),
2702 2702 ('B', 'bookmarks', None, _('show bookmarks')),
2703 2703 ] + remoteopts + formatteropts,
2704 2704 _('[-nibtB] [-r REV] [SOURCE]'),
2705 2705 optionalrepo=True, cmdtype=readonly)
2706 2706 def identify(ui, repo, source=None, rev=None,
2707 2707 num=None, id=None, branch=None, tags=None, bookmarks=None, **opts):
2708 2708 """identify the working directory or specified revision
2709 2709
2710 2710 Print a summary identifying the repository state at REV using one or
2711 2711 two parent hash identifiers, followed by a "+" if the working
2712 2712 directory has uncommitted changes, the branch name (if not default),
2713 2713 a list of tags, and a list of bookmarks.
2714 2714
2715 2715 When REV is not given, print a summary of the current state of the
2716 2716 repository including the working directory. Specify -r. to get information
2717 2717 of the working directory parent without scanning uncommitted changes.
2718 2718
2719 2719 Specifying a path to a repository root or Mercurial bundle will
2720 2720 cause lookup to operate on that repository/bundle.
2721 2721
2722 2722 .. container:: verbose
2723 2723
2724 2724 Examples:
2725 2725
2726 2726 - generate a build identifier for the working directory::
2727 2727
2728 2728 hg id --id > build-id.dat
2729 2729
2730 2730 - find the revision corresponding to a tag::
2731 2731
2732 2732 hg id -n -r 1.3
2733 2733
2734 2734 - check the most recent revision of a remote repository::
2735 2735
2736 2736 hg id -r tip https://www.mercurial-scm.org/repo/hg/
2737 2737
2738 2738 See :hg:`log` for generating more information about specific revisions,
2739 2739 including full hash identifiers.
2740 2740
2741 2741 Returns 0 if successful.
2742 2742 """
2743 2743
2744 2744 opts = pycompat.byteskwargs(opts)
2745 2745 if not repo and not source:
2746 2746 raise error.Abort(_("there is no Mercurial repository here "
2747 2747 "(.hg not found)"))
2748 2748
2749 2749 if ui.debugflag:
2750 2750 hexfunc = hex
2751 2751 else:
2752 2752 hexfunc = short
2753 2753 default = not (num or id or branch or tags or bookmarks)
2754 2754 output = []
2755 2755 revs = []
2756 2756
2757 2757 if source:
2758 2758 source, branches = hg.parseurl(ui.expandpath(source))
2759 2759 peer = hg.peer(repo or ui, opts, source) # only pass ui when no repo
2760 2760 repo = peer.local()
2761 2761 revs, checkout = hg.addbranchrevs(repo, peer, branches, None)
2762 2762
2763 2763 fm = ui.formatter('identify', opts)
2764 2764 fm.startitem()
2765 2765
2766 2766 if not repo:
2767 2767 if num or branch or tags:
2768 2768 raise error.Abort(
2769 2769 _("can't query remote revision number, branch, or tags"))
2770 2770 if not rev and revs:
2771 2771 rev = revs[0]
2772 2772 if not rev:
2773 2773 rev = "tip"
2774 2774
2775 2775 remoterev = peer.lookup(rev)
2776 2776 hexrev = hexfunc(remoterev)
2777 2777 if default or id:
2778 2778 output = [hexrev]
2779 2779 fm.data(id=hexrev)
2780 2780
2781 2781 def getbms():
2782 2782 bms = []
2783 2783
2784 2784 if 'bookmarks' in peer.listkeys('namespaces'):
2785 2785 hexremoterev = hex(remoterev)
2786 2786 bms = [bm for bm, bmr in peer.listkeys('bookmarks').iteritems()
2787 2787 if bmr == hexremoterev]
2788 2788
2789 2789 return sorted(bms)
2790 2790
2791 2791 bms = getbms()
2792 2792 if bookmarks:
2793 2793 output.extend(bms)
2794 2794 elif default and not ui.quiet:
2795 2795 # multiple bookmarks for a single parent separated by '/'
2796 2796 bm = '/'.join(bms)
2797 2797 if bm:
2798 2798 output.append(bm)
2799 2799
2800 2800 fm.data(node=hex(remoterev))
2801 2801 fm.data(bookmarks=fm.formatlist(bms, name='bookmark'))
2802 2802 else:
2803 2803 if rev:
2804 2804 repo = scmutil.unhidehashlikerevs(repo, [rev], 'nowarn')
2805 2805 ctx = scmutil.revsingle(repo, rev, None)
2806 2806
2807 2807 if ctx.rev() is None:
2808 2808 ctx = repo[None]
2809 2809 parents = ctx.parents()
2810 2810 taglist = []
2811 2811 for p in parents:
2812 2812 taglist.extend(p.tags())
2813 2813
2814 2814 dirty = ""
2815 2815 if ctx.dirty(missing=True, merge=False, branch=False):
2816 2816 dirty = '+'
2817 2817 fm.data(dirty=dirty)
2818 2818
2819 2819 hexoutput = [hexfunc(p.node()) for p in parents]
2820 2820 if default or id:
2821 2821 output = ["%s%s" % ('+'.join(hexoutput), dirty)]
2822 2822 fm.data(id="%s%s" % ('+'.join(hexoutput), dirty))
2823 2823
2824 2824 if num:
2825 2825 numoutput = ["%d" % p.rev() for p in parents]
2826 2826 output.append("%s%s" % ('+'.join(numoutput), dirty))
2827 2827
2828 2828 fn = fm.nested('parents')
2829 2829 for p in parents:
2830 2830 fn.startitem()
2831 2831 fn.data(rev=p.rev())
2832 2832 fn.data(node=p.hex())
2833 2833 fn.context(ctx=p)
2834 2834 fn.end()
2835 2835 else:
2836 2836 hexoutput = hexfunc(ctx.node())
2837 2837 if default or id:
2838 2838 output = [hexoutput]
2839 2839 fm.data(id=hexoutput)
2840 2840
2841 2841 if num:
2842 2842 output.append(pycompat.bytestr(ctx.rev()))
2843 2843 taglist = ctx.tags()
2844 2844
2845 2845 if default and not ui.quiet:
2846 2846 b = ctx.branch()
2847 2847 if b != 'default':
2848 2848 output.append("(%s)" % b)
2849 2849
2850 2850 # multiple tags for a single parent separated by '/'
2851 2851 t = '/'.join(taglist)
2852 2852 if t:
2853 2853 output.append(t)
2854 2854
2855 2855 # multiple bookmarks for a single parent separated by '/'
2856 2856 bm = '/'.join(ctx.bookmarks())
2857 2857 if bm:
2858 2858 output.append(bm)
2859 2859 else:
2860 2860 if branch:
2861 2861 output.append(ctx.branch())
2862 2862
2863 2863 if tags:
2864 2864 output.extend(taglist)
2865 2865
2866 2866 if bookmarks:
2867 2867 output.extend(ctx.bookmarks())
2868 2868
2869 2869 fm.data(node=ctx.hex())
2870 2870 fm.data(branch=ctx.branch())
2871 2871 fm.data(tags=fm.formatlist(taglist, name='tag', sep=':'))
2872 2872 fm.data(bookmarks=fm.formatlist(ctx.bookmarks(), name='bookmark'))
2873 2873 fm.context(ctx=ctx)
2874 2874
2875 2875 fm.plain("%s\n" % ' '.join(output))
2876 2876 fm.end()
2877 2877
2878 2878 @command('import|patch',
2879 2879 [('p', 'strip', 1,
2880 2880 _('directory strip option for patch. This has the same '
2881 2881 'meaning as the corresponding patch option'), _('NUM')),
2882 2882 ('b', 'base', '', _('base path (DEPRECATED)'), _('PATH')),
2883 2883 ('e', 'edit', False, _('invoke editor on commit messages')),
2884 2884 ('f', 'force', None,
2885 2885 _('skip check for outstanding uncommitted changes (DEPRECATED)')),
2886 2886 ('', 'no-commit', None,
2887 2887 _("don't commit, just update the working directory")),
2888 2888 ('', 'bypass', None,
2889 2889 _("apply patch without touching the working directory")),
2890 2890 ('', 'partial', None,
2891 2891 _('commit even if some hunks fail')),
2892 2892 ('', 'exact', None,
2893 2893 _('abort if patch would apply lossily')),
2894 2894 ('', 'prefix', '',
2895 2895 _('apply patch to subdirectory'), _('DIR')),
2896 2896 ('', 'import-branch', None,
2897 2897 _('use any branch information in patch (implied by --exact)'))] +
2898 2898 commitopts + commitopts2 + similarityopts,
2899 2899 _('[OPTION]... PATCH...'))
2900 2900 def import_(ui, repo, patch1=None, *patches, **opts):
2901 2901 """import an ordered set of patches
2902 2902
2903 2903 Import a list of patches and commit them individually (unless
2904 2904 --no-commit is specified).
2905 2905
2906 2906 To read a patch from standard input (stdin), use "-" as the patch
2907 2907 name. If a URL is specified, the patch will be downloaded from
2908 2908 there.
2909 2909
2910 2910 Import first applies changes to the working directory (unless
2911 2911 --bypass is specified), import will abort if there are outstanding
2912 2912 changes.
2913 2913
2914 2914 Use --bypass to apply and commit patches directly to the
2915 2915 repository, without affecting the working directory. Without
2916 2916 --exact, patches will be applied on top of the working directory
2917 2917 parent revision.
2918 2918
2919 2919 You can import a patch straight from a mail message. Even patches
2920 2920 as attachments work (to use the body part, it must have type
2921 2921 text/plain or text/x-patch). From and Subject headers of email
2922 2922 message are used as default committer and commit message. All
2923 2923 text/plain body parts before first diff are added to the commit
2924 2924 message.
2925 2925
2926 2926 If the imported patch was generated by :hg:`export`, user and
2927 2927 description from patch override values from message headers and
2928 2928 body. Values given on command line with -m/--message and -u/--user
2929 2929 override these.
2930 2930
2931 2931 If --exact is specified, import will set the working directory to
2932 2932 the parent of each patch before applying it, and will abort if the
2933 2933 resulting changeset has a different ID than the one recorded in
2934 2934 the patch. This will guard against various ways that portable
2935 2935 patch formats and mail systems might fail to transfer Mercurial
2936 2936 data or metadata. See :hg:`bundle` for lossless transmission.
2937 2937
2938 2938 Use --partial to ensure a changeset will be created from the patch
2939 2939 even if some hunks fail to apply. Hunks that fail to apply will be
2940 2940 written to a <target-file>.rej file. Conflicts can then be resolved
2941 2941 by hand before :hg:`commit --amend` is run to update the created
2942 2942 changeset. This flag exists to let people import patches that
2943 2943 partially apply without losing the associated metadata (author,
2944 2944 date, description, ...).
2945 2945
2946 2946 .. note::
2947 2947
2948 2948 When no hunks apply cleanly, :hg:`import --partial` will create
2949 2949 an empty changeset, importing only the patch metadata.
2950 2950
2951 2951 With -s/--similarity, hg will attempt to discover renames and
2952 2952 copies in the patch in the same way as :hg:`addremove`.
2953 2953
2954 2954 It is possible to use external patch programs to perform the patch
2955 2955 by setting the ``ui.patch`` configuration option. For the default
2956 2956 internal tool, the fuzz can also be configured via ``patch.fuzz``.
2957 2957 See :hg:`help config` for more information about configuration
2958 2958 files and how to use these options.
2959 2959
2960 2960 See :hg:`help dates` for a list of formats valid for -d/--date.
2961 2961
2962 2962 .. container:: verbose
2963 2963
2964 2964 Examples:
2965 2965
2966 2966 - import a traditional patch from a website and detect renames::
2967 2967
2968 2968 hg import -s 80 http://example.com/bugfix.patch
2969 2969
2970 2970 - import a changeset from an hgweb server::
2971 2971
2972 2972 hg import https://www.mercurial-scm.org/repo/hg/rev/5ca8c111e9aa
2973 2973
2974 2974 - import all the patches in an Unix-style mbox::
2975 2975
2976 2976 hg import incoming-patches.mbox
2977 2977
2978 2978 - import patches from stdin::
2979 2979
2980 2980 hg import -
2981 2981
2982 2982 - attempt to exactly restore an exported changeset (not always
2983 2983 possible)::
2984 2984
2985 2985 hg import --exact proposed-fix.patch
2986 2986
2987 2987 - use an external tool to apply a patch which is too fuzzy for
2988 2988 the default internal tool.
2989 2989
2990 2990 hg import --config ui.patch="patch --merge" fuzzy.patch
2991 2991
2992 2992 - change the default fuzzing from 2 to a less strict 7
2993 2993
2994 2994 hg import --config ui.fuzz=7 fuzz.patch
2995 2995
2996 2996 Returns 0 on success, 1 on partial success (see --partial).
2997 2997 """
2998 2998
2999 2999 opts = pycompat.byteskwargs(opts)
3000 3000 if not patch1:
3001 3001 raise error.Abort(_('need at least one patch to import'))
3002 3002
3003 3003 patches = (patch1,) + patches
3004 3004
3005 3005 date = opts.get('date')
3006 3006 if date:
3007 3007 opts['date'] = util.parsedate(date)
3008 3008
3009 3009 exact = opts.get('exact')
3010 3010 update = not opts.get('bypass')
3011 3011 if not update and opts.get('no_commit'):
3012 3012 raise error.Abort(_('cannot use --no-commit with --bypass'))
3013 3013 try:
3014 3014 sim = float(opts.get('similarity') or 0)
3015 3015 except ValueError:
3016 3016 raise error.Abort(_('similarity must be a number'))
3017 3017 if sim < 0 or sim > 100:
3018 3018 raise error.Abort(_('similarity must be between 0 and 100'))
3019 3019 if sim and not update:
3020 3020 raise error.Abort(_('cannot use --similarity with --bypass'))
3021 3021 if exact:
3022 3022 if opts.get('edit'):
3023 3023 raise error.Abort(_('cannot use --exact with --edit'))
3024 3024 if opts.get('prefix'):
3025 3025 raise error.Abort(_('cannot use --exact with --prefix'))
3026 3026
3027 3027 base = opts["base"]
3028 3028 wlock = dsguard = lock = tr = None
3029 3029 msgs = []
3030 3030 ret = 0
3031 3031
3032 3032
3033 3033 try:
3034 3034 wlock = repo.wlock()
3035 3035
3036 3036 if update:
3037 3037 cmdutil.checkunfinished(repo)
3038 3038 if (exact or not opts.get('force')):
3039 3039 cmdutil.bailifchanged(repo)
3040 3040
3041 3041 if not opts.get('no_commit'):
3042 3042 lock = repo.lock()
3043 3043 tr = repo.transaction('import')
3044 3044 else:
3045 3045 dsguard = dirstateguard.dirstateguard(repo, 'import')
3046 3046 parents = repo[None].parents()
3047 3047 for patchurl in patches:
3048 3048 if patchurl == '-':
3049 3049 ui.status(_('applying patch from stdin\n'))
3050 3050 patchfile = ui.fin
3051 3051 patchurl = 'stdin' # for error message
3052 3052 else:
3053 3053 patchurl = os.path.join(base, patchurl)
3054 3054 ui.status(_('applying %s\n') % patchurl)
3055 3055 patchfile = hg.openpath(ui, patchurl)
3056 3056
3057 3057 haspatch = False
3058 3058 for hunk in patch.split(patchfile):
3059 3059 (msg, node, rej) = cmdutil.tryimportone(ui, repo, hunk,
3060 3060 parents, opts,
3061 3061 msgs, hg.clean)
3062 3062 if msg:
3063 3063 haspatch = True
3064 3064 ui.note(msg + '\n')
3065 3065 if update or exact:
3066 3066 parents = repo[None].parents()
3067 3067 else:
3068 3068 parents = [repo[node]]
3069 3069 if rej:
3070 3070 ui.write_err(_("patch applied partially\n"))
3071 3071 ui.write_err(_("(fix the .rej files and run "
3072 3072 "`hg commit --amend`)\n"))
3073 3073 ret = 1
3074 3074 break
3075 3075
3076 3076 if not haspatch:
3077 3077 raise error.Abort(_('%s: no diffs found') % patchurl)
3078 3078
3079 3079 if tr:
3080 3080 tr.close()
3081 3081 if msgs:
3082 3082 repo.savecommitmessage('\n* * *\n'.join(msgs))
3083 3083 if dsguard:
3084 3084 dsguard.close()
3085 3085 return ret
3086 3086 finally:
3087 3087 if tr:
3088 3088 tr.release()
3089 3089 release(lock, dsguard, wlock)
3090 3090
3091 3091 @command('incoming|in',
3092 3092 [('f', 'force', None,
3093 3093 _('run even if remote repository is unrelated')),
3094 3094 ('n', 'newest-first', None, _('show newest record first')),
3095 3095 ('', 'bundle', '',
3096 3096 _('file to store the bundles into'), _('FILE')),
3097 3097 ('r', 'rev', [], _('a remote changeset intended to be added'), _('REV')),
3098 3098 ('B', 'bookmarks', False, _("compare bookmarks")),
3099 3099 ('b', 'branch', [],
3100 3100 _('a specific branch you would like to pull'), _('BRANCH')),
3101 3101 ] + logopts + remoteopts + subrepoopts,
3102 3102 _('[-p] [-n] [-M] [-f] [-r REV]... [--bundle FILENAME] [SOURCE]'))
3103 3103 def incoming(ui, repo, source="default", **opts):
3104 3104 """show new changesets found in source
3105 3105
3106 3106 Show new changesets found in the specified path/URL or the default
3107 3107 pull location. These are the changesets that would have been pulled
3108 3108 by :hg:`pull` at the time you issued this command.
3109 3109
3110 3110 See pull for valid source format details.
3111 3111
3112 3112 .. container:: verbose
3113 3113
3114 3114 With -B/--bookmarks, the result of bookmark comparison between
3115 3115 local and remote repositories is displayed. With -v/--verbose,
3116 3116 status is also displayed for each bookmark like below::
3117 3117
3118 3118 BM1 01234567890a added
3119 3119 BM2 1234567890ab advanced
3120 3120 BM3 234567890abc diverged
3121 3121 BM4 34567890abcd changed
3122 3122
3123 3123 The action taken locally when pulling depends on the
3124 3124 status of each bookmark:
3125 3125
3126 3126 :``added``: pull will create it
3127 3127 :``advanced``: pull will update it
3128 3128 :``diverged``: pull will create a divergent bookmark
3129 3129 :``changed``: result depends on remote changesets
3130 3130
3131 3131 From the point of view of pulling behavior, bookmark
3132 3132 existing only in the remote repository are treated as ``added``,
3133 3133 even if it is in fact locally deleted.
3134 3134
3135 3135 .. container:: verbose
3136 3136
3137 3137 For remote repository, using --bundle avoids downloading the
3138 3138 changesets twice if the incoming is followed by a pull.
3139 3139
3140 3140 Examples:
3141 3141
3142 3142 - show incoming changes with patches and full description::
3143 3143
3144 3144 hg incoming -vp
3145 3145
3146 3146 - show incoming changes excluding merges, store a bundle::
3147 3147
3148 3148 hg in -vpM --bundle incoming.hg
3149 3149 hg pull incoming.hg
3150 3150
3151 3151 - briefly list changes inside a bundle::
3152 3152
3153 3153 hg in changes.hg -T "{desc|firstline}\\n"
3154 3154
3155 3155 Returns 0 if there are incoming changes, 1 otherwise.
3156 3156 """
3157 3157 opts = pycompat.byteskwargs(opts)
3158 3158 if opts.get('graph'):
3159 3159 logcmdutil.checkunsupportedgraphflags([], opts)
3160 3160 def display(other, chlist, displayer):
3161 3161 revdag = logcmdutil.graphrevs(other, chlist, opts)
3162 3162 logcmdutil.displaygraph(ui, repo, revdag, displayer,
3163 3163 graphmod.asciiedges)
3164 3164
3165 3165 hg._incoming(display, lambda: 1, ui, repo, source, opts, buffered=True)
3166 3166 return 0
3167 3167
3168 3168 if opts.get('bundle') and opts.get('subrepos'):
3169 3169 raise error.Abort(_('cannot combine --bundle and --subrepos'))
3170 3170
3171 3171 if opts.get('bookmarks'):
3172 3172 source, branches = hg.parseurl(ui.expandpath(source),
3173 3173 opts.get('branch'))
3174 3174 other = hg.peer(repo, opts, source)
3175 3175 if 'bookmarks' not in other.listkeys('namespaces'):
3176 3176 ui.warn(_("remote doesn't support bookmarks\n"))
3177 3177 return 0
3178 3178 ui.pager('incoming')
3179 3179 ui.status(_('comparing with %s\n') % util.hidepassword(source))
3180 3180 return bookmarks.incoming(ui, repo, other)
3181 3181
3182 3182 repo._subtoppath = ui.expandpath(source)
3183 3183 try:
3184 3184 return hg.incoming(ui, repo, source, opts)
3185 3185 finally:
3186 3186 del repo._subtoppath
3187 3187
3188 3188
3189 3189 @command('^init', remoteopts, _('[-e CMD] [--remotecmd CMD] [DEST]'),
3190 3190 norepo=True)
3191 3191 def init(ui, dest=".", **opts):
3192 3192 """create a new repository in the given directory
3193 3193
3194 3194 Initialize a new repository in the given directory. If the given
3195 3195 directory does not exist, it will be created.
3196 3196
3197 3197 If no directory is given, the current directory is used.
3198 3198
3199 3199 It is possible to specify an ``ssh://`` URL as the destination.
3200 3200 See :hg:`help urls` for more information.
3201 3201
3202 3202 Returns 0 on success.
3203 3203 """
3204 3204 opts = pycompat.byteskwargs(opts)
3205 3205 hg.peer(ui, opts, ui.expandpath(dest), create=True)
3206 3206
3207 3207 @command('locate',
3208 3208 [('r', 'rev', '', _('search the repository as it is in REV'), _('REV')),
3209 3209 ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
3210 3210 ('f', 'fullpath', None, _('print complete paths from the filesystem root')),
3211 3211 ] + walkopts,
3212 3212 _('[OPTION]... [PATTERN]...'))
3213 3213 def locate(ui, repo, *pats, **opts):
3214 3214 """locate files matching specific patterns (DEPRECATED)
3215 3215
3216 3216 Print files under Mercurial control in the working directory whose
3217 3217 names match the given patterns.
3218 3218
3219 3219 By default, this command searches all directories in the working
3220 3220 directory. To search just the current directory and its
3221 3221 subdirectories, use "--include .".
3222 3222
3223 3223 If no patterns are given to match, this command prints the names
3224 3224 of all files under Mercurial control in the working directory.
3225 3225
3226 3226 If you want to feed the output of this command into the "xargs"
3227 3227 command, use the -0 option to both this command and "xargs". This
3228 3228 will avoid the problem of "xargs" treating single filenames that
3229 3229 contain whitespace as multiple filenames.
3230 3230
3231 3231 See :hg:`help files` for a more versatile command.
3232 3232
3233 3233 Returns 0 if a match is found, 1 otherwise.
3234 3234 """
3235 3235 opts = pycompat.byteskwargs(opts)
3236 3236 if opts.get('print0'):
3237 3237 end = '\0'
3238 3238 else:
3239 3239 end = '\n'
3240 3240 rev = scmutil.revsingle(repo, opts.get('rev'), None).node()
3241 3241
3242 3242 ret = 1
3243 3243 ctx = repo[rev]
3244 3244 m = scmutil.match(ctx, pats, opts, default='relglob',
3245 3245 badfn=lambda x, y: False)
3246 3246
3247 3247 ui.pager('locate')
3248 3248 for abs in ctx.matches(m):
3249 3249 if opts.get('fullpath'):
3250 3250 ui.write(repo.wjoin(abs), end)
3251 3251 else:
3252 3252 ui.write(((pats and m.rel(abs)) or abs), end)
3253 3253 ret = 0
3254 3254
3255 3255 return ret
3256 3256
3257 3257 @command('^log|history',
3258 3258 [('f', 'follow', None,
3259 3259 _('follow changeset history, or file history across copies and renames')),
3260 3260 ('', 'follow-first', None,
3261 3261 _('only follow the first parent of merge changesets (DEPRECATED)')),
3262 3262 ('d', 'date', '', _('show revisions matching date spec'), _('DATE')),
3263 3263 ('C', 'copies', None, _('show copied files')),
3264 3264 ('k', 'keyword', [],
3265 3265 _('do case-insensitive search for a given text'), _('TEXT')),
3266 3266 ('r', 'rev', [], _('show the specified revision or revset'), _('REV')),
3267 3267 ('L', 'line-range', [],
3268 3268 _('follow line range of specified file (EXPERIMENTAL)'),
3269 3269 _('FILE,RANGE')),
3270 3270 ('', 'removed', None, _('include revisions where files were removed')),
3271 3271 ('m', 'only-merges', None, _('show only merges (DEPRECATED)')),
3272 3272 ('u', 'user', [], _('revisions committed by user'), _('USER')),
3273 3273 ('', 'only-branch', [],
3274 3274 _('show only changesets within the given named branch (DEPRECATED)'),
3275 3275 _('BRANCH')),
3276 3276 ('b', 'branch', [],
3277 3277 _('show changesets within the given named branch'), _('BRANCH')),
3278 3278 ('P', 'prune', [],
3279 3279 _('do not display revision or any of its ancestors'), _('REV')),
3280 3280 ] + logopts + walkopts,
3281 3281 _('[OPTION]... [FILE]'),
3282 3282 inferrepo=True, cmdtype=readonly)
3283 3283 def log(ui, repo, *pats, **opts):
3284 3284 """show revision history of entire repository or files
3285 3285
3286 3286 Print the revision history of the specified files or the entire
3287 3287 project.
3288 3288
3289 3289 If no revision range is specified, the default is ``tip:0`` unless
3290 3290 --follow is set, in which case the working directory parent is
3291 3291 used as the starting revision.
3292 3292
3293 3293 File history is shown without following rename or copy history of
3294 3294 files. Use -f/--follow with a filename to follow history across
3295 3295 renames and copies. --follow without a filename will only show
3296 3296 ancestors of the starting revision.
3297 3297
3298 3298 By default this command prints revision number and changeset id,
3299 3299 tags, non-trivial parents, user, date and time, and a summary for
3300 3300 each commit. When the -v/--verbose switch is used, the list of
3301 3301 changed files and full commit message are shown.
3302 3302
3303 3303 With --graph the revisions are shown as an ASCII art DAG with the most
3304 3304 recent changeset at the top.
3305 3305 'o' is a changeset, '@' is a working directory parent, 'x' is obsolete,
3306 3306 and '+' represents a fork where the changeset from the lines below is a
3307 3307 parent of the 'o' merge on the same line.
3308 3308 Paths in the DAG are represented with '|', '/' and so forth. ':' in place
3309 3309 of a '|' indicates one or more revisions in a path are omitted.
3310 3310
3311 3311 .. container:: verbose
3312 3312
3313 3313 Use -L/--line-range FILE,M:N options to follow the history of lines
3314 3314 from M to N in FILE. With -p/--patch only diff hunks affecting
3315 3315 specified line range will be shown. This option requires --follow;
3316 3316 it can be specified multiple times. Currently, this option is not
3317 3317 compatible with --graph. This option is experimental.
3318 3318
3319 3319 .. note::
3320 3320
3321 3321 :hg:`log --patch` may generate unexpected diff output for merge
3322 3322 changesets, as it will only compare the merge changeset against
3323 3323 its first parent. Also, only files different from BOTH parents
3324 3324 will appear in files:.
3325 3325
3326 3326 .. note::
3327 3327
3328 3328 For performance reasons, :hg:`log FILE` may omit duplicate changes
3329 3329 made on branches and will not show removals or mode changes. To
3330 3330 see all such changes, use the --removed switch.
3331 3331
3332 3332 .. container:: verbose
3333 3333
3334 3334 .. note::
3335 3335
3336 3336 The history resulting from -L/--line-range options depends on diff
3337 3337 options; for instance if white-spaces are ignored, respective changes
3338 3338 with only white-spaces in specified line range will not be listed.
3339 3339
3340 3340 .. container:: verbose
3341 3341
3342 3342 Some examples:
3343 3343
3344 3344 - changesets with full descriptions and file lists::
3345 3345
3346 3346 hg log -v
3347 3347
3348 3348 - changesets ancestral to the working directory::
3349 3349
3350 3350 hg log -f
3351 3351
3352 3352 - last 10 commits on the current branch::
3353 3353
3354 3354 hg log -l 10 -b .
3355 3355
3356 3356 - changesets showing all modifications of a file, including removals::
3357 3357
3358 3358 hg log --removed file.c
3359 3359
3360 3360 - all changesets that touch a directory, with diffs, excluding merges::
3361 3361
3362 3362 hg log -Mp lib/
3363 3363
3364 3364 - all revision numbers that match a keyword::
3365 3365
3366 3366 hg log -k bug --template "{rev}\\n"
3367 3367
3368 3368 - the full hash identifier of the working directory parent::
3369 3369
3370 3370 hg log -r . --template "{node}\\n"
3371 3371
3372 3372 - list available log templates::
3373 3373
3374 3374 hg log -T list
3375 3375
3376 3376 - check if a given changeset is included in a tagged release::
3377 3377
3378 3378 hg log -r "a21ccf and ancestor(1.9)"
3379 3379
3380 3380 - find all changesets by some user in a date range::
3381 3381
3382 3382 hg log -k alice -d "may 2008 to jul 2008"
3383 3383
3384 3384 - summary of all changesets after the last tag::
3385 3385
3386 3386 hg log -r "last(tagged())::" --template "{desc|firstline}\\n"
3387 3387
3388 3388 - changesets touching lines 13 to 23 for file.c::
3389 3389
3390 3390 hg log -L file.c,13:23
3391 3391
3392 3392 - changesets touching lines 13 to 23 for file.c and lines 2 to 6 of
3393 3393 main.c with patch::
3394 3394
3395 3395 hg log -L file.c,13:23 -L main.c,2:6 -p
3396 3396
3397 3397 See :hg:`help dates` for a list of formats valid for -d/--date.
3398 3398
3399 3399 See :hg:`help revisions` for more about specifying and ordering
3400 3400 revisions.
3401 3401
3402 3402 See :hg:`help templates` for more about pre-packaged styles and
3403 3403 specifying custom templates. The default template used by the log
3404 3404 command can be customized via the ``ui.logtemplate`` configuration
3405 3405 setting.
3406 3406
3407 3407 Returns 0 on success.
3408 3408
3409 3409 """
3410 3410 opts = pycompat.byteskwargs(opts)
3411 3411 linerange = opts.get('line_range')
3412 3412
3413 3413 if linerange and not opts.get('follow'):
3414 3414 raise error.Abort(_('--line-range requires --follow'))
3415 3415
3416 3416 if linerange and pats:
3417 3417 # TODO: take pats as patterns with no line-range filter
3418 3418 raise error.Abort(
3419 3419 _('FILE arguments are not compatible with --line-range option')
3420 3420 )
3421 3421
3422 3422 repo = scmutil.unhidehashlikerevs(repo, opts.get('rev'), 'nowarn')
3423 3423 revs, differ = logcmdutil.getrevs(repo, pats, opts)
3424 3424 if linerange:
3425 3425 # TODO: should follow file history from logcmdutil._initialrevs(),
3426 3426 # then filter the result by logcmdutil._makerevset() and --limit
3427 3427 revs, differ = logcmdutil.getlinerangerevs(repo, revs, opts)
3428 3428
3429 3429 getrenamed = None
3430 3430 if opts.get('copies'):
3431 3431 endrev = None
3432 3432 if opts.get('rev'):
3433 3433 endrev = scmutil.revrange(repo, opts.get('rev')).max() + 1
3434 3434 getrenamed = templatekw.getrenamedfn(repo, endrev=endrev)
3435 3435
3436 3436 ui.pager('log')
3437 3437 displayer = logcmdutil.changesetdisplayer(ui, repo, opts, differ,
3438 3438 buffered=True)
3439 3439 if opts.get('graph'):
3440 3440 displayfn = logcmdutil.displaygraphrevs
3441 3441 else:
3442 3442 displayfn = logcmdutil.displayrevs
3443 3443 displayfn(ui, repo, revs, displayer, getrenamed)
3444 3444
3445 3445 @command('manifest',
3446 3446 [('r', 'rev', '', _('revision to display'), _('REV')),
3447 3447 ('', 'all', False, _("list files from all revisions"))]
3448 3448 + formatteropts,
3449 3449 _('[-r REV]'), cmdtype=readonly)
3450 3450 def manifest(ui, repo, node=None, rev=None, **opts):
3451 3451 """output the current or given revision of the project manifest
3452 3452
3453 3453 Print a list of version controlled files for the given revision.
3454 3454 If no revision is given, the first parent of the working directory
3455 3455 is used, or the null revision if no revision is checked out.
3456 3456
3457 3457 With -v, print file permissions, symlink and executable bits.
3458 3458 With --debug, print file revision hashes.
3459 3459
3460 3460 If option --all is specified, the list of all files from all revisions
3461 3461 is printed. This includes deleted and renamed files.
3462 3462
3463 3463 Returns 0 on success.
3464 3464 """
3465 3465 opts = pycompat.byteskwargs(opts)
3466 3466 fm = ui.formatter('manifest', opts)
3467 3467
3468 3468 if opts.get('all'):
3469 3469 if rev or node:
3470 3470 raise error.Abort(_("can't specify a revision with --all"))
3471 3471
3472 3472 res = []
3473 3473 prefix = "data/"
3474 3474 suffix = ".i"
3475 3475 plen = len(prefix)
3476 3476 slen = len(suffix)
3477 3477 with repo.lock():
3478 3478 for fn, b, size in repo.store.datafiles():
3479 3479 if size != 0 and fn[-slen:] == suffix and fn[:plen] == prefix:
3480 3480 res.append(fn[plen:-slen])
3481 3481 ui.pager('manifest')
3482 3482 for f in res:
3483 3483 fm.startitem()
3484 3484 fm.write("path", '%s\n', f)
3485 3485 fm.end()
3486 3486 return
3487 3487
3488 3488 if rev and node:
3489 3489 raise error.Abort(_("please specify just one revision"))
3490 3490
3491 3491 if not node:
3492 3492 node = rev
3493 3493
3494 3494 char = {'l': '@', 'x': '*', '': ''}
3495 3495 mode = {'l': '644', 'x': '755', '': '644'}
3496 3496 if node:
3497 3497 repo = scmutil.unhidehashlikerevs(repo, [node], 'nowarn')
3498 3498 ctx = scmutil.revsingle(repo, node)
3499 3499 mf = ctx.manifest()
3500 3500 ui.pager('manifest')
3501 3501 for f in ctx:
3502 3502 fm.startitem()
3503 3503 fl = ctx[f].flags()
3504 3504 fm.condwrite(ui.debugflag, 'hash', '%s ', hex(mf[f]))
3505 3505 fm.condwrite(ui.verbose, 'mode type', '%s %1s ', mode[fl], char[fl])
3506 3506 fm.write('path', '%s\n', f)
3507 3507 fm.end()
3508 3508
3509 3509 @command('^merge',
3510 3510 [('f', 'force', None,
3511 3511 _('force a merge including outstanding changes (DEPRECATED)')),
3512 3512 ('r', 'rev', '', _('revision to merge'), _('REV')),
3513 3513 ('P', 'preview', None,
3514 3514 _('review revisions to merge (no merge is performed)')),
3515 3515 ('', 'abort', None, _('abort the ongoing merge')),
3516 3516 ] + mergetoolopts,
3517 3517 _('[-P] [[-r] REV]'))
3518 3518 def merge(ui, repo, node=None, **opts):
3519 3519 """merge another revision into working directory
3520 3520
3521 3521 The current working directory is updated with all changes made in
3522 3522 the requested revision since the last common predecessor revision.
3523 3523
3524 3524 Files that changed between either parent are marked as changed for
3525 3525 the next commit and a commit must be performed before any further
3526 3526 updates to the repository are allowed. The next commit will have
3527 3527 two parents.
3528 3528
3529 3529 ``--tool`` can be used to specify the merge tool used for file
3530 3530 merges. It overrides the HGMERGE environment variable and your
3531 3531 configuration files. See :hg:`help merge-tools` for options.
3532 3532
3533 3533 If no revision is specified, the working directory's parent is a
3534 3534 head revision, and the current branch contains exactly one other
3535 3535 head, the other head is merged with by default. Otherwise, an
3536 3536 explicit revision with which to merge with must be provided.
3537 3537
3538 3538 See :hg:`help resolve` for information on handling file conflicts.
3539 3539
3540 3540 To undo an uncommitted merge, use :hg:`merge --abort` which
3541 3541 will check out a clean copy of the original merge parent, losing
3542 3542 all changes.
3543 3543
3544 3544 Returns 0 on success, 1 if there are unresolved files.
3545 3545 """
3546 3546
3547 3547 opts = pycompat.byteskwargs(opts)
3548 3548 abort = opts.get('abort')
3549 3549 if abort and repo.dirstate.p2() == nullid:
3550 3550 cmdutil.wrongtooltocontinue(repo, _('merge'))
3551 3551 if abort:
3552 3552 if node:
3553 3553 raise error.Abort(_("cannot specify a node with --abort"))
3554 3554 if opts.get('rev'):
3555 3555 raise error.Abort(_("cannot specify both --rev and --abort"))
3556 3556 if opts.get('preview'):
3557 3557 raise error.Abort(_("cannot specify --preview with --abort"))
3558 3558 if opts.get('rev') and node:
3559 3559 raise error.Abort(_("please specify just one revision"))
3560 3560 if not node:
3561 3561 node = opts.get('rev')
3562 3562
3563 3563 if node:
3564 3564 node = scmutil.revsingle(repo, node).node()
3565 3565
3566 3566 if not node and not abort:
3567 3567 node = repo[destutil.destmerge(repo)].node()
3568 3568
3569 3569 if opts.get('preview'):
3570 3570 # find nodes that are ancestors of p2 but not of p1
3571 3571 p1 = repo.lookup('.')
3572 3572 p2 = repo.lookup(node)
3573 3573 nodes = repo.changelog.findmissing(common=[p1], heads=[p2])
3574 3574
3575 3575 displayer = logcmdutil.changesetdisplayer(ui, repo, opts)
3576 3576 for node in nodes:
3577 3577 displayer.show(repo[node])
3578 3578 displayer.close()
3579 3579 return 0
3580 3580
3581 3581 try:
3582 3582 # ui.forcemerge is an internal variable, do not document
3583 3583 repo.ui.setconfig('ui', 'forcemerge', opts.get('tool', ''), 'merge')
3584 3584 force = opts.get('force')
3585 3585 labels = ['working copy', 'merge rev']
3586 3586 return hg.merge(repo, node, force=force, mergeforce=force,
3587 3587 labels=labels, abort=abort)
3588 3588 finally:
3589 3589 ui.setconfig('ui', 'forcemerge', '', 'merge')
3590 3590
3591 3591 @command('outgoing|out',
3592 3592 [('f', 'force', None, _('run even when the destination is unrelated')),
3593 3593 ('r', 'rev', [],
3594 3594 _('a changeset intended to be included in the destination'), _('REV')),
3595 3595 ('n', 'newest-first', None, _('show newest record first')),
3596 3596 ('B', 'bookmarks', False, _('compare bookmarks')),
3597 3597 ('b', 'branch', [], _('a specific branch you would like to push'),
3598 3598 _('BRANCH')),
3599 3599 ] + logopts + remoteopts + subrepoopts,
3600 3600 _('[-M] [-p] [-n] [-f] [-r REV]... [DEST]'))
3601 3601 def outgoing(ui, repo, dest=None, **opts):
3602 3602 """show changesets not found in the destination
3603 3603
3604 3604 Show changesets not found in the specified destination repository
3605 3605 or the default push location. These are the changesets that would
3606 3606 be pushed if a push was requested.
3607 3607
3608 3608 See pull for details of valid destination formats.
3609 3609
3610 3610 .. container:: verbose
3611 3611
3612 3612 With -B/--bookmarks, the result of bookmark comparison between
3613 3613 local and remote repositories is displayed. With -v/--verbose,
3614 3614 status is also displayed for each bookmark like below::
3615 3615
3616 3616 BM1 01234567890a added
3617 3617 BM2 deleted
3618 3618 BM3 234567890abc advanced
3619 3619 BM4 34567890abcd diverged
3620 3620 BM5 4567890abcde changed
3621 3621
3622 3622 The action taken when pushing depends on the
3623 3623 status of each bookmark:
3624 3624
3625 3625 :``added``: push with ``-B`` will create it
3626 3626 :``deleted``: push with ``-B`` will delete it
3627 3627 :``advanced``: push will update it
3628 3628 :``diverged``: push with ``-B`` will update it
3629 3629 :``changed``: push with ``-B`` will update it
3630 3630
3631 3631 From the point of view of pushing behavior, bookmarks
3632 3632 existing only in the remote repository are treated as
3633 3633 ``deleted``, even if it is in fact added remotely.
3634 3634
3635 3635 Returns 0 if there are outgoing changes, 1 otherwise.
3636 3636 """
3637 3637 opts = pycompat.byteskwargs(opts)
3638 3638 if opts.get('graph'):
3639 3639 logcmdutil.checkunsupportedgraphflags([], opts)
3640 3640 o, other = hg._outgoing(ui, repo, dest, opts)
3641 3641 if not o:
3642 3642 cmdutil.outgoinghooks(ui, repo, other, opts, o)
3643 3643 return
3644 3644
3645 3645 revdag = logcmdutil.graphrevs(repo, o, opts)
3646 3646 ui.pager('outgoing')
3647 3647 displayer = logcmdutil.changesetdisplayer(ui, repo, opts, buffered=True)
3648 3648 logcmdutil.displaygraph(ui, repo, revdag, displayer,
3649 3649 graphmod.asciiedges)
3650 3650 cmdutil.outgoinghooks(ui, repo, other, opts, o)
3651 3651 return 0
3652 3652
3653 3653 if opts.get('bookmarks'):
3654 3654 dest = ui.expandpath(dest or 'default-push', dest or 'default')
3655 3655 dest, branches = hg.parseurl(dest, opts.get('branch'))
3656 3656 other = hg.peer(repo, opts, dest)
3657 3657 if 'bookmarks' not in other.listkeys('namespaces'):
3658 3658 ui.warn(_("remote doesn't support bookmarks\n"))
3659 3659 return 0
3660 3660 ui.status(_('comparing with %s\n') % util.hidepassword(dest))
3661 3661 ui.pager('outgoing')
3662 3662 return bookmarks.outgoing(ui, repo, other)
3663 3663
3664 3664 repo._subtoppath = ui.expandpath(dest or 'default-push', dest or 'default')
3665 3665 try:
3666 3666 return hg.outgoing(ui, repo, dest, opts)
3667 3667 finally:
3668 3668 del repo._subtoppath
3669 3669
3670 3670 @command('parents',
3671 3671 [('r', 'rev', '', _('show parents of the specified revision'), _('REV')),
3672 3672 ] + templateopts,
3673 3673 _('[-r REV] [FILE]'),
3674 3674 inferrepo=True)
3675 3675 def parents(ui, repo, file_=None, **opts):
3676 3676 """show the parents of the working directory or revision (DEPRECATED)
3677 3677
3678 3678 Print the working directory's parent revisions. If a revision is
3679 3679 given via -r/--rev, the parent of that revision will be printed.
3680 3680 If a file argument is given, the revision in which the file was
3681 3681 last changed (before the working directory revision or the
3682 3682 argument to --rev if given) is printed.
3683 3683
3684 3684 This command is equivalent to::
3685 3685
3686 3686 hg log -r "p1()+p2()" or
3687 3687 hg log -r "p1(REV)+p2(REV)" or
3688 3688 hg log -r "max(::p1() and file(FILE))+max(::p2() and file(FILE))" or
3689 3689 hg log -r "max(::p1(REV) and file(FILE))+max(::p2(REV) and file(FILE))"
3690 3690
3691 3691 See :hg:`summary` and :hg:`help revsets` for related information.
3692 3692
3693 3693 Returns 0 on success.
3694 3694 """
3695 3695
3696 3696 opts = pycompat.byteskwargs(opts)
3697 3697 rev = opts.get('rev')
3698 3698 if rev:
3699 3699 repo = scmutil.unhidehashlikerevs(repo, [rev], 'nowarn')
3700 3700 ctx = scmutil.revsingle(repo, rev, None)
3701 3701
3702 3702 if file_:
3703 3703 m = scmutil.match(ctx, (file_,), opts)
3704 3704 if m.anypats() or len(m.files()) != 1:
3705 3705 raise error.Abort(_('can only specify an explicit filename'))
3706 3706 file_ = m.files()[0]
3707 3707 filenodes = []
3708 3708 for cp in ctx.parents():
3709 3709 if not cp:
3710 3710 continue
3711 3711 try:
3712 3712 filenodes.append(cp.filenode(file_))
3713 3713 except error.LookupError:
3714 3714 pass
3715 3715 if not filenodes:
3716 3716 raise error.Abort(_("'%s' not found in manifest!") % file_)
3717 3717 p = []
3718 3718 for fn in filenodes:
3719 3719 fctx = repo.filectx(file_, fileid=fn)
3720 3720 p.append(fctx.node())
3721 3721 else:
3722 3722 p = [cp.node() for cp in ctx.parents()]
3723 3723
3724 3724 displayer = logcmdutil.changesetdisplayer(ui, repo, opts)
3725 3725 for n in p:
3726 3726 if n != nullid:
3727 3727 displayer.show(repo[n])
3728 3728 displayer.close()
3729 3729
3730 3730 @command('paths', formatteropts, _('[NAME]'), optionalrepo=True,
3731 3731 cmdtype=readonly)
3732 3732 def paths(ui, repo, search=None, **opts):
3733 3733 """show aliases for remote repositories
3734 3734
3735 3735 Show definition of symbolic path name NAME. If no name is given,
3736 3736 show definition of all available names.
3737 3737
3738 3738 Option -q/--quiet suppresses all output when searching for NAME
3739 3739 and shows only the path names when listing all definitions.
3740 3740
3741 3741 Path names are defined in the [paths] section of your
3742 3742 configuration file and in ``/etc/mercurial/hgrc``. If run inside a
3743 3743 repository, ``.hg/hgrc`` is used, too.
3744 3744
3745 3745 The path names ``default`` and ``default-push`` have a special
3746 3746 meaning. When performing a push or pull operation, they are used
3747 3747 as fallbacks if no location is specified on the command-line.
3748 3748 When ``default-push`` is set, it will be used for push and
3749 3749 ``default`` will be used for pull; otherwise ``default`` is used
3750 3750 as the fallback for both. When cloning a repository, the clone
3751 3751 source is written as ``default`` in ``.hg/hgrc``.
3752 3752
3753 3753 .. note::
3754 3754
3755 3755 ``default`` and ``default-push`` apply to all inbound (e.g.
3756 3756 :hg:`incoming`) and outbound (e.g. :hg:`outgoing`, :hg:`email`
3757 3757 and :hg:`bundle`) operations.
3758 3758
3759 3759 See :hg:`help urls` for more information.
3760 3760
3761 3761 Returns 0 on success.
3762 3762 """
3763 3763
3764 3764 opts = pycompat.byteskwargs(opts)
3765 3765 ui.pager('paths')
3766 3766 if search:
3767 3767 pathitems = [(name, path) for name, path in ui.paths.iteritems()
3768 3768 if name == search]
3769 3769 else:
3770 3770 pathitems = sorted(ui.paths.iteritems())
3771 3771
3772 3772 fm = ui.formatter('paths', opts)
3773 3773 if fm.isplain():
3774 3774 hidepassword = util.hidepassword
3775 3775 else:
3776 3776 hidepassword = str
3777 3777 if ui.quiet:
3778 3778 namefmt = '%s\n'
3779 3779 else:
3780 3780 namefmt = '%s = '
3781 3781 showsubopts = not search and not ui.quiet
3782 3782
3783 3783 for name, path in pathitems:
3784 3784 fm.startitem()
3785 3785 fm.condwrite(not search, 'name', namefmt, name)
3786 3786 fm.condwrite(not ui.quiet, 'url', '%s\n', hidepassword(path.rawloc))
3787 3787 for subopt, value in sorted(path.suboptions.items()):
3788 3788 assert subopt not in ('name', 'url')
3789 3789 if showsubopts:
3790 3790 fm.plain('%s:%s = ' % (name, subopt))
3791 3791 fm.condwrite(showsubopts, subopt, '%s\n', value)
3792 3792
3793 3793 fm.end()
3794 3794
3795 3795 if search and not pathitems:
3796 3796 if not ui.quiet:
3797 3797 ui.warn(_("not found!\n"))
3798 3798 return 1
3799 3799 else:
3800 3800 return 0
3801 3801
3802 3802 @command('phase',
3803 3803 [('p', 'public', False, _('set changeset phase to public')),
3804 3804 ('d', 'draft', False, _('set changeset phase to draft')),
3805 3805 ('s', 'secret', False, _('set changeset phase to secret')),
3806 3806 ('f', 'force', False, _('allow to move boundary backward')),
3807 3807 ('r', 'rev', [], _('target revision'), _('REV')),
3808 3808 ],
3809 3809 _('[-p|-d|-s] [-f] [-r] [REV...]'))
3810 3810 def phase(ui, repo, *revs, **opts):
3811 3811 """set or show the current phase name
3812 3812
3813 3813 With no argument, show the phase name of the current revision(s).
3814 3814
3815 3815 With one of -p/--public, -d/--draft or -s/--secret, change the
3816 3816 phase value of the specified revisions.
3817 3817
3818 3818 Unless -f/--force is specified, :hg:`phase` won't move changesets from a
3819 3819 lower phase to a higher phase. Phases are ordered as follows::
3820 3820
3821 3821 public < draft < secret
3822 3822
3823 3823 Returns 0 on success, 1 if some phases could not be changed.
3824 3824
3825 3825 (For more information about the phases concept, see :hg:`help phases`.)
3826 3826 """
3827 3827 opts = pycompat.byteskwargs(opts)
3828 3828 # search for a unique phase argument
3829 3829 targetphase = None
3830 3830 for idx, name in enumerate(phases.phasenames):
3831 3831 if opts[name]:
3832 3832 if targetphase is not None:
3833 3833 raise error.Abort(_('only one phase can be specified'))
3834 3834 targetphase = idx
3835 3835
3836 3836 # look for specified revision
3837 3837 revs = list(revs)
3838 3838 revs.extend(opts['rev'])
3839 3839 if not revs:
3840 3840 # display both parents as the second parent phase can influence
3841 3841 # the phase of a merge commit
3842 3842 revs = [c.rev() for c in repo[None].parents()]
3843 3843
3844 3844 revs = scmutil.revrange(repo, revs)
3845 3845
3846 3846 ret = 0
3847 3847 if targetphase is None:
3848 3848 # display
3849 3849 for r in revs:
3850 3850 ctx = repo[r]
3851 3851 ui.write('%i: %s\n' % (ctx.rev(), ctx.phasestr()))
3852 3852 else:
3853 3853 with repo.lock(), repo.transaction("phase") as tr:
3854 3854 # set phase
3855 3855 if not revs:
3856 3856 raise error.Abort(_('empty revision set'))
3857 3857 nodes = [repo[r].node() for r in revs]
3858 3858 # moving revision from public to draft may hide them
3859 3859 # We have to check result on an unfiltered repository
3860 3860 unfi = repo.unfiltered()
3861 3861 getphase = unfi._phasecache.phase
3862 3862 olddata = [getphase(unfi, r) for r in unfi]
3863 3863 phases.advanceboundary(repo, tr, targetphase, nodes)
3864 3864 if opts['force']:
3865 3865 phases.retractboundary(repo, tr, targetphase, nodes)
3866 3866 getphase = unfi._phasecache.phase
3867 3867 newdata = [getphase(unfi, r) for r in unfi]
3868 3868 changes = sum(newdata[r] != olddata[r] for r in unfi)
3869 3869 cl = unfi.changelog
3870 3870 rejected = [n for n in nodes
3871 3871 if newdata[cl.rev(n)] < targetphase]
3872 3872 if rejected:
3873 3873 ui.warn(_('cannot move %i changesets to a higher '
3874 3874 'phase, use --force\n') % len(rejected))
3875 3875 ret = 1
3876 3876 if changes:
3877 3877 msg = _('phase changed for %i changesets\n') % changes
3878 3878 if ret:
3879 3879 ui.status(msg)
3880 3880 else:
3881 3881 ui.note(msg)
3882 3882 else:
3883 3883 ui.warn(_('no phases changed\n'))
3884 3884 return ret
3885 3885
3886 3886 def postincoming(ui, repo, modheads, optupdate, checkout, brev):
3887 3887 """Run after a changegroup has been added via pull/unbundle
3888 3888
3889 3889 This takes arguments below:
3890 3890
3891 3891 :modheads: change of heads by pull/unbundle
3892 3892 :optupdate: updating working directory is needed or not
3893 3893 :checkout: update destination revision (or None to default destination)
3894 3894 :brev: a name, which might be a bookmark to be activated after updating
3895 3895 """
3896 3896 if modheads == 0:
3897 3897 return
3898 3898 if optupdate:
3899 3899 try:
3900 3900 return hg.updatetotally(ui, repo, checkout, brev)
3901 3901 except error.UpdateAbort as inst:
3902 3902 msg = _("not updating: %s") % str(inst)
3903 3903 hint = inst.hint
3904 3904 raise error.UpdateAbort(msg, hint=hint)
3905 3905 if modheads > 1:
3906 3906 currentbranchheads = len(repo.branchheads())
3907 3907 if currentbranchheads == modheads:
3908 3908 ui.status(_("(run 'hg heads' to see heads, 'hg merge' to merge)\n"))
3909 3909 elif currentbranchheads > 1:
3910 3910 ui.status(_("(run 'hg heads .' to see heads, 'hg merge' to "
3911 3911 "merge)\n"))
3912 3912 else:
3913 3913 ui.status(_("(run 'hg heads' to see heads)\n"))
3914 3914 elif not ui.configbool('commands', 'update.requiredest'):
3915 3915 ui.status(_("(run 'hg update' to get a working copy)\n"))
3916 3916
3917 3917 @command('^pull',
3918 3918 [('u', 'update', None,
3919 3919 _('update to new branch head if new descendants were pulled')),
3920 3920 ('f', 'force', None, _('run even when remote repository is unrelated')),
3921 3921 ('r', 'rev', [], _('a remote changeset intended to be added'), _('REV')),
3922 3922 ('B', 'bookmark', [], _("bookmark to pull"), _('BOOKMARK')),
3923 3923 ('b', 'branch', [], _('a specific branch you would like to pull'),
3924 3924 _('BRANCH')),
3925 3925 ] + remoteopts,
3926 3926 _('[-u] [-f] [-r REV]... [-e CMD] [--remotecmd CMD] [SOURCE]'))
3927 3927 def pull(ui, repo, source="default", **opts):
3928 3928 """pull changes from the specified source
3929 3929
3930 3930 Pull changes from a remote repository to a local one.
3931 3931
3932 3932 This finds all changes from the repository at the specified path
3933 3933 or URL and adds them to a local repository (the current one unless
3934 3934 -R is specified). By default, this does not update the copy of the
3935 3935 project in the working directory.
3936 3936
3937 3937 Use :hg:`incoming` if you want to see what would have been added
3938 3938 by a pull at the time you issued this command. If you then decide
3939 3939 to add those changes to the repository, you should use :hg:`pull
3940 3940 -r X` where ``X`` is the last changeset listed by :hg:`incoming`.
3941 3941
3942 3942 If SOURCE is omitted, the 'default' path will be used.
3943 3943 See :hg:`help urls` for more information.
3944 3944
3945 3945 Specifying bookmark as ``.`` is equivalent to specifying the active
3946 3946 bookmark's name.
3947 3947
3948 3948 Returns 0 on success, 1 if an update had unresolved files.
3949 3949 """
3950 3950
3951 3951 opts = pycompat.byteskwargs(opts)
3952 3952 if ui.configbool('commands', 'update.requiredest') and opts.get('update'):
3953 3953 msg = _('update destination required by configuration')
3954 3954 hint = _('use hg pull followed by hg update DEST')
3955 3955 raise error.Abort(msg, hint=hint)
3956 3956
3957 3957 source, branches = hg.parseurl(ui.expandpath(source), opts.get('branch'))
3958 3958 ui.status(_('pulling from %s\n') % util.hidepassword(source))
3959 3959 other = hg.peer(repo, opts, source)
3960 3960 try:
3961 3961 revs, checkout = hg.addbranchrevs(repo, other, branches,
3962 3962 opts.get('rev'))
3963 3963
3964 3964
3965 3965 pullopargs = {}
3966 3966 if opts.get('bookmark'):
3967 3967 if not revs:
3968 3968 revs = []
3969 3969 # The list of bookmark used here is not the one used to actually
3970 3970 # update the bookmark name. This can result in the revision pulled
3971 3971 # not ending up with the name of the bookmark because of a race
3972 3972 # condition on the server. (See issue 4689 for details)
3973 3973 remotebookmarks = other.listkeys('bookmarks')
3974 3974 remotebookmarks = bookmarks.unhexlifybookmarks(remotebookmarks)
3975 3975 pullopargs['remotebookmarks'] = remotebookmarks
3976 3976 for b in opts['bookmark']:
3977 3977 b = repo._bookmarks.expandname(b)
3978 3978 if b not in remotebookmarks:
3979 3979 raise error.Abort(_('remote bookmark %s not found!') % b)
3980 3980 revs.append(hex(remotebookmarks[b]))
3981 3981
3982 3982 if revs:
3983 3983 try:
3984 3984 # When 'rev' is a bookmark name, we cannot guarantee that it
3985 3985 # will be updated with that name because of a race condition
3986 3986 # server side. (See issue 4689 for details)
3987 3987 oldrevs = revs
3988 3988 revs = [] # actually, nodes
3989 3989 for r in oldrevs:
3990 3990 node = other.lookup(r)
3991 3991 revs.append(node)
3992 3992 if r == checkout:
3993 3993 checkout = node
3994 3994 except error.CapabilityError:
3995 3995 err = _("other repository doesn't support revision lookup, "
3996 3996 "so a rev cannot be specified.")
3997 3997 raise error.Abort(err)
3998 3998
3999 3999 wlock = util.nullcontextmanager()
4000 4000 if opts.get('update'):
4001 4001 wlock = repo.wlock()
4002 4002 with wlock:
4003 4003 pullopargs.update(opts.get('opargs', {}))
4004 4004 modheads = exchange.pull(repo, other, heads=revs,
4005 4005 force=opts.get('force'),
4006 4006 bookmarks=opts.get('bookmark', ()),
4007 4007 opargs=pullopargs).cgresult
4008 4008
4009 4009 # brev is a name, which might be a bookmark to be activated at
4010 4010 # the end of the update. In other words, it is an explicit
4011 4011 # destination of the update
4012 4012 brev = None
4013 4013
4014 4014 if checkout:
4015 4015 checkout = str(repo.changelog.rev(checkout))
4016 4016
4017 4017 # order below depends on implementation of
4018 4018 # hg.addbranchrevs(). opts['bookmark'] is ignored,
4019 4019 # because 'checkout' is determined without it.
4020 4020 if opts.get('rev'):
4021 4021 brev = opts['rev'][0]
4022 4022 elif opts.get('branch'):
4023 4023 brev = opts['branch'][0]
4024 4024 else:
4025 4025 brev = branches[0]
4026 4026 repo._subtoppath = source
4027 4027 try:
4028 4028 ret = postincoming(ui, repo, modheads, opts.get('update'),
4029 4029 checkout, brev)
4030 4030
4031 4031 finally:
4032 4032 del repo._subtoppath
4033 4033
4034 4034 finally:
4035 4035 other.close()
4036 4036 return ret
4037 4037
4038 4038 @command('^push',
4039 4039 [('f', 'force', None, _('force push')),
4040 4040 ('r', 'rev', [],
4041 4041 _('a changeset intended to be included in the destination'),
4042 4042 _('REV')),
4043 4043 ('B', 'bookmark', [], _("bookmark to push"), _('BOOKMARK')),
4044 4044 ('b', 'branch', [],
4045 4045 _('a specific branch you would like to push'), _('BRANCH')),
4046 4046 ('', 'new-branch', False, _('allow pushing a new branch')),
4047 4047 ('', 'pushvars', [], _('variables that can be sent to server (ADVANCED)')),
4048 4048 ] + remoteopts,
4049 4049 _('[-f] [-r REV]... [-e CMD] [--remotecmd CMD] [DEST]'))
4050 4050 def push(ui, repo, dest=None, **opts):
4051 4051 """push changes to the specified destination
4052 4052
4053 4053 Push changesets from the local repository to the specified
4054 4054 destination.
4055 4055
4056 4056 This operation is symmetrical to pull: it is identical to a pull
4057 4057 in the destination repository from the current one.
4058 4058
4059 4059 By default, push will not allow creation of new heads at the
4060 4060 destination, since multiple heads would make it unclear which head
4061 4061 to use. In this situation, it is recommended to pull and merge
4062 4062 before pushing.
4063 4063
4064 4064 Use --new-branch if you want to allow push to create a new named
4065 4065 branch that is not present at the destination. This allows you to
4066 4066 only create a new branch without forcing other changes.
4067 4067
4068 4068 .. note::
4069 4069
4070 4070 Extra care should be taken with the -f/--force option,
4071 4071 which will push all new heads on all branches, an action which will
4072 4072 almost always cause confusion for collaborators.
4073 4073
4074 4074 If -r/--rev is used, the specified revision and all its ancestors
4075 4075 will be pushed to the remote repository.
4076 4076
4077 4077 If -B/--bookmark is used, the specified bookmarked revision, its
4078 4078 ancestors, and the bookmark will be pushed to the remote
4079 4079 repository. Specifying ``.`` is equivalent to specifying the active
4080 4080 bookmark's name.
4081 4081
4082 4082 Please see :hg:`help urls` for important details about ``ssh://``
4083 4083 URLs. If DESTINATION is omitted, a default path will be used.
4084 4084
4085 4085 .. container:: verbose
4086 4086
4087 4087 The --pushvars option sends strings to the server that become
4088 4088 environment variables prepended with ``HG_USERVAR_``. For example,
4089 4089 ``--pushvars ENABLE_FEATURE=true``, provides the server side hooks with
4090 4090 ``HG_USERVAR_ENABLE_FEATURE=true`` as part of their environment.
4091 4091
4092 4092 pushvars can provide for user-overridable hooks as well as set debug
4093 4093 levels. One example is having a hook that blocks commits containing
4094 4094 conflict markers, but enables the user to override the hook if the file
4095 4095 is using conflict markers for testing purposes or the file format has
4096 4096 strings that look like conflict markers.
4097 4097
4098 4098 By default, servers will ignore `--pushvars`. To enable it add the
4099 4099 following to your configuration file::
4100 4100
4101 4101 [push]
4102 4102 pushvars.server = true
4103 4103
4104 4104 Returns 0 if push was successful, 1 if nothing to push.
4105 4105 """
4106 4106
4107 4107 opts = pycompat.byteskwargs(opts)
4108 4108 if opts.get('bookmark'):
4109 4109 ui.setconfig('bookmarks', 'pushing', opts['bookmark'], 'push')
4110 4110 for b in opts['bookmark']:
4111 4111 # translate -B options to -r so changesets get pushed
4112 4112 b = repo._bookmarks.expandname(b)
4113 4113 if b in repo._bookmarks:
4114 4114 opts.setdefault('rev', []).append(b)
4115 4115 else:
4116 4116 # if we try to push a deleted bookmark, translate it to null
4117 4117 # this lets simultaneous -r, -b options continue working
4118 4118 opts.setdefault('rev', []).append("null")
4119 4119
4120 4120 path = ui.paths.getpath(dest, default=('default-push', 'default'))
4121 4121 if not path:
4122 4122 raise error.Abort(_('default repository not configured!'),
4123 4123 hint=_("see 'hg help config.paths'"))
4124 4124 dest = path.pushloc or path.loc
4125 4125 branches = (path.branch, opts.get('branch') or [])
4126 4126 ui.status(_('pushing to %s\n') % util.hidepassword(dest))
4127 4127 revs, checkout = hg.addbranchrevs(repo, repo, branches, opts.get('rev'))
4128 4128 other = hg.peer(repo, opts, dest)
4129 4129
4130 4130 if revs:
4131 4131 revs = [repo.lookup(r) for r in scmutil.revrange(repo, revs)]
4132 4132 if not revs:
4133 4133 raise error.Abort(_("specified revisions evaluate to an empty set"),
4134 4134 hint=_("use different revision arguments"))
4135 4135 elif path.pushrev:
4136 4136 # It doesn't make any sense to specify ancestor revisions. So limit
4137 4137 # to DAG heads to make discovery simpler.
4138 4138 expr = revsetlang.formatspec('heads(%r)', path.pushrev)
4139 4139 revs = scmutil.revrange(repo, [expr])
4140 4140 revs = [repo[rev].node() for rev in revs]
4141 4141 if not revs:
4142 4142 raise error.Abort(_('default push revset for path evaluates to an '
4143 4143 'empty set'))
4144 4144
4145 4145 repo._subtoppath = dest
4146 4146 try:
4147 4147 # push subrepos depth-first for coherent ordering
4148 4148 c = repo['']
4149 4149 subs = c.substate # only repos that are committed
4150 4150 for s in sorted(subs):
4151 4151 result = c.sub(s).push(opts)
4152 4152 if result == 0:
4153 4153 return not result
4154 4154 finally:
4155 4155 del repo._subtoppath
4156 4156
4157 4157 opargs = dict(opts.get('opargs', {})) # copy opargs since we may mutate it
4158 4158 opargs.setdefault('pushvars', []).extend(opts.get('pushvars', []))
4159 4159
4160 4160 pushop = exchange.push(repo, other, opts.get('force'), revs=revs,
4161 4161 newbranch=opts.get('new_branch'),
4162 4162 bookmarks=opts.get('bookmark', ()),
4163 4163 opargs=opargs)
4164 4164
4165 4165 result = not pushop.cgresult
4166 4166
4167 4167 if pushop.bkresult is not None:
4168 4168 if pushop.bkresult == 2:
4169 4169 result = 2
4170 4170 elif not result and pushop.bkresult:
4171 4171 result = 2
4172 4172
4173 4173 return result
4174 4174
4175 4175 @command('recover', [])
4176 4176 def recover(ui, repo):
4177 4177 """roll back an interrupted transaction
4178 4178
4179 4179 Recover from an interrupted commit or pull.
4180 4180
4181 4181 This command tries to fix the repository status after an
4182 4182 interrupted operation. It should only be necessary when Mercurial
4183 4183 suggests it.
4184 4184
4185 4185 Returns 0 if successful, 1 if nothing to recover or verify fails.
4186 4186 """
4187 4187 if repo.recover():
4188 4188 return hg.verify(repo)
4189 4189 return 1
4190 4190
4191 4191 @command('^remove|rm',
4192 4192 [('A', 'after', None, _('record delete for missing files')),
4193 4193 ('f', 'force', None,
4194 4194 _('forget added files, delete modified files')),
4195 4195 ] + subrepoopts + walkopts,
4196 4196 _('[OPTION]... FILE...'),
4197 4197 inferrepo=True)
4198 4198 def remove(ui, repo, *pats, **opts):
4199 4199 """remove the specified files on the next commit
4200 4200
4201 4201 Schedule the indicated files for removal from the current branch.
4202 4202
4203 4203 This command schedules the files to be removed at the next commit.
4204 4204 To undo a remove before that, see :hg:`revert`. To undo added
4205 4205 files, see :hg:`forget`.
4206 4206
4207 4207 .. container:: verbose
4208 4208
4209 4209 -A/--after can be used to remove only files that have already
4210 4210 been deleted, -f/--force can be used to force deletion, and -Af
4211 4211 can be used to remove files from the next revision without
4212 4212 deleting them from the working directory.
4213 4213
4214 4214 The following table details the behavior of remove for different
4215 4215 file states (columns) and option combinations (rows). The file
4216 4216 states are Added [A], Clean [C], Modified [M] and Missing [!]
4217 4217 (as reported by :hg:`status`). The actions are Warn, Remove
4218 4218 (from branch) and Delete (from disk):
4219 4219
4220 4220 ========= == == == ==
4221 4221 opt/state A C M !
4222 4222 ========= == == == ==
4223 4223 none W RD W R
4224 4224 -f R RD RD R
4225 4225 -A W W W R
4226 4226 -Af R R R R
4227 4227 ========= == == == ==
4228 4228
4229 4229 .. note::
4230 4230
4231 4231 :hg:`remove` never deletes files in Added [A] state from the
4232 4232 working directory, not even if ``--force`` is specified.
4233 4233
4234 4234 Returns 0 on success, 1 if any warnings encountered.
4235 4235 """
4236 4236
4237 4237 opts = pycompat.byteskwargs(opts)
4238 4238 after, force = opts.get('after'), opts.get('force')
4239 4239 if not pats and not after:
4240 4240 raise error.Abort(_('no files specified'))
4241 4241
4242 4242 m = scmutil.match(repo[None], pats, opts)
4243 4243 subrepos = opts.get('subrepos')
4244 4244 return cmdutil.remove(ui, repo, m, "", after, force, subrepos)
4245 4245
4246 4246 @command('rename|move|mv',
4247 4247 [('A', 'after', None, _('record a rename that has already occurred')),
4248 4248 ('f', 'force', None, _('forcibly copy over an existing managed file')),
4249 4249 ] + walkopts + dryrunopts,
4250 4250 _('[OPTION]... SOURCE... DEST'))
4251 4251 def rename(ui, repo, *pats, **opts):
4252 4252 """rename files; equivalent of copy + remove
4253 4253
4254 4254 Mark dest as copies of sources; mark sources for deletion. If dest
4255 4255 is a directory, copies are put in that directory. If dest is a
4256 4256 file, there can only be one source.
4257 4257
4258 4258 By default, this command copies the contents of files as they
4259 4259 exist in the working directory. If invoked with -A/--after, the
4260 4260 operation is recorded, but no copying is performed.
4261 4261
4262 4262 This command takes effect at the next commit. To undo a rename
4263 4263 before that, see :hg:`revert`.
4264 4264
4265 4265 Returns 0 on success, 1 if errors are encountered.
4266 4266 """
4267 4267 opts = pycompat.byteskwargs(opts)
4268 4268 with repo.wlock(False):
4269 4269 return cmdutil.copy(ui, repo, pats, opts, rename=True)
4270 4270
4271 4271 @command('resolve',
4272 4272 [('a', 'all', None, _('select all unresolved files')),
4273 4273 ('l', 'list', None, _('list state of files needing merge')),
4274 4274 ('m', 'mark', None, _('mark files as resolved')),
4275 4275 ('u', 'unmark', None, _('mark files as unresolved')),
4276 4276 ('n', 'no-status', None, _('hide status prefix'))]
4277 4277 + mergetoolopts + walkopts + formatteropts,
4278 4278 _('[OPTION]... [FILE]...'),
4279 4279 inferrepo=True)
4280 4280 def resolve(ui, repo, *pats, **opts):
4281 4281 """redo merges or set/view the merge status of files
4282 4282
4283 4283 Merges with unresolved conflicts are often the result of
4284 4284 non-interactive merging using the ``internal:merge`` configuration
4285 4285 setting, or a command-line merge tool like ``diff3``. The resolve
4286 4286 command is used to manage the files involved in a merge, after
4287 4287 :hg:`merge` has been run, and before :hg:`commit` is run (i.e. the
4288 4288 working directory must have two parents). See :hg:`help
4289 4289 merge-tools` for information on configuring merge tools.
4290 4290
4291 4291 The resolve command can be used in the following ways:
4292 4292
4293 4293 - :hg:`resolve [--tool TOOL] FILE...`: attempt to re-merge the specified
4294 4294 files, discarding any previous merge attempts. Re-merging is not
4295 4295 performed for files already marked as resolved. Use ``--all/-a``
4296 4296 to select all unresolved files. ``--tool`` can be used to specify
4297 4297 the merge tool used for the given files. It overrides the HGMERGE
4298 4298 environment variable and your configuration files. Previous file
4299 4299 contents are saved with a ``.orig`` suffix.
4300 4300
4301 4301 - :hg:`resolve -m [FILE]`: mark a file as having been resolved
4302 4302 (e.g. after having manually fixed-up the files). The default is
4303 4303 to mark all unresolved files.
4304 4304
4305 4305 - :hg:`resolve -u [FILE]...`: mark a file as unresolved. The
4306 4306 default is to mark all resolved files.
4307 4307
4308 4308 - :hg:`resolve -l`: list files which had or still have conflicts.
4309 4309 In the printed list, ``U`` = unresolved and ``R`` = resolved.
4310 4310 You can use ``set:unresolved()`` or ``set:resolved()`` to filter
4311 4311 the list. See :hg:`help filesets` for details.
4312 4312
4313 4313 .. note::
4314 4314
4315 4315 Mercurial will not let you commit files with unresolved merge
4316 4316 conflicts. You must use :hg:`resolve -m ...` before you can
4317 4317 commit after a conflicting merge.
4318 4318
4319 4319 Returns 0 on success, 1 if any files fail a resolve attempt.
4320 4320 """
4321 4321
4322 4322 opts = pycompat.byteskwargs(opts)
4323 4323 flaglist = 'all mark unmark list no_status'.split()
4324 4324 all, mark, unmark, show, nostatus = \
4325 4325 [opts.get(o) for o in flaglist]
4326 4326
4327 4327 if (show and (mark or unmark)) or (mark and unmark):
4328 4328 raise error.Abort(_("too many options specified"))
4329 4329 if pats and all:
4330 4330 raise error.Abort(_("can't specify --all and patterns"))
4331 4331 if not (all or pats or show or mark or unmark):
4332 4332 raise error.Abort(_('no files or directories specified'),
4333 4333 hint=('use --all to re-merge all unresolved files'))
4334 4334
4335 4335 if show:
4336 4336 ui.pager('resolve')
4337 4337 fm = ui.formatter('resolve', opts)
4338 4338 ms = mergemod.mergestate.read(repo)
4339 4339 m = scmutil.match(repo[None], pats, opts)
4340 4340
4341 4341 # Labels and keys based on merge state. Unresolved path conflicts show
4342 4342 # as 'P'. Resolved path conflicts show as 'R', the same as normal
4343 4343 # resolved conflicts.
4344 4344 mergestateinfo = {
4345 4345 'u': ('resolve.unresolved', 'U'),
4346 4346 'r': ('resolve.resolved', 'R'),
4347 4347 'pu': ('resolve.unresolved', 'P'),
4348 4348 'pr': ('resolve.resolved', 'R'),
4349 4349 'd': ('resolve.driverresolved', 'D'),
4350 4350 }
4351 4351
4352 4352 for f in ms:
4353 4353 if not m(f):
4354 4354 continue
4355 4355
4356 4356 label, key = mergestateinfo[ms[f]]
4357 4357 fm.startitem()
4358 4358 fm.condwrite(not nostatus, 'status', '%s ', key, label=label)
4359 4359 fm.write('path', '%s\n', f, label=label)
4360 4360 fm.end()
4361 4361 return 0
4362 4362
4363 4363 with repo.wlock():
4364 4364 ms = mergemod.mergestate.read(repo)
4365 4365
4366 4366 if not (ms.active() or repo.dirstate.p2() != nullid):
4367 4367 raise error.Abort(
4368 4368 _('resolve command not applicable when not merging'))
4369 4369
4370 4370 wctx = repo[None]
4371 4371
4372 4372 if ms.mergedriver and ms.mdstate() == 'u':
4373 4373 proceed = mergemod.driverpreprocess(repo, ms, wctx)
4374 4374 ms.commit()
4375 4375 # allow mark and unmark to go through
4376 4376 if not mark and not unmark and not proceed:
4377 4377 return 1
4378 4378
4379 4379 m = scmutil.match(wctx, pats, opts)
4380 4380 ret = 0
4381 4381 didwork = False
4382 4382 runconclude = False
4383 4383
4384 4384 tocomplete = []
4385 4385 for f in ms:
4386 4386 if not m(f):
4387 4387 continue
4388 4388
4389 4389 didwork = True
4390 4390
4391 4391 # don't let driver-resolved files be marked, and run the conclude
4392 4392 # step if asked to resolve
4393 4393 if ms[f] == "d":
4394 4394 exact = m.exact(f)
4395 4395 if mark:
4396 4396 if exact:
4397 4397 ui.warn(_('not marking %s as it is driver-resolved\n')
4398 4398 % f)
4399 4399 elif unmark:
4400 4400 if exact:
4401 4401 ui.warn(_('not unmarking %s as it is driver-resolved\n')
4402 4402 % f)
4403 4403 else:
4404 4404 runconclude = True
4405 4405 continue
4406 4406
4407 4407 # path conflicts must be resolved manually
4408 4408 if ms[f] in ("pu", "pr"):
4409 4409 if mark:
4410 4410 ms.mark(f, "pr")
4411 4411 elif unmark:
4412 4412 ms.mark(f, "pu")
4413 4413 elif ms[f] == "pu":
4414 4414 ui.warn(_('%s: path conflict must be resolved manually\n')
4415 4415 % f)
4416 4416 continue
4417 4417
4418 4418 if mark:
4419 4419 ms.mark(f, "r")
4420 4420 elif unmark:
4421 4421 ms.mark(f, "u")
4422 4422 else:
4423 4423 # backup pre-resolve (merge uses .orig for its own purposes)
4424 4424 a = repo.wjoin(f)
4425 4425 try:
4426 4426 util.copyfile(a, a + ".resolve")
4427 4427 except (IOError, OSError) as inst:
4428 4428 if inst.errno != errno.ENOENT:
4429 4429 raise
4430 4430
4431 4431 try:
4432 4432 # preresolve file
4433 4433 ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
4434 4434 'resolve')
4435 4435 complete, r = ms.preresolve(f, wctx)
4436 4436 if not complete:
4437 4437 tocomplete.append(f)
4438 4438 elif r:
4439 4439 ret = 1
4440 4440 finally:
4441 4441 ui.setconfig('ui', 'forcemerge', '', 'resolve')
4442 4442 ms.commit()
4443 4443
4444 4444 # replace filemerge's .orig file with our resolve file, but only
4445 4445 # for merges that are complete
4446 4446 if complete:
4447 4447 try:
4448 4448 util.rename(a + ".resolve",
4449 4449 scmutil.origpath(ui, repo, a))
4450 4450 except OSError as inst:
4451 4451 if inst.errno != errno.ENOENT:
4452 4452 raise
4453 4453
4454 4454 for f in tocomplete:
4455 4455 try:
4456 4456 # resolve file
4457 4457 ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
4458 4458 'resolve')
4459 4459 r = ms.resolve(f, wctx)
4460 4460 if r:
4461 4461 ret = 1
4462 4462 finally:
4463 4463 ui.setconfig('ui', 'forcemerge', '', 'resolve')
4464 4464 ms.commit()
4465 4465
4466 4466 # replace filemerge's .orig file with our resolve file
4467 4467 a = repo.wjoin(f)
4468 4468 try:
4469 4469 util.rename(a + ".resolve", scmutil.origpath(ui, repo, a))
4470 4470 except OSError as inst:
4471 4471 if inst.errno != errno.ENOENT:
4472 4472 raise
4473 4473
4474 4474 ms.commit()
4475 4475 ms.recordactions()
4476 4476
4477 4477 if not didwork and pats:
4478 4478 hint = None
4479 4479 if not any([p for p in pats if p.find(':') >= 0]):
4480 4480 pats = ['path:%s' % p for p in pats]
4481 4481 m = scmutil.match(wctx, pats, opts)
4482 4482 for f in ms:
4483 4483 if not m(f):
4484 4484 continue
4485 4485 flags = ''.join(['-%s ' % o[0] for o in flaglist
4486 4486 if opts.get(o)])
4487 4487 hint = _("(try: hg resolve %s%s)\n") % (
4488 4488 flags,
4489 4489 ' '.join(pats))
4490 4490 break
4491 4491 ui.warn(_("arguments do not match paths that need resolving\n"))
4492 4492 if hint:
4493 4493 ui.warn(hint)
4494 4494 elif ms.mergedriver and ms.mdstate() != 's':
4495 4495 # run conclude step when either a driver-resolved file is requested
4496 4496 # or there are no driver-resolved files
4497 4497 # we can't use 'ret' to determine whether any files are unresolved
4498 4498 # because we might not have tried to resolve some
4499 4499 if ((runconclude or not list(ms.driverresolved()))
4500 4500 and not list(ms.unresolved())):
4501 4501 proceed = mergemod.driverconclude(repo, ms, wctx)
4502 4502 ms.commit()
4503 4503 if not proceed:
4504 4504 return 1
4505 4505
4506 4506 # Nudge users into finishing an unfinished operation
4507 4507 unresolvedf = list(ms.unresolved())
4508 4508 driverresolvedf = list(ms.driverresolved())
4509 4509 if not unresolvedf and not driverresolvedf:
4510 4510 ui.status(_('(no more unresolved files)\n'))
4511 4511 cmdutil.checkafterresolved(repo)
4512 4512 elif not unresolvedf:
4513 4513 ui.status(_('(no more unresolved files -- '
4514 4514 'run "hg resolve --all" to conclude)\n'))
4515 4515
4516 4516 return ret
4517 4517
4518 4518 @command('revert',
4519 4519 [('a', 'all', None, _('revert all changes when no arguments given')),
4520 4520 ('d', 'date', '', _('tipmost revision matching date'), _('DATE')),
4521 4521 ('r', 'rev', '', _('revert to the specified revision'), _('REV')),
4522 4522 ('C', 'no-backup', None, _('do not save backup copies of files')),
4523 4523 ('i', 'interactive', None, _('interactively select the changes')),
4524 4524 ] + walkopts + dryrunopts,
4525 4525 _('[OPTION]... [-r REV] [NAME]...'))
4526 4526 def revert(ui, repo, *pats, **opts):
4527 4527 """restore files to their checkout state
4528 4528
4529 4529 .. note::
4530 4530
4531 4531 To check out earlier revisions, you should use :hg:`update REV`.
4532 4532 To cancel an uncommitted merge (and lose your changes),
4533 4533 use :hg:`merge --abort`.
4534 4534
4535 4535 With no revision specified, revert the specified files or directories
4536 4536 to the contents they had in the parent of the working directory.
4537 4537 This restores the contents of files to an unmodified
4538 4538 state and unschedules adds, removes, copies, and renames. If the
4539 4539 working directory has two parents, you must explicitly specify a
4540 4540 revision.
4541 4541
4542 4542 Using the -r/--rev or -d/--date options, revert the given files or
4543 4543 directories to their states as of a specific revision. Because
4544 4544 revert does not change the working directory parents, this will
4545 4545 cause these files to appear modified. This can be helpful to "back
4546 4546 out" some or all of an earlier change. See :hg:`backout` for a
4547 4547 related method.
4548 4548
4549 4549 Modified files are saved with a .orig suffix before reverting.
4550 4550 To disable these backups, use --no-backup. It is possible to store
4551 4551 the backup files in a custom directory relative to the root of the
4552 4552 repository by setting the ``ui.origbackuppath`` configuration
4553 4553 option.
4554 4554
4555 4555 See :hg:`help dates` for a list of formats valid for -d/--date.
4556 4556
4557 4557 See :hg:`help backout` for a way to reverse the effect of an
4558 4558 earlier changeset.
4559 4559
4560 4560 Returns 0 on success.
4561 4561 """
4562 4562
4563 4563 opts = pycompat.byteskwargs(opts)
4564 4564 if opts.get("date"):
4565 4565 if opts.get("rev"):
4566 4566 raise error.Abort(_("you can't specify a revision and a date"))
4567 4567 opts["rev"] = cmdutil.finddate(ui, repo, opts["date"])
4568 4568
4569 4569 parent, p2 = repo.dirstate.parents()
4570 4570 if not opts.get('rev') and p2 != nullid:
4571 4571 # revert after merge is a trap for new users (issue2915)
4572 4572 raise error.Abort(_('uncommitted merge with no revision specified'),
4573 4573 hint=_("use 'hg update' or see 'hg help revert'"))
4574 4574
4575 4575 rev = opts.get('rev')
4576 4576 if rev:
4577 4577 repo = scmutil.unhidehashlikerevs(repo, [rev], 'nowarn')
4578 4578 ctx = scmutil.revsingle(repo, rev)
4579 4579
4580 4580 if (not (pats or opts.get('include') or opts.get('exclude') or
4581 4581 opts.get('all') or opts.get('interactive'))):
4582 4582 msg = _("no files or directories specified")
4583 4583 if p2 != nullid:
4584 4584 hint = _("uncommitted merge, use --all to discard all changes,"
4585 4585 " or 'hg update -C .' to abort the merge")
4586 4586 raise error.Abort(msg, hint=hint)
4587 4587 dirty = any(repo.status())
4588 4588 node = ctx.node()
4589 4589 if node != parent:
4590 4590 if dirty:
4591 4591 hint = _("uncommitted changes, use --all to discard all"
4592 4592 " changes, or 'hg update %s' to update") % ctx.rev()
4593 4593 else:
4594 4594 hint = _("use --all to revert all files,"
4595 4595 " or 'hg update %s' to update") % ctx.rev()
4596 4596 elif dirty:
4597 4597 hint = _("uncommitted changes, use --all to discard all changes")
4598 4598 else:
4599 4599 hint = _("use --all to revert all files")
4600 4600 raise error.Abort(msg, hint=hint)
4601 4601
4602 4602 return cmdutil.revert(ui, repo, ctx, (parent, p2), *pats,
4603 4603 **pycompat.strkwargs(opts))
4604 4604
4605 4605 @command('rollback', dryrunopts +
4606 4606 [('f', 'force', False, _('ignore safety measures'))])
4607 4607 def rollback(ui, repo, **opts):
4608 4608 """roll back the last transaction (DANGEROUS) (DEPRECATED)
4609 4609
4610 4610 Please use :hg:`commit --amend` instead of rollback to correct
4611 4611 mistakes in the last commit.
4612 4612
4613 4613 This command should be used with care. There is only one level of
4614 4614 rollback, and there is no way to undo a rollback. It will also
4615 4615 restore the dirstate at the time of the last transaction, losing
4616 4616 any dirstate changes since that time. This command does not alter
4617 4617 the working directory.
4618 4618
4619 4619 Transactions are used to encapsulate the effects of all commands
4620 4620 that create new changesets or propagate existing changesets into a
4621 4621 repository.
4622 4622
4623 4623 .. container:: verbose
4624 4624
4625 4625 For example, the following commands are transactional, and their
4626 4626 effects can be rolled back:
4627 4627
4628 4628 - commit
4629 4629 - import
4630 4630 - pull
4631 4631 - push (with this repository as the destination)
4632 4632 - unbundle
4633 4633
4634 4634 To avoid permanent data loss, rollback will refuse to rollback a
4635 4635 commit transaction if it isn't checked out. Use --force to
4636 4636 override this protection.
4637 4637
4638 4638 The rollback command can be entirely disabled by setting the
4639 4639 ``ui.rollback`` configuration setting to false. If you're here
4640 4640 because you want to use rollback and it's disabled, you can
4641 4641 re-enable the command by setting ``ui.rollback`` to true.
4642 4642
4643 4643 This command is not intended for use on public repositories. Once
4644 4644 changes are visible for pull by other users, rolling a transaction
4645 4645 back locally is ineffective (someone else may already have pulled
4646 4646 the changes). Furthermore, a race is possible with readers of the
4647 4647 repository; for example an in-progress pull from the repository
4648 4648 may fail if a rollback is performed.
4649 4649
4650 4650 Returns 0 on success, 1 if no rollback data is available.
4651 4651 """
4652 4652 if not ui.configbool('ui', 'rollback'):
4653 4653 raise error.Abort(_('rollback is disabled because it is unsafe'),
4654 4654 hint=('see `hg help -v rollback` for information'))
4655 4655 return repo.rollback(dryrun=opts.get(r'dry_run'),
4656 4656 force=opts.get(r'force'))
4657 4657
4658 4658 @command('root', [], cmdtype=readonly)
4659 4659 def root(ui, repo):
4660 4660 """print the root (top) of the current working directory
4661 4661
4662 4662 Print the root directory of the current repository.
4663 4663
4664 4664 Returns 0 on success.
4665 4665 """
4666 4666 ui.write(repo.root + "\n")
4667 4667
4668 4668 @command('^serve',
4669 4669 [('A', 'accesslog', '', _('name of access log file to write to'),
4670 4670 _('FILE')),
4671 4671 ('d', 'daemon', None, _('run server in background')),
4672 4672 ('', 'daemon-postexec', [], _('used internally by daemon mode')),
4673 4673 ('E', 'errorlog', '', _('name of error log file to write to'), _('FILE')),
4674 4674 # use string type, then we can check if something was passed
4675 4675 ('p', 'port', '', _('port to listen on (default: 8000)'), _('PORT')),
4676 4676 ('a', 'address', '', _('address to listen on (default: all interfaces)'),
4677 4677 _('ADDR')),
4678 4678 ('', 'prefix', '', _('prefix path to serve from (default: server root)'),
4679 4679 _('PREFIX')),
4680 4680 ('n', 'name', '',
4681 4681 _('name to show in web pages (default: working directory)'), _('NAME')),
4682 4682 ('', 'web-conf', '',
4683 4683 _("name of the hgweb config file (see 'hg help hgweb')"), _('FILE')),
4684 4684 ('', 'webdir-conf', '', _('name of the hgweb config file (DEPRECATED)'),
4685 4685 _('FILE')),
4686 4686 ('', 'pid-file', '', _('name of file to write process ID to'), _('FILE')),
4687 4687 ('', 'stdio', None, _('for remote clients (ADVANCED)')),
4688 4688 ('', 'cmdserver', '', _('for remote clients (ADVANCED)'), _('MODE')),
4689 4689 ('t', 'templates', '', _('web templates to use'), _('TEMPLATE')),
4690 4690 ('', 'style', '', _('template style to use'), _('STYLE')),
4691 4691 ('6', 'ipv6', None, _('use IPv6 in addition to IPv4')),
4692 4692 ('', 'certificate', '', _('SSL certificate file'), _('FILE'))]
4693 4693 + subrepoopts,
4694 4694 _('[OPTION]...'),
4695 4695 optionalrepo=True)
4696 4696 def serve(ui, repo, **opts):
4697 4697 """start stand-alone webserver
4698 4698
4699 4699 Start a local HTTP repository browser and pull server. You can use
4700 4700 this for ad-hoc sharing and browsing of repositories. It is
4701 4701 recommended to use a real web server to serve a repository for
4702 4702 longer periods of time.
4703 4703
4704 4704 Please note that the server does not implement access control.
4705 4705 This means that, by default, anybody can read from the server and
4706 4706 nobody can write to it by default. Set the ``web.allow-push``
4707 4707 option to ``*`` to allow everybody to push to the server. You
4708 4708 should use a real web server if you need to authenticate users.
4709 4709
4710 4710 By default, the server logs accesses to stdout and errors to
4711 4711 stderr. Use the -A/--accesslog and -E/--errorlog options to log to
4712 4712 files.
4713 4713
4714 4714 To have the server choose a free port number to listen on, specify
4715 4715 a port number of 0; in this case, the server will print the port
4716 4716 number it uses.
4717 4717
4718 4718 Returns 0 on success.
4719 4719 """
4720 4720
4721 4721 opts = pycompat.byteskwargs(opts)
4722 4722 if opts["stdio"] and opts["cmdserver"]:
4723 4723 raise error.Abort(_("cannot use --stdio with --cmdserver"))
4724 4724
4725 4725 if opts["stdio"]:
4726 4726 if repo is None:
4727 4727 raise error.RepoError(_("there is no Mercurial repository here"
4728 4728 " (.hg not found)"))
4729 4729 s = wireprotoserver.sshserver(ui, repo)
4730 4730 s.serve_forever()
4731 4731
4732 4732 service = server.createservice(ui, repo, opts)
4733 4733 return server.runservice(opts, initfn=service.init, runfn=service.run)
4734 4734
4735 4735 @command('^status|st',
4736 4736 [('A', 'all', None, _('show status of all files')),
4737 4737 ('m', 'modified', None, _('show only modified files')),
4738 4738 ('a', 'added', None, _('show only added files')),
4739 4739 ('r', 'removed', None, _('show only removed files')),
4740 4740 ('d', 'deleted', None, _('show only deleted (but tracked) files')),
4741 4741 ('c', 'clean', None, _('show only files without changes')),
4742 4742 ('u', 'unknown', None, _('show only unknown (not tracked) files')),
4743 4743 ('i', 'ignored', None, _('show only ignored files')),
4744 4744 ('n', 'no-status', None, _('hide status prefix')),
4745 4745 ('t', 'terse', '', _('show the terse output (EXPERIMENTAL)')),
4746 4746 ('C', 'copies', None, _('show source of copied files')),
4747 4747 ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
4748 4748 ('', 'rev', [], _('show difference from revision'), _('REV')),
4749 4749 ('', 'change', '', _('list the changed files of a revision'), _('REV')),
4750 4750 ] + walkopts + subrepoopts + formatteropts,
4751 4751 _('[OPTION]... [FILE]...'),
4752 4752 inferrepo=True, cmdtype=readonly)
4753 4753 def status(ui, repo, *pats, **opts):
4754 4754 """show changed files in the working directory
4755 4755
4756 4756 Show status of files in the repository. If names are given, only
4757 4757 files that match are shown. Files that are clean or ignored or
4758 4758 the source of a copy/move operation, are not listed unless
4759 4759 -c/--clean, -i/--ignored, -C/--copies or -A/--all are given.
4760 4760 Unless options described with "show only ..." are given, the
4761 4761 options -mardu are used.
4762 4762
4763 4763 Option -q/--quiet hides untracked (unknown and ignored) files
4764 4764 unless explicitly requested with -u/--unknown or -i/--ignored.
4765 4765
4766 4766 .. note::
4767 4767
4768 4768 :hg:`status` may appear to disagree with diff if permissions have
4769 4769 changed or a merge has occurred. The standard diff format does
4770 4770 not report permission changes and diff only reports changes
4771 4771 relative to one merge parent.
4772 4772
4773 4773 If one revision is given, it is used as the base revision.
4774 4774 If two revisions are given, the differences between them are
4775 4775 shown. The --change option can also be used as a shortcut to list
4776 4776 the changed files of a revision from its first parent.
4777 4777
4778 4778 The codes used to show the status of files are::
4779 4779
4780 4780 M = modified
4781 4781 A = added
4782 4782 R = removed
4783 4783 C = clean
4784 4784 ! = missing (deleted by non-hg command, but still tracked)
4785 4785 ? = not tracked
4786 4786 I = ignored
4787 4787 = origin of the previous file (with --copies)
4788 4788
4789 4789 .. container:: verbose
4790 4790
4791 4791 The -t/--terse option abbreviates the output by showing only the directory
4792 4792 name if all the files in it share the same status. The option takes an
4793 4793 argument indicating the statuses to abbreviate: 'm' for 'modified', 'a'
4794 4794 for 'added', 'r' for 'removed', 'd' for 'deleted', 'u' for 'unknown', 'i'
4795 4795 for 'ignored' and 'c' for clean.
4796 4796
4797 4797 It abbreviates only those statuses which are passed. Note that clean and
4798 4798 ignored files are not displayed with '--terse ic' unless the -c/--clean
4799 4799 and -i/--ignored options are also used.
4800 4800
4801 4801 The -v/--verbose option shows information when the repository is in an
4802 4802 unfinished merge, shelve, rebase state etc. You can have this behavior
4803 4803 turned on by default by enabling the ``commands.status.verbose`` option.
4804 4804
4805 4805 You can skip displaying some of these states by setting
4806 4806 ``commands.status.skipstates`` to one or more of: 'bisect', 'graft',
4807 4807 'histedit', 'merge', 'rebase', or 'unshelve'.
4808 4808
4809 4809 Examples:
4810 4810
4811 4811 - show changes in the working directory relative to a
4812 4812 changeset::
4813 4813
4814 4814 hg status --rev 9353
4815 4815
4816 4816 - show changes in the working directory relative to the
4817 4817 current directory (see :hg:`help patterns` for more information)::
4818 4818
4819 4819 hg status re:
4820 4820
4821 4821 - show all changes including copies in an existing changeset::
4822 4822
4823 4823 hg status --copies --change 9353
4824 4824
4825 4825 - get a NUL separated list of added files, suitable for xargs::
4826 4826
4827 4827 hg status -an0
4828 4828
4829 4829 - show more information about the repository status, abbreviating
4830 4830 added, removed, modified, deleted, and untracked paths::
4831 4831
4832 4832 hg status -v -t mardu
4833 4833
4834 4834 Returns 0 on success.
4835 4835
4836 4836 """
4837 4837
4838 4838 opts = pycompat.byteskwargs(opts)
4839 4839 revs = opts.get('rev')
4840 4840 change = opts.get('change')
4841 4841 terse = opts.get('terse')
4842 4842
4843 4843 if revs and change:
4844 4844 msg = _('cannot specify --rev and --change at the same time')
4845 4845 raise error.Abort(msg)
4846 4846 elif revs and terse:
4847 4847 msg = _('cannot use --terse with --rev')
4848 4848 raise error.Abort(msg)
4849 4849 elif change:
4850 4850 repo = scmutil.unhidehashlikerevs(repo, [change], 'nowarn')
4851 4851 node2 = scmutil.revsingle(repo, change, None).node()
4852 4852 node1 = repo[node2].p1().node()
4853 4853 else:
4854 4854 repo = scmutil.unhidehashlikerevs(repo, revs, 'nowarn')
4855 4855 node1, node2 = scmutil.revpair(repo, revs)
4856 4856
4857 4857 if pats or ui.configbool('commands', 'status.relative'):
4858 4858 cwd = repo.getcwd()
4859 4859 else:
4860 4860 cwd = ''
4861 4861
4862 4862 if opts.get('print0'):
4863 4863 end = '\0'
4864 4864 else:
4865 4865 end = '\n'
4866 4866 copy = {}
4867 4867 states = 'modified added removed deleted unknown ignored clean'.split()
4868 4868 show = [k for k in states if opts.get(k)]
4869 4869 if opts.get('all'):
4870 4870 show += ui.quiet and (states[:4] + ['clean']) or states
4871 4871
4872 4872 if not show:
4873 4873 if ui.quiet:
4874 4874 show = states[:4]
4875 4875 else:
4876 4876 show = states[:5]
4877 4877
4878 4878 m = scmutil.match(repo[node2], pats, opts)
4879 4879 if terse:
4880 4880 # we need to compute clean and unknown to terse
4881 4881 stat = repo.status(node1, node2, m,
4882 4882 'ignored' in show or 'i' in terse,
4883 4883 True, True, opts.get('subrepos'))
4884 4884
4885 4885 stat = cmdutil.tersedir(stat, terse)
4886 4886 else:
4887 4887 stat = repo.status(node1, node2, m,
4888 4888 'ignored' in show, 'clean' in show,
4889 4889 'unknown' in show, opts.get('subrepos'))
4890 4890
4891 4891 changestates = zip(states, pycompat.iterbytestr('MAR!?IC'), stat)
4892 4892
4893 4893 if (opts.get('all') or opts.get('copies')
4894 4894 or ui.configbool('ui', 'statuscopies')) and not opts.get('no_status'):
4895 4895 copy = copies.pathcopies(repo[node1], repo[node2], m)
4896 4896
4897 4897 ui.pager('status')
4898 4898 fm = ui.formatter('status', opts)
4899 4899 fmt = '%s' + end
4900 4900 showchar = not opts.get('no_status')
4901 4901
4902 4902 for state, char, files in changestates:
4903 4903 if state in show:
4904 4904 label = 'status.' + state
4905 4905 for f in files:
4906 4906 fm.startitem()
4907 4907 fm.condwrite(showchar, 'status', '%s ', char, label=label)
4908 4908 fm.write('path', fmt, repo.pathto(f, cwd), label=label)
4909 4909 if f in copy:
4910 4910 fm.write("copy", ' %s' + end, repo.pathto(copy[f], cwd),
4911 4911 label='status.copied')
4912 4912
4913 4913 if ((ui.verbose or ui.configbool('commands', 'status.verbose'))
4914 4914 and not ui.plain()):
4915 4915 cmdutil.morestatus(repo, fm)
4916 4916 fm.end()
4917 4917
4918 4918 @command('^summary|sum',
4919 4919 [('', 'remote', None, _('check for push and pull'))],
4920 4920 '[--remote]', cmdtype=readonly)
4921 4921 def summary(ui, repo, **opts):
4922 4922 """summarize working directory state
4923 4923
4924 4924 This generates a brief summary of the working directory state,
4925 4925 including parents, branch, commit status, phase and available updates.
4926 4926
4927 4927 With the --remote option, this will check the default paths for
4928 4928 incoming and outgoing changes. This can be time-consuming.
4929 4929
4930 4930 Returns 0 on success.
4931 4931 """
4932 4932
4933 4933 opts = pycompat.byteskwargs(opts)
4934 4934 ui.pager('summary')
4935 4935 ctx = repo[None]
4936 4936 parents = ctx.parents()
4937 4937 pnode = parents[0].node()
4938 4938 marks = []
4939 4939
4940 4940 ms = None
4941 4941 try:
4942 4942 ms = mergemod.mergestate.read(repo)
4943 4943 except error.UnsupportedMergeRecords as e:
4944 4944 s = ' '.join(e.recordtypes)
4945 4945 ui.warn(
4946 4946 _('warning: merge state has unsupported record types: %s\n') % s)
4947 4947 unresolved = []
4948 4948 else:
4949 4949 unresolved = list(ms.unresolved())
4950 4950
4951 4951 for p in parents:
4952 4952 # label with log.changeset (instead of log.parent) since this
4953 4953 # shows a working directory parent *changeset*:
4954 4954 # i18n: column positioning for "hg summary"
4955 4955 ui.write(_('parent: %d:%s ') % (p.rev(), p),
4956 4956 label=logcmdutil.changesetlabels(p))
4957 4957 ui.write(' '.join(p.tags()), label='log.tag')
4958 4958 if p.bookmarks():
4959 4959 marks.extend(p.bookmarks())
4960 4960 if p.rev() == -1:
4961 4961 if not len(repo):
4962 4962 ui.write(_(' (empty repository)'))
4963 4963 else:
4964 4964 ui.write(_(' (no revision checked out)'))
4965 4965 if p.obsolete():
4966 4966 ui.write(_(' (obsolete)'))
4967 4967 if p.isunstable():
4968 4968 instabilities = (ui.label(instability, 'trouble.%s' % instability)
4969 4969 for instability in p.instabilities())
4970 4970 ui.write(' ('
4971 4971 + ', '.join(instabilities)
4972 4972 + ')')
4973 4973 ui.write('\n')
4974 4974 if p.description():
4975 4975 ui.status(' ' + p.description().splitlines()[0].strip() + '\n',
4976 4976 label='log.summary')
4977 4977
4978 4978 branch = ctx.branch()
4979 4979 bheads = repo.branchheads(branch)
4980 4980 # i18n: column positioning for "hg summary"
4981 4981 m = _('branch: %s\n') % branch
4982 4982 if branch != 'default':
4983 4983 ui.write(m, label='log.branch')
4984 4984 else:
4985 4985 ui.status(m, label='log.branch')
4986 4986
4987 4987 if marks:
4988 4988 active = repo._activebookmark
4989 4989 # i18n: column positioning for "hg summary"
4990 4990 ui.write(_('bookmarks:'), label='log.bookmark')
4991 4991 if active is not None:
4992 4992 if active in marks:
4993 4993 ui.write(' *' + active, label=bookmarks.activebookmarklabel)
4994 4994 marks.remove(active)
4995 4995 else:
4996 4996 ui.write(' [%s]' % active, label=bookmarks.activebookmarklabel)
4997 4997 for m in marks:
4998 4998 ui.write(' ' + m, label='log.bookmark')
4999 4999 ui.write('\n', label='log.bookmark')
5000 5000
5001 5001 status = repo.status(unknown=True)
5002 5002
5003 5003 c = repo.dirstate.copies()
5004 5004 copied, renamed = [], []
5005 5005 for d, s in c.iteritems():
5006 5006 if s in status.removed:
5007 5007 status.removed.remove(s)
5008 5008 renamed.append(d)
5009 5009 else:
5010 5010 copied.append(d)
5011 5011 if d in status.added:
5012 5012 status.added.remove(d)
5013 5013
5014 5014 subs = [s for s in ctx.substate if ctx.sub(s).dirty()]
5015 5015
5016 5016 labels = [(ui.label(_('%d modified'), 'status.modified'), status.modified),
5017 5017 (ui.label(_('%d added'), 'status.added'), status.added),
5018 5018 (ui.label(_('%d removed'), 'status.removed'), status.removed),
5019 5019 (ui.label(_('%d renamed'), 'status.copied'), renamed),
5020 5020 (ui.label(_('%d copied'), 'status.copied'), copied),
5021 5021 (ui.label(_('%d deleted'), 'status.deleted'), status.deleted),
5022 5022 (ui.label(_('%d unknown'), 'status.unknown'), status.unknown),
5023 5023 (ui.label(_('%d unresolved'), 'resolve.unresolved'), unresolved),
5024 5024 (ui.label(_('%d subrepos'), 'status.modified'), subs)]
5025 5025 t = []
5026 5026 for l, s in labels:
5027 5027 if s:
5028 5028 t.append(l % len(s))
5029 5029
5030 5030 t = ', '.join(t)
5031 5031 cleanworkdir = False
5032 5032
5033 5033 if repo.vfs.exists('graftstate'):
5034 5034 t += _(' (graft in progress)')
5035 5035 if repo.vfs.exists('updatestate'):
5036 5036 t += _(' (interrupted update)')
5037 5037 elif len(parents) > 1:
5038 5038 t += _(' (merge)')
5039 5039 elif branch != parents[0].branch():
5040 5040 t += _(' (new branch)')
5041 5041 elif (parents[0].closesbranch() and
5042 5042 pnode in repo.branchheads(branch, closed=True)):
5043 5043 t += _(' (head closed)')
5044 5044 elif not (status.modified or status.added or status.removed or renamed or
5045 5045 copied or subs):
5046 5046 t += _(' (clean)')
5047 5047 cleanworkdir = True
5048 5048 elif pnode not in bheads:
5049 5049 t += _(' (new branch head)')
5050 5050
5051 5051 if parents:
5052 5052 pendingphase = max(p.phase() for p in parents)
5053 5053 else:
5054 5054 pendingphase = phases.public
5055 5055
5056 5056 if pendingphase > phases.newcommitphase(ui):
5057 5057 t += ' (%s)' % phases.phasenames[pendingphase]
5058 5058
5059 5059 if cleanworkdir:
5060 5060 # i18n: column positioning for "hg summary"
5061 5061 ui.status(_('commit: %s\n') % t.strip())
5062 5062 else:
5063 5063 # i18n: column positioning for "hg summary"
5064 5064 ui.write(_('commit: %s\n') % t.strip())
5065 5065
5066 5066 # all ancestors of branch heads - all ancestors of parent = new csets
5067 5067 new = len(repo.changelog.findmissing([pctx.node() for pctx in parents],
5068 5068 bheads))
5069 5069
5070 5070 if new == 0:
5071 5071 # i18n: column positioning for "hg summary"
5072 5072 ui.status(_('update: (current)\n'))
5073 5073 elif pnode not in bheads:
5074 5074 # i18n: column positioning for "hg summary"
5075 5075 ui.write(_('update: %d new changesets (update)\n') % new)
5076 5076 else:
5077 5077 # i18n: column positioning for "hg summary"
5078 5078 ui.write(_('update: %d new changesets, %d branch heads (merge)\n') %
5079 5079 (new, len(bheads)))
5080 5080
5081 5081 t = []
5082 5082 draft = len(repo.revs('draft()'))
5083 5083 if draft:
5084 5084 t.append(_('%d draft') % draft)
5085 5085 secret = len(repo.revs('secret()'))
5086 5086 if secret:
5087 5087 t.append(_('%d secret') % secret)
5088 5088
5089 5089 if draft or secret:
5090 5090 ui.status(_('phases: %s\n') % ', '.join(t))
5091 5091
5092 5092 if obsolete.isenabled(repo, obsolete.createmarkersopt):
5093 5093 for trouble in ("orphan", "contentdivergent", "phasedivergent"):
5094 5094 numtrouble = len(repo.revs(trouble + "()"))
5095 5095 # We write all the possibilities to ease translation
5096 5096 troublemsg = {
5097 5097 "orphan": _("orphan: %d changesets"),
5098 5098 "contentdivergent": _("content-divergent: %d changesets"),
5099 5099 "phasedivergent": _("phase-divergent: %d changesets"),
5100 5100 }
5101 5101 if numtrouble > 0:
5102 5102 ui.status(troublemsg[trouble] % numtrouble + "\n")
5103 5103
5104 5104 cmdutil.summaryhooks(ui, repo)
5105 5105
5106 5106 if opts.get('remote'):
5107 5107 needsincoming, needsoutgoing = True, True
5108 5108 else:
5109 5109 needsincoming, needsoutgoing = False, False
5110 5110 for i, o in cmdutil.summaryremotehooks(ui, repo, opts, None):
5111 5111 if i:
5112 5112 needsincoming = True
5113 5113 if o:
5114 5114 needsoutgoing = True
5115 5115 if not needsincoming and not needsoutgoing:
5116 5116 return
5117 5117
5118 5118 def getincoming():
5119 5119 source, branches = hg.parseurl(ui.expandpath('default'))
5120 5120 sbranch = branches[0]
5121 5121 try:
5122 5122 other = hg.peer(repo, {}, source)
5123 5123 except error.RepoError:
5124 5124 if opts.get('remote'):
5125 5125 raise
5126 5126 return source, sbranch, None, None, None
5127 5127 revs, checkout = hg.addbranchrevs(repo, other, branches, None)
5128 5128 if revs:
5129 5129 revs = [other.lookup(rev) for rev in revs]
5130 5130 ui.debug('comparing with %s\n' % util.hidepassword(source))
5131 5131 repo.ui.pushbuffer()
5132 5132 commoninc = discovery.findcommonincoming(repo, other, heads=revs)
5133 5133 repo.ui.popbuffer()
5134 5134 return source, sbranch, other, commoninc, commoninc[1]
5135 5135
5136 5136 if needsincoming:
5137 5137 source, sbranch, sother, commoninc, incoming = getincoming()
5138 5138 else:
5139 5139 source = sbranch = sother = commoninc = incoming = None
5140 5140
5141 5141 def getoutgoing():
5142 5142 dest, branches = hg.parseurl(ui.expandpath('default-push', 'default'))
5143 5143 dbranch = branches[0]
5144 5144 revs, checkout = hg.addbranchrevs(repo, repo, branches, None)
5145 5145 if source != dest:
5146 5146 try:
5147 5147 dother = hg.peer(repo, {}, dest)
5148 5148 except error.RepoError:
5149 5149 if opts.get('remote'):
5150 5150 raise
5151 5151 return dest, dbranch, None, None
5152 5152 ui.debug('comparing with %s\n' % util.hidepassword(dest))
5153 5153 elif sother is None:
5154 5154 # there is no explicit destination peer, but source one is invalid
5155 5155 return dest, dbranch, None, None
5156 5156 else:
5157 5157 dother = sother
5158 5158 if (source != dest or (sbranch is not None and sbranch != dbranch)):
5159 5159 common = None
5160 5160 else:
5161 5161 common = commoninc
5162 5162 if revs:
5163 5163 revs = [repo.lookup(rev) for rev in revs]
5164 5164 repo.ui.pushbuffer()
5165 5165 outgoing = discovery.findcommonoutgoing(repo, dother, onlyheads=revs,
5166 5166 commoninc=common)
5167 5167 repo.ui.popbuffer()
5168 5168 return dest, dbranch, dother, outgoing
5169 5169
5170 5170 if needsoutgoing:
5171 5171 dest, dbranch, dother, outgoing = getoutgoing()
5172 5172 else:
5173 5173 dest = dbranch = dother = outgoing = None
5174 5174
5175 5175 if opts.get('remote'):
5176 5176 t = []
5177 5177 if incoming:
5178 5178 t.append(_('1 or more incoming'))
5179 5179 o = outgoing.missing
5180 5180 if o:
5181 5181 t.append(_('%d outgoing') % len(o))
5182 5182 other = dother or sother
5183 5183 if 'bookmarks' in other.listkeys('namespaces'):
5184 5184 counts = bookmarks.summary(repo, other)
5185 5185 if counts[0] > 0:
5186 5186 t.append(_('%d incoming bookmarks') % counts[0])
5187 5187 if counts[1] > 0:
5188 5188 t.append(_('%d outgoing bookmarks') % counts[1])
5189 5189
5190 5190 if t:
5191 5191 # i18n: column positioning for "hg summary"
5192 5192 ui.write(_('remote: %s\n') % (', '.join(t)))
5193 5193 else:
5194 5194 # i18n: column positioning for "hg summary"
5195 5195 ui.status(_('remote: (synced)\n'))
5196 5196
5197 5197 cmdutil.summaryremotehooks(ui, repo, opts,
5198 5198 ((source, sbranch, sother, commoninc),
5199 5199 (dest, dbranch, dother, outgoing)))
5200 5200
5201 5201 @command('tag',
5202 5202 [('f', 'force', None, _('force tag')),
5203 5203 ('l', 'local', None, _('make the tag local')),
5204 5204 ('r', 'rev', '', _('revision to tag'), _('REV')),
5205 5205 ('', 'remove', None, _('remove a tag')),
5206 5206 # -l/--local is already there, commitopts cannot be used
5207 5207 ('e', 'edit', None, _('invoke editor on commit messages')),
5208 5208 ('m', 'message', '', _('use text as commit message'), _('TEXT')),
5209 5209 ] + commitopts2,
5210 5210 _('[-f] [-l] [-m TEXT] [-d DATE] [-u USER] [-r REV] NAME...'))
5211 5211 def tag(ui, repo, name1, *names, **opts):
5212 5212 """add one or more tags for the current or given revision
5213 5213
5214 5214 Name a particular revision using <name>.
5215 5215
5216 5216 Tags are used to name particular revisions of the repository and are
5217 5217 very useful to compare different revisions, to go back to significant
5218 5218 earlier versions or to mark branch points as releases, etc. Changing
5219 5219 an existing tag is normally disallowed; use -f/--force to override.
5220 5220
5221 5221 If no revision is given, the parent of the working directory is
5222 5222 used.
5223 5223
5224 5224 To facilitate version control, distribution, and merging of tags,
5225 5225 they are stored as a file named ".hgtags" which is managed similarly
5226 5226 to other project files and can be hand-edited if necessary. This
5227 5227 also means that tagging creates a new commit. The file
5228 5228 ".hg/localtags" is used for local tags (not shared among
5229 5229 repositories).
5230 5230
5231 5231 Tag commits are usually made at the head of a branch. If the parent
5232 5232 of the working directory is not a branch head, :hg:`tag` aborts; use
5233 5233 -f/--force to force the tag commit to be based on a non-head
5234 5234 changeset.
5235 5235
5236 5236 See :hg:`help dates` for a list of formats valid for -d/--date.
5237 5237
5238 5238 Since tag names have priority over branch names during revision
5239 5239 lookup, using an existing branch name as a tag name is discouraged.
5240 5240
5241 5241 Returns 0 on success.
5242 5242 """
5243 5243 opts = pycompat.byteskwargs(opts)
5244 5244 wlock = lock = None
5245 5245 try:
5246 5246 wlock = repo.wlock()
5247 5247 lock = repo.lock()
5248 5248 rev_ = "."
5249 5249 names = [t.strip() for t in (name1,) + names]
5250 5250 if len(names) != len(set(names)):
5251 5251 raise error.Abort(_('tag names must be unique'))
5252 5252 for n in names:
5253 5253 scmutil.checknewlabel(repo, n, 'tag')
5254 5254 if not n:
5255 5255 raise error.Abort(_('tag names cannot consist entirely of '
5256 5256 'whitespace'))
5257 5257 if opts.get('rev') and opts.get('remove'):
5258 5258 raise error.Abort(_("--rev and --remove are incompatible"))
5259 5259 if opts.get('rev'):
5260 5260 rev_ = opts['rev']
5261 5261 message = opts.get('message')
5262 5262 if opts.get('remove'):
5263 5263 if opts.get('local'):
5264 5264 expectedtype = 'local'
5265 5265 else:
5266 5266 expectedtype = 'global'
5267 5267
5268 5268 for n in names:
5269 5269 if not repo.tagtype(n):
5270 5270 raise error.Abort(_("tag '%s' does not exist") % n)
5271 5271 if repo.tagtype(n) != expectedtype:
5272 5272 if expectedtype == 'global':
5273 5273 raise error.Abort(_("tag '%s' is not a global tag") % n)
5274 5274 else:
5275 5275 raise error.Abort(_("tag '%s' is not a local tag") % n)
5276 5276 rev_ = 'null'
5277 5277 if not message:
5278 5278 # we don't translate commit messages
5279 5279 message = 'Removed tag %s' % ', '.join(names)
5280 5280 elif not opts.get('force'):
5281 5281 for n in names:
5282 5282 if n in repo.tags():
5283 5283 raise error.Abort(_("tag '%s' already exists "
5284 5284 "(use -f to force)") % n)
5285 5285 if not opts.get('local'):
5286 5286 p1, p2 = repo.dirstate.parents()
5287 5287 if p2 != nullid:
5288 5288 raise error.Abort(_('uncommitted merge'))
5289 5289 bheads = repo.branchheads()
5290 5290 if not opts.get('force') and bheads and p1 not in bheads:
5291 5291 raise error.Abort(_('working directory is not at a branch head '
5292 5292 '(use -f to force)'))
5293 5293 r = scmutil.revsingle(repo, rev_).node()
5294 5294
5295 5295 if not message:
5296 5296 # we don't translate commit messages
5297 5297 message = ('Added tag %s for changeset %s' %
5298 5298 (', '.join(names), short(r)))
5299 5299
5300 5300 date = opts.get('date')
5301 5301 if date:
5302 5302 date = util.parsedate(date)
5303 5303
5304 5304 if opts.get('remove'):
5305 5305 editform = 'tag.remove'
5306 5306 else:
5307 5307 editform = 'tag.add'
5308 5308 editor = cmdutil.getcommiteditor(editform=editform,
5309 5309 **pycompat.strkwargs(opts))
5310 5310
5311 5311 # don't allow tagging the null rev
5312 5312 if (not opts.get('remove') and
5313 5313 scmutil.revsingle(repo, rev_).rev() == nullrev):
5314 5314 raise error.Abort(_("cannot tag null revision"))
5315 5315
5316 5316 tagsmod.tag(repo, names, r, message, opts.get('local'),
5317 5317 opts.get('user'), date, editor=editor)
5318 5318 finally:
5319 5319 release(lock, wlock)
5320 5320
5321 5321 @command('tags', formatteropts, '', cmdtype=readonly)
5322 5322 def tags(ui, repo, **opts):
5323 5323 """list repository tags
5324 5324
5325 5325 This lists both regular and local tags. When the -v/--verbose
5326 5326 switch is used, a third column "local" is printed for local tags.
5327 5327 When the -q/--quiet switch is used, only the tag name is printed.
5328 5328
5329 5329 Returns 0 on success.
5330 5330 """
5331 5331
5332 5332 opts = pycompat.byteskwargs(opts)
5333 5333 ui.pager('tags')
5334 5334 fm = ui.formatter('tags', opts)
5335 5335 hexfunc = fm.hexfunc
5336 5336 tagtype = ""
5337 5337
5338 5338 for t, n in reversed(repo.tagslist()):
5339 5339 hn = hexfunc(n)
5340 5340 label = 'tags.normal'
5341 5341 tagtype = ''
5342 5342 if repo.tagtype(t) == 'local':
5343 5343 label = 'tags.local'
5344 5344 tagtype = 'local'
5345 5345
5346 5346 fm.startitem()
5347 5347 fm.write('tag', '%s', t, label=label)
5348 5348 fmt = " " * (30 - encoding.colwidth(t)) + ' %5d:%s'
5349 5349 fm.condwrite(not ui.quiet, 'rev node', fmt,
5350 5350 repo.changelog.rev(n), hn, label=label)
5351 5351 fm.condwrite(ui.verbose and tagtype, 'type', ' %s',
5352 5352 tagtype, label=label)
5353 5353 fm.plain('\n')
5354 5354 fm.end()
5355 5355
5356 5356 @command('tip',
5357 5357 [('p', 'patch', None, _('show patch')),
5358 5358 ('g', 'git', None, _('use git extended diff format')),
5359 5359 ] + templateopts,
5360 5360 _('[-p] [-g]'))
5361 5361 def tip(ui, repo, **opts):
5362 5362 """show the tip revision (DEPRECATED)
5363 5363
5364 5364 The tip revision (usually just called the tip) is the changeset
5365 5365 most recently added to the repository (and therefore the most
5366 5366 recently changed head).
5367 5367
5368 5368 If you have just made a commit, that commit will be the tip. If
5369 5369 you have just pulled changes from another repository, the tip of
5370 5370 that repository becomes the current tip. The "tip" tag is special
5371 5371 and cannot be renamed or assigned to a different changeset.
5372 5372
5373 5373 This command is deprecated, please use :hg:`heads` instead.
5374 5374
5375 5375 Returns 0 on success.
5376 5376 """
5377 5377 opts = pycompat.byteskwargs(opts)
5378 5378 displayer = logcmdutil.changesetdisplayer(ui, repo, opts)
5379 5379 displayer.show(repo['tip'])
5380 5380 displayer.close()
5381 5381
5382 5382 @command('unbundle',
5383 5383 [('u', 'update', None,
5384 5384 _('update to new branch head if changesets were unbundled'))],
5385 5385 _('[-u] FILE...'))
5386 5386 def unbundle(ui, repo, fname1, *fnames, **opts):
5387 5387 """apply one or more bundle files
5388 5388
5389 5389 Apply one or more bundle files generated by :hg:`bundle`.
5390 5390
5391 5391 Returns 0 on success, 1 if an update has unresolved files.
5392 5392 """
5393 5393 fnames = (fname1,) + fnames
5394 5394
5395 5395 with repo.lock():
5396 5396 for fname in fnames:
5397 5397 f = hg.openpath(ui, fname)
5398 5398 gen = exchange.readbundle(ui, f, fname)
5399 5399 if isinstance(gen, streamclone.streamcloneapplier):
5400 5400 raise error.Abort(
5401 5401 _('packed bundles cannot be applied with '
5402 5402 '"hg unbundle"'),
5403 5403 hint=_('use "hg debugapplystreamclonebundle"'))
5404 5404 url = 'bundle:' + fname
5405 5405 try:
5406 5406 txnname = 'unbundle'
5407 5407 if not isinstance(gen, bundle2.unbundle20):
5408 5408 txnname = 'unbundle\n%s' % util.hidepassword(url)
5409 5409 with repo.transaction(txnname) as tr:
5410 5410 op = bundle2.applybundle(repo, gen, tr, source='unbundle',
5411 5411 url=url)
5412 5412 except error.BundleUnknownFeatureError as exc:
5413 5413 raise error.Abort(
5414 5414 _('%s: unknown bundle feature, %s') % (fname, exc),
5415 5415 hint=_("see https://mercurial-scm.org/"
5416 5416 "wiki/BundleFeature for more "
5417 5417 "information"))
5418 5418 modheads = bundle2.combinechangegroupresults(op)
5419 5419
5420 5420 return postincoming(ui, repo, modheads, opts.get(r'update'), None, None)
5421 5421
5422 5422 @command('^update|up|checkout|co',
5423 5423 [('C', 'clean', None, _('discard uncommitted changes (no backup)')),
5424 5424 ('c', 'check', None, _('require clean working directory')),
5425 5425 ('m', 'merge', None, _('merge uncommitted changes')),
5426 5426 ('d', 'date', '', _('tipmost revision matching date'), _('DATE')),
5427 5427 ('r', 'rev', '', _('revision'), _('REV'))
5428 5428 ] + mergetoolopts,
5429 5429 _('[-C|-c|-m] [-d DATE] [[-r] REV]'))
5430 5430 def update(ui, repo, node=None, rev=None, clean=False, date=None, check=False,
5431 5431 merge=None, tool=None):
5432 5432 """update working directory (or switch revisions)
5433 5433
5434 5434 Update the repository's working directory to the specified
5435 5435 changeset. If no changeset is specified, update to the tip of the
5436 5436 current named branch and move the active bookmark (see :hg:`help
5437 5437 bookmarks`).
5438 5438
5439 5439 Update sets the working directory's parent revision to the specified
5440 5440 changeset (see :hg:`help parents`).
5441 5441
5442 5442 If the changeset is not a descendant or ancestor of the working
5443 5443 directory's parent and there are uncommitted changes, the update is
5444 5444 aborted. With the -c/--check option, the working directory is checked
5445 5445 for uncommitted changes; if none are found, the working directory is
5446 5446 updated to the specified changeset.
5447 5447
5448 5448 .. container:: verbose
5449 5449
5450 5450 The -C/--clean, -c/--check, and -m/--merge options control what
5451 5451 happens if the working directory contains uncommitted changes.
5452 5452 At most of one of them can be specified.
5453 5453
5454 5454 1. If no option is specified, and if
5455 5455 the requested changeset is an ancestor or descendant of
5456 5456 the working directory's parent, the uncommitted changes
5457 5457 are merged into the requested changeset and the merged
5458 5458 result is left uncommitted. If the requested changeset is
5459 5459 not an ancestor or descendant (that is, it is on another
5460 5460 branch), the update is aborted and the uncommitted changes
5461 5461 are preserved.
5462 5462
5463 5463 2. With the -m/--merge option, the update is allowed even if the
5464 5464 requested changeset is not an ancestor or descendant of
5465 5465 the working directory's parent.
5466 5466
5467 5467 3. With the -c/--check option, the update is aborted and the
5468 5468 uncommitted changes are preserved.
5469 5469
5470 5470 4. With the -C/--clean option, uncommitted changes are discarded and
5471 5471 the working directory is updated to the requested changeset.
5472 5472
5473 5473 To cancel an uncommitted merge (and lose your changes), use
5474 5474 :hg:`merge --abort`.
5475 5475
5476 5476 Use null as the changeset to remove the working directory (like
5477 5477 :hg:`clone -U`).
5478 5478
5479 5479 If you want to revert just one file to an older revision, use
5480 5480 :hg:`revert [-r REV] NAME`.
5481 5481
5482 5482 See :hg:`help dates` for a list of formats valid for -d/--date.
5483 5483
5484 5484 Returns 0 on success, 1 if there are unresolved files.
5485 5485 """
5486 5486 if rev and node:
5487 5487 raise error.Abort(_("please specify just one revision"))
5488 5488
5489 5489 if ui.configbool('commands', 'update.requiredest'):
5490 5490 if not node and not rev and not date:
5491 5491 raise error.Abort(_('you must specify a destination'),
5492 5492 hint=_('for example: hg update ".::"'))
5493 5493
5494 5494 if rev is None or rev == '':
5495 5495 rev = node
5496 5496
5497 5497 if date and rev is not None:
5498 5498 raise error.Abort(_("you can't specify a revision and a date"))
5499 5499
5500 5500 if len([x for x in (clean, check, merge) if x]) > 1:
5501 5501 raise error.Abort(_("can only specify one of -C/--clean, -c/--check, "
5502 5502 "or -m/--merge"))
5503 5503
5504 5504 updatecheck = None
5505 5505 if check:
5506 5506 updatecheck = 'abort'
5507 5507 elif merge:
5508 5508 updatecheck = 'none'
5509 5509
5510 5510 with repo.wlock():
5511 5511 cmdutil.clearunfinished(repo)
5512 5512
5513 5513 if date:
5514 5514 rev = cmdutil.finddate(ui, repo, date)
5515 5515
5516 5516 # if we defined a bookmark, we have to remember the original name
5517 5517 brev = rev
5518 5518 if rev:
5519 5519 repo = scmutil.unhidehashlikerevs(repo, [rev], 'nowarn')
5520 5520 ctx = scmutil.revsingle(repo, rev, rev)
5521 5521 rev = ctx.rev()
5522 5522 if ctx.hidden():
5523 5523 ctxstr = ctx.hex()[:12]
5524 5524 ui.warn(_("updating to a hidden changeset %s\n") % ctxstr)
5525 5525
5526 5526 if ctx.obsolete():
5527 5527 obsfatemsg = obsutil._getfilteredreason(repo, ctxstr, ctx)
5528 5528 ui.warn("(%s)\n" % obsfatemsg)
5529 5529
5530 5530 repo.ui.setconfig('ui', 'forcemerge', tool, 'update')
5531 5531
5532 5532 return hg.updatetotally(ui, repo, rev, brev, clean=clean,
5533 5533 updatecheck=updatecheck)
5534 5534
5535 5535 @command('verify', [])
5536 5536 def verify(ui, repo):
5537 5537 """verify the integrity of the repository
5538 5538
5539 5539 Verify the integrity of the current repository.
5540 5540
5541 5541 This will perform an extensive check of the repository's
5542 5542 integrity, validating the hashes and checksums of each entry in
5543 5543 the changelog, manifest, and tracked files, as well as the
5544 5544 integrity of their crosslinks and indices.
5545 5545
5546 5546 Please see https://mercurial-scm.org/wiki/RepositoryCorruption
5547 5547 for more information about recovery from corruption of the
5548 5548 repository.
5549 5549
5550 5550 Returns 0 on success, 1 if errors are encountered.
5551 5551 """
5552 5552 return hg.verify(repo)
5553 5553
5554 5554 @command('version', [] + formatteropts, norepo=True, cmdtype=readonly)
5555 5555 def version_(ui, **opts):
5556 5556 """output version and copyright information"""
5557 5557 opts = pycompat.byteskwargs(opts)
5558 5558 if ui.verbose:
5559 5559 ui.pager('version')
5560 5560 fm = ui.formatter("version", opts)
5561 5561 fm.startitem()
5562 5562 fm.write("ver", _("Mercurial Distributed SCM (version %s)\n"),
5563 5563 util.version())
5564 5564 license = _(
5565 5565 "(see https://mercurial-scm.org for more information)\n"
5566 5566 "\nCopyright (C) 2005-2018 Matt Mackall and others\n"
5567 5567 "This is free software; see the source for copying conditions. "
5568 5568 "There is NO\nwarranty; "
5569 5569 "not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
5570 5570 )
5571 5571 if not ui.quiet:
5572 5572 fm.plain(license)
5573 5573
5574 5574 if ui.verbose:
5575 5575 fm.plain(_("\nEnabled extensions:\n\n"))
5576 5576 # format names and versions into columns
5577 5577 names = []
5578 5578 vers = []
5579 5579 isinternals = []
5580 5580 for name, module in extensions.extensions():
5581 5581 names.append(name)
5582 5582 vers.append(extensions.moduleversion(module) or None)
5583 5583 isinternals.append(extensions.ismoduleinternal(module))
5584 5584 fn = fm.nested("extensions")
5585 5585 if names:
5586 5586 namefmt = " %%-%ds " % max(len(n) for n in names)
5587 5587 places = [_("external"), _("internal")]
5588 5588 for n, v, p in zip(names, vers, isinternals):
5589 5589 fn.startitem()
5590 5590 fn.condwrite(ui.verbose, "name", namefmt, n)
5591 5591 if ui.verbose:
5592 5592 fn.plain("%s " % places[p])
5593 5593 fn.data(bundled=p)
5594 5594 fn.condwrite(ui.verbose and v, "ver", "%s", v)
5595 5595 if ui.verbose:
5596 5596 fn.plain("\n")
5597 5597 fn.end()
5598 5598 fm.end()
5599 5599
5600 5600 def loadcmdtable(ui, name, cmdtable):
5601 5601 """Load command functions from specified cmdtable
5602 5602 """
5603 5603 overrides = [cmd for cmd in cmdtable if cmd in table]
5604 5604 if overrides:
5605 5605 ui.warn(_("extension '%s' overrides commands: %s\n")
5606 5606 % (name, " ".join(overrides)))
5607 5607 table.update(cmdtable)
@@ -1,1787 +1,1786 b''
1 1 # subrepo.py - sub-repository classes and factory
2 2 #
3 3 # Copyright 2009-2010 Matt Mackall <mpm@selenic.com>
4 4 #
5 5 # This software may be used and distributed according to the terms of the
6 6 # GNU General Public License version 2 or any later version.
7 7
8 8 from __future__ import absolute_import
9 9
10 10 import copy
11 11 import errno
12 12 import hashlib
13 13 import os
14 14 import posixpath
15 15 import re
16 16 import stat
17 17 import subprocess
18 18 import sys
19 19 import tarfile
20 20 import xml.dom.minidom
21 21
22 22 from .i18n import _
23 23 from . import (
24 24 cmdutil,
25 25 encoding,
26 26 error,
27 27 exchange,
28 28 logcmdutil,
29 29 match as matchmod,
30 30 node,
31 31 pathutil,
32 32 phases,
33 33 pycompat,
34 34 scmutil,
35 35 subrepoutil,
36 36 util,
37 37 vfs as vfsmod,
38 38 )
39 39
40 40 hg = None
41 41 reporelpath = subrepoutil.reporelpath
42 42 subrelpath = subrepoutil.subrelpath
43 43 _abssource = subrepoutil._abssource
44 44 propertycache = util.propertycache
45 45
46 46 def _expandedabspath(path):
47 47 '''
48 48 get a path or url and if it is a path expand it and return an absolute path
49 49 '''
50 50 expandedpath = util.urllocalpath(util.expandpath(path))
51 51 u = util.url(expandedpath)
52 52 if not u.scheme:
53 53 path = util.normpath(os.path.abspath(u.path))
54 54 return path
55 55
56 56 def _getstorehashcachename(remotepath):
57 57 '''get a unique filename for the store hash cache of a remote repository'''
58 58 return node.hex(hashlib.sha1(_expandedabspath(remotepath)).digest())[0:12]
59 59
60 60 class SubrepoAbort(error.Abort):
61 61 """Exception class used to avoid handling a subrepo error more than once"""
62 62 def __init__(self, *args, **kw):
63 63 self.subrepo = kw.pop(r'subrepo', None)
64 64 self.cause = kw.pop(r'cause', None)
65 65 error.Abort.__init__(self, *args, **kw)
66 66
67 67 def annotatesubrepoerror(func):
68 68 def decoratedmethod(self, *args, **kargs):
69 69 try:
70 70 res = func(self, *args, **kargs)
71 71 except SubrepoAbort as ex:
72 72 # This exception has already been handled
73 73 raise ex
74 74 except error.Abort as ex:
75 75 subrepo = subrelpath(self)
76 76 errormsg = str(ex) + ' ' + _('(in subrepository "%s")') % subrepo
77 77 # avoid handling this exception by raising a SubrepoAbort exception
78 78 raise SubrepoAbort(errormsg, hint=ex.hint, subrepo=subrepo,
79 79 cause=sys.exc_info())
80 80 return res
81 81 return decoratedmethod
82 82
83 83 def _updateprompt(ui, sub, dirty, local, remote):
84 84 if dirty:
85 85 msg = (_(' subrepository sources for %s differ\n'
86 86 'use (l)ocal source (%s) or (r)emote source (%s)?'
87 87 '$$ &Local $$ &Remote')
88 88 % (subrelpath(sub), local, remote))
89 89 else:
90 90 msg = (_(' subrepository sources for %s differ (in checked out '
91 91 'version)\n'
92 92 'use (l)ocal source (%s) or (r)emote source (%s)?'
93 93 '$$ &Local $$ &Remote')
94 94 % (subrelpath(sub), local, remote))
95 95 return ui.promptchoice(msg, 0)
96 96
97 97 def _sanitize(ui, vfs, ignore):
98 98 for dirname, dirs, names in vfs.walk():
99 99 for i, d in enumerate(dirs):
100 100 if d.lower() == ignore:
101 101 del dirs[i]
102 102 break
103 103 if vfs.basename(dirname).lower() != '.hg':
104 104 continue
105 105 for f in names:
106 106 if f.lower() == 'hgrc':
107 107 ui.warn(_("warning: removing potentially hostile 'hgrc' "
108 108 "in '%s'\n") % vfs.join(dirname))
109 109 vfs.unlink(vfs.reljoin(dirname, f))
110 110
111 111 def _auditsubrepopath(repo, path):
112 112 # auditor doesn't check if the path itself is a symlink
113 113 pathutil.pathauditor(repo.root)(path)
114 114 if repo.wvfs.islink(path):
115 115 raise error.Abort(_("subrepo '%s' traverses symbolic link") % path)
116 116
117 117 SUBREPO_ALLOWED_DEFAULTS = {
118 118 'hg': True,
119 119 'git': False,
120 120 'svn': False,
121 121 }
122 122
123 123 def _checktype(ui, kind):
124 124 # subrepos.allowed is a master kill switch. If disabled, subrepos are
125 125 # disabled period.
126 126 if not ui.configbool('subrepos', 'allowed', True):
127 127 raise error.Abort(_('subrepos not enabled'),
128 128 hint=_("see 'hg help config.subrepos' for details"))
129 129
130 130 default = SUBREPO_ALLOWED_DEFAULTS.get(kind, False)
131 131 if not ui.configbool('subrepos', '%s:allowed' % kind, default):
132 132 raise error.Abort(_('%s subrepos not allowed') % kind,
133 133 hint=_("see 'hg help config.subrepos' for details"))
134 134
135 135 if kind not in types:
136 136 raise error.Abort(_('unknown subrepo type %s') % kind)
137 137
138 138 def subrepo(ctx, path, allowwdir=False, allowcreate=True):
139 139 """return instance of the right subrepo class for subrepo in path"""
140 140 # subrepo inherently violates our import layering rules
141 141 # because it wants to make repo objects from deep inside the stack
142 142 # so we manually delay the circular imports to not break
143 143 # scripts that don't use our demand-loading
144 144 global hg
145 145 from . import hg as h
146 146 hg = h
147 147
148 148 repo = ctx.repo()
149 149 _auditsubrepopath(repo, path)
150 150 state = ctx.substate[path]
151 151 _checktype(repo.ui, state[2])
152 152 if allowwdir:
153 153 state = (state[0], ctx.subrev(path), state[2])
154 154 return types[state[2]](ctx, path, state[:2], allowcreate)
155 155
156 156 def nullsubrepo(ctx, path, pctx):
157 157 """return an empty subrepo in pctx for the extant subrepo in ctx"""
158 158 # subrepo inherently violates our import layering rules
159 159 # because it wants to make repo objects from deep inside the stack
160 160 # so we manually delay the circular imports to not break
161 161 # scripts that don't use our demand-loading
162 162 global hg
163 163 from . import hg as h
164 164 hg = h
165 165
166 166 repo = ctx.repo()
167 167 _auditsubrepopath(repo, path)
168 168 state = ctx.substate[path]
169 169 _checktype(repo.ui, state[2])
170 170 subrev = ''
171 171 if state[2] == 'hg':
172 172 subrev = "0" * 40
173 173 return types[state[2]](pctx, path, (state[0], subrev), True)
174 174
175 175 # subrepo classes need to implement the following abstract class:
176 176
177 177 class abstractsubrepo(object):
178 178
179 179 def __init__(self, ctx, path):
180 180 """Initialize abstractsubrepo part
181 181
182 182 ``ctx`` is the context referring this subrepository in the
183 183 parent repository.
184 184
185 185 ``path`` is the path to this subrepository as seen from
186 186 innermost repository.
187 187 """
188 188 self.ui = ctx.repo().ui
189 189 self._ctx = ctx
190 190 self._path = path
191 191
192 192 def addwebdirpath(self, serverpath, webconf):
193 193 """Add the hgwebdir entries for this subrepo, and any of its subrepos.
194 194
195 195 ``serverpath`` is the path component of the URL for this repo.
196 196
197 197 ``webconf`` is the dictionary of hgwebdir entries.
198 198 """
199 199 pass
200 200
201 201 def storeclean(self, path):
202 202 """
203 203 returns true if the repository has not changed since it was last
204 204 cloned from or pushed to a given repository.
205 205 """
206 206 return False
207 207
208 208 def dirty(self, ignoreupdate=False, missing=False):
209 209 """returns true if the dirstate of the subrepo is dirty or does not
210 210 match current stored state. If ignoreupdate is true, only check
211 211 whether the subrepo has uncommitted changes in its dirstate. If missing
212 212 is true, check for deleted files.
213 213 """
214 214 raise NotImplementedError
215 215
216 216 def dirtyreason(self, ignoreupdate=False, missing=False):
217 217 """return reason string if it is ``dirty()``
218 218
219 219 Returned string should have enough information for the message
220 220 of exception.
221 221
222 222 This returns None, otherwise.
223 223 """
224 224 if self.dirty(ignoreupdate=ignoreupdate, missing=missing):
225 225 return _('uncommitted changes in subrepository "%s"'
226 226 ) % subrelpath(self)
227 227
228 228 def bailifchanged(self, ignoreupdate=False, hint=None):
229 229 """raise Abort if subrepository is ``dirty()``
230 230 """
231 231 dirtyreason = self.dirtyreason(ignoreupdate=ignoreupdate,
232 232 missing=True)
233 233 if dirtyreason:
234 234 raise error.Abort(dirtyreason, hint=hint)
235 235
236 236 def basestate(self):
237 237 """current working directory base state, disregarding .hgsubstate
238 238 state and working directory modifications"""
239 239 raise NotImplementedError
240 240
241 241 def checknested(self, path):
242 242 """check if path is a subrepository within this repository"""
243 243 return False
244 244
245 245 def commit(self, text, user, date):
246 246 """commit the current changes to the subrepo with the given
247 247 log message. Use given user and date if possible. Return the
248 248 new state of the subrepo.
249 249 """
250 250 raise NotImplementedError
251 251
252 252 def phase(self, state):
253 253 """returns phase of specified state in the subrepository.
254 254 """
255 255 return phases.public
256 256
257 257 def remove(self):
258 258 """remove the subrepo
259 259
260 260 (should verify the dirstate is not dirty first)
261 261 """
262 262 raise NotImplementedError
263 263
264 264 def get(self, state, overwrite=False):
265 265 """run whatever commands are needed to put the subrepo into
266 266 this state
267 267 """
268 268 raise NotImplementedError
269 269
270 270 def merge(self, state):
271 271 """merge currently-saved state with the new state."""
272 272 raise NotImplementedError
273 273
274 274 def push(self, opts):
275 275 """perform whatever action is analogous to 'hg push'
276 276
277 277 This may be a no-op on some systems.
278 278 """
279 279 raise NotImplementedError
280 280
281 281 def add(self, ui, match, prefix, explicitonly, **opts):
282 282 return []
283 283
284 284 def addremove(self, matcher, prefix, opts, dry_run, similarity):
285 285 self.ui.warn("%s: %s" % (prefix, _("addremove is not supported")))
286 286 return 1
287 287
288 288 def cat(self, match, fm, fntemplate, prefix, **opts):
289 289 return 1
290 290
291 291 def status(self, rev2, **opts):
292 292 return scmutil.status([], [], [], [], [], [], [])
293 293
294 294 def diff(self, ui, diffopts, node2, match, prefix, **opts):
295 295 pass
296 296
297 297 def outgoing(self, ui, dest, opts):
298 298 return 1
299 299
300 300 def incoming(self, ui, source, opts):
301 301 return 1
302 302
303 303 def files(self):
304 304 """return filename iterator"""
305 305 raise NotImplementedError
306 306
307 307 def filedata(self, name, decode):
308 308 """return file data, optionally passed through repo decoders"""
309 309 raise NotImplementedError
310 310
311 311 def fileflags(self, name):
312 312 """return file flags"""
313 313 return ''
314 314
315 315 def getfileset(self, expr):
316 316 """Resolve the fileset expression for this repo"""
317 317 return set()
318 318
319 319 def printfiles(self, ui, m, fm, fmt, subrepos):
320 320 """handle the files command for this subrepo"""
321 321 return 1
322 322
323 323 def archive(self, archiver, prefix, match=None, decode=True):
324 324 if match is not None:
325 325 files = [f for f in self.files() if match(f)]
326 326 else:
327 327 files = self.files()
328 328 total = len(files)
329 329 relpath = subrelpath(self)
330 330 self.ui.progress(_('archiving (%s)') % relpath, 0,
331 331 unit=_('files'), total=total)
332 332 for i, name in enumerate(files):
333 333 flags = self.fileflags(name)
334 334 mode = 'x' in flags and 0o755 or 0o644
335 335 symlink = 'l' in flags
336 336 archiver.addfile(prefix + self._path + '/' + name,
337 337 mode, symlink, self.filedata(name, decode))
338 338 self.ui.progress(_('archiving (%s)') % relpath, i + 1,
339 339 unit=_('files'), total=total)
340 340 self.ui.progress(_('archiving (%s)') % relpath, None)
341 341 return total
342 342
343 343 def walk(self, match):
344 344 '''
345 345 walk recursively through the directory tree, finding all files
346 346 matched by the match function
347 347 '''
348 348
349 349 def forget(self, match, prefix):
350 350 return ([], [])
351 351
352 352 def removefiles(self, matcher, prefix, after, force, subrepos, warnings):
353 353 """remove the matched files from the subrepository and the filesystem,
354 354 possibly by force and/or after the file has been removed from the
355 355 filesystem. Return 0 on success, 1 on any warning.
356 356 """
357 357 warnings.append(_("warning: removefiles not implemented (%s)")
358 358 % self._path)
359 359 return 1
360 360
361 361 def revert(self, substate, *pats, **opts):
362 362 self.ui.warn(_('%s: reverting %s subrepos is unsupported\n') \
363 363 % (substate[0], substate[2]))
364 364 return []
365 365
366 366 def shortid(self, revid):
367 367 return revid
368 368
369 369 def unshare(self):
370 370 '''
371 371 convert this repository from shared to normal storage.
372 372 '''
373 373
374 374 def verify(self):
375 375 '''verify the integrity of the repository. Return 0 on success or
376 376 warning, 1 on any error.
377 377 '''
378 378 return 0
379 379
380 380 @propertycache
381 381 def wvfs(self):
382 382 """return vfs to access the working directory of this subrepository
383 383 """
384 384 return vfsmod.vfs(self._ctx.repo().wvfs.join(self._path))
385 385
386 386 @propertycache
387 387 def _relpath(self):
388 388 """return path to this subrepository as seen from outermost repository
389 389 """
390 390 return self.wvfs.reljoin(reporelpath(self._ctx.repo()), self._path)
391 391
392 392 class hgsubrepo(abstractsubrepo):
393 393 def __init__(self, ctx, path, state, allowcreate):
394 394 super(hgsubrepo, self).__init__(ctx, path)
395 395 self._state = state
396 396 r = ctx.repo()
397 397 root = r.wjoin(path)
398 398 create = allowcreate and not r.wvfs.exists('%s/.hg' % path)
399 399 self._repo = hg.repository(r.baseui, root, create=create)
400 400
401 401 # Propagate the parent's --hidden option
402 402 if r is r.unfiltered():
403 403 self._repo = self._repo.unfiltered()
404 404
405 405 self.ui = self._repo.ui
406 406 for s, k in [('ui', 'commitsubrepos')]:
407 407 v = r.ui.config(s, k)
408 408 if v:
409 409 self.ui.setconfig(s, k, v, 'subrepo')
410 410 # internal config: ui._usedassubrepo
411 411 self.ui.setconfig('ui', '_usedassubrepo', 'True', 'subrepo')
412 412 self._initrepo(r, state[0], create)
413 413
414 414 @annotatesubrepoerror
415 415 def addwebdirpath(self, serverpath, webconf):
416 416 cmdutil.addwebdirpath(self._repo, subrelpath(self), webconf)
417 417
418 418 def storeclean(self, path):
419 419 with self._repo.lock():
420 420 return self._storeclean(path)
421 421
422 422 def _storeclean(self, path):
423 423 clean = True
424 424 itercache = self._calcstorehash(path)
425 425 for filehash in self._readstorehashcache(path):
426 426 if filehash != next(itercache, None):
427 427 clean = False
428 428 break
429 429 if clean:
430 430 # if not empty:
431 431 # the cached and current pull states have a different size
432 432 clean = next(itercache, None) is None
433 433 return clean
434 434
435 435 def _calcstorehash(self, remotepath):
436 436 '''calculate a unique "store hash"
437 437
438 438 This method is used to to detect when there are changes that may
439 439 require a push to a given remote path.'''
440 440 # sort the files that will be hashed in increasing (likely) file size
441 441 filelist = ('bookmarks', 'store/phaseroots', 'store/00changelog.i')
442 442 yield '# %s\n' % _expandedabspath(remotepath)
443 443 vfs = self._repo.vfs
444 444 for relname in filelist:
445 445 filehash = node.hex(hashlib.sha1(vfs.tryread(relname)).digest())
446 446 yield '%s = %s\n' % (relname, filehash)
447 447
448 448 @propertycache
449 449 def _cachestorehashvfs(self):
450 450 return vfsmod.vfs(self._repo.vfs.join('cache/storehash'))
451 451
452 452 def _readstorehashcache(self, remotepath):
453 453 '''read the store hash cache for a given remote repository'''
454 454 cachefile = _getstorehashcachename(remotepath)
455 455 return self._cachestorehashvfs.tryreadlines(cachefile, 'r')
456 456
457 457 def _cachestorehash(self, remotepath):
458 458 '''cache the current store hash
459 459
460 460 Each remote repo requires its own store hash cache, because a subrepo
461 461 store may be "clean" versus a given remote repo, but not versus another
462 462 '''
463 463 cachefile = _getstorehashcachename(remotepath)
464 464 with self._repo.lock():
465 465 storehash = list(self._calcstorehash(remotepath))
466 466 vfs = self._cachestorehashvfs
467 467 vfs.writelines(cachefile, storehash, mode='wb', notindexed=True)
468 468
469 469 def _getctx(self):
470 470 '''fetch the context for this subrepo revision, possibly a workingctx
471 471 '''
472 472 if self._ctx.rev() is None:
473 473 return self._repo[None] # workingctx if parent is workingctx
474 474 else:
475 475 rev = self._state[1]
476 476 return self._repo[rev]
477 477
478 478 @annotatesubrepoerror
479 479 def _initrepo(self, parentrepo, source, create):
480 480 self._repo._subparent = parentrepo
481 481 self._repo._subsource = source
482 482
483 483 if create:
484 484 lines = ['[paths]\n']
485 485
486 486 def addpathconfig(key, value):
487 487 if value:
488 488 lines.append('%s = %s\n' % (key, value))
489 489 self.ui.setconfig('paths', key, value, 'subrepo')
490 490
491 491 defpath = _abssource(self._repo, abort=False)
492 492 defpushpath = _abssource(self._repo, True, abort=False)
493 493 addpathconfig('default', defpath)
494 494 if defpath != defpushpath:
495 495 addpathconfig('default-push', defpushpath)
496 496
497 497 self._repo.vfs.write('hgrc', util.tonativeeol(''.join(lines)))
498 498
499 499 @annotatesubrepoerror
500 500 def add(self, ui, match, prefix, explicitonly, **opts):
501 501 return cmdutil.add(ui, self._repo, match,
502 502 self.wvfs.reljoin(prefix, self._path),
503 503 explicitonly, **opts)
504 504
505 505 @annotatesubrepoerror
506 506 def addremove(self, m, prefix, opts, dry_run, similarity):
507 507 # In the same way as sub directories are processed, once in a subrepo,
508 508 # always entry any of its subrepos. Don't corrupt the options that will
509 509 # be used to process sibling subrepos however.
510 510 opts = copy.copy(opts)
511 511 opts['subrepos'] = True
512 512 return scmutil.addremove(self._repo, m,
513 513 self.wvfs.reljoin(prefix, self._path), opts,
514 514 dry_run, similarity)
515 515
516 516 @annotatesubrepoerror
517 517 def cat(self, match, fm, fntemplate, prefix, **opts):
518 518 rev = self._state[1]
519 519 ctx = self._repo[rev]
520 520 return cmdutil.cat(self.ui, self._repo, ctx, match, fm, fntemplate,
521 521 prefix, **opts)
522 522
523 523 @annotatesubrepoerror
524 524 def status(self, rev2, **opts):
525 525 try:
526 526 rev1 = self._state[1]
527 527 ctx1 = self._repo[rev1]
528 528 ctx2 = self._repo[rev2]
529 529 return self._repo.status(ctx1, ctx2, **opts)
530 530 except error.RepoLookupError as inst:
531 531 self.ui.warn(_('warning: error "%s" in subrepository "%s"\n')
532 532 % (inst, subrelpath(self)))
533 533 return scmutil.status([], [], [], [], [], [], [])
534 534
535 535 @annotatesubrepoerror
536 536 def diff(self, ui, diffopts, node2, match, prefix, **opts):
537 537 try:
538 538 node1 = node.bin(self._state[1])
539 539 # We currently expect node2 to come from substate and be
540 540 # in hex format
541 541 if node2 is not None:
542 542 node2 = node.bin(node2)
543 543 logcmdutil.diffordiffstat(ui, self._repo, diffopts,
544 544 node1, node2, match,
545 545 prefix=posixpath.join(prefix, self._path),
546 546 listsubrepos=True, **opts)
547 547 except error.RepoLookupError as inst:
548 548 self.ui.warn(_('warning: error "%s" in subrepository "%s"\n')
549 549 % (inst, subrelpath(self)))
550 550
551 551 @annotatesubrepoerror
552 552 def archive(self, archiver, prefix, match=None, decode=True):
553 553 self._get(self._state + ('hg',))
554 554 files = self.files()
555 555 if match:
556 556 files = [f for f in files if match(f)]
557 557 rev = self._state[1]
558 558 ctx = self._repo[rev]
559 559 scmutil.fileprefetchhooks(self._repo, ctx, files)
560 560 total = abstractsubrepo.archive(self, archiver, prefix, match)
561 561 for subpath in ctx.substate:
562 562 s = subrepo(ctx, subpath, True)
563 563 submatch = matchmod.subdirmatcher(subpath, match)
564 564 total += s.archive(archiver, prefix + self._path + '/', submatch,
565 565 decode)
566 566 return total
567 567
568 568 @annotatesubrepoerror
569 569 def dirty(self, ignoreupdate=False, missing=False):
570 570 r = self._state[1]
571 571 if r == '' and not ignoreupdate: # no state recorded
572 572 return True
573 573 w = self._repo[None]
574 574 if r != w.p1().hex() and not ignoreupdate:
575 575 # different version checked out
576 576 return True
577 577 return w.dirty(missing=missing) # working directory changed
578 578
579 579 def basestate(self):
580 580 return self._repo['.'].hex()
581 581
582 582 def checknested(self, path):
583 583 return self._repo._checknested(self._repo.wjoin(path))
584 584
585 585 @annotatesubrepoerror
586 586 def commit(self, text, user, date):
587 587 # don't bother committing in the subrepo if it's only been
588 588 # updated
589 589 if not self.dirty(True):
590 590 return self._repo['.'].hex()
591 591 self.ui.debug("committing subrepo %s\n" % subrelpath(self))
592 592 n = self._repo.commit(text, user, date)
593 593 if not n:
594 594 return self._repo['.'].hex() # different version checked out
595 595 return node.hex(n)
596 596
597 597 @annotatesubrepoerror
598 598 def phase(self, state):
599 599 return self._repo[state].phase()
600 600
601 601 @annotatesubrepoerror
602 602 def remove(self):
603 603 # we can't fully delete the repository as it may contain
604 604 # local-only history
605 605 self.ui.note(_('removing subrepo %s\n') % subrelpath(self))
606 606 hg.clean(self._repo, node.nullid, False)
607 607
608 608 def _get(self, state):
609 609 source, revision, kind = state
610 610 parentrepo = self._repo._subparent
611 611
612 612 if revision in self._repo.unfiltered():
613 613 # Allow shared subrepos tracked at null to setup the sharedpath
614 614 if len(self._repo) != 0 or not parentrepo.shared():
615 615 return True
616 616 self._repo._subsource = source
617 617 srcurl = _abssource(self._repo)
618 618 other = hg.peer(self._repo, {}, srcurl)
619 619 if len(self._repo) == 0:
620 620 # use self._repo.vfs instead of self.wvfs to remove .hg only
621 621 self._repo.vfs.rmtree()
622 622 if parentrepo.shared():
623 623 self.ui.status(_('sharing subrepo %s from %s\n')
624 624 % (subrelpath(self), srcurl))
625 625 shared = hg.share(self._repo._subparent.baseui,
626 626 other, self._repo.root,
627 627 update=False, bookmarks=False)
628 628 self._repo = shared.local()
629 629 else:
630 630 self.ui.status(_('cloning subrepo %s from %s\n')
631 631 % (subrelpath(self), srcurl))
632 632 other, cloned = hg.clone(self._repo._subparent.baseui, {},
633 633 other, self._repo.root,
634 634 update=False)
635 635 self._repo = cloned.local()
636 636 self._initrepo(parentrepo, source, create=True)
637 637 self._cachestorehash(srcurl)
638 638 else:
639 639 self.ui.status(_('pulling subrepo %s from %s\n')
640 640 % (subrelpath(self), srcurl))
641 641 cleansub = self.storeclean(srcurl)
642 642 exchange.pull(self._repo, other)
643 643 if cleansub:
644 644 # keep the repo clean after pull
645 645 self._cachestorehash(srcurl)
646 646 return False
647 647
648 648 @annotatesubrepoerror
649 649 def get(self, state, overwrite=False):
650 650 inrepo = self._get(state)
651 651 source, revision, kind = state
652 652 repo = self._repo
653 653 repo.ui.debug("getting subrepo %s\n" % self._path)
654 654 if inrepo:
655 655 urepo = repo.unfiltered()
656 656 ctx = urepo[revision]
657 657 if ctx.hidden():
658 658 urepo.ui.warn(
659 659 _('revision %s in subrepository "%s" is hidden\n') \
660 660 % (revision[0:12], self._path))
661 661 repo = urepo
662 662 hg.updaterepo(repo, revision, overwrite)
663 663
664 664 @annotatesubrepoerror
665 665 def merge(self, state):
666 666 self._get(state)
667 667 cur = self._repo['.']
668 668 dst = self._repo[state[1]]
669 669 anc = dst.ancestor(cur)
670 670
671 671 def mergefunc():
672 672 if anc == cur and dst.branch() == cur.branch():
673 673 self.ui.debug('updating subrepository "%s"\n'
674 674 % subrelpath(self))
675 675 hg.update(self._repo, state[1])
676 676 elif anc == dst:
677 677 self.ui.debug('skipping subrepository "%s"\n'
678 678 % subrelpath(self))
679 679 else:
680 680 self.ui.debug('merging subrepository "%s"\n' % subrelpath(self))
681 681 hg.merge(self._repo, state[1], remind=False)
682 682
683 683 wctx = self._repo[None]
684 684 if self.dirty():
685 685 if anc != dst:
686 686 if _updateprompt(self.ui, self, wctx.dirty(), cur, dst):
687 687 mergefunc()
688 688 else:
689 689 mergefunc()
690 690 else:
691 691 mergefunc()
692 692
693 693 @annotatesubrepoerror
694 694 def push(self, opts):
695 695 force = opts.get('force')
696 696 newbranch = opts.get('new_branch')
697 697 ssh = opts.get('ssh')
698 698
699 699 # push subrepos depth-first for coherent ordering
700 700 c = self._repo['']
701 701 subs = c.substate # only repos that are committed
702 702 for s in sorted(subs):
703 703 if c.sub(s).push(opts) == 0:
704 704 return False
705 705
706 706 dsturl = _abssource(self._repo, True)
707 707 if not force:
708 708 if self.storeclean(dsturl):
709 709 self.ui.status(
710 710 _('no changes made to subrepo %s since last push to %s\n')
711 711 % (subrelpath(self), dsturl))
712 712 return None
713 713 self.ui.status(_('pushing subrepo %s to %s\n') %
714 714 (subrelpath(self), dsturl))
715 715 other = hg.peer(self._repo, {'ssh': ssh}, dsturl)
716 716 res = exchange.push(self._repo, other, force, newbranch=newbranch)
717 717
718 718 # the repo is now clean
719 719 self._cachestorehash(dsturl)
720 720 return res.cgresult
721 721
722 722 @annotatesubrepoerror
723 723 def outgoing(self, ui, dest, opts):
724 724 if 'rev' in opts or 'branch' in opts:
725 725 opts = copy.copy(opts)
726 726 opts.pop('rev', None)
727 727 opts.pop('branch', None)
728 728 return hg.outgoing(ui, self._repo, _abssource(self._repo, True), opts)
729 729
730 730 @annotatesubrepoerror
731 731 def incoming(self, ui, source, opts):
732 732 if 'rev' in opts or 'branch' in opts:
733 733 opts = copy.copy(opts)
734 734 opts.pop('rev', None)
735 735 opts.pop('branch', None)
736 736 return hg.incoming(ui, self._repo, _abssource(self._repo, False), opts)
737 737
738 738 @annotatesubrepoerror
739 739 def files(self):
740 740 rev = self._state[1]
741 741 ctx = self._repo[rev]
742 742 return ctx.manifest().keys()
743 743
744 744 def filedata(self, name, decode):
745 745 rev = self._state[1]
746 746 data = self._repo[rev][name].data()
747 747 if decode:
748 748 data = self._repo.wwritedata(name, data)
749 749 return data
750 750
751 751 def fileflags(self, name):
752 752 rev = self._state[1]
753 753 ctx = self._repo[rev]
754 754 return ctx.flags(name)
755 755
756 756 @annotatesubrepoerror
757 757 def printfiles(self, ui, m, fm, fmt, subrepos):
758 758 # If the parent context is a workingctx, use the workingctx here for
759 759 # consistency.
760 760 if self._ctx.rev() is None:
761 761 ctx = self._repo[None]
762 762 else:
763 763 rev = self._state[1]
764 764 ctx = self._repo[rev]
765 765 return cmdutil.files(ui, ctx, m, fm, fmt, subrepos)
766 766
767 767 @annotatesubrepoerror
768 768 def getfileset(self, expr):
769 769 if self._ctx.rev() is None:
770 770 ctx = self._repo[None]
771 771 else:
772 772 rev = self._state[1]
773 773 ctx = self._repo[rev]
774 774
775 775 files = ctx.getfileset(expr)
776 776
777 777 for subpath in ctx.substate:
778 778 sub = ctx.sub(subpath)
779 779
780 780 try:
781 781 files.extend(subpath + '/' + f for f in sub.getfileset(expr))
782 782 except error.LookupError:
783 783 self.ui.status(_("skipping missing subrepository: %s\n")
784 784 % self.wvfs.reljoin(reporelpath(self), subpath))
785 785 return files
786 786
787 787 def walk(self, match):
788 788 ctx = self._repo[None]
789 789 return ctx.walk(match)
790 790
791 791 @annotatesubrepoerror
792 792 def forget(self, match, prefix):
793 793 return cmdutil.forget(self.ui, self._repo, match,
794 794 self.wvfs.reljoin(prefix, self._path), True)
795 795
796 796 @annotatesubrepoerror
797 797 def removefiles(self, matcher, prefix, after, force, subrepos, warnings):
798 798 return cmdutil.remove(self.ui, self._repo, matcher,
799 799 self.wvfs.reljoin(prefix, self._path),
800 800 after, force, subrepos)
801 801
802 802 @annotatesubrepoerror
803 803 def revert(self, substate, *pats, **opts):
804 804 # reverting a subrepo is a 2 step process:
805 805 # 1. if the no_backup is not set, revert all modified
806 806 # files inside the subrepo
807 807 # 2. update the subrepo to the revision specified in
808 808 # the corresponding substate dictionary
809 809 self.ui.status(_('reverting subrepo %s\n') % substate[0])
810 810 if not opts.get(r'no_backup'):
811 811 # Revert all files on the subrepo, creating backups
812 812 # Note that this will not recursively revert subrepos
813 813 # We could do it if there was a set:subrepos() predicate
814 814 opts = opts.copy()
815 815 opts[r'date'] = None
816 816 opts[r'rev'] = substate[1]
817 817
818 818 self.filerevert(*pats, **opts)
819 819
820 820 # Update the repo to the revision specified in the given substate
821 821 if not opts.get(r'dry_run'):
822 822 self.get(substate, overwrite=True)
823 823
824 824 def filerevert(self, *pats, **opts):
825 825 ctx = self._repo[opts[r'rev']]
826 826 parents = self._repo.dirstate.parents()
827 827 if opts.get(r'all'):
828 828 pats = ['set:modified()']
829 829 else:
830 830 pats = []
831 831 cmdutil.revert(self.ui, self._repo, ctx, parents, *pats, **opts)
832 832
833 833 def shortid(self, revid):
834 834 return revid[:12]
835 835
836 836 @annotatesubrepoerror
837 837 def unshare(self):
838 838 # subrepo inherently violates our import layering rules
839 839 # because it wants to make repo objects from deep inside the stack
840 840 # so we manually delay the circular imports to not break
841 841 # scripts that don't use our demand-loading
842 842 global hg
843 843 from . import hg as h
844 844 hg = h
845 845
846 846 # Nothing prevents a user from sharing in a repo, and then making that a
847 847 # subrepo. Alternately, the previous unshare attempt may have failed
848 848 # part way through. So recurse whether or not this layer is shared.
849 849 if self._repo.shared():
850 850 self.ui.status(_("unsharing subrepo '%s'\n") % self._relpath)
851 851
852 852 hg.unshare(self.ui, self._repo)
853 853
854 854 def verify(self):
855 855 try:
856 856 rev = self._state[1]
857 857 ctx = self._repo.unfiltered()[rev]
858 858 if ctx.hidden():
859 859 # Since hidden revisions aren't pushed/pulled, it seems worth an
860 860 # explicit warning.
861 861 ui = self._repo.ui
862 862 ui.warn(_("subrepo '%s' is hidden in revision %s\n") %
863 863 (self._relpath, node.short(self._ctx.node())))
864 864 return 0
865 865 except error.RepoLookupError:
866 866 # A missing subrepo revision may be a case of needing to pull it, so
867 867 # don't treat this as an error.
868 868 self._repo.ui.warn(_("subrepo '%s' not found in revision %s\n") %
869 869 (self._relpath, node.short(self._ctx.node())))
870 870 return 0
871 871
872 872 @propertycache
873 873 def wvfs(self):
874 874 """return own wvfs for efficiency and consistency
875 875 """
876 876 return self._repo.wvfs
877 877
878 878 @propertycache
879 879 def _relpath(self):
880 880 """return path to this subrepository as seen from outermost repository
881 881 """
882 882 # Keep consistent dir separators by avoiding vfs.join(self._path)
883 883 return reporelpath(self._repo)
884 884
885 885 class svnsubrepo(abstractsubrepo):
886 886 def __init__(self, ctx, path, state, allowcreate):
887 887 super(svnsubrepo, self).__init__(ctx, path)
888 888 self._state = state
889 889 self._exe = util.findexe('svn')
890 890 if not self._exe:
891 891 raise error.Abort(_("'svn' executable not found for subrepo '%s'")
892 892 % self._path)
893 893
894 894 def _svncommand(self, commands, filename='', failok=False):
895 895 cmd = [self._exe]
896 896 extrakw = {}
897 897 if not self.ui.interactive():
898 898 # Making stdin be a pipe should prevent svn from behaving
899 899 # interactively even if we can't pass --non-interactive.
900 900 extrakw[r'stdin'] = subprocess.PIPE
901 901 # Starting in svn 1.5 --non-interactive is a global flag
902 902 # instead of being per-command, but we need to support 1.4 so
903 903 # we have to be intelligent about what commands take
904 904 # --non-interactive.
905 905 if commands[0] in ('update', 'checkout', 'commit'):
906 906 cmd.append('--non-interactive')
907 907 cmd.extend(commands)
908 908 if filename is not None:
909 909 path = self.wvfs.reljoin(self._ctx.repo().origroot,
910 910 self._path, filename)
911 911 cmd.append(path)
912 912 env = dict(encoding.environ)
913 913 # Avoid localized output, preserve current locale for everything else.
914 914 lc_all = env.get('LC_ALL')
915 915 if lc_all:
916 916 env['LANG'] = lc_all
917 917 del env['LC_ALL']
918 918 env['LC_MESSAGES'] = 'C'
919 919 p = subprocess.Popen(cmd, bufsize=-1, close_fds=util.closefds,
920 920 stdout=subprocess.PIPE, stderr=subprocess.PIPE,
921 921 universal_newlines=True, env=env, **extrakw)
922 922 stdout, stderr = p.communicate()
923 923 stderr = stderr.strip()
924 924 if not failok:
925 925 if p.returncode:
926 926 raise error.Abort(stderr or 'exited with code %d'
927 927 % p.returncode)
928 928 if stderr:
929 929 self.ui.warn(stderr + '\n')
930 930 return stdout, stderr
931 931
932 932 @propertycache
933 933 def _svnversion(self):
934 934 output, err = self._svncommand(['--version', '--quiet'], filename=None)
935 935 m = re.search(br'^(\d+)\.(\d+)', output)
936 936 if not m:
937 937 raise error.Abort(_('cannot retrieve svn tool version'))
938 938 return (int(m.group(1)), int(m.group(2)))
939 939
940 940 def _svnmissing(self):
941 941 return not self.wvfs.exists('.svn')
942 942
943 943 def _wcrevs(self):
944 944 # Get the working directory revision as well as the last
945 945 # commit revision so we can compare the subrepo state with
946 946 # both. We used to store the working directory one.
947 947 output, err = self._svncommand(['info', '--xml'])
948 948 doc = xml.dom.minidom.parseString(output)
949 949 entries = doc.getElementsByTagName('entry')
950 950 lastrev, rev = '0', '0'
951 951 if entries:
952 952 rev = str(entries[0].getAttribute('revision')) or '0'
953 953 commits = entries[0].getElementsByTagName('commit')
954 954 if commits:
955 955 lastrev = str(commits[0].getAttribute('revision')) or '0'
956 956 return (lastrev, rev)
957 957
958 958 def _wcrev(self):
959 959 return self._wcrevs()[0]
960 960
961 961 def _wcchanged(self):
962 962 """Return (changes, extchanges, missing) where changes is True
963 963 if the working directory was changed, extchanges is
964 964 True if any of these changes concern an external entry and missing
965 965 is True if any change is a missing entry.
966 966 """
967 967 output, err = self._svncommand(['status', '--xml'])
968 968 externals, changes, missing = [], [], []
969 969 doc = xml.dom.minidom.parseString(output)
970 970 for e in doc.getElementsByTagName('entry'):
971 971 s = e.getElementsByTagName('wc-status')
972 972 if not s:
973 973 continue
974 974 item = s[0].getAttribute('item')
975 975 props = s[0].getAttribute('props')
976 976 path = e.getAttribute('path')
977 977 if item == 'external':
978 978 externals.append(path)
979 979 elif item == 'missing':
980 980 missing.append(path)
981 981 if (item not in ('', 'normal', 'unversioned', 'external')
982 982 or props not in ('', 'none', 'normal')):
983 983 changes.append(path)
984 984 for path in changes:
985 985 for ext in externals:
986 986 if path == ext or path.startswith(ext + pycompat.ossep):
987 987 return True, True, bool(missing)
988 988 return bool(changes), False, bool(missing)
989 989
990 990 @annotatesubrepoerror
991 991 def dirty(self, ignoreupdate=False, missing=False):
992 992 if self._svnmissing():
993 993 return self._state[1] != ''
994 994 wcchanged = self._wcchanged()
995 995 changed = wcchanged[0] or (missing and wcchanged[2])
996 996 if not changed:
997 997 if self._state[1] in self._wcrevs() or ignoreupdate:
998 998 return False
999 999 return True
1000 1000
1001 1001 def basestate(self):
1002 1002 lastrev, rev = self._wcrevs()
1003 1003 if lastrev != rev:
1004 1004 # Last committed rev is not the same than rev. We would
1005 1005 # like to take lastrev but we do not know if the subrepo
1006 1006 # URL exists at lastrev. Test it and fallback to rev it
1007 1007 # is not there.
1008 1008 try:
1009 1009 self._svncommand(['list', '%s@%s' % (self._state[0], lastrev)])
1010 1010 return lastrev
1011 1011 except error.Abort:
1012 1012 pass
1013 1013 return rev
1014 1014
1015 1015 @annotatesubrepoerror
1016 1016 def commit(self, text, user, date):
1017 1017 # user and date are out of our hands since svn is centralized
1018 1018 changed, extchanged, missing = self._wcchanged()
1019 1019 if not changed:
1020 1020 return self.basestate()
1021 1021 if extchanged:
1022 1022 # Do not try to commit externals
1023 1023 raise error.Abort(_('cannot commit svn externals'))
1024 1024 if missing:
1025 1025 # svn can commit with missing entries but aborting like hg
1026 1026 # seems a better approach.
1027 1027 raise error.Abort(_('cannot commit missing svn entries'))
1028 1028 commitinfo, err = self._svncommand(['commit', '-m', text])
1029 1029 self.ui.status(commitinfo)
1030 1030 newrev = re.search('Committed revision ([0-9]+).', commitinfo)
1031 1031 if not newrev:
1032 1032 if not commitinfo.strip():
1033 1033 # Sometimes, our definition of "changed" differs from
1034 1034 # svn one. For instance, svn ignores missing files
1035 1035 # when committing. If there are only missing files, no
1036 1036 # commit is made, no output and no error code.
1037 1037 raise error.Abort(_('failed to commit svn changes'))
1038 1038 raise error.Abort(commitinfo.splitlines()[-1])
1039 1039 newrev = newrev.groups()[0]
1040 1040 self.ui.status(self._svncommand(['update', '-r', newrev])[0])
1041 1041 return newrev
1042 1042
1043 1043 @annotatesubrepoerror
1044 1044 def remove(self):
1045 1045 if self.dirty():
1046 1046 self.ui.warn(_('not removing repo %s because '
1047 1047 'it has changes.\n') % self._path)
1048 1048 return
1049 1049 self.ui.note(_('removing subrepo %s\n') % self._path)
1050 1050
1051 1051 self.wvfs.rmtree(forcibly=True)
1052 1052 try:
1053 1053 pwvfs = self._ctx.repo().wvfs
1054 1054 pwvfs.removedirs(pwvfs.dirname(self._path))
1055 1055 except OSError:
1056 1056 pass
1057 1057
1058 1058 @annotatesubrepoerror
1059 1059 def get(self, state, overwrite=False):
1060 1060 if overwrite:
1061 1061 self._svncommand(['revert', '--recursive'])
1062 1062 args = ['checkout']
1063 1063 if self._svnversion >= (1, 5):
1064 1064 args.append('--force')
1065 1065 # The revision must be specified at the end of the URL to properly
1066 1066 # update to a directory which has since been deleted and recreated.
1067 1067 args.append('%s@%s' % (state[0], state[1]))
1068 1068
1069 1069 # SEC: check that the ssh url is safe
1070 1070 util.checksafessh(state[0])
1071 1071
1072 1072 status, err = self._svncommand(args, failok=True)
1073 1073 _sanitize(self.ui, self.wvfs, '.svn')
1074 1074 if not re.search('Checked out revision [0-9]+.', status):
1075 1075 if ('is already a working copy for a different URL' in err
1076 1076 and (self._wcchanged()[:2] == (False, False))):
1077 1077 # obstructed but clean working copy, so just blow it away.
1078 1078 self.remove()
1079 1079 self.get(state, overwrite=False)
1080 1080 return
1081 1081 raise error.Abort((status or err).splitlines()[-1])
1082 1082 self.ui.status(status)
1083 1083
1084 1084 @annotatesubrepoerror
1085 1085 def merge(self, state):
1086 1086 old = self._state[1]
1087 1087 new = state[1]
1088 1088 wcrev = self._wcrev()
1089 1089 if new != wcrev:
1090 1090 dirty = old == wcrev or self._wcchanged()[0]
1091 1091 if _updateprompt(self.ui, self, dirty, wcrev, new):
1092 1092 self.get(state, False)
1093 1093
1094 1094 def push(self, opts):
1095 1095 # push is a no-op for SVN
1096 1096 return True
1097 1097
1098 1098 @annotatesubrepoerror
1099 1099 def files(self):
1100 1100 output = self._svncommand(['list', '--recursive', '--xml'])[0]
1101 1101 doc = xml.dom.minidom.parseString(output)
1102 1102 paths = []
1103 1103 for e in doc.getElementsByTagName('entry'):
1104 1104 kind = str(e.getAttribute('kind'))
1105 1105 if kind != 'file':
1106 1106 continue
1107 1107 name = ''.join(c.data for c
1108 1108 in e.getElementsByTagName('name')[0].childNodes
1109 1109 if c.nodeType == c.TEXT_NODE)
1110 1110 paths.append(name.encode('utf-8'))
1111 1111 return paths
1112 1112
1113 1113 def filedata(self, name, decode):
1114 1114 return self._svncommand(['cat'], name)[0]
1115 1115
1116 1116
1117 1117 class gitsubrepo(abstractsubrepo):
1118 1118 def __init__(self, ctx, path, state, allowcreate):
1119 1119 super(gitsubrepo, self).__init__(ctx, path)
1120 1120 self._state = state
1121 1121 self._abspath = ctx.repo().wjoin(path)
1122 1122 self._subparent = ctx.repo()
1123 1123 self._ensuregit()
1124 1124
1125 1125 def _ensuregit(self):
1126 1126 try:
1127 1127 self._gitexecutable = 'git'
1128 1128 out, err = self._gitnodir(['--version'])
1129 1129 except OSError as e:
1130 1130 genericerror = _("error executing git for subrepo '%s': %s")
1131 1131 notfoundhint = _("check git is installed and in your PATH")
1132 1132 if e.errno != errno.ENOENT:
1133 1133 raise error.Abort(genericerror % (
1134 1134 self._path, encoding.strtolocal(e.strerror)))
1135 1135 elif pycompat.iswindows:
1136 1136 try:
1137 1137 self._gitexecutable = 'git.cmd'
1138 1138 out, err = self._gitnodir(['--version'])
1139 1139 except OSError as e2:
1140 1140 if e2.errno == errno.ENOENT:
1141 1141 raise error.Abort(_("couldn't find 'git' or 'git.cmd'"
1142 1142 " for subrepo '%s'") % self._path,
1143 1143 hint=notfoundhint)
1144 1144 else:
1145 1145 raise error.Abort(genericerror % (self._path,
1146 1146 encoding.strtolocal(e2.strerror)))
1147 1147 else:
1148 1148 raise error.Abort(_("couldn't find git for subrepo '%s'")
1149 1149 % self._path, hint=notfoundhint)
1150 1150 versionstatus = self._checkversion(out)
1151 1151 if versionstatus == 'unknown':
1152 1152 self.ui.warn(_('cannot retrieve git version\n'))
1153 1153 elif versionstatus == 'abort':
1154 1154 raise error.Abort(_('git subrepo requires at least 1.6.0 or later'))
1155 1155 elif versionstatus == 'warning':
1156 1156 self.ui.warn(_('git subrepo requires at least 1.6.0 or later\n'))
1157 1157
1158 1158 @staticmethod
1159 1159 def _gitversion(out):
1160 1160 m = re.search(br'^git version (\d+)\.(\d+)\.(\d+)', out)
1161 1161 if m:
1162 1162 return (int(m.group(1)), int(m.group(2)), int(m.group(3)))
1163 1163
1164 1164 m = re.search(br'^git version (\d+)\.(\d+)', out)
1165 1165 if m:
1166 1166 return (int(m.group(1)), int(m.group(2)), 0)
1167 1167
1168 1168 return -1
1169 1169
1170 1170 @staticmethod
1171 1171 def _checkversion(out):
1172 1172 '''ensure git version is new enough
1173 1173
1174 1174 >>> _checkversion = gitsubrepo._checkversion
1175 1175 >>> _checkversion(b'git version 1.6.0')
1176 1176 'ok'
1177 1177 >>> _checkversion(b'git version 1.8.5')
1178 1178 'ok'
1179 1179 >>> _checkversion(b'git version 1.4.0')
1180 1180 'abort'
1181 1181 >>> _checkversion(b'git version 1.5.0')
1182 1182 'warning'
1183 1183 >>> _checkversion(b'git version 1.9-rc0')
1184 1184 'ok'
1185 1185 >>> _checkversion(b'git version 1.9.0.265.g81cdec2')
1186 1186 'ok'
1187 1187 >>> _checkversion(b'git version 1.9.0.GIT')
1188 1188 'ok'
1189 1189 >>> _checkversion(b'git version 12345')
1190 1190 'unknown'
1191 1191 >>> _checkversion(b'no')
1192 1192 'unknown'
1193 1193 '''
1194 1194 version = gitsubrepo._gitversion(out)
1195 1195 # git 1.4.0 can't work at all, but 1.5.X can in at least some cases,
1196 1196 # despite the docstring comment. For now, error on 1.4.0, warn on
1197 1197 # 1.5.0 but attempt to continue.
1198 1198 if version == -1:
1199 1199 return 'unknown'
1200 1200 if version < (1, 5, 0):
1201 1201 return 'abort'
1202 1202 elif version < (1, 6, 0):
1203 1203 return 'warning'
1204 1204 return 'ok'
1205 1205
1206 1206 def _gitcommand(self, commands, env=None, stream=False):
1207 1207 return self._gitdir(commands, env=env, stream=stream)[0]
1208 1208
1209 1209 def _gitdir(self, commands, env=None, stream=False):
1210 1210 return self._gitnodir(commands, env=env, stream=stream,
1211 1211 cwd=self._abspath)
1212 1212
1213 1213 def _gitnodir(self, commands, env=None, stream=False, cwd=None):
1214 1214 """Calls the git command
1215 1215
1216 1216 The methods tries to call the git command. versions prior to 1.6.0
1217 1217 are not supported and very probably fail.
1218 1218 """
1219 1219 self.ui.debug('%s: git %s\n' % (self._relpath, ' '.join(commands)))
1220 1220 if env is None:
1221 1221 env = encoding.environ.copy()
1222 1222 # disable localization for Git output (issue5176)
1223 1223 env['LC_ALL'] = 'C'
1224 1224 # fix for Git CVE-2015-7545
1225 1225 if 'GIT_ALLOW_PROTOCOL' not in env:
1226 1226 env['GIT_ALLOW_PROTOCOL'] = 'file:git:http:https:ssh'
1227 1227 # unless ui.quiet is set, print git's stderr,
1228 1228 # which is mostly progress and useful info
1229 1229 errpipe = None
1230 1230 if self.ui.quiet:
1231 1231 errpipe = open(os.devnull, 'w')
1232 1232 if self.ui._colormode and len(commands) and commands[0] == "diff":
1233 1233 # insert the argument in the front,
1234 1234 # the end of git diff arguments is used for paths
1235 1235 commands.insert(1, '--color')
1236 1236 p = subprocess.Popen([self._gitexecutable] + commands, bufsize=-1,
1237 1237 cwd=cwd, env=env, close_fds=util.closefds,
1238 1238 stdout=subprocess.PIPE, stderr=errpipe)
1239 1239 if stream:
1240 1240 return p.stdout, None
1241 1241
1242 1242 retdata = p.stdout.read().strip()
1243 1243 # wait for the child to exit to avoid race condition.
1244 1244 p.wait()
1245 1245
1246 1246 if p.returncode != 0 and p.returncode != 1:
1247 1247 # there are certain error codes that are ok
1248 1248 command = commands[0]
1249 1249 if command in ('cat-file', 'symbolic-ref'):
1250 1250 return retdata, p.returncode
1251 1251 # for all others, abort
1252 1252 raise error.Abort(_('git %s error %d in %s') %
1253 1253 (command, p.returncode, self._relpath))
1254 1254
1255 1255 return retdata, p.returncode
1256 1256
1257 1257 def _gitmissing(self):
1258 1258 return not self.wvfs.exists('.git')
1259 1259
1260 1260 def _gitstate(self):
1261 1261 return self._gitcommand(['rev-parse', 'HEAD'])
1262 1262
1263 1263 def _gitcurrentbranch(self):
1264 1264 current, err = self._gitdir(['symbolic-ref', 'HEAD', '--quiet'])
1265 1265 if err:
1266 1266 current = None
1267 1267 return current
1268 1268
1269 1269 def _gitremote(self, remote):
1270 1270 out = self._gitcommand(['remote', 'show', '-n', remote])
1271 1271 line = out.split('\n')[1]
1272 1272 i = line.index('URL: ') + len('URL: ')
1273 1273 return line[i:]
1274 1274
1275 1275 def _githavelocally(self, revision):
1276 1276 out, code = self._gitdir(['cat-file', '-e', revision])
1277 1277 return code == 0
1278 1278
1279 1279 def _gitisancestor(self, r1, r2):
1280 1280 base = self._gitcommand(['merge-base', r1, r2])
1281 1281 return base == r1
1282 1282
1283 1283 def _gitisbare(self):
1284 1284 return self._gitcommand(['config', '--bool', 'core.bare']) == 'true'
1285 1285
1286 1286 def _gitupdatestat(self):
1287 1287 """This must be run before git diff-index.
1288 1288 diff-index only looks at changes to file stat;
1289 1289 this command looks at file contents and updates the stat."""
1290 1290 self._gitcommand(['update-index', '-q', '--refresh'])
1291 1291
1292 1292 def _gitbranchmap(self):
1293 1293 '''returns 2 things:
1294 1294 a map from git branch to revision
1295 1295 a map from revision to branches'''
1296 1296 branch2rev = {}
1297 1297 rev2branch = {}
1298 1298
1299 1299 out = self._gitcommand(['for-each-ref', '--format',
1300 1300 '%(objectname) %(refname)'])
1301 1301 for line in out.split('\n'):
1302 1302 revision, ref = line.split(' ')
1303 1303 if (not ref.startswith('refs/heads/') and
1304 1304 not ref.startswith('refs/remotes/')):
1305 1305 continue
1306 1306 if ref.startswith('refs/remotes/') and ref.endswith('/HEAD'):
1307 1307 continue # ignore remote/HEAD redirects
1308 1308 branch2rev[ref] = revision
1309 1309 rev2branch.setdefault(revision, []).append(ref)
1310 1310 return branch2rev, rev2branch
1311 1311
1312 1312 def _gittracking(self, branches):
1313 1313 'return map of remote branch to local tracking branch'
1314 1314 # assumes no more than one local tracking branch for each remote
1315 1315 tracking = {}
1316 1316 for b in branches:
1317 1317 if b.startswith('refs/remotes/'):
1318 1318 continue
1319 1319 bname = b.split('/', 2)[2]
1320 1320 remote = self._gitcommand(['config', 'branch.%s.remote' % bname])
1321 1321 if remote:
1322 1322 ref = self._gitcommand(['config', 'branch.%s.merge' % bname])
1323 1323 tracking['refs/remotes/%s/%s' %
1324 1324 (remote, ref.split('/', 2)[2])] = b
1325 1325 return tracking
1326 1326
1327 1327 def _abssource(self, source):
1328 1328 if '://' not in source:
1329 1329 # recognize the scp syntax as an absolute source
1330 1330 colon = source.find(':')
1331 1331 if colon != -1 and '/' not in source[:colon]:
1332 1332 return source
1333 1333 self._subsource = source
1334 1334 return _abssource(self)
1335 1335
1336 1336 def _fetch(self, source, revision):
1337 1337 if self._gitmissing():
1338 1338 # SEC: check for safe ssh url
1339 1339 util.checksafessh(source)
1340 1340
1341 1341 source = self._abssource(source)
1342 1342 self.ui.status(_('cloning subrepo %s from %s\n') %
1343 1343 (self._relpath, source))
1344 1344 self._gitnodir(['clone', source, self._abspath])
1345 1345 if self._githavelocally(revision):
1346 1346 return
1347 1347 self.ui.status(_('pulling subrepo %s from %s\n') %
1348 1348 (self._relpath, self._gitremote('origin')))
1349 1349 # try only origin: the originally cloned repo
1350 1350 self._gitcommand(['fetch'])
1351 1351 if not self._githavelocally(revision):
1352 1352 raise error.Abort(_('revision %s does not exist in subrepository '
1353 1353 '"%s"\n') % (revision, self._relpath))
1354 1354
1355 1355 @annotatesubrepoerror
1356 1356 def dirty(self, ignoreupdate=False, missing=False):
1357 1357 if self._gitmissing():
1358 1358 return self._state[1] != ''
1359 1359 if self._gitisbare():
1360 1360 return True
1361 1361 if not ignoreupdate and self._state[1] != self._gitstate():
1362 1362 # different version checked out
1363 1363 return True
1364 1364 # check for staged changes or modified files; ignore untracked files
1365 1365 self._gitupdatestat()
1366 1366 out, code = self._gitdir(['diff-index', '--quiet', 'HEAD'])
1367 1367 return code == 1
1368 1368
1369 1369 def basestate(self):
1370 1370 return self._gitstate()
1371 1371
1372 1372 @annotatesubrepoerror
1373 1373 def get(self, state, overwrite=False):
1374 1374 source, revision, kind = state
1375 1375 if not revision:
1376 1376 self.remove()
1377 1377 return
1378 1378 self._fetch(source, revision)
1379 1379 # if the repo was set to be bare, unbare it
1380 1380 if self._gitisbare():
1381 1381 self._gitcommand(['config', 'core.bare', 'false'])
1382 1382 if self._gitstate() == revision:
1383 1383 self._gitcommand(['reset', '--hard', 'HEAD'])
1384 1384 return
1385 1385 elif self._gitstate() == revision:
1386 1386 if overwrite:
1387 1387 # first reset the index to unmark new files for commit, because
1388 1388 # reset --hard will otherwise throw away files added for commit,
1389 1389 # not just unmark them.
1390 1390 self._gitcommand(['reset', 'HEAD'])
1391 1391 self._gitcommand(['reset', '--hard', 'HEAD'])
1392 1392 return
1393 1393 branch2rev, rev2branch = self._gitbranchmap()
1394 1394
1395 1395 def checkout(args):
1396 1396 cmd = ['checkout']
1397 1397 if overwrite:
1398 1398 # first reset the index to unmark new files for commit, because
1399 1399 # the -f option will otherwise throw away files added for
1400 1400 # commit, not just unmark them.
1401 1401 self._gitcommand(['reset', 'HEAD'])
1402 1402 cmd.append('-f')
1403 1403 self._gitcommand(cmd + args)
1404 1404 _sanitize(self.ui, self.wvfs, '.git')
1405 1405
1406 1406 def rawcheckout():
1407 1407 # no branch to checkout, check it out with no branch
1408 1408 self.ui.warn(_('checking out detached HEAD in '
1409 1409 'subrepository "%s"\n') % self._relpath)
1410 1410 self.ui.warn(_('check out a git branch if you intend '
1411 1411 'to make changes\n'))
1412 1412 checkout(['-q', revision])
1413 1413
1414 1414 if revision not in rev2branch:
1415 1415 rawcheckout()
1416 1416 return
1417 1417 branches = rev2branch[revision]
1418 1418 firstlocalbranch = None
1419 1419 for b in branches:
1420 1420 if b == 'refs/heads/master':
1421 1421 # master trumps all other branches
1422 1422 checkout(['refs/heads/master'])
1423 1423 return
1424 1424 if not firstlocalbranch and not b.startswith('refs/remotes/'):
1425 1425 firstlocalbranch = b
1426 1426 if firstlocalbranch:
1427 1427 checkout([firstlocalbranch])
1428 1428 return
1429 1429
1430 1430 tracking = self._gittracking(branch2rev.keys())
1431 1431 # choose a remote branch already tracked if possible
1432 1432 remote = branches[0]
1433 1433 if remote not in tracking:
1434 1434 for b in branches:
1435 1435 if b in tracking:
1436 1436 remote = b
1437 1437 break
1438 1438
1439 1439 if remote not in tracking:
1440 1440 # create a new local tracking branch
1441 1441 local = remote.split('/', 3)[3]
1442 1442 checkout(['-b', local, remote])
1443 1443 elif self._gitisancestor(branch2rev[tracking[remote]], remote):
1444 1444 # When updating to a tracked remote branch,
1445 1445 # if the local tracking branch is downstream of it,
1446 1446 # a normal `git pull` would have performed a "fast-forward merge"
1447 1447 # which is equivalent to updating the local branch to the remote.
1448 1448 # Since we are only looking at branching at update, we need to
1449 1449 # detect this situation and perform this action lazily.
1450 1450 if tracking[remote] != self._gitcurrentbranch():
1451 1451 checkout([tracking[remote]])
1452 1452 self._gitcommand(['merge', '--ff', remote])
1453 1453 _sanitize(self.ui, self.wvfs, '.git')
1454 1454 else:
1455 1455 # a real merge would be required, just checkout the revision
1456 1456 rawcheckout()
1457 1457
1458 1458 @annotatesubrepoerror
1459 1459 def commit(self, text, user, date):
1460 1460 if self._gitmissing():
1461 1461 raise error.Abort(_("subrepo %s is missing") % self._relpath)
1462 1462 cmd = ['commit', '-a', '-m', text]
1463 1463 env = encoding.environ.copy()
1464 1464 if user:
1465 1465 cmd += ['--author', user]
1466 1466 if date:
1467 1467 # git's date parser silently ignores when seconds < 1e9
1468 1468 # convert to ISO8601
1469 1469 env['GIT_AUTHOR_DATE'] = util.datestr(date,
1470 1470 '%Y-%m-%dT%H:%M:%S %1%2')
1471 1471 self._gitcommand(cmd, env=env)
1472 1472 # make sure commit works otherwise HEAD might not exist under certain
1473 1473 # circumstances
1474 1474 return self._gitstate()
1475 1475
1476 1476 @annotatesubrepoerror
1477 1477 def merge(self, state):
1478 1478 source, revision, kind = state
1479 1479 self._fetch(source, revision)
1480 1480 base = self._gitcommand(['merge-base', revision, self._state[1]])
1481 1481 self._gitupdatestat()
1482 1482 out, code = self._gitdir(['diff-index', '--quiet', 'HEAD'])
1483 1483
1484 1484 def mergefunc():
1485 1485 if base == revision:
1486 1486 self.get(state) # fast forward merge
1487 1487 elif base != self._state[1]:
1488 1488 self._gitcommand(['merge', '--no-commit', revision])
1489 1489 _sanitize(self.ui, self.wvfs, '.git')
1490 1490
1491 1491 if self.dirty():
1492 1492 if self._gitstate() != revision:
1493 1493 dirty = self._gitstate() == self._state[1] or code != 0
1494 1494 if _updateprompt(self.ui, self, dirty,
1495 1495 self._state[1][:7], revision[:7]):
1496 1496 mergefunc()
1497 1497 else:
1498 1498 mergefunc()
1499 1499
1500 1500 @annotatesubrepoerror
1501 1501 def push(self, opts):
1502 1502 force = opts.get('force')
1503 1503
1504 1504 if not self._state[1]:
1505 1505 return True
1506 1506 if self._gitmissing():
1507 1507 raise error.Abort(_("subrepo %s is missing") % self._relpath)
1508 1508 # if a branch in origin contains the revision, nothing to do
1509 1509 branch2rev, rev2branch = self._gitbranchmap()
1510 1510 if self._state[1] in rev2branch:
1511 1511 for b in rev2branch[self._state[1]]:
1512 1512 if b.startswith('refs/remotes/origin/'):
1513 1513 return True
1514 1514 for b, revision in branch2rev.iteritems():
1515 1515 if b.startswith('refs/remotes/origin/'):
1516 1516 if self._gitisancestor(self._state[1], revision):
1517 1517 return True
1518 1518 # otherwise, try to push the currently checked out branch
1519 1519 cmd = ['push']
1520 1520 if force:
1521 1521 cmd.append('--force')
1522 1522
1523 1523 current = self._gitcurrentbranch()
1524 1524 if current:
1525 1525 # determine if the current branch is even useful
1526 1526 if not self._gitisancestor(self._state[1], current):
1527 1527 self.ui.warn(_('unrelated git branch checked out '
1528 1528 'in subrepository "%s"\n') % self._relpath)
1529 1529 return False
1530 1530 self.ui.status(_('pushing branch %s of subrepository "%s"\n') %
1531 1531 (current.split('/', 2)[2], self._relpath))
1532 1532 ret = self._gitdir(cmd + ['origin', current])
1533 1533 return ret[1] == 0
1534 1534 else:
1535 1535 self.ui.warn(_('no branch checked out in subrepository "%s"\n'
1536 1536 'cannot push revision %s\n') %
1537 1537 (self._relpath, self._state[1]))
1538 1538 return False
1539 1539
1540 1540 @annotatesubrepoerror
1541 1541 def add(self, ui, match, prefix, explicitonly, **opts):
1542 1542 if self._gitmissing():
1543 1543 return []
1544 1544
1545 1545 (modified, added, removed,
1546 1546 deleted, unknown, ignored, clean) = self.status(None, unknown=True,
1547 1547 clean=True)
1548 1548
1549 1549 tracked = set()
1550 1550 # dirstates 'amn' warn, 'r' is added again
1551 1551 for l in (modified, added, deleted, clean):
1552 1552 tracked.update(l)
1553 1553
1554 1554 # Unknown files not of interest will be rejected by the matcher
1555 1555 files = unknown
1556 1556 files.extend(match.files())
1557 1557
1558 1558 rejected = []
1559 1559
1560 1560 files = [f for f in sorted(set(files)) if match(f)]
1561 1561 for f in files:
1562 1562 exact = match.exact(f)
1563 1563 command = ["add"]
1564 1564 if exact:
1565 1565 command.append("-f") #should be added, even if ignored
1566 1566 if ui.verbose or not exact:
1567 1567 ui.status(_('adding %s\n') % match.rel(f))
1568 1568
1569 1569 if f in tracked: # hg prints 'adding' even if already tracked
1570 1570 if exact:
1571 1571 rejected.append(f)
1572 1572 continue
1573 1573 if not opts.get(r'dry_run'):
1574 1574 self._gitcommand(command + [f])
1575 1575
1576 1576 for f in rejected:
1577 1577 ui.warn(_("%s already tracked!\n") % match.abs(f))
1578 1578
1579 1579 return rejected
1580 1580
1581 1581 @annotatesubrepoerror
1582 1582 def remove(self):
1583 1583 if self._gitmissing():
1584 1584 return
1585 1585 if self.dirty():
1586 1586 self.ui.warn(_('not removing repo %s because '
1587 1587 'it has changes.\n') % self._relpath)
1588 1588 return
1589 1589 # we can't fully delete the repository as it may contain
1590 1590 # local-only history
1591 1591 self.ui.note(_('removing subrepo %s\n') % self._relpath)
1592 1592 self._gitcommand(['config', 'core.bare', 'true'])
1593 1593 for f, kind in self.wvfs.readdir():
1594 1594 if f == '.git':
1595 1595 continue
1596 1596 if kind == stat.S_IFDIR:
1597 1597 self.wvfs.rmtree(f)
1598 1598 else:
1599 1599 self.wvfs.unlink(f)
1600 1600
1601 1601 def archive(self, archiver, prefix, match=None, decode=True):
1602 1602 total = 0
1603 1603 source, revision = self._state
1604 1604 if not revision:
1605 1605 return total
1606 1606 self._fetch(source, revision)
1607 1607
1608 1608 # Parse git's native archive command.
1609 1609 # This should be much faster than manually traversing the trees
1610 1610 # and objects with many subprocess calls.
1611 1611 tarstream = self._gitcommand(['archive', revision], stream=True)
1612 1612 tar = tarfile.open(fileobj=tarstream, mode='r|')
1613 1613 relpath = subrelpath(self)
1614 1614 self.ui.progress(_('archiving (%s)') % relpath, 0, unit=_('files'))
1615 1615 for i, info in enumerate(tar):
1616 1616 if info.isdir():
1617 1617 continue
1618 1618 if match and not match(info.name):
1619 1619 continue
1620 1620 if info.issym():
1621 1621 data = info.linkname
1622 1622 else:
1623 1623 data = tar.extractfile(info).read()
1624 1624 archiver.addfile(prefix + self._path + '/' + info.name,
1625 1625 info.mode, info.issym(), data)
1626 1626 total += 1
1627 1627 self.ui.progress(_('archiving (%s)') % relpath, i + 1,
1628 1628 unit=_('files'))
1629 1629 self.ui.progress(_('archiving (%s)') % relpath, None)
1630 1630 return total
1631 1631
1632 1632
1633 1633 @annotatesubrepoerror
1634 1634 def cat(self, match, fm, fntemplate, prefix, **opts):
1635 1635 rev = self._state[1]
1636 1636 if match.anypats():
1637 1637 return 1 #No support for include/exclude yet
1638 1638
1639 1639 if not match.files():
1640 1640 return 1
1641 1641
1642 1642 # TODO: add support for non-plain formatter (see cmdutil.cat())
1643 1643 for f in match.files():
1644 1644 output = self._gitcommand(["show", "%s:%s" % (rev, f)])
1645 fp = cmdutil.makefileobj(self._subparent, fntemplate,
1646 self._ctx.node(),
1645 fp = cmdutil.makefileobj(self._ctx, fntemplate,
1647 1646 pathname=self.wvfs.reljoin(prefix, f))
1648 1647 fp.write(output)
1649 1648 fp.close()
1650 1649 return 0
1651 1650
1652 1651
1653 1652 @annotatesubrepoerror
1654 1653 def status(self, rev2, **opts):
1655 1654 rev1 = self._state[1]
1656 1655 if self._gitmissing() or not rev1:
1657 1656 # if the repo is missing, return no results
1658 1657 return scmutil.status([], [], [], [], [], [], [])
1659 1658 modified, added, removed = [], [], []
1660 1659 self._gitupdatestat()
1661 1660 if rev2:
1662 1661 command = ['diff-tree', '--no-renames', '-r', rev1, rev2]
1663 1662 else:
1664 1663 command = ['diff-index', '--no-renames', rev1]
1665 1664 out = self._gitcommand(command)
1666 1665 for line in out.split('\n'):
1667 1666 tab = line.find('\t')
1668 1667 if tab == -1:
1669 1668 continue
1670 1669 status, f = line[tab - 1], line[tab + 1:]
1671 1670 if status == 'M':
1672 1671 modified.append(f)
1673 1672 elif status == 'A':
1674 1673 added.append(f)
1675 1674 elif status == 'D':
1676 1675 removed.append(f)
1677 1676
1678 1677 deleted, unknown, ignored, clean = [], [], [], []
1679 1678
1680 1679 command = ['status', '--porcelain', '-z']
1681 1680 if opts.get(r'unknown'):
1682 1681 command += ['--untracked-files=all']
1683 1682 if opts.get(r'ignored'):
1684 1683 command += ['--ignored']
1685 1684 out = self._gitcommand(command)
1686 1685
1687 1686 changedfiles = set()
1688 1687 changedfiles.update(modified)
1689 1688 changedfiles.update(added)
1690 1689 changedfiles.update(removed)
1691 1690 for line in out.split('\0'):
1692 1691 if not line:
1693 1692 continue
1694 1693 st = line[0:2]
1695 1694 #moves and copies show 2 files on one line
1696 1695 if line.find('\0') >= 0:
1697 1696 filename1, filename2 = line[3:].split('\0')
1698 1697 else:
1699 1698 filename1 = line[3:]
1700 1699 filename2 = None
1701 1700
1702 1701 changedfiles.add(filename1)
1703 1702 if filename2:
1704 1703 changedfiles.add(filename2)
1705 1704
1706 1705 if st == '??':
1707 1706 unknown.append(filename1)
1708 1707 elif st == '!!':
1709 1708 ignored.append(filename1)
1710 1709
1711 1710 if opts.get(r'clean'):
1712 1711 out = self._gitcommand(['ls-files'])
1713 1712 for f in out.split('\n'):
1714 1713 if not f in changedfiles:
1715 1714 clean.append(f)
1716 1715
1717 1716 return scmutil.status(modified, added, removed, deleted,
1718 1717 unknown, ignored, clean)
1719 1718
1720 1719 @annotatesubrepoerror
1721 1720 def diff(self, ui, diffopts, node2, match, prefix, **opts):
1722 1721 node1 = self._state[1]
1723 1722 cmd = ['diff', '--no-renames']
1724 1723 if opts[r'stat']:
1725 1724 cmd.append('--stat')
1726 1725 else:
1727 1726 # for Git, this also implies '-p'
1728 1727 cmd.append('-U%d' % diffopts.context)
1729 1728
1730 1729 gitprefix = self.wvfs.reljoin(prefix, self._path)
1731 1730
1732 1731 if diffopts.noprefix:
1733 1732 cmd.extend(['--src-prefix=%s/' % gitprefix,
1734 1733 '--dst-prefix=%s/' % gitprefix])
1735 1734 else:
1736 1735 cmd.extend(['--src-prefix=a/%s/' % gitprefix,
1737 1736 '--dst-prefix=b/%s/' % gitprefix])
1738 1737
1739 1738 if diffopts.ignorews:
1740 1739 cmd.append('--ignore-all-space')
1741 1740 if diffopts.ignorewsamount:
1742 1741 cmd.append('--ignore-space-change')
1743 1742 if self._gitversion(self._gitcommand(['--version'])) >= (1, 8, 4) \
1744 1743 and diffopts.ignoreblanklines:
1745 1744 cmd.append('--ignore-blank-lines')
1746 1745
1747 1746 cmd.append(node1)
1748 1747 if node2:
1749 1748 cmd.append(node2)
1750 1749
1751 1750 output = ""
1752 1751 if match.always():
1753 1752 output += self._gitcommand(cmd) + '\n'
1754 1753 else:
1755 1754 st = self.status(node2)[:3]
1756 1755 files = [f for sublist in st for f in sublist]
1757 1756 for f in files:
1758 1757 if match(f):
1759 1758 output += self._gitcommand(cmd + ['--', f]) + '\n'
1760 1759
1761 1760 if output.strip():
1762 1761 ui.write(output)
1763 1762
1764 1763 @annotatesubrepoerror
1765 1764 def revert(self, substate, *pats, **opts):
1766 1765 self.ui.status(_('reverting subrepo %s\n') % substate[0])
1767 1766 if not opts.get(r'no_backup'):
1768 1767 status = self.status(None)
1769 1768 names = status.modified
1770 1769 for name in names:
1771 1770 bakname = scmutil.origpath(self.ui, self._subparent, name)
1772 1771 self.ui.note(_('saving current version of %s as %s\n') %
1773 1772 (name, bakname))
1774 1773 self.wvfs.rename(name, bakname)
1775 1774
1776 1775 if not opts.get(r'dry_run'):
1777 1776 self.get(substate, overwrite=True)
1778 1777 return []
1779 1778
1780 1779 def shortid(self, revid):
1781 1780 return revid[:7]
1782 1781
1783 1782 types = {
1784 1783 'hg': hgsubrepo,
1785 1784 'svn': svnsubrepo,
1786 1785 'git': gitsubrepo,
1787 1786 }
General Comments 0
You need to be logged in to leave comments. Login now