##// END OF EJS Templates
Simplify update.
Bryan O'Sullivan -
r4942:b8076522 default
parent child Browse files
Show More
@@ -1,3135 +1,3135 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
6 6 # of the GNU General Public License, incorporated herein by reference.
7 7
8 8 import demandimport; demandimport.enable()
9 9 from node import *
10 10 from i18n import _
11 11 import bisect, os, re, sys, urllib, shlex, stat
12 12 import ui, hg, util, revlog, bundlerepo, extensions
13 13 import difflib, patch, time, help, mdiff, tempfile
14 14 import errno, version, socket
15 15 import archival, changegroup, cmdutil, hgweb.server, sshserver
16 16
17 17 # Commands start here, listed alphabetically
18 18
19 19 def add(ui, repo, *pats, **opts):
20 20 """add the specified files on the next commit
21 21
22 22 Schedule files to be version controlled and added to the repository.
23 23
24 24 The files will be added to the repository at the next commit. To
25 25 undo an add before that, see hg revert.
26 26
27 27 If no names are given, add all files in the repository.
28 28 """
29 29
30 30 names = []
31 31 for src, abs, rel, exact in cmdutil.walk(repo, pats, opts):
32 32 if exact:
33 33 if ui.verbose:
34 34 ui.status(_('adding %s\n') % rel)
35 35 names.append(abs)
36 36 elif repo.dirstate.state(abs) == '?':
37 37 ui.status(_('adding %s\n') % rel)
38 38 names.append(abs)
39 39 if not opts.get('dry_run'):
40 40 repo.add(names)
41 41
42 42 def addremove(ui, repo, *pats, **opts):
43 43 """add all new files, delete all missing files
44 44
45 45 Add all new files and remove all missing files from the repository.
46 46
47 47 New files are ignored if they match any of the patterns in .hgignore. As
48 48 with add, these changes take effect at the next commit.
49 49
50 50 Use the -s option to detect renamed files. With a parameter > 0,
51 51 this compares every removed file with every added file and records
52 52 those similar enough as renames. This option takes a percentage
53 53 between 0 (disabled) and 100 (files must be identical) as its
54 54 parameter. Detecting renamed files this way can be expensive.
55 55 """
56 56 sim = float(opts.get('similarity') or 0)
57 57 if sim < 0 or sim > 100:
58 58 raise util.Abort(_('similarity must be between 0 and 100'))
59 59 return cmdutil.addremove(repo, pats, opts, similarity=sim/100.)
60 60
61 61 def annotate(ui, repo, *pats, **opts):
62 62 """show changeset information per file line
63 63
64 64 List changes in files, showing the revision id responsible for each line
65 65
66 66 This command is useful to discover who did a change or when a change took
67 67 place.
68 68
69 69 Without the -a option, annotate will avoid processing files it
70 70 detects as binary. With -a, annotate will generate an annotation
71 71 anyway, probably with undesirable results.
72 72 """
73 73 getdate = util.cachefunc(lambda x: util.datestr(x.date()))
74 74
75 75 if not pats:
76 76 raise util.Abort(_('at least one file name or pattern required'))
77 77
78 78 opmap = [['user', lambda x: ui.shortuser(x.user())],
79 79 ['number', lambda x: str(x.rev())],
80 80 ['changeset', lambda x: short(x.node())],
81 81 ['date', getdate], ['follow', lambda x: x.path()]]
82 82 if (not opts['user'] and not opts['changeset'] and not opts['date']
83 83 and not opts['follow']):
84 84 opts['number'] = 1
85 85
86 86 ctx = repo.changectx(opts['rev'])
87 87
88 88 for src, abs, rel, exact in cmdutil.walk(repo, pats, opts,
89 89 node=ctx.node()):
90 90 fctx = ctx.filectx(abs)
91 91 if not opts['text'] and util.binary(fctx.data()):
92 92 ui.write(_("%s: binary file\n") % ((pats and rel) or abs))
93 93 continue
94 94
95 95 lines = fctx.annotate(follow=opts.get('follow'))
96 96 pieces = []
97 97
98 98 for o, f in opmap:
99 99 if opts[o]:
100 100 l = [f(n) for n, dummy in lines]
101 101 if l:
102 102 m = max(map(len, l))
103 103 pieces.append(["%*s" % (m, x) for x in l])
104 104
105 105 if pieces:
106 106 for p, l in zip(zip(*pieces), lines):
107 107 ui.write("%s: %s" % (" ".join(p), l[1]))
108 108
109 109 def archive(ui, repo, dest, **opts):
110 110 '''create unversioned archive of a repository revision
111 111
112 112 By default, the revision used is the parent of the working
113 113 directory; use "-r" to specify a different revision.
114 114
115 115 To specify the type of archive to create, use "-t". Valid
116 116 types are:
117 117
118 118 "files" (default): a directory full of files
119 119 "tar": tar archive, uncompressed
120 120 "tbz2": tar archive, compressed using bzip2
121 121 "tgz": tar archive, compressed using gzip
122 122 "uzip": zip archive, uncompressed
123 123 "zip": zip archive, compressed using deflate
124 124
125 125 The exact name of the destination archive or directory is given
126 126 using a format string; see "hg help export" for details.
127 127
128 128 Each member added to an archive file has a directory prefix
129 129 prepended. Use "-p" to specify a format string for the prefix.
130 130 The default is the basename of the archive, with suffixes removed.
131 131 '''
132 132
133 133 node = repo.changectx(opts['rev']).node()
134 134 dest = cmdutil.make_filename(repo, dest, node)
135 135 if os.path.realpath(dest) == repo.root:
136 136 raise util.Abort(_('repository root cannot be destination'))
137 137 dummy, matchfn, dummy = cmdutil.matchpats(repo, [], opts)
138 138 kind = opts.get('type') or 'files'
139 139 prefix = opts['prefix']
140 140 if dest == '-':
141 141 if kind == 'files':
142 142 raise util.Abort(_('cannot archive plain files to stdout'))
143 143 dest = sys.stdout
144 144 if not prefix: prefix = os.path.basename(repo.root) + '-%h'
145 145 prefix = cmdutil.make_filename(repo, prefix, node)
146 146 archival.archive(repo, dest, node, kind, not opts['no_decode'],
147 147 matchfn, prefix)
148 148
149 149 def backout(ui, repo, node=None, rev=None, **opts):
150 150 '''reverse effect of earlier changeset
151 151
152 152 Commit the backed out changes as a new changeset. The new
153 153 changeset is a child of the backed out changeset.
154 154
155 155 If you back out a changeset other than the tip, a new head is
156 156 created. This head is the parent of the working directory. If
157 157 you back out an old changeset, your working directory will appear
158 158 old after the backout. You should merge the backout changeset
159 159 with another head.
160 160
161 161 The --merge option remembers the parent of the working directory
162 162 before starting the backout, then merges the new head with that
163 163 changeset afterwards. This saves you from doing the merge by
164 164 hand. The result of this merge is not committed, as for a normal
165 165 merge.'''
166 166 if rev and node:
167 167 raise util.Abort(_("please specify just one revision"))
168 168
169 169 if not rev:
170 170 rev = node
171 171
172 172 if not rev:
173 173 raise util.Abort(_("please specify a revision to backout"))
174 174
175 175 cmdutil.bail_if_changed(repo)
176 176 op1, op2 = repo.dirstate.parents()
177 177 if op2 != nullid:
178 178 raise util.Abort(_('outstanding uncommitted merge'))
179 179 node = repo.lookup(rev)
180 180 p1, p2 = repo.changelog.parents(node)
181 181 if p1 == nullid:
182 182 raise util.Abort(_('cannot back out a change with no parents'))
183 183 if p2 != nullid:
184 184 if not opts['parent']:
185 185 raise util.Abort(_('cannot back out a merge changeset without '
186 186 '--parent'))
187 187 p = repo.lookup(opts['parent'])
188 188 if p not in (p1, p2):
189 189 raise util.Abort(_('%s is not a parent of %s') %
190 190 (short(p), short(node)))
191 191 parent = p
192 192 else:
193 193 if opts['parent']:
194 194 raise util.Abort(_('cannot use --parent on non-merge changeset'))
195 195 parent = p1
196 196 hg.clean(repo, node, show_stats=False)
197 197 revert_opts = opts.copy()
198 198 revert_opts['date'] = None
199 199 revert_opts['all'] = True
200 200 revert_opts['rev'] = hex(parent)
201 201 revert(ui, repo, **revert_opts)
202 202 commit_opts = opts.copy()
203 203 commit_opts['addremove'] = False
204 204 if not commit_opts['message'] and not commit_opts['logfile']:
205 205 commit_opts['message'] = _("Backed out changeset %s") % (short(node))
206 206 commit_opts['force_editor'] = True
207 207 commit(ui, repo, **commit_opts)
208 208 def nice(node):
209 209 return '%d:%s' % (repo.changelog.rev(node), short(node))
210 210 ui.status(_('changeset %s backs out changeset %s\n') %
211 211 (nice(repo.changelog.tip()), nice(node)))
212 212 if op1 != node:
213 213 if opts['merge']:
214 214 ui.status(_('merging with changeset %s\n') % nice(op1))
215 215 hg.merge(repo, hex(op1))
216 216 else:
217 217 ui.status(_('the backout changeset is a new head - '
218 218 'do not forget to merge\n'))
219 219 ui.status(_('(use "backout --merge" '
220 220 'if you want to auto-merge)\n'))
221 221
222 222 def branch(ui, repo, label=None, **opts):
223 223 """set or show the current branch name
224 224
225 225 With no argument, show the current branch name. With one argument,
226 226 set the working directory branch name (the branch does not exist in
227 227 the repository until the next commit).
228 228
229 229 Unless --force is specified, branch will not let you set a
230 230 branch name that shadows an existing branch.
231 231 """
232 232
233 233 if label:
234 234 if not opts.get('force') and label in repo.branchtags():
235 235 if label not in [p.branch() for p in repo.workingctx().parents()]:
236 236 raise util.Abort(_('a branch of the same name already exists'
237 237 ' (use --force to override)'))
238 238 repo.dirstate.setbranch(util.fromlocal(label))
239 239 ui.status(_('marked working directory as branch %s\n') % label)
240 240 else:
241 241 ui.write("%s\n" % util.tolocal(repo.dirstate.branch()))
242 242
243 243 def branches(ui, repo, active=False):
244 244 """list repository named branches
245 245
246 246 List the repository's named branches, indicating which ones are
247 247 inactive. If active is specified, only show active branches.
248 248
249 249 A branch is considered active if it contains unmerged heads.
250 250 """
251 251 b = repo.branchtags()
252 252 heads = dict.fromkeys(repo.heads(), 1)
253 253 l = [((n in heads), repo.changelog.rev(n), n, t) for t, n in b.items()]
254 254 l.sort()
255 255 l.reverse()
256 256 for ishead, r, n, t in l:
257 257 if active and not ishead:
258 258 # If we're only displaying active branches, abort the loop on
259 259 # encountering the first inactive head
260 260 break
261 261 else:
262 262 hexfunc = ui.debugflag and hex or short
263 263 if ui.quiet:
264 264 ui.write("%s\n" % t)
265 265 else:
266 266 spaces = " " * (30 - util.locallen(t))
267 267 # The code only gets here if inactive branches are being
268 268 # displayed or the branch is active.
269 269 isinactive = ((not ishead) and " (inactive)") or ''
270 270 ui.write("%s%s %s:%s%s\n" % (t, spaces, r, hexfunc(n), isinactive))
271 271
272 272 def bundle(ui, repo, fname, dest=None, **opts):
273 273 """create a changegroup file
274 274
275 275 Generate a compressed changegroup file collecting changesets not
276 276 found in the other repository.
277 277
278 278 If no destination repository is specified the destination is assumed
279 279 to have all the nodes specified by one or more --base parameters.
280 280
281 281 The bundle file can then be transferred using conventional means and
282 282 applied to another repository with the unbundle or pull command.
283 283 This is useful when direct push and pull are not available or when
284 284 exporting an entire repository is undesirable.
285 285
286 286 Applying bundles preserves all changeset contents including
287 287 permissions, copy/rename information, and revision history.
288 288 """
289 289 revs = opts.get('rev') or None
290 290 if revs:
291 291 revs = [repo.lookup(rev) for rev in revs]
292 292 base = opts.get('base')
293 293 if base:
294 294 if dest:
295 295 raise util.Abort(_("--base is incompatible with specifiying "
296 296 "a destination"))
297 297 base = [repo.lookup(rev) for rev in base]
298 298 # create the right base
299 299 # XXX: nodesbetween / changegroup* should be "fixed" instead
300 300 o = []
301 301 has = {nullid: None}
302 302 for n in base:
303 303 has.update(repo.changelog.reachable(n))
304 304 if revs:
305 305 visit = list(revs)
306 306 else:
307 307 visit = repo.changelog.heads()
308 308 seen = {}
309 309 while visit:
310 310 n = visit.pop(0)
311 311 parents = [p for p in repo.changelog.parents(n) if p not in has]
312 312 if len(parents) == 0:
313 313 o.insert(0, n)
314 314 else:
315 315 for p in parents:
316 316 if p not in seen:
317 317 seen[p] = 1
318 318 visit.append(p)
319 319 else:
320 320 cmdutil.setremoteconfig(ui, opts)
321 321 dest, revs = cmdutil.parseurl(
322 322 ui.expandpath(dest or 'default-push', dest or 'default'), revs)
323 323 other = hg.repository(ui, dest)
324 324 o = repo.findoutgoing(other, force=opts['force'])
325 325
326 326 if revs:
327 327 cg = repo.changegroupsubset(o, revs, 'bundle')
328 328 else:
329 329 cg = repo.changegroup(o, 'bundle')
330 330 changegroup.writebundle(cg, fname, "HG10BZ")
331 331
332 332 def cat(ui, repo, file1, *pats, **opts):
333 333 """output the current or given revision of files
334 334
335 335 Print the specified files as they were at the given revision.
336 336 If no revision is given, the parent of the working directory is used,
337 337 or tip if no revision is checked out.
338 338
339 339 Output may be to a file, in which case the name of the file is
340 340 given using a format string. The formatting rules are the same as
341 341 for the export command, with the following additions:
342 342
343 343 %s basename of file being printed
344 344 %d dirname of file being printed, or '.' if in repo root
345 345 %p root-relative path name of file being printed
346 346 """
347 347 ctx = repo.changectx(opts['rev'])
348 348 err = 1
349 349 for src, abs, rel, exact in cmdutil.walk(repo, (file1,) + pats, opts,
350 350 ctx.node()):
351 351 fp = cmdutil.make_file(repo, opts['output'], ctx.node(), pathname=abs)
352 352 fp.write(ctx.filectx(abs).data())
353 353 err = 0
354 354 return err
355 355
356 356 def clone(ui, source, dest=None, **opts):
357 357 """make a copy of an existing repository
358 358
359 359 Create a copy of an existing repository in a new directory.
360 360
361 361 If no destination directory name is specified, it defaults to the
362 362 basename of the source.
363 363
364 364 The location of the source is added to the new repository's
365 365 .hg/hgrc file, as the default to be used for future pulls.
366 366
367 367 For efficiency, hardlinks are used for cloning whenever the source
368 368 and destination are on the same filesystem (note this applies only
369 369 to the repository data, not to the checked out files). Some
370 370 filesystems, such as AFS, implement hardlinking incorrectly, but
371 371 do not report errors. In these cases, use the --pull option to
372 372 avoid hardlinking.
373 373
374 374 You can safely clone repositories and checked out files using full
375 375 hardlinks with
376 376
377 377 $ cp -al REPO REPOCLONE
378 378
379 379 which is the fastest way to clone. However, the operation is not
380 380 atomic (making sure REPO is not modified during the operation is
381 381 up to you) and you have to make sure your editor breaks hardlinks
382 382 (Emacs and most Linux Kernel tools do so).
383 383
384 384 If you use the -r option to clone up to a specific revision, no
385 385 subsequent revisions will be present in the cloned repository.
386 386 This option implies --pull, even on local repositories.
387 387
388 388 See pull for valid source format details.
389 389
390 390 It is possible to specify an ssh:// URL as the destination, but no
391 391 .hg/hgrc and working directory will be created on the remote side.
392 392 Look at the help text for the pull command for important details
393 393 about ssh:// URLs.
394 394 """
395 395 cmdutil.setremoteconfig(ui, opts)
396 396 hg.clone(ui, source, dest,
397 397 pull=opts['pull'],
398 398 stream=opts['uncompressed'],
399 399 rev=opts['rev'],
400 400 update=not opts['noupdate'])
401 401
402 402 def commit(ui, repo, *pats, **opts):
403 403 """commit the specified files or all outstanding changes
404 404
405 405 Commit changes to the given files into the repository.
406 406
407 407 If a list of files is omitted, all changes reported by "hg status"
408 408 will be committed.
409 409
410 410 If no commit message is specified, the editor configured in your hgrc
411 411 or in the EDITOR environment variable is started to enter a message.
412 412 """
413 413 message = cmdutil.logmessage(opts)
414 414
415 415 if opts['addremove']:
416 416 cmdutil.addremove(repo, pats, opts)
417 417 fns, match, anypats = cmdutil.matchpats(repo, pats, opts)
418 418 if pats:
419 419 status = repo.status(files=fns, match=match)
420 420 modified, added, removed, deleted, unknown = status[:5]
421 421 files = modified + added + removed
422 422 slist = None
423 423 for f in fns:
424 424 if f == '.':
425 425 continue
426 426 if f not in files:
427 427 rf = repo.wjoin(f)
428 428 try:
429 429 mode = os.lstat(rf)[stat.ST_MODE]
430 430 except OSError:
431 431 raise util.Abort(_("file %s not found!") % rf)
432 432 if stat.S_ISDIR(mode):
433 433 name = f + '/'
434 434 if slist is None:
435 435 slist = list(files)
436 436 slist.sort()
437 437 i = bisect.bisect(slist, name)
438 438 if i >= len(slist) or not slist[i].startswith(name):
439 439 raise util.Abort(_("no match under directory %s!")
440 440 % rf)
441 441 elif not (stat.S_ISREG(mode) or stat.S_ISLNK(mode)):
442 442 raise util.Abort(_("can't commit %s: "
443 443 "unsupported file type!") % rf)
444 444 elif repo.dirstate.state(f) == '?':
445 445 raise util.Abort(_("file %s not tracked!") % rf)
446 446 else:
447 447 files = []
448 448 try:
449 449 repo.commit(files, message, opts['user'], opts['date'], match,
450 450 force_editor=opts.get('force_editor'))
451 451 except ValueError, inst:
452 452 raise util.Abort(str(inst))
453 453
454 454 def docopy(ui, repo, pats, opts, wlock):
455 455 # called with the repo lock held
456 456 #
457 457 # hgsep => pathname that uses "/" to separate directories
458 458 # ossep => pathname that uses os.sep to separate directories
459 459 cwd = repo.getcwd()
460 460 errors = 0
461 461 copied = []
462 462 targets = {}
463 463
464 464 # abs: hgsep
465 465 # rel: ossep
466 466 # return: hgsep
467 467 def okaytocopy(abs, rel, exact):
468 468 reasons = {'?': _('is not managed'),
469 469 'r': _('has been marked for remove')}
470 470 state = repo.dirstate.state(abs)
471 471 reason = reasons.get(state)
472 472 if reason:
473 473 if exact:
474 474 ui.warn(_('%s: not copying - file %s\n') % (rel, reason))
475 475 else:
476 476 if state == 'a':
477 477 origsrc = repo.dirstate.copied(abs)
478 478 if origsrc is not None:
479 479 return origsrc
480 480 return abs
481 481
482 482 # origsrc: hgsep
483 483 # abssrc: hgsep
484 484 # relsrc: ossep
485 485 # otarget: ossep
486 486 def copy(origsrc, abssrc, relsrc, otarget, exact):
487 487 abstarget = util.canonpath(repo.root, cwd, otarget)
488 488 reltarget = repo.pathto(abstarget, cwd)
489 489 prevsrc = targets.get(abstarget)
490 490 src = repo.wjoin(abssrc)
491 491 target = repo.wjoin(abstarget)
492 492 if prevsrc is not None:
493 493 ui.warn(_('%s: not overwriting - %s collides with %s\n') %
494 494 (reltarget, repo.pathto(abssrc, cwd),
495 495 repo.pathto(prevsrc, cwd)))
496 496 return
497 497 if (not opts['after'] and os.path.exists(target) or
498 498 opts['after'] and repo.dirstate.state(abstarget) not in '?ar'):
499 499 if not opts['force']:
500 500 ui.warn(_('%s: not overwriting - file exists\n') %
501 501 reltarget)
502 502 return
503 503 if not opts['after'] and not opts.get('dry_run'):
504 504 os.unlink(target)
505 505 if opts['after']:
506 506 if not os.path.exists(target):
507 507 return
508 508 else:
509 509 targetdir = os.path.dirname(target) or '.'
510 510 if not os.path.isdir(targetdir) and not opts.get('dry_run'):
511 511 os.makedirs(targetdir)
512 512 try:
513 513 restore = repo.dirstate.state(abstarget) == 'r'
514 514 if restore and not opts.get('dry_run'):
515 515 repo.undelete([abstarget], wlock)
516 516 try:
517 517 if not opts.get('dry_run'):
518 518 util.copyfile(src, target)
519 519 restore = False
520 520 finally:
521 521 if restore:
522 522 repo.remove([abstarget], wlock=wlock)
523 523 except IOError, inst:
524 524 if inst.errno == errno.ENOENT:
525 525 ui.warn(_('%s: deleted in working copy\n') % relsrc)
526 526 else:
527 527 ui.warn(_('%s: cannot copy - %s\n') %
528 528 (relsrc, inst.strerror))
529 529 errors += 1
530 530 return
531 531 if ui.verbose or not exact:
532 532 ui.status(_('copying %s to %s\n') % (relsrc, reltarget))
533 533 targets[abstarget] = abssrc
534 534 if abstarget != origsrc:
535 535 if repo.dirstate.state(origsrc) == 'a':
536 536 if not ui.quiet:
537 537 ui.warn(_("%s has not been committed yet, so no copy "
538 538 "data will be stored for %s.\n")
539 539 % (repo.pathto(origsrc, cwd), reltarget))
540 540 if abstarget not in repo.dirstate and not opts.get('dry_run'):
541 541 repo.add([abstarget], wlock)
542 542 elif not opts.get('dry_run'):
543 543 repo.copy(origsrc, abstarget, wlock)
544 544 copied.append((abssrc, relsrc, exact))
545 545
546 546 # pat: ossep
547 547 # dest ossep
548 548 # srcs: list of (hgsep, hgsep, ossep, bool)
549 549 # return: function that takes hgsep and returns ossep
550 550 def targetpathfn(pat, dest, srcs):
551 551 if os.path.isdir(pat):
552 552 abspfx = util.canonpath(repo.root, cwd, pat)
553 553 abspfx = util.localpath(abspfx)
554 554 if destdirexists:
555 555 striplen = len(os.path.split(abspfx)[0])
556 556 else:
557 557 striplen = len(abspfx)
558 558 if striplen:
559 559 striplen += len(os.sep)
560 560 res = lambda p: os.path.join(dest, util.localpath(p)[striplen:])
561 561 elif destdirexists:
562 562 res = lambda p: os.path.join(dest,
563 563 os.path.basename(util.localpath(p)))
564 564 else:
565 565 res = lambda p: dest
566 566 return res
567 567
568 568 # pat: ossep
569 569 # dest ossep
570 570 # srcs: list of (hgsep, hgsep, ossep, bool)
571 571 # return: function that takes hgsep and returns ossep
572 572 def targetpathafterfn(pat, dest, srcs):
573 573 if util.patkind(pat, None)[0]:
574 574 # a mercurial pattern
575 575 res = lambda p: os.path.join(dest,
576 576 os.path.basename(util.localpath(p)))
577 577 else:
578 578 abspfx = util.canonpath(repo.root, cwd, pat)
579 579 if len(abspfx) < len(srcs[0][0]):
580 580 # A directory. Either the target path contains the last
581 581 # component of the source path or it does not.
582 582 def evalpath(striplen):
583 583 score = 0
584 584 for s in srcs:
585 585 t = os.path.join(dest, util.localpath(s[0])[striplen:])
586 586 if os.path.exists(t):
587 587 score += 1
588 588 return score
589 589
590 590 abspfx = util.localpath(abspfx)
591 591 striplen = len(abspfx)
592 592 if striplen:
593 593 striplen += len(os.sep)
594 594 if os.path.isdir(os.path.join(dest, os.path.split(abspfx)[1])):
595 595 score = evalpath(striplen)
596 596 striplen1 = len(os.path.split(abspfx)[0])
597 597 if striplen1:
598 598 striplen1 += len(os.sep)
599 599 if evalpath(striplen1) > score:
600 600 striplen = striplen1
601 601 res = lambda p: os.path.join(dest,
602 602 util.localpath(p)[striplen:])
603 603 else:
604 604 # a file
605 605 if destdirexists:
606 606 res = lambda p: os.path.join(dest,
607 607 os.path.basename(util.localpath(p)))
608 608 else:
609 609 res = lambda p: dest
610 610 return res
611 611
612 612
613 613 pats = util.expand_glob(pats)
614 614 if not pats:
615 615 raise util.Abort(_('no source or destination specified'))
616 616 if len(pats) == 1:
617 617 raise util.Abort(_('no destination specified'))
618 618 dest = pats.pop()
619 619 destdirexists = os.path.isdir(dest)
620 620 if (len(pats) > 1 or util.patkind(pats[0], None)[0]) and not destdirexists:
621 621 raise util.Abort(_('with multiple sources, destination must be an '
622 622 'existing directory'))
623 623 if opts['after']:
624 624 tfn = targetpathafterfn
625 625 else:
626 626 tfn = targetpathfn
627 627 copylist = []
628 628 for pat in pats:
629 629 srcs = []
630 630 for tag, abssrc, relsrc, exact in cmdutil.walk(repo, [pat], opts,
631 631 globbed=True):
632 632 origsrc = okaytocopy(abssrc, relsrc, exact)
633 633 if origsrc:
634 634 srcs.append((origsrc, abssrc, relsrc, exact))
635 635 if not srcs:
636 636 continue
637 637 copylist.append((tfn(pat, dest, srcs), srcs))
638 638 if not copylist:
639 639 raise util.Abort(_('no files to copy'))
640 640
641 641 for targetpath, srcs in copylist:
642 642 for origsrc, abssrc, relsrc, exact in srcs:
643 643 copy(origsrc, abssrc, relsrc, targetpath(abssrc), exact)
644 644
645 645 if errors:
646 646 ui.warn(_('(consider using --after)\n'))
647 647 return errors, copied
648 648
649 649 def copy(ui, repo, *pats, **opts):
650 650 """mark files as copied for the next commit
651 651
652 652 Mark dest as having copies of source files. If dest is a
653 653 directory, copies are put in that directory. If dest is a file,
654 654 there can only be one source.
655 655
656 656 By default, this command copies the contents of files as they
657 657 stand in the working directory. If invoked with --after, the
658 658 operation is recorded, but no copying is performed.
659 659
660 660 This command takes effect in the next commit. To undo a copy
661 661 before that, see hg revert.
662 662 """
663 663 wlock = repo.wlock(0)
664 664 errs, copied = docopy(ui, repo, pats, opts, wlock)
665 665 return errs
666 666
667 667 def debugancestor(ui, index, rev1, rev2):
668 668 """find the ancestor revision of two revisions in a given index"""
669 669 r = revlog.revlog(util.opener(os.getcwd(), audit=False), index)
670 670 a = r.ancestor(r.lookup(rev1), r.lookup(rev2))
671 671 ui.write("%d:%s\n" % (r.rev(a), hex(a)))
672 672
673 673 def debugcomplete(ui, cmd='', **opts):
674 674 """returns the completion list associated with the given command"""
675 675
676 676 if opts['options']:
677 677 options = []
678 678 otables = [globalopts]
679 679 if cmd:
680 680 aliases, entry = cmdutil.findcmd(ui, cmd)
681 681 otables.append(entry[1])
682 682 for t in otables:
683 683 for o in t:
684 684 if o[0]:
685 685 options.append('-%s' % o[0])
686 686 options.append('--%s' % o[1])
687 687 ui.write("%s\n" % "\n".join(options))
688 688 return
689 689
690 690 clist = cmdutil.findpossible(ui, cmd).keys()
691 691 clist.sort()
692 692 ui.write("%s\n" % "\n".join(clist))
693 693
694 694 def debugrebuildstate(ui, repo, rev=""):
695 695 """rebuild the dirstate as it would look like for the given revision"""
696 696 if rev == "":
697 697 rev = repo.changelog.tip()
698 698 ctx = repo.changectx(rev)
699 699 files = ctx.manifest()
700 700 wlock = repo.wlock()
701 701 repo.dirstate.rebuild(rev, files)
702 702
703 703 def debugcheckstate(ui, repo):
704 704 """validate the correctness of the current dirstate"""
705 705 parent1, parent2 = repo.dirstate.parents()
706 706 dc = repo.dirstate
707 707 m1 = repo.changectx(parent1).manifest()
708 708 m2 = repo.changectx(parent2).manifest()
709 709 errors = 0
710 710 for f in dc:
711 711 state = repo.dirstate.state(f)
712 712 if state in "nr" and f not in m1:
713 713 ui.warn(_("%s in state %s, but not in manifest1\n") % (f, state))
714 714 errors += 1
715 715 if state in "a" and f in m1:
716 716 ui.warn(_("%s in state %s, but also in manifest1\n") % (f, state))
717 717 errors += 1
718 718 if state in "m" and f not in m1 and f not in m2:
719 719 ui.warn(_("%s in state %s, but not in either manifest\n") %
720 720 (f, state))
721 721 errors += 1
722 722 for f in m1:
723 723 state = repo.dirstate.state(f)
724 724 if state not in "nrm":
725 725 ui.warn(_("%s in manifest1, but listed as state %s") % (f, state))
726 726 errors += 1
727 727 if errors:
728 728 error = _(".hg/dirstate inconsistent with current parent's manifest")
729 729 raise util.Abort(error)
730 730
731 731 def showconfig(ui, repo, *values, **opts):
732 732 """show combined config settings from all hgrc files
733 733
734 734 With no args, print names and values of all config items.
735 735
736 736 With one arg of the form section.name, print just the value of
737 737 that config item.
738 738
739 739 With multiple args, print names and values of all config items
740 740 with matching section names."""
741 741
742 742 untrusted = bool(opts.get('untrusted'))
743 743 if values:
744 744 if len([v for v in values if '.' in v]) > 1:
745 745 raise util.Abort(_('only one config item permitted'))
746 746 for section, name, value in ui.walkconfig(untrusted=untrusted):
747 747 sectname = section + '.' + name
748 748 if values:
749 749 for v in values:
750 750 if v == section:
751 751 ui.write('%s=%s\n' % (sectname, value))
752 752 elif v == sectname:
753 753 ui.write(value, '\n')
754 754 else:
755 755 ui.write('%s=%s\n' % (sectname, value))
756 756
757 757 def debugsetparents(ui, repo, rev1, rev2=None):
758 758 """manually set the parents of the current working directory
759 759
760 760 This is useful for writing repository conversion tools, but should
761 761 be used with care.
762 762 """
763 763
764 764 if not rev2:
765 765 rev2 = hex(nullid)
766 766
767 767 wlock = repo.wlock()
768 768 try:
769 769 repo.dirstate.setparents(repo.lookup(rev1), repo.lookup(rev2))
770 770 finally:
771 771 wlock.release()
772 772
773 773 def debugstate(ui, repo):
774 774 """show the contents of the current dirstate"""
775 775 dc = repo.dirstate
776 776 for file_ in dc:
777 777 if dc[file_][3] == -1:
778 778 # Pad or slice to locale representation
779 779 locale_len = len(time.strftime("%x %X", time.localtime(0)))
780 780 timestr = 'unset'
781 781 timestr = timestr[:locale_len] + ' '*(locale_len - len(timestr))
782 782 else:
783 783 timestr = time.strftime("%x %X", time.localtime(dc[file_][3]))
784 784 ui.write("%c %3o %10d %s %s\n"
785 785 % (dc[file_][0], dc[file_][1] & 0777, dc[file_][2],
786 786 timestr, file_))
787 787 for f in repo.dirstate.copies():
788 788 ui.write(_("copy: %s -> %s\n") % (repo.dirstate.copied(f), f))
789 789
790 790 def debugdata(ui, file_, rev):
791 791 """dump the contents of a data file revision"""
792 792 r = revlog.revlog(util.opener(os.getcwd(), audit=False), file_[:-2] + ".i")
793 793 try:
794 794 ui.write(r.revision(r.lookup(rev)))
795 795 except KeyError:
796 796 raise util.Abort(_('invalid revision identifier %s') % rev)
797 797
798 798 def debugdate(ui, date, range=None, **opts):
799 799 """parse and display a date"""
800 800 if opts["extended"]:
801 801 d = util.parsedate(date, util.extendeddateformats)
802 802 else:
803 803 d = util.parsedate(date)
804 804 ui.write("internal: %s %s\n" % d)
805 805 ui.write("standard: %s\n" % util.datestr(d))
806 806 if range:
807 807 m = util.matchdate(range)
808 808 ui.write("match: %s\n" % m(d[0]))
809 809
810 810 def debugindex(ui, file_):
811 811 """dump the contents of an index file"""
812 812 r = revlog.revlog(util.opener(os.getcwd(), audit=False), file_)
813 813 ui.write(" rev offset length base linkrev" +
814 814 " nodeid p1 p2\n")
815 815 for i in xrange(r.count()):
816 816 node = r.node(i)
817 817 pp = r.parents(node)
818 818 ui.write("% 6d % 9d % 7d % 6d % 7d %s %s %s\n" % (
819 819 i, r.start(i), r.length(i), r.base(i), r.linkrev(node),
820 820 short(node), short(pp[0]), short(pp[1])))
821 821
822 822 def debugindexdot(ui, file_):
823 823 """dump an index DAG as a .dot file"""
824 824 r = revlog.revlog(util.opener(os.getcwd(), audit=False), file_)
825 825 ui.write("digraph G {\n")
826 826 for i in xrange(r.count()):
827 827 node = r.node(i)
828 828 pp = r.parents(node)
829 829 ui.write("\t%d -> %d\n" % (r.rev(pp[0]), i))
830 830 if pp[1] != nullid:
831 831 ui.write("\t%d -> %d\n" % (r.rev(pp[1]), i))
832 832 ui.write("}\n")
833 833
834 834 def debuginstall(ui):
835 835 '''test Mercurial installation'''
836 836
837 837 def writetemp(contents):
838 838 (fd, name) = tempfile.mkstemp()
839 839 f = os.fdopen(fd, "wb")
840 840 f.write(contents)
841 841 f.close()
842 842 return name
843 843
844 844 problems = 0
845 845
846 846 # encoding
847 847 ui.status(_("Checking encoding (%s)...\n") % util._encoding)
848 848 try:
849 849 util.fromlocal("test")
850 850 except util.Abort, inst:
851 851 ui.write(" %s\n" % inst)
852 852 ui.write(_(" (check that your locale is properly set)\n"))
853 853 problems += 1
854 854
855 855 # compiled modules
856 856 ui.status(_("Checking extensions...\n"))
857 857 try:
858 858 import bdiff, mpatch, base85
859 859 except Exception, inst:
860 860 ui.write(" %s\n" % inst)
861 861 ui.write(_(" One or more extensions could not be found"))
862 862 ui.write(_(" (check that you compiled the extensions)\n"))
863 863 problems += 1
864 864
865 865 # templates
866 866 ui.status(_("Checking templates...\n"))
867 867 try:
868 868 import templater
869 869 t = templater.templater(templater.templatepath("map-cmdline.default"))
870 870 except Exception, inst:
871 871 ui.write(" %s\n" % inst)
872 872 ui.write(_(" (templates seem to have been installed incorrectly)\n"))
873 873 problems += 1
874 874
875 875 # patch
876 876 ui.status(_("Checking patch...\n"))
877 877 patcher = ui.config('ui', 'patch')
878 878 patcher = ((patcher and util.find_exe(patcher)) or
879 879 util.find_exe('gpatch') or
880 880 util.find_exe('patch'))
881 881 if not patcher:
882 882 ui.write(_(" Can't find patch or gpatch in PATH\n"))
883 883 ui.write(_(" (specify a patch utility in your .hgrc file)\n"))
884 884 problems += 1
885 885 else:
886 886 # actually attempt a patch here
887 887 a = "1\n2\n3\n4\n"
888 888 b = "1\n2\n3\ninsert\n4\n"
889 889 fa = writetemp(a)
890 890 d = mdiff.unidiff(a, None, b, None, os.path.basename(fa))
891 891 fd = writetemp(d)
892 892
893 893 files = {}
894 894 try:
895 895 patch.patch(fd, ui, cwd=os.path.dirname(fa), files=files)
896 896 except util.Abort, e:
897 897 ui.write(_(" patch call failed:\n"))
898 898 ui.write(" " + str(e) + "\n")
899 899 problems += 1
900 900 else:
901 901 if list(files) != [os.path.basename(fa)]:
902 902 ui.write(_(" unexpected patch output!"))
903 903 ui.write(_(" (you may have an incompatible version of patch)\n"))
904 904 problems += 1
905 905 a = file(fa).read()
906 906 if a != b:
907 907 ui.write(_(" patch test failed!"))
908 908 ui.write(_(" (you may have an incompatible version of patch)\n"))
909 909 problems += 1
910 910
911 911 os.unlink(fa)
912 912 os.unlink(fd)
913 913
914 914 # merge helper
915 915 ui.status(_("Checking merge helper...\n"))
916 916 cmd = (os.environ.get("HGMERGE") or ui.config("ui", "merge")
917 917 or "hgmerge")
918 918 cmdpath = util.find_exe(cmd) or util.find_exe(cmd.split()[0])
919 919 if not cmdpath:
920 920 if cmd == 'hgmerge':
921 921 ui.write(_(" No merge helper set and can't find default"
922 922 " hgmerge script in PATH\n"))
923 923 ui.write(_(" (specify a merge helper in your .hgrc file)\n"))
924 924 else:
925 925 ui.write(_(" Can't find merge helper '%s' in PATH\n") % cmd)
926 926 ui.write(_(" (specify a merge helper in your .hgrc file)\n"))
927 927 problems += 1
928 928 else:
929 929 # actually attempt a patch here
930 930 fa = writetemp("1\n2\n3\n4\n")
931 931 fl = writetemp("1\n2\n3\ninsert\n4\n")
932 932 fr = writetemp("begin\n1\n2\n3\n4\n")
933 933 r = util.system('%s "%s" "%s" "%s"' % (cmd, fl, fa, fr))
934 934 if r:
935 935 ui.write(_(" Got unexpected merge error %d!\n") % r)
936 936 problems += 1
937 937 m = file(fl).read()
938 938 if m != "begin\n1\n2\n3\ninsert\n4\n":
939 939 ui.write(_(" Got unexpected merge results!\n"))
940 940 ui.write(_(" (your merge helper may have the"
941 941 " wrong argument order)\n"))
942 942 ui.write(_(" Result: %r\n") % m)
943 943 problems += 1
944 944 os.unlink(fa)
945 945 os.unlink(fl)
946 946 os.unlink(fr)
947 947
948 948 # editor
949 949 ui.status(_("Checking commit editor...\n"))
950 950 editor = (os.environ.get("HGEDITOR") or
951 951 ui.config("ui", "editor") or
952 952 os.environ.get("EDITOR", "vi"))
953 953 cmdpath = util.find_exe(editor) or util.find_exe(editor.split()[0])
954 954 if not cmdpath:
955 955 if editor == 'vi':
956 956 ui.write(_(" No commit editor set and can't find vi in PATH\n"))
957 957 ui.write(_(" (specify a commit editor in your .hgrc file)\n"))
958 958 else:
959 959 ui.write(_(" Can't find editor '%s' in PATH\n") % editor)
960 960 ui.write(_(" (specify a commit editor in your .hgrc file)\n"))
961 961 problems += 1
962 962
963 963 # check username
964 964 ui.status(_("Checking username...\n"))
965 965 user = os.environ.get("HGUSER")
966 966 if user is None:
967 967 user = ui.config("ui", "username")
968 968 if user is None:
969 969 user = os.environ.get("EMAIL")
970 970 if not user:
971 971 ui.warn(" ")
972 972 ui.username()
973 973 ui.write(_(" (specify a username in your .hgrc file)\n"))
974 974
975 975 if not problems:
976 976 ui.status(_("No problems detected\n"))
977 977 else:
978 978 ui.write(_("%s problems detected,"
979 979 " please check your install!\n") % problems)
980 980
981 981 return problems
982 982
983 983 def debugrename(ui, repo, file1, *pats, **opts):
984 984 """dump rename information"""
985 985
986 986 ctx = repo.changectx(opts.get('rev', 'tip'))
987 987 for src, abs, rel, exact in cmdutil.walk(repo, (file1,) + pats, opts,
988 988 ctx.node()):
989 989 m = ctx.filectx(abs).renamed()
990 990 if m:
991 991 ui.write(_("%s renamed from %s:%s\n") % (rel, m[0], hex(m[1])))
992 992 else:
993 993 ui.write(_("%s not renamed\n") % rel)
994 994
995 995 def debugwalk(ui, repo, *pats, **opts):
996 996 """show how files match on given patterns"""
997 997 items = list(cmdutil.walk(repo, pats, opts))
998 998 if not items:
999 999 return
1000 1000 fmt = '%%s %%-%ds %%-%ds %%s' % (
1001 1001 max([len(abs) for (src, abs, rel, exact) in items]),
1002 1002 max([len(rel) for (src, abs, rel, exact) in items]))
1003 1003 for src, abs, rel, exact in items:
1004 1004 line = fmt % (src, abs, rel, exact and 'exact' or '')
1005 1005 ui.write("%s\n" % line.rstrip())
1006 1006
1007 1007 def diff(ui, repo, *pats, **opts):
1008 1008 """diff repository (or selected files)
1009 1009
1010 1010 Show differences between revisions for the specified files.
1011 1011
1012 1012 Differences between files are shown using the unified diff format.
1013 1013
1014 1014 NOTE: diff may generate unexpected results for merges, as it will
1015 1015 default to comparing against the working directory's first parent
1016 1016 changeset if no revisions are specified.
1017 1017
1018 1018 When two revision arguments are given, then changes are shown
1019 1019 between those revisions. If only one revision is specified then
1020 1020 that revision is compared to the working directory, and, when no
1021 1021 revisions are specified, the working directory files are compared
1022 1022 to its parent.
1023 1023
1024 1024 Without the -a option, diff will avoid generating diffs of files
1025 1025 it detects as binary. With -a, diff will generate a diff anyway,
1026 1026 probably with undesirable results.
1027 1027 """
1028 1028 node1, node2 = cmdutil.revpair(repo, opts['rev'])
1029 1029
1030 1030 fns, matchfn, anypats = cmdutil.matchpats(repo, pats, opts)
1031 1031
1032 1032 patch.diff(repo, node1, node2, fns, match=matchfn,
1033 1033 opts=patch.diffopts(ui, opts))
1034 1034
1035 1035 def export(ui, repo, *changesets, **opts):
1036 1036 """dump the header and diffs for one or more changesets
1037 1037
1038 1038 Print the changeset header and diffs for one or more revisions.
1039 1039
1040 1040 The information shown in the changeset header is: author,
1041 1041 changeset hash, parent(s) and commit comment.
1042 1042
1043 1043 NOTE: export may generate unexpected diff output for merge changesets,
1044 1044 as it will compare the merge changeset against its first parent only.
1045 1045
1046 1046 Output may be to a file, in which case the name of the file is
1047 1047 given using a format string. The formatting rules are as follows:
1048 1048
1049 1049 %% literal "%" character
1050 1050 %H changeset hash (40 bytes of hexadecimal)
1051 1051 %N number of patches being generated
1052 1052 %R changeset revision number
1053 1053 %b basename of the exporting repository
1054 1054 %h short-form changeset hash (12 bytes of hexadecimal)
1055 1055 %n zero-padded sequence number, starting at 1
1056 1056 %r zero-padded changeset revision number
1057 1057
1058 1058 Without the -a option, export will avoid generating diffs of files
1059 1059 it detects as binary. With -a, export will generate a diff anyway,
1060 1060 probably with undesirable results.
1061 1061
1062 1062 With the --switch-parent option, the diff will be against the second
1063 1063 parent. It can be useful to review a merge.
1064 1064 """
1065 1065 if not changesets:
1066 1066 raise util.Abort(_("export requires at least one changeset"))
1067 1067 revs = cmdutil.revrange(repo, changesets)
1068 1068 if len(revs) > 1:
1069 1069 ui.note(_('exporting patches:\n'))
1070 1070 else:
1071 1071 ui.note(_('exporting patch:\n'))
1072 1072 patch.export(repo, revs, template=opts['output'],
1073 1073 switch_parent=opts['switch_parent'],
1074 1074 opts=patch.diffopts(ui, opts))
1075 1075
1076 1076 def grep(ui, repo, pattern, *pats, **opts):
1077 1077 """search for a pattern in specified files and revisions
1078 1078
1079 1079 Search revisions of files for a regular expression.
1080 1080
1081 1081 This command behaves differently than Unix grep. It only accepts
1082 1082 Python/Perl regexps. It searches repository history, not the
1083 1083 working directory. It always prints the revision number in which
1084 1084 a match appears.
1085 1085
1086 1086 By default, grep only prints output for the first revision of a
1087 1087 file in which it finds a match. To get it to print every revision
1088 1088 that contains a change in match status ("-" for a match that
1089 1089 becomes a non-match, or "+" for a non-match that becomes a match),
1090 1090 use the --all flag.
1091 1091 """
1092 1092 reflags = 0
1093 1093 if opts['ignore_case']:
1094 1094 reflags |= re.I
1095 1095 try:
1096 1096 regexp = re.compile(pattern, reflags)
1097 1097 except Exception, inst:
1098 1098 ui.warn(_("grep: invalid match pattern: %s!\n") % inst)
1099 1099 return None
1100 1100 sep, eol = ':', '\n'
1101 1101 if opts['print0']:
1102 1102 sep = eol = '\0'
1103 1103
1104 1104 fcache = {}
1105 1105 def getfile(fn):
1106 1106 if fn not in fcache:
1107 1107 fcache[fn] = repo.file(fn)
1108 1108 return fcache[fn]
1109 1109
1110 1110 def matchlines(body):
1111 1111 begin = 0
1112 1112 linenum = 0
1113 1113 while True:
1114 1114 match = regexp.search(body, begin)
1115 1115 if not match:
1116 1116 break
1117 1117 mstart, mend = match.span()
1118 1118 linenum += body.count('\n', begin, mstart) + 1
1119 1119 lstart = body.rfind('\n', begin, mstart) + 1 or begin
1120 1120 lend = body.find('\n', mend)
1121 1121 yield linenum, mstart - lstart, mend - lstart, body[lstart:lend]
1122 1122 begin = lend + 1
1123 1123
1124 1124 class linestate(object):
1125 1125 def __init__(self, line, linenum, colstart, colend):
1126 1126 self.line = line
1127 1127 self.linenum = linenum
1128 1128 self.colstart = colstart
1129 1129 self.colend = colend
1130 1130
1131 1131 def __eq__(self, other):
1132 1132 return self.line == other.line
1133 1133
1134 1134 matches = {}
1135 1135 copies = {}
1136 1136 def grepbody(fn, rev, body):
1137 1137 matches[rev].setdefault(fn, [])
1138 1138 m = matches[rev][fn]
1139 1139 for lnum, cstart, cend, line in matchlines(body):
1140 1140 s = linestate(line, lnum, cstart, cend)
1141 1141 m.append(s)
1142 1142
1143 1143 def difflinestates(a, b):
1144 1144 sm = difflib.SequenceMatcher(None, a, b)
1145 1145 for tag, alo, ahi, blo, bhi in sm.get_opcodes():
1146 1146 if tag == 'insert':
1147 1147 for i in xrange(blo, bhi):
1148 1148 yield ('+', b[i])
1149 1149 elif tag == 'delete':
1150 1150 for i in xrange(alo, ahi):
1151 1151 yield ('-', a[i])
1152 1152 elif tag == 'replace':
1153 1153 for i in xrange(alo, ahi):
1154 1154 yield ('-', a[i])
1155 1155 for i in xrange(blo, bhi):
1156 1156 yield ('+', b[i])
1157 1157
1158 1158 prev = {}
1159 1159 def display(fn, rev, states, prevstates):
1160 1160 found = False
1161 1161 filerevmatches = {}
1162 1162 r = prev.get(fn, -1)
1163 1163 if opts['all']:
1164 1164 iter = difflinestates(states, prevstates)
1165 1165 else:
1166 1166 iter = [('', l) for l in prevstates]
1167 1167 for change, l in iter:
1168 1168 cols = [fn, str(r)]
1169 1169 if opts['line_number']:
1170 1170 cols.append(str(l.linenum))
1171 1171 if opts['all']:
1172 1172 cols.append(change)
1173 1173 if opts['user']:
1174 1174 cols.append(ui.shortuser(get(r)[1]))
1175 1175 if opts['files_with_matches']:
1176 1176 c = (fn, r)
1177 1177 if c in filerevmatches:
1178 1178 continue
1179 1179 filerevmatches[c] = 1
1180 1180 else:
1181 1181 cols.append(l.line)
1182 1182 ui.write(sep.join(cols), eol)
1183 1183 found = True
1184 1184 return found
1185 1185
1186 1186 fstate = {}
1187 1187 skip = {}
1188 1188 get = util.cachefunc(lambda r: repo.changectx(r).changeset())
1189 1189 changeiter, matchfn = cmdutil.walkchangerevs(ui, repo, pats, get, opts)
1190 1190 found = False
1191 1191 follow = opts.get('follow')
1192 1192 for st, rev, fns in changeiter:
1193 1193 if st == 'window':
1194 1194 matches.clear()
1195 1195 elif st == 'add':
1196 1196 mf = repo.changectx(rev).manifest()
1197 1197 matches[rev] = {}
1198 1198 for fn in fns:
1199 1199 if fn in skip:
1200 1200 continue
1201 1201 fstate.setdefault(fn, {})
1202 1202 try:
1203 1203 grepbody(fn, rev, getfile(fn).read(mf[fn]))
1204 1204 if follow:
1205 1205 copied = getfile(fn).renamed(mf[fn])
1206 1206 if copied:
1207 1207 copies.setdefault(rev, {})[fn] = copied[0]
1208 1208 except KeyError:
1209 1209 pass
1210 1210 elif st == 'iter':
1211 1211 states = matches[rev].items()
1212 1212 states.sort()
1213 1213 for fn, m in states:
1214 1214 copy = copies.get(rev, {}).get(fn)
1215 1215 if fn in skip:
1216 1216 if copy:
1217 1217 skip[copy] = True
1218 1218 continue
1219 1219 if fn in prev or fstate[fn]:
1220 1220 r = display(fn, rev, m, fstate[fn])
1221 1221 found = found or r
1222 1222 if r and not opts['all']:
1223 1223 skip[fn] = True
1224 1224 if copy:
1225 1225 skip[copy] = True
1226 1226 fstate[fn] = m
1227 1227 if copy:
1228 1228 fstate[copy] = m
1229 1229 prev[fn] = rev
1230 1230
1231 1231 fstate = fstate.items()
1232 1232 fstate.sort()
1233 1233 for fn, state in fstate:
1234 1234 if fn in skip:
1235 1235 continue
1236 1236 if fn not in copies.get(prev[fn], {}):
1237 1237 found = display(fn, rev, {}, state) or found
1238 1238 return (not found and 1) or 0
1239 1239
1240 1240 def heads(ui, repo, *branchrevs, **opts):
1241 1241 """show current repository heads or show branch heads
1242 1242
1243 1243 With no arguments, show all repository head changesets.
1244 1244
1245 1245 If branch or revisions names are given this will show the heads of
1246 1246 the specified branches or the branches those revisions are tagged
1247 1247 with.
1248 1248
1249 1249 Repository "heads" are changesets that don't have child
1250 1250 changesets. They are where development generally takes place and
1251 1251 are the usual targets for update and merge operations.
1252 1252
1253 1253 Branch heads are changesets that have a given branch tag, but have
1254 1254 no child changesets with that tag. They are usually where
1255 1255 development on the given branch takes place.
1256 1256 """
1257 1257 if opts['rev']:
1258 1258 start = repo.lookup(opts['rev'])
1259 1259 else:
1260 1260 start = None
1261 1261 if not branchrevs:
1262 1262 # Assume we're looking repo-wide heads if no revs were specified.
1263 1263 heads = repo.heads(start)
1264 1264 else:
1265 1265 heads = []
1266 1266 visitedset = util.set()
1267 1267 for branchrev in branchrevs:
1268 1268 branch = repo.changectx(branchrev).branch()
1269 1269 if branch in visitedset:
1270 1270 continue
1271 1271 visitedset.add(branch)
1272 1272 bheads = repo.branchheads(branch, start)
1273 1273 if not bheads:
1274 1274 if branch != branchrev:
1275 1275 ui.warn(_("no changes on branch %s containing %s are "
1276 1276 "reachable from %s\n")
1277 1277 % (branch, branchrev, opts['rev']))
1278 1278 else:
1279 1279 ui.warn(_("no changes on branch %s are reachable from %s\n")
1280 1280 % (branch, opts['rev']))
1281 1281 heads.extend(bheads)
1282 1282 if not heads:
1283 1283 return 1
1284 1284 displayer = cmdutil.show_changeset(ui, repo, opts)
1285 1285 for n in heads:
1286 1286 displayer.show(changenode=n)
1287 1287
1288 1288 def help_(ui, name=None, with_version=False):
1289 1289 """show help for a command, extension, or list of commands
1290 1290
1291 1291 With no arguments, print a list of commands and short help.
1292 1292
1293 1293 Given a command name, print help for that command.
1294 1294
1295 1295 Given an extension name, print help for that extension, and the
1296 1296 commands it provides."""
1297 1297 option_lists = []
1298 1298
1299 1299 def addglobalopts(aliases):
1300 1300 if ui.verbose:
1301 1301 option_lists.append((_("global options:"), globalopts))
1302 1302 if name == 'shortlist':
1303 1303 option_lists.append((_('use "hg help" for the full list '
1304 1304 'of commands'), ()))
1305 1305 else:
1306 1306 if name == 'shortlist':
1307 1307 msg = _('use "hg help" for the full list of commands '
1308 1308 'or "hg -v" for details')
1309 1309 elif aliases:
1310 1310 msg = _('use "hg -v help%s" to show aliases and '
1311 1311 'global options') % (name and " " + name or "")
1312 1312 else:
1313 1313 msg = _('use "hg -v help %s" to show global options') % name
1314 1314 option_lists.append((msg, ()))
1315 1315
1316 1316 def helpcmd(name):
1317 1317 if with_version:
1318 1318 version_(ui)
1319 1319 ui.write('\n')
1320 1320 aliases, i = cmdutil.findcmd(ui, name)
1321 1321 # synopsis
1322 1322 ui.write("%s\n\n" % i[2])
1323 1323
1324 1324 # description
1325 1325 doc = i[0].__doc__
1326 1326 if not doc:
1327 1327 doc = _("(No help text available)")
1328 1328 if ui.quiet:
1329 1329 doc = doc.splitlines(0)[0]
1330 1330 ui.write("%s\n" % doc.rstrip())
1331 1331
1332 1332 if not ui.quiet:
1333 1333 # aliases
1334 1334 if len(aliases) > 1:
1335 1335 ui.write(_("\naliases: %s\n") % ', '.join(aliases[1:]))
1336 1336
1337 1337 # options
1338 1338 if i[1]:
1339 1339 option_lists.append((_("options:\n"), i[1]))
1340 1340
1341 1341 addglobalopts(False)
1342 1342
1343 1343 def helplist(select=None):
1344 1344 h = {}
1345 1345 cmds = {}
1346 1346 for c, e in table.items():
1347 1347 f = c.split("|", 1)[0]
1348 1348 if select and not select(f):
1349 1349 continue
1350 1350 if name == "shortlist" and not f.startswith("^"):
1351 1351 continue
1352 1352 f = f.lstrip("^")
1353 1353 if not ui.debugflag and f.startswith("debug"):
1354 1354 continue
1355 1355 doc = e[0].__doc__
1356 1356 if not doc:
1357 1357 doc = _("(No help text available)")
1358 1358 h[f] = doc.splitlines(0)[0].rstrip()
1359 1359 cmds[f] = c.lstrip("^")
1360 1360
1361 1361 fns = h.keys()
1362 1362 fns.sort()
1363 1363 m = max(map(len, fns))
1364 1364 for f in fns:
1365 1365 if ui.verbose:
1366 1366 commands = cmds[f].replace("|",", ")
1367 1367 ui.write(" %s:\n %s\n"%(commands, h[f]))
1368 1368 else:
1369 1369 ui.write(' %-*s %s\n' % (m, f, h[f]))
1370 1370
1371 1371 if not ui.quiet:
1372 1372 addglobalopts(True)
1373 1373
1374 1374 def helptopic(name):
1375 1375 v = None
1376 1376 for i in help.helptable:
1377 1377 l = i.split('|')
1378 1378 if name in l:
1379 1379 v = i
1380 1380 header = l[-1]
1381 1381 if not v:
1382 1382 raise cmdutil.UnknownCommand(name)
1383 1383
1384 1384 # description
1385 1385 doc = help.helptable[v]
1386 1386 if not doc:
1387 1387 doc = _("(No help text available)")
1388 1388 if callable(doc):
1389 1389 doc = doc()
1390 1390
1391 1391 ui.write("%s\n" % header)
1392 1392 ui.write("%s\n" % doc.rstrip())
1393 1393
1394 1394 def helpext(name):
1395 1395 try:
1396 1396 mod = extensions.find(name)
1397 1397 except KeyError:
1398 1398 raise cmdutil.UnknownCommand(name)
1399 1399
1400 1400 doc = (mod.__doc__ or _('No help text available')).splitlines(0)
1401 1401 ui.write(_('%s extension - %s\n') % (name.split('.')[-1], doc[0]))
1402 1402 for d in doc[1:]:
1403 1403 ui.write(d, '\n')
1404 1404
1405 1405 ui.status('\n')
1406 1406
1407 1407 try:
1408 1408 ct = mod.cmdtable
1409 1409 except AttributeError:
1410 1410 ct = None
1411 1411 if not ct:
1412 1412 ui.status(_('no commands defined\n'))
1413 1413 return
1414 1414
1415 1415 ui.status(_('list of commands:\n\n'))
1416 1416 modcmds = dict.fromkeys([c.split('|', 1)[0] for c in ct])
1417 1417 helplist(modcmds.has_key)
1418 1418
1419 1419 if name and name != 'shortlist':
1420 1420 i = None
1421 1421 for f in (helpcmd, helptopic, helpext):
1422 1422 try:
1423 1423 f(name)
1424 1424 i = None
1425 1425 break
1426 1426 except cmdutil.UnknownCommand, inst:
1427 1427 i = inst
1428 1428 if i:
1429 1429 raise i
1430 1430
1431 1431 else:
1432 1432 # program name
1433 1433 if ui.verbose or with_version:
1434 1434 version_(ui)
1435 1435 else:
1436 1436 ui.status(_("Mercurial Distributed SCM\n"))
1437 1437 ui.status('\n')
1438 1438
1439 1439 # list of commands
1440 1440 if name == "shortlist":
1441 1441 ui.status(_('basic commands:\n\n'))
1442 1442 else:
1443 1443 ui.status(_('list of commands:\n\n'))
1444 1444
1445 1445 helplist()
1446 1446
1447 1447 # list all option lists
1448 1448 opt_output = []
1449 1449 for title, options in option_lists:
1450 1450 opt_output.append(("\n%s" % title, None))
1451 1451 for shortopt, longopt, default, desc in options:
1452 1452 if "DEPRECATED" in desc and not ui.verbose: continue
1453 1453 opt_output.append(("%2s%s" % (shortopt and "-%s" % shortopt,
1454 1454 longopt and " --%s" % longopt),
1455 1455 "%s%s" % (desc,
1456 1456 default
1457 1457 and _(" (default: %s)") % default
1458 1458 or "")))
1459 1459
1460 1460 if opt_output:
1461 1461 opts_len = max([len(line[0]) for line in opt_output if line[1]] or [0])
1462 1462 for first, second in opt_output:
1463 1463 if second:
1464 1464 ui.write(" %-*s %s\n" % (opts_len, first, second))
1465 1465 else:
1466 1466 ui.write("%s\n" % first)
1467 1467
1468 1468 def identify(ui, repo, source=None,
1469 1469 rev=None, num=None, id=None, branch=None, tags=None):
1470 1470 """identify the working copy or specified revision
1471 1471
1472 1472 With no revision, print a summary of the current state of the repo.
1473 1473
1474 1474 With a path, do a lookup in another repository.
1475 1475
1476 1476 This summary identifies the repository state using one or two parent
1477 1477 hash identifiers, followed by a "+" if there are uncommitted changes
1478 1478 in the working directory, a list of tags for this revision and a branch
1479 1479 name for non-default branches.
1480 1480 """
1481 1481
1482 1482 hexfunc = ui.debugflag and hex or short
1483 1483 default = not (num or id or branch or tags)
1484 1484 output = []
1485 1485
1486 1486 if source:
1487 1487 source, revs = cmdutil.parseurl(ui.expandpath(source), [])
1488 1488 srepo = hg.repository(ui, source)
1489 1489 if not rev and revs:
1490 1490 rev = revs[0]
1491 1491 if not rev:
1492 1492 rev = "tip"
1493 1493 if num or branch or tags:
1494 1494 raise util.Abort(
1495 1495 "can't query remote revision number, branch, or tags")
1496 1496 output = [hexfunc(srepo.lookup(rev))]
1497 1497 elif not rev:
1498 1498 ctx = repo.workingctx()
1499 1499 parents = ctx.parents()
1500 1500 changed = False
1501 1501 if default or id or num:
1502 1502 changed = ctx.files() + ctx.deleted()
1503 1503 if default or id:
1504 1504 output = ["%s%s" % ('+'.join([hexfunc(p.node()) for p in parents]),
1505 1505 (changed) and "+" or "")]
1506 1506 if num:
1507 1507 output.append("%s%s" % ('+'.join([str(p.rev()) for p in parents]),
1508 1508 (changed) and "+" or ""))
1509 1509 else:
1510 1510 ctx = repo.changectx(rev)
1511 1511 if default or id:
1512 1512 output = [hexfunc(ctx.node())]
1513 1513 if num:
1514 1514 output.append(str(ctx.rev()))
1515 1515
1516 1516 if not source and default and not ui.quiet:
1517 1517 b = util.tolocal(ctx.branch())
1518 1518 if b != 'default':
1519 1519 output.append("(%s)" % b)
1520 1520
1521 1521 # multiple tags for a single parent separated by '/'
1522 1522 t = "/".join(ctx.tags())
1523 1523 if t:
1524 1524 output.append(t)
1525 1525
1526 1526 if branch:
1527 1527 output.append(util.tolocal(ctx.branch()))
1528 1528
1529 1529 if tags:
1530 1530 output.extend(ctx.tags())
1531 1531
1532 1532 ui.write("%s\n" % ' '.join(output))
1533 1533
1534 1534 def import_(ui, repo, patch1, *patches, **opts):
1535 1535 """import an ordered set of patches
1536 1536
1537 1537 Import a list of patches and commit them individually.
1538 1538
1539 1539 If there are outstanding changes in the working directory, import
1540 1540 will abort unless given the -f flag.
1541 1541
1542 1542 You can import a patch straight from a mail message. Even patches
1543 1543 as attachments work (body part must be type text/plain or
1544 1544 text/x-patch to be used). From and Subject headers of email
1545 1545 message are used as default committer and commit message. All
1546 1546 text/plain body parts before first diff are added to commit
1547 1547 message.
1548 1548
1549 1549 If the imported patch was generated by hg export, user and description
1550 1550 from patch override values from message headers and body. Values
1551 1551 given on command line with -m and -u override these.
1552 1552
1553 1553 If --exact is specified, import will set the working directory
1554 1554 to the parent of each patch before applying it, and will abort
1555 1555 if the resulting changeset has a different ID than the one
1556 1556 recorded in the patch. This may happen due to character set
1557 1557 problems or other deficiencies in the text patch format.
1558 1558
1559 1559 To read a patch from standard input, use patch name "-".
1560 1560 """
1561 1561 patches = (patch1,) + patches
1562 1562
1563 1563 if opts.get('exact') or not opts['force']:
1564 1564 cmdutil.bail_if_changed(repo)
1565 1565
1566 1566 d = opts["base"]
1567 1567 strip = opts["strip"]
1568 1568
1569 1569 wlock = repo.wlock()
1570 1570 lock = repo.lock()
1571 1571
1572 1572 for p in patches:
1573 1573 pf = os.path.join(d, p)
1574 1574
1575 1575 if pf == '-':
1576 1576 ui.status(_("applying patch from stdin\n"))
1577 1577 tmpname, message, user, date, branch, nodeid, p1, p2 = patch.extract(ui, sys.stdin)
1578 1578 else:
1579 1579 ui.status(_("applying %s\n") % p)
1580 1580 tmpname, message, user, date, branch, nodeid, p1, p2 = patch.extract(ui, file(pf, 'rb'))
1581 1581
1582 1582 if tmpname is None:
1583 1583 raise util.Abort(_('no diffs found'))
1584 1584
1585 1585 try:
1586 1586 cmdline_message = cmdutil.logmessage(opts)
1587 1587 if cmdline_message:
1588 1588 # pickup the cmdline msg
1589 1589 message = cmdline_message
1590 1590 elif message:
1591 1591 # pickup the patch msg
1592 1592 message = message.strip()
1593 1593 else:
1594 1594 # launch the editor
1595 1595 message = None
1596 1596 ui.debug(_('message:\n%s\n') % message)
1597 1597
1598 1598 wp = repo.workingctx().parents()
1599 1599 if opts.get('exact'):
1600 1600 if not nodeid or not p1:
1601 1601 raise util.Abort(_('not a mercurial patch'))
1602 1602 p1 = repo.lookup(p1)
1603 1603 p2 = repo.lookup(p2 or hex(nullid))
1604 1604
1605 1605 if p1 != wp[0].node():
1606 1606 hg.clean(repo, p1, wlock=wlock)
1607 1607 repo.dirstate.setparents(p1, p2)
1608 1608 elif p2:
1609 1609 try:
1610 1610 p1 = repo.lookup(p1)
1611 1611 p2 = repo.lookup(p2)
1612 1612 if p1 == wp[0].node():
1613 1613 repo.dirstate.setparents(p1, p2)
1614 1614 except hg.RepoError:
1615 1615 pass
1616 1616 if opts.get('exact') or opts.get('import_branch'):
1617 1617 repo.dirstate.setbranch(branch or 'default')
1618 1618
1619 1619 files = {}
1620 1620 try:
1621 1621 fuzz = patch.patch(tmpname, ui, strip=strip, cwd=repo.root,
1622 1622 files=files)
1623 1623 finally:
1624 1624 files = patch.updatedir(ui, repo, files, wlock=wlock)
1625 1625 n = repo.commit(files, message, user, date, wlock=wlock, lock=lock)
1626 1626 if opts.get('exact'):
1627 1627 if hex(n) != nodeid:
1628 1628 repo.rollback(wlock=wlock, lock=lock)
1629 1629 raise util.Abort(_('patch is damaged or loses information'))
1630 1630 finally:
1631 1631 os.unlink(tmpname)
1632 1632
1633 1633 def incoming(ui, repo, source="default", **opts):
1634 1634 """show new changesets found in source
1635 1635
1636 1636 Show new changesets found in the specified path/URL or the default
1637 1637 pull location. These are the changesets that would be pulled if a pull
1638 1638 was requested.
1639 1639
1640 1640 For remote repository, using --bundle avoids downloading the changesets
1641 1641 twice if the incoming is followed by a pull.
1642 1642
1643 1643 See pull for valid source format details.
1644 1644 """
1645 1645 source, revs = cmdutil.parseurl(ui.expandpath(source), opts['rev'])
1646 1646 cmdutil.setremoteconfig(ui, opts)
1647 1647
1648 1648 other = hg.repository(ui, source)
1649 1649 ui.status(_('comparing with %s\n') % source)
1650 1650 if revs:
1651 1651 if 'lookup' in other.capabilities:
1652 1652 revs = [other.lookup(rev) for rev in revs]
1653 1653 else:
1654 1654 error = _("Other repository doesn't support revision lookup, so a rev cannot be specified.")
1655 1655 raise util.Abort(error)
1656 1656 incoming = repo.findincoming(other, heads=revs, force=opts["force"])
1657 1657 if not incoming:
1658 1658 try:
1659 1659 os.unlink(opts["bundle"])
1660 1660 except:
1661 1661 pass
1662 1662 ui.status(_("no changes found\n"))
1663 1663 return 1
1664 1664
1665 1665 cleanup = None
1666 1666 try:
1667 1667 fname = opts["bundle"]
1668 1668 if fname or not other.local():
1669 1669 # create a bundle (uncompressed if other repo is not local)
1670 1670 if revs is None:
1671 1671 cg = other.changegroup(incoming, "incoming")
1672 1672 else:
1673 1673 if 'changegroupsubset' not in other.capabilities:
1674 1674 raise util.Abort(_("Partial incoming cannot be done because other repository doesn't support changegroupsubset."))
1675 1675 cg = other.changegroupsubset(incoming, revs, 'incoming')
1676 1676 bundletype = other.local() and "HG10BZ" or "HG10UN"
1677 1677 fname = cleanup = changegroup.writebundle(cg, fname, bundletype)
1678 1678 # keep written bundle?
1679 1679 if opts["bundle"]:
1680 1680 cleanup = None
1681 1681 if not other.local():
1682 1682 # use the created uncompressed bundlerepo
1683 1683 other = bundlerepo.bundlerepository(ui, repo.root, fname)
1684 1684
1685 1685 o = other.changelog.nodesbetween(incoming, revs)[0]
1686 1686 if opts['newest_first']:
1687 1687 o.reverse()
1688 1688 displayer = cmdutil.show_changeset(ui, other, opts)
1689 1689 for n in o:
1690 1690 parents = [p for p in other.changelog.parents(n) if p != nullid]
1691 1691 if opts['no_merges'] and len(parents) == 2:
1692 1692 continue
1693 1693 displayer.show(changenode=n)
1694 1694 finally:
1695 1695 if hasattr(other, 'close'):
1696 1696 other.close()
1697 1697 if cleanup:
1698 1698 os.unlink(cleanup)
1699 1699
1700 1700 def init(ui, dest=".", **opts):
1701 1701 """create a new repository in the given directory
1702 1702
1703 1703 Initialize a new repository in the given directory. If the given
1704 1704 directory does not exist, it is created.
1705 1705
1706 1706 If no directory is given, the current directory is used.
1707 1707
1708 1708 It is possible to specify an ssh:// URL as the destination.
1709 1709 Look at the help text for the pull command for important details
1710 1710 about ssh:// URLs.
1711 1711 """
1712 1712 cmdutil.setremoteconfig(ui, opts)
1713 1713 hg.repository(ui, dest, create=1)
1714 1714
1715 1715 def locate(ui, repo, *pats, **opts):
1716 1716 """locate files matching specific patterns
1717 1717
1718 1718 Print all files under Mercurial control whose names match the
1719 1719 given patterns.
1720 1720
1721 1721 This command searches the entire repository by default. To search
1722 1722 just the current directory and its subdirectories, use
1723 1723 "--include .".
1724 1724
1725 1725 If no patterns are given to match, this command prints all file
1726 1726 names.
1727 1727
1728 1728 If you want to feed the output of this command into the "xargs"
1729 1729 command, use the "-0" option to both this command and "xargs".
1730 1730 This will avoid the problem of "xargs" treating single filenames
1731 1731 that contain white space as multiple filenames.
1732 1732 """
1733 1733 end = opts['print0'] and '\0' or '\n'
1734 1734 rev = opts['rev']
1735 1735 if rev:
1736 1736 node = repo.lookup(rev)
1737 1737 else:
1738 1738 node = None
1739 1739
1740 1740 ret = 1
1741 1741 for src, abs, rel, exact in cmdutil.walk(repo, pats, opts, node=node,
1742 1742 badmatch=util.always,
1743 1743 default='relglob'):
1744 1744 if src == 'b':
1745 1745 continue
1746 1746 if not node and repo.dirstate.state(abs) == '?':
1747 1747 continue
1748 1748 if opts['fullpath']:
1749 1749 ui.write(os.path.join(repo.root, abs), end)
1750 1750 else:
1751 1751 ui.write(((pats and rel) or abs), end)
1752 1752 ret = 0
1753 1753
1754 1754 return ret
1755 1755
1756 1756 def log(ui, repo, *pats, **opts):
1757 1757 """show revision history of entire repository or files
1758 1758
1759 1759 Print the revision history of the specified files or the entire
1760 1760 project.
1761 1761
1762 1762 File history is shown without following rename or copy history of
1763 1763 files. Use -f/--follow with a file name to follow history across
1764 1764 renames and copies. --follow without a file name will only show
1765 1765 ancestors or descendants of the starting revision. --follow-first
1766 1766 only follows the first parent of merge revisions.
1767 1767
1768 1768 If no revision range is specified, the default is tip:0 unless
1769 1769 --follow is set, in which case the working directory parent is
1770 1770 used as the starting revision.
1771 1771
1772 1772 By default this command outputs: changeset id and hash, tags,
1773 1773 non-trivial parents, user, date and time, and a summary for each
1774 1774 commit. When the -v/--verbose switch is used, the list of changed
1775 1775 files and full commit message is shown.
1776 1776
1777 1777 NOTE: log -p may generate unexpected diff output for merge
1778 1778 changesets, as it will compare the merge changeset against its
1779 1779 first parent only. Also, the files: list will only reflect files
1780 1780 that are different from BOTH parents.
1781 1781
1782 1782 """
1783 1783
1784 1784 get = util.cachefunc(lambda r: repo.changectx(r).changeset())
1785 1785 changeiter, matchfn = cmdutil.walkchangerevs(ui, repo, pats, get, opts)
1786 1786
1787 1787 if opts['limit']:
1788 1788 try:
1789 1789 limit = int(opts['limit'])
1790 1790 except ValueError:
1791 1791 raise util.Abort(_('limit must be a positive integer'))
1792 1792 if limit <= 0: raise util.Abort(_('limit must be positive'))
1793 1793 else:
1794 1794 limit = sys.maxint
1795 1795 count = 0
1796 1796
1797 1797 if opts['copies'] and opts['rev']:
1798 1798 endrev = max(cmdutil.revrange(repo, opts['rev'])) + 1
1799 1799 else:
1800 1800 endrev = repo.changelog.count()
1801 1801 rcache = {}
1802 1802 ncache = {}
1803 1803 dcache = []
1804 1804 def getrenamed(fn, rev, man):
1805 1805 '''looks up all renames for a file (up to endrev) the first
1806 1806 time the file is given. It indexes on the changerev and only
1807 1807 parses the manifest if linkrev != changerev.
1808 1808 Returns rename info for fn at changerev rev.'''
1809 1809 if fn not in rcache:
1810 1810 rcache[fn] = {}
1811 1811 ncache[fn] = {}
1812 1812 fl = repo.file(fn)
1813 1813 for i in xrange(fl.count()):
1814 1814 node = fl.node(i)
1815 1815 lr = fl.linkrev(node)
1816 1816 renamed = fl.renamed(node)
1817 1817 rcache[fn][lr] = renamed
1818 1818 if renamed:
1819 1819 ncache[fn][node] = renamed
1820 1820 if lr >= endrev:
1821 1821 break
1822 1822 if rev in rcache[fn]:
1823 1823 return rcache[fn][rev]
1824 1824 mr = repo.manifest.rev(man)
1825 1825 if repo.manifest.parentrevs(mr) != (mr - 1, nullrev):
1826 1826 return ncache[fn].get(repo.manifest.find(man, fn)[0])
1827 1827 if not dcache or dcache[0] != man:
1828 1828 dcache[:] = [man, repo.manifest.readdelta(man)]
1829 1829 if fn in dcache[1]:
1830 1830 return ncache[fn].get(dcache[1][fn])
1831 1831 return None
1832 1832
1833 1833 df = False
1834 1834 if opts["date"]:
1835 1835 df = util.matchdate(opts["date"])
1836 1836
1837 1837 displayer = cmdutil.show_changeset(ui, repo, opts, True, matchfn)
1838 1838 for st, rev, fns in changeiter:
1839 1839 if st == 'add':
1840 1840 changenode = repo.changelog.node(rev)
1841 1841 parents = [p for p in repo.changelog.parentrevs(rev)
1842 1842 if p != nullrev]
1843 1843 if opts['no_merges'] and len(parents) == 2:
1844 1844 continue
1845 1845 if opts['only_merges'] and len(parents) != 2:
1846 1846 continue
1847 1847
1848 1848 if df:
1849 1849 changes = get(rev)
1850 1850 if not df(changes[2][0]):
1851 1851 continue
1852 1852
1853 1853 if opts['keyword']:
1854 1854 changes = get(rev)
1855 1855 miss = 0
1856 1856 for k in [kw.lower() for kw in opts['keyword']]:
1857 1857 if not (k in changes[1].lower() or
1858 1858 k in changes[4].lower() or
1859 1859 k in " ".join(changes[3]).lower()):
1860 1860 miss = 1
1861 1861 break
1862 1862 if miss:
1863 1863 continue
1864 1864
1865 1865 copies = []
1866 1866 if opts.get('copies') and rev:
1867 1867 mf = get(rev)[0]
1868 1868 for fn in get(rev)[3]:
1869 1869 rename = getrenamed(fn, rev, mf)
1870 1870 if rename:
1871 1871 copies.append((fn, rename[0]))
1872 1872 displayer.show(rev, changenode, copies=copies)
1873 1873 elif st == 'iter':
1874 1874 if count == limit: break
1875 1875 if displayer.flush(rev):
1876 1876 count += 1
1877 1877
1878 1878 def manifest(ui, repo, rev=None):
1879 1879 """output the current or given revision of the project manifest
1880 1880
1881 1881 Print a list of version controlled files for the given revision.
1882 1882 If no revision is given, the parent of the working directory is used,
1883 1883 or tip if no revision is checked out.
1884 1884
1885 1885 The manifest is the list of files being version controlled. If no revision
1886 1886 is given then the first parent of the working directory is used.
1887 1887
1888 1888 With -v flag, print file permissions. With --debug flag, print
1889 1889 file revision hashes.
1890 1890 """
1891 1891
1892 1892 m = repo.changectx(rev).manifest()
1893 1893 files = m.keys()
1894 1894 files.sort()
1895 1895
1896 1896 for f in files:
1897 1897 if ui.debugflag:
1898 1898 ui.write("%40s " % hex(m[f]))
1899 1899 if ui.verbose:
1900 1900 ui.write("%3s " % (m.execf(f) and "755" or "644"))
1901 1901 ui.write("%s\n" % f)
1902 1902
1903 1903 def merge(ui, repo, node=None, force=None, rev=None):
1904 1904 """merge working directory with another revision
1905 1905
1906 1906 Merge the contents of the current working directory and the
1907 1907 requested revision. Files that changed between either parent are
1908 1908 marked as changed for the next commit and a commit must be
1909 1909 performed before any further updates are allowed.
1910 1910
1911 1911 If no revision is specified, the working directory's parent is a
1912 1912 head revision, and the repository contains exactly one other head,
1913 1913 the other head is merged with by default. Otherwise, an explicit
1914 1914 revision to merge with must be provided.
1915 1915 """
1916 1916
1917 1917 if rev and node:
1918 1918 raise util.Abort(_("please specify just one revision"))
1919 1919
1920 1920 if not node:
1921 1921 node = rev
1922 1922
1923 1923 if not node:
1924 1924 heads = repo.heads()
1925 1925 if len(heads) > 2:
1926 1926 raise util.Abort(_('repo has %d heads - '
1927 1927 'please merge with an explicit rev') %
1928 1928 len(heads))
1929 1929 if len(heads) == 1:
1930 1930 raise util.Abort(_('there is nothing to merge - '
1931 1931 'use "hg update" instead'))
1932 1932 parent = repo.dirstate.parents()[0]
1933 1933 if parent not in heads:
1934 1934 raise util.Abort(_('working dir not at a head rev - '
1935 1935 'use "hg update" or merge with an explicit rev'))
1936 1936 node = parent == heads[0] and heads[-1] or heads[0]
1937 1937 return hg.merge(repo, node, force=force)
1938 1938
1939 1939 def outgoing(ui, repo, dest=None, **opts):
1940 1940 """show changesets not found in destination
1941 1941
1942 1942 Show changesets not found in the specified destination repository or
1943 1943 the default push location. These are the changesets that would be pushed
1944 1944 if a push was requested.
1945 1945
1946 1946 See pull for valid destination format details.
1947 1947 """
1948 1948 dest, revs = cmdutil.parseurl(
1949 1949 ui.expandpath(dest or 'default-push', dest or 'default'), opts['rev'])
1950 1950 cmdutil.setremoteconfig(ui, opts)
1951 1951 if revs:
1952 1952 revs = [repo.lookup(rev) for rev in revs]
1953 1953
1954 1954 other = hg.repository(ui, dest)
1955 1955 ui.status(_('comparing with %s\n') % dest)
1956 1956 o = repo.findoutgoing(other, force=opts['force'])
1957 1957 if not o:
1958 1958 ui.status(_("no changes found\n"))
1959 1959 return 1
1960 1960 o = repo.changelog.nodesbetween(o, revs)[0]
1961 1961 if opts['newest_first']:
1962 1962 o.reverse()
1963 1963 displayer = cmdutil.show_changeset(ui, repo, opts)
1964 1964 for n in o:
1965 1965 parents = [p for p in repo.changelog.parents(n) if p != nullid]
1966 1966 if opts['no_merges'] and len(parents) == 2:
1967 1967 continue
1968 1968 displayer.show(changenode=n)
1969 1969
1970 1970 def parents(ui, repo, file_=None, **opts):
1971 1971 """show the parents of the working dir or revision
1972 1972
1973 1973 Print the working directory's parent revisions. If a
1974 1974 revision is given via --rev, the parent of that revision
1975 1975 will be printed. If a file argument is given, revision in
1976 1976 which the file was last changed (before the working directory
1977 1977 revision or the argument to --rev if given) is printed.
1978 1978 """
1979 1979 rev = opts.get('rev')
1980 1980 if file_:
1981 1981 files, match, anypats = cmdutil.matchpats(repo, (file_,), opts)
1982 1982 if anypats or len(files) != 1:
1983 1983 raise util.Abort(_('can only specify an explicit file name'))
1984 1984 ctx = repo.filectx(files[0], changeid=rev)
1985 1985 elif rev:
1986 1986 ctx = repo.changectx(rev)
1987 1987 else:
1988 1988 ctx = repo.workingctx()
1989 1989 p = [cp.node() for cp in ctx.parents()]
1990 1990
1991 1991 displayer = cmdutil.show_changeset(ui, repo, opts)
1992 1992 for n in p:
1993 1993 if n != nullid:
1994 1994 displayer.show(changenode=n)
1995 1995
1996 1996 def paths(ui, repo, search=None):
1997 1997 """show definition of symbolic path names
1998 1998
1999 1999 Show definition of symbolic path name NAME. If no name is given, show
2000 2000 definition of available names.
2001 2001
2002 2002 Path names are defined in the [paths] section of /etc/mercurial/hgrc
2003 2003 and $HOME/.hgrc. If run inside a repository, .hg/hgrc is used, too.
2004 2004 """
2005 2005 if search:
2006 2006 for name, path in ui.configitems("paths"):
2007 2007 if name == search:
2008 2008 ui.write("%s\n" % path)
2009 2009 return
2010 2010 ui.warn(_("not found!\n"))
2011 2011 return 1
2012 2012 else:
2013 2013 for name, path in ui.configitems("paths"):
2014 2014 ui.write("%s = %s\n" % (name, path))
2015 2015
2016 2016 def postincoming(ui, repo, modheads, optupdate):
2017 2017 if modheads == 0:
2018 2018 return
2019 2019 if optupdate:
2020 2020 if modheads == 1:
2021 return hg.update(repo, repo.changelog.tip()) # update
2021 return hg.update(repo, None)
2022 2022 else:
2023 2023 ui.status(_("not updating, since new heads added\n"))
2024 2024 if modheads > 1:
2025 2025 ui.status(_("(run 'hg heads' to see heads, 'hg merge' to merge)\n"))
2026 2026 else:
2027 2027 ui.status(_("(run 'hg update' to get a working copy)\n"))
2028 2028
2029 2029 def pull(ui, repo, source="default", **opts):
2030 2030 """pull changes from the specified source
2031 2031
2032 2032 Pull changes from a remote repository to a local one.
2033 2033
2034 2034 This finds all changes from the repository at the specified path
2035 2035 or URL and adds them to the local repository. By default, this
2036 2036 does not update the copy of the project in the working directory.
2037 2037
2038 2038 Valid URLs are of the form:
2039 2039
2040 2040 local/filesystem/path (or file://local/filesystem/path)
2041 2041 http://[user@]host[:port]/[path]
2042 2042 https://[user@]host[:port]/[path]
2043 2043 ssh://[user@]host[:port]/[path]
2044 2044 static-http://host[:port]/[path]
2045 2045
2046 2046 Paths in the local filesystem can either point to Mercurial
2047 2047 repositories or to bundle files (as created by 'hg bundle' or
2048 2048 'hg incoming --bundle'). The static-http:// protocol, albeit slow,
2049 2049 allows access to a Mercurial repository where you simply use a web
2050 2050 server to publish the .hg directory as static content.
2051 2051
2052 2052 An optional identifier after # indicates a particular branch, tag,
2053 2053 or changeset to pull.
2054 2054
2055 2055 Some notes about using SSH with Mercurial:
2056 2056 - SSH requires an accessible shell account on the destination machine
2057 2057 and a copy of hg in the remote path or specified with as remotecmd.
2058 2058 - path is relative to the remote user's home directory by default.
2059 2059 Use an extra slash at the start of a path to specify an absolute path:
2060 2060 ssh://example.com//tmp/repository
2061 2061 - Mercurial doesn't use its own compression via SSH; the right thing
2062 2062 to do is to configure it in your ~/.ssh/config, e.g.:
2063 2063 Host *.mylocalnetwork.example.com
2064 2064 Compression no
2065 2065 Host *
2066 2066 Compression yes
2067 2067 Alternatively specify "ssh -C" as your ssh command in your hgrc or
2068 2068 with the --ssh command line option.
2069 2069 """
2070 2070 source, revs = cmdutil.parseurl(ui.expandpath(source), opts['rev'])
2071 2071 cmdutil.setremoteconfig(ui, opts)
2072 2072
2073 2073 other = hg.repository(ui, source)
2074 2074 ui.status(_('pulling from %s\n') % (source))
2075 2075 if revs:
2076 2076 if 'lookup' in other.capabilities:
2077 2077 revs = [other.lookup(rev) for rev in revs]
2078 2078 else:
2079 2079 error = _("Other repository doesn't support revision lookup, so a rev cannot be specified.")
2080 2080 raise util.Abort(error)
2081 2081
2082 2082 modheads = repo.pull(other, heads=revs, force=opts['force'])
2083 2083 return postincoming(ui, repo, modheads, opts['update'])
2084 2084
2085 2085 def push(ui, repo, dest=None, **opts):
2086 2086 """push changes to the specified destination
2087 2087
2088 2088 Push changes from the local repository to the given destination.
2089 2089
2090 2090 This is the symmetrical operation for pull. It helps to move
2091 2091 changes from the current repository to a different one. If the
2092 2092 destination is local this is identical to a pull in that directory
2093 2093 from the current one.
2094 2094
2095 2095 By default, push will refuse to run if it detects the result would
2096 2096 increase the number of remote heads. This generally indicates the
2097 2097 the client has forgotten to sync and merge before pushing.
2098 2098
2099 2099 Valid URLs are of the form:
2100 2100
2101 2101 local/filesystem/path (or file://local/filesystem/path)
2102 2102 ssh://[user@]host[:port]/[path]
2103 2103 http://[user@]host[:port]/[path]
2104 2104 https://[user@]host[:port]/[path]
2105 2105
2106 2106 An optional identifier after # indicates a particular branch, tag,
2107 2107 or changeset to push.
2108 2108
2109 2109 Look at the help text for the pull command for important details
2110 2110 about ssh:// URLs.
2111 2111
2112 2112 Pushing to http:// and https:// URLs is only possible, if this
2113 2113 feature is explicitly enabled on the remote Mercurial server.
2114 2114 """
2115 2115 dest, revs = cmdutil.parseurl(
2116 2116 ui.expandpath(dest or 'default-push', dest or 'default'), opts['rev'])
2117 2117 cmdutil.setremoteconfig(ui, opts)
2118 2118
2119 2119 other = hg.repository(ui, dest)
2120 2120 ui.status('pushing to %s\n' % (dest))
2121 2121 if revs:
2122 2122 revs = [repo.lookup(rev) for rev in revs]
2123 2123 r = repo.push(other, opts['force'], revs=revs)
2124 2124 return r == 0
2125 2125
2126 2126 def rawcommit(ui, repo, *pats, **opts):
2127 2127 """raw commit interface (DEPRECATED)
2128 2128
2129 2129 (DEPRECATED)
2130 2130 Lowlevel commit, for use in helper scripts.
2131 2131
2132 2132 This command is not intended to be used by normal users, as it is
2133 2133 primarily useful for importing from other SCMs.
2134 2134
2135 2135 This command is now deprecated and will be removed in a future
2136 2136 release, please use debugsetparents and commit instead.
2137 2137 """
2138 2138
2139 2139 ui.warn(_("(the rawcommit command is deprecated)\n"))
2140 2140
2141 2141 message = cmdutil.logmessage(opts)
2142 2142
2143 2143 files, match, anypats = cmdutil.matchpats(repo, pats, opts)
2144 2144 if opts['files']:
2145 2145 files += open(opts['files']).read().splitlines()
2146 2146
2147 2147 parents = [repo.lookup(p) for p in opts['parent']]
2148 2148
2149 2149 try:
2150 2150 repo.rawcommit(files, message, opts['user'], opts['date'], *parents)
2151 2151 except ValueError, inst:
2152 2152 raise util.Abort(str(inst))
2153 2153
2154 2154 def recover(ui, repo):
2155 2155 """roll back an interrupted transaction
2156 2156
2157 2157 Recover from an interrupted commit or pull.
2158 2158
2159 2159 This command tries to fix the repository status after an interrupted
2160 2160 operation. It should only be necessary when Mercurial suggests it.
2161 2161 """
2162 2162 if repo.recover():
2163 2163 return hg.verify(repo)
2164 2164 return 1
2165 2165
2166 2166 def remove(ui, repo, *pats, **opts):
2167 2167 """remove the specified files on the next commit
2168 2168
2169 2169 Schedule the indicated files for removal from the repository.
2170 2170
2171 2171 This only removes files from the current branch, not from the
2172 2172 entire project history. If the files still exist in the working
2173 2173 directory, they will be deleted from it. If invoked with --after,
2174 2174 files are marked as removed, but not actually unlinked unless --force
2175 2175 is also given. Without exact file names, --after will only mark
2176 2176 files as removed if they are no longer in the working directory.
2177 2177
2178 2178 This command schedules the files to be removed at the next commit.
2179 2179 To undo a remove before that, see hg revert.
2180 2180
2181 2181 Modified files and added files are not removed by default. To
2182 2182 remove them, use the -f/--force option.
2183 2183 """
2184 2184 names = []
2185 2185 if not opts['after'] and not pats:
2186 2186 raise util.Abort(_('no files specified'))
2187 2187 files, matchfn, anypats = cmdutil.matchpats(repo, pats, opts)
2188 2188 exact = dict.fromkeys(files)
2189 2189 mardu = map(dict.fromkeys, repo.status(files=files, match=matchfn))[:5]
2190 2190 modified, added, removed, deleted, unknown = mardu
2191 2191 remove, forget = [], []
2192 2192 for src, abs, rel, exact in cmdutil.walk(repo, pats, opts):
2193 2193 reason = None
2194 2194 if abs in modified and not opts['force']:
2195 2195 reason = _('is modified (use -f to force removal)')
2196 2196 elif abs in added:
2197 2197 if opts['force']:
2198 2198 forget.append(abs)
2199 2199 continue
2200 2200 reason = _('has been marked for add (use -f to force removal)')
2201 2201 elif repo.dirstate.state(abs) == '?':
2202 2202 reason = _('is not managed')
2203 2203 elif opts['after'] and not exact and abs not in deleted:
2204 2204 continue
2205 2205 elif abs in removed:
2206 2206 continue
2207 2207 if reason:
2208 2208 if exact:
2209 2209 ui.warn(_('not removing %s: file %s\n') % (rel, reason))
2210 2210 else:
2211 2211 if ui.verbose or not exact:
2212 2212 ui.status(_('removing %s\n') % rel)
2213 2213 remove.append(abs)
2214 2214 repo.forget(forget)
2215 2215 repo.remove(remove, unlink=opts['force'] or not opts['after'])
2216 2216
2217 2217 def rename(ui, repo, *pats, **opts):
2218 2218 """rename files; equivalent of copy + remove
2219 2219
2220 2220 Mark dest as copies of sources; mark sources for deletion. If
2221 2221 dest is a directory, copies are put in that directory. If dest is
2222 2222 a file, there can only be one source.
2223 2223
2224 2224 By default, this command copies the contents of files as they
2225 2225 stand in the working directory. If invoked with --after, the
2226 2226 operation is recorded, but no copying is performed.
2227 2227
2228 2228 This command takes effect in the next commit. To undo a rename
2229 2229 before that, see hg revert.
2230 2230 """
2231 2231 wlock = repo.wlock(0)
2232 2232 errs, copied = docopy(ui, repo, pats, opts, wlock)
2233 2233 names = []
2234 2234 for abs, rel, exact in copied:
2235 2235 if ui.verbose or not exact:
2236 2236 ui.status(_('removing %s\n') % rel)
2237 2237 names.append(abs)
2238 2238 if not opts.get('dry_run'):
2239 2239 repo.remove(names, True, wlock=wlock)
2240 2240 return errs
2241 2241
2242 2242 def revert(ui, repo, *pats, **opts):
2243 2243 """revert files or dirs to their states as of some revision
2244 2244
2245 2245 With no revision specified, revert the named files or directories
2246 2246 to the contents they had in the parent of the working directory.
2247 2247 This restores the contents of the affected files to an unmodified
2248 2248 state and unschedules adds, removes, copies, and renames. If the
2249 2249 working directory has two parents, you must explicitly specify the
2250 2250 revision to revert to.
2251 2251
2252 2252 Modified files are saved with a .orig suffix before reverting.
2253 2253 To disable these backups, use --no-backup.
2254 2254
2255 2255 Using the -r option, revert the given files or directories to their
2256 2256 contents as of a specific revision. This can be helpful to "roll
2257 2257 back" some or all of a change that should not have been committed.
2258 2258
2259 2259 Revert modifies the working directory. It does not commit any
2260 2260 changes, or change the parent of the working directory. If you
2261 2261 revert to a revision other than the parent of the working
2262 2262 directory, the reverted files will thus appear modified
2263 2263 afterwards.
2264 2264
2265 2265 If a file has been deleted, it is restored. If the executable
2266 2266 mode of a file was changed, it is reset.
2267 2267
2268 2268 If names are given, all files matching the names are reverted.
2269 2269
2270 2270 If no arguments are given, no files are reverted.
2271 2271 """
2272 2272
2273 2273 if opts["date"]:
2274 2274 if opts["rev"]:
2275 2275 raise util.Abort(_("you can't specify a revision and a date"))
2276 2276 opts["rev"] = cmdutil.finddate(ui, repo, opts["date"])
2277 2277
2278 2278 if not pats and not opts['all']:
2279 2279 raise util.Abort(_('no files or directories specified; '
2280 2280 'use --all to revert the whole repo'))
2281 2281
2282 2282 parent, p2 = repo.dirstate.parents()
2283 2283 if not opts['rev'] and p2 != nullid:
2284 2284 raise util.Abort(_('uncommitted merge - please provide a '
2285 2285 'specific revision'))
2286 2286 ctx = repo.changectx(opts['rev'])
2287 2287 node = ctx.node()
2288 2288 mf = ctx.manifest()
2289 2289 if node == parent:
2290 2290 pmf = mf
2291 2291 else:
2292 2292 pmf = None
2293 2293
2294 2294 wlock = repo.wlock()
2295 2295
2296 2296 # need all matching names in dirstate and manifest of target rev,
2297 2297 # so have to walk both. do not print errors if files exist in one
2298 2298 # but not other.
2299 2299
2300 2300 names = {}
2301 2301 target_only = {}
2302 2302
2303 2303 # walk dirstate.
2304 2304
2305 2305 for src, abs, rel, exact in cmdutil.walk(repo, pats, opts,
2306 2306 badmatch=mf.has_key):
2307 2307 names[abs] = (rel, exact)
2308 2308 if src == 'b':
2309 2309 target_only[abs] = True
2310 2310
2311 2311 # walk target manifest.
2312 2312
2313 2313 def badmatch(path):
2314 2314 if path in names:
2315 2315 return True
2316 2316 path_ = path + '/'
2317 2317 for f in names:
2318 2318 if f.startswith(path_):
2319 2319 return True
2320 2320 return False
2321 2321
2322 2322 for src, abs, rel, exact in cmdutil.walk(repo, pats, opts, node=node,
2323 2323 badmatch=badmatch):
2324 2324 if abs in names or src == 'b':
2325 2325 continue
2326 2326 names[abs] = (rel, exact)
2327 2327 target_only[abs] = True
2328 2328
2329 2329 changes = repo.status(match=names.has_key, wlock=wlock)[:5]
2330 2330 modified, added, removed, deleted, unknown = map(dict.fromkeys, changes)
2331 2331
2332 2332 revert = ([], _('reverting %s\n'))
2333 2333 add = ([], _('adding %s\n'))
2334 2334 remove = ([], _('removing %s\n'))
2335 2335 forget = ([], _('forgetting %s\n'))
2336 2336 undelete = ([], _('undeleting %s\n'))
2337 2337 update = {}
2338 2338
2339 2339 disptable = (
2340 2340 # dispatch table:
2341 2341 # file state
2342 2342 # action if in target manifest
2343 2343 # action if not in target manifest
2344 2344 # make backup if in target manifest
2345 2345 # make backup if not in target manifest
2346 2346 (modified, revert, remove, True, True),
2347 2347 (added, revert, forget, True, False),
2348 2348 (removed, undelete, None, False, False),
2349 2349 (deleted, revert, remove, False, False),
2350 2350 (unknown, add, None, True, False),
2351 2351 (target_only, add, None, False, False),
2352 2352 )
2353 2353
2354 2354 entries = names.items()
2355 2355 entries.sort()
2356 2356
2357 2357 for abs, (rel, exact) in entries:
2358 2358 mfentry = mf.get(abs)
2359 2359 target = repo.wjoin(abs)
2360 2360 def handle(xlist, dobackup):
2361 2361 xlist[0].append(abs)
2362 2362 update[abs] = 1
2363 2363 if dobackup and not opts['no_backup'] and util.lexists(target):
2364 2364 bakname = "%s.orig" % rel
2365 2365 ui.note(_('saving current version of %s as %s\n') %
2366 2366 (rel, bakname))
2367 2367 if not opts.get('dry_run'):
2368 2368 util.copyfile(target, bakname)
2369 2369 if ui.verbose or not exact:
2370 2370 ui.status(xlist[1] % rel)
2371 2371 for table, hitlist, misslist, backuphit, backupmiss in disptable:
2372 2372 if abs not in table: continue
2373 2373 # file has changed in dirstate
2374 2374 if mfentry:
2375 2375 handle(hitlist, backuphit)
2376 2376 elif misslist is not None:
2377 2377 handle(misslist, backupmiss)
2378 2378 else:
2379 2379 if exact: ui.warn(_('file not managed: %s\n') % rel)
2380 2380 break
2381 2381 else:
2382 2382 # file has not changed in dirstate
2383 2383 if node == parent:
2384 2384 if exact: ui.warn(_('no changes needed to %s\n') % rel)
2385 2385 continue
2386 2386 if pmf is None:
2387 2387 # only need parent manifest in this unlikely case,
2388 2388 # so do not read by default
2389 2389 pmf = repo.changectx(parent).manifest()
2390 2390 if abs in pmf:
2391 2391 if mfentry:
2392 2392 # if version of file is same in parent and target
2393 2393 # manifests, do nothing
2394 2394 if pmf[abs] != mfentry:
2395 2395 handle(revert, False)
2396 2396 else:
2397 2397 handle(remove, False)
2398 2398
2399 2399 if not opts.get('dry_run'):
2400 2400 repo.dirstate.forget(forget[0])
2401 2401 r = hg.revert(repo, node, update.has_key, wlock)
2402 2402 repo.dirstate.update(add[0], 'a')
2403 2403 repo.dirstate.update(undelete[0], 'n')
2404 2404 repo.dirstate.update(remove[0], 'r')
2405 2405 return r
2406 2406
2407 2407 def rollback(ui, repo):
2408 2408 """roll back the last transaction in this repository
2409 2409
2410 2410 Roll back the last transaction in this repository, restoring the
2411 2411 project to its state prior to the transaction.
2412 2412
2413 2413 Transactions are used to encapsulate the effects of all commands
2414 2414 that create new changesets or propagate existing changesets into a
2415 2415 repository. For example, the following commands are transactional,
2416 2416 and their effects can be rolled back:
2417 2417
2418 2418 commit
2419 2419 import
2420 2420 pull
2421 2421 push (with this repository as destination)
2422 2422 unbundle
2423 2423
2424 2424 This command should be used with care. There is only one level of
2425 2425 rollback, and there is no way to undo a rollback. It will also
2426 2426 restore the dirstate at the time of the last transaction, which
2427 2427 may lose subsequent dirstate changes.
2428 2428
2429 2429 This command is not intended for use on public repositories. Once
2430 2430 changes are visible for pull by other users, rolling a transaction
2431 2431 back locally is ineffective (someone else may already have pulled
2432 2432 the changes). Furthermore, a race is possible with readers of the
2433 2433 repository; for example an in-progress pull from the repository
2434 2434 may fail if a rollback is performed.
2435 2435 """
2436 2436 repo.rollback()
2437 2437
2438 2438 def root(ui, repo):
2439 2439 """print the root (top) of the current working dir
2440 2440
2441 2441 Print the root directory of the current repository.
2442 2442 """
2443 2443 ui.write(repo.root + "\n")
2444 2444
2445 2445 def serve(ui, repo, **opts):
2446 2446 """export the repository via HTTP
2447 2447
2448 2448 Start a local HTTP repository browser and pull server.
2449 2449
2450 2450 By default, the server logs accesses to stdout and errors to
2451 2451 stderr. Use the "-A" and "-E" options to log to files.
2452 2452 """
2453 2453
2454 2454 if opts["stdio"]:
2455 2455 if repo is None:
2456 2456 raise hg.RepoError(_("There is no Mercurial repository here"
2457 2457 " (.hg not found)"))
2458 2458 s = sshserver.sshserver(ui, repo)
2459 2459 s.serve_forever()
2460 2460
2461 2461 parentui = ui.parentui or ui
2462 2462 optlist = ("name templates style address port ipv6"
2463 2463 " accesslog errorlog webdir_conf")
2464 2464 for o in optlist.split():
2465 2465 if opts[o]:
2466 2466 parentui.setconfig("web", o, str(opts[o]))
2467 2467 if repo.ui != parentui:
2468 2468 repo.ui.setconfig("web", o, str(opts[o]))
2469 2469
2470 2470 if repo is None and not ui.config("web", "webdir_conf"):
2471 2471 raise hg.RepoError(_("There is no Mercurial repository here"
2472 2472 " (.hg not found)"))
2473 2473
2474 2474 class service:
2475 2475 def init(self):
2476 2476 util.set_signal_handler()
2477 2477 try:
2478 2478 self.httpd = hgweb.server.create_server(parentui, repo)
2479 2479 except socket.error, inst:
2480 2480 raise util.Abort(_('cannot start server: ') + inst.args[1])
2481 2481
2482 2482 if not ui.verbose: return
2483 2483
2484 2484 if self.httpd.port != 80:
2485 2485 ui.status(_('listening at http://%s:%d/\n') %
2486 2486 (self.httpd.addr, self.httpd.port))
2487 2487 else:
2488 2488 ui.status(_('listening at http://%s/\n') % self.httpd.addr)
2489 2489
2490 2490 def run(self):
2491 2491 self.httpd.serve_forever()
2492 2492
2493 2493 service = service()
2494 2494
2495 2495 cmdutil.service(opts, initfn=service.init, runfn=service.run)
2496 2496
2497 2497 def status(ui, repo, *pats, **opts):
2498 2498 """show changed files in the working directory
2499 2499
2500 2500 Show status of files in the repository. If names are given, only
2501 2501 files that match are shown. Files that are clean or ignored, are
2502 2502 not listed unless -c (clean), -i (ignored) or -A is given.
2503 2503
2504 2504 NOTE: status may appear to disagree with diff if permissions have
2505 2505 changed or a merge has occurred. The standard diff format does not
2506 2506 report permission changes and diff only reports changes relative
2507 2507 to one merge parent.
2508 2508
2509 2509 If one revision is given, it is used as the base revision.
2510 2510 If two revisions are given, the difference between them is shown.
2511 2511
2512 2512 The codes used to show the status of files are:
2513 2513 M = modified
2514 2514 A = added
2515 2515 R = removed
2516 2516 C = clean
2517 2517 ! = deleted, but still tracked
2518 2518 ? = not tracked
2519 2519 I = ignored (not shown by default)
2520 2520 = the previous added file was copied from here
2521 2521 """
2522 2522
2523 2523 all = opts['all']
2524 2524 node1, node2 = cmdutil.revpair(repo, opts.get('rev'))
2525 2525
2526 2526 files, matchfn, anypats = cmdutil.matchpats(repo, pats, opts)
2527 2527 cwd = (pats and repo.getcwd()) or ''
2528 2528 modified, added, removed, deleted, unknown, ignored, clean = [
2529 2529 n for n in repo.status(node1=node1, node2=node2, files=files,
2530 2530 match=matchfn,
2531 2531 list_ignored=all or opts['ignored'],
2532 2532 list_clean=all or opts['clean'])]
2533 2533
2534 2534 changetypes = (('modified', 'M', modified),
2535 2535 ('added', 'A', added),
2536 2536 ('removed', 'R', removed),
2537 2537 ('deleted', '!', deleted),
2538 2538 ('unknown', '?', unknown),
2539 2539 ('ignored', 'I', ignored))
2540 2540
2541 2541 explicit_changetypes = changetypes + (('clean', 'C', clean),)
2542 2542
2543 2543 end = opts['print0'] and '\0' or '\n'
2544 2544
2545 2545 for opt, char, changes in ([ct for ct in explicit_changetypes
2546 2546 if all or opts[ct[0]]]
2547 2547 or changetypes):
2548 2548 if opts['no_status']:
2549 2549 format = "%%s%s" % end
2550 2550 else:
2551 2551 format = "%s %%s%s" % (char, end)
2552 2552
2553 2553 for f in changes:
2554 2554 ui.write(format % repo.pathto(f, cwd))
2555 2555 if ((all or opts.get('copies')) and not opts.get('no_status')):
2556 2556 copied = repo.dirstate.copied(f)
2557 2557 if copied:
2558 2558 ui.write(' %s%s' % (repo.pathto(copied, cwd), end))
2559 2559
2560 2560 def tag(ui, repo, name, rev_=None, **opts):
2561 2561 """add a tag for the current or given revision
2562 2562
2563 2563 Name a particular revision using <name>.
2564 2564
2565 2565 Tags are used to name particular revisions of the repository and are
2566 2566 very useful to compare different revision, to go back to significant
2567 2567 earlier versions or to mark branch points as releases, etc.
2568 2568
2569 2569 If no revision is given, the parent of the working directory is used,
2570 2570 or tip if no revision is checked out.
2571 2571
2572 2572 To facilitate version control, distribution, and merging of tags,
2573 2573 they are stored as a file named ".hgtags" which is managed
2574 2574 similarly to other project files and can be hand-edited if
2575 2575 necessary. The file '.hg/localtags' is used for local tags (not
2576 2576 shared among repositories).
2577 2577 """
2578 2578 if name in ['tip', '.', 'null']:
2579 2579 raise util.Abort(_("the name '%s' is reserved") % name)
2580 2580 if rev_ is not None:
2581 2581 ui.warn(_("use of 'hg tag NAME [REV]' is deprecated, "
2582 2582 "please use 'hg tag [-r REV] NAME' instead\n"))
2583 2583 if opts['rev']:
2584 2584 raise util.Abort(_("use only one form to specify the revision"))
2585 2585 if opts['rev'] and opts['remove']:
2586 2586 raise util.Abort(_("--rev and --remove are incompatible"))
2587 2587 if opts['rev']:
2588 2588 rev_ = opts['rev']
2589 2589 message = opts['message']
2590 2590 if opts['remove']:
2591 2591 if not name in repo.tags():
2592 2592 raise util.Abort(_('tag %s does not exist') % name)
2593 2593 rev_ = nullid
2594 2594 if not message:
2595 2595 message = _('Removed tag %s') % name
2596 2596 elif name in repo.tags() and not opts['force']:
2597 2597 raise util.Abort(_('a tag named %s already exists (use -f to force)')
2598 2598 % name)
2599 2599 if not rev_ and repo.dirstate.parents()[1] != nullid:
2600 2600 raise util.Abort(_('uncommitted merge - please provide a '
2601 2601 'specific revision'))
2602 2602 r = repo.changectx(rev_).node()
2603 2603
2604 2604 if not message:
2605 2605 message = _('Added tag %s for changeset %s') % (name, short(r))
2606 2606
2607 2607 repo.tag(name, r, message, opts['local'], opts['user'], opts['date'])
2608 2608
2609 2609 def tags(ui, repo):
2610 2610 """list repository tags
2611 2611
2612 2612 List the repository tags.
2613 2613
2614 2614 This lists both regular and local tags.
2615 2615 """
2616 2616
2617 2617 l = repo.tagslist()
2618 2618 l.reverse()
2619 2619 hexfunc = ui.debugflag and hex or short
2620 2620 for t, n in l:
2621 2621 try:
2622 2622 hn = hexfunc(n)
2623 2623 r = "%5d:%s" % (repo.changelog.rev(n), hexfunc(n))
2624 2624 except revlog.LookupError:
2625 2625 r = " ?:%s" % hn
2626 2626 if ui.quiet:
2627 2627 ui.write("%s\n" % t)
2628 2628 else:
2629 2629 spaces = " " * (30 - util.locallen(t))
2630 2630 ui.write("%s%s %s\n" % (t, spaces, r))
2631 2631
2632 2632 def tip(ui, repo, **opts):
2633 2633 """show the tip revision
2634 2634
2635 2635 Show the tip revision.
2636 2636 """
2637 2637 cmdutil.show_changeset(ui, repo, opts).show(nullrev+repo.changelog.count())
2638 2638
2639 2639 def unbundle(ui, repo, fname1, *fnames, **opts):
2640 2640 """apply one or more changegroup files
2641 2641
2642 2642 Apply one or more compressed changegroup files generated by the
2643 2643 bundle command.
2644 2644 """
2645 2645 fnames = (fname1,) + fnames
2646 2646 result = None
2647 2647 for fname in fnames:
2648 2648 if os.path.exists(fname):
2649 2649 f = open(fname, "rb")
2650 2650 else:
2651 2651 f = urllib.urlopen(fname)
2652 2652 gen = changegroup.readbundle(f, fname)
2653 2653 modheads = repo.addchangegroup(gen, 'unbundle', 'bundle:' + fname)
2654 2654
2655 2655 return postincoming(ui, repo, modheads, opts['update'])
2656 2656
2657 2657 def update(ui, repo, node=None, rev=None, clean=False, date=None):
2658 2658 """update working directory
2659 2659
2660 2660 Update the working directory to the specified revision, or the
2661 2661 tip of the current branch if none is specified.
2662 2662
2663 2663 If there are no outstanding changes in the working directory and
2664 2664 there is a linear relationship between the current version and the
2665 2665 requested version, the result is the requested version.
2666 2666
2667 2667 To merge the working directory with another revision, use the
2668 2668 merge command.
2669 2669
2670 2670 By default, update will refuse to run if doing so would require
2671 2671 discarding local changes.
2672 2672 """
2673 2673 if rev and node:
2674 2674 raise util.Abort(_("please specify just one revision"))
2675 2675
2676 2676 if not rev:
2677 2677 rev = node
2678 2678
2679 2679 if date:
2680 2680 if rev:
2681 2681 raise util.Abort(_("you can't specify a revision and a date"))
2682 2682 rev = cmdutil.finddate(ui, repo, date)
2683 2683
2684 2684 if clean:
2685 2685 return hg.clean(repo, rev)
2686 2686 else:
2687 2687 return hg.update(repo, rev)
2688 2688
2689 2689 def verify(ui, repo):
2690 2690 """verify the integrity of the repository
2691 2691
2692 2692 Verify the integrity of the current repository.
2693 2693
2694 2694 This will perform an extensive check of the repository's
2695 2695 integrity, validating the hashes and checksums of each entry in
2696 2696 the changelog, manifest, and tracked files, as well as the
2697 2697 integrity of their crosslinks and indices.
2698 2698 """
2699 2699 return hg.verify(repo)
2700 2700
2701 2701 def version_(ui):
2702 2702 """output version and copyright information"""
2703 2703 ui.write(_("Mercurial Distributed SCM (version %s)\n")
2704 2704 % version.get_version())
2705 2705 ui.status(_(
2706 2706 "\nCopyright (C) 2005-2007 Matt Mackall <mpm@selenic.com> and others\n"
2707 2707 "This is free software; see the source for copying conditions. "
2708 2708 "There is NO\nwarranty; "
2709 2709 "not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
2710 2710 ))
2711 2711
2712 2712 # Command options and aliases are listed here, alphabetically
2713 2713
2714 2714 globalopts = [
2715 2715 ('R', 'repository', '',
2716 2716 _('repository root directory or symbolic path name')),
2717 2717 ('', 'cwd', '', _('change working directory')),
2718 2718 ('y', 'noninteractive', None,
2719 2719 _('do not prompt, assume \'yes\' for any required answers')),
2720 2720 ('q', 'quiet', None, _('suppress output')),
2721 2721 ('v', 'verbose', None, _('enable additional output')),
2722 2722 ('', 'config', [], _('set/override config option')),
2723 2723 ('', 'debug', None, _('enable debugging output')),
2724 2724 ('', 'debugger', None, _('start debugger')),
2725 2725 ('', 'encoding', util._encoding, _('set the charset encoding')),
2726 2726 ('', 'encodingmode', util._encodingmode, _('set the charset encoding mode')),
2727 2727 ('', 'lsprof', None, _('print improved command execution profile')),
2728 2728 ('', 'traceback', None, _('print traceback on exception')),
2729 2729 ('', 'time', None, _('time how long the command takes')),
2730 2730 ('', 'profile', None, _('print command execution profile')),
2731 2731 ('', 'version', None, _('output version information and exit')),
2732 2732 ('h', 'help', None, _('display help and exit')),
2733 2733 ]
2734 2734
2735 2735 dryrunopts = [('n', 'dry-run', None,
2736 2736 _('do not perform actions, just print output'))]
2737 2737
2738 2738 remoteopts = [
2739 2739 ('e', 'ssh', '', _('specify ssh command to use')),
2740 2740 ('', 'remotecmd', '', _('specify hg command to run on the remote side')),
2741 2741 ]
2742 2742
2743 2743 walkopts = [
2744 2744 ('I', 'include', [], _('include names matching the given patterns')),
2745 2745 ('X', 'exclude', [], _('exclude names matching the given patterns')),
2746 2746 ]
2747 2747
2748 2748 commitopts = [
2749 2749 ('m', 'message', '', _('use <text> as commit message')),
2750 2750 ('l', 'logfile', '', _('read commit message from <file>')),
2751 2751 ]
2752 2752
2753 2753 table = {
2754 2754 "^add": (add, walkopts + dryrunopts, _('hg add [OPTION]... [FILE]...')),
2755 2755 "addremove":
2756 2756 (addremove,
2757 2757 [('s', 'similarity', '',
2758 2758 _('guess renamed files by similarity (0<=s<=100)')),
2759 2759 ] + walkopts + dryrunopts,
2760 2760 _('hg addremove [OPTION]... [FILE]...')),
2761 2761 "^annotate":
2762 2762 (annotate,
2763 2763 [('r', 'rev', '', _('annotate the specified revision')),
2764 2764 ('f', 'follow', None, _('follow file copies and renames')),
2765 2765 ('a', 'text', None, _('treat all files as text')),
2766 2766 ('u', 'user', None, _('list the author')),
2767 2767 ('d', 'date', None, _('list the date')),
2768 2768 ('n', 'number', None, _('list the revision number (default)')),
2769 2769 ('c', 'changeset', None, _('list the changeset')),
2770 2770 ] + walkopts,
2771 2771 _('hg annotate [-r REV] [-f] [-a] [-u] [-d] [-n] [-c] FILE...')),
2772 2772 "archive":
2773 2773 (archive,
2774 2774 [('', 'no-decode', None, _('do not pass files through decoders')),
2775 2775 ('p', 'prefix', '', _('directory prefix for files in archive')),
2776 2776 ('r', 'rev', '', _('revision to distribute')),
2777 2777 ('t', 'type', '', _('type of distribution to create')),
2778 2778 ] + walkopts,
2779 2779 _('hg archive [OPTION]... DEST')),
2780 2780 "backout":
2781 2781 (backout,
2782 2782 [('', 'merge', None,
2783 2783 _('merge with old dirstate parent after backout')),
2784 2784 ('d', 'date', '', _('record datecode as commit date')),
2785 2785 ('', 'parent', '', _('parent to choose when backing out merge')),
2786 2786 ('u', 'user', '', _('record user as committer')),
2787 2787 ('r', 'rev', '', _('revision to backout')),
2788 2788 ] + walkopts + commitopts,
2789 2789 _('hg backout [OPTION]... [-r] REV')),
2790 2790 "branch":
2791 2791 (branch,
2792 2792 [('f', 'force', None,
2793 2793 _('set branch name even if it shadows an existing branch'))],
2794 2794 _('hg branch [NAME]')),
2795 2795 "branches":
2796 2796 (branches,
2797 2797 [('a', 'active', False,
2798 2798 _('show only branches that have unmerged heads'))],
2799 2799 _('hg branches [-a]')),
2800 2800 "bundle":
2801 2801 (bundle,
2802 2802 [('f', 'force', None,
2803 2803 _('run even when remote repository is unrelated')),
2804 2804 ('r', 'rev', [],
2805 2805 _('a changeset you would like to bundle')),
2806 2806 ('', 'base', [],
2807 2807 _('a base changeset to specify instead of a destination')),
2808 2808 ] + remoteopts,
2809 2809 _('hg bundle [-f] [-r REV]... [--base REV]... FILE [DEST]')),
2810 2810 "cat":
2811 2811 (cat,
2812 2812 [('o', 'output', '', _('print output to file with formatted name')),
2813 2813 ('r', 'rev', '', _('print the given revision')),
2814 2814 ] + walkopts,
2815 2815 _('hg cat [OPTION]... FILE...')),
2816 2816 "^clone":
2817 2817 (clone,
2818 2818 [('U', 'noupdate', None, _('do not update the new working directory')),
2819 2819 ('r', 'rev', [],
2820 2820 _('a changeset you would like to have after cloning')),
2821 2821 ('', 'pull', None, _('use pull protocol to copy metadata')),
2822 2822 ('', 'uncompressed', None,
2823 2823 _('use uncompressed transfer (fast over LAN)')),
2824 2824 ] + remoteopts,
2825 2825 _('hg clone [OPTION]... SOURCE [DEST]')),
2826 2826 "^commit|ci":
2827 2827 (commit,
2828 2828 [('A', 'addremove', None,
2829 2829 _('mark new/missing files as added/removed before committing')),
2830 2830 ('d', 'date', '', _('record datecode as commit date')),
2831 2831 ('u', 'user', '', _('record user as commiter')),
2832 2832 ] + walkopts + commitopts,
2833 2833 _('hg commit [OPTION]... [FILE]...')),
2834 2834 "copy|cp":
2835 2835 (copy,
2836 2836 [('A', 'after', None, _('record a copy that has already occurred')),
2837 2837 ('f', 'force', None,
2838 2838 _('forcibly copy over an existing managed file')),
2839 2839 ] + walkopts + dryrunopts,
2840 2840 _('hg copy [OPTION]... [SOURCE]... DEST')),
2841 2841 "debugancestor": (debugancestor, [], _('debugancestor INDEX REV1 REV2')),
2842 2842 "debugcomplete":
2843 2843 (debugcomplete,
2844 2844 [('o', 'options', None, _('show the command options'))],
2845 2845 _('debugcomplete [-o] CMD')),
2846 2846 "debuginstall": (debuginstall, [], _('debuginstall')),
2847 2847 "debugrebuildstate":
2848 2848 (debugrebuildstate,
2849 2849 [('r', 'rev', '', _('revision to rebuild to'))],
2850 2850 _('debugrebuildstate [-r REV] [REV]')),
2851 2851 "debugcheckstate": (debugcheckstate, [], _('debugcheckstate')),
2852 2852 "debugsetparents": (debugsetparents, [], _('debugsetparents REV1 [REV2]')),
2853 2853 "debugstate": (debugstate, [], _('debugstate')),
2854 2854 "debugdate":
2855 2855 (debugdate,
2856 2856 [('e', 'extended', None, _('try extended date formats'))],
2857 2857 _('debugdate [-e] DATE [RANGE]')),
2858 2858 "debugdata": (debugdata, [], _('debugdata FILE REV')),
2859 2859 "debugindex": (debugindex, [], _('debugindex FILE')),
2860 2860 "debugindexdot": (debugindexdot, [], _('debugindexdot FILE')),
2861 2861 "debugrename":
2862 2862 (debugrename,
2863 2863 [('r', 'rev', '', _('revision to debug'))],
2864 2864 _('debugrename [-r REV] FILE')),
2865 2865 "debugwalk": (debugwalk, walkopts, _('debugwalk [OPTION]... [FILE]...')),
2866 2866 "^diff":
2867 2867 (diff,
2868 2868 [('r', 'rev', [], _('revision')),
2869 2869 ('a', 'text', None, _('treat all files as text')),
2870 2870 ('p', 'show-function', None,
2871 2871 _('show which function each change is in')),
2872 2872 ('g', 'git', None, _('use git extended diff format')),
2873 2873 ('', 'nodates', None, _("don't include dates in diff headers")),
2874 2874 ('w', 'ignore-all-space', None,
2875 2875 _('ignore white space when comparing lines')),
2876 2876 ('b', 'ignore-space-change', None,
2877 2877 _('ignore changes in the amount of white space')),
2878 2878 ('B', 'ignore-blank-lines', None,
2879 2879 _('ignore changes whose lines are all blank')),
2880 2880 ] + walkopts,
2881 2881 _('hg diff [OPTION]... [-r REV1 [-r REV2]] [FILE]...')),
2882 2882 "^export":
2883 2883 (export,
2884 2884 [('o', 'output', '', _('print output to file with formatted name')),
2885 2885 ('a', 'text', None, _('treat all files as text')),
2886 2886 ('g', 'git', None, _('use git extended diff format')),
2887 2887 ('', 'nodates', None, _("don't include dates in diff headers")),
2888 2888 ('', 'switch-parent', None, _('diff against the second parent'))],
2889 2889 _('hg export [OPTION]... [-o OUTFILESPEC] REV...')),
2890 2890 "grep":
2891 2891 (grep,
2892 2892 [('0', 'print0', None, _('end fields with NUL')),
2893 2893 ('', 'all', None, _('print all revisions that match')),
2894 2894 ('f', 'follow', None,
2895 2895 _('follow changeset history, or file history across copies and renames')),
2896 2896 ('i', 'ignore-case', None, _('ignore case when matching')),
2897 2897 ('l', 'files-with-matches', None,
2898 2898 _('print only filenames and revs that match')),
2899 2899 ('n', 'line-number', None, _('print matching line numbers')),
2900 2900 ('r', 'rev', [], _('search in given revision range')),
2901 2901 ('u', 'user', None, _('print user who committed change')),
2902 2902 ] + walkopts,
2903 2903 _('hg grep [OPTION]... PATTERN [FILE]...')),
2904 2904 "heads":
2905 2905 (heads,
2906 2906 [('', 'style', '', _('display using template map file')),
2907 2907 ('r', 'rev', '', _('show only heads which are descendants of rev')),
2908 2908 ('', 'template', '', _('display with template'))],
2909 2909 _('hg heads [-r REV] [REV]...')),
2910 2910 "help": (help_, [], _('hg help [COMMAND]')),
2911 2911 "identify|id":
2912 2912 (identify,
2913 2913 [('r', 'rev', '', _('identify the specified rev')),
2914 2914 ('n', 'num', None, _('show local revision number')),
2915 2915 ('i', 'id', None, _('show global revision id')),
2916 2916 ('b', 'branch', None, _('show branch')),
2917 2917 ('t', 'tags', None, _('show tags'))],
2918 2918 _('hg identify [-nibt] [-r REV] [SOURCE]')),
2919 2919 "import|patch":
2920 2920 (import_,
2921 2921 [('p', 'strip', 1,
2922 2922 _('directory strip option for patch. This has the same\n'
2923 2923 'meaning as the corresponding patch option')),
2924 2924 ('b', 'base', '', _('base path')),
2925 2925 ('f', 'force', None,
2926 2926 _('skip check for outstanding uncommitted changes')),
2927 2927 ('', 'exact', None,
2928 2928 _('apply patch to the nodes from which it was generated')),
2929 2929 ('', 'import-branch', None,
2930 2930 _('Use any branch information in patch (implied by --exact)'))] + commitopts,
2931 2931 _('hg import [-p NUM] [-m MESSAGE] [-f] PATCH...')),
2932 2932 "incoming|in": (incoming,
2933 2933 [('M', 'no-merges', None, _('do not show merges')),
2934 2934 ('f', 'force', None,
2935 2935 _('run even when remote repository is unrelated')),
2936 2936 ('', 'style', '', _('display using template map file')),
2937 2937 ('n', 'newest-first', None, _('show newest record first')),
2938 2938 ('', 'bundle', '', _('file to store the bundles into')),
2939 2939 ('p', 'patch', None, _('show patch')),
2940 2940 ('r', 'rev', [], _('a specific revision up to which you would like to pull')),
2941 2941 ('', 'template', '', _('display with template')),
2942 2942 ] + remoteopts,
2943 2943 _('hg incoming [-p] [-n] [-M] [-f] [-r REV]...'
2944 2944 ' [--bundle FILENAME] [SOURCE]')),
2945 2945 "^init":
2946 2946 (init,
2947 2947 remoteopts,
2948 2948 _('hg init [-e CMD] [--remotecmd CMD] [DEST]')),
2949 2949 "locate":
2950 2950 (locate,
2951 2951 [('r', 'rev', '', _('search the repository as it stood at rev')),
2952 2952 ('0', 'print0', None,
2953 2953 _('end filenames with NUL, for use with xargs')),
2954 2954 ('f', 'fullpath', None,
2955 2955 _('print complete paths from the filesystem root')),
2956 2956 ] + walkopts,
2957 2957 _('hg locate [OPTION]... [PATTERN]...')),
2958 2958 "^log|history":
2959 2959 (log,
2960 2960 [('f', 'follow', None,
2961 2961 _('follow changeset history, or file history across copies and renames')),
2962 2962 ('', 'follow-first', None,
2963 2963 _('only follow the first parent of merge changesets')),
2964 2964 ('d', 'date', '', _('show revs matching date spec')),
2965 2965 ('C', 'copies', None, _('show copied files')),
2966 2966 ('k', 'keyword', [], _('do case-insensitive search for a keyword')),
2967 2967 ('l', 'limit', '', _('limit number of changes displayed')),
2968 2968 ('r', 'rev', [], _('show the specified revision or range')),
2969 2969 ('', 'removed', None, _('include revs where files were removed')),
2970 2970 ('M', 'no-merges', None, _('do not show merges')),
2971 2971 ('', 'style', '', _('display using template map file')),
2972 2972 ('m', 'only-merges', None, _('show only merges')),
2973 2973 ('p', 'patch', None, _('show patch')),
2974 2974 ('P', 'prune', [], _('do not display revision or any of its ancestors')),
2975 2975 ('', 'template', '', _('display with template')),
2976 2976 ] + walkopts,
2977 2977 _('hg log [OPTION]... [FILE]')),
2978 2978 "manifest": (manifest, [], _('hg manifest [REV]')),
2979 2979 "^merge":
2980 2980 (merge,
2981 2981 [('f', 'force', None, _('force a merge with outstanding changes')),
2982 2982 ('r', 'rev', '', _('revision to merge')),
2983 2983 ],
2984 2984 _('hg merge [-f] [[-r] REV]')),
2985 2985 "outgoing|out": (outgoing,
2986 2986 [('M', 'no-merges', None, _('do not show merges')),
2987 2987 ('f', 'force', None,
2988 2988 _('run even when remote repository is unrelated')),
2989 2989 ('p', 'patch', None, _('show patch')),
2990 2990 ('', 'style', '', _('display using template map file')),
2991 2991 ('r', 'rev', [], _('a specific revision you would like to push')),
2992 2992 ('n', 'newest-first', None, _('show newest record first')),
2993 2993 ('', 'template', '', _('display with template')),
2994 2994 ] + remoteopts,
2995 2995 _('hg outgoing [-M] [-p] [-n] [-f] [-r REV]... [DEST]')),
2996 2996 "^parents":
2997 2997 (parents,
2998 2998 [('r', 'rev', '', _('show parents from the specified rev')),
2999 2999 ('', 'style', '', _('display using template map file')),
3000 3000 ('', 'template', '', _('display with template'))],
3001 3001 _('hg parents [-r REV] [FILE]')),
3002 3002 "paths": (paths, [], _('hg paths [NAME]')),
3003 3003 "^pull":
3004 3004 (pull,
3005 3005 [('u', 'update', None,
3006 3006 _('update to new tip if changesets were pulled')),
3007 3007 ('f', 'force', None,
3008 3008 _('run even when remote repository is unrelated')),
3009 3009 ('r', 'rev', [],
3010 3010 _('a specific revision up to which you would like to pull')),
3011 3011 ] + remoteopts,
3012 3012 _('hg pull [-u] [-f] [-r REV]... [-e CMD] [--remotecmd CMD] [SOURCE]')),
3013 3013 "^push":
3014 3014 (push,
3015 3015 [('f', 'force', None, _('force push')),
3016 3016 ('r', 'rev', [], _('a specific revision you would like to push')),
3017 3017 ] + remoteopts,
3018 3018 _('hg push [-f] [-r REV]... [-e CMD] [--remotecmd CMD] [DEST]')),
3019 3019 "debugrawcommit|rawcommit":
3020 3020 (rawcommit,
3021 3021 [('p', 'parent', [], _('parent')),
3022 3022 ('d', 'date', '', _('date code')),
3023 3023 ('u', 'user', '', _('user')),
3024 3024 ('F', 'files', '', _('file list'))
3025 3025 ] + commitopts,
3026 3026 _('hg debugrawcommit [OPTION]... [FILE]...')),
3027 3027 "recover": (recover, [], _('hg recover')),
3028 3028 "^remove|rm":
3029 3029 (remove,
3030 3030 [('A', 'after', None, _('record remove that has already occurred')),
3031 3031 ('f', 'force', None, _('remove file even if modified')),
3032 3032 ] + walkopts,
3033 3033 _('hg remove [OPTION]... FILE...')),
3034 3034 "rename|mv":
3035 3035 (rename,
3036 3036 [('A', 'after', None, _('record a rename that has already occurred')),
3037 3037 ('f', 'force', None,
3038 3038 _('forcibly copy over an existing managed file')),
3039 3039 ] + walkopts + dryrunopts,
3040 3040 _('hg rename [OPTION]... SOURCE... DEST')),
3041 3041 "^revert":
3042 3042 (revert,
3043 3043 [('a', 'all', None, _('revert all changes when no arguments given')),
3044 3044 ('d', 'date', '', _('tipmost revision matching date')),
3045 3045 ('r', 'rev', '', _('revision to revert to')),
3046 3046 ('', 'no-backup', None, _('do not save backup copies of files')),
3047 3047 ] + walkopts + dryrunopts,
3048 3048 _('hg revert [OPTION]... [-r REV] [NAME]...')),
3049 3049 "rollback": (rollback, [], _('hg rollback')),
3050 3050 "root": (root, [], _('hg root')),
3051 3051 "showconfig|debugconfig":
3052 3052 (showconfig,
3053 3053 [('u', 'untrusted', None, _('show untrusted configuration options'))],
3054 3054 _('showconfig [-u] [NAME]...')),
3055 3055 "^serve":
3056 3056 (serve,
3057 3057 [('A', 'accesslog', '', _('name of access log file to write to')),
3058 3058 ('d', 'daemon', None, _('run server in background')),
3059 3059 ('', 'daemon-pipefds', '', _('used internally by daemon mode')),
3060 3060 ('E', 'errorlog', '', _('name of error log file to write to')),
3061 3061 ('p', 'port', 0, _('port to use (default: 8000)')),
3062 3062 ('a', 'address', '', _('address to use')),
3063 3063 ('n', 'name', '',
3064 3064 _('name to show in web pages (default: working dir)')),
3065 3065 ('', 'webdir-conf', '', _('name of the webdir config file'
3066 3066 ' (serve more than one repo)')),
3067 3067 ('', 'pid-file', '', _('name of file to write process ID to')),
3068 3068 ('', 'stdio', None, _('for remote clients')),
3069 3069 ('t', 'templates', '', _('web templates to use')),
3070 3070 ('', 'style', '', _('template style to use')),
3071 3071 ('6', 'ipv6', None, _('use IPv6 in addition to IPv4'))],
3072 3072 _('hg serve [OPTION]...')),
3073 3073 "^status|st":
3074 3074 (status,
3075 3075 [('A', 'all', None, _('show status of all files')),
3076 3076 ('m', 'modified', None, _('show only modified files')),
3077 3077 ('a', 'added', None, _('show only added files')),
3078 3078 ('r', 'removed', None, _('show only removed files')),
3079 3079 ('d', 'deleted', None, _('show only deleted (but tracked) files')),
3080 3080 ('c', 'clean', None, _('show only files without changes')),
3081 3081 ('u', 'unknown', None, _('show only unknown (not tracked) files')),
3082 3082 ('i', 'ignored', None, _('show only ignored files')),
3083 3083 ('n', 'no-status', None, _('hide status prefix')),
3084 3084 ('C', 'copies', None, _('show source of copied files')),
3085 3085 ('0', 'print0', None,
3086 3086 _('end filenames with NUL, for use with xargs')),
3087 3087 ('', 'rev', [], _('show difference from revision')),
3088 3088 ] + walkopts,
3089 3089 _('hg status [OPTION]... [FILE]...')),
3090 3090 "tag":
3091 3091 (tag,
3092 3092 [('f', 'force', None, _('replace existing tag')),
3093 3093 ('l', 'local', None, _('make the tag local')),
3094 3094 ('m', 'message', '', _('message for tag commit log entry')),
3095 3095 ('d', 'date', '', _('record datecode as commit date')),
3096 3096 ('u', 'user', '', _('record user as commiter')),
3097 3097 ('r', 'rev', '', _('revision to tag')),
3098 3098 ('', 'remove', None, _('remove a tag'))],
3099 3099 _('hg tag [-l] [-m TEXT] [-d DATE] [-u USER] [-r REV] NAME')),
3100 3100 "tags": (tags, [], _('hg tags')),
3101 3101 "tip":
3102 3102 (tip,
3103 3103 [('', 'style', '', _('display using template map file')),
3104 3104 ('p', 'patch', None, _('show patch')),
3105 3105 ('', 'template', '', _('display with template'))],
3106 3106 _('hg tip [-p]')),
3107 3107 "unbundle":
3108 3108 (unbundle,
3109 3109 [('u', 'update', None,
3110 3110 _('update to new tip if changesets were unbundled'))],
3111 3111 _('hg unbundle [-u] FILE...')),
3112 3112 "^update|up|checkout|co":
3113 3113 (update,
3114 3114 [('C', 'clean', None, _('overwrite locally modified files')),
3115 3115 ('d', 'date', '', _('tipmost revision matching date')),
3116 3116 ('r', 'rev', '', _('revision'))],
3117 3117 _('hg update [-C] [-d DATE] [[-r] REV]')),
3118 3118 "verify": (verify, [], _('hg verify')),
3119 3119 "version": (version_, [], _('hg version')),
3120 3120 }
3121 3121
3122 3122 norepo = ("clone init version help debugancestor debugcomplete debugdata"
3123 3123 " debugindex debugindexdot debugdate debuginstall")
3124 3124 optionalrepo = ("paths serve showconfig")
3125 3125
3126 3126 def dispatch(args, argv0=None):
3127 3127 try:
3128 3128 u = ui.ui(traceback='--traceback' in args)
3129 3129 except util.Abort, inst:
3130 3130 sys.stderr.write(_("abort: %s\n") % inst)
3131 3131 return -1
3132 3132 return cmdutil.runcatch(u, args, argv0=argv0)
3133 3133
3134 3134 def run():
3135 3135 sys.exit(dispatch(sys.argv[1:], argv0=sys.argv[0]))
General Comments 0
You need to be logged in to leave comments. Login now