##// END OF EJS Templates
push: use `exchange.push` in `commands.push`...
Pierre-Yves David -
r22617:1625770c default
parent child Browse files
Show More
@@ -1,6325 +1,6325 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 node import hex, bin, nullid, nullrev, short
9 9 from lock import release
10 10 from i18n import _
11 11 import os, re, difflib, time, tempfile, errno, shlex
12 12 import sys, socket
13 13 import hg, scmutil, util, revlog, copies, error, bookmarks
14 14 import patch, help, encoding, templatekw, discovery
15 15 import archival, changegroup, cmdutil, hbisect
16 16 import sshserver, hgweb, commandserver
17 17 import extensions
18 18 from hgweb import server as hgweb_server
19 19 import merge as mergemod
20 20 import minirst, revset, fileset
21 21 import dagparser, context, simplemerge, graphmod
22 22 import random
23 23 import setdiscovery, treediscovery, dagutil, pvec, localrepo
24 24 import phases, obsolete, exchange
25 25
26 26 table = {}
27 27
28 28 command = cmdutil.command(table)
29 29
30 30 # Space delimited list of commands that don't require local repositories.
31 31 # This should be populated by passing norepo=True into the @command decorator.
32 32 norepo = ''
33 33 # Space delimited list of commands that optionally require local repositories.
34 34 # This should be populated by passing optionalrepo=True into the @command
35 35 # decorator.
36 36 optionalrepo = ''
37 37 # Space delimited list of commands that will examine arguments looking for
38 38 # a repository. This should be populated by passing inferrepo=True into the
39 39 # @command decorator.
40 40 inferrepo = ''
41 41
42 42 # common command options
43 43
44 44 globalopts = [
45 45 ('R', 'repository', '',
46 46 _('repository root directory or name of overlay bundle file'),
47 47 _('REPO')),
48 48 ('', 'cwd', '',
49 49 _('change working directory'), _('DIR')),
50 50 ('y', 'noninteractive', None,
51 51 _('do not prompt, automatically pick the first choice for all prompts')),
52 52 ('q', 'quiet', None, _('suppress output')),
53 53 ('v', 'verbose', None, _('enable additional output')),
54 54 ('', 'config', [],
55 55 _('set/override config option (use \'section.name=value\')'),
56 56 _('CONFIG')),
57 57 ('', 'debug', None, _('enable debugging output')),
58 58 ('', 'debugger', None, _('start debugger')),
59 59 ('', 'encoding', encoding.encoding, _('set the charset encoding'),
60 60 _('ENCODE')),
61 61 ('', 'encodingmode', encoding.encodingmode,
62 62 _('set the charset encoding mode'), _('MODE')),
63 63 ('', 'traceback', None, _('always print a traceback on exception')),
64 64 ('', 'time', None, _('time how long the command takes')),
65 65 ('', 'profile', None, _('print command execution profile')),
66 66 ('', 'version', None, _('output version information and exit')),
67 67 ('h', 'help', None, _('display help and exit')),
68 68 ('', 'hidden', False, _('consider hidden changesets')),
69 69 ]
70 70
71 71 dryrunopts = [('n', 'dry-run', None,
72 72 _('do not perform actions, just print output'))]
73 73
74 74 remoteopts = [
75 75 ('e', 'ssh', '',
76 76 _('specify ssh command to use'), _('CMD')),
77 77 ('', 'remotecmd', '',
78 78 _('specify hg command to run on the remote side'), _('CMD')),
79 79 ('', 'insecure', None,
80 80 _('do not verify server certificate (ignoring web.cacerts config)')),
81 81 ]
82 82
83 83 walkopts = [
84 84 ('I', 'include', [],
85 85 _('include names matching the given patterns'), _('PATTERN')),
86 86 ('X', 'exclude', [],
87 87 _('exclude names matching the given patterns'), _('PATTERN')),
88 88 ]
89 89
90 90 commitopts = [
91 91 ('m', 'message', '',
92 92 _('use text as commit message'), _('TEXT')),
93 93 ('l', 'logfile', '',
94 94 _('read commit message from file'), _('FILE')),
95 95 ]
96 96
97 97 commitopts2 = [
98 98 ('d', 'date', '',
99 99 _('record the specified date as commit date'), _('DATE')),
100 100 ('u', 'user', '',
101 101 _('record the specified user as committer'), _('USER')),
102 102 ]
103 103
104 104 # hidden for now
105 105 formatteropts = [
106 106 ('T', 'template', '',
107 107 _('display with template (DEPRECATED)'), _('TEMPLATE')),
108 108 ]
109 109
110 110 templateopts = [
111 111 ('', 'style', '',
112 112 _('display using template map file (DEPRECATED)'), _('STYLE')),
113 113 ('T', 'template', '',
114 114 _('display with template'), _('TEMPLATE')),
115 115 ]
116 116
117 117 logopts = [
118 118 ('p', 'patch', None, _('show patch')),
119 119 ('g', 'git', None, _('use git extended diff format')),
120 120 ('l', 'limit', '',
121 121 _('limit number of changes displayed'), _('NUM')),
122 122 ('M', 'no-merges', None, _('do not show merges')),
123 123 ('', 'stat', None, _('output diffstat-style summary of changes')),
124 124 ('G', 'graph', None, _("show the revision DAG")),
125 125 ] + templateopts
126 126
127 127 diffopts = [
128 128 ('a', 'text', None, _('treat all files as text')),
129 129 ('g', 'git', None, _('use git extended diff format')),
130 130 ('', 'nodates', None, _('omit dates from diff headers'))
131 131 ]
132 132
133 133 diffwsopts = [
134 134 ('w', 'ignore-all-space', None,
135 135 _('ignore white space when comparing lines')),
136 136 ('b', 'ignore-space-change', None,
137 137 _('ignore changes in the amount of white space')),
138 138 ('B', 'ignore-blank-lines', None,
139 139 _('ignore changes whose lines are all blank')),
140 140 ]
141 141
142 142 diffopts2 = [
143 143 ('p', 'show-function', None, _('show which function each change is in')),
144 144 ('', 'reverse', None, _('produce a diff that undoes the changes')),
145 145 ] + diffwsopts + [
146 146 ('U', 'unified', '',
147 147 _('number of lines of context to show'), _('NUM')),
148 148 ('', 'stat', None, _('output diffstat-style summary of changes')),
149 149 ]
150 150
151 151 mergetoolopts = [
152 152 ('t', 'tool', '', _('specify merge tool')),
153 153 ]
154 154
155 155 similarityopts = [
156 156 ('s', 'similarity', '',
157 157 _('guess renamed files by similarity (0<=s<=100)'), _('SIMILARITY'))
158 158 ]
159 159
160 160 subrepoopts = [
161 161 ('S', 'subrepos', None,
162 162 _('recurse into subrepositories'))
163 163 ]
164 164
165 165 # Commands start here, listed alphabetically
166 166
167 167 @command('^add',
168 168 walkopts + subrepoopts + dryrunopts,
169 169 _('[OPTION]... [FILE]...'),
170 170 inferrepo=True)
171 171 def add(ui, repo, *pats, **opts):
172 172 """add the specified files on the next commit
173 173
174 174 Schedule files to be version controlled and added to the
175 175 repository.
176 176
177 177 The files will be added to the repository at the next commit. To
178 178 undo an add before that, see :hg:`forget`.
179 179
180 180 If no names are given, add all files to the repository.
181 181
182 182 .. container:: verbose
183 183
184 184 An example showing how new (unknown) files are added
185 185 automatically by :hg:`add`::
186 186
187 187 $ ls
188 188 foo.c
189 189 $ hg status
190 190 ? foo.c
191 191 $ hg add
192 192 adding foo.c
193 193 $ hg status
194 194 A foo.c
195 195
196 196 Returns 0 if all files are successfully added.
197 197 """
198 198
199 199 m = scmutil.match(repo[None], pats, opts)
200 200 rejected = cmdutil.add(ui, repo, m, opts.get('dry_run'),
201 201 opts.get('subrepos'), prefix="", explicitonly=False)
202 202 return rejected and 1 or 0
203 203
204 204 @command('addremove',
205 205 similarityopts + walkopts + dryrunopts,
206 206 _('[OPTION]... [FILE]...'),
207 207 inferrepo=True)
208 208 def addremove(ui, repo, *pats, **opts):
209 209 """add all new files, delete all missing files
210 210
211 211 Add all new files and remove all missing files from the
212 212 repository.
213 213
214 214 New files are ignored if they match any of the patterns in
215 215 ``.hgignore``. As with add, these changes take effect at the next
216 216 commit.
217 217
218 218 Use the -s/--similarity option to detect renamed files. This
219 219 option takes a percentage between 0 (disabled) and 100 (files must
220 220 be identical) as its parameter. With a parameter greater than 0,
221 221 this compares every removed file with every added file and records
222 222 those similar enough as renames. Detecting renamed files this way
223 223 can be expensive. After using this option, :hg:`status -C` can be
224 224 used to check which files were identified as moved or renamed. If
225 225 not specified, -s/--similarity defaults to 100 and only renames of
226 226 identical files are detected.
227 227
228 228 Returns 0 if all files are successfully added.
229 229 """
230 230 try:
231 231 sim = float(opts.get('similarity') or 100)
232 232 except ValueError:
233 233 raise util.Abort(_('similarity must be a number'))
234 234 if sim < 0 or sim > 100:
235 235 raise util.Abort(_('similarity must be between 0 and 100'))
236 236 return scmutil.addremove(repo, pats, opts, similarity=sim / 100.0)
237 237
238 238 @command('^annotate|blame',
239 239 [('r', 'rev', '', _('annotate the specified revision'), _('REV')),
240 240 ('', 'follow', None,
241 241 _('follow copies/renames and list the filename (DEPRECATED)')),
242 242 ('', 'no-follow', None, _("don't follow copies and renames")),
243 243 ('a', 'text', None, _('treat all files as text')),
244 244 ('u', 'user', None, _('list the author (long with -v)')),
245 245 ('f', 'file', None, _('list the filename')),
246 246 ('d', 'date', None, _('list the date (short with -q)')),
247 247 ('n', 'number', None, _('list the revision number (default)')),
248 248 ('c', 'changeset', None, _('list the changeset')),
249 249 ('l', 'line-number', None, _('show line number at the first appearance'))
250 250 ] + diffwsopts + walkopts + formatteropts,
251 251 _('[-r REV] [-f] [-a] [-u] [-d] [-n] [-c] [-l] FILE...'),
252 252 inferrepo=True)
253 253 def annotate(ui, repo, *pats, **opts):
254 254 """show changeset information by line for each file
255 255
256 256 List changes in files, showing the revision id responsible for
257 257 each line
258 258
259 259 This command is useful for discovering when a change was made and
260 260 by whom.
261 261
262 262 Without the -a/--text option, annotate will avoid processing files
263 263 it detects as binary. With -a, annotate will annotate the file
264 264 anyway, although the results will probably be neither useful
265 265 nor desirable.
266 266
267 267 Returns 0 on success.
268 268 """
269 269 if not pats:
270 270 raise util.Abort(_('at least one filename or pattern is required'))
271 271
272 272 if opts.get('follow'):
273 273 # --follow is deprecated and now just an alias for -f/--file
274 274 # to mimic the behavior of Mercurial before version 1.5
275 275 opts['file'] = True
276 276
277 277 fm = ui.formatter('annotate', opts)
278 278 datefunc = ui.quiet and util.shortdate or util.datestr
279 279 if fm or ui.debugflag:
280 280 hexfn = hex
281 281 else:
282 282 hexfn = short
283 283
284 284 opmap = [('user', ' ', lambda x: x[0].user(), ui.shortuser),
285 285 ('number', ' ', lambda x: x[0].rev(), str),
286 286 ('changeset', ' ', lambda x: hexfn(x[0].node()), str),
287 287 ('date', ' ', lambda x: x[0].date(), util.cachefunc(datefunc)),
288 288 ('file', ' ', lambda x: x[0].path(), str),
289 289 ('line_number', ':', lambda x: x[1], str),
290 290 ]
291 291 fieldnamemap = {'number': 'rev', 'changeset': 'node'}
292 292
293 293 if (not opts.get('user') and not opts.get('changeset')
294 294 and not opts.get('date') and not opts.get('file')):
295 295 opts['number'] = True
296 296
297 297 linenumber = opts.get('line_number') is not None
298 298 if linenumber and (not opts.get('changeset')) and (not opts.get('number')):
299 299 raise util.Abort(_('at least one of -n/-c is required for -l'))
300 300
301 301 if fm:
302 302 def makefunc(get, fmt):
303 303 return get
304 304 else:
305 305 def makefunc(get, fmt):
306 306 return lambda x: fmt(get(x))
307 307 funcmap = [(makefunc(get, fmt), sep) for op, sep, get, fmt in opmap
308 308 if opts.get(op)]
309 309 funcmap[0] = (funcmap[0][0], '') # no separator in front of first column
310 310 fields = ' '.join(fieldnamemap.get(op, op) for op, sep, get, fmt in opmap
311 311 if opts.get(op))
312 312
313 313 def bad(x, y):
314 314 raise util.Abort("%s: %s" % (x, y))
315 315
316 316 ctx = scmutil.revsingle(repo, opts.get('rev'))
317 317 m = scmutil.match(ctx, pats, opts)
318 318 m.bad = bad
319 319 follow = not opts.get('no_follow')
320 320 diffopts = patch.diffopts(ui, opts, section='annotate')
321 321 for abs in ctx.walk(m):
322 322 fctx = ctx[abs]
323 323 if not opts.get('text') and util.binary(fctx.data()):
324 324 fm.plain(_("%s: binary file\n") % ((pats and m.rel(abs)) or abs))
325 325 continue
326 326
327 327 lines = fctx.annotate(follow=follow, linenumber=linenumber,
328 328 diffopts=diffopts)
329 329 formats = []
330 330 pieces = []
331 331
332 332 for f, sep in funcmap:
333 333 l = [f(n) for n, dummy in lines]
334 334 if l:
335 335 if fm:
336 336 formats.append(['%s' for x in l])
337 337 else:
338 338 sizes = [encoding.colwidth(x) for x in l]
339 339 ml = max(sizes)
340 340 formats.append([sep + ' ' * (ml - w) + '%s' for w in sizes])
341 341 pieces.append(l)
342 342
343 343 for f, p, l in zip(zip(*formats), zip(*pieces), lines):
344 344 fm.startitem()
345 345 fm.write(fields, "".join(f), *p)
346 346 fm.write('line', ": %s", l[1])
347 347
348 348 if lines and not lines[-1][1].endswith('\n'):
349 349 fm.plain('\n')
350 350
351 351 fm.end()
352 352
353 353 @command('archive',
354 354 [('', 'no-decode', None, _('do not pass files through decoders')),
355 355 ('p', 'prefix', '', _('directory prefix for files in archive'),
356 356 _('PREFIX')),
357 357 ('r', 'rev', '', _('revision to distribute'), _('REV')),
358 358 ('t', 'type', '', _('type of distribution to create'), _('TYPE')),
359 359 ] + subrepoopts + walkopts,
360 360 _('[OPTION]... DEST'))
361 361 def archive(ui, repo, dest, **opts):
362 362 '''create an unversioned archive of a repository revision
363 363
364 364 By default, the revision used is the parent of the working
365 365 directory; use -r/--rev to specify a different revision.
366 366
367 367 The archive type is automatically detected based on file
368 368 extension (or override using -t/--type).
369 369
370 370 .. container:: verbose
371 371
372 372 Examples:
373 373
374 374 - create a zip file containing the 1.0 release::
375 375
376 376 hg archive -r 1.0 project-1.0.zip
377 377
378 378 - create a tarball excluding .hg files::
379 379
380 380 hg archive project.tar.gz -X ".hg*"
381 381
382 382 Valid types are:
383 383
384 384 :``files``: a directory full of files (default)
385 385 :``tar``: tar archive, uncompressed
386 386 :``tbz2``: tar archive, compressed using bzip2
387 387 :``tgz``: tar archive, compressed using gzip
388 388 :``uzip``: zip archive, uncompressed
389 389 :``zip``: zip archive, compressed using deflate
390 390
391 391 The exact name of the destination archive or directory is given
392 392 using a format string; see :hg:`help export` for details.
393 393
394 394 Each member added to an archive file has a directory prefix
395 395 prepended. Use -p/--prefix to specify a format string for the
396 396 prefix. The default is the basename of the archive, with suffixes
397 397 removed.
398 398
399 399 Returns 0 on success.
400 400 '''
401 401
402 402 ctx = scmutil.revsingle(repo, opts.get('rev'))
403 403 if not ctx:
404 404 raise util.Abort(_('no working directory: please specify a revision'))
405 405 node = ctx.node()
406 406 dest = cmdutil.makefilename(repo, dest, node)
407 407 if os.path.realpath(dest) == repo.root:
408 408 raise util.Abort(_('repository root cannot be destination'))
409 409
410 410 kind = opts.get('type') or archival.guesskind(dest) or 'files'
411 411 prefix = opts.get('prefix')
412 412
413 413 if dest == '-':
414 414 if kind == 'files':
415 415 raise util.Abort(_('cannot archive plain files to stdout'))
416 416 dest = cmdutil.makefileobj(repo, dest)
417 417 if not prefix:
418 418 prefix = os.path.basename(repo.root) + '-%h'
419 419
420 420 prefix = cmdutil.makefilename(repo, prefix, node)
421 421 matchfn = scmutil.match(ctx, [], opts)
422 422 archival.archive(repo, dest, node, kind, not opts.get('no_decode'),
423 423 matchfn, prefix, subrepos=opts.get('subrepos'))
424 424
425 425 @command('backout',
426 426 [('', 'merge', None, _('merge with old dirstate parent after backout')),
427 427 ('', 'parent', '',
428 428 _('parent to choose when backing out merge (DEPRECATED)'), _('REV')),
429 429 ('r', 'rev', '', _('revision to backout'), _('REV')),
430 430 ('e', 'edit', False, _('invoke editor on commit messages')),
431 431 ] + mergetoolopts + walkopts + commitopts + commitopts2,
432 432 _('[OPTION]... [-r] REV'))
433 433 def backout(ui, repo, node=None, rev=None, **opts):
434 434 '''reverse effect of earlier changeset
435 435
436 436 Prepare a new changeset with the effect of REV undone in the
437 437 current working directory.
438 438
439 439 If REV is the parent of the working directory, then this new changeset
440 440 is committed automatically. Otherwise, hg needs to merge the
441 441 changes and the merged result is left uncommitted.
442 442
443 443 .. note::
444 444
445 445 backout cannot be used to fix either an unwanted or
446 446 incorrect merge.
447 447
448 448 .. container:: verbose
449 449
450 450 By default, the pending changeset will have one parent,
451 451 maintaining a linear history. With --merge, the pending
452 452 changeset will instead have two parents: the old parent of the
453 453 working directory and a new child of REV that simply undoes REV.
454 454
455 455 Before version 1.7, the behavior without --merge was equivalent
456 456 to specifying --merge followed by :hg:`update --clean .` to
457 457 cancel the merge and leave the child of REV as a head to be
458 458 merged separately.
459 459
460 460 See :hg:`help dates` for a list of formats valid for -d/--date.
461 461
462 462 Returns 0 on success, 1 if nothing to backout or there are unresolved
463 463 files.
464 464 '''
465 465 if rev and node:
466 466 raise util.Abort(_("please specify just one revision"))
467 467
468 468 if not rev:
469 469 rev = node
470 470
471 471 if not rev:
472 472 raise util.Abort(_("please specify a revision to backout"))
473 473
474 474 date = opts.get('date')
475 475 if date:
476 476 opts['date'] = util.parsedate(date)
477 477
478 478 cmdutil.checkunfinished(repo)
479 479 cmdutil.bailifchanged(repo)
480 480 node = scmutil.revsingle(repo, rev).node()
481 481
482 482 op1, op2 = repo.dirstate.parents()
483 483 if not repo.changelog.isancestor(node, op1):
484 484 raise util.Abort(_('cannot backout change that is not an ancestor'))
485 485
486 486 p1, p2 = repo.changelog.parents(node)
487 487 if p1 == nullid:
488 488 raise util.Abort(_('cannot backout a change with no parents'))
489 489 if p2 != nullid:
490 490 if not opts.get('parent'):
491 491 raise util.Abort(_('cannot backout a merge changeset'))
492 492 p = repo.lookup(opts['parent'])
493 493 if p not in (p1, p2):
494 494 raise util.Abort(_('%s is not a parent of %s') %
495 495 (short(p), short(node)))
496 496 parent = p
497 497 else:
498 498 if opts.get('parent'):
499 499 raise util.Abort(_('cannot use --parent on non-merge changeset'))
500 500 parent = p1
501 501
502 502 # the backout should appear on the same branch
503 503 wlock = repo.wlock()
504 504 try:
505 505 branch = repo.dirstate.branch()
506 506 bheads = repo.branchheads(branch)
507 507 rctx = scmutil.revsingle(repo, hex(parent))
508 508 if not opts.get('merge') and op1 != node:
509 509 try:
510 510 ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
511 511 'backout')
512 512 repo.dirstate.beginparentchange()
513 513 stats = mergemod.update(repo, parent, True, True, False,
514 514 node, False)
515 515 repo.setparents(op1, op2)
516 516 repo.dirstate.endparentchange()
517 517 hg._showstats(repo, stats)
518 518 if stats[3]:
519 519 repo.ui.status(_("use 'hg resolve' to retry unresolved "
520 520 "file merges\n"))
521 521 else:
522 522 msg = _("changeset %s backed out, "
523 523 "don't forget to commit.\n")
524 524 ui.status(msg % short(node))
525 525 return stats[3] > 0
526 526 finally:
527 527 ui.setconfig('ui', 'forcemerge', '', '')
528 528 else:
529 529 hg.clean(repo, node, show_stats=False)
530 530 repo.dirstate.setbranch(branch)
531 531 cmdutil.revert(ui, repo, rctx, repo.dirstate.parents())
532 532
533 533
534 534 def commitfunc(ui, repo, message, match, opts):
535 535 editform = 'backout'
536 536 e = cmdutil.getcommiteditor(editform=editform, **opts)
537 537 if not message:
538 538 # we don't translate commit messages
539 539 message = "Backed out changeset %s" % short(node)
540 540 e = cmdutil.getcommiteditor(edit=True, editform=editform)
541 541 return repo.commit(message, opts.get('user'), opts.get('date'),
542 542 match, editor=e)
543 543 newnode = cmdutil.commit(ui, repo, commitfunc, [], opts)
544 544 if not newnode:
545 545 ui.status(_("nothing changed\n"))
546 546 return 1
547 547 cmdutil.commitstatus(repo, newnode, branch, bheads)
548 548
549 549 def nice(node):
550 550 return '%d:%s' % (repo.changelog.rev(node), short(node))
551 551 ui.status(_('changeset %s backs out changeset %s\n') %
552 552 (nice(repo.changelog.tip()), nice(node)))
553 553 if opts.get('merge') and op1 != node:
554 554 hg.clean(repo, op1, show_stats=False)
555 555 ui.status(_('merging with changeset %s\n')
556 556 % nice(repo.changelog.tip()))
557 557 try:
558 558 ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
559 559 'backout')
560 560 return hg.merge(repo, hex(repo.changelog.tip()))
561 561 finally:
562 562 ui.setconfig('ui', 'forcemerge', '', '')
563 563 finally:
564 564 wlock.release()
565 565 return 0
566 566
567 567 @command('bisect',
568 568 [('r', 'reset', False, _('reset bisect state')),
569 569 ('g', 'good', False, _('mark changeset good')),
570 570 ('b', 'bad', False, _('mark changeset bad')),
571 571 ('s', 'skip', False, _('skip testing changeset')),
572 572 ('e', 'extend', False, _('extend the bisect range')),
573 573 ('c', 'command', '', _('use command to check changeset state'), _('CMD')),
574 574 ('U', 'noupdate', False, _('do not update to target'))],
575 575 _("[-gbsr] [-U] [-c CMD] [REV]"))
576 576 def bisect(ui, repo, rev=None, extra=None, command=None,
577 577 reset=None, good=None, bad=None, skip=None, extend=None,
578 578 noupdate=None):
579 579 """subdivision search of changesets
580 580
581 581 This command helps to find changesets which introduce problems. To
582 582 use, mark the earliest changeset you know exhibits the problem as
583 583 bad, then mark the latest changeset which is free from the problem
584 584 as good. Bisect will update your working directory to a revision
585 585 for testing (unless the -U/--noupdate option is specified). Once
586 586 you have performed tests, mark the working directory as good or
587 587 bad, and bisect will either update to another candidate changeset
588 588 or announce that it has found the bad revision.
589 589
590 590 As a shortcut, you can also use the revision argument to mark a
591 591 revision as good or bad without checking it out first.
592 592
593 593 If you supply a command, it will be used for automatic bisection.
594 594 The environment variable HG_NODE will contain the ID of the
595 595 changeset being tested. The exit status of the command will be
596 596 used to mark revisions as good or bad: status 0 means good, 125
597 597 means to skip the revision, 127 (command not found) will abort the
598 598 bisection, and any other non-zero exit status means the revision
599 599 is bad.
600 600
601 601 .. container:: verbose
602 602
603 603 Some examples:
604 604
605 605 - start a bisection with known bad revision 34, and good revision 12::
606 606
607 607 hg bisect --bad 34
608 608 hg bisect --good 12
609 609
610 610 - advance the current bisection by marking current revision as good or
611 611 bad::
612 612
613 613 hg bisect --good
614 614 hg bisect --bad
615 615
616 616 - mark the current revision, or a known revision, to be skipped (e.g. if
617 617 that revision is not usable because of another issue)::
618 618
619 619 hg bisect --skip
620 620 hg bisect --skip 23
621 621
622 622 - skip all revisions that do not touch directories ``foo`` or ``bar``::
623 623
624 624 hg bisect --skip "!( file('path:foo') & file('path:bar') )"
625 625
626 626 - forget the current bisection::
627 627
628 628 hg bisect --reset
629 629
630 630 - use 'make && make tests' to automatically find the first broken
631 631 revision::
632 632
633 633 hg bisect --reset
634 634 hg bisect --bad 34
635 635 hg bisect --good 12
636 636 hg bisect --command "make && make tests"
637 637
638 638 - see all changesets whose states are already known in the current
639 639 bisection::
640 640
641 641 hg log -r "bisect(pruned)"
642 642
643 643 - see the changeset currently being bisected (especially useful
644 644 if running with -U/--noupdate)::
645 645
646 646 hg log -r "bisect(current)"
647 647
648 648 - see all changesets that took part in the current bisection::
649 649
650 650 hg log -r "bisect(range)"
651 651
652 652 - you can even get a nice graph::
653 653
654 654 hg log --graph -r "bisect(range)"
655 655
656 656 See :hg:`help revsets` for more about the `bisect()` keyword.
657 657
658 658 Returns 0 on success.
659 659 """
660 660 def extendbisectrange(nodes, good):
661 661 # bisect is incomplete when it ends on a merge node and
662 662 # one of the parent was not checked.
663 663 parents = repo[nodes[0]].parents()
664 664 if len(parents) > 1:
665 665 side = good and state['bad'] or state['good']
666 666 num = len(set(i.node() for i in parents) & set(side))
667 667 if num == 1:
668 668 return parents[0].ancestor(parents[1])
669 669 return None
670 670
671 671 def print_result(nodes, good):
672 672 displayer = cmdutil.show_changeset(ui, repo, {})
673 673 if len(nodes) == 1:
674 674 # narrowed it down to a single revision
675 675 if good:
676 676 ui.write(_("The first good revision is:\n"))
677 677 else:
678 678 ui.write(_("The first bad revision is:\n"))
679 679 displayer.show(repo[nodes[0]])
680 680 extendnode = extendbisectrange(nodes, good)
681 681 if extendnode is not None:
682 682 ui.write(_('Not all ancestors of this changeset have been'
683 683 ' checked.\nUse bisect --extend to continue the '
684 684 'bisection from\nthe common ancestor, %s.\n')
685 685 % extendnode)
686 686 else:
687 687 # multiple possible revisions
688 688 if good:
689 689 ui.write(_("Due to skipped revisions, the first "
690 690 "good revision could be any of:\n"))
691 691 else:
692 692 ui.write(_("Due to skipped revisions, the first "
693 693 "bad revision could be any of:\n"))
694 694 for n in nodes:
695 695 displayer.show(repo[n])
696 696 displayer.close()
697 697
698 698 def check_state(state, interactive=True):
699 699 if not state['good'] or not state['bad']:
700 700 if (good or bad or skip or reset) and interactive:
701 701 return
702 702 if not state['good']:
703 703 raise util.Abort(_('cannot bisect (no known good revisions)'))
704 704 else:
705 705 raise util.Abort(_('cannot bisect (no known bad revisions)'))
706 706 return True
707 707
708 708 # backward compatibility
709 709 if rev in "good bad reset init".split():
710 710 ui.warn(_("(use of 'hg bisect <cmd>' is deprecated)\n"))
711 711 cmd, rev, extra = rev, extra, None
712 712 if cmd == "good":
713 713 good = True
714 714 elif cmd == "bad":
715 715 bad = True
716 716 else:
717 717 reset = True
718 718 elif extra or good + bad + skip + reset + extend + bool(command) > 1:
719 719 raise util.Abort(_('incompatible arguments'))
720 720
721 721 cmdutil.checkunfinished(repo)
722 722
723 723 if reset:
724 724 p = repo.join("bisect.state")
725 725 if os.path.exists(p):
726 726 os.unlink(p)
727 727 return
728 728
729 729 state = hbisect.load_state(repo)
730 730
731 731 if command:
732 732 changesets = 1
733 733 if noupdate:
734 734 try:
735 735 node = state['current'][0]
736 736 except LookupError:
737 737 raise util.Abort(_('current bisect revision is unknown - '
738 738 'start a new bisect to fix'))
739 739 else:
740 740 node, p2 = repo.dirstate.parents()
741 741 if p2 != nullid:
742 742 raise util.Abort(_('current bisect revision is a merge'))
743 743 try:
744 744 while changesets:
745 745 # update state
746 746 state['current'] = [node]
747 747 hbisect.save_state(repo, state)
748 748 status = util.system(command,
749 749 environ={'HG_NODE': hex(node)},
750 750 out=ui.fout)
751 751 if status == 125:
752 752 transition = "skip"
753 753 elif status == 0:
754 754 transition = "good"
755 755 # status < 0 means process was killed
756 756 elif status == 127:
757 757 raise util.Abort(_("failed to execute %s") % command)
758 758 elif status < 0:
759 759 raise util.Abort(_("%s killed") % command)
760 760 else:
761 761 transition = "bad"
762 762 ctx = scmutil.revsingle(repo, rev, node)
763 763 rev = None # clear for future iterations
764 764 state[transition].append(ctx.node())
765 765 ui.status(_('changeset %d:%s: %s\n') % (ctx, ctx, transition))
766 766 check_state(state, interactive=False)
767 767 # bisect
768 768 nodes, changesets, bgood = hbisect.bisect(repo.changelog, state)
769 769 # update to next check
770 770 node = nodes[0]
771 771 if not noupdate:
772 772 cmdutil.bailifchanged(repo)
773 773 hg.clean(repo, node, show_stats=False)
774 774 finally:
775 775 state['current'] = [node]
776 776 hbisect.save_state(repo, state)
777 777 print_result(nodes, bgood)
778 778 return
779 779
780 780 # update state
781 781
782 782 if rev:
783 783 nodes = [repo.lookup(i) for i in scmutil.revrange(repo, [rev])]
784 784 else:
785 785 nodes = [repo.lookup('.')]
786 786
787 787 if good or bad or skip:
788 788 if good:
789 789 state['good'] += nodes
790 790 elif bad:
791 791 state['bad'] += nodes
792 792 elif skip:
793 793 state['skip'] += nodes
794 794 hbisect.save_state(repo, state)
795 795
796 796 if not check_state(state):
797 797 return
798 798
799 799 # actually bisect
800 800 nodes, changesets, good = hbisect.bisect(repo.changelog, state)
801 801 if extend:
802 802 if not changesets:
803 803 extendnode = extendbisectrange(nodes, good)
804 804 if extendnode is not None:
805 805 ui.write(_("Extending search to changeset %d:%s\n")
806 806 % (extendnode.rev(), extendnode))
807 807 state['current'] = [extendnode.node()]
808 808 hbisect.save_state(repo, state)
809 809 if noupdate:
810 810 return
811 811 cmdutil.bailifchanged(repo)
812 812 return hg.clean(repo, extendnode.node())
813 813 raise util.Abort(_("nothing to extend"))
814 814
815 815 if changesets == 0:
816 816 print_result(nodes, good)
817 817 else:
818 818 assert len(nodes) == 1 # only a single node can be tested next
819 819 node = nodes[0]
820 820 # compute the approximate number of remaining tests
821 821 tests, size = 0, 2
822 822 while size <= changesets:
823 823 tests, size = tests + 1, size * 2
824 824 rev = repo.changelog.rev(node)
825 825 ui.write(_("Testing changeset %d:%s "
826 826 "(%d changesets remaining, ~%d tests)\n")
827 827 % (rev, short(node), changesets, tests))
828 828 state['current'] = [node]
829 829 hbisect.save_state(repo, state)
830 830 if not noupdate:
831 831 cmdutil.bailifchanged(repo)
832 832 return hg.clean(repo, node)
833 833
834 834 @command('bookmarks|bookmark',
835 835 [('f', 'force', False, _('force')),
836 836 ('r', 'rev', '', _('revision'), _('REV')),
837 837 ('d', 'delete', False, _('delete a given bookmark')),
838 838 ('m', 'rename', '', _('rename a given bookmark'), _('NAME')),
839 839 ('i', 'inactive', False, _('mark a bookmark inactive'))],
840 840 _('hg bookmarks [OPTIONS]... [NAME]...'))
841 841 def bookmark(ui, repo, *names, **opts):
842 842 '''create a new bookmark or list existing bookmarks
843 843
844 844 Bookmarks are labels on changesets to help track lines of development.
845 845 Bookmarks are unversioned and can be moved, renamed and deleted.
846 846 Deleting or moving a bookmark has no effect on the associated changesets.
847 847
848 848 Creating or updating to a bookmark causes it to be marked as 'active'.
849 849 The active bookmark is indicated with a '*'.
850 850 When a commit is made, the active bookmark will advance to the new commit.
851 851 A plain :hg:`update` will also advance an active bookmark, if possible.
852 852 Updating away from a bookmark will cause it to be deactivated.
853 853
854 854 Bookmarks can be pushed and pulled between repositories (see
855 855 :hg:`help push` and :hg:`help pull`). If a shared bookmark has
856 856 diverged, a new 'divergent bookmark' of the form 'name@path' will
857 857 be created. Using :hg:'merge' will resolve the divergence.
858 858
859 859 A bookmark named '@' has the special property that :hg:`clone` will
860 860 check it out by default if it exists.
861 861
862 862 .. container:: verbose
863 863
864 864 Examples:
865 865
866 866 - create an active bookmark for a new line of development::
867 867
868 868 hg book new-feature
869 869
870 870 - create an inactive bookmark as a place marker::
871 871
872 872 hg book -i reviewed
873 873
874 874 - create an inactive bookmark on another changeset::
875 875
876 876 hg book -r .^ tested
877 877
878 878 - move the '@' bookmark from another branch::
879 879
880 880 hg book -f @
881 881 '''
882 882 force = opts.get('force')
883 883 rev = opts.get('rev')
884 884 delete = opts.get('delete')
885 885 rename = opts.get('rename')
886 886 inactive = opts.get('inactive')
887 887
888 888 def checkformat(mark):
889 889 mark = mark.strip()
890 890 if not mark:
891 891 raise util.Abort(_("bookmark names cannot consist entirely of "
892 892 "whitespace"))
893 893 scmutil.checknewlabel(repo, mark, 'bookmark')
894 894 return mark
895 895
896 896 def checkconflict(repo, mark, cur, force=False, target=None):
897 897 if mark in marks and not force:
898 898 if target:
899 899 if marks[mark] == target and target == cur:
900 900 # re-activating a bookmark
901 901 return
902 902 anc = repo.changelog.ancestors([repo[target].rev()])
903 903 bmctx = repo[marks[mark]]
904 904 divs = [repo[b].node() for b in marks
905 905 if b.split('@', 1)[0] == mark.split('@', 1)[0]]
906 906
907 907 # allow resolving a single divergent bookmark even if moving
908 908 # the bookmark across branches when a revision is specified
909 909 # that contains a divergent bookmark
910 910 if bmctx.rev() not in anc and target in divs:
911 911 bookmarks.deletedivergent(repo, [target], mark)
912 912 return
913 913
914 914 deletefrom = [b for b in divs
915 915 if repo[b].rev() in anc or b == target]
916 916 bookmarks.deletedivergent(repo, deletefrom, mark)
917 917 if bookmarks.validdest(repo, bmctx, repo[target]):
918 918 ui.status(_("moving bookmark '%s' forward from %s\n") %
919 919 (mark, short(bmctx.node())))
920 920 return
921 921 raise util.Abort(_("bookmark '%s' already exists "
922 922 "(use -f to force)") % mark)
923 923 if ((mark in repo.branchmap() or mark == repo.dirstate.branch())
924 924 and not force):
925 925 raise util.Abort(
926 926 _("a bookmark cannot have the name of an existing branch"))
927 927
928 928 if delete and rename:
929 929 raise util.Abort(_("--delete and --rename are incompatible"))
930 930 if delete and rev:
931 931 raise util.Abort(_("--rev is incompatible with --delete"))
932 932 if rename and rev:
933 933 raise util.Abort(_("--rev is incompatible with --rename"))
934 934 if not names and (delete or rev):
935 935 raise util.Abort(_("bookmark name required"))
936 936
937 937 if delete or rename or names or inactive:
938 938 wlock = repo.wlock()
939 939 try:
940 940 cur = repo.changectx('.').node()
941 941 marks = repo._bookmarks
942 942 if delete:
943 943 for mark in names:
944 944 if mark not in marks:
945 945 raise util.Abort(_("bookmark '%s' does not exist") %
946 946 mark)
947 947 if mark == repo._bookmarkcurrent:
948 948 bookmarks.unsetcurrent(repo)
949 949 del marks[mark]
950 950 marks.write()
951 951
952 952 elif rename:
953 953 if not names:
954 954 raise util.Abort(_("new bookmark name required"))
955 955 elif len(names) > 1:
956 956 raise util.Abort(_("only one new bookmark name allowed"))
957 957 mark = checkformat(names[0])
958 958 if rename not in marks:
959 959 raise util.Abort(_("bookmark '%s' does not exist") % rename)
960 960 checkconflict(repo, mark, cur, force)
961 961 marks[mark] = marks[rename]
962 962 if repo._bookmarkcurrent == rename and not inactive:
963 963 bookmarks.setcurrent(repo, mark)
964 964 del marks[rename]
965 965 marks.write()
966 966
967 967 elif names:
968 968 newact = None
969 969 for mark in names:
970 970 mark = checkformat(mark)
971 971 if newact is None:
972 972 newact = mark
973 973 if inactive and mark == repo._bookmarkcurrent:
974 974 bookmarks.unsetcurrent(repo)
975 975 return
976 976 tgt = cur
977 977 if rev:
978 978 tgt = scmutil.revsingle(repo, rev).node()
979 979 checkconflict(repo, mark, cur, force, tgt)
980 980 marks[mark] = tgt
981 981 if not inactive and cur == marks[newact] and not rev:
982 982 bookmarks.setcurrent(repo, newact)
983 983 elif cur != tgt and newact == repo._bookmarkcurrent:
984 984 bookmarks.unsetcurrent(repo)
985 985 marks.write()
986 986
987 987 elif inactive:
988 988 if len(marks) == 0:
989 989 ui.status(_("no bookmarks set\n"))
990 990 elif not repo._bookmarkcurrent:
991 991 ui.status(_("no active bookmark\n"))
992 992 else:
993 993 bookmarks.unsetcurrent(repo)
994 994 finally:
995 995 wlock.release()
996 996 else: # show bookmarks
997 997 hexfn = ui.debugflag and hex or short
998 998 marks = repo._bookmarks
999 999 if len(marks) == 0:
1000 1000 ui.status(_("no bookmarks set\n"))
1001 1001 else:
1002 1002 for bmark, n in sorted(marks.iteritems()):
1003 1003 current = repo._bookmarkcurrent
1004 1004 if bmark == current:
1005 1005 prefix, label = '*', 'bookmarks.current'
1006 1006 else:
1007 1007 prefix, label = ' ', ''
1008 1008
1009 1009 if ui.quiet:
1010 1010 ui.write("%s\n" % bmark, label=label)
1011 1011 else:
1012 1012 pad = " " * (25 - encoding.colwidth(bmark))
1013 1013 ui.write(" %s %s%s %d:%s\n" % (
1014 1014 prefix, bmark, pad, repo.changelog.rev(n), hexfn(n)),
1015 1015 label=label)
1016 1016
1017 1017 @command('branch',
1018 1018 [('f', 'force', None,
1019 1019 _('set branch name even if it shadows an existing branch')),
1020 1020 ('C', 'clean', None, _('reset branch name to parent branch name'))],
1021 1021 _('[-fC] [NAME]'))
1022 1022 def branch(ui, repo, label=None, **opts):
1023 1023 """set or show the current branch name
1024 1024
1025 1025 .. note::
1026 1026
1027 1027 Branch names are permanent and global. Use :hg:`bookmark` to create a
1028 1028 light-weight bookmark instead. See :hg:`help glossary` for more
1029 1029 information about named branches and bookmarks.
1030 1030
1031 1031 With no argument, show the current branch name. With one argument,
1032 1032 set the working directory branch name (the branch will not exist
1033 1033 in the repository until the next commit). Standard practice
1034 1034 recommends that primary development take place on the 'default'
1035 1035 branch.
1036 1036
1037 1037 Unless -f/--force is specified, branch will not let you set a
1038 1038 branch name that already exists, even if it's inactive.
1039 1039
1040 1040 Use -C/--clean to reset the working directory branch to that of
1041 1041 the parent of the working directory, negating a previous branch
1042 1042 change.
1043 1043
1044 1044 Use the command :hg:`update` to switch to an existing branch. Use
1045 1045 :hg:`commit --close-branch` to mark this branch as closed.
1046 1046
1047 1047 Returns 0 on success.
1048 1048 """
1049 1049 if label:
1050 1050 label = label.strip()
1051 1051
1052 1052 if not opts.get('clean') and not label:
1053 1053 ui.write("%s\n" % repo.dirstate.branch())
1054 1054 return
1055 1055
1056 1056 wlock = repo.wlock()
1057 1057 try:
1058 1058 if opts.get('clean'):
1059 1059 label = repo[None].p1().branch()
1060 1060 repo.dirstate.setbranch(label)
1061 1061 ui.status(_('reset working directory to branch %s\n') % label)
1062 1062 elif label:
1063 1063 if not opts.get('force') and label in repo.branchmap():
1064 1064 if label not in [p.branch() for p in repo.parents()]:
1065 1065 raise util.Abort(_('a branch of the same name already'
1066 1066 ' exists'),
1067 1067 # i18n: "it" refers to an existing branch
1068 1068 hint=_("use 'hg update' to switch to it"))
1069 1069 scmutil.checknewlabel(repo, label, 'branch')
1070 1070 repo.dirstate.setbranch(label)
1071 1071 ui.status(_('marked working directory as branch %s\n') % label)
1072 1072 ui.status(_('(branches are permanent and global, '
1073 1073 'did you want a bookmark?)\n'))
1074 1074 finally:
1075 1075 wlock.release()
1076 1076
1077 1077 @command('branches',
1078 1078 [('a', 'active', False, _('show only branches that have unmerged heads')),
1079 1079 ('c', 'closed', False, _('show normal and closed branches'))],
1080 1080 _('[-ac]'))
1081 1081 def branches(ui, repo, active=False, closed=False):
1082 1082 """list repository named branches
1083 1083
1084 1084 List the repository's named branches, indicating which ones are
1085 1085 inactive. If -c/--closed is specified, also list branches which have
1086 1086 been marked closed (see :hg:`commit --close-branch`).
1087 1087
1088 1088 If -a/--active is specified, only show active branches. A branch
1089 1089 is considered active if it contains repository heads.
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 hexfunc = ui.debugflag and hex or short
1097 1097
1098 1098 allheads = set(repo.heads())
1099 1099 branches = []
1100 1100 for tag, heads, tip, isclosed in repo.branchmap().iterbranches():
1101 1101 isactive = not isclosed and bool(set(heads) & allheads)
1102 1102 branches.append((tag, repo[tip], isactive, not isclosed))
1103 1103 branches.sort(key=lambda i: (i[2], i[1].rev(), i[0], i[3]),
1104 1104 reverse=True)
1105 1105
1106 1106 for tag, ctx, isactive, isopen in branches:
1107 1107 if (not active) or isactive:
1108 1108 if isactive:
1109 1109 label = 'branches.active'
1110 1110 notice = ''
1111 1111 elif not isopen:
1112 1112 if not closed:
1113 1113 continue
1114 1114 label = 'branches.closed'
1115 1115 notice = _(' (closed)')
1116 1116 else:
1117 1117 label = 'branches.inactive'
1118 1118 notice = _(' (inactive)')
1119 1119 if tag == repo.dirstate.branch():
1120 1120 label = 'branches.current'
1121 1121 rev = str(ctx.rev()).rjust(31 - encoding.colwidth(tag))
1122 1122 rev = ui.label('%s:%s' % (rev, hexfunc(ctx.node())),
1123 1123 'log.changeset changeset.%s' % ctx.phasestr())
1124 1124 labeledtag = ui.label(tag, label)
1125 1125 if ui.quiet:
1126 1126 ui.write("%s\n" % labeledtag)
1127 1127 else:
1128 1128 ui.write("%s %s%s\n" % (labeledtag, rev, notice))
1129 1129
1130 1130 @command('bundle',
1131 1131 [('f', 'force', None, _('run even when the destination is unrelated')),
1132 1132 ('r', 'rev', [], _('a changeset intended to be added to the destination'),
1133 1133 _('REV')),
1134 1134 ('b', 'branch', [], _('a specific branch you would like to bundle'),
1135 1135 _('BRANCH')),
1136 1136 ('', 'base', [],
1137 1137 _('a base changeset assumed to be available at the destination'),
1138 1138 _('REV')),
1139 1139 ('a', 'all', None, _('bundle all changesets in the repository')),
1140 1140 ('t', 'type', 'bzip2', _('bundle compression type to use'), _('TYPE')),
1141 1141 ] + remoteopts,
1142 1142 _('[-f] [-t TYPE] [-a] [-r REV]... [--base REV]... FILE [DEST]'))
1143 1143 def bundle(ui, repo, fname, dest=None, **opts):
1144 1144 """create a changegroup file
1145 1145
1146 1146 Generate a compressed changegroup file collecting changesets not
1147 1147 known to be in another repository.
1148 1148
1149 1149 If you omit the destination repository, then hg assumes the
1150 1150 destination will have all the nodes you specify with --base
1151 1151 parameters. To create a bundle containing all changesets, use
1152 1152 -a/--all (or --base null).
1153 1153
1154 1154 You can change compression method with the -t/--type option.
1155 1155 The available compression methods are: none, bzip2, and
1156 1156 gzip (by default, bundles are compressed using bzip2).
1157 1157
1158 1158 The bundle file can then be transferred using conventional means
1159 1159 and applied to another repository with the unbundle or pull
1160 1160 command. This is useful when direct push and pull are not
1161 1161 available or when exporting an entire repository is undesirable.
1162 1162
1163 1163 Applying bundles preserves all changeset contents including
1164 1164 permissions, copy/rename information, and revision history.
1165 1165
1166 1166 Returns 0 on success, 1 if no changes found.
1167 1167 """
1168 1168 revs = None
1169 1169 if 'rev' in opts:
1170 1170 revs = scmutil.revrange(repo, opts['rev'])
1171 1171
1172 1172 bundletype = opts.get('type', 'bzip2').lower()
1173 1173 btypes = {'none': 'HG10UN', 'bzip2': 'HG10BZ', 'gzip': 'HG10GZ'}
1174 1174 bundletype = btypes.get(bundletype)
1175 1175 if bundletype not in changegroup.bundletypes:
1176 1176 raise util.Abort(_('unknown bundle type specified with --type'))
1177 1177
1178 1178 if opts.get('all'):
1179 1179 base = ['null']
1180 1180 else:
1181 1181 base = scmutil.revrange(repo, opts.get('base'))
1182 1182 # TODO: get desired bundlecaps from command line.
1183 1183 bundlecaps = None
1184 1184 if base:
1185 1185 if dest:
1186 1186 raise util.Abort(_("--base is incompatible with specifying "
1187 1187 "a destination"))
1188 1188 common = [repo.lookup(rev) for rev in base]
1189 1189 heads = revs and map(repo.lookup, revs) or revs
1190 1190 cg = changegroup.getchangegroup(repo, 'bundle', heads=heads,
1191 1191 common=common, bundlecaps=bundlecaps)
1192 1192 outgoing = None
1193 1193 else:
1194 1194 dest = ui.expandpath(dest or 'default-push', dest or 'default')
1195 1195 dest, branches = hg.parseurl(dest, opts.get('branch'))
1196 1196 other = hg.peer(repo, opts, dest)
1197 1197 revs, checkout = hg.addbranchrevs(repo, repo, branches, revs)
1198 1198 heads = revs and map(repo.lookup, revs) or revs
1199 1199 outgoing = discovery.findcommonoutgoing(repo, other,
1200 1200 onlyheads=heads,
1201 1201 force=opts.get('force'),
1202 1202 portable=True)
1203 1203 cg = changegroup.getlocalchangegroup(repo, 'bundle', outgoing,
1204 1204 bundlecaps)
1205 1205 if not cg:
1206 1206 scmutil.nochangesfound(ui, repo, outgoing and outgoing.excluded)
1207 1207 return 1
1208 1208
1209 1209 changegroup.writebundle(cg, fname, bundletype)
1210 1210
1211 1211 @command('cat',
1212 1212 [('o', 'output', '',
1213 1213 _('print output to file with formatted name'), _('FORMAT')),
1214 1214 ('r', 'rev', '', _('print the given revision'), _('REV')),
1215 1215 ('', 'decode', None, _('apply any matching decode filter')),
1216 1216 ] + walkopts,
1217 1217 _('[OPTION]... FILE...'),
1218 1218 inferrepo=True)
1219 1219 def cat(ui, repo, file1, *pats, **opts):
1220 1220 """output the current or given revision of files
1221 1221
1222 1222 Print the specified files as they were at the given revision. If
1223 1223 no revision is given, the parent of the working directory is used.
1224 1224
1225 1225 Output may be to a file, in which case the name of the file is
1226 1226 given using a format string. The formatting rules as follows:
1227 1227
1228 1228 :``%%``: literal "%" character
1229 1229 :``%s``: basename of file being printed
1230 1230 :``%d``: dirname of file being printed, or '.' if in repository root
1231 1231 :``%p``: root-relative path name of file being printed
1232 1232 :``%H``: changeset hash (40 hexadecimal digits)
1233 1233 :``%R``: changeset revision number
1234 1234 :``%h``: short-form changeset hash (12 hexadecimal digits)
1235 1235 :``%r``: zero-padded changeset revision number
1236 1236 :``%b``: basename of the exporting repository
1237 1237
1238 1238 Returns 0 on success.
1239 1239 """
1240 1240 ctx = scmutil.revsingle(repo, opts.get('rev'))
1241 1241 m = scmutil.match(ctx, (file1,) + pats, opts)
1242 1242
1243 1243 return cmdutil.cat(ui, repo, ctx, m, '', **opts)
1244 1244
1245 1245 @command('^clone',
1246 1246 [('U', 'noupdate', None,
1247 1247 _('the clone will include an empty working copy (only a repository)')),
1248 1248 ('u', 'updaterev', '', _('revision, tag or branch to check out'), _('REV')),
1249 1249 ('r', 'rev', [], _('include the specified changeset'), _('REV')),
1250 1250 ('b', 'branch', [], _('clone only the specified branch'), _('BRANCH')),
1251 1251 ('', 'pull', None, _('use pull protocol to copy metadata')),
1252 1252 ('', 'uncompressed', None, _('use uncompressed transfer (fast over LAN)')),
1253 1253 ] + remoteopts,
1254 1254 _('[OPTION]... SOURCE [DEST]'),
1255 1255 norepo=True)
1256 1256 def clone(ui, source, dest=None, **opts):
1257 1257 """make a copy of an existing repository
1258 1258
1259 1259 Create a copy of an existing repository in a new directory.
1260 1260
1261 1261 If no destination directory name is specified, it defaults to the
1262 1262 basename of the source.
1263 1263
1264 1264 The location of the source is added to the new repository's
1265 1265 ``.hg/hgrc`` file, as the default to be used for future pulls.
1266 1266
1267 1267 Only local paths and ``ssh://`` URLs are supported as
1268 1268 destinations. For ``ssh://`` destinations, no working directory or
1269 1269 ``.hg/hgrc`` will be created on the remote side.
1270 1270
1271 1271 To pull only a subset of changesets, specify one or more revisions
1272 1272 identifiers with -r/--rev or branches with -b/--branch. The
1273 1273 resulting clone will contain only the specified changesets and
1274 1274 their ancestors. These options (or 'clone src#rev dest') imply
1275 1275 --pull, even for local source repositories. Note that specifying a
1276 1276 tag will include the tagged changeset but not the changeset
1277 1277 containing the tag.
1278 1278
1279 1279 If the source repository has a bookmark called '@' set, that
1280 1280 revision will be checked out in the new repository by default.
1281 1281
1282 1282 To check out a particular version, use -u/--update, or
1283 1283 -U/--noupdate to create a clone with no working directory.
1284 1284
1285 1285 .. container:: verbose
1286 1286
1287 1287 For efficiency, hardlinks are used for cloning whenever the
1288 1288 source and destination are on the same filesystem (note this
1289 1289 applies only to the repository data, not to the working
1290 1290 directory). Some filesystems, such as AFS, implement hardlinking
1291 1291 incorrectly, but do not report errors. In these cases, use the
1292 1292 --pull option to avoid hardlinking.
1293 1293
1294 1294 In some cases, you can clone repositories and the working
1295 1295 directory using full hardlinks with ::
1296 1296
1297 1297 $ cp -al REPO REPOCLONE
1298 1298
1299 1299 This is the fastest way to clone, but it is not always safe. The
1300 1300 operation is not atomic (making sure REPO is not modified during
1301 1301 the operation is up to you) and you have to make sure your
1302 1302 editor breaks hardlinks (Emacs and most Linux Kernel tools do
1303 1303 so). Also, this is not compatible with certain extensions that
1304 1304 place their metadata under the .hg directory, such as mq.
1305 1305
1306 1306 Mercurial will update the working directory to the first applicable
1307 1307 revision from this list:
1308 1308
1309 1309 a) null if -U or the source repository has no changesets
1310 1310 b) if -u . and the source repository is local, the first parent of
1311 1311 the source repository's working directory
1312 1312 c) the changeset specified with -u (if a branch name, this means the
1313 1313 latest head of that branch)
1314 1314 d) the changeset specified with -r
1315 1315 e) the tipmost head specified with -b
1316 1316 f) the tipmost head specified with the url#branch source syntax
1317 1317 g) the revision marked with the '@' bookmark, if present
1318 1318 h) the tipmost head of the default branch
1319 1319 i) tip
1320 1320
1321 1321 Examples:
1322 1322
1323 1323 - clone a remote repository to a new directory named hg/::
1324 1324
1325 1325 hg clone http://selenic.com/hg
1326 1326
1327 1327 - create a lightweight local clone::
1328 1328
1329 1329 hg clone project/ project-feature/
1330 1330
1331 1331 - clone from an absolute path on an ssh server (note double-slash)::
1332 1332
1333 1333 hg clone ssh://user@server//home/projects/alpha/
1334 1334
1335 1335 - do a high-speed clone over a LAN while checking out a
1336 1336 specified version::
1337 1337
1338 1338 hg clone --uncompressed http://server/repo -u 1.5
1339 1339
1340 1340 - create a repository without changesets after a particular revision::
1341 1341
1342 1342 hg clone -r 04e544 experimental/ good/
1343 1343
1344 1344 - clone (and track) a particular named branch::
1345 1345
1346 1346 hg clone http://selenic.com/hg#stable
1347 1347
1348 1348 See :hg:`help urls` for details on specifying URLs.
1349 1349
1350 1350 Returns 0 on success.
1351 1351 """
1352 1352 if opts.get('noupdate') and opts.get('updaterev'):
1353 1353 raise util.Abort(_("cannot specify both --noupdate and --updaterev"))
1354 1354
1355 1355 r = hg.clone(ui, opts, source, dest,
1356 1356 pull=opts.get('pull'),
1357 1357 stream=opts.get('uncompressed'),
1358 1358 rev=opts.get('rev'),
1359 1359 update=opts.get('updaterev') or not opts.get('noupdate'),
1360 1360 branch=opts.get('branch'))
1361 1361
1362 1362 return r is None
1363 1363
1364 1364 @command('^commit|ci',
1365 1365 [('A', 'addremove', None,
1366 1366 _('mark new/missing files as added/removed before committing')),
1367 1367 ('', 'close-branch', None,
1368 1368 _('mark a branch as closed, hiding it from the branch list')),
1369 1369 ('', 'amend', None, _('amend the parent of the working dir')),
1370 1370 ('s', 'secret', None, _('use the secret phase for committing')),
1371 1371 ('e', 'edit', None, _('invoke editor on commit messages')),
1372 1372 ] + walkopts + commitopts + commitopts2 + subrepoopts,
1373 1373 _('[OPTION]... [FILE]...'),
1374 1374 inferrepo=True)
1375 1375 def commit(ui, repo, *pats, **opts):
1376 1376 """commit the specified files or all outstanding changes
1377 1377
1378 1378 Commit changes to the given files into the repository. Unlike a
1379 1379 centralized SCM, this operation is a local operation. See
1380 1380 :hg:`push` for a way to actively distribute your changes.
1381 1381
1382 1382 If a list of files is omitted, all changes reported by :hg:`status`
1383 1383 will be committed.
1384 1384
1385 1385 If you are committing the result of a merge, do not provide any
1386 1386 filenames or -I/-X filters.
1387 1387
1388 1388 If no commit message is specified, Mercurial starts your
1389 1389 configured editor where you can enter a message. In case your
1390 1390 commit fails, you will find a backup of your message in
1391 1391 ``.hg/last-message.txt``.
1392 1392
1393 1393 The --amend flag can be used to amend the parent of the
1394 1394 working directory with a new commit that contains the changes
1395 1395 in the parent in addition to those currently reported by :hg:`status`,
1396 1396 if there are any. The old commit is stored in a backup bundle in
1397 1397 ``.hg/strip-backup`` (see :hg:`help bundle` and :hg:`help unbundle`
1398 1398 on how to restore it).
1399 1399
1400 1400 Message, user and date are taken from the amended commit unless
1401 1401 specified. When a message isn't specified on the command line,
1402 1402 the editor will open with the message of the amended commit.
1403 1403
1404 1404 It is not possible to amend public changesets (see :hg:`help phases`)
1405 1405 or changesets that have children.
1406 1406
1407 1407 See :hg:`help dates` for a list of formats valid for -d/--date.
1408 1408
1409 1409 Returns 0 on success, 1 if nothing changed.
1410 1410 """
1411 1411 if opts.get('subrepos'):
1412 1412 if opts.get('amend'):
1413 1413 raise util.Abort(_('cannot amend with --subrepos'))
1414 1414 # Let --subrepos on the command line override config setting.
1415 1415 ui.setconfig('ui', 'commitsubrepos', True, 'commit')
1416 1416
1417 1417 cmdutil.checkunfinished(repo, commit=True)
1418 1418
1419 1419 branch = repo[None].branch()
1420 1420 bheads = repo.branchheads(branch)
1421 1421
1422 1422 extra = {}
1423 1423 if opts.get('close_branch'):
1424 1424 extra['close'] = 1
1425 1425
1426 1426 if not bheads:
1427 1427 raise util.Abort(_('can only close branch heads'))
1428 1428 elif opts.get('amend'):
1429 1429 if repo.parents()[0].p1().branch() != branch and \
1430 1430 repo.parents()[0].p2().branch() != branch:
1431 1431 raise util.Abort(_('can only close branch heads'))
1432 1432
1433 1433 if opts.get('amend'):
1434 1434 if ui.configbool('ui', 'commitsubrepos'):
1435 1435 raise util.Abort(_('cannot amend with ui.commitsubrepos enabled'))
1436 1436
1437 1437 old = repo['.']
1438 1438 if not old.mutable():
1439 1439 raise util.Abort(_('cannot amend public changesets'))
1440 1440 if len(repo[None].parents()) > 1:
1441 1441 raise util.Abort(_('cannot amend while merging'))
1442 1442 if (not obsolete._enabled) and old.children():
1443 1443 raise util.Abort(_('cannot amend changeset with children'))
1444 1444
1445 1445 # commitfunc is used only for temporary amend commit by cmdutil.amend
1446 1446 def commitfunc(ui, repo, message, match, opts):
1447 1447 return repo.commit(message,
1448 1448 opts.get('user') or old.user(),
1449 1449 opts.get('date') or old.date(),
1450 1450 match,
1451 1451 extra=extra)
1452 1452
1453 1453 current = repo._bookmarkcurrent
1454 1454 marks = old.bookmarks()
1455 1455 node = cmdutil.amend(ui, repo, commitfunc, old, extra, pats, opts)
1456 1456 if node == old.node():
1457 1457 ui.status(_("nothing changed\n"))
1458 1458 return 1
1459 1459 elif marks:
1460 1460 ui.debug('moving bookmarks %r from %s to %s\n' %
1461 1461 (marks, old.hex(), hex(node)))
1462 1462 newmarks = repo._bookmarks
1463 1463 for bm in marks:
1464 1464 newmarks[bm] = node
1465 1465 if bm == current:
1466 1466 bookmarks.setcurrent(repo, bm)
1467 1467 newmarks.write()
1468 1468 else:
1469 1469 def commitfunc(ui, repo, message, match, opts):
1470 1470 backup = ui.backupconfig('phases', 'new-commit')
1471 1471 baseui = repo.baseui
1472 1472 basebackup = baseui.backupconfig('phases', 'new-commit')
1473 1473 try:
1474 1474 if opts.get('secret'):
1475 1475 ui.setconfig('phases', 'new-commit', 'secret', 'commit')
1476 1476 # Propagate to subrepos
1477 1477 baseui.setconfig('phases', 'new-commit', 'secret', 'commit')
1478 1478
1479 1479 editform = cmdutil.mergeeditform(repo[None], 'commit.normal')
1480 1480 editor = cmdutil.getcommiteditor(editform=editform, **opts)
1481 1481 return repo.commit(message, opts.get('user'), opts.get('date'),
1482 1482 match,
1483 1483 editor=editor,
1484 1484 extra=extra)
1485 1485 finally:
1486 1486 ui.restoreconfig(backup)
1487 1487 repo.baseui.restoreconfig(basebackup)
1488 1488
1489 1489
1490 1490 node = cmdutil.commit(ui, repo, commitfunc, pats, opts)
1491 1491
1492 1492 if not node:
1493 1493 stat = repo.status(match=scmutil.match(repo[None], pats, opts))
1494 1494 if stat[3]:
1495 1495 ui.status(_("nothing changed (%d missing files, see "
1496 1496 "'hg status')\n") % len(stat[3]))
1497 1497 else:
1498 1498 ui.status(_("nothing changed\n"))
1499 1499 return 1
1500 1500
1501 1501 cmdutil.commitstatus(repo, node, branch, bheads, opts)
1502 1502
1503 1503 @command('config|showconfig|debugconfig',
1504 1504 [('u', 'untrusted', None, _('show untrusted configuration options')),
1505 1505 ('e', 'edit', None, _('edit user config')),
1506 1506 ('l', 'local', None, _('edit repository config')),
1507 1507 ('g', 'global', None, _('edit global config'))],
1508 1508 _('[-u] [NAME]...'),
1509 1509 optionalrepo=True)
1510 1510 def config(ui, repo, *values, **opts):
1511 1511 """show combined config settings from all hgrc files
1512 1512
1513 1513 With no arguments, print names and values of all config items.
1514 1514
1515 1515 With one argument of the form section.name, print just the value
1516 1516 of that config item.
1517 1517
1518 1518 With multiple arguments, print names and values of all config
1519 1519 items with matching section names.
1520 1520
1521 1521 With --edit, start an editor on the user-level config file. With
1522 1522 --global, edit the system-wide config file. With --local, edit the
1523 1523 repository-level config file.
1524 1524
1525 1525 With --debug, the source (filename and line number) is printed
1526 1526 for each config item.
1527 1527
1528 1528 See :hg:`help config` for more information about config files.
1529 1529
1530 1530 Returns 0 on success, 1 if NAME does not exist.
1531 1531
1532 1532 """
1533 1533
1534 1534 if opts.get('edit') or opts.get('local') or opts.get('global'):
1535 1535 if opts.get('local') and opts.get('global'):
1536 1536 raise util.Abort(_("can't use --local and --global together"))
1537 1537
1538 1538 if opts.get('local'):
1539 1539 if not repo:
1540 1540 raise util.Abort(_("can't use --local outside a repository"))
1541 1541 paths = [repo.join('hgrc')]
1542 1542 elif opts.get('global'):
1543 1543 paths = scmutil.systemrcpath()
1544 1544 else:
1545 1545 paths = scmutil.userrcpath()
1546 1546
1547 1547 for f in paths:
1548 1548 if os.path.exists(f):
1549 1549 break
1550 1550 else:
1551 1551 from ui import samplehgrcs
1552 1552
1553 1553 if opts.get('global'):
1554 1554 samplehgrc = samplehgrcs['global']
1555 1555 elif opts.get('local'):
1556 1556 samplehgrc = samplehgrcs['local']
1557 1557 else:
1558 1558 samplehgrc = samplehgrcs['user']
1559 1559
1560 1560 f = paths[0]
1561 1561 fp = open(f, "w")
1562 1562 fp.write(samplehgrc)
1563 1563 fp.close()
1564 1564
1565 1565 editor = ui.geteditor()
1566 1566 util.system("%s \"%s\"" % (editor, f),
1567 1567 onerr=util.Abort, errprefix=_("edit failed"),
1568 1568 out=ui.fout)
1569 1569 return
1570 1570
1571 1571 for f in scmutil.rcpath():
1572 1572 ui.debug('read config from: %s\n' % f)
1573 1573 untrusted = bool(opts.get('untrusted'))
1574 1574 if values:
1575 1575 sections = [v for v in values if '.' not in v]
1576 1576 items = [v for v in values if '.' in v]
1577 1577 if len(items) > 1 or items and sections:
1578 1578 raise util.Abort(_('only one config item permitted'))
1579 1579 matched = False
1580 1580 for section, name, value in ui.walkconfig(untrusted=untrusted):
1581 1581 value = str(value).replace('\n', '\\n')
1582 1582 sectname = section + '.' + name
1583 1583 if values:
1584 1584 for v in values:
1585 1585 if v == section:
1586 1586 ui.debug('%s: ' %
1587 1587 ui.configsource(section, name, untrusted))
1588 1588 ui.write('%s=%s\n' % (sectname, value))
1589 1589 matched = True
1590 1590 elif v == sectname:
1591 1591 ui.debug('%s: ' %
1592 1592 ui.configsource(section, name, untrusted))
1593 1593 ui.write(value, '\n')
1594 1594 matched = True
1595 1595 else:
1596 1596 ui.debug('%s: ' %
1597 1597 ui.configsource(section, name, untrusted))
1598 1598 ui.write('%s=%s\n' % (sectname, value))
1599 1599 matched = True
1600 1600 if matched:
1601 1601 return 0
1602 1602 return 1
1603 1603
1604 1604 @command('copy|cp',
1605 1605 [('A', 'after', None, _('record a copy that has already occurred')),
1606 1606 ('f', 'force', None, _('forcibly copy over an existing managed file')),
1607 1607 ] + walkopts + dryrunopts,
1608 1608 _('[OPTION]... [SOURCE]... DEST'))
1609 1609 def copy(ui, repo, *pats, **opts):
1610 1610 """mark files as copied for the next commit
1611 1611
1612 1612 Mark dest as having copies of source files. If dest is a
1613 1613 directory, copies are put in that directory. If dest is a file,
1614 1614 the source must be a single file.
1615 1615
1616 1616 By default, this command copies the contents of files as they
1617 1617 exist in the working directory. If invoked with -A/--after, the
1618 1618 operation is recorded, but no copying is performed.
1619 1619
1620 1620 This command takes effect with the next commit. To undo a copy
1621 1621 before that, see :hg:`revert`.
1622 1622
1623 1623 Returns 0 on success, 1 if errors are encountered.
1624 1624 """
1625 1625 wlock = repo.wlock(False)
1626 1626 try:
1627 1627 return cmdutil.copy(ui, repo, pats, opts)
1628 1628 finally:
1629 1629 wlock.release()
1630 1630
1631 1631 @command('debugancestor', [], _('[INDEX] REV1 REV2'), optionalrepo=True)
1632 1632 def debugancestor(ui, repo, *args):
1633 1633 """find the ancestor revision of two revisions in a given index"""
1634 1634 if len(args) == 3:
1635 1635 index, rev1, rev2 = args
1636 1636 r = revlog.revlog(scmutil.opener(os.getcwd(), audit=False), index)
1637 1637 lookup = r.lookup
1638 1638 elif len(args) == 2:
1639 1639 if not repo:
1640 1640 raise util.Abort(_("there is no Mercurial repository here "
1641 1641 "(.hg not found)"))
1642 1642 rev1, rev2 = args
1643 1643 r = repo.changelog
1644 1644 lookup = repo.lookup
1645 1645 else:
1646 1646 raise util.Abort(_('either two or three arguments required'))
1647 1647 a = r.ancestor(lookup(rev1), lookup(rev2))
1648 1648 ui.write("%d:%s\n" % (r.rev(a), hex(a)))
1649 1649
1650 1650 @command('debugbuilddag',
1651 1651 [('m', 'mergeable-file', None, _('add single file mergeable changes')),
1652 1652 ('o', 'overwritten-file', None, _('add single file all revs overwrite')),
1653 1653 ('n', 'new-file', None, _('add new file at each rev'))],
1654 1654 _('[OPTION]... [TEXT]'))
1655 1655 def debugbuilddag(ui, repo, text=None,
1656 1656 mergeable_file=False,
1657 1657 overwritten_file=False,
1658 1658 new_file=False):
1659 1659 """builds a repo with a given DAG from scratch in the current empty repo
1660 1660
1661 1661 The description of the DAG is read from stdin if not given on the
1662 1662 command line.
1663 1663
1664 1664 Elements:
1665 1665
1666 1666 - "+n" is a linear run of n nodes based on the current default parent
1667 1667 - "." is a single node based on the current default parent
1668 1668 - "$" resets the default parent to null (implied at the start);
1669 1669 otherwise the default parent is always the last node created
1670 1670 - "<p" sets the default parent to the backref p
1671 1671 - "*p" is a fork at parent p, which is a backref
1672 1672 - "*p1/p2" is a merge of parents p1 and p2, which are backrefs
1673 1673 - "/p2" is a merge of the preceding node and p2
1674 1674 - ":tag" defines a local tag for the preceding node
1675 1675 - "@branch" sets the named branch for subsequent nodes
1676 1676 - "#...\\n" is a comment up to the end of the line
1677 1677
1678 1678 Whitespace between the above elements is ignored.
1679 1679
1680 1680 A backref is either
1681 1681
1682 1682 - a number n, which references the node curr-n, where curr is the current
1683 1683 node, or
1684 1684 - the name of a local tag you placed earlier using ":tag", or
1685 1685 - empty to denote the default parent.
1686 1686
1687 1687 All string valued-elements are either strictly alphanumeric, or must
1688 1688 be enclosed in double quotes ("..."), with "\\" as escape character.
1689 1689 """
1690 1690
1691 1691 if text is None:
1692 1692 ui.status(_("reading DAG from stdin\n"))
1693 1693 text = ui.fin.read()
1694 1694
1695 1695 cl = repo.changelog
1696 1696 if len(cl) > 0:
1697 1697 raise util.Abort(_('repository is not empty'))
1698 1698
1699 1699 # determine number of revs in DAG
1700 1700 total = 0
1701 1701 for type, data in dagparser.parsedag(text):
1702 1702 if type == 'n':
1703 1703 total += 1
1704 1704
1705 1705 if mergeable_file:
1706 1706 linesperrev = 2
1707 1707 # make a file with k lines per rev
1708 1708 initialmergedlines = [str(i) for i in xrange(0, total * linesperrev)]
1709 1709 initialmergedlines.append("")
1710 1710
1711 1711 tags = []
1712 1712
1713 1713 lock = tr = None
1714 1714 try:
1715 1715 lock = repo.lock()
1716 1716 tr = repo.transaction("builddag")
1717 1717
1718 1718 at = -1
1719 1719 atbranch = 'default'
1720 1720 nodeids = []
1721 1721 id = 0
1722 1722 ui.progress(_('building'), id, unit=_('revisions'), total=total)
1723 1723 for type, data in dagparser.parsedag(text):
1724 1724 if type == 'n':
1725 1725 ui.note(('node %s\n' % str(data)))
1726 1726 id, ps = data
1727 1727
1728 1728 files = []
1729 1729 fctxs = {}
1730 1730
1731 1731 p2 = None
1732 1732 if mergeable_file:
1733 1733 fn = "mf"
1734 1734 p1 = repo[ps[0]]
1735 1735 if len(ps) > 1:
1736 1736 p2 = repo[ps[1]]
1737 1737 pa = p1.ancestor(p2)
1738 1738 base, local, other = [x[fn].data() for x in (pa, p1,
1739 1739 p2)]
1740 1740 m3 = simplemerge.Merge3Text(base, local, other)
1741 1741 ml = [l.strip() for l in m3.merge_lines()]
1742 1742 ml.append("")
1743 1743 elif at > 0:
1744 1744 ml = p1[fn].data().split("\n")
1745 1745 else:
1746 1746 ml = initialmergedlines
1747 1747 ml[id * linesperrev] += " r%i" % id
1748 1748 mergedtext = "\n".join(ml)
1749 1749 files.append(fn)
1750 1750 fctxs[fn] = context.memfilectx(repo, fn, mergedtext)
1751 1751
1752 1752 if overwritten_file:
1753 1753 fn = "of"
1754 1754 files.append(fn)
1755 1755 fctxs[fn] = context.memfilectx(repo, fn, "r%i\n" % id)
1756 1756
1757 1757 if new_file:
1758 1758 fn = "nf%i" % id
1759 1759 files.append(fn)
1760 1760 fctxs[fn] = context.memfilectx(repo, fn, "r%i\n" % id)
1761 1761 if len(ps) > 1:
1762 1762 if not p2:
1763 1763 p2 = repo[ps[1]]
1764 1764 for fn in p2:
1765 1765 if fn.startswith("nf"):
1766 1766 files.append(fn)
1767 1767 fctxs[fn] = p2[fn]
1768 1768
1769 1769 def fctxfn(repo, cx, path):
1770 1770 return fctxs.get(path)
1771 1771
1772 1772 if len(ps) == 0 or ps[0] < 0:
1773 1773 pars = [None, None]
1774 1774 elif len(ps) == 1:
1775 1775 pars = [nodeids[ps[0]], None]
1776 1776 else:
1777 1777 pars = [nodeids[p] for p in ps]
1778 1778 cx = context.memctx(repo, pars, "r%i" % id, files, fctxfn,
1779 1779 date=(id, 0),
1780 1780 user="debugbuilddag",
1781 1781 extra={'branch': atbranch})
1782 1782 nodeid = repo.commitctx(cx)
1783 1783 nodeids.append(nodeid)
1784 1784 at = id
1785 1785 elif type == 'l':
1786 1786 id, name = data
1787 1787 ui.note(('tag %s\n' % name))
1788 1788 tags.append("%s %s\n" % (hex(repo.changelog.node(id)), name))
1789 1789 elif type == 'a':
1790 1790 ui.note(('branch %s\n' % data))
1791 1791 atbranch = data
1792 1792 ui.progress(_('building'), id, unit=_('revisions'), total=total)
1793 1793 tr.close()
1794 1794
1795 1795 if tags:
1796 1796 repo.opener.write("localtags", "".join(tags))
1797 1797 finally:
1798 1798 ui.progress(_('building'), None)
1799 1799 release(tr, lock)
1800 1800
1801 1801 @command('debugbundle',
1802 1802 [('a', 'all', None, _('show all details'))],
1803 1803 _('FILE'),
1804 1804 norepo=True)
1805 1805 def debugbundle(ui, bundlepath, all=None, **opts):
1806 1806 """lists the contents of a bundle"""
1807 1807 f = hg.openpath(ui, bundlepath)
1808 1808 try:
1809 1809 gen = exchange.readbundle(ui, f, bundlepath)
1810 1810 if all:
1811 1811 ui.write(("format: id, p1, p2, cset, delta base, len(delta)\n"))
1812 1812
1813 1813 def showchunks(named):
1814 1814 ui.write("\n%s\n" % named)
1815 1815 chain = None
1816 1816 while True:
1817 1817 chunkdata = gen.deltachunk(chain)
1818 1818 if not chunkdata:
1819 1819 break
1820 1820 node = chunkdata['node']
1821 1821 p1 = chunkdata['p1']
1822 1822 p2 = chunkdata['p2']
1823 1823 cs = chunkdata['cs']
1824 1824 deltabase = chunkdata['deltabase']
1825 1825 delta = chunkdata['delta']
1826 1826 ui.write("%s %s %s %s %s %s\n" %
1827 1827 (hex(node), hex(p1), hex(p2),
1828 1828 hex(cs), hex(deltabase), len(delta)))
1829 1829 chain = node
1830 1830
1831 1831 chunkdata = gen.changelogheader()
1832 1832 showchunks("changelog")
1833 1833 chunkdata = gen.manifestheader()
1834 1834 showchunks("manifest")
1835 1835 while True:
1836 1836 chunkdata = gen.filelogheader()
1837 1837 if not chunkdata:
1838 1838 break
1839 1839 fname = chunkdata['filename']
1840 1840 showchunks(fname)
1841 1841 else:
1842 1842 chunkdata = gen.changelogheader()
1843 1843 chain = None
1844 1844 while True:
1845 1845 chunkdata = gen.deltachunk(chain)
1846 1846 if not chunkdata:
1847 1847 break
1848 1848 node = chunkdata['node']
1849 1849 ui.write("%s\n" % hex(node))
1850 1850 chain = node
1851 1851 finally:
1852 1852 f.close()
1853 1853
1854 1854 @command('debugcheckstate', [], '')
1855 1855 def debugcheckstate(ui, repo):
1856 1856 """validate the correctness of the current dirstate"""
1857 1857 parent1, parent2 = repo.dirstate.parents()
1858 1858 m1 = repo[parent1].manifest()
1859 1859 m2 = repo[parent2].manifest()
1860 1860 errors = 0
1861 1861 for f in repo.dirstate:
1862 1862 state = repo.dirstate[f]
1863 1863 if state in "nr" and f not in m1:
1864 1864 ui.warn(_("%s in state %s, but not in manifest1\n") % (f, state))
1865 1865 errors += 1
1866 1866 if state in "a" and f in m1:
1867 1867 ui.warn(_("%s in state %s, but also in manifest1\n") % (f, state))
1868 1868 errors += 1
1869 1869 if state in "m" and f not in m1 and f not in m2:
1870 1870 ui.warn(_("%s in state %s, but not in either manifest\n") %
1871 1871 (f, state))
1872 1872 errors += 1
1873 1873 for f in m1:
1874 1874 state = repo.dirstate[f]
1875 1875 if state not in "nrm":
1876 1876 ui.warn(_("%s in manifest1, but listed as state %s") % (f, state))
1877 1877 errors += 1
1878 1878 if errors:
1879 1879 error = _(".hg/dirstate inconsistent with current parent's manifest")
1880 1880 raise util.Abort(error)
1881 1881
1882 1882 @command('debugcommands', [], _('[COMMAND]'), norepo=True)
1883 1883 def debugcommands(ui, cmd='', *args):
1884 1884 """list all available commands and options"""
1885 1885 for cmd, vals in sorted(table.iteritems()):
1886 1886 cmd = cmd.split('|')[0].strip('^')
1887 1887 opts = ', '.join([i[1] for i in vals[1]])
1888 1888 ui.write('%s: %s\n' % (cmd, opts))
1889 1889
1890 1890 @command('debugcomplete',
1891 1891 [('o', 'options', None, _('show the command options'))],
1892 1892 _('[-o] CMD'),
1893 1893 norepo=True)
1894 1894 def debugcomplete(ui, cmd='', **opts):
1895 1895 """returns the completion list associated with the given command"""
1896 1896
1897 1897 if opts.get('options'):
1898 1898 options = []
1899 1899 otables = [globalopts]
1900 1900 if cmd:
1901 1901 aliases, entry = cmdutil.findcmd(cmd, table, False)
1902 1902 otables.append(entry[1])
1903 1903 for t in otables:
1904 1904 for o in t:
1905 1905 if "(DEPRECATED)" in o[3]:
1906 1906 continue
1907 1907 if o[0]:
1908 1908 options.append('-%s' % o[0])
1909 1909 options.append('--%s' % o[1])
1910 1910 ui.write("%s\n" % "\n".join(options))
1911 1911 return
1912 1912
1913 1913 cmdlist = cmdutil.findpossible(cmd, table)
1914 1914 if ui.verbose:
1915 1915 cmdlist = [' '.join(c[0]) for c in cmdlist.values()]
1916 1916 ui.write("%s\n" % "\n".join(sorted(cmdlist)))
1917 1917
1918 1918 @command('debugdag',
1919 1919 [('t', 'tags', None, _('use tags as labels')),
1920 1920 ('b', 'branches', None, _('annotate with branch names')),
1921 1921 ('', 'dots', None, _('use dots for runs')),
1922 1922 ('s', 'spaces', None, _('separate elements by spaces'))],
1923 1923 _('[OPTION]... [FILE [REV]...]'),
1924 1924 optionalrepo=True)
1925 1925 def debugdag(ui, repo, file_=None, *revs, **opts):
1926 1926 """format the changelog or an index DAG as a concise textual description
1927 1927
1928 1928 If you pass a revlog index, the revlog's DAG is emitted. If you list
1929 1929 revision numbers, they get labeled in the output as rN.
1930 1930
1931 1931 Otherwise, the changelog DAG of the current repo is emitted.
1932 1932 """
1933 1933 spaces = opts.get('spaces')
1934 1934 dots = opts.get('dots')
1935 1935 if file_:
1936 1936 rlog = revlog.revlog(scmutil.opener(os.getcwd(), audit=False), file_)
1937 1937 revs = set((int(r) for r in revs))
1938 1938 def events():
1939 1939 for r in rlog:
1940 1940 yield 'n', (r, list(p for p in rlog.parentrevs(r)
1941 1941 if p != -1))
1942 1942 if r in revs:
1943 1943 yield 'l', (r, "r%i" % r)
1944 1944 elif repo:
1945 1945 cl = repo.changelog
1946 1946 tags = opts.get('tags')
1947 1947 branches = opts.get('branches')
1948 1948 if tags:
1949 1949 labels = {}
1950 1950 for l, n in repo.tags().items():
1951 1951 labels.setdefault(cl.rev(n), []).append(l)
1952 1952 def events():
1953 1953 b = "default"
1954 1954 for r in cl:
1955 1955 if branches:
1956 1956 newb = cl.read(cl.node(r))[5]['branch']
1957 1957 if newb != b:
1958 1958 yield 'a', newb
1959 1959 b = newb
1960 1960 yield 'n', (r, list(p for p in cl.parentrevs(r)
1961 1961 if p != -1))
1962 1962 if tags:
1963 1963 ls = labels.get(r)
1964 1964 if ls:
1965 1965 for l in ls:
1966 1966 yield 'l', (r, l)
1967 1967 else:
1968 1968 raise util.Abort(_('need repo for changelog dag'))
1969 1969
1970 1970 for line in dagparser.dagtextlines(events(),
1971 1971 addspaces=spaces,
1972 1972 wraplabels=True,
1973 1973 wrapannotations=True,
1974 1974 wrapnonlinear=dots,
1975 1975 usedots=dots,
1976 1976 maxlinewidth=70):
1977 1977 ui.write(line)
1978 1978 ui.write("\n")
1979 1979
1980 1980 @command('debugdata',
1981 1981 [('c', 'changelog', False, _('open changelog')),
1982 1982 ('m', 'manifest', False, _('open manifest'))],
1983 1983 _('-c|-m|FILE REV'))
1984 1984 def debugdata(ui, repo, file_, rev=None, **opts):
1985 1985 """dump the contents of a data file revision"""
1986 1986 if opts.get('changelog') or opts.get('manifest'):
1987 1987 file_, rev = None, file_
1988 1988 elif rev is None:
1989 1989 raise error.CommandError('debugdata', _('invalid arguments'))
1990 1990 r = cmdutil.openrevlog(repo, 'debugdata', file_, opts)
1991 1991 try:
1992 1992 ui.write(r.revision(r.lookup(rev)))
1993 1993 except KeyError:
1994 1994 raise util.Abort(_('invalid revision identifier %s') % rev)
1995 1995
1996 1996 @command('debugdate',
1997 1997 [('e', 'extended', None, _('try extended date formats'))],
1998 1998 _('[-e] DATE [RANGE]'),
1999 1999 norepo=True, optionalrepo=True)
2000 2000 def debugdate(ui, date, range=None, **opts):
2001 2001 """parse and display a date"""
2002 2002 if opts["extended"]:
2003 2003 d = util.parsedate(date, util.extendeddateformats)
2004 2004 else:
2005 2005 d = util.parsedate(date)
2006 2006 ui.write(("internal: %s %s\n") % d)
2007 2007 ui.write(("standard: %s\n") % util.datestr(d))
2008 2008 if range:
2009 2009 m = util.matchdate(range)
2010 2010 ui.write(("match: %s\n") % m(d[0]))
2011 2011
2012 2012 @command('debugdiscovery',
2013 2013 [('', 'old', None, _('use old-style discovery')),
2014 2014 ('', 'nonheads', None,
2015 2015 _('use old-style discovery with non-heads included')),
2016 2016 ] + remoteopts,
2017 2017 _('[-l REV] [-r REV] [-b BRANCH]... [OTHER]'))
2018 2018 def debugdiscovery(ui, repo, remoteurl="default", **opts):
2019 2019 """runs the changeset discovery protocol in isolation"""
2020 2020 remoteurl, branches = hg.parseurl(ui.expandpath(remoteurl),
2021 2021 opts.get('branch'))
2022 2022 remote = hg.peer(repo, opts, remoteurl)
2023 2023 ui.status(_('comparing with %s\n') % util.hidepassword(remoteurl))
2024 2024
2025 2025 # make sure tests are repeatable
2026 2026 random.seed(12323)
2027 2027
2028 2028 def doit(localheads, remoteheads, remote=remote):
2029 2029 if opts.get('old'):
2030 2030 if localheads:
2031 2031 raise util.Abort('cannot use localheads with old style '
2032 2032 'discovery')
2033 2033 if not util.safehasattr(remote, 'branches'):
2034 2034 # enable in-client legacy support
2035 2035 remote = localrepo.locallegacypeer(remote.local())
2036 2036 common, _in, hds = treediscovery.findcommonincoming(repo, remote,
2037 2037 force=True)
2038 2038 common = set(common)
2039 2039 if not opts.get('nonheads'):
2040 2040 ui.write(("unpruned common: %s\n") %
2041 2041 " ".join(sorted(short(n) for n in common)))
2042 2042 dag = dagutil.revlogdag(repo.changelog)
2043 2043 all = dag.ancestorset(dag.internalizeall(common))
2044 2044 common = dag.externalizeall(dag.headsetofconnecteds(all))
2045 2045 else:
2046 2046 common, any, hds = setdiscovery.findcommonheads(ui, repo, remote)
2047 2047 common = set(common)
2048 2048 rheads = set(hds)
2049 2049 lheads = set(repo.heads())
2050 2050 ui.write(("common heads: %s\n") %
2051 2051 " ".join(sorted(short(n) for n in common)))
2052 2052 if lheads <= common:
2053 2053 ui.write(("local is subset\n"))
2054 2054 elif rheads <= common:
2055 2055 ui.write(("remote is subset\n"))
2056 2056
2057 2057 serverlogs = opts.get('serverlog')
2058 2058 if serverlogs:
2059 2059 for filename in serverlogs:
2060 2060 logfile = open(filename, 'r')
2061 2061 try:
2062 2062 line = logfile.readline()
2063 2063 while line:
2064 2064 parts = line.strip().split(';')
2065 2065 op = parts[1]
2066 2066 if op == 'cg':
2067 2067 pass
2068 2068 elif op == 'cgss':
2069 2069 doit(parts[2].split(' '), parts[3].split(' '))
2070 2070 elif op == 'unb':
2071 2071 doit(parts[3].split(' '), parts[2].split(' '))
2072 2072 line = logfile.readline()
2073 2073 finally:
2074 2074 logfile.close()
2075 2075
2076 2076 else:
2077 2077 remoterevs, _checkout = hg.addbranchrevs(repo, remote, branches,
2078 2078 opts.get('remote_head'))
2079 2079 localrevs = opts.get('local_head')
2080 2080 doit(localrevs, remoterevs)
2081 2081
2082 2082 @command('debugfileset',
2083 2083 [('r', 'rev', '', _('apply the filespec on this revision'), _('REV'))],
2084 2084 _('[-r REV] FILESPEC'))
2085 2085 def debugfileset(ui, repo, expr, **opts):
2086 2086 '''parse and apply a fileset specification'''
2087 2087 ctx = scmutil.revsingle(repo, opts.get('rev'), None)
2088 2088 if ui.verbose:
2089 2089 tree = fileset.parse(expr)[0]
2090 2090 ui.note(tree, "\n")
2091 2091
2092 2092 for f in ctx.getfileset(expr):
2093 2093 ui.write("%s\n" % f)
2094 2094
2095 2095 @command('debugfsinfo', [], _('[PATH]'), norepo=True)
2096 2096 def debugfsinfo(ui, path="."):
2097 2097 """show information detected about current filesystem"""
2098 2098 util.writefile('.debugfsinfo', '')
2099 2099 ui.write(('exec: %s\n') % (util.checkexec(path) and 'yes' or 'no'))
2100 2100 ui.write(('symlink: %s\n') % (util.checklink(path) and 'yes' or 'no'))
2101 2101 ui.write(('hardlink: %s\n') % (util.checknlink(path) and 'yes' or 'no'))
2102 2102 ui.write(('case-sensitive: %s\n') % (util.checkcase('.debugfsinfo')
2103 2103 and 'yes' or 'no'))
2104 2104 os.unlink('.debugfsinfo')
2105 2105
2106 2106 @command('debuggetbundle',
2107 2107 [('H', 'head', [], _('id of head node'), _('ID')),
2108 2108 ('C', 'common', [], _('id of common node'), _('ID')),
2109 2109 ('t', 'type', 'bzip2', _('bundle compression type to use'), _('TYPE'))],
2110 2110 _('REPO FILE [-H|-C ID]...'),
2111 2111 norepo=True)
2112 2112 def debuggetbundle(ui, repopath, bundlepath, head=None, common=None, **opts):
2113 2113 """retrieves a bundle from a repo
2114 2114
2115 2115 Every ID must be a full-length hex node id string. Saves the bundle to the
2116 2116 given file.
2117 2117 """
2118 2118 repo = hg.peer(ui, opts, repopath)
2119 2119 if not repo.capable('getbundle'):
2120 2120 raise util.Abort("getbundle() not supported by target repository")
2121 2121 args = {}
2122 2122 if common:
2123 2123 args['common'] = [bin(s) for s in common]
2124 2124 if head:
2125 2125 args['heads'] = [bin(s) for s in head]
2126 2126 # TODO: get desired bundlecaps from command line.
2127 2127 args['bundlecaps'] = None
2128 2128 bundle = repo.getbundle('debug', **args)
2129 2129
2130 2130 bundletype = opts.get('type', 'bzip2').lower()
2131 2131 btypes = {'none': 'HG10UN', 'bzip2': 'HG10BZ', 'gzip': 'HG10GZ'}
2132 2132 bundletype = btypes.get(bundletype)
2133 2133 if bundletype not in changegroup.bundletypes:
2134 2134 raise util.Abort(_('unknown bundle type specified with --type'))
2135 2135 changegroup.writebundle(bundle, bundlepath, bundletype)
2136 2136
2137 2137 @command('debugignore', [], '')
2138 2138 def debugignore(ui, repo, *values, **opts):
2139 2139 """display the combined ignore pattern"""
2140 2140 ignore = repo.dirstate._ignore
2141 2141 includepat = getattr(ignore, 'includepat', None)
2142 2142 if includepat is not None:
2143 2143 ui.write("%s\n" % includepat)
2144 2144 else:
2145 2145 raise util.Abort(_("no ignore patterns found"))
2146 2146
2147 2147 @command('debugindex',
2148 2148 [('c', 'changelog', False, _('open changelog')),
2149 2149 ('m', 'manifest', False, _('open manifest')),
2150 2150 ('f', 'format', 0, _('revlog format'), _('FORMAT'))],
2151 2151 _('[-f FORMAT] -c|-m|FILE'),
2152 2152 optionalrepo=True)
2153 2153 def debugindex(ui, repo, file_=None, **opts):
2154 2154 """dump the contents of an index file"""
2155 2155 r = cmdutil.openrevlog(repo, 'debugindex', file_, opts)
2156 2156 format = opts.get('format', 0)
2157 2157 if format not in (0, 1):
2158 2158 raise util.Abort(_("unknown format %d") % format)
2159 2159
2160 2160 generaldelta = r.version & revlog.REVLOGGENERALDELTA
2161 2161 if generaldelta:
2162 2162 basehdr = ' delta'
2163 2163 else:
2164 2164 basehdr = ' base'
2165 2165
2166 2166 if format == 0:
2167 2167 ui.write(" rev offset length " + basehdr + " linkrev"
2168 2168 " nodeid p1 p2\n")
2169 2169 elif format == 1:
2170 2170 ui.write(" rev flag offset length"
2171 2171 " size " + basehdr + " link p1 p2"
2172 2172 " nodeid\n")
2173 2173
2174 2174 for i in r:
2175 2175 node = r.node(i)
2176 2176 if generaldelta:
2177 2177 base = r.deltaparent(i)
2178 2178 else:
2179 2179 base = r.chainbase(i)
2180 2180 if format == 0:
2181 2181 try:
2182 2182 pp = r.parents(node)
2183 2183 except Exception:
2184 2184 pp = [nullid, nullid]
2185 2185 ui.write("% 6d % 9d % 7d % 6d % 7d %s %s %s\n" % (
2186 2186 i, r.start(i), r.length(i), base, r.linkrev(i),
2187 2187 short(node), short(pp[0]), short(pp[1])))
2188 2188 elif format == 1:
2189 2189 pr = r.parentrevs(i)
2190 2190 ui.write("% 6d %04x % 8d % 8d % 8d % 6d % 6d % 6d % 6d %s\n" % (
2191 2191 i, r.flags(i), r.start(i), r.length(i), r.rawsize(i),
2192 2192 base, r.linkrev(i), pr[0], pr[1], short(node)))
2193 2193
2194 2194 @command('debugindexdot', [], _('FILE'), optionalrepo=True)
2195 2195 def debugindexdot(ui, repo, file_):
2196 2196 """dump an index DAG as a graphviz dot file"""
2197 2197 r = None
2198 2198 if repo:
2199 2199 filelog = repo.file(file_)
2200 2200 if len(filelog):
2201 2201 r = filelog
2202 2202 if not r:
2203 2203 r = revlog.revlog(scmutil.opener(os.getcwd(), audit=False), file_)
2204 2204 ui.write(("digraph G {\n"))
2205 2205 for i in r:
2206 2206 node = r.node(i)
2207 2207 pp = r.parents(node)
2208 2208 ui.write("\t%d -> %d\n" % (r.rev(pp[0]), i))
2209 2209 if pp[1] != nullid:
2210 2210 ui.write("\t%d -> %d\n" % (r.rev(pp[1]), i))
2211 2211 ui.write("}\n")
2212 2212
2213 2213 @command('debuginstall', [], '', norepo=True)
2214 2214 def debuginstall(ui):
2215 2215 '''test Mercurial installation
2216 2216
2217 2217 Returns 0 on success.
2218 2218 '''
2219 2219
2220 2220 def writetemp(contents):
2221 2221 (fd, name) = tempfile.mkstemp(prefix="hg-debuginstall-")
2222 2222 f = os.fdopen(fd, "wb")
2223 2223 f.write(contents)
2224 2224 f.close()
2225 2225 return name
2226 2226
2227 2227 problems = 0
2228 2228
2229 2229 # encoding
2230 2230 ui.status(_("checking encoding (%s)...\n") % encoding.encoding)
2231 2231 try:
2232 2232 encoding.fromlocal("test")
2233 2233 except util.Abort, inst:
2234 2234 ui.write(" %s\n" % inst)
2235 2235 ui.write(_(" (check that your locale is properly set)\n"))
2236 2236 problems += 1
2237 2237
2238 2238 # Python
2239 2239 ui.status(_("checking Python executable (%s)\n") % sys.executable)
2240 2240 ui.status(_("checking Python version (%s)\n")
2241 2241 % ("%s.%s.%s" % sys.version_info[:3]))
2242 2242 ui.status(_("checking Python lib (%s)...\n")
2243 2243 % os.path.dirname(os.__file__))
2244 2244
2245 2245 # compiled modules
2246 2246 ui.status(_("checking installed modules (%s)...\n")
2247 2247 % os.path.dirname(__file__))
2248 2248 try:
2249 2249 import bdiff, mpatch, base85, osutil
2250 2250 dir(bdiff), dir(mpatch), dir(base85), dir(osutil) # quiet pyflakes
2251 2251 except Exception, inst:
2252 2252 ui.write(" %s\n" % inst)
2253 2253 ui.write(_(" One or more extensions could not be found"))
2254 2254 ui.write(_(" (check that you compiled the extensions)\n"))
2255 2255 problems += 1
2256 2256
2257 2257 # templates
2258 2258 import templater
2259 2259 p = templater.templatepath()
2260 2260 ui.status(_("checking templates (%s)...\n") % ' '.join(p))
2261 2261 if p:
2262 2262 m = templater.templatepath("map-cmdline.default")
2263 2263 if m:
2264 2264 # template found, check if it is working
2265 2265 try:
2266 2266 templater.templater(m)
2267 2267 except Exception, inst:
2268 2268 ui.write(" %s\n" % inst)
2269 2269 p = None
2270 2270 else:
2271 2271 ui.write(_(" template 'default' not found\n"))
2272 2272 p = None
2273 2273 else:
2274 2274 ui.write(_(" no template directories found\n"))
2275 2275 if not p:
2276 2276 ui.write(_(" (templates seem to have been installed incorrectly)\n"))
2277 2277 problems += 1
2278 2278
2279 2279 # editor
2280 2280 ui.status(_("checking commit editor...\n"))
2281 2281 editor = ui.geteditor()
2282 2282 cmdpath = util.findexe(shlex.split(editor)[0])
2283 2283 if not cmdpath:
2284 2284 if editor == 'vi':
2285 2285 ui.write(_(" No commit editor set and can't find vi in PATH\n"))
2286 2286 ui.write(_(" (specify a commit editor in your configuration"
2287 2287 " file)\n"))
2288 2288 else:
2289 2289 ui.write(_(" Can't find editor '%s' in PATH\n") % editor)
2290 2290 ui.write(_(" (specify a commit editor in your configuration"
2291 2291 " file)\n"))
2292 2292 problems += 1
2293 2293
2294 2294 # check username
2295 2295 ui.status(_("checking username...\n"))
2296 2296 try:
2297 2297 ui.username()
2298 2298 except util.Abort, e:
2299 2299 ui.write(" %s\n" % e)
2300 2300 ui.write(_(" (specify a username in your configuration file)\n"))
2301 2301 problems += 1
2302 2302
2303 2303 if not problems:
2304 2304 ui.status(_("no problems detected\n"))
2305 2305 else:
2306 2306 ui.write(_("%s problems detected,"
2307 2307 " please check your install!\n") % problems)
2308 2308
2309 2309 return problems
2310 2310
2311 2311 @command('debugknown', [], _('REPO ID...'), norepo=True)
2312 2312 def debugknown(ui, repopath, *ids, **opts):
2313 2313 """test whether node ids are known to a repo
2314 2314
2315 2315 Every ID must be a full-length hex node id string. Returns a list of 0s
2316 2316 and 1s indicating unknown/known.
2317 2317 """
2318 2318 repo = hg.peer(ui, opts, repopath)
2319 2319 if not repo.capable('known'):
2320 2320 raise util.Abort("known() not supported by target repository")
2321 2321 flags = repo.known([bin(s) for s in ids])
2322 2322 ui.write("%s\n" % ("".join([f and "1" or "0" for f in flags])))
2323 2323
2324 2324 @command('debuglabelcomplete', [], _('LABEL...'))
2325 2325 def debuglabelcomplete(ui, repo, *args):
2326 2326 '''complete "labels" - tags, open branch names, bookmark names'''
2327 2327
2328 2328 labels = set()
2329 2329 labels.update(t[0] for t in repo.tagslist())
2330 2330 labels.update(repo._bookmarks.keys())
2331 2331 labels.update(tag for (tag, heads, tip, closed)
2332 2332 in repo.branchmap().iterbranches() if not closed)
2333 2333 completions = set()
2334 2334 if not args:
2335 2335 args = ['']
2336 2336 for a in args:
2337 2337 completions.update(l for l in labels if l.startswith(a))
2338 2338 ui.write('\n'.join(sorted(completions)))
2339 2339 ui.write('\n')
2340 2340
2341 2341 @command('debuglocks',
2342 2342 [('L', 'force-lock', None, _('free the store lock (DANGEROUS)')),
2343 2343 ('W', 'force-wlock', None,
2344 2344 _('free the working state lock (DANGEROUS)'))],
2345 2345 _(''))
2346 2346 def debuglocks(ui, repo, **opts):
2347 2347 """show or modify state of locks
2348 2348
2349 2349 By default, this command will show which locks are held. This
2350 2350 includes the user and process holding the lock, the amount of time
2351 2351 the lock has been held, and the machine name where the process is
2352 2352 running if it's not local.
2353 2353
2354 2354 Locks protect the integrity of Mercurial's data, so should be
2355 2355 treated with care. System crashes or other interruptions may cause
2356 2356 locks to not be properly released, though Mercurial will usually
2357 2357 detect and remove such stale locks automatically.
2358 2358
2359 2359 However, detecting stale locks may not always be possible (for
2360 2360 instance, on a shared filesystem). Removing locks may also be
2361 2361 blocked by filesystem permissions.
2362 2362
2363 2363 Returns 0 if no locks are held.
2364 2364
2365 2365 """
2366 2366
2367 2367 if opts.get('force_lock'):
2368 2368 repo.svfs.unlink('lock')
2369 2369 if opts.get('force_wlock'):
2370 2370 repo.vfs.unlink('wlock')
2371 2371 if opts.get('force_lock') or opts.get('force_lock'):
2372 2372 return 0
2373 2373
2374 2374 now = time.time()
2375 2375 held = 0
2376 2376
2377 2377 def report(vfs, name, method):
2378 2378 # this causes stale locks to get reaped for more accurate reporting
2379 2379 try:
2380 2380 l = method(False)
2381 2381 except error.LockHeld:
2382 2382 l = None
2383 2383
2384 2384 if l:
2385 2385 l.release()
2386 2386 else:
2387 2387 try:
2388 2388 stat = repo.svfs.lstat(name)
2389 2389 age = now - stat.st_mtime
2390 2390 user = util.username(stat.st_uid)
2391 2391 locker = vfs.readlock(name)
2392 2392 if ":" in locker:
2393 2393 host, pid = locker.split(':')
2394 2394 if host == socket.gethostname():
2395 2395 locker = 'user %s, process %s' % (user, pid)
2396 2396 else:
2397 2397 locker = 'user %s, process %s, host %s' \
2398 2398 % (user, pid, host)
2399 2399 ui.write("%-6s %s (%ds)\n" % (name + ":", locker, age))
2400 2400 return 1
2401 2401 except OSError, e:
2402 2402 if e.errno != errno.ENOENT:
2403 2403 raise
2404 2404
2405 2405 ui.write("%-6s free\n" % (name + ":"))
2406 2406 return 0
2407 2407
2408 2408 held += report(repo.svfs, "lock", repo.lock)
2409 2409 held += report(repo.vfs, "wlock", repo.wlock)
2410 2410
2411 2411 return held
2412 2412
2413 2413 @command('debugobsolete',
2414 2414 [('', 'flags', 0, _('markers flag')),
2415 2415 ('', 'record-parents', False,
2416 2416 _('record parent information for the precursor')),
2417 2417 ('r', 'rev', [], _('display markers relevant to REV')),
2418 2418 ] + commitopts2,
2419 2419 _('[OBSOLETED [REPLACEMENT] [REPL... ]'))
2420 2420 def debugobsolete(ui, repo, precursor=None, *successors, **opts):
2421 2421 """create arbitrary obsolete marker
2422 2422
2423 2423 With no arguments, displays the list of obsolescence markers."""
2424 2424
2425 2425 def parsenodeid(s):
2426 2426 try:
2427 2427 # We do not use revsingle/revrange functions here to accept
2428 2428 # arbitrary node identifiers, possibly not present in the
2429 2429 # local repository.
2430 2430 n = bin(s)
2431 2431 if len(n) != len(nullid):
2432 2432 raise TypeError()
2433 2433 return n
2434 2434 except TypeError:
2435 2435 raise util.Abort('changeset references must be full hexadecimal '
2436 2436 'node identifiers')
2437 2437
2438 2438 if precursor is not None:
2439 2439 if opts['rev']:
2440 2440 raise util.Abort('cannot select revision when creating marker')
2441 2441 metadata = {}
2442 2442 metadata['user'] = opts['user'] or ui.username()
2443 2443 succs = tuple(parsenodeid(succ) for succ in successors)
2444 2444 l = repo.lock()
2445 2445 try:
2446 2446 tr = repo.transaction('debugobsolete')
2447 2447 try:
2448 2448 try:
2449 2449 date = opts.get('date')
2450 2450 if date:
2451 2451 date = util.parsedate(date)
2452 2452 else:
2453 2453 date = None
2454 2454 prec = parsenodeid(precursor)
2455 2455 parents = None
2456 2456 if opts['record_parents']:
2457 2457 if prec not in repo.unfiltered():
2458 2458 raise util.Abort('cannot used --record-parents on '
2459 2459 'unknown changesets')
2460 2460 parents = repo.unfiltered()[prec].parents()
2461 2461 parents = tuple(p.node() for p in parents)
2462 2462 repo.obsstore.create(tr, prec, succs, opts['flags'],
2463 2463 parents=parents, date=date,
2464 2464 metadata=metadata)
2465 2465 tr.close()
2466 2466 except ValueError, exc:
2467 2467 raise util.Abort(_('bad obsmarker input: %s') % exc)
2468 2468 finally:
2469 2469 tr.release()
2470 2470 finally:
2471 2471 l.release()
2472 2472 else:
2473 2473 if opts['rev']:
2474 2474 revs = scmutil.revrange(repo, opts['rev'])
2475 2475 nodes = [repo[r].node() for r in revs]
2476 2476 markers = list(obsolete.getmarkers(repo, nodes=nodes))
2477 2477 markers.sort(key=lambda x: x._data)
2478 2478 else:
2479 2479 markers = obsolete.getmarkers(repo)
2480 2480
2481 2481 for m in markers:
2482 2482 cmdutil.showmarker(ui, m)
2483 2483
2484 2484 @command('debugpathcomplete',
2485 2485 [('f', 'full', None, _('complete an entire path')),
2486 2486 ('n', 'normal', None, _('show only normal files')),
2487 2487 ('a', 'added', None, _('show only added files')),
2488 2488 ('r', 'removed', None, _('show only removed files'))],
2489 2489 _('FILESPEC...'))
2490 2490 def debugpathcomplete(ui, repo, *specs, **opts):
2491 2491 '''complete part or all of a tracked path
2492 2492
2493 2493 This command supports shells that offer path name completion. It
2494 2494 currently completes only files already known to the dirstate.
2495 2495
2496 2496 Completion extends only to the next path segment unless
2497 2497 --full is specified, in which case entire paths are used.'''
2498 2498
2499 2499 def complete(path, acceptable):
2500 2500 dirstate = repo.dirstate
2501 2501 spec = os.path.normpath(os.path.join(os.getcwd(), path))
2502 2502 rootdir = repo.root + os.sep
2503 2503 if spec != repo.root and not spec.startswith(rootdir):
2504 2504 return [], []
2505 2505 if os.path.isdir(spec):
2506 2506 spec += '/'
2507 2507 spec = spec[len(rootdir):]
2508 2508 fixpaths = os.sep != '/'
2509 2509 if fixpaths:
2510 2510 spec = spec.replace(os.sep, '/')
2511 2511 speclen = len(spec)
2512 2512 fullpaths = opts['full']
2513 2513 files, dirs = set(), set()
2514 2514 adddir, addfile = dirs.add, files.add
2515 2515 for f, st in dirstate.iteritems():
2516 2516 if f.startswith(spec) and st[0] in acceptable:
2517 2517 if fixpaths:
2518 2518 f = f.replace('/', os.sep)
2519 2519 if fullpaths:
2520 2520 addfile(f)
2521 2521 continue
2522 2522 s = f.find(os.sep, speclen)
2523 2523 if s >= 0:
2524 2524 adddir(f[:s])
2525 2525 else:
2526 2526 addfile(f)
2527 2527 return files, dirs
2528 2528
2529 2529 acceptable = ''
2530 2530 if opts['normal']:
2531 2531 acceptable += 'nm'
2532 2532 if opts['added']:
2533 2533 acceptable += 'a'
2534 2534 if opts['removed']:
2535 2535 acceptable += 'r'
2536 2536 cwd = repo.getcwd()
2537 2537 if not specs:
2538 2538 specs = ['.']
2539 2539
2540 2540 files, dirs = set(), set()
2541 2541 for spec in specs:
2542 2542 f, d = complete(spec, acceptable or 'nmar')
2543 2543 files.update(f)
2544 2544 dirs.update(d)
2545 2545 files.update(dirs)
2546 2546 ui.write('\n'.join(repo.pathto(p, cwd) for p in sorted(files)))
2547 2547 ui.write('\n')
2548 2548
2549 2549 @command('debugpushkey', [], _('REPO NAMESPACE [KEY OLD NEW]'), norepo=True)
2550 2550 def debugpushkey(ui, repopath, namespace, *keyinfo, **opts):
2551 2551 '''access the pushkey key/value protocol
2552 2552
2553 2553 With two args, list the keys in the given namespace.
2554 2554
2555 2555 With five args, set a key to new if it currently is set to old.
2556 2556 Reports success or failure.
2557 2557 '''
2558 2558
2559 2559 target = hg.peer(ui, {}, repopath)
2560 2560 if keyinfo:
2561 2561 key, old, new = keyinfo
2562 2562 r = target.pushkey(namespace, key, old, new)
2563 2563 ui.status(str(r) + '\n')
2564 2564 return not r
2565 2565 else:
2566 2566 for k, v in sorted(target.listkeys(namespace).iteritems()):
2567 2567 ui.write("%s\t%s\n" % (k.encode('string-escape'),
2568 2568 v.encode('string-escape')))
2569 2569
2570 2570 @command('debugpvec', [], _('A B'))
2571 2571 def debugpvec(ui, repo, a, b=None):
2572 2572 ca = scmutil.revsingle(repo, a)
2573 2573 cb = scmutil.revsingle(repo, b)
2574 2574 pa = pvec.ctxpvec(ca)
2575 2575 pb = pvec.ctxpvec(cb)
2576 2576 if pa == pb:
2577 2577 rel = "="
2578 2578 elif pa > pb:
2579 2579 rel = ">"
2580 2580 elif pa < pb:
2581 2581 rel = "<"
2582 2582 elif pa | pb:
2583 2583 rel = "|"
2584 2584 ui.write(_("a: %s\n") % pa)
2585 2585 ui.write(_("b: %s\n") % pb)
2586 2586 ui.write(_("depth(a): %d depth(b): %d\n") % (pa._depth, pb._depth))
2587 2587 ui.write(_("delta: %d hdist: %d distance: %d relation: %s\n") %
2588 2588 (abs(pa._depth - pb._depth), pvec._hamming(pa._vec, pb._vec),
2589 2589 pa.distance(pb), rel))
2590 2590
2591 2591 @command('debugrebuilddirstate|debugrebuildstate',
2592 2592 [('r', 'rev', '', _('revision to rebuild to'), _('REV'))],
2593 2593 _('[-r REV]'))
2594 2594 def debugrebuilddirstate(ui, repo, rev):
2595 2595 """rebuild the dirstate as it would look like for the given revision
2596 2596
2597 2597 If no revision is specified the first current parent will be used.
2598 2598
2599 2599 The dirstate will be set to the files of the given revision.
2600 2600 The actual working directory content or existing dirstate
2601 2601 information such as adds or removes is not considered.
2602 2602
2603 2603 One use of this command is to make the next :hg:`status` invocation
2604 2604 check the actual file content.
2605 2605 """
2606 2606 ctx = scmutil.revsingle(repo, rev)
2607 2607 wlock = repo.wlock()
2608 2608 try:
2609 2609 repo.dirstate.rebuild(ctx.node(), ctx.manifest())
2610 2610 finally:
2611 2611 wlock.release()
2612 2612
2613 2613 @command('debugrename',
2614 2614 [('r', 'rev', '', _('revision to debug'), _('REV'))],
2615 2615 _('[-r REV] FILE'))
2616 2616 def debugrename(ui, repo, file1, *pats, **opts):
2617 2617 """dump rename information"""
2618 2618
2619 2619 ctx = scmutil.revsingle(repo, opts.get('rev'))
2620 2620 m = scmutil.match(ctx, (file1,) + pats, opts)
2621 2621 for abs in ctx.walk(m):
2622 2622 fctx = ctx[abs]
2623 2623 o = fctx.filelog().renamed(fctx.filenode())
2624 2624 rel = m.rel(abs)
2625 2625 if o:
2626 2626 ui.write(_("%s renamed from %s:%s\n") % (rel, o[0], hex(o[1])))
2627 2627 else:
2628 2628 ui.write(_("%s not renamed\n") % rel)
2629 2629
2630 2630 @command('debugrevlog',
2631 2631 [('c', 'changelog', False, _('open changelog')),
2632 2632 ('m', 'manifest', False, _('open manifest')),
2633 2633 ('d', 'dump', False, _('dump index data'))],
2634 2634 _('-c|-m|FILE'),
2635 2635 optionalrepo=True)
2636 2636 def debugrevlog(ui, repo, file_=None, **opts):
2637 2637 """show data and statistics about a revlog"""
2638 2638 r = cmdutil.openrevlog(repo, 'debugrevlog', file_, opts)
2639 2639
2640 2640 if opts.get("dump"):
2641 2641 numrevs = len(r)
2642 2642 ui.write("# rev p1rev p2rev start end deltastart base p1 p2"
2643 2643 " rawsize totalsize compression heads chainlen\n")
2644 2644 ts = 0
2645 2645 heads = set()
2646 2646 rindex = r.index
2647 2647
2648 2648 def chainbaseandlen(rev):
2649 2649 clen = 0
2650 2650 base = rindex[rev][3]
2651 2651 while base != rev:
2652 2652 clen += 1
2653 2653 rev = base
2654 2654 base = rindex[rev][3]
2655 2655 return base, clen
2656 2656
2657 2657 for rev in xrange(numrevs):
2658 2658 dbase = r.deltaparent(rev)
2659 2659 if dbase == -1:
2660 2660 dbase = rev
2661 2661 cbase, clen = chainbaseandlen(rev)
2662 2662 p1, p2 = r.parentrevs(rev)
2663 2663 rs = r.rawsize(rev)
2664 2664 ts = ts + rs
2665 2665 heads -= set(r.parentrevs(rev))
2666 2666 heads.add(rev)
2667 2667 ui.write("%5d %5d %5d %5d %5d %10d %4d %4d %4d %7d %9d "
2668 2668 "%11d %5d %8d\n" %
2669 2669 (rev, p1, p2, r.start(rev), r.end(rev),
2670 2670 r.start(dbase), r.start(cbase),
2671 2671 r.start(p1), r.start(p2),
2672 2672 rs, ts, ts / r.end(rev), len(heads), clen))
2673 2673 return 0
2674 2674
2675 2675 v = r.version
2676 2676 format = v & 0xFFFF
2677 2677 flags = []
2678 2678 gdelta = False
2679 2679 if v & revlog.REVLOGNGINLINEDATA:
2680 2680 flags.append('inline')
2681 2681 if v & revlog.REVLOGGENERALDELTA:
2682 2682 gdelta = True
2683 2683 flags.append('generaldelta')
2684 2684 if not flags:
2685 2685 flags = ['(none)']
2686 2686
2687 2687 nummerges = 0
2688 2688 numfull = 0
2689 2689 numprev = 0
2690 2690 nump1 = 0
2691 2691 nump2 = 0
2692 2692 numother = 0
2693 2693 nump1prev = 0
2694 2694 nump2prev = 0
2695 2695 chainlengths = []
2696 2696
2697 2697 datasize = [None, 0, 0L]
2698 2698 fullsize = [None, 0, 0L]
2699 2699 deltasize = [None, 0, 0L]
2700 2700
2701 2701 def addsize(size, l):
2702 2702 if l[0] is None or size < l[0]:
2703 2703 l[0] = size
2704 2704 if size > l[1]:
2705 2705 l[1] = size
2706 2706 l[2] += size
2707 2707
2708 2708 numrevs = len(r)
2709 2709 for rev in xrange(numrevs):
2710 2710 p1, p2 = r.parentrevs(rev)
2711 2711 delta = r.deltaparent(rev)
2712 2712 if format > 0:
2713 2713 addsize(r.rawsize(rev), datasize)
2714 2714 if p2 != nullrev:
2715 2715 nummerges += 1
2716 2716 size = r.length(rev)
2717 2717 if delta == nullrev:
2718 2718 chainlengths.append(0)
2719 2719 numfull += 1
2720 2720 addsize(size, fullsize)
2721 2721 else:
2722 2722 chainlengths.append(chainlengths[delta] + 1)
2723 2723 addsize(size, deltasize)
2724 2724 if delta == rev - 1:
2725 2725 numprev += 1
2726 2726 if delta == p1:
2727 2727 nump1prev += 1
2728 2728 elif delta == p2:
2729 2729 nump2prev += 1
2730 2730 elif delta == p1:
2731 2731 nump1 += 1
2732 2732 elif delta == p2:
2733 2733 nump2 += 1
2734 2734 elif delta != nullrev:
2735 2735 numother += 1
2736 2736
2737 2737 # Adjust size min value for empty cases
2738 2738 for size in (datasize, fullsize, deltasize):
2739 2739 if size[0] is None:
2740 2740 size[0] = 0
2741 2741
2742 2742 numdeltas = numrevs - numfull
2743 2743 numoprev = numprev - nump1prev - nump2prev
2744 2744 totalrawsize = datasize[2]
2745 2745 datasize[2] /= numrevs
2746 2746 fulltotal = fullsize[2]
2747 2747 fullsize[2] /= numfull
2748 2748 deltatotal = deltasize[2]
2749 2749 if numrevs - numfull > 0:
2750 2750 deltasize[2] /= numrevs - numfull
2751 2751 totalsize = fulltotal + deltatotal
2752 2752 avgchainlen = sum(chainlengths) / numrevs
2753 2753 compratio = totalrawsize / totalsize
2754 2754
2755 2755 basedfmtstr = '%%%dd\n'
2756 2756 basepcfmtstr = '%%%dd %s(%%5.2f%%%%)\n'
2757 2757
2758 2758 def dfmtstr(max):
2759 2759 return basedfmtstr % len(str(max))
2760 2760 def pcfmtstr(max, padding=0):
2761 2761 return basepcfmtstr % (len(str(max)), ' ' * padding)
2762 2762
2763 2763 def pcfmt(value, total):
2764 2764 return (value, 100 * float(value) / total)
2765 2765
2766 2766 ui.write(('format : %d\n') % format)
2767 2767 ui.write(('flags : %s\n') % ', '.join(flags))
2768 2768
2769 2769 ui.write('\n')
2770 2770 fmt = pcfmtstr(totalsize)
2771 2771 fmt2 = dfmtstr(totalsize)
2772 2772 ui.write(('revisions : ') + fmt2 % numrevs)
2773 2773 ui.write((' merges : ') + fmt % pcfmt(nummerges, numrevs))
2774 2774 ui.write((' normal : ') + fmt % pcfmt(numrevs - nummerges, numrevs))
2775 2775 ui.write(('revisions : ') + fmt2 % numrevs)
2776 2776 ui.write((' full : ') + fmt % pcfmt(numfull, numrevs))
2777 2777 ui.write((' deltas : ') + fmt % pcfmt(numdeltas, numrevs))
2778 2778 ui.write(('revision size : ') + fmt2 % totalsize)
2779 2779 ui.write((' full : ') + fmt % pcfmt(fulltotal, totalsize))
2780 2780 ui.write((' deltas : ') + fmt % pcfmt(deltatotal, totalsize))
2781 2781
2782 2782 ui.write('\n')
2783 2783 fmt = dfmtstr(max(avgchainlen, compratio))
2784 2784 ui.write(('avg chain length : ') + fmt % avgchainlen)
2785 2785 ui.write(('compression ratio : ') + fmt % compratio)
2786 2786
2787 2787 if format > 0:
2788 2788 ui.write('\n')
2789 2789 ui.write(('uncompressed data size (min/max/avg) : %d / %d / %d\n')
2790 2790 % tuple(datasize))
2791 2791 ui.write(('full revision size (min/max/avg) : %d / %d / %d\n')
2792 2792 % tuple(fullsize))
2793 2793 ui.write(('delta size (min/max/avg) : %d / %d / %d\n')
2794 2794 % tuple(deltasize))
2795 2795
2796 2796 if numdeltas > 0:
2797 2797 ui.write('\n')
2798 2798 fmt = pcfmtstr(numdeltas)
2799 2799 fmt2 = pcfmtstr(numdeltas, 4)
2800 2800 ui.write(('deltas against prev : ') + fmt % pcfmt(numprev, numdeltas))
2801 2801 if numprev > 0:
2802 2802 ui.write((' where prev = p1 : ') + fmt2 % pcfmt(nump1prev,
2803 2803 numprev))
2804 2804 ui.write((' where prev = p2 : ') + fmt2 % pcfmt(nump2prev,
2805 2805 numprev))
2806 2806 ui.write((' other : ') + fmt2 % pcfmt(numoprev,
2807 2807 numprev))
2808 2808 if gdelta:
2809 2809 ui.write(('deltas against p1 : ')
2810 2810 + fmt % pcfmt(nump1, numdeltas))
2811 2811 ui.write(('deltas against p2 : ')
2812 2812 + fmt % pcfmt(nump2, numdeltas))
2813 2813 ui.write(('deltas against other : ') + fmt % pcfmt(numother,
2814 2814 numdeltas))
2815 2815
2816 2816 @command('debugrevspec',
2817 2817 [('', 'optimize', None, _('print parsed tree after optimizing'))],
2818 2818 ('REVSPEC'))
2819 2819 def debugrevspec(ui, repo, expr, **opts):
2820 2820 """parse and apply a revision specification
2821 2821
2822 2822 Use --verbose to print the parsed tree before and after aliases
2823 2823 expansion.
2824 2824 """
2825 2825 if ui.verbose:
2826 2826 tree = revset.parse(expr)[0]
2827 2827 ui.note(revset.prettyformat(tree), "\n")
2828 2828 newtree = revset.findaliases(ui, tree)
2829 2829 if newtree != tree:
2830 2830 ui.note(revset.prettyformat(newtree), "\n")
2831 2831 if opts["optimize"]:
2832 2832 weight, optimizedtree = revset.optimize(newtree, True)
2833 2833 ui.note("* optimized:\n", revset.prettyformat(optimizedtree), "\n")
2834 2834 func = revset.match(ui, expr)
2835 2835 for c in func(repo, revset.spanset(repo)):
2836 2836 ui.write("%s\n" % c)
2837 2837
2838 2838 @command('debugsetparents', [], _('REV1 [REV2]'))
2839 2839 def debugsetparents(ui, repo, rev1, rev2=None):
2840 2840 """manually set the parents of the current working directory
2841 2841
2842 2842 This is useful for writing repository conversion tools, but should
2843 2843 be used with care.
2844 2844
2845 2845 Returns 0 on success.
2846 2846 """
2847 2847
2848 2848 r1 = scmutil.revsingle(repo, rev1).node()
2849 2849 r2 = scmutil.revsingle(repo, rev2, 'null').node()
2850 2850
2851 2851 wlock = repo.wlock()
2852 2852 try:
2853 2853 repo.dirstate.beginparentchange()
2854 2854 repo.setparents(r1, r2)
2855 2855 repo.dirstate.endparentchange()
2856 2856 finally:
2857 2857 wlock.release()
2858 2858
2859 2859 @command('debugdirstate|debugstate',
2860 2860 [('', 'nodates', None, _('do not display the saved mtime')),
2861 2861 ('', 'datesort', None, _('sort by saved mtime'))],
2862 2862 _('[OPTION]...'))
2863 2863 def debugstate(ui, repo, nodates=None, datesort=None):
2864 2864 """show the contents of the current dirstate"""
2865 2865 timestr = ""
2866 2866 showdate = not nodates
2867 2867 if datesort:
2868 2868 keyfunc = lambda x: (x[1][3], x[0]) # sort by mtime, then by filename
2869 2869 else:
2870 2870 keyfunc = None # sort by filename
2871 2871 for file_, ent in sorted(repo.dirstate._map.iteritems(), key=keyfunc):
2872 2872 if showdate:
2873 2873 if ent[3] == -1:
2874 2874 # Pad or slice to locale representation
2875 2875 locale_len = len(time.strftime("%Y-%m-%d %H:%M:%S ",
2876 2876 time.localtime(0)))
2877 2877 timestr = 'unset'
2878 2878 timestr = (timestr[:locale_len] +
2879 2879 ' ' * (locale_len - len(timestr)))
2880 2880 else:
2881 2881 timestr = time.strftime("%Y-%m-%d %H:%M:%S ",
2882 2882 time.localtime(ent[3]))
2883 2883 if ent[1] & 020000:
2884 2884 mode = 'lnk'
2885 2885 else:
2886 2886 mode = '%3o' % (ent[1] & 0777 & ~util.umask)
2887 2887 ui.write("%c %s %10d %s%s\n" % (ent[0], mode, ent[2], timestr, file_))
2888 2888 for f in repo.dirstate.copies():
2889 2889 ui.write(_("copy: %s -> %s\n") % (repo.dirstate.copied(f), f))
2890 2890
2891 2891 @command('debugsub',
2892 2892 [('r', 'rev', '',
2893 2893 _('revision to check'), _('REV'))],
2894 2894 _('[-r REV] [REV]'))
2895 2895 def debugsub(ui, repo, rev=None):
2896 2896 ctx = scmutil.revsingle(repo, rev, None)
2897 2897 for k, v in sorted(ctx.substate.items()):
2898 2898 ui.write(('path %s\n') % k)
2899 2899 ui.write((' source %s\n') % v[0])
2900 2900 ui.write((' revision %s\n') % v[1])
2901 2901
2902 2902 @command('debugsuccessorssets',
2903 2903 [],
2904 2904 _('[REV]'))
2905 2905 def debugsuccessorssets(ui, repo, *revs):
2906 2906 """show set of successors for revision
2907 2907
2908 2908 A successors set of changeset A is a consistent group of revisions that
2909 2909 succeed A. It contains non-obsolete changesets only.
2910 2910
2911 2911 In most cases a changeset A has a single successors set containing a single
2912 2912 successor (changeset A replaced by A').
2913 2913
2914 2914 A changeset that is made obsolete with no successors are called "pruned".
2915 2915 Such changesets have no successors sets at all.
2916 2916
2917 2917 A changeset that has been "split" will have a successors set containing
2918 2918 more than one successor.
2919 2919
2920 2920 A changeset that has been rewritten in multiple different ways is called
2921 2921 "divergent". Such changesets have multiple successor sets (each of which
2922 2922 may also be split, i.e. have multiple successors).
2923 2923
2924 2924 Results are displayed as follows::
2925 2925
2926 2926 <rev1>
2927 2927 <successors-1A>
2928 2928 <rev2>
2929 2929 <successors-2A>
2930 2930 <successors-2B1> <successors-2B2> <successors-2B3>
2931 2931
2932 2932 Here rev2 has two possible (i.e. divergent) successors sets. The first
2933 2933 holds one element, whereas the second holds three (i.e. the changeset has
2934 2934 been split).
2935 2935 """
2936 2936 # passed to successorssets caching computation from one call to another
2937 2937 cache = {}
2938 2938 ctx2str = str
2939 2939 node2str = short
2940 2940 if ui.debug():
2941 2941 def ctx2str(ctx):
2942 2942 return ctx.hex()
2943 2943 node2str = hex
2944 2944 for rev in scmutil.revrange(repo, revs):
2945 2945 ctx = repo[rev]
2946 2946 ui.write('%s\n'% ctx2str(ctx))
2947 2947 for succsset in obsolete.successorssets(repo, ctx.node(), cache):
2948 2948 if succsset:
2949 2949 ui.write(' ')
2950 2950 ui.write(node2str(succsset[0]))
2951 2951 for node in succsset[1:]:
2952 2952 ui.write(' ')
2953 2953 ui.write(node2str(node))
2954 2954 ui.write('\n')
2955 2955
2956 2956 @command('debugwalk', walkopts, _('[OPTION]... [FILE]...'), inferrepo=True)
2957 2957 def debugwalk(ui, repo, *pats, **opts):
2958 2958 """show how files match on given patterns"""
2959 2959 m = scmutil.match(repo[None], pats, opts)
2960 2960 items = list(repo.walk(m))
2961 2961 if not items:
2962 2962 return
2963 2963 f = lambda fn: fn
2964 2964 if ui.configbool('ui', 'slash') and os.sep != '/':
2965 2965 f = lambda fn: util.normpath(fn)
2966 2966 fmt = 'f %%-%ds %%-%ds %%s' % (
2967 2967 max([len(abs) for abs in items]),
2968 2968 max([len(m.rel(abs)) for abs in items]))
2969 2969 for abs in items:
2970 2970 line = fmt % (abs, f(m.rel(abs)), m.exact(abs) and 'exact' or '')
2971 2971 ui.write("%s\n" % line.rstrip())
2972 2972
2973 2973 @command('debugwireargs',
2974 2974 [('', 'three', '', 'three'),
2975 2975 ('', 'four', '', 'four'),
2976 2976 ('', 'five', '', 'five'),
2977 2977 ] + remoteopts,
2978 2978 _('REPO [OPTIONS]... [ONE [TWO]]'),
2979 2979 norepo=True)
2980 2980 def debugwireargs(ui, repopath, *vals, **opts):
2981 2981 repo = hg.peer(ui, opts, repopath)
2982 2982 for opt in remoteopts:
2983 2983 del opts[opt[1]]
2984 2984 args = {}
2985 2985 for k, v in opts.iteritems():
2986 2986 if v:
2987 2987 args[k] = v
2988 2988 # run twice to check that we don't mess up the stream for the next command
2989 2989 res1 = repo.debugwireargs(*vals, **args)
2990 2990 res2 = repo.debugwireargs(*vals, **args)
2991 2991 ui.write("%s\n" % res1)
2992 2992 if res1 != res2:
2993 2993 ui.warn("%s\n" % res2)
2994 2994
2995 2995 @command('^diff',
2996 2996 [('r', 'rev', [], _('revision'), _('REV')),
2997 2997 ('c', 'change', '', _('change made by revision'), _('REV'))
2998 2998 ] + diffopts + diffopts2 + walkopts + subrepoopts,
2999 2999 _('[OPTION]... ([-c REV] | [-r REV1 [-r REV2]]) [FILE]...'),
3000 3000 inferrepo=True)
3001 3001 def diff(ui, repo, *pats, **opts):
3002 3002 """diff repository (or selected files)
3003 3003
3004 3004 Show differences between revisions for the specified files.
3005 3005
3006 3006 Differences between files are shown using the unified diff format.
3007 3007
3008 3008 .. note::
3009 3009
3010 3010 diff may generate unexpected results for merges, as it will
3011 3011 default to comparing against the working directory's first
3012 3012 parent changeset if no revisions are specified.
3013 3013
3014 3014 When two revision arguments are given, then changes are shown
3015 3015 between those revisions. If only one revision is specified then
3016 3016 that revision is compared to the working directory, and, when no
3017 3017 revisions are specified, the working directory files are compared
3018 3018 to its parent.
3019 3019
3020 3020 Alternatively you can specify -c/--change with a revision to see
3021 3021 the changes in that changeset relative to its first parent.
3022 3022
3023 3023 Without the -a/--text option, diff will avoid generating diffs of
3024 3024 files it detects as binary. With -a, diff will generate a diff
3025 3025 anyway, probably with undesirable results.
3026 3026
3027 3027 Use the -g/--git option to generate diffs in the git extended diff
3028 3028 format. For more information, read :hg:`help diffs`.
3029 3029
3030 3030 .. container:: verbose
3031 3031
3032 3032 Examples:
3033 3033
3034 3034 - compare a file in the current working directory to its parent::
3035 3035
3036 3036 hg diff foo.c
3037 3037
3038 3038 - compare two historical versions of a directory, with rename info::
3039 3039
3040 3040 hg diff --git -r 1.0:1.2 lib/
3041 3041
3042 3042 - get change stats relative to the last change on some date::
3043 3043
3044 3044 hg diff --stat -r "date('may 2')"
3045 3045
3046 3046 - diff all newly-added files that contain a keyword::
3047 3047
3048 3048 hg diff "set:added() and grep(GNU)"
3049 3049
3050 3050 - compare a revision and its parents::
3051 3051
3052 3052 hg diff -c 9353 # compare against first parent
3053 3053 hg diff -r 9353^:9353 # same using revset syntax
3054 3054 hg diff -r 9353^2:9353 # compare against the second parent
3055 3055
3056 3056 Returns 0 on success.
3057 3057 """
3058 3058
3059 3059 revs = opts.get('rev')
3060 3060 change = opts.get('change')
3061 3061 stat = opts.get('stat')
3062 3062 reverse = opts.get('reverse')
3063 3063
3064 3064 if revs and change:
3065 3065 msg = _('cannot specify --rev and --change at the same time')
3066 3066 raise util.Abort(msg)
3067 3067 elif change:
3068 3068 node2 = scmutil.revsingle(repo, change, None).node()
3069 3069 node1 = repo[node2].p1().node()
3070 3070 else:
3071 3071 node1, node2 = scmutil.revpair(repo, revs)
3072 3072
3073 3073 if reverse:
3074 3074 node1, node2 = node2, node1
3075 3075
3076 3076 diffopts = patch.diffopts(ui, opts)
3077 3077 m = scmutil.match(repo[node2], pats, opts)
3078 3078 cmdutil.diffordiffstat(ui, repo, diffopts, node1, node2, m, stat=stat,
3079 3079 listsubrepos=opts.get('subrepos'))
3080 3080
3081 3081 @command('^export',
3082 3082 [('o', 'output', '',
3083 3083 _('print output to file with formatted name'), _('FORMAT')),
3084 3084 ('', 'switch-parent', None, _('diff against the second parent')),
3085 3085 ('r', 'rev', [], _('revisions to export'), _('REV')),
3086 3086 ] + diffopts,
3087 3087 _('[OPTION]... [-o OUTFILESPEC] [-r] [REV]...'))
3088 3088 def export(ui, repo, *changesets, **opts):
3089 3089 """dump the header and diffs for one or more changesets
3090 3090
3091 3091 Print the changeset header and diffs for one or more revisions.
3092 3092 If no revision is given, the parent of the working directory is used.
3093 3093
3094 3094 The information shown in the changeset header is: author, date,
3095 3095 branch name (if non-default), changeset hash, parent(s) and commit
3096 3096 comment.
3097 3097
3098 3098 .. note::
3099 3099
3100 3100 export may generate unexpected diff output for merge
3101 3101 changesets, as it will compare the merge changeset against its
3102 3102 first parent only.
3103 3103
3104 3104 Output may be to a file, in which case the name of the file is
3105 3105 given using a format string. The formatting rules are as follows:
3106 3106
3107 3107 :``%%``: literal "%" character
3108 3108 :``%H``: changeset hash (40 hexadecimal digits)
3109 3109 :``%N``: number of patches being generated
3110 3110 :``%R``: changeset revision number
3111 3111 :``%b``: basename of the exporting repository
3112 3112 :``%h``: short-form changeset hash (12 hexadecimal digits)
3113 3113 :``%m``: first line of the commit message (only alphanumeric characters)
3114 3114 :``%n``: zero-padded sequence number, starting at 1
3115 3115 :``%r``: zero-padded changeset revision number
3116 3116
3117 3117 Without the -a/--text option, export will avoid generating diffs
3118 3118 of files it detects as binary. With -a, export will generate a
3119 3119 diff anyway, probably with undesirable results.
3120 3120
3121 3121 Use the -g/--git option to generate diffs in the git extended diff
3122 3122 format. See :hg:`help diffs` for more information.
3123 3123
3124 3124 With the --switch-parent option, the diff will be against the
3125 3125 second parent. It can be useful to review a merge.
3126 3126
3127 3127 .. container:: verbose
3128 3128
3129 3129 Examples:
3130 3130
3131 3131 - use export and import to transplant a bugfix to the current
3132 3132 branch::
3133 3133
3134 3134 hg export -r 9353 | hg import -
3135 3135
3136 3136 - export all the changesets between two revisions to a file with
3137 3137 rename information::
3138 3138
3139 3139 hg export --git -r 123:150 > changes.txt
3140 3140
3141 3141 - split outgoing changes into a series of patches with
3142 3142 descriptive names::
3143 3143
3144 3144 hg export -r "outgoing()" -o "%n-%m.patch"
3145 3145
3146 3146 Returns 0 on success.
3147 3147 """
3148 3148 changesets += tuple(opts.get('rev', []))
3149 3149 if not changesets:
3150 3150 changesets = ['.']
3151 3151 revs = scmutil.revrange(repo, changesets)
3152 3152 if not revs:
3153 3153 raise util.Abort(_("export requires at least one changeset"))
3154 3154 if len(revs) > 1:
3155 3155 ui.note(_('exporting patches:\n'))
3156 3156 else:
3157 3157 ui.note(_('exporting patch:\n'))
3158 3158 cmdutil.export(repo, revs, template=opts.get('output'),
3159 3159 switch_parent=opts.get('switch_parent'),
3160 3160 opts=patch.diffopts(ui, opts))
3161 3161
3162 3162 @command('files',
3163 3163 [('r', 'rev', '', _('search the repository as it is in REV'), _('REV')),
3164 3164 ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
3165 3165 ] + walkopts + formatteropts,
3166 3166 _('[OPTION]... [PATTERN]...'))
3167 3167 def files(ui, repo, *pats, **opts):
3168 3168 """list tracked files
3169 3169
3170 3170 Print files under Mercurial control in the working directory or
3171 3171 specified revision whose names match the given patterns (excluding
3172 3172 removed files).
3173 3173
3174 3174 If no patterns are given to match, this command prints the names
3175 3175 of all files under Mercurial control in the working copy.
3176 3176
3177 3177 .. container:: verbose
3178 3178
3179 3179 Examples:
3180 3180
3181 3181 - list all files under the current directory::
3182 3182
3183 3183 hg files .
3184 3184
3185 3185 - shows sizes and flags for current revision::
3186 3186
3187 3187 hg files -vr .
3188 3188
3189 3189 - list all files named README::
3190 3190
3191 3191 hg files -I "**/README"
3192 3192
3193 3193 - list all binary files::
3194 3194
3195 3195 hg files "set:binary()"
3196 3196
3197 3197 - find files containing a regular expression:
3198 3198
3199 3199 hg files "set:grep('bob')"
3200 3200
3201 3201 - search tracked file contents with xargs and grep::
3202 3202
3203 3203 hg files -0 | xargs -0 grep foo
3204 3204
3205 3205 See :hg:'help pattern' and :hg:'help revsets' for more information
3206 3206 on specifying file patterns.
3207 3207
3208 3208 Returns 0 if a match is found, 1 otherwise.
3209 3209
3210 3210 """
3211 3211 ctx = scmutil.revsingle(repo, opts.get('rev'), None)
3212 3212 rev = ctx.rev()
3213 3213 ret = 1
3214 3214
3215 3215 end = '\n'
3216 3216 if opts.get('print0'):
3217 3217 end = '\0'
3218 3218 fm = ui.formatter('files', opts)
3219 3219 fmt = '%s' + end
3220 3220
3221 3221 m = scmutil.match(ctx, pats, opts)
3222 3222 ds = repo.dirstate
3223 3223 for f in ctx.matches(m):
3224 3224 if rev is None and ds[f] == 'r':
3225 3225 continue
3226 3226 fm.startitem()
3227 3227 if ui.verbose:
3228 3228 fc = ctx[f]
3229 3229 fm.write('size flags', '% 10d % 1s ', fc.size(), fc.flags())
3230 3230 fm.data(abspath=f)
3231 3231 fm.write('path', fmt, m.rel(f))
3232 3232 ret = 0
3233 3233
3234 3234 fm.end()
3235 3235
3236 3236 return ret
3237 3237
3238 3238 @command('^forget', walkopts, _('[OPTION]... FILE...'), inferrepo=True)
3239 3239 def forget(ui, repo, *pats, **opts):
3240 3240 """forget the specified files on the next commit
3241 3241
3242 3242 Mark the specified files so they will no longer be tracked
3243 3243 after the next commit.
3244 3244
3245 3245 This only removes files from the current branch, not from the
3246 3246 entire project history, and it does not delete them from the
3247 3247 working directory.
3248 3248
3249 3249 To undo a forget before the next commit, see :hg:`add`.
3250 3250
3251 3251 .. container:: verbose
3252 3252
3253 3253 Examples:
3254 3254
3255 3255 - forget newly-added binary files::
3256 3256
3257 3257 hg forget "set:added() and binary()"
3258 3258
3259 3259 - forget files that would be excluded by .hgignore::
3260 3260
3261 3261 hg forget "set:hgignore()"
3262 3262
3263 3263 Returns 0 on success.
3264 3264 """
3265 3265
3266 3266 if not pats:
3267 3267 raise util.Abort(_('no files specified'))
3268 3268
3269 3269 m = scmutil.match(repo[None], pats, opts)
3270 3270 rejected = cmdutil.forget(ui, repo, m, prefix="", explicitonly=False)[0]
3271 3271 return rejected and 1 or 0
3272 3272
3273 3273 @command(
3274 3274 'graft',
3275 3275 [('r', 'rev', [], _('revisions to graft'), _('REV')),
3276 3276 ('c', 'continue', False, _('resume interrupted graft')),
3277 3277 ('e', 'edit', False, _('invoke editor on commit messages')),
3278 3278 ('', 'log', None, _('append graft info to log message')),
3279 3279 ('f', 'force', False, _('force graft')),
3280 3280 ('D', 'currentdate', False,
3281 3281 _('record the current date as commit date')),
3282 3282 ('U', 'currentuser', False,
3283 3283 _('record the current user as committer'), _('DATE'))]
3284 3284 + commitopts2 + mergetoolopts + dryrunopts,
3285 3285 _('[OPTION]... [-r] REV...'))
3286 3286 def graft(ui, repo, *revs, **opts):
3287 3287 '''copy changes from other branches onto the current branch
3288 3288
3289 3289 This command uses Mercurial's merge logic to copy individual
3290 3290 changes from other branches without merging branches in the
3291 3291 history graph. This is sometimes known as 'backporting' or
3292 3292 'cherry-picking'. By default, graft will copy user, date, and
3293 3293 description from the source changesets.
3294 3294
3295 3295 Changesets that are ancestors of the current revision, that have
3296 3296 already been grafted, or that are merges will be skipped.
3297 3297
3298 3298 If --log is specified, log messages will have a comment appended
3299 3299 of the form::
3300 3300
3301 3301 (grafted from CHANGESETHASH)
3302 3302
3303 3303 If --force is specified, revisions will be grafted even if they
3304 3304 are already ancestors of or have been grafted to the destination.
3305 3305 This is useful when the revisions have since been backed out.
3306 3306
3307 3307 If a graft merge results in conflicts, the graft process is
3308 3308 interrupted so that the current merge can be manually resolved.
3309 3309 Once all conflicts are addressed, the graft process can be
3310 3310 continued with the -c/--continue option.
3311 3311
3312 3312 .. note::
3313 3313
3314 3314 The -c/--continue option does not reapply earlier options, except
3315 3315 for --force.
3316 3316
3317 3317 .. container:: verbose
3318 3318
3319 3319 Examples:
3320 3320
3321 3321 - copy a single change to the stable branch and edit its description::
3322 3322
3323 3323 hg update stable
3324 3324 hg graft --edit 9393
3325 3325
3326 3326 - graft a range of changesets with one exception, updating dates::
3327 3327
3328 3328 hg graft -D "2085::2093 and not 2091"
3329 3329
3330 3330 - continue a graft after resolving conflicts::
3331 3331
3332 3332 hg graft -c
3333 3333
3334 3334 - show the source of a grafted changeset::
3335 3335
3336 3336 hg log --debug -r .
3337 3337
3338 3338 See :hg:`help revisions` and :hg:`help revsets` for more about
3339 3339 specifying revisions.
3340 3340
3341 3341 Returns 0 on successful completion.
3342 3342 '''
3343 3343
3344 3344 revs = list(revs)
3345 3345 revs.extend(opts['rev'])
3346 3346
3347 3347 if not opts.get('user') and opts.get('currentuser'):
3348 3348 opts['user'] = ui.username()
3349 3349 if not opts.get('date') and opts.get('currentdate'):
3350 3350 opts['date'] = "%d %d" % util.makedate()
3351 3351
3352 3352 editor = cmdutil.getcommiteditor(editform='graft', **opts)
3353 3353
3354 3354 cont = False
3355 3355 if opts['continue']:
3356 3356 cont = True
3357 3357 if revs:
3358 3358 raise util.Abort(_("can't specify --continue and revisions"))
3359 3359 # read in unfinished revisions
3360 3360 try:
3361 3361 nodes = repo.opener.read('graftstate').splitlines()
3362 3362 revs = [repo[node].rev() for node in nodes]
3363 3363 except IOError, inst:
3364 3364 if inst.errno != errno.ENOENT:
3365 3365 raise
3366 3366 raise util.Abort(_("no graft state found, can't continue"))
3367 3367 else:
3368 3368 cmdutil.checkunfinished(repo)
3369 3369 cmdutil.bailifchanged(repo)
3370 3370 if not revs:
3371 3371 raise util.Abort(_('no revisions specified'))
3372 3372 revs = scmutil.revrange(repo, revs)
3373 3373
3374 3374 # check for merges
3375 3375 for rev in repo.revs('%ld and merge()', revs):
3376 3376 ui.warn(_('skipping ungraftable merge revision %s\n') % rev)
3377 3377 revs.remove(rev)
3378 3378 if not revs:
3379 3379 return -1
3380 3380
3381 3381 # Don't check in the --continue case, in effect retaining --force across
3382 3382 # --continues. That's because without --force, any revisions we decided to
3383 3383 # skip would have been filtered out here, so they wouldn't have made their
3384 3384 # way to the graftstate. With --force, any revisions we would have otherwise
3385 3385 # skipped would not have been filtered out, and if they hadn't been applied
3386 3386 # already, they'd have been in the graftstate.
3387 3387 if not (cont or opts.get('force')):
3388 3388 # check for ancestors of dest branch
3389 3389 crev = repo['.'].rev()
3390 3390 ancestors = repo.changelog.ancestors([crev], inclusive=True)
3391 3391 # Cannot use x.remove(y) on smart set, this has to be a list.
3392 3392 # XXX make this lazy in the future
3393 3393 revs = list(revs)
3394 3394 # don't mutate while iterating, create a copy
3395 3395 for rev in list(revs):
3396 3396 if rev in ancestors:
3397 3397 ui.warn(_('skipping ancestor revision %s\n') % rev)
3398 3398 # XXX remove on list is slow
3399 3399 revs.remove(rev)
3400 3400 if not revs:
3401 3401 return -1
3402 3402
3403 3403 # analyze revs for earlier grafts
3404 3404 ids = {}
3405 3405 for ctx in repo.set("%ld", revs):
3406 3406 ids[ctx.hex()] = ctx.rev()
3407 3407 n = ctx.extra().get('source')
3408 3408 if n:
3409 3409 ids[n] = ctx.rev()
3410 3410
3411 3411 # check ancestors for earlier grafts
3412 3412 ui.debug('scanning for duplicate grafts\n')
3413 3413
3414 3414 for rev in repo.changelog.findmissingrevs(revs, [crev]):
3415 3415 ctx = repo[rev]
3416 3416 n = ctx.extra().get('source')
3417 3417 if n in ids:
3418 3418 try:
3419 3419 r = repo[n].rev()
3420 3420 except error.RepoLookupError:
3421 3421 r = None
3422 3422 if r in revs:
3423 3423 ui.warn(_('skipping revision %s (already grafted to %s)\n')
3424 3424 % (r, rev))
3425 3425 revs.remove(r)
3426 3426 elif ids[n] in revs:
3427 3427 if r is None:
3428 3428 ui.warn(_('skipping already grafted revision %s '
3429 3429 '(%s also has unknown origin %s)\n')
3430 3430 % (ids[n], rev, n))
3431 3431 else:
3432 3432 ui.warn(_('skipping already grafted revision %s '
3433 3433 '(%s also has origin %d)\n')
3434 3434 % (ids[n], rev, r))
3435 3435 revs.remove(ids[n])
3436 3436 elif ctx.hex() in ids:
3437 3437 r = ids[ctx.hex()]
3438 3438 ui.warn(_('skipping already grafted revision %s '
3439 3439 '(was grafted from %d)\n') % (r, rev))
3440 3440 revs.remove(r)
3441 3441 if not revs:
3442 3442 return -1
3443 3443
3444 3444 wlock = repo.wlock()
3445 3445 try:
3446 3446 current = repo['.']
3447 3447 for pos, ctx in enumerate(repo.set("%ld", revs)):
3448 3448
3449 3449 ui.status(_('grafting revision %s\n') % ctx.rev())
3450 3450 if opts.get('dry_run'):
3451 3451 continue
3452 3452
3453 3453 source = ctx.extra().get('source')
3454 3454 if not source:
3455 3455 source = ctx.hex()
3456 3456 extra = {'source': source}
3457 3457 user = ctx.user()
3458 3458 if opts.get('user'):
3459 3459 user = opts['user']
3460 3460 date = ctx.date()
3461 3461 if opts.get('date'):
3462 3462 date = opts['date']
3463 3463 message = ctx.description()
3464 3464 if opts.get('log'):
3465 3465 message += '\n(grafted from %s)' % ctx.hex()
3466 3466
3467 3467 # we don't merge the first commit when continuing
3468 3468 if not cont:
3469 3469 # perform the graft merge with p1(rev) as 'ancestor'
3470 3470 try:
3471 3471 # ui.forcemerge is an internal variable, do not document
3472 3472 repo.ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
3473 3473 'graft')
3474 3474 stats = mergemod.update(repo, ctx.node(), True, True, False,
3475 3475 ctx.p1().node(),
3476 3476 labels=['local', 'graft'])
3477 3477 finally:
3478 3478 repo.ui.setconfig('ui', 'forcemerge', '', 'graft')
3479 3479 # report any conflicts
3480 3480 if stats and stats[3] > 0:
3481 3481 # write out state for --continue
3482 3482 nodelines = [repo[rev].hex() + "\n" for rev in revs[pos:]]
3483 3483 repo.opener.write('graftstate', ''.join(nodelines))
3484 3484 raise util.Abort(
3485 3485 _("unresolved conflicts, can't continue"),
3486 3486 hint=_('use hg resolve and hg graft --continue'))
3487 3487 else:
3488 3488 cont = False
3489 3489
3490 3490 # drop the second merge parent
3491 3491 repo.dirstate.beginparentchange()
3492 3492 repo.setparents(current.node(), nullid)
3493 3493 repo.dirstate.write()
3494 3494 # fix up dirstate for copies and renames
3495 3495 cmdutil.duplicatecopies(repo, ctx.rev(), ctx.p1().rev())
3496 3496 repo.dirstate.endparentchange()
3497 3497
3498 3498 # commit
3499 3499 node = repo.commit(text=message, user=user,
3500 3500 date=date, extra=extra, editor=editor)
3501 3501 if node is None:
3502 3502 ui.status(_('graft for revision %s is empty\n') % ctx.rev())
3503 3503 else:
3504 3504 current = repo[node]
3505 3505 finally:
3506 3506 wlock.release()
3507 3507
3508 3508 # remove state when we complete successfully
3509 3509 if not opts.get('dry_run'):
3510 3510 util.unlinkpath(repo.join('graftstate'), ignoremissing=True)
3511 3511
3512 3512 return 0
3513 3513
3514 3514 @command('grep',
3515 3515 [('0', 'print0', None, _('end fields with NUL')),
3516 3516 ('', 'all', None, _('print all revisions that match')),
3517 3517 ('a', 'text', None, _('treat all files as text')),
3518 3518 ('f', 'follow', None,
3519 3519 _('follow changeset history,'
3520 3520 ' or file history across copies and renames')),
3521 3521 ('i', 'ignore-case', None, _('ignore case when matching')),
3522 3522 ('l', 'files-with-matches', None,
3523 3523 _('print only filenames and revisions that match')),
3524 3524 ('n', 'line-number', None, _('print matching line numbers')),
3525 3525 ('r', 'rev', [],
3526 3526 _('only search files changed within revision range'), _('REV')),
3527 3527 ('u', 'user', None, _('list the author (long with -v)')),
3528 3528 ('d', 'date', None, _('list the date (short with -q)')),
3529 3529 ] + walkopts,
3530 3530 _('[OPTION]... PATTERN [FILE]...'),
3531 3531 inferrepo=True)
3532 3532 def grep(ui, repo, pattern, *pats, **opts):
3533 3533 """search for a pattern in specified files and revisions
3534 3534
3535 3535 Search revisions of files for a regular expression.
3536 3536
3537 3537 This command behaves differently than Unix grep. It only accepts
3538 3538 Python/Perl regexps. It searches repository history, not the
3539 3539 working directory. It always prints the revision number in which a
3540 3540 match appears.
3541 3541
3542 3542 By default, grep only prints output for the first revision of a
3543 3543 file in which it finds a match. To get it to print every revision
3544 3544 that contains a change in match status ("-" for a match that
3545 3545 becomes a non-match, or "+" for a non-match that becomes a match),
3546 3546 use the --all flag.
3547 3547
3548 3548 Returns 0 if a match is found, 1 otherwise.
3549 3549 """
3550 3550 reflags = re.M
3551 3551 if opts.get('ignore_case'):
3552 3552 reflags |= re.I
3553 3553 try:
3554 3554 regexp = util.re.compile(pattern, reflags)
3555 3555 except re.error, inst:
3556 3556 ui.warn(_("grep: invalid match pattern: %s\n") % inst)
3557 3557 return 1
3558 3558 sep, eol = ':', '\n'
3559 3559 if opts.get('print0'):
3560 3560 sep = eol = '\0'
3561 3561
3562 3562 getfile = util.lrucachefunc(repo.file)
3563 3563
3564 3564 def matchlines(body):
3565 3565 begin = 0
3566 3566 linenum = 0
3567 3567 while begin < len(body):
3568 3568 match = regexp.search(body, begin)
3569 3569 if not match:
3570 3570 break
3571 3571 mstart, mend = match.span()
3572 3572 linenum += body.count('\n', begin, mstart) + 1
3573 3573 lstart = body.rfind('\n', begin, mstart) + 1 or begin
3574 3574 begin = body.find('\n', mend) + 1 or len(body) + 1
3575 3575 lend = begin - 1
3576 3576 yield linenum, mstart - lstart, mend - lstart, body[lstart:lend]
3577 3577
3578 3578 class linestate(object):
3579 3579 def __init__(self, line, linenum, colstart, colend):
3580 3580 self.line = line
3581 3581 self.linenum = linenum
3582 3582 self.colstart = colstart
3583 3583 self.colend = colend
3584 3584
3585 3585 def __hash__(self):
3586 3586 return hash((self.linenum, self.line))
3587 3587
3588 3588 def __eq__(self, other):
3589 3589 return self.line == other.line
3590 3590
3591 3591 def __iter__(self):
3592 3592 yield (self.line[:self.colstart], '')
3593 3593 yield (self.line[self.colstart:self.colend], 'grep.match')
3594 3594 rest = self.line[self.colend:]
3595 3595 while rest != '':
3596 3596 match = regexp.search(rest)
3597 3597 if not match:
3598 3598 yield (rest, '')
3599 3599 break
3600 3600 mstart, mend = match.span()
3601 3601 yield (rest[:mstart], '')
3602 3602 yield (rest[mstart:mend], 'grep.match')
3603 3603 rest = rest[mend:]
3604 3604
3605 3605 matches = {}
3606 3606 copies = {}
3607 3607 def grepbody(fn, rev, body):
3608 3608 matches[rev].setdefault(fn, [])
3609 3609 m = matches[rev][fn]
3610 3610 for lnum, cstart, cend, line in matchlines(body):
3611 3611 s = linestate(line, lnum, cstart, cend)
3612 3612 m.append(s)
3613 3613
3614 3614 def difflinestates(a, b):
3615 3615 sm = difflib.SequenceMatcher(None, a, b)
3616 3616 for tag, alo, ahi, blo, bhi in sm.get_opcodes():
3617 3617 if tag == 'insert':
3618 3618 for i in xrange(blo, bhi):
3619 3619 yield ('+', b[i])
3620 3620 elif tag == 'delete':
3621 3621 for i in xrange(alo, ahi):
3622 3622 yield ('-', a[i])
3623 3623 elif tag == 'replace':
3624 3624 for i in xrange(alo, ahi):
3625 3625 yield ('-', a[i])
3626 3626 for i in xrange(blo, bhi):
3627 3627 yield ('+', b[i])
3628 3628
3629 3629 def display(fn, ctx, pstates, states):
3630 3630 rev = ctx.rev()
3631 3631 datefunc = ui.quiet and util.shortdate or util.datestr
3632 3632 found = False
3633 3633 @util.cachefunc
3634 3634 def binary():
3635 3635 flog = getfile(fn)
3636 3636 return util.binary(flog.read(ctx.filenode(fn)))
3637 3637
3638 3638 if opts.get('all'):
3639 3639 iter = difflinestates(pstates, states)
3640 3640 else:
3641 3641 iter = [('', l) for l in states]
3642 3642 for change, l in iter:
3643 3643 cols = [(fn, 'grep.filename'), (str(rev), 'grep.rev')]
3644 3644
3645 3645 if opts.get('line_number'):
3646 3646 cols.append((str(l.linenum), 'grep.linenumber'))
3647 3647 if opts.get('all'):
3648 3648 cols.append((change, 'grep.change'))
3649 3649 if opts.get('user'):
3650 3650 cols.append((ui.shortuser(ctx.user()), 'grep.user'))
3651 3651 if opts.get('date'):
3652 3652 cols.append((datefunc(ctx.date()), 'grep.date'))
3653 3653 for col, label in cols[:-1]:
3654 3654 ui.write(col, label=label)
3655 3655 ui.write(sep, label='grep.sep')
3656 3656 ui.write(cols[-1][0], label=cols[-1][1])
3657 3657 if not opts.get('files_with_matches'):
3658 3658 ui.write(sep, label='grep.sep')
3659 3659 if not opts.get('text') and binary():
3660 3660 ui.write(" Binary file matches")
3661 3661 else:
3662 3662 for s, label in l:
3663 3663 ui.write(s, label=label)
3664 3664 ui.write(eol)
3665 3665 found = True
3666 3666 if opts.get('files_with_matches'):
3667 3667 break
3668 3668 return found
3669 3669
3670 3670 skip = {}
3671 3671 revfiles = {}
3672 3672 matchfn = scmutil.match(repo[None], pats, opts)
3673 3673 found = False
3674 3674 follow = opts.get('follow')
3675 3675
3676 3676 def prep(ctx, fns):
3677 3677 rev = ctx.rev()
3678 3678 pctx = ctx.p1()
3679 3679 parent = pctx.rev()
3680 3680 matches.setdefault(rev, {})
3681 3681 matches.setdefault(parent, {})
3682 3682 files = revfiles.setdefault(rev, [])
3683 3683 for fn in fns:
3684 3684 flog = getfile(fn)
3685 3685 try:
3686 3686 fnode = ctx.filenode(fn)
3687 3687 except error.LookupError:
3688 3688 continue
3689 3689
3690 3690 copied = flog.renamed(fnode)
3691 3691 copy = follow and copied and copied[0]
3692 3692 if copy:
3693 3693 copies.setdefault(rev, {})[fn] = copy
3694 3694 if fn in skip:
3695 3695 if copy:
3696 3696 skip[copy] = True
3697 3697 continue
3698 3698 files.append(fn)
3699 3699
3700 3700 if fn not in matches[rev]:
3701 3701 grepbody(fn, rev, flog.read(fnode))
3702 3702
3703 3703 pfn = copy or fn
3704 3704 if pfn not in matches[parent]:
3705 3705 try:
3706 3706 fnode = pctx.filenode(pfn)
3707 3707 grepbody(pfn, parent, flog.read(fnode))
3708 3708 except error.LookupError:
3709 3709 pass
3710 3710
3711 3711 for ctx in cmdutil.walkchangerevs(repo, matchfn, opts, prep):
3712 3712 rev = ctx.rev()
3713 3713 parent = ctx.p1().rev()
3714 3714 for fn in sorted(revfiles.get(rev, [])):
3715 3715 states = matches[rev][fn]
3716 3716 copy = copies.get(rev, {}).get(fn)
3717 3717 if fn in skip:
3718 3718 if copy:
3719 3719 skip[copy] = True
3720 3720 continue
3721 3721 pstates = matches.get(parent, {}).get(copy or fn, [])
3722 3722 if pstates or states:
3723 3723 r = display(fn, ctx, pstates, states)
3724 3724 found = found or r
3725 3725 if r and not opts.get('all'):
3726 3726 skip[fn] = True
3727 3727 if copy:
3728 3728 skip[copy] = True
3729 3729 del matches[rev]
3730 3730 del revfiles[rev]
3731 3731
3732 3732 return not found
3733 3733
3734 3734 @command('heads',
3735 3735 [('r', 'rev', '',
3736 3736 _('show only heads which are descendants of STARTREV'), _('STARTREV')),
3737 3737 ('t', 'topo', False, _('show topological heads only')),
3738 3738 ('a', 'active', False, _('show active branchheads only (DEPRECATED)')),
3739 3739 ('c', 'closed', False, _('show normal and closed branch heads')),
3740 3740 ] + templateopts,
3741 3741 _('[-ct] [-r STARTREV] [REV]...'))
3742 3742 def heads(ui, repo, *branchrevs, **opts):
3743 3743 """show branch heads
3744 3744
3745 3745 With no arguments, show all open branch heads in the repository.
3746 3746 Branch heads are changesets that have no descendants on the
3747 3747 same branch. They are where development generally takes place and
3748 3748 are the usual targets for update and merge operations.
3749 3749
3750 3750 If one or more REVs are given, only open branch heads on the
3751 3751 branches associated with the specified changesets are shown. This
3752 3752 means that you can use :hg:`heads .` to see the heads on the
3753 3753 currently checked-out branch.
3754 3754
3755 3755 If -c/--closed is specified, also show branch heads marked closed
3756 3756 (see :hg:`commit --close-branch`).
3757 3757
3758 3758 If STARTREV is specified, only those heads that are descendants of
3759 3759 STARTREV will be displayed.
3760 3760
3761 3761 If -t/--topo is specified, named branch mechanics will be ignored and only
3762 3762 topological heads (changesets with no children) will be shown.
3763 3763
3764 3764 Returns 0 if matching heads are found, 1 if not.
3765 3765 """
3766 3766
3767 3767 start = None
3768 3768 if 'rev' in opts:
3769 3769 start = scmutil.revsingle(repo, opts['rev'], None).node()
3770 3770
3771 3771 if opts.get('topo'):
3772 3772 heads = [repo[h] for h in repo.heads(start)]
3773 3773 else:
3774 3774 heads = []
3775 3775 for branch in repo.branchmap():
3776 3776 heads += repo.branchheads(branch, start, opts.get('closed'))
3777 3777 heads = [repo[h] for h in heads]
3778 3778
3779 3779 if branchrevs:
3780 3780 branches = set(repo[br].branch() for br in branchrevs)
3781 3781 heads = [h for h in heads if h.branch() in branches]
3782 3782
3783 3783 if opts.get('active') and branchrevs:
3784 3784 dagheads = repo.heads(start)
3785 3785 heads = [h for h in heads if h.node() in dagheads]
3786 3786
3787 3787 if branchrevs:
3788 3788 haveheads = set(h.branch() for h in heads)
3789 3789 if branches - haveheads:
3790 3790 headless = ', '.join(b for b in branches - haveheads)
3791 3791 msg = _('no open branch heads found on branches %s')
3792 3792 if opts.get('rev'):
3793 3793 msg += _(' (started at %s)') % opts['rev']
3794 3794 ui.warn((msg + '\n') % headless)
3795 3795
3796 3796 if not heads:
3797 3797 return 1
3798 3798
3799 3799 heads = sorted(heads, key=lambda x: -x.rev())
3800 3800 displayer = cmdutil.show_changeset(ui, repo, opts)
3801 3801 for ctx in heads:
3802 3802 displayer.show(ctx)
3803 3803 displayer.close()
3804 3804
3805 3805 @command('help',
3806 3806 [('e', 'extension', None, _('show only help for extensions')),
3807 3807 ('c', 'command', None, _('show only help for commands')),
3808 3808 ('k', 'keyword', '', _('show topics matching keyword')),
3809 3809 ],
3810 3810 _('[-ec] [TOPIC]'),
3811 3811 norepo=True)
3812 3812 def help_(ui, name=None, **opts):
3813 3813 """show help for a given topic or a help overview
3814 3814
3815 3815 With no arguments, print a list of commands with short help messages.
3816 3816
3817 3817 Given a topic, extension, or command name, print help for that
3818 3818 topic.
3819 3819
3820 3820 Returns 0 if successful.
3821 3821 """
3822 3822
3823 3823 textwidth = min(ui.termwidth(), 80) - 2
3824 3824
3825 3825 keep = []
3826 3826 if ui.verbose:
3827 3827 keep.append('verbose')
3828 3828 if sys.platform.startswith('win'):
3829 3829 keep.append('windows')
3830 3830 elif sys.platform == 'OpenVMS':
3831 3831 keep.append('vms')
3832 3832 elif sys.platform == 'plan9':
3833 3833 keep.append('plan9')
3834 3834 else:
3835 3835 keep.append('unix')
3836 3836 keep.append(sys.platform.lower())
3837 3837
3838 3838 section = None
3839 3839 if name and '.' in name:
3840 3840 name, section = name.split('.')
3841 3841
3842 3842 text = help.help_(ui, name, **opts)
3843 3843
3844 3844 formatted, pruned = minirst.format(text, textwidth, keep=keep,
3845 3845 section=section)
3846 3846 if section and not formatted:
3847 3847 raise util.Abort(_("help section not found"))
3848 3848
3849 3849 if 'verbose' in pruned:
3850 3850 keep.append('omitted')
3851 3851 else:
3852 3852 keep.append('notomitted')
3853 3853 formatted, pruned = minirst.format(text, textwidth, keep=keep,
3854 3854 section=section)
3855 3855 ui.write(formatted)
3856 3856
3857 3857
3858 3858 @command('identify|id',
3859 3859 [('r', 'rev', '',
3860 3860 _('identify the specified revision'), _('REV')),
3861 3861 ('n', 'num', None, _('show local revision number')),
3862 3862 ('i', 'id', None, _('show global revision id')),
3863 3863 ('b', 'branch', None, _('show branch')),
3864 3864 ('t', 'tags', None, _('show tags')),
3865 3865 ('B', 'bookmarks', None, _('show bookmarks')),
3866 3866 ] + remoteopts,
3867 3867 _('[-nibtB] [-r REV] [SOURCE]'),
3868 3868 optionalrepo=True)
3869 3869 def identify(ui, repo, source=None, rev=None,
3870 3870 num=None, id=None, branch=None, tags=None, bookmarks=None, **opts):
3871 3871 """identify the working copy or specified revision
3872 3872
3873 3873 Print a summary identifying the repository state at REV using one or
3874 3874 two parent hash identifiers, followed by a "+" if the working
3875 3875 directory has uncommitted changes, the branch name (if not default),
3876 3876 a list of tags, and a list of bookmarks.
3877 3877
3878 3878 When REV is not given, print a summary of the current state of the
3879 3879 repository.
3880 3880
3881 3881 Specifying a path to a repository root or Mercurial bundle will
3882 3882 cause lookup to operate on that repository/bundle.
3883 3883
3884 3884 .. container:: verbose
3885 3885
3886 3886 Examples:
3887 3887
3888 3888 - generate a build identifier for the working directory::
3889 3889
3890 3890 hg id --id > build-id.dat
3891 3891
3892 3892 - find the revision corresponding to a tag::
3893 3893
3894 3894 hg id -n -r 1.3
3895 3895
3896 3896 - check the most recent revision of a remote repository::
3897 3897
3898 3898 hg id -r tip http://selenic.com/hg/
3899 3899
3900 3900 Returns 0 if successful.
3901 3901 """
3902 3902
3903 3903 if not repo and not source:
3904 3904 raise util.Abort(_("there is no Mercurial repository here "
3905 3905 "(.hg not found)"))
3906 3906
3907 3907 hexfunc = ui.debugflag and hex or short
3908 3908 default = not (num or id or branch or tags or bookmarks)
3909 3909 output = []
3910 3910 revs = []
3911 3911
3912 3912 if source:
3913 3913 source, branches = hg.parseurl(ui.expandpath(source))
3914 3914 peer = hg.peer(repo or ui, opts, source) # only pass ui when no repo
3915 3915 repo = peer.local()
3916 3916 revs, checkout = hg.addbranchrevs(repo, peer, branches, None)
3917 3917
3918 3918 if not repo:
3919 3919 if num or branch or tags:
3920 3920 raise util.Abort(
3921 3921 _("can't query remote revision number, branch, or tags"))
3922 3922 if not rev and revs:
3923 3923 rev = revs[0]
3924 3924 if not rev:
3925 3925 rev = "tip"
3926 3926
3927 3927 remoterev = peer.lookup(rev)
3928 3928 if default or id:
3929 3929 output = [hexfunc(remoterev)]
3930 3930
3931 3931 def getbms():
3932 3932 bms = []
3933 3933
3934 3934 if 'bookmarks' in peer.listkeys('namespaces'):
3935 3935 hexremoterev = hex(remoterev)
3936 3936 bms = [bm for bm, bmr in peer.listkeys('bookmarks').iteritems()
3937 3937 if bmr == hexremoterev]
3938 3938
3939 3939 return sorted(bms)
3940 3940
3941 3941 if bookmarks:
3942 3942 output.extend(getbms())
3943 3943 elif default and not ui.quiet:
3944 3944 # multiple bookmarks for a single parent separated by '/'
3945 3945 bm = '/'.join(getbms())
3946 3946 if bm:
3947 3947 output.append(bm)
3948 3948 else:
3949 3949 if not rev:
3950 3950 ctx = repo[None]
3951 3951 parents = ctx.parents()
3952 3952 changed = ""
3953 3953 if default or id or num:
3954 3954 if (util.any(repo.status())
3955 3955 or util.any(ctx.sub(s).dirty() for s in ctx.substate)):
3956 3956 changed = '+'
3957 3957 if default or id:
3958 3958 output = ["%s%s" %
3959 3959 ('+'.join([hexfunc(p.node()) for p in parents]), changed)]
3960 3960 if num:
3961 3961 output.append("%s%s" %
3962 3962 ('+'.join([str(p.rev()) for p in parents]), changed))
3963 3963 else:
3964 3964 ctx = scmutil.revsingle(repo, rev)
3965 3965 if default or id:
3966 3966 output = [hexfunc(ctx.node())]
3967 3967 if num:
3968 3968 output.append(str(ctx.rev()))
3969 3969
3970 3970 if default and not ui.quiet:
3971 3971 b = ctx.branch()
3972 3972 if b != 'default':
3973 3973 output.append("(%s)" % b)
3974 3974
3975 3975 # multiple tags for a single parent separated by '/'
3976 3976 t = '/'.join(ctx.tags())
3977 3977 if t:
3978 3978 output.append(t)
3979 3979
3980 3980 # multiple bookmarks for a single parent separated by '/'
3981 3981 bm = '/'.join(ctx.bookmarks())
3982 3982 if bm:
3983 3983 output.append(bm)
3984 3984 else:
3985 3985 if branch:
3986 3986 output.append(ctx.branch())
3987 3987
3988 3988 if tags:
3989 3989 output.extend(ctx.tags())
3990 3990
3991 3991 if bookmarks:
3992 3992 output.extend(ctx.bookmarks())
3993 3993
3994 3994 ui.write("%s\n" % ' '.join(output))
3995 3995
3996 3996 @command('import|patch',
3997 3997 [('p', 'strip', 1,
3998 3998 _('directory strip option for patch. This has the same '
3999 3999 'meaning as the corresponding patch option'), _('NUM')),
4000 4000 ('b', 'base', '', _('base path (DEPRECATED)'), _('PATH')),
4001 4001 ('e', 'edit', False, _('invoke editor on commit messages')),
4002 4002 ('f', 'force', None,
4003 4003 _('skip check for outstanding uncommitted changes (DEPRECATED)')),
4004 4004 ('', 'no-commit', None,
4005 4005 _("don't commit, just update the working directory")),
4006 4006 ('', 'bypass', None,
4007 4007 _("apply patch without touching the working directory")),
4008 4008 ('', 'partial', None,
4009 4009 _('commit even if some hunks fail')),
4010 4010 ('', 'exact', None,
4011 4011 _('apply patch to the nodes from which it was generated')),
4012 4012 ('', 'import-branch', None,
4013 4013 _('use any branch information in patch (implied by --exact)'))] +
4014 4014 commitopts + commitopts2 + similarityopts,
4015 4015 _('[OPTION]... PATCH...'))
4016 4016 def import_(ui, repo, patch1=None, *patches, **opts):
4017 4017 """import an ordered set of patches
4018 4018
4019 4019 Import a list of patches and commit them individually (unless
4020 4020 --no-commit is specified).
4021 4021
4022 4022 Because import first applies changes to the working directory,
4023 4023 import will abort if there are outstanding changes.
4024 4024
4025 4025 You can import a patch straight from a mail message. Even patches
4026 4026 as attachments work (to use the body part, it must have type
4027 4027 text/plain or text/x-patch). From and Subject headers of email
4028 4028 message are used as default committer and commit message. All
4029 4029 text/plain body parts before first diff are added to commit
4030 4030 message.
4031 4031
4032 4032 If the imported patch was generated by :hg:`export`, user and
4033 4033 description from patch override values from message headers and
4034 4034 body. Values given on command line with -m/--message and -u/--user
4035 4035 override these.
4036 4036
4037 4037 If --exact is specified, import will set the working directory to
4038 4038 the parent of each patch before applying it, and will abort if the
4039 4039 resulting changeset has a different ID than the one recorded in
4040 4040 the patch. This may happen due to character set problems or other
4041 4041 deficiencies in the text patch format.
4042 4042
4043 4043 Use --bypass to apply and commit patches directly to the
4044 4044 repository, not touching the working directory. Without --exact,
4045 4045 patches will be applied on top of the working directory parent
4046 4046 revision.
4047 4047
4048 4048 With -s/--similarity, hg will attempt to discover renames and
4049 4049 copies in the patch in the same way as :hg:`addremove`.
4050 4050
4051 4051 Use --partial to ensure a changeset will be created from the patch
4052 4052 even if some hunks fail to apply. Hunks that fail to apply will be
4053 4053 written to a <target-file>.rej file. Conflicts can then be resolved
4054 4054 by hand before :hg:`commit --amend` is run to update the created
4055 4055 changeset. This flag exists to let people import patches that
4056 4056 partially apply without losing the associated metadata (author,
4057 4057 date, description, ...). Note that when none of the hunk applies
4058 4058 cleanly, :hg:`import --partial` will create an empty changeset,
4059 4059 importing only the patch metadata.
4060 4060
4061 4061 To read a patch from standard input, use "-" as the patch name. If
4062 4062 a URL is specified, the patch will be downloaded from it.
4063 4063 See :hg:`help dates` for a list of formats valid for -d/--date.
4064 4064
4065 4065 .. container:: verbose
4066 4066
4067 4067 Examples:
4068 4068
4069 4069 - import a traditional patch from a website and detect renames::
4070 4070
4071 4071 hg import -s 80 http://example.com/bugfix.patch
4072 4072
4073 4073 - import a changeset from an hgweb server::
4074 4074
4075 4075 hg import http://www.selenic.com/hg/rev/5ca8c111e9aa
4076 4076
4077 4077 - import all the patches in an Unix-style mbox::
4078 4078
4079 4079 hg import incoming-patches.mbox
4080 4080
4081 4081 - attempt to exactly restore an exported changeset (not always
4082 4082 possible)::
4083 4083
4084 4084 hg import --exact proposed-fix.patch
4085 4085
4086 4086 Returns 0 on success, 1 on partial success (see --partial).
4087 4087 """
4088 4088
4089 4089 if not patch1:
4090 4090 raise util.Abort(_('need at least one patch to import'))
4091 4091
4092 4092 patches = (patch1,) + patches
4093 4093
4094 4094 date = opts.get('date')
4095 4095 if date:
4096 4096 opts['date'] = util.parsedate(date)
4097 4097
4098 4098 update = not opts.get('bypass')
4099 4099 if not update and opts.get('no_commit'):
4100 4100 raise util.Abort(_('cannot use --no-commit with --bypass'))
4101 4101 try:
4102 4102 sim = float(opts.get('similarity') or 0)
4103 4103 except ValueError:
4104 4104 raise util.Abort(_('similarity must be a number'))
4105 4105 if sim < 0 or sim > 100:
4106 4106 raise util.Abort(_('similarity must be between 0 and 100'))
4107 4107 if sim and not update:
4108 4108 raise util.Abort(_('cannot use --similarity with --bypass'))
4109 4109 if opts.get('exact') and opts.get('edit'):
4110 4110 raise util.Abort(_('cannot use --exact with --edit'))
4111 4111
4112 4112 if update:
4113 4113 cmdutil.checkunfinished(repo)
4114 4114 if (opts.get('exact') or not opts.get('force')) and update:
4115 4115 cmdutil.bailifchanged(repo)
4116 4116
4117 4117 base = opts["base"]
4118 4118 wlock = lock = tr = None
4119 4119 msgs = []
4120 4120 ret = 0
4121 4121
4122 4122
4123 4123 try:
4124 4124 try:
4125 4125 wlock = repo.wlock()
4126 4126 repo.dirstate.beginparentchange()
4127 4127 if not opts.get('no_commit'):
4128 4128 lock = repo.lock()
4129 4129 tr = repo.transaction('import')
4130 4130 parents = repo.parents()
4131 4131 for patchurl in patches:
4132 4132 if patchurl == '-':
4133 4133 ui.status(_('applying patch from stdin\n'))
4134 4134 patchfile = ui.fin
4135 4135 patchurl = 'stdin' # for error message
4136 4136 else:
4137 4137 patchurl = os.path.join(base, patchurl)
4138 4138 ui.status(_('applying %s\n') % patchurl)
4139 4139 patchfile = hg.openpath(ui, patchurl)
4140 4140
4141 4141 haspatch = False
4142 4142 for hunk in patch.split(patchfile):
4143 4143 (msg, node, rej) = cmdutil.tryimportone(ui, repo, hunk,
4144 4144 parents, opts,
4145 4145 msgs, hg.clean)
4146 4146 if msg:
4147 4147 haspatch = True
4148 4148 ui.note(msg + '\n')
4149 4149 if update or opts.get('exact'):
4150 4150 parents = repo.parents()
4151 4151 else:
4152 4152 parents = [repo[node]]
4153 4153 if rej:
4154 4154 ui.write_err(_("patch applied partially\n"))
4155 4155 ui.write_err(_("(fix the .rej files and run "
4156 4156 "`hg commit --amend`)\n"))
4157 4157 ret = 1
4158 4158 break
4159 4159
4160 4160 if not haspatch:
4161 4161 raise util.Abort(_('%s: no diffs found') % patchurl)
4162 4162
4163 4163 if tr:
4164 4164 tr.close()
4165 4165 if msgs:
4166 4166 repo.savecommitmessage('\n* * *\n'.join(msgs))
4167 4167 repo.dirstate.endparentchange()
4168 4168 return ret
4169 4169 except: # re-raises
4170 4170 # wlock.release() indirectly calls dirstate.write(): since
4171 4171 # we're crashing, we do not want to change the working dir
4172 4172 # parent after all, so make sure it writes nothing
4173 4173 repo.dirstate.invalidate()
4174 4174 raise
4175 4175 finally:
4176 4176 if tr:
4177 4177 tr.release()
4178 4178 release(lock, wlock)
4179 4179
4180 4180 @command('incoming|in',
4181 4181 [('f', 'force', None,
4182 4182 _('run even if remote repository is unrelated')),
4183 4183 ('n', 'newest-first', None, _('show newest record first')),
4184 4184 ('', 'bundle', '',
4185 4185 _('file to store the bundles into'), _('FILE')),
4186 4186 ('r', 'rev', [], _('a remote changeset intended to be added'), _('REV')),
4187 4187 ('B', 'bookmarks', False, _("compare bookmarks")),
4188 4188 ('b', 'branch', [],
4189 4189 _('a specific branch you would like to pull'), _('BRANCH')),
4190 4190 ] + logopts + remoteopts + subrepoopts,
4191 4191 _('[-p] [-n] [-M] [-f] [-r REV]... [--bundle FILENAME] [SOURCE]'))
4192 4192 def incoming(ui, repo, source="default", **opts):
4193 4193 """show new changesets found in source
4194 4194
4195 4195 Show new changesets found in the specified path/URL or the default
4196 4196 pull location. These are the changesets that would have been pulled
4197 4197 if a pull at the time you issued this command.
4198 4198
4199 4199 For remote repository, using --bundle avoids downloading the
4200 4200 changesets twice if the incoming is followed by a pull.
4201 4201
4202 4202 See pull for valid source format details.
4203 4203
4204 4204 .. container:: verbose
4205 4205
4206 4206 Examples:
4207 4207
4208 4208 - show incoming changes with patches and full description::
4209 4209
4210 4210 hg incoming -vp
4211 4211
4212 4212 - show incoming changes excluding merges, store a bundle::
4213 4213
4214 4214 hg in -vpM --bundle incoming.hg
4215 4215 hg pull incoming.hg
4216 4216
4217 4217 - briefly list changes inside a bundle::
4218 4218
4219 4219 hg in changes.hg -T "{desc|firstline}\\n"
4220 4220
4221 4221 Returns 0 if there are incoming changes, 1 otherwise.
4222 4222 """
4223 4223 if opts.get('graph'):
4224 4224 cmdutil.checkunsupportedgraphflags([], opts)
4225 4225 def display(other, chlist, displayer):
4226 4226 revdag = cmdutil.graphrevs(other, chlist, opts)
4227 4227 showparents = [ctx.node() for ctx in repo[None].parents()]
4228 4228 cmdutil.displaygraph(ui, revdag, displayer, showparents,
4229 4229 graphmod.asciiedges)
4230 4230
4231 4231 hg._incoming(display, lambda: 1, ui, repo, source, opts, buffered=True)
4232 4232 return 0
4233 4233
4234 4234 if opts.get('bundle') and opts.get('subrepos'):
4235 4235 raise util.Abort(_('cannot combine --bundle and --subrepos'))
4236 4236
4237 4237 if opts.get('bookmarks'):
4238 4238 source, branches = hg.parseurl(ui.expandpath(source),
4239 4239 opts.get('branch'))
4240 4240 other = hg.peer(repo, opts, source)
4241 4241 if 'bookmarks' not in other.listkeys('namespaces'):
4242 4242 ui.warn(_("remote doesn't support bookmarks\n"))
4243 4243 return 0
4244 4244 ui.status(_('comparing with %s\n') % util.hidepassword(source))
4245 4245 return bookmarks.diff(ui, repo, other)
4246 4246
4247 4247 repo._subtoppath = ui.expandpath(source)
4248 4248 try:
4249 4249 return hg.incoming(ui, repo, source, opts)
4250 4250 finally:
4251 4251 del repo._subtoppath
4252 4252
4253 4253
4254 4254 @command('^init', remoteopts, _('[-e CMD] [--remotecmd CMD] [DEST]'),
4255 4255 norepo=True)
4256 4256 def init(ui, dest=".", **opts):
4257 4257 """create a new repository in the given directory
4258 4258
4259 4259 Initialize a new repository in the given directory. If the given
4260 4260 directory does not exist, it will be created.
4261 4261
4262 4262 If no directory is given, the current directory is used.
4263 4263
4264 4264 It is possible to specify an ``ssh://`` URL as the destination.
4265 4265 See :hg:`help urls` for more information.
4266 4266
4267 4267 Returns 0 on success.
4268 4268 """
4269 4269 hg.peer(ui, opts, ui.expandpath(dest), create=True)
4270 4270
4271 4271 @command('locate',
4272 4272 [('r', 'rev', '', _('search the repository as it is in REV'), _('REV')),
4273 4273 ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
4274 4274 ('f', 'fullpath', None, _('print complete paths from the filesystem root')),
4275 4275 ] + walkopts,
4276 4276 _('[OPTION]... [PATTERN]...'))
4277 4277 def locate(ui, repo, *pats, **opts):
4278 4278 """locate files matching specific patterns (DEPRECATED)
4279 4279
4280 4280 Print files under Mercurial control in the working directory whose
4281 4281 names match the given patterns.
4282 4282
4283 4283 By default, this command searches all directories in the working
4284 4284 directory. To search just the current directory and its
4285 4285 subdirectories, use "--include .".
4286 4286
4287 4287 If no patterns are given to match, this command prints the names
4288 4288 of all files under Mercurial control in the working directory.
4289 4289
4290 4290 If you want to feed the output of this command into the "xargs"
4291 4291 command, use the -0 option to both this command and "xargs". This
4292 4292 will avoid the problem of "xargs" treating single filenames that
4293 4293 contain whitespace as multiple filenames.
4294 4294
4295 4295 See :hg:`help files` for a more versatile command.
4296 4296
4297 4297 Returns 0 if a match is found, 1 otherwise.
4298 4298 """
4299 4299 end = opts.get('print0') and '\0' or '\n'
4300 4300 rev = scmutil.revsingle(repo, opts.get('rev'), None).node()
4301 4301
4302 4302 ret = 1
4303 4303 ctx = repo[rev]
4304 4304 m = scmutil.match(ctx, pats, opts, default='relglob')
4305 4305 m.bad = lambda x, y: False
4306 4306
4307 4307 for abs in ctx.matches(m):
4308 4308 if opts.get('fullpath'):
4309 4309 ui.write(repo.wjoin(abs), end)
4310 4310 else:
4311 4311 ui.write(((pats and m.rel(abs)) or abs), end)
4312 4312 ret = 0
4313 4313
4314 4314 return ret
4315 4315
4316 4316 @command('^log|history',
4317 4317 [('f', 'follow', None,
4318 4318 _('follow changeset history, or file history across copies and renames')),
4319 4319 ('', 'follow-first', None,
4320 4320 _('only follow the first parent of merge changesets (DEPRECATED)')),
4321 4321 ('d', 'date', '', _('show revisions matching date spec'), _('DATE')),
4322 4322 ('C', 'copies', None, _('show copied files')),
4323 4323 ('k', 'keyword', [],
4324 4324 _('do case-insensitive search for a given text'), _('TEXT')),
4325 4325 ('r', 'rev', [], _('show the specified revision or range'), _('REV')),
4326 4326 ('', 'removed', None, _('include revisions where files were removed')),
4327 4327 ('m', 'only-merges', None, _('show only merges (DEPRECATED)')),
4328 4328 ('u', 'user', [], _('revisions committed by user'), _('USER')),
4329 4329 ('', 'only-branch', [],
4330 4330 _('show only changesets within the given named branch (DEPRECATED)'),
4331 4331 _('BRANCH')),
4332 4332 ('b', 'branch', [],
4333 4333 _('show changesets within the given named branch'), _('BRANCH')),
4334 4334 ('P', 'prune', [],
4335 4335 _('do not display revision or any of its ancestors'), _('REV')),
4336 4336 ] + logopts + walkopts,
4337 4337 _('[OPTION]... [FILE]'),
4338 4338 inferrepo=True)
4339 4339 def log(ui, repo, *pats, **opts):
4340 4340 """show revision history of entire repository or files
4341 4341
4342 4342 Print the revision history of the specified files or the entire
4343 4343 project.
4344 4344
4345 4345 If no revision range is specified, the default is ``tip:0`` unless
4346 4346 --follow is set, in which case the working directory parent is
4347 4347 used as the starting revision.
4348 4348
4349 4349 File history is shown without following rename or copy history of
4350 4350 files. Use -f/--follow with a filename to follow history across
4351 4351 renames and copies. --follow without a filename will only show
4352 4352 ancestors or descendants of the starting revision.
4353 4353
4354 4354 By default this command prints revision number and changeset id,
4355 4355 tags, non-trivial parents, user, date and time, and a summary for
4356 4356 each commit. When the -v/--verbose switch is used, the list of
4357 4357 changed files and full commit message are shown.
4358 4358
4359 4359 With --graph the revisions are shown as an ASCII art DAG with the most
4360 4360 recent changeset at the top.
4361 4361 'o' is a changeset, '@' is a working directory parent, 'x' is obsolete,
4362 4362 and '+' represents a fork where the changeset from the lines below is a
4363 4363 parent of the 'o' merge on the same line.
4364 4364
4365 4365 .. note::
4366 4366
4367 4367 log -p/--patch may generate unexpected diff output for merge
4368 4368 changesets, as it will only compare the merge changeset against
4369 4369 its first parent. Also, only files different from BOTH parents
4370 4370 will appear in files:.
4371 4371
4372 4372 .. note::
4373 4373
4374 4374 for performance reasons, log FILE may omit duplicate changes
4375 4375 made on branches and will not show removals or mode changes. To
4376 4376 see all such changes, use the --removed switch.
4377 4377
4378 4378 .. container:: verbose
4379 4379
4380 4380 Some examples:
4381 4381
4382 4382 - changesets with full descriptions and file lists::
4383 4383
4384 4384 hg log -v
4385 4385
4386 4386 - changesets ancestral to the working directory::
4387 4387
4388 4388 hg log -f
4389 4389
4390 4390 - last 10 commits on the current branch::
4391 4391
4392 4392 hg log -l 10 -b .
4393 4393
4394 4394 - changesets showing all modifications of a file, including removals::
4395 4395
4396 4396 hg log --removed file.c
4397 4397
4398 4398 - all changesets that touch a directory, with diffs, excluding merges::
4399 4399
4400 4400 hg log -Mp lib/
4401 4401
4402 4402 - all revision numbers that match a keyword::
4403 4403
4404 4404 hg log -k bug --template "{rev}\\n"
4405 4405
4406 4406 - list available log templates::
4407 4407
4408 4408 hg log -T list
4409 4409
4410 4410 - check if a given changeset is included in a tagged release::
4411 4411
4412 4412 hg log -r "a21ccf and ancestor(1.9)"
4413 4413
4414 4414 - find all changesets by some user in a date range::
4415 4415
4416 4416 hg log -k alice -d "may 2008 to jul 2008"
4417 4417
4418 4418 - summary of all changesets after the last tag::
4419 4419
4420 4420 hg log -r "last(tagged())::" --template "{desc|firstline}\\n"
4421 4421
4422 4422 See :hg:`help dates` for a list of formats valid for -d/--date.
4423 4423
4424 4424 See :hg:`help revisions` and :hg:`help revsets` for more about
4425 4425 specifying revisions.
4426 4426
4427 4427 See :hg:`help templates` for more about pre-packaged styles and
4428 4428 specifying custom templates.
4429 4429
4430 4430 Returns 0 on success.
4431 4431
4432 4432 """
4433 4433 if opts.get('graph'):
4434 4434 return cmdutil.graphlog(ui, repo, *pats, **opts)
4435 4435
4436 4436 revs, expr, filematcher = cmdutil.getlogrevs(repo, pats, opts)
4437 4437 limit = cmdutil.loglimit(opts)
4438 4438 count = 0
4439 4439
4440 4440 getrenamed = None
4441 4441 if opts.get('copies'):
4442 4442 endrev = None
4443 4443 if opts.get('rev'):
4444 4444 endrev = scmutil.revrange(repo, opts.get('rev')).max() + 1
4445 4445 getrenamed = templatekw.getrenamedfn(repo, endrev=endrev)
4446 4446
4447 4447 displayer = cmdutil.show_changeset(ui, repo, opts, buffered=True)
4448 4448 for rev in revs:
4449 4449 if count == limit:
4450 4450 break
4451 4451 ctx = repo[rev]
4452 4452 copies = None
4453 4453 if getrenamed is not None and rev:
4454 4454 copies = []
4455 4455 for fn in ctx.files():
4456 4456 rename = getrenamed(fn, rev)
4457 4457 if rename:
4458 4458 copies.append((fn, rename[0]))
4459 4459 revmatchfn = filematcher and filematcher(ctx.rev()) or None
4460 4460 displayer.show(ctx, copies=copies, matchfn=revmatchfn)
4461 4461 if displayer.flush(rev):
4462 4462 count += 1
4463 4463
4464 4464 displayer.close()
4465 4465
4466 4466 @command('manifest',
4467 4467 [('r', 'rev', '', _('revision to display'), _('REV')),
4468 4468 ('', 'all', False, _("list files from all revisions"))]
4469 4469 + formatteropts,
4470 4470 _('[-r REV]'))
4471 4471 def manifest(ui, repo, node=None, rev=None, **opts):
4472 4472 """output the current or given revision of the project manifest
4473 4473
4474 4474 Print a list of version controlled files for the given revision.
4475 4475 If no revision is given, the first parent of the working directory
4476 4476 is used, or the null revision if no revision is checked out.
4477 4477
4478 4478 With -v, print file permissions, symlink and executable bits.
4479 4479 With --debug, print file revision hashes.
4480 4480
4481 4481 If option --all is specified, the list of all files from all revisions
4482 4482 is printed. This includes deleted and renamed files.
4483 4483
4484 4484 Returns 0 on success.
4485 4485 """
4486 4486
4487 4487 fm = ui.formatter('manifest', opts)
4488 4488
4489 4489 if opts.get('all'):
4490 4490 if rev or node:
4491 4491 raise util.Abort(_("can't specify a revision with --all"))
4492 4492
4493 4493 res = []
4494 4494 prefix = "data/"
4495 4495 suffix = ".i"
4496 4496 plen = len(prefix)
4497 4497 slen = len(suffix)
4498 4498 lock = repo.lock()
4499 4499 try:
4500 4500 for fn, b, size in repo.store.datafiles():
4501 4501 if size != 0 and fn[-slen:] == suffix and fn[:plen] == prefix:
4502 4502 res.append(fn[plen:-slen])
4503 4503 finally:
4504 4504 lock.release()
4505 4505 for f in res:
4506 4506 fm.startitem()
4507 4507 fm.write("path", '%s\n', f)
4508 4508 fm.end()
4509 4509 return
4510 4510
4511 4511 if rev and node:
4512 4512 raise util.Abort(_("please specify just one revision"))
4513 4513
4514 4514 if not node:
4515 4515 node = rev
4516 4516
4517 4517 char = {'l': '@', 'x': '*', '': ''}
4518 4518 mode = {'l': '644', 'x': '755', '': '644'}
4519 4519 ctx = scmutil.revsingle(repo, node)
4520 4520 mf = ctx.manifest()
4521 4521 for f in ctx:
4522 4522 fm.startitem()
4523 4523 fl = ctx[f].flags()
4524 4524 fm.condwrite(ui.debugflag, 'hash', '%s ', hex(mf[f]))
4525 4525 fm.condwrite(ui.verbose, 'mode type', '%s %1s ', mode[fl], char[fl])
4526 4526 fm.write('path', '%s\n', f)
4527 4527 fm.end()
4528 4528
4529 4529 @command('^merge',
4530 4530 [('f', 'force', None,
4531 4531 _('force a merge including outstanding changes (DEPRECATED)')),
4532 4532 ('r', 'rev', '', _('revision to merge'), _('REV')),
4533 4533 ('P', 'preview', None,
4534 4534 _('review revisions to merge (no merge is performed)'))
4535 4535 ] + mergetoolopts,
4536 4536 _('[-P] [-f] [[-r] REV]'))
4537 4537 def merge(ui, repo, node=None, **opts):
4538 4538 """merge working directory with another revision
4539 4539
4540 4540 The current working directory is updated with all changes made in
4541 4541 the requested revision since the last common predecessor revision.
4542 4542
4543 4543 Files that changed between either parent are marked as changed for
4544 4544 the next commit and a commit must be performed before any further
4545 4545 updates to the repository are allowed. The next commit will have
4546 4546 two parents.
4547 4547
4548 4548 ``--tool`` can be used to specify the merge tool used for file
4549 4549 merges. It overrides the HGMERGE environment variable and your
4550 4550 configuration files. See :hg:`help merge-tools` for options.
4551 4551
4552 4552 If no revision is specified, the working directory's parent is a
4553 4553 head revision, and the current branch contains exactly one other
4554 4554 head, the other head is merged with by default. Otherwise, an
4555 4555 explicit revision with which to merge with must be provided.
4556 4556
4557 4557 :hg:`resolve` must be used to resolve unresolved files.
4558 4558
4559 4559 To undo an uncommitted merge, use :hg:`update --clean .` which
4560 4560 will check out a clean copy of the original merge parent, losing
4561 4561 all changes.
4562 4562
4563 4563 Returns 0 on success, 1 if there are unresolved files.
4564 4564 """
4565 4565
4566 4566 if opts.get('rev') and node:
4567 4567 raise util.Abort(_("please specify just one revision"))
4568 4568 if not node:
4569 4569 node = opts.get('rev')
4570 4570
4571 4571 if node:
4572 4572 node = scmutil.revsingle(repo, node).node()
4573 4573
4574 4574 if not node and repo._bookmarkcurrent:
4575 4575 bmheads = repo.bookmarkheads(repo._bookmarkcurrent)
4576 4576 curhead = repo[repo._bookmarkcurrent].node()
4577 4577 if len(bmheads) == 2:
4578 4578 if curhead == bmheads[0]:
4579 4579 node = bmheads[1]
4580 4580 else:
4581 4581 node = bmheads[0]
4582 4582 elif len(bmheads) > 2:
4583 4583 raise util.Abort(_("multiple matching bookmarks to merge - "
4584 4584 "please merge with an explicit rev or bookmark"),
4585 4585 hint=_("run 'hg heads' to see all heads"))
4586 4586 elif len(bmheads) <= 1:
4587 4587 raise util.Abort(_("no matching bookmark to merge - "
4588 4588 "please merge with an explicit rev or bookmark"),
4589 4589 hint=_("run 'hg heads' to see all heads"))
4590 4590
4591 4591 if not node and not repo._bookmarkcurrent:
4592 4592 branch = repo[None].branch()
4593 4593 bheads = repo.branchheads(branch)
4594 4594 nbhs = [bh for bh in bheads if not repo[bh].bookmarks()]
4595 4595
4596 4596 if len(nbhs) > 2:
4597 4597 raise util.Abort(_("branch '%s' has %d heads - "
4598 4598 "please merge with an explicit rev")
4599 4599 % (branch, len(bheads)),
4600 4600 hint=_("run 'hg heads .' to see heads"))
4601 4601
4602 4602 parent = repo.dirstate.p1()
4603 4603 if len(nbhs) <= 1:
4604 4604 if len(bheads) > 1:
4605 4605 raise util.Abort(_("heads are bookmarked - "
4606 4606 "please merge with an explicit rev"),
4607 4607 hint=_("run 'hg heads' to see all heads"))
4608 4608 if len(repo.heads()) > 1:
4609 4609 raise util.Abort(_("branch '%s' has one head - "
4610 4610 "please merge with an explicit rev")
4611 4611 % branch,
4612 4612 hint=_("run 'hg heads' to see all heads"))
4613 4613 msg, hint = _('nothing to merge'), None
4614 4614 if parent != repo.lookup(branch):
4615 4615 hint = _("use 'hg update' instead")
4616 4616 raise util.Abort(msg, hint=hint)
4617 4617
4618 4618 if parent not in bheads:
4619 4619 raise util.Abort(_('working directory not at a head revision'),
4620 4620 hint=_("use 'hg update' or merge with an "
4621 4621 "explicit revision"))
4622 4622 if parent == nbhs[0]:
4623 4623 node = nbhs[-1]
4624 4624 else:
4625 4625 node = nbhs[0]
4626 4626
4627 4627 if opts.get('preview'):
4628 4628 # find nodes that are ancestors of p2 but not of p1
4629 4629 p1 = repo.lookup('.')
4630 4630 p2 = repo.lookup(node)
4631 4631 nodes = repo.changelog.findmissing(common=[p1], heads=[p2])
4632 4632
4633 4633 displayer = cmdutil.show_changeset(ui, repo, opts)
4634 4634 for node in nodes:
4635 4635 displayer.show(repo[node])
4636 4636 displayer.close()
4637 4637 return 0
4638 4638
4639 4639 try:
4640 4640 # ui.forcemerge is an internal variable, do not document
4641 4641 repo.ui.setconfig('ui', 'forcemerge', opts.get('tool', ''), 'merge')
4642 4642 return hg.merge(repo, node, force=opts.get('force'))
4643 4643 finally:
4644 4644 ui.setconfig('ui', 'forcemerge', '', 'merge')
4645 4645
4646 4646 @command('outgoing|out',
4647 4647 [('f', 'force', None, _('run even when the destination is unrelated')),
4648 4648 ('r', 'rev', [],
4649 4649 _('a changeset intended to be included in the destination'), _('REV')),
4650 4650 ('n', 'newest-first', None, _('show newest record first')),
4651 4651 ('B', 'bookmarks', False, _('compare bookmarks')),
4652 4652 ('b', 'branch', [], _('a specific branch you would like to push'),
4653 4653 _('BRANCH')),
4654 4654 ] + logopts + remoteopts + subrepoopts,
4655 4655 _('[-M] [-p] [-n] [-f] [-r REV]... [DEST]'))
4656 4656 def outgoing(ui, repo, dest=None, **opts):
4657 4657 """show changesets not found in the destination
4658 4658
4659 4659 Show changesets not found in the specified destination repository
4660 4660 or the default push location. These are the changesets that would
4661 4661 be pushed if a push was requested.
4662 4662
4663 4663 See pull for details of valid destination formats.
4664 4664
4665 4665 Returns 0 if there are outgoing changes, 1 otherwise.
4666 4666 """
4667 4667 if opts.get('graph'):
4668 4668 cmdutil.checkunsupportedgraphflags([], opts)
4669 4669 o, other = hg._outgoing(ui, repo, dest, opts)
4670 4670 if not o:
4671 4671 cmdutil.outgoinghooks(ui, repo, other, opts, o)
4672 4672 return
4673 4673
4674 4674 revdag = cmdutil.graphrevs(repo, o, opts)
4675 4675 displayer = cmdutil.show_changeset(ui, repo, opts, buffered=True)
4676 4676 showparents = [ctx.node() for ctx in repo[None].parents()]
4677 4677 cmdutil.displaygraph(ui, revdag, displayer, showparents,
4678 4678 graphmod.asciiedges)
4679 4679 cmdutil.outgoinghooks(ui, repo, other, opts, o)
4680 4680 return 0
4681 4681
4682 4682 if opts.get('bookmarks'):
4683 4683 dest = ui.expandpath(dest or 'default-push', dest or 'default')
4684 4684 dest, branches = hg.parseurl(dest, opts.get('branch'))
4685 4685 other = hg.peer(repo, opts, dest)
4686 4686 if 'bookmarks' not in other.listkeys('namespaces'):
4687 4687 ui.warn(_("remote doesn't support bookmarks\n"))
4688 4688 return 0
4689 4689 ui.status(_('comparing with %s\n') % util.hidepassword(dest))
4690 4690 return bookmarks.diff(ui, other, repo)
4691 4691
4692 4692 repo._subtoppath = ui.expandpath(dest or 'default-push', dest or 'default')
4693 4693 try:
4694 4694 return hg.outgoing(ui, repo, dest, opts)
4695 4695 finally:
4696 4696 del repo._subtoppath
4697 4697
4698 4698 @command('parents',
4699 4699 [('r', 'rev', '', _('show parents of the specified revision'), _('REV')),
4700 4700 ] + templateopts,
4701 4701 _('[-r REV] [FILE]'),
4702 4702 inferrepo=True)
4703 4703 def parents(ui, repo, file_=None, **opts):
4704 4704 """show the parents of the working directory or revision (DEPRECATED)
4705 4705
4706 4706 Print the working directory's parent revisions. If a revision is
4707 4707 given via -r/--rev, the parent of that revision will be printed.
4708 4708 If a file argument is given, the revision in which the file was
4709 4709 last changed (before the working directory revision or the
4710 4710 argument to --rev if given) is printed.
4711 4711
4712 4712 See :hg:`summary` and :hg:`help revsets` for related information.
4713 4713
4714 4714 Returns 0 on success.
4715 4715 """
4716 4716
4717 4717 ctx = scmutil.revsingle(repo, opts.get('rev'), None)
4718 4718
4719 4719 if file_:
4720 4720 m = scmutil.match(ctx, (file_,), opts)
4721 4721 if m.anypats() or len(m.files()) != 1:
4722 4722 raise util.Abort(_('can only specify an explicit filename'))
4723 4723 file_ = m.files()[0]
4724 4724 filenodes = []
4725 4725 for cp in ctx.parents():
4726 4726 if not cp:
4727 4727 continue
4728 4728 try:
4729 4729 filenodes.append(cp.filenode(file_))
4730 4730 except error.LookupError:
4731 4731 pass
4732 4732 if not filenodes:
4733 4733 raise util.Abort(_("'%s' not found in manifest!") % file_)
4734 4734 p = []
4735 4735 for fn in filenodes:
4736 4736 fctx = repo.filectx(file_, fileid=fn)
4737 4737 p.append(fctx.node())
4738 4738 else:
4739 4739 p = [cp.node() for cp in ctx.parents()]
4740 4740
4741 4741 displayer = cmdutil.show_changeset(ui, repo, opts)
4742 4742 for n in p:
4743 4743 if n != nullid:
4744 4744 displayer.show(repo[n])
4745 4745 displayer.close()
4746 4746
4747 4747 @command('paths', [], _('[NAME]'), optionalrepo=True)
4748 4748 def paths(ui, repo, search=None):
4749 4749 """show aliases for remote repositories
4750 4750
4751 4751 Show definition of symbolic path name NAME. If no name is given,
4752 4752 show definition of all available names.
4753 4753
4754 4754 Option -q/--quiet suppresses all output when searching for NAME
4755 4755 and shows only the path names when listing all definitions.
4756 4756
4757 4757 Path names are defined in the [paths] section of your
4758 4758 configuration file and in ``/etc/mercurial/hgrc``. If run inside a
4759 4759 repository, ``.hg/hgrc`` is used, too.
4760 4760
4761 4761 The path names ``default`` and ``default-push`` have a special
4762 4762 meaning. When performing a push or pull operation, they are used
4763 4763 as fallbacks if no location is specified on the command-line.
4764 4764 When ``default-push`` is set, it will be used for push and
4765 4765 ``default`` will be used for pull; otherwise ``default`` is used
4766 4766 as the fallback for both. When cloning a repository, the clone
4767 4767 source is written as ``default`` in ``.hg/hgrc``. Note that
4768 4768 ``default`` and ``default-push`` apply to all inbound (e.g.
4769 4769 :hg:`incoming`) and outbound (e.g. :hg:`outgoing`, :hg:`email` and
4770 4770 :hg:`bundle`) operations.
4771 4771
4772 4772 See :hg:`help urls` for more information.
4773 4773
4774 4774 Returns 0 on success.
4775 4775 """
4776 4776 if search:
4777 4777 for name, path in ui.configitems("paths"):
4778 4778 if name == search:
4779 4779 ui.status("%s\n" % util.hidepassword(path))
4780 4780 return
4781 4781 if not ui.quiet:
4782 4782 ui.warn(_("not found!\n"))
4783 4783 return 1
4784 4784 else:
4785 4785 for name, path in ui.configitems("paths"):
4786 4786 if ui.quiet:
4787 4787 ui.write("%s\n" % name)
4788 4788 else:
4789 4789 ui.write("%s = %s\n" % (name, util.hidepassword(path)))
4790 4790
4791 4791 @command('phase',
4792 4792 [('p', 'public', False, _('set changeset phase to public')),
4793 4793 ('d', 'draft', False, _('set changeset phase to draft')),
4794 4794 ('s', 'secret', False, _('set changeset phase to secret')),
4795 4795 ('f', 'force', False, _('allow to move boundary backward')),
4796 4796 ('r', 'rev', [], _('target revision'), _('REV')),
4797 4797 ],
4798 4798 _('[-p|-d|-s] [-f] [-r] REV...'))
4799 4799 def phase(ui, repo, *revs, **opts):
4800 4800 """set or show the current phase name
4801 4801
4802 4802 With no argument, show the phase name of specified revisions.
4803 4803
4804 4804 With one of -p/--public, -d/--draft or -s/--secret, change the
4805 4805 phase value of the specified revisions.
4806 4806
4807 4807 Unless -f/--force is specified, :hg:`phase` won't move changeset from a
4808 4808 lower phase to an higher phase. Phases are ordered as follows::
4809 4809
4810 4810 public < draft < secret
4811 4811
4812 4812 Returns 0 on success, 1 if no phases were changed or some could not
4813 4813 be changed.
4814 4814 """
4815 4815 # search for a unique phase argument
4816 4816 targetphase = None
4817 4817 for idx, name in enumerate(phases.phasenames):
4818 4818 if opts[name]:
4819 4819 if targetphase is not None:
4820 4820 raise util.Abort(_('only one phase can be specified'))
4821 4821 targetphase = idx
4822 4822
4823 4823 # look for specified revision
4824 4824 revs = list(revs)
4825 4825 revs.extend(opts['rev'])
4826 4826 if not revs:
4827 4827 raise util.Abort(_('no revisions specified'))
4828 4828
4829 4829 revs = scmutil.revrange(repo, revs)
4830 4830
4831 4831 lock = None
4832 4832 ret = 0
4833 4833 if targetphase is None:
4834 4834 # display
4835 4835 for r in revs:
4836 4836 ctx = repo[r]
4837 4837 ui.write('%i: %s\n' % (ctx.rev(), ctx.phasestr()))
4838 4838 else:
4839 4839 tr = None
4840 4840 lock = repo.lock()
4841 4841 try:
4842 4842 tr = repo.transaction("phase")
4843 4843 # set phase
4844 4844 if not revs:
4845 4845 raise util.Abort(_('empty revision set'))
4846 4846 nodes = [repo[r].node() for r in revs]
4847 4847 olddata = repo._phasecache.getphaserevs(repo)[:]
4848 4848 phases.advanceboundary(repo, tr, targetphase, nodes)
4849 4849 if opts['force']:
4850 4850 phases.retractboundary(repo, tr, targetphase, nodes)
4851 4851 tr.close()
4852 4852 finally:
4853 4853 if tr is not None:
4854 4854 tr.release()
4855 4855 lock.release()
4856 4856 # moving revision from public to draft may hide them
4857 4857 # We have to check result on an unfiltered repository
4858 4858 unfi = repo.unfiltered()
4859 4859 newdata = repo._phasecache.getphaserevs(unfi)
4860 4860 changes = sum(o != newdata[i] for i, o in enumerate(olddata))
4861 4861 cl = unfi.changelog
4862 4862 rejected = [n for n in nodes
4863 4863 if newdata[cl.rev(n)] < targetphase]
4864 4864 if rejected:
4865 4865 ui.warn(_('cannot move %i changesets to a higher '
4866 4866 'phase, use --force\n') % len(rejected))
4867 4867 ret = 1
4868 4868 if changes:
4869 4869 msg = _('phase changed for %i changesets\n') % changes
4870 4870 if ret:
4871 4871 ui.status(msg)
4872 4872 else:
4873 4873 ui.note(msg)
4874 4874 else:
4875 4875 ui.warn(_('no phases changed\n'))
4876 4876 ret = 1
4877 4877 return ret
4878 4878
4879 4879 def postincoming(ui, repo, modheads, optupdate, checkout):
4880 4880 if modheads == 0:
4881 4881 return
4882 4882 if optupdate:
4883 4883 checkout, movemarkfrom = bookmarks.calculateupdate(ui, repo, checkout)
4884 4884 try:
4885 4885 ret = hg.update(repo, checkout)
4886 4886 except util.Abort, inst:
4887 4887 ui.warn(_("not updating: %s\n") % str(inst))
4888 4888 if inst.hint:
4889 4889 ui.warn(_("(%s)\n") % inst.hint)
4890 4890 return 0
4891 4891 if not ret and not checkout:
4892 4892 if bookmarks.update(repo, [movemarkfrom], repo['.'].node()):
4893 4893 ui.status(_("updating bookmark %s\n") % repo._bookmarkcurrent)
4894 4894 return ret
4895 4895 if modheads > 1:
4896 4896 currentbranchheads = len(repo.branchheads())
4897 4897 if currentbranchheads == modheads:
4898 4898 ui.status(_("(run 'hg heads' to see heads, 'hg merge' to merge)\n"))
4899 4899 elif currentbranchheads > 1:
4900 4900 ui.status(_("(run 'hg heads .' to see heads, 'hg merge' to "
4901 4901 "merge)\n"))
4902 4902 else:
4903 4903 ui.status(_("(run 'hg heads' to see heads)\n"))
4904 4904 else:
4905 4905 ui.status(_("(run 'hg update' to get a working copy)\n"))
4906 4906
4907 4907 @command('^pull',
4908 4908 [('u', 'update', None,
4909 4909 _('update to new branch head if changesets were pulled')),
4910 4910 ('f', 'force', None, _('run even when remote repository is unrelated')),
4911 4911 ('r', 'rev', [], _('a remote changeset intended to be added'), _('REV')),
4912 4912 ('B', 'bookmark', [], _("bookmark to pull"), _('BOOKMARK')),
4913 4913 ('b', 'branch', [], _('a specific branch you would like to pull'),
4914 4914 _('BRANCH')),
4915 4915 ] + remoteopts,
4916 4916 _('[-u] [-f] [-r REV]... [-e CMD] [--remotecmd CMD] [SOURCE]'))
4917 4917 def pull(ui, repo, source="default", **opts):
4918 4918 """pull changes from the specified source
4919 4919
4920 4920 Pull changes from a remote repository to a local one.
4921 4921
4922 4922 This finds all changes from the repository at the specified path
4923 4923 or URL and adds them to a local repository (the current one unless
4924 4924 -R is specified). By default, this does not update the copy of the
4925 4925 project in the working directory.
4926 4926
4927 4927 Use :hg:`incoming` if you want to see what would have been added
4928 4928 by a pull at the time you issued this command. If you then decide
4929 4929 to add those changes to the repository, you should use :hg:`pull
4930 4930 -r X` where ``X`` is the last changeset listed by :hg:`incoming`.
4931 4931
4932 4932 If SOURCE is omitted, the 'default' path will be used.
4933 4933 See :hg:`help urls` for more information.
4934 4934
4935 4935 Returns 0 on success, 1 if an update had unresolved files.
4936 4936 """
4937 4937 source, branches = hg.parseurl(ui.expandpath(source), opts.get('branch'))
4938 4938 other = hg.peer(repo, opts, source)
4939 4939 try:
4940 4940 ui.status(_('pulling from %s\n') % util.hidepassword(source))
4941 4941 revs, checkout = hg.addbranchrevs(repo, other, branches,
4942 4942 opts.get('rev'))
4943 4943
4944 4944 remotebookmarks = other.listkeys('bookmarks')
4945 4945
4946 4946 if opts.get('bookmark'):
4947 4947 if not revs:
4948 4948 revs = []
4949 4949 for b in opts['bookmark']:
4950 4950 if b not in remotebookmarks:
4951 4951 raise util.Abort(_('remote bookmark %s not found!') % b)
4952 4952 revs.append(remotebookmarks[b])
4953 4953
4954 4954 if revs:
4955 4955 try:
4956 4956 revs = [other.lookup(rev) for rev in revs]
4957 4957 except error.CapabilityError:
4958 4958 err = _("other repository doesn't support revision lookup, "
4959 4959 "so a rev cannot be specified.")
4960 4960 raise util.Abort(err)
4961 4961
4962 4962 modheads = repo.pull(other, heads=revs, force=opts.get('force'))
4963 4963 bookmarks.updatefromremote(ui, repo, remotebookmarks, source)
4964 4964 if checkout:
4965 4965 checkout = str(repo.changelog.rev(other.lookup(checkout)))
4966 4966 repo._subtoppath = source
4967 4967 try:
4968 4968 ret = postincoming(ui, repo, modheads, opts.get('update'), checkout)
4969 4969
4970 4970 finally:
4971 4971 del repo._subtoppath
4972 4972
4973 4973 # update specified bookmarks
4974 4974 if opts.get('bookmark'):
4975 4975 marks = repo._bookmarks
4976 4976 for b in opts['bookmark']:
4977 4977 # explicit pull overrides local bookmark if any
4978 4978 ui.status(_("importing bookmark %s\n") % b)
4979 4979 marks[b] = repo[remotebookmarks[b]].node()
4980 4980 marks.write()
4981 4981 finally:
4982 4982 other.close()
4983 4983 return ret
4984 4984
4985 4985 @command('^push',
4986 4986 [('f', 'force', None, _('force push')),
4987 4987 ('r', 'rev', [],
4988 4988 _('a changeset intended to be included in the destination'),
4989 4989 _('REV')),
4990 4990 ('B', 'bookmark', [], _("bookmark to push"), _('BOOKMARK')),
4991 4991 ('b', 'branch', [],
4992 4992 _('a specific branch you would like to push'), _('BRANCH')),
4993 4993 ('', 'new-branch', False, _('allow pushing a new branch')),
4994 4994 ] + remoteopts,
4995 4995 _('[-f] [-r REV]... [-e CMD] [--remotecmd CMD] [DEST]'))
4996 4996 def push(ui, repo, dest=None, **opts):
4997 4997 """push changes to the specified destination
4998 4998
4999 4999 Push changesets from the local repository to the specified
5000 5000 destination.
5001 5001
5002 5002 This operation is symmetrical to pull: it is identical to a pull
5003 5003 in the destination repository from the current one.
5004 5004
5005 5005 By default, push will not allow creation of new heads at the
5006 5006 destination, since multiple heads would make it unclear which head
5007 5007 to use. In this situation, it is recommended to pull and merge
5008 5008 before pushing.
5009 5009
5010 5010 Use --new-branch if you want to allow push to create a new named
5011 5011 branch that is not present at the destination. This allows you to
5012 5012 only create a new branch without forcing other changes.
5013 5013
5014 5014 .. note::
5015 5015
5016 5016 Extra care should be taken with the -f/--force option,
5017 5017 which will push all new heads on all branches, an action which will
5018 5018 almost always cause confusion for collaborators.
5019 5019
5020 5020 If -r/--rev is used, the specified revision and all its ancestors
5021 5021 will be pushed to the remote repository.
5022 5022
5023 5023 If -B/--bookmark is used, the specified bookmarked revision, its
5024 5024 ancestors, and the bookmark will be pushed to the remote
5025 5025 repository.
5026 5026
5027 5027 Please see :hg:`help urls` for important details about ``ssh://``
5028 5028 URLs. If DESTINATION is omitted, a default path will be used.
5029 5029
5030 5030 Returns 0 if push was successful, 1 if nothing to push.
5031 5031 """
5032 5032
5033 5033 if opts.get('bookmark'):
5034 5034 ui.setconfig('bookmarks', 'pushing', opts['bookmark'], 'push')
5035 5035 for b in opts['bookmark']:
5036 5036 # translate -B options to -r so changesets get pushed
5037 5037 if b in repo._bookmarks:
5038 5038 opts.setdefault('rev', []).append(b)
5039 5039 else:
5040 5040 # if we try to push a deleted bookmark, translate it to null
5041 5041 # this lets simultaneous -r, -b options continue working
5042 5042 opts.setdefault('rev', []).append("null")
5043 5043
5044 5044 dest = ui.expandpath(dest or 'default-push', dest or 'default')
5045 5045 dest, branches = hg.parseurl(dest, opts.get('branch'))
5046 5046 ui.status(_('pushing to %s\n') % util.hidepassword(dest))
5047 5047 revs, checkout = hg.addbranchrevs(repo, repo, branches, opts.get('rev'))
5048 5048 try:
5049 5049 other = hg.peer(repo, opts, dest)
5050 5050 except error.RepoError:
5051 5051 if dest == "default-push":
5052 5052 raise util.Abort(_("default repository not configured!"),
5053 5053 hint=_('see the "path" section in "hg help config"'))
5054 5054 else:
5055 5055 raise
5056 5056
5057 5057 if revs:
5058 5058 revs = [repo.lookup(r) for r in scmutil.revrange(repo, revs)]
5059 5059
5060 5060 repo._subtoppath = dest
5061 5061 try:
5062 5062 # push subrepos depth-first for coherent ordering
5063 5063 c = repo['']
5064 5064 subs = c.substate # only repos that are committed
5065 5065 for s in sorted(subs):
5066 5066 result = c.sub(s).push(opts)
5067 5067 if result == 0:
5068 5068 return not result
5069 5069 finally:
5070 5070 del repo._subtoppath
5071 result = repo.push(other, opts.get('force'), revs=revs,
5072 newbranch=opts.get('new_branch'))
5073
5074 result = not result
5071 pushop = exchange.push(repo, other, opts.get('force'), revs=revs,
5072 newbranch=opts.get('new_branch'))
5073
5074 result = not pushop.cgresult
5075 5075
5076 5076 if opts.get('bookmark'):
5077 5077 bresult = bookmarks.pushtoremote(ui, repo, other, opts['bookmark'])
5078 5078 if bresult == 2:
5079 5079 return 2
5080 5080 if not result and bresult:
5081 5081 result = 2
5082 5082
5083 5083 return result
5084 5084
5085 5085 @command('recover', [])
5086 5086 def recover(ui, repo):
5087 5087 """roll back an interrupted transaction
5088 5088
5089 5089 Recover from an interrupted commit or pull.
5090 5090
5091 5091 This command tries to fix the repository status after an
5092 5092 interrupted operation. It should only be necessary when Mercurial
5093 5093 suggests it.
5094 5094
5095 5095 Returns 0 if successful, 1 if nothing to recover or verify fails.
5096 5096 """
5097 5097 if repo.recover():
5098 5098 return hg.verify(repo)
5099 5099 return 1
5100 5100
5101 5101 @command('^remove|rm',
5102 5102 [('A', 'after', None, _('record delete for missing files')),
5103 5103 ('f', 'force', None,
5104 5104 _('remove (and delete) file even if added or modified')),
5105 5105 ] + walkopts,
5106 5106 _('[OPTION]... FILE...'),
5107 5107 inferrepo=True)
5108 5108 def remove(ui, repo, *pats, **opts):
5109 5109 """remove the specified files on the next commit
5110 5110
5111 5111 Schedule the indicated files for removal from the current branch.
5112 5112
5113 5113 This command schedules the files to be removed at the next commit.
5114 5114 To undo a remove before that, see :hg:`revert`. To undo added
5115 5115 files, see :hg:`forget`.
5116 5116
5117 5117 .. container:: verbose
5118 5118
5119 5119 -A/--after can be used to remove only files that have already
5120 5120 been deleted, -f/--force can be used to force deletion, and -Af
5121 5121 can be used to remove files from the next revision without
5122 5122 deleting them from the working directory.
5123 5123
5124 5124 The following table details the behavior of remove for different
5125 5125 file states (columns) and option combinations (rows). The file
5126 5126 states are Added [A], Clean [C], Modified [M] and Missing [!]
5127 5127 (as reported by :hg:`status`). The actions are Warn, Remove
5128 5128 (from branch) and Delete (from disk):
5129 5129
5130 5130 ========= == == == ==
5131 5131 opt/state A C M !
5132 5132 ========= == == == ==
5133 5133 none W RD W R
5134 5134 -f R RD RD R
5135 5135 -A W W W R
5136 5136 -Af R R R R
5137 5137 ========= == == == ==
5138 5138
5139 5139 Note that remove never deletes files in Added [A] state from the
5140 5140 working directory, not even if option --force is specified.
5141 5141
5142 5142 Returns 0 on success, 1 if any warnings encountered.
5143 5143 """
5144 5144
5145 5145 ret = 0
5146 5146 after, force = opts.get('after'), opts.get('force')
5147 5147 if not pats and not after:
5148 5148 raise util.Abort(_('no files specified'))
5149 5149
5150 5150 m = scmutil.match(repo[None], pats, opts)
5151 5151 s = repo.status(match=m, clean=True)
5152 5152 modified, added, deleted, clean = s[0], s[1], s[3], s[6]
5153 5153
5154 5154 # warn about failure to delete explicit files/dirs
5155 5155 wctx = repo[None]
5156 5156 for f in m.files():
5157 5157 if f in repo.dirstate or f in wctx.dirs():
5158 5158 continue
5159 5159 if os.path.exists(m.rel(f)):
5160 5160 if os.path.isdir(m.rel(f)):
5161 5161 ui.warn(_('not removing %s: no tracked files\n') % m.rel(f))
5162 5162 else:
5163 5163 ui.warn(_('not removing %s: file is untracked\n') % m.rel(f))
5164 5164 # missing files will generate a warning elsewhere
5165 5165 ret = 1
5166 5166
5167 5167 if force:
5168 5168 list = modified + deleted + clean + added
5169 5169 elif after:
5170 5170 list = deleted
5171 5171 for f in modified + added + clean:
5172 5172 ui.warn(_('not removing %s: file still exists\n') % m.rel(f))
5173 5173 ret = 1
5174 5174 else:
5175 5175 list = deleted + clean
5176 5176 for f in modified:
5177 5177 ui.warn(_('not removing %s: file is modified (use -f'
5178 5178 ' to force removal)\n') % m.rel(f))
5179 5179 ret = 1
5180 5180 for f in added:
5181 5181 ui.warn(_('not removing %s: file has been marked for add'
5182 5182 ' (use forget to undo)\n') % m.rel(f))
5183 5183 ret = 1
5184 5184
5185 5185 for f in sorted(list):
5186 5186 if ui.verbose or not m.exact(f):
5187 5187 ui.status(_('removing %s\n') % m.rel(f))
5188 5188
5189 5189 wlock = repo.wlock()
5190 5190 try:
5191 5191 if not after:
5192 5192 for f in list:
5193 5193 if f in added:
5194 5194 continue # we never unlink added files on remove
5195 5195 util.unlinkpath(repo.wjoin(f), ignoremissing=True)
5196 5196 repo[None].forget(list)
5197 5197 finally:
5198 5198 wlock.release()
5199 5199
5200 5200 return ret
5201 5201
5202 5202 @command('rename|move|mv',
5203 5203 [('A', 'after', None, _('record a rename that has already occurred')),
5204 5204 ('f', 'force', None, _('forcibly copy over an existing managed file')),
5205 5205 ] + walkopts + dryrunopts,
5206 5206 _('[OPTION]... SOURCE... DEST'))
5207 5207 def rename(ui, repo, *pats, **opts):
5208 5208 """rename files; equivalent of copy + remove
5209 5209
5210 5210 Mark dest as copies of sources; mark sources for deletion. If dest
5211 5211 is a directory, copies are put in that directory. If dest is a
5212 5212 file, there can only be one source.
5213 5213
5214 5214 By default, this command copies the contents of files as they
5215 5215 exist in the working directory. If invoked with -A/--after, the
5216 5216 operation is recorded, but no copying is performed.
5217 5217
5218 5218 This command takes effect at the next commit. To undo a rename
5219 5219 before that, see :hg:`revert`.
5220 5220
5221 5221 Returns 0 on success, 1 if errors are encountered.
5222 5222 """
5223 5223 wlock = repo.wlock(False)
5224 5224 try:
5225 5225 return cmdutil.copy(ui, repo, pats, opts, rename=True)
5226 5226 finally:
5227 5227 wlock.release()
5228 5228
5229 5229 @command('resolve',
5230 5230 [('a', 'all', None, _('select all unresolved files')),
5231 5231 ('l', 'list', None, _('list state of files needing merge')),
5232 5232 ('m', 'mark', None, _('mark files as resolved')),
5233 5233 ('u', 'unmark', None, _('mark files as unresolved')),
5234 5234 ('n', 'no-status', None, _('hide status prefix'))]
5235 5235 + mergetoolopts + walkopts,
5236 5236 _('[OPTION]... [FILE]...'),
5237 5237 inferrepo=True)
5238 5238 def resolve(ui, repo, *pats, **opts):
5239 5239 """redo merges or set/view the merge status of files
5240 5240
5241 5241 Merges with unresolved conflicts are often the result of
5242 5242 non-interactive merging using the ``internal:merge`` configuration
5243 5243 setting, or a command-line merge tool like ``diff3``. The resolve
5244 5244 command is used to manage the files involved in a merge, after
5245 5245 :hg:`merge` has been run, and before :hg:`commit` is run (i.e. the
5246 5246 working directory must have two parents). See :hg:`help
5247 5247 merge-tools` for information on configuring merge tools.
5248 5248
5249 5249 The resolve command can be used in the following ways:
5250 5250
5251 5251 - :hg:`resolve [--tool TOOL] FILE...`: attempt to re-merge the specified
5252 5252 files, discarding any previous merge attempts. Re-merging is not
5253 5253 performed for files already marked as resolved. Use ``--all/-a``
5254 5254 to select all unresolved files. ``--tool`` can be used to specify
5255 5255 the merge tool used for the given files. It overrides the HGMERGE
5256 5256 environment variable and your configuration files. Previous file
5257 5257 contents are saved with a ``.orig`` suffix.
5258 5258
5259 5259 - :hg:`resolve -m [FILE]`: mark a file as having been resolved
5260 5260 (e.g. after having manually fixed-up the files). The default is
5261 5261 to mark all unresolved files.
5262 5262
5263 5263 - :hg:`resolve -u [FILE]...`: mark a file as unresolved. The
5264 5264 default is to mark all resolved files.
5265 5265
5266 5266 - :hg:`resolve -l`: list files which had or still have conflicts.
5267 5267 In the printed list, ``U`` = unresolved and ``R`` = resolved.
5268 5268
5269 5269 Note that Mercurial will not let you commit files with unresolved
5270 5270 merge conflicts. You must use :hg:`resolve -m ...` before you can
5271 5271 commit after a conflicting merge.
5272 5272
5273 5273 Returns 0 on success, 1 if any files fail a resolve attempt.
5274 5274 """
5275 5275
5276 5276 all, mark, unmark, show, nostatus = \
5277 5277 [opts.get(o) for o in 'all mark unmark list no_status'.split()]
5278 5278
5279 5279 if (show and (mark or unmark)) or (mark and unmark):
5280 5280 raise util.Abort(_("too many options specified"))
5281 5281 if pats and all:
5282 5282 raise util.Abort(_("can't specify --all and patterns"))
5283 5283 if not (all or pats or show or mark or unmark):
5284 5284 raise util.Abort(_('no files or directories specified'),
5285 5285 hint=('use --all to remerge all files'))
5286 5286
5287 5287 wlock = repo.wlock()
5288 5288 try:
5289 5289 ms = mergemod.mergestate(repo)
5290 5290
5291 5291 if not ms.active() and not show:
5292 5292 raise util.Abort(
5293 5293 _('resolve command not applicable when not merging'))
5294 5294
5295 5295 m = scmutil.match(repo[None], pats, opts)
5296 5296 ret = 0
5297 5297 didwork = False
5298 5298
5299 5299 for f in ms:
5300 5300 if not m(f):
5301 5301 continue
5302 5302
5303 5303 didwork = True
5304 5304
5305 5305 if show:
5306 5306 if nostatus:
5307 5307 ui.write("%s\n" % f)
5308 5308 else:
5309 5309 ui.write("%s %s\n" % (ms[f].upper(), f),
5310 5310 label='resolve.' +
5311 5311 {'u': 'unresolved', 'r': 'resolved'}[ms[f]])
5312 5312 elif mark:
5313 5313 ms.mark(f, "r")
5314 5314 elif unmark:
5315 5315 ms.mark(f, "u")
5316 5316 else:
5317 5317 wctx = repo[None]
5318 5318
5319 5319 # backup pre-resolve (merge uses .orig for its own purposes)
5320 5320 a = repo.wjoin(f)
5321 5321 util.copyfile(a, a + ".resolve")
5322 5322
5323 5323 try:
5324 5324 # resolve file
5325 5325 ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
5326 5326 'resolve')
5327 5327 if ms.resolve(f, wctx):
5328 5328 ret = 1
5329 5329 finally:
5330 5330 ui.setconfig('ui', 'forcemerge', '', 'resolve')
5331 5331 ms.commit()
5332 5332
5333 5333 # replace filemerge's .orig file with our resolve file
5334 5334 util.rename(a + ".resolve", a + ".orig")
5335 5335
5336 5336 ms.commit()
5337 5337
5338 5338 if not didwork and pats:
5339 5339 ui.warn(_("arguments do not match paths that need resolving\n"))
5340 5340
5341 5341 finally:
5342 5342 wlock.release()
5343 5343
5344 5344 # Nudge users into finishing an unfinished operation. We don't print
5345 5345 # this with the list/show operation because we want list/show to remain
5346 5346 # machine readable.
5347 5347 if not list(ms.unresolved()) and not show:
5348 5348 ui.status(_('(no more unresolved files)\n'))
5349 5349
5350 5350 return ret
5351 5351
5352 5352 @command('revert',
5353 5353 [('a', 'all', None, _('revert all changes when no arguments given')),
5354 5354 ('d', 'date', '', _('tipmost revision matching date'), _('DATE')),
5355 5355 ('r', 'rev', '', _('revert to the specified revision'), _('REV')),
5356 5356 ('C', 'no-backup', None, _('do not save backup copies of files')),
5357 5357 ] + walkopts + dryrunopts,
5358 5358 _('[OPTION]... [-r REV] [NAME]...'))
5359 5359 def revert(ui, repo, *pats, **opts):
5360 5360 """restore files to their checkout state
5361 5361
5362 5362 .. note::
5363 5363
5364 5364 To check out earlier revisions, you should use :hg:`update REV`.
5365 5365 To cancel an uncommitted merge (and lose your changes),
5366 5366 use :hg:`update --clean .`.
5367 5367
5368 5368 With no revision specified, revert the specified files or directories
5369 5369 to the contents they had in the parent of the working directory.
5370 5370 This restores the contents of files to an unmodified
5371 5371 state and unschedules adds, removes, copies, and renames. If the
5372 5372 working directory has two parents, you must explicitly specify a
5373 5373 revision.
5374 5374
5375 5375 Using the -r/--rev or -d/--date options, revert the given files or
5376 5376 directories to their states as of a specific revision. Because
5377 5377 revert does not change the working directory parents, this will
5378 5378 cause these files to appear modified. This can be helpful to "back
5379 5379 out" some or all of an earlier change. See :hg:`backout` for a
5380 5380 related method.
5381 5381
5382 5382 Modified files are saved with a .orig suffix before reverting.
5383 5383 To disable these backups, use --no-backup.
5384 5384
5385 5385 See :hg:`help dates` for a list of formats valid for -d/--date.
5386 5386
5387 5387 Returns 0 on success.
5388 5388 """
5389 5389
5390 5390 if opts.get("date"):
5391 5391 if opts.get("rev"):
5392 5392 raise util.Abort(_("you can't specify a revision and a date"))
5393 5393 opts["rev"] = cmdutil.finddate(ui, repo, opts["date"])
5394 5394
5395 5395 parent, p2 = repo.dirstate.parents()
5396 5396 if not opts.get('rev') and p2 != nullid:
5397 5397 # revert after merge is a trap for new users (issue2915)
5398 5398 raise util.Abort(_('uncommitted merge with no revision specified'),
5399 5399 hint=_('use "hg update" or see "hg help revert"'))
5400 5400
5401 5401 ctx = scmutil.revsingle(repo, opts.get('rev'))
5402 5402
5403 5403 if not pats and not opts.get('all'):
5404 5404 msg = _("no files or directories specified")
5405 5405 if p2 != nullid:
5406 5406 hint = _("uncommitted merge, use --all to discard all changes,"
5407 5407 " or 'hg update -C .' to abort the merge")
5408 5408 raise util.Abort(msg, hint=hint)
5409 5409 dirty = util.any(repo.status())
5410 5410 node = ctx.node()
5411 5411 if node != parent:
5412 5412 if dirty:
5413 5413 hint = _("uncommitted changes, use --all to discard all"
5414 5414 " changes, or 'hg update %s' to update") % ctx.rev()
5415 5415 else:
5416 5416 hint = _("use --all to revert all files,"
5417 5417 " or 'hg update %s' to update") % ctx.rev()
5418 5418 elif dirty:
5419 5419 hint = _("uncommitted changes, use --all to discard all changes")
5420 5420 else:
5421 5421 hint = _("use --all to revert all files")
5422 5422 raise util.Abort(msg, hint=hint)
5423 5423
5424 5424 return cmdutil.revert(ui, repo, ctx, (parent, p2), *pats, **opts)
5425 5425
5426 5426 @command('rollback', dryrunopts +
5427 5427 [('f', 'force', False, _('ignore safety measures'))])
5428 5428 def rollback(ui, repo, **opts):
5429 5429 """roll back the last transaction (DANGEROUS) (DEPRECATED)
5430 5430
5431 5431 Please use :hg:`commit --amend` instead of rollback to correct
5432 5432 mistakes in the last commit.
5433 5433
5434 5434 This command should be used with care. There is only one level of
5435 5435 rollback, and there is no way to undo a rollback. It will also
5436 5436 restore the dirstate at the time of the last transaction, losing
5437 5437 any dirstate changes since that time. This command does not alter
5438 5438 the working directory.
5439 5439
5440 5440 Transactions are used to encapsulate the effects of all commands
5441 5441 that create new changesets or propagate existing changesets into a
5442 5442 repository.
5443 5443
5444 5444 .. container:: verbose
5445 5445
5446 5446 For example, the following commands are transactional, and their
5447 5447 effects can be rolled back:
5448 5448
5449 5449 - commit
5450 5450 - import
5451 5451 - pull
5452 5452 - push (with this repository as the destination)
5453 5453 - unbundle
5454 5454
5455 5455 To avoid permanent data loss, rollback will refuse to rollback a
5456 5456 commit transaction if it isn't checked out. Use --force to
5457 5457 override this protection.
5458 5458
5459 5459 This command is not intended for use on public repositories. Once
5460 5460 changes are visible for pull by other users, rolling a transaction
5461 5461 back locally is ineffective (someone else may already have pulled
5462 5462 the changes). Furthermore, a race is possible with readers of the
5463 5463 repository; for example an in-progress pull from the repository
5464 5464 may fail if a rollback is performed.
5465 5465
5466 5466 Returns 0 on success, 1 if no rollback data is available.
5467 5467 """
5468 5468 return repo.rollback(dryrun=opts.get('dry_run'),
5469 5469 force=opts.get('force'))
5470 5470
5471 5471 @command('root', [])
5472 5472 def root(ui, repo):
5473 5473 """print the root (top) of the current working directory
5474 5474
5475 5475 Print the root directory of the current repository.
5476 5476
5477 5477 Returns 0 on success.
5478 5478 """
5479 5479 ui.write(repo.root + "\n")
5480 5480
5481 5481 @command('^serve',
5482 5482 [('A', 'accesslog', '', _('name of access log file to write to'),
5483 5483 _('FILE')),
5484 5484 ('d', 'daemon', None, _('run server in background')),
5485 5485 ('', 'daemon-pipefds', '', _('used internally by daemon mode'), _('NUM')),
5486 5486 ('E', 'errorlog', '', _('name of error log file to write to'), _('FILE')),
5487 5487 # use string type, then we can check if something was passed
5488 5488 ('p', 'port', '', _('port to listen on (default: 8000)'), _('PORT')),
5489 5489 ('a', 'address', '', _('address to listen on (default: all interfaces)'),
5490 5490 _('ADDR')),
5491 5491 ('', 'prefix', '', _('prefix path to serve from (default: server root)'),
5492 5492 _('PREFIX')),
5493 5493 ('n', 'name', '',
5494 5494 _('name to show in web pages (default: working directory)'), _('NAME')),
5495 5495 ('', 'web-conf', '',
5496 5496 _('name of the hgweb config file (see "hg help hgweb")'), _('FILE')),
5497 5497 ('', 'webdir-conf', '', _('name of the hgweb config file (DEPRECATED)'),
5498 5498 _('FILE')),
5499 5499 ('', 'pid-file', '', _('name of file to write process ID to'), _('FILE')),
5500 5500 ('', 'stdio', None, _('for remote clients')),
5501 5501 ('', 'cmdserver', '', _('for remote clients'), _('MODE')),
5502 5502 ('t', 'templates', '', _('web templates to use'), _('TEMPLATE')),
5503 5503 ('', 'style', '', _('template style to use'), _('STYLE')),
5504 5504 ('6', 'ipv6', None, _('use IPv6 in addition to IPv4')),
5505 5505 ('', 'certificate', '', _('SSL certificate file'), _('FILE'))],
5506 5506 _('[OPTION]...'),
5507 5507 optionalrepo=True)
5508 5508 def serve(ui, repo, **opts):
5509 5509 """start stand-alone webserver
5510 5510
5511 5511 Start a local HTTP repository browser and pull server. You can use
5512 5512 this for ad-hoc sharing and browsing of repositories. It is
5513 5513 recommended to use a real web server to serve a repository for
5514 5514 longer periods of time.
5515 5515
5516 5516 Please note that the server does not implement access control.
5517 5517 This means that, by default, anybody can read from the server and
5518 5518 nobody can write to it by default. Set the ``web.allow_push``
5519 5519 option to ``*`` to allow everybody to push to the server. You
5520 5520 should use a real web server if you need to authenticate users.
5521 5521
5522 5522 By default, the server logs accesses to stdout and errors to
5523 5523 stderr. Use the -A/--accesslog and -E/--errorlog options to log to
5524 5524 files.
5525 5525
5526 5526 To have the server choose a free port number to listen on, specify
5527 5527 a port number of 0; in this case, the server will print the port
5528 5528 number it uses.
5529 5529
5530 5530 Returns 0 on success.
5531 5531 """
5532 5532
5533 5533 if opts["stdio"] and opts["cmdserver"]:
5534 5534 raise util.Abort(_("cannot use --stdio with --cmdserver"))
5535 5535
5536 5536 if opts["stdio"]:
5537 5537 if repo is None:
5538 5538 raise error.RepoError(_("there is no Mercurial repository here"
5539 5539 " (.hg not found)"))
5540 5540 s = sshserver.sshserver(ui, repo)
5541 5541 s.serve_forever()
5542 5542
5543 5543 if opts["cmdserver"]:
5544 5544 s = commandserver.server(ui, repo, opts["cmdserver"])
5545 5545 return s.serve()
5546 5546
5547 5547 # this way we can check if something was given in the command-line
5548 5548 if opts.get('port'):
5549 5549 opts['port'] = util.getport(opts.get('port'))
5550 5550
5551 5551 baseui = repo and repo.baseui or ui
5552 5552 optlist = ("name templates style address port prefix ipv6"
5553 5553 " accesslog errorlog certificate encoding")
5554 5554 for o in optlist.split():
5555 5555 val = opts.get(o, '')
5556 5556 if val in (None, ''): # should check against default options instead
5557 5557 continue
5558 5558 baseui.setconfig("web", o, val, 'serve')
5559 5559 if repo and repo.ui != baseui:
5560 5560 repo.ui.setconfig("web", o, val, 'serve')
5561 5561
5562 5562 o = opts.get('web_conf') or opts.get('webdir_conf')
5563 5563 if not o:
5564 5564 if not repo:
5565 5565 raise error.RepoError(_("there is no Mercurial repository"
5566 5566 " here (.hg not found)"))
5567 5567 o = repo
5568 5568
5569 5569 app = hgweb.hgweb(o, baseui=baseui)
5570 5570 service = httpservice(ui, app, opts)
5571 5571 cmdutil.service(opts, initfn=service.init, runfn=service.run)
5572 5572
5573 5573 class httpservice(object):
5574 5574 def __init__(self, ui, app, opts):
5575 5575 self.ui = ui
5576 5576 self.app = app
5577 5577 self.opts = opts
5578 5578
5579 5579 def init(self):
5580 5580 util.setsignalhandler()
5581 5581 self.httpd = hgweb_server.create_server(self.ui, self.app)
5582 5582
5583 5583 if self.opts['port'] and not self.ui.verbose:
5584 5584 return
5585 5585
5586 5586 if self.httpd.prefix:
5587 5587 prefix = self.httpd.prefix.strip('/') + '/'
5588 5588 else:
5589 5589 prefix = ''
5590 5590
5591 5591 port = ':%d' % self.httpd.port
5592 5592 if port == ':80':
5593 5593 port = ''
5594 5594
5595 5595 bindaddr = self.httpd.addr
5596 5596 if bindaddr == '0.0.0.0':
5597 5597 bindaddr = '*'
5598 5598 elif ':' in bindaddr: # IPv6
5599 5599 bindaddr = '[%s]' % bindaddr
5600 5600
5601 5601 fqaddr = self.httpd.fqaddr
5602 5602 if ':' in fqaddr:
5603 5603 fqaddr = '[%s]' % fqaddr
5604 5604 if self.opts['port']:
5605 5605 write = self.ui.status
5606 5606 else:
5607 5607 write = self.ui.write
5608 5608 write(_('listening at http://%s%s/%s (bound to %s:%d)\n') %
5609 5609 (fqaddr, port, prefix, bindaddr, self.httpd.port))
5610 5610 self.ui.flush() # avoid buffering of status message
5611 5611
5612 5612 def run(self):
5613 5613 self.httpd.serve_forever()
5614 5614
5615 5615
5616 5616 @command('^status|st',
5617 5617 [('A', 'all', None, _('show status of all files')),
5618 5618 ('m', 'modified', None, _('show only modified files')),
5619 5619 ('a', 'added', None, _('show only added files')),
5620 5620 ('r', 'removed', None, _('show only removed files')),
5621 5621 ('d', 'deleted', None, _('show only deleted (but tracked) files')),
5622 5622 ('c', 'clean', None, _('show only files without changes')),
5623 5623 ('u', 'unknown', None, _('show only unknown (not tracked) files')),
5624 5624 ('i', 'ignored', None, _('show only ignored files')),
5625 5625 ('n', 'no-status', None, _('hide status prefix')),
5626 5626 ('C', 'copies', None, _('show source of copied files')),
5627 5627 ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
5628 5628 ('', 'rev', [], _('show difference from revision'), _('REV')),
5629 5629 ('', 'change', '', _('list the changed files of a revision'), _('REV')),
5630 5630 ] + walkopts + subrepoopts + formatteropts,
5631 5631 _('[OPTION]... [FILE]...'),
5632 5632 inferrepo=True)
5633 5633 def status(ui, repo, *pats, **opts):
5634 5634 """show changed files in the working directory
5635 5635
5636 5636 Show status of files in the repository. If names are given, only
5637 5637 files that match are shown. Files that are clean or ignored or
5638 5638 the source of a copy/move operation, are not listed unless
5639 5639 -c/--clean, -i/--ignored, -C/--copies or -A/--all are given.
5640 5640 Unless options described with "show only ..." are given, the
5641 5641 options -mardu are used.
5642 5642
5643 5643 Option -q/--quiet hides untracked (unknown and ignored) files
5644 5644 unless explicitly requested with -u/--unknown or -i/--ignored.
5645 5645
5646 5646 .. note::
5647 5647
5648 5648 status may appear to disagree with diff if permissions have
5649 5649 changed or a merge has occurred. The standard diff format does
5650 5650 not report permission changes and diff only reports changes
5651 5651 relative to one merge parent.
5652 5652
5653 5653 If one revision is given, it is used as the base revision.
5654 5654 If two revisions are given, the differences between them are
5655 5655 shown. The --change option can also be used as a shortcut to list
5656 5656 the changed files of a revision from its first parent.
5657 5657
5658 5658 The codes used to show the status of files are::
5659 5659
5660 5660 M = modified
5661 5661 A = added
5662 5662 R = removed
5663 5663 C = clean
5664 5664 ! = missing (deleted by non-hg command, but still tracked)
5665 5665 ? = not tracked
5666 5666 I = ignored
5667 5667 = origin of the previous file (with --copies)
5668 5668
5669 5669 .. container:: verbose
5670 5670
5671 5671 Examples:
5672 5672
5673 5673 - show changes in the working directory relative to a
5674 5674 changeset::
5675 5675
5676 5676 hg status --rev 9353
5677 5677
5678 5678 - show all changes including copies in an existing changeset::
5679 5679
5680 5680 hg status --copies --change 9353
5681 5681
5682 5682 - get a NUL separated list of added files, suitable for xargs::
5683 5683
5684 5684 hg status -an0
5685 5685
5686 5686 Returns 0 on success.
5687 5687 """
5688 5688
5689 5689 revs = opts.get('rev')
5690 5690 change = opts.get('change')
5691 5691
5692 5692 if revs and change:
5693 5693 msg = _('cannot specify --rev and --change at the same time')
5694 5694 raise util.Abort(msg)
5695 5695 elif change:
5696 5696 node2 = scmutil.revsingle(repo, change, None).node()
5697 5697 node1 = repo[node2].p1().node()
5698 5698 else:
5699 5699 node1, node2 = scmutil.revpair(repo, revs)
5700 5700
5701 5701 cwd = (pats and repo.getcwd()) or ''
5702 5702 end = opts.get('print0') and '\0' or '\n'
5703 5703 copy = {}
5704 5704 states = 'modified added removed deleted unknown ignored clean'.split()
5705 5705 show = [k for k in states if opts.get(k)]
5706 5706 if opts.get('all'):
5707 5707 show += ui.quiet and (states[:4] + ['clean']) or states
5708 5708 if not show:
5709 5709 show = ui.quiet and states[:4] or states[:5]
5710 5710
5711 5711 stat = repo.status(node1, node2, scmutil.match(repo[node2], pats, opts),
5712 5712 'ignored' in show, 'clean' in show, 'unknown' in show,
5713 5713 opts.get('subrepos'))
5714 5714 changestates = zip(states, 'MAR!?IC', stat)
5715 5715
5716 5716 if (opts.get('all') or opts.get('copies')) and not opts.get('no_status'):
5717 5717 copy = copies.pathcopies(repo[node1], repo[node2])
5718 5718
5719 5719 fm = ui.formatter('status', opts)
5720 5720 fmt = '%s' + end
5721 5721 showchar = not opts.get('no_status')
5722 5722
5723 5723 for state, char, files in changestates:
5724 5724 if state in show:
5725 5725 label = 'status.' + state
5726 5726 for f in files:
5727 5727 fm.startitem()
5728 5728 fm.condwrite(showchar, 'status', '%s ', char, label=label)
5729 5729 fm.write('path', fmt, repo.pathto(f, cwd), label=label)
5730 5730 if f in copy:
5731 5731 fm.write("copy", ' %s' + end, repo.pathto(copy[f], cwd),
5732 5732 label='status.copied')
5733 5733 fm.end()
5734 5734
5735 5735 @command('^summary|sum',
5736 5736 [('', 'remote', None, _('check for push and pull'))], '[--remote]')
5737 5737 def summary(ui, repo, **opts):
5738 5738 """summarize working directory state
5739 5739
5740 5740 This generates a brief summary of the working directory state,
5741 5741 including parents, branch, commit status, and available updates.
5742 5742
5743 5743 With the --remote option, this will check the default paths for
5744 5744 incoming and outgoing changes. This can be time-consuming.
5745 5745
5746 5746 Returns 0 on success.
5747 5747 """
5748 5748
5749 5749 ctx = repo[None]
5750 5750 parents = ctx.parents()
5751 5751 pnode = parents[0].node()
5752 5752 marks = []
5753 5753
5754 5754 for p in parents:
5755 5755 # label with log.changeset (instead of log.parent) since this
5756 5756 # shows a working directory parent *changeset*:
5757 5757 # i18n: column positioning for "hg summary"
5758 5758 ui.write(_('parent: %d:%s ') % (p.rev(), str(p)),
5759 5759 label='log.changeset changeset.%s' % p.phasestr())
5760 5760 ui.write(' '.join(p.tags()), label='log.tag')
5761 5761 if p.bookmarks():
5762 5762 marks.extend(p.bookmarks())
5763 5763 if p.rev() == -1:
5764 5764 if not len(repo):
5765 5765 ui.write(_(' (empty repository)'))
5766 5766 else:
5767 5767 ui.write(_(' (no revision checked out)'))
5768 5768 ui.write('\n')
5769 5769 if p.description():
5770 5770 ui.status(' ' + p.description().splitlines()[0].strip() + '\n',
5771 5771 label='log.summary')
5772 5772
5773 5773 branch = ctx.branch()
5774 5774 bheads = repo.branchheads(branch)
5775 5775 # i18n: column positioning for "hg summary"
5776 5776 m = _('branch: %s\n') % branch
5777 5777 if branch != 'default':
5778 5778 ui.write(m, label='log.branch')
5779 5779 else:
5780 5780 ui.status(m, label='log.branch')
5781 5781
5782 5782 if marks:
5783 5783 current = repo._bookmarkcurrent
5784 5784 # i18n: column positioning for "hg summary"
5785 5785 ui.write(_('bookmarks:'), label='log.bookmark')
5786 5786 if current is not None:
5787 5787 if current in marks:
5788 5788 ui.write(' *' + current, label='bookmarks.current')
5789 5789 marks.remove(current)
5790 5790 else:
5791 5791 ui.write(' [%s]' % current, label='bookmarks.current')
5792 5792 for m in marks:
5793 5793 ui.write(' ' + m, label='log.bookmark')
5794 5794 ui.write('\n', label='log.bookmark')
5795 5795
5796 5796 st = list(repo.status(unknown=True))[:6]
5797 5797
5798 5798 c = repo.dirstate.copies()
5799 5799 copied, renamed = [], []
5800 5800 for d, s in c.iteritems():
5801 5801 if s in st[2]:
5802 5802 st[2].remove(s)
5803 5803 renamed.append(d)
5804 5804 else:
5805 5805 copied.append(d)
5806 5806 if d in st[1]:
5807 5807 st[1].remove(d)
5808 5808 st.insert(3, renamed)
5809 5809 st.insert(4, copied)
5810 5810
5811 5811 ms = mergemod.mergestate(repo)
5812 5812 st.append([f for f in ms if ms[f] == 'u'])
5813 5813
5814 5814 subs = [s for s in ctx.substate if ctx.sub(s).dirty()]
5815 5815 st.append(subs)
5816 5816
5817 5817 labels = [ui.label(_('%d modified'), 'status.modified'),
5818 5818 ui.label(_('%d added'), 'status.added'),
5819 5819 ui.label(_('%d removed'), 'status.removed'),
5820 5820 ui.label(_('%d renamed'), 'status.copied'),
5821 5821 ui.label(_('%d copied'), 'status.copied'),
5822 5822 ui.label(_('%d deleted'), 'status.deleted'),
5823 5823 ui.label(_('%d unknown'), 'status.unknown'),
5824 5824 ui.label(_('%d ignored'), 'status.ignored'),
5825 5825 ui.label(_('%d unresolved'), 'resolve.unresolved'),
5826 5826 ui.label(_('%d subrepos'), 'status.modified')]
5827 5827 t = []
5828 5828 for s, l in zip(st, labels):
5829 5829 if s:
5830 5830 t.append(l % len(s))
5831 5831
5832 5832 t = ', '.join(t)
5833 5833 cleanworkdir = False
5834 5834
5835 5835 if repo.vfs.exists('updatestate'):
5836 5836 t += _(' (interrupted update)')
5837 5837 elif len(parents) > 1:
5838 5838 t += _(' (merge)')
5839 5839 elif branch != parents[0].branch():
5840 5840 t += _(' (new branch)')
5841 5841 elif (parents[0].closesbranch() and
5842 5842 pnode in repo.branchheads(branch, closed=True)):
5843 5843 t += _(' (head closed)')
5844 5844 elif not (st[0] or st[1] or st[2] or st[3] or st[4] or st[9]):
5845 5845 t += _(' (clean)')
5846 5846 cleanworkdir = True
5847 5847 elif pnode not in bheads:
5848 5848 t += _(' (new branch head)')
5849 5849
5850 5850 if cleanworkdir:
5851 5851 # i18n: column positioning for "hg summary"
5852 5852 ui.status(_('commit: %s\n') % t.strip())
5853 5853 else:
5854 5854 # i18n: column positioning for "hg summary"
5855 5855 ui.write(_('commit: %s\n') % t.strip())
5856 5856
5857 5857 # all ancestors of branch heads - all ancestors of parent = new csets
5858 5858 new = len(repo.changelog.findmissing([pctx.node() for pctx in parents],
5859 5859 bheads))
5860 5860
5861 5861 if new == 0:
5862 5862 # i18n: column positioning for "hg summary"
5863 5863 ui.status(_('update: (current)\n'))
5864 5864 elif pnode not in bheads:
5865 5865 # i18n: column positioning for "hg summary"
5866 5866 ui.write(_('update: %d new changesets (update)\n') % new)
5867 5867 else:
5868 5868 # i18n: column positioning for "hg summary"
5869 5869 ui.write(_('update: %d new changesets, %d branch heads (merge)\n') %
5870 5870 (new, len(bheads)))
5871 5871
5872 5872 cmdutil.summaryhooks(ui, repo)
5873 5873
5874 5874 if opts.get('remote'):
5875 5875 needsincoming, needsoutgoing = True, True
5876 5876 else:
5877 5877 needsincoming, needsoutgoing = False, False
5878 5878 for i, o in cmdutil.summaryremotehooks(ui, repo, opts, None):
5879 5879 if i:
5880 5880 needsincoming = True
5881 5881 if o:
5882 5882 needsoutgoing = True
5883 5883 if not needsincoming and not needsoutgoing:
5884 5884 return
5885 5885
5886 5886 def getincoming():
5887 5887 source, branches = hg.parseurl(ui.expandpath('default'))
5888 5888 sbranch = branches[0]
5889 5889 try:
5890 5890 other = hg.peer(repo, {}, source)
5891 5891 except error.RepoError:
5892 5892 if opts.get('remote'):
5893 5893 raise
5894 5894 return source, sbranch, None, None, None
5895 5895 revs, checkout = hg.addbranchrevs(repo, other, branches, None)
5896 5896 if revs:
5897 5897 revs = [other.lookup(rev) for rev in revs]
5898 5898 ui.debug('comparing with %s\n' % util.hidepassword(source))
5899 5899 repo.ui.pushbuffer()
5900 5900 commoninc = discovery.findcommonincoming(repo, other, heads=revs)
5901 5901 repo.ui.popbuffer()
5902 5902 return source, sbranch, other, commoninc, commoninc[1]
5903 5903
5904 5904 if needsincoming:
5905 5905 source, sbranch, sother, commoninc, incoming = getincoming()
5906 5906 else:
5907 5907 source = sbranch = sother = commoninc = incoming = None
5908 5908
5909 5909 def getoutgoing():
5910 5910 dest, branches = hg.parseurl(ui.expandpath('default-push', 'default'))
5911 5911 dbranch = branches[0]
5912 5912 revs, checkout = hg.addbranchrevs(repo, repo, branches, None)
5913 5913 if source != dest:
5914 5914 try:
5915 5915 dother = hg.peer(repo, {}, dest)
5916 5916 except error.RepoError:
5917 5917 if opts.get('remote'):
5918 5918 raise
5919 5919 return dest, dbranch, None, None
5920 5920 ui.debug('comparing with %s\n' % util.hidepassword(dest))
5921 5921 elif sother is None:
5922 5922 # there is no explicit destination peer, but source one is invalid
5923 5923 return dest, dbranch, None, None
5924 5924 else:
5925 5925 dother = sother
5926 5926 if (source != dest or (sbranch is not None and sbranch != dbranch)):
5927 5927 common = None
5928 5928 else:
5929 5929 common = commoninc
5930 5930 if revs:
5931 5931 revs = [repo.lookup(rev) for rev in revs]
5932 5932 repo.ui.pushbuffer()
5933 5933 outgoing = discovery.findcommonoutgoing(repo, dother, onlyheads=revs,
5934 5934 commoninc=common)
5935 5935 repo.ui.popbuffer()
5936 5936 return dest, dbranch, dother, outgoing
5937 5937
5938 5938 if needsoutgoing:
5939 5939 dest, dbranch, dother, outgoing = getoutgoing()
5940 5940 else:
5941 5941 dest = dbranch = dother = outgoing = None
5942 5942
5943 5943 if opts.get('remote'):
5944 5944 t = []
5945 5945 if incoming:
5946 5946 t.append(_('1 or more incoming'))
5947 5947 o = outgoing.missing
5948 5948 if o:
5949 5949 t.append(_('%d outgoing') % len(o))
5950 5950 other = dother or sother
5951 5951 if 'bookmarks' in other.listkeys('namespaces'):
5952 5952 lmarks = repo.listkeys('bookmarks')
5953 5953 rmarks = other.listkeys('bookmarks')
5954 5954 diff = set(rmarks) - set(lmarks)
5955 5955 if len(diff) > 0:
5956 5956 t.append(_('%d incoming bookmarks') % len(diff))
5957 5957 diff = set(lmarks) - set(rmarks)
5958 5958 if len(diff) > 0:
5959 5959 t.append(_('%d outgoing bookmarks') % len(diff))
5960 5960
5961 5961 if t:
5962 5962 # i18n: column positioning for "hg summary"
5963 5963 ui.write(_('remote: %s\n') % (', '.join(t)))
5964 5964 else:
5965 5965 # i18n: column positioning for "hg summary"
5966 5966 ui.status(_('remote: (synced)\n'))
5967 5967
5968 5968 cmdutil.summaryremotehooks(ui, repo, opts,
5969 5969 ((source, sbranch, sother, commoninc),
5970 5970 (dest, dbranch, dother, outgoing)))
5971 5971
5972 5972 @command('tag',
5973 5973 [('f', 'force', None, _('force tag')),
5974 5974 ('l', 'local', None, _('make the tag local')),
5975 5975 ('r', 'rev', '', _('revision to tag'), _('REV')),
5976 5976 ('', 'remove', None, _('remove a tag')),
5977 5977 # -l/--local is already there, commitopts cannot be used
5978 5978 ('e', 'edit', None, _('invoke editor on commit messages')),
5979 5979 ('m', 'message', '', _('use text as commit message'), _('TEXT')),
5980 5980 ] + commitopts2,
5981 5981 _('[-f] [-l] [-m TEXT] [-d DATE] [-u USER] [-r REV] NAME...'))
5982 5982 def tag(ui, repo, name1, *names, **opts):
5983 5983 """add one or more tags for the current or given revision
5984 5984
5985 5985 Name a particular revision using <name>.
5986 5986
5987 5987 Tags are used to name particular revisions of the repository and are
5988 5988 very useful to compare different revisions, to go back to significant
5989 5989 earlier versions or to mark branch points as releases, etc. Changing
5990 5990 an existing tag is normally disallowed; use -f/--force to override.
5991 5991
5992 5992 If no revision is given, the parent of the working directory is
5993 5993 used.
5994 5994
5995 5995 To facilitate version control, distribution, and merging of tags,
5996 5996 they are stored as a file named ".hgtags" which is managed similarly
5997 5997 to other project files and can be hand-edited if necessary. This
5998 5998 also means that tagging creates a new commit. The file
5999 5999 ".hg/localtags" is used for local tags (not shared among
6000 6000 repositories).
6001 6001
6002 6002 Tag commits are usually made at the head of a branch. If the parent
6003 6003 of the working directory is not a branch head, :hg:`tag` aborts; use
6004 6004 -f/--force to force the tag commit to be based on a non-head
6005 6005 changeset.
6006 6006
6007 6007 See :hg:`help dates` for a list of formats valid for -d/--date.
6008 6008
6009 6009 Since tag names have priority over branch names during revision
6010 6010 lookup, using an existing branch name as a tag name is discouraged.
6011 6011
6012 6012 Returns 0 on success.
6013 6013 """
6014 6014 wlock = lock = None
6015 6015 try:
6016 6016 wlock = repo.wlock()
6017 6017 lock = repo.lock()
6018 6018 rev_ = "."
6019 6019 names = [t.strip() for t in (name1,) + names]
6020 6020 if len(names) != len(set(names)):
6021 6021 raise util.Abort(_('tag names must be unique'))
6022 6022 for n in names:
6023 6023 scmutil.checknewlabel(repo, n, 'tag')
6024 6024 if not n:
6025 6025 raise util.Abort(_('tag names cannot consist entirely of '
6026 6026 'whitespace'))
6027 6027 if opts.get('rev') and opts.get('remove'):
6028 6028 raise util.Abort(_("--rev and --remove are incompatible"))
6029 6029 if opts.get('rev'):
6030 6030 rev_ = opts['rev']
6031 6031 message = opts.get('message')
6032 6032 if opts.get('remove'):
6033 6033 expectedtype = opts.get('local') and 'local' or 'global'
6034 6034 for n in names:
6035 6035 if not repo.tagtype(n):
6036 6036 raise util.Abort(_("tag '%s' does not exist") % n)
6037 6037 if repo.tagtype(n) != expectedtype:
6038 6038 if expectedtype == 'global':
6039 6039 raise util.Abort(_("tag '%s' is not a global tag") % n)
6040 6040 else:
6041 6041 raise util.Abort(_("tag '%s' is not a local tag") % n)
6042 6042 rev_ = nullid
6043 6043 if not message:
6044 6044 # we don't translate commit messages
6045 6045 message = 'Removed tag %s' % ', '.join(names)
6046 6046 elif not opts.get('force'):
6047 6047 for n in names:
6048 6048 if n in repo.tags():
6049 6049 raise util.Abort(_("tag '%s' already exists "
6050 6050 "(use -f to force)") % n)
6051 6051 if not opts.get('local'):
6052 6052 p1, p2 = repo.dirstate.parents()
6053 6053 if p2 != nullid:
6054 6054 raise util.Abort(_('uncommitted merge'))
6055 6055 bheads = repo.branchheads()
6056 6056 if not opts.get('force') and bheads and p1 not in bheads:
6057 6057 raise util.Abort(_('not at a branch head (use -f to force)'))
6058 6058 r = scmutil.revsingle(repo, rev_).node()
6059 6059
6060 6060 if not message:
6061 6061 # we don't translate commit messages
6062 6062 message = ('Added tag %s for changeset %s' %
6063 6063 (', '.join(names), short(r)))
6064 6064
6065 6065 date = opts.get('date')
6066 6066 if date:
6067 6067 date = util.parsedate(date)
6068 6068
6069 6069 if opts.get('remove'):
6070 6070 editform = 'tag.remove'
6071 6071 else:
6072 6072 editform = 'tag.add'
6073 6073 editor = cmdutil.getcommiteditor(editform=editform, **opts)
6074 6074
6075 6075 # don't allow tagging the null rev
6076 6076 if (not opts.get('remove') and
6077 6077 scmutil.revsingle(repo, rev_).rev() == nullrev):
6078 6078 raise util.Abort(_("cannot tag null revision"))
6079 6079
6080 6080 repo.tag(names, r, message, opts.get('local'), opts.get('user'), date,
6081 6081 editor=editor)
6082 6082 finally:
6083 6083 release(lock, wlock)
6084 6084
6085 6085 @command('tags', formatteropts, '')
6086 6086 def tags(ui, repo, **opts):
6087 6087 """list repository tags
6088 6088
6089 6089 This lists both regular and local tags. When the -v/--verbose
6090 6090 switch is used, a third column "local" is printed for local tags.
6091 6091
6092 6092 Returns 0 on success.
6093 6093 """
6094 6094
6095 6095 fm = ui.formatter('tags', opts)
6096 6096 if fm or ui.debugflag:
6097 6097 hexfunc = hex
6098 6098 else:
6099 6099 hexfunc = short
6100 6100 tagtype = ""
6101 6101
6102 6102 for t, n in reversed(repo.tagslist()):
6103 6103 hn = hexfunc(n)
6104 6104 label = 'tags.normal'
6105 6105 tagtype = ''
6106 6106 if repo.tagtype(t) == 'local':
6107 6107 label = 'tags.local'
6108 6108 tagtype = 'local'
6109 6109
6110 6110 fm.startitem()
6111 6111 fm.write('tag', '%s', t, label=label)
6112 6112 fmt = " " * (30 - encoding.colwidth(t)) + ' %5d:%s'
6113 6113 fm.condwrite(not ui.quiet, 'rev node', fmt,
6114 6114 repo.changelog.rev(n), hn, label=label)
6115 6115 fm.condwrite(ui.verbose and tagtype, 'type', ' %s',
6116 6116 tagtype, label=label)
6117 6117 fm.plain('\n')
6118 6118 fm.end()
6119 6119
6120 6120 @command('tip',
6121 6121 [('p', 'patch', None, _('show patch')),
6122 6122 ('g', 'git', None, _('use git extended diff format')),
6123 6123 ] + templateopts,
6124 6124 _('[-p] [-g]'))
6125 6125 def tip(ui, repo, **opts):
6126 6126 """show the tip revision (DEPRECATED)
6127 6127
6128 6128 The tip revision (usually just called the tip) is the changeset
6129 6129 most recently added to the repository (and therefore the most
6130 6130 recently changed head).
6131 6131
6132 6132 If you have just made a commit, that commit will be the tip. If
6133 6133 you have just pulled changes from another repository, the tip of
6134 6134 that repository becomes the current tip. The "tip" tag is special
6135 6135 and cannot be renamed or assigned to a different changeset.
6136 6136
6137 6137 This command is deprecated, please use :hg:`heads` instead.
6138 6138
6139 6139 Returns 0 on success.
6140 6140 """
6141 6141 displayer = cmdutil.show_changeset(ui, repo, opts)
6142 6142 displayer.show(repo['tip'])
6143 6143 displayer.close()
6144 6144
6145 6145 @command('unbundle',
6146 6146 [('u', 'update', None,
6147 6147 _('update to new branch head if changesets were unbundled'))],
6148 6148 _('[-u] FILE...'))
6149 6149 def unbundle(ui, repo, fname1, *fnames, **opts):
6150 6150 """apply one or more changegroup files
6151 6151
6152 6152 Apply one or more compressed changegroup files generated by the
6153 6153 bundle command.
6154 6154
6155 6155 Returns 0 on success, 1 if an update has unresolved files.
6156 6156 """
6157 6157 fnames = (fname1,) + fnames
6158 6158
6159 6159 lock = repo.lock()
6160 6160 try:
6161 6161 for fname in fnames:
6162 6162 f = hg.openpath(ui, fname)
6163 6163 gen = exchange.readbundle(ui, f, fname)
6164 6164 modheads = changegroup.addchangegroup(repo, gen, 'unbundle',
6165 6165 'bundle:' + fname)
6166 6166 finally:
6167 6167 lock.release()
6168 6168
6169 6169 return postincoming(ui, repo, modheads, opts.get('update'), None)
6170 6170
6171 6171 @command('^update|up|checkout|co',
6172 6172 [('C', 'clean', None, _('discard uncommitted changes (no backup)')),
6173 6173 ('c', 'check', None,
6174 6174 _('update across branches if no uncommitted changes')),
6175 6175 ('d', 'date', '', _('tipmost revision matching date'), _('DATE')),
6176 6176 ('r', 'rev', '', _('revision'), _('REV'))
6177 6177 ] + mergetoolopts,
6178 6178 _('[-c] [-C] [-d DATE] [[-r] REV]'))
6179 6179 def update(ui, repo, node=None, rev=None, clean=False, date=None, check=False,
6180 6180 tool=None):
6181 6181 """update working directory (or switch revisions)
6182 6182
6183 6183 Update the repository's working directory to the specified
6184 6184 changeset. If no changeset is specified, update to the tip of the
6185 6185 current named branch and move the current bookmark (see :hg:`help
6186 6186 bookmarks`).
6187 6187
6188 6188 Update sets the working directory's parent revision to the specified
6189 6189 changeset (see :hg:`help parents`).
6190 6190
6191 6191 If the changeset is not a descendant or ancestor of the working
6192 6192 directory's parent, the update is aborted. With the -c/--check
6193 6193 option, the working directory is checked for uncommitted changes; if
6194 6194 none are found, the working directory is updated to the specified
6195 6195 changeset.
6196 6196
6197 6197 .. container:: verbose
6198 6198
6199 6199 The following rules apply when the working directory contains
6200 6200 uncommitted changes:
6201 6201
6202 6202 1. If neither -c/--check nor -C/--clean is specified, and if
6203 6203 the requested changeset is an ancestor or descendant of
6204 6204 the working directory's parent, the uncommitted changes
6205 6205 are merged into the requested changeset and the merged
6206 6206 result is left uncommitted. If the requested changeset is
6207 6207 not an ancestor or descendant (that is, it is on another
6208 6208 branch), the update is aborted and the uncommitted changes
6209 6209 are preserved.
6210 6210
6211 6211 2. With the -c/--check option, the update is aborted and the
6212 6212 uncommitted changes are preserved.
6213 6213
6214 6214 3. With the -C/--clean option, uncommitted changes are discarded and
6215 6215 the working directory is updated to the requested changeset.
6216 6216
6217 6217 To cancel an uncommitted merge (and lose your changes), use
6218 6218 :hg:`update --clean .`.
6219 6219
6220 6220 Use null as the changeset to remove the working directory (like
6221 6221 :hg:`clone -U`).
6222 6222
6223 6223 If you want to revert just one file to an older revision, use
6224 6224 :hg:`revert [-r REV] NAME`.
6225 6225
6226 6226 See :hg:`help dates` for a list of formats valid for -d/--date.
6227 6227
6228 6228 Returns 0 on success, 1 if there are unresolved files.
6229 6229 """
6230 6230 if rev and node:
6231 6231 raise util.Abort(_("please specify just one revision"))
6232 6232
6233 6233 if rev is None or rev == '':
6234 6234 rev = node
6235 6235
6236 6236 cmdutil.clearunfinished(repo)
6237 6237
6238 6238 # with no argument, we also move the current bookmark, if any
6239 6239 rev, movemarkfrom = bookmarks.calculateupdate(ui, repo, rev)
6240 6240
6241 6241 # if we defined a bookmark, we have to remember the original bookmark name
6242 6242 brev = rev
6243 6243 rev = scmutil.revsingle(repo, rev, rev).rev()
6244 6244
6245 6245 if check and clean:
6246 6246 raise util.Abort(_("cannot specify both -c/--check and -C/--clean"))
6247 6247
6248 6248 if date:
6249 6249 if rev is not None:
6250 6250 raise util.Abort(_("you can't specify a revision and a date"))
6251 6251 rev = cmdutil.finddate(ui, repo, date)
6252 6252
6253 6253 if check:
6254 6254 c = repo[None]
6255 6255 if c.dirty(merge=False, branch=False, missing=True):
6256 6256 raise util.Abort(_("uncommitted changes"))
6257 6257 if rev is None:
6258 6258 rev = repo[repo[None].branch()].rev()
6259 6259 mergemod._checkunknown(repo, repo[None], repo[rev])
6260 6260
6261 6261 repo.ui.setconfig('ui', 'forcemerge', tool, 'update')
6262 6262
6263 6263 if clean:
6264 6264 ret = hg.clean(repo, rev)
6265 6265 else:
6266 6266 ret = hg.update(repo, rev)
6267 6267
6268 6268 if not ret and movemarkfrom:
6269 6269 if bookmarks.update(repo, [movemarkfrom], repo['.'].node()):
6270 6270 ui.status(_("updating bookmark %s\n") % repo._bookmarkcurrent)
6271 6271 elif brev in repo._bookmarks:
6272 6272 bookmarks.setcurrent(repo, brev)
6273 6273 ui.status(_("(activating bookmark %s)\n") % brev)
6274 6274 elif brev:
6275 6275 if repo._bookmarkcurrent:
6276 6276 ui.status(_("(leaving bookmark %s)\n") %
6277 6277 repo._bookmarkcurrent)
6278 6278 bookmarks.unsetcurrent(repo)
6279 6279
6280 6280 return ret
6281 6281
6282 6282 @command('verify', [])
6283 6283 def verify(ui, repo):
6284 6284 """verify the integrity of the repository
6285 6285
6286 6286 Verify the integrity of the current repository.
6287 6287
6288 6288 This will perform an extensive check of the repository's
6289 6289 integrity, validating the hashes and checksums of each entry in
6290 6290 the changelog, manifest, and tracked files, as well as the
6291 6291 integrity of their crosslinks and indices.
6292 6292
6293 6293 Please see http://mercurial.selenic.com/wiki/RepositoryCorruption
6294 6294 for more information about recovery from corruption of the
6295 6295 repository.
6296 6296
6297 6297 Returns 0 on success, 1 if errors are encountered.
6298 6298 """
6299 6299 return hg.verify(repo)
6300 6300
6301 6301 @command('version', [], norepo=True)
6302 6302 def version_(ui):
6303 6303 """output version and copyright information"""
6304 6304 ui.write(_("Mercurial Distributed SCM (version %s)\n")
6305 6305 % util.version())
6306 6306 ui.status(_(
6307 6307 "(see http://mercurial.selenic.com for more information)\n"
6308 6308 "\nCopyright (C) 2005-2014 Matt Mackall and others\n"
6309 6309 "This is free software; see the source for copying conditions. "
6310 6310 "There is NO\nwarranty; "
6311 6311 "not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
6312 6312 ))
6313 6313
6314 6314 ui.note(_("\nEnabled extensions:\n\n"))
6315 6315 if ui.verbose:
6316 6316 # format names and versions into columns
6317 6317 names = []
6318 6318 vers = []
6319 6319 for name, module in extensions.extensions():
6320 6320 names.append(name)
6321 6321 vers.append(extensions.moduleversion(module))
6322 6322 if names:
6323 6323 maxnamelen = max(len(n) for n in names)
6324 6324 for i, name in enumerate(names):
6325 6325 ui.write(" %-*s %s\n" % (maxnamelen, name, vers[i]))
General Comments 0
You need to be logged in to leave comments. Login now