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