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