commands.py
3931 lines
| 142.7 KiB
| text/x-python
|
PythonLexer
/ mercurial / commands.py
|
r249 | # commands.py - command processing for mercurial | ||
# | ||||
|
r4635 | # Copyright 2005-2007 Matt Mackall <mpm@selenic.com> | ||
|
r249 | # | ||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r249 | |||
|
r6211 | from node import hex, nullid, nullrev, short | ||
|
r8109 | from lock import release | ||
|
r7013 | from i18n import _, gettext | ||
|
r9678 | import os, re, sys, difflib, time, tempfile | ||
import hg, util, revlog, bundlerepo, extensions, copies, error | ||||
|
r10060 | import patch, help, mdiff, url, encoding, templatekw | ||
|
r11004 | import archival, changegroup, cmdutil, sshserver, hbisect, hgweb, hgweb.server | ||
|
r10651 | import merge as mergemod | ||
|
r9157 | import minirst | ||
|
r2731 | |||
|
r255 | # Commands start here, listed alphabetically | ||
|
r209 | |||
|
r724 | def add(ui, repo, *pats, **opts): | ||
|
r1437 | """add the specified files on the next commit | ||
|
r8004 | Schedule files to be version controlled and added to the | ||
repository. | ||||
|
r1437 | |||
|
r3829 | The files will be added to the repository at the next commit. To | ||
|
r8902 | undo an add before that, see hg forget. | ||
|
r1437 | |||
|
r7807 | If no names are given, add all files to the repository. | ||
|
r10446 | |||
.. container:: verbose | ||||
An example showing how new (unknown) files are added | ||||
|
r10973 | automatically by :hg:`add`:: | ||
|
r10446 | |||
$ ls | ||||
foo.c | ||||
$ hg status | ||||
? foo.c | ||||
$ hg add | ||||
adding foo.c | ||||
$ hg status | ||||
|
r10448 | A foo.c | ||
|
r1437 | """ | ||
|
r8679 | bad = [] | ||
|
r724 | names = [] | ||
|
r6579 | m = cmdutil.match(repo, pats, opts) | ||
|
r8679 | oldbad = m.bad | ||
|
r10282 | m.bad = lambda x, y: bad.append(x) or oldbad(x, y) | ||
|
r8679 | |||
for f in repo.walk(m): | ||||
exact = m.exact(f) | ||||
if exact or f not in repo.dirstate: | ||||
names.append(f) | ||||
if ui.verbose or not exact: | ||||
ui.status(_('adding %s\n') % m.rel(f)) | ||||
|
r2503 | if not opts.get('dry_run'): | ||
|
r8679 | bad += [f for f in repo.add(names) if f in m.files()] | ||
return bad and 1 or 0 | ||||
|
r213 | |||
|
r766 | def addremove(ui, repo, *pats, **opts): | ||
|
r3181 | """add all new files, delete all missing files | ||
|
r2181 | |||
|
r8004 | Add all new files and remove all missing files from the | ||
repository. | ||||
New files are ignored if they match any of the patterns in | ||||
.hgignore. As with add, these changes take effect at the next | ||||
commit. | ||||
|
r2958 | |||
|
r8033 | Use the -s/--similarity option to detect renamed files. With a | ||
|
r9249 | parameter greater than 0, this compares every removed file with | ||
every added file and records those similar enough as renames. This | ||||
option takes a percentage between 0 (disabled) and 100 (files must | ||||
be identical) as its parameter. Detecting renamed files this way | ||||
can be expensive. | ||||
|
r1437 | """ | ||
|
r4966 | try: | ||
sim = float(opts.get('similarity') or 0) | ||||
except ValueError: | ||||
raise util.Abort(_('similarity must be a number')) | ||||
|
r2958 | if sim < 0 or sim > 100: | ||
raise util.Abort(_('similarity must be between 0 and 100')) | ||||
|
r10282 | return cmdutil.addremove(repo, pats, opts, similarity=sim / 100.0) | ||
|
r219 | |||
|
r733 | def annotate(ui, repo, *pats, **opts): | ||
|
r8779 | """show changeset information by line for each file | ||
|
r1437 | |||
|
r8004 | List changes in files, showing the revision id responsible for | ||
each line | ||||
|
r8779 | This command is useful for discovering when a change was made and | ||
by whom. | ||||
|
r1437 | |||
|
r8033 | Without the -a/--text option, annotate will avoid processing files | ||
|
r8779 | it detects as binary. With -a, annotate will annotate the file | ||
anyway, although the results will probably be neither useful | ||||
nor desirable. | ||||
|
r1437 | """ | ||
|
r10579 | if opts.get('follow'): | ||
# --follow is deprecated and now just an alias for -f/--file | ||||
# to mimic the behavior of Mercurial before version 1.5 | ||||
opts['file'] = 1 | ||||
|
r6134 | datefunc = ui.quiet and util.shortdate or util.datestr | ||
getdate = util.cachefunc(lambda x: datefunc(x[0].date())) | ||||
|
r1522 | |||
|
r744 | if not pats: | ||
|
r8761 | raise util.Abort(_('at least one filename or pattern is required')) | ||
|
r744 | |||
|
r4857 | opmap = [('user', lambda x: ui.shortuser(x[0].user())), | ||
('number', lambda x: str(x[0].rev())), | ||||
('changeset', lambda x: short(x[0].node())), | ||||
('date', getdate), | ||||
|
r10369 | ('file', lambda x: x[0].path()), | ||
|
r4857 | ] | ||
|
r10282 | if (not opts.get('user') and not opts.get('changeset') | ||
|
r10369 | and not opts.get('date') and not opts.get('file')): | ||
|
r714 | opts['number'] = 1 | ||
|
r209 | |||
|
r4857 | linenumber = opts.get('line_number') is not None | ||
|
r10394 | if linenumber and (not opts.get('changeset')) and (not opts.get('number')): | ||
|
r4857 | raise util.Abort(_('at least one of -n/-c is required for -l')) | ||
funcmap = [func for op, func in opmap if opts.get(op)] | ||||
if linenumber: | ||||
lastfunc = funcmap[-1] | ||||
funcmap[-1] = lambda x: "%s:%s" % (lastfunc(x), x[1]) | ||||
|
r7131 | ctx = repo[opts.get('rev')] | ||
|
r6579 | m = cmdutil.match(repo, pats, opts) | ||
|
r10369 | follow = not opts.get('no_follow') | ||
|
r6764 | for abs in ctx.walk(m): | ||
fctx = ctx[abs] | ||||
|
r7131 | if not opts.get('text') and util.binary(fctx.data()): | ||
|
r6584 | ui.write(_("%s: binary file\n") % ((pats and m.rel(abs)) or abs)) | ||
|
r1016 | continue | ||
|
r10369 | lines = fctx.annotate(follow=follow, linenumber=linenumber) | ||
|
r209 | pieces = [] | ||
|
r4857 | for f in funcmap: | ||
l = [f(n) for n, dummy in lines] | ||||
if l: | ||||
|
r7094 | ml = max(map(len, l)) | ||
pieces.append(["%*s" % (ml, x) for x in l]) | ||||
|
r209 | |||
|
r771 | if pieces: | ||
for p, l in zip(zip(*pieces), lines): | ||||
ui.write("%s: %s" % (" ".join(p), l[1])) | ||||
|
r209 | |||
|
r2112 | def archive(ui, repo, dest, **opts): | ||
|
r8779 | '''create an unversioned archive of a repository revision | ||
|
r2112 | |||
By default, the revision used is the parent of the working | ||||
|
r8033 | directory; use -r/--rev to specify a different revision. | ||
|
r10650 | The archive type is automatically detected based on file | ||
extension (or override using -t/--type). | ||||
Valid types are: | ||||
|
r9892 | |||
:``files``: a directory full of files (default) | ||||
:``tar``: tar archive, uncompressed | ||||
:``tbz2``: tar archive, compressed using bzip2 | ||||
:``tgz``: tar archive, compressed using gzip | ||||
:``uzip``: zip archive, uncompressed | ||||
:``zip``: zip archive, compressed using deflate | ||||
|
r2112 | |||
The exact name of the destination archive or directory is given | ||||
|
r10973 | using a format string; see :hg:`help export` for details. | ||
|
r2112 | |||
Each member added to an archive file has a directory prefix | ||||
|
r8033 | prepended. Use -p/--prefix to specify a format string for the | ||
prefix. The default is the basename of the archive, with suffixes | ||||
removed. | ||||
|
r2112 | ''' | ||
|
r7131 | ctx = repo[opts.get('rev')] | ||
|
r5061 | if not ctx: | ||
|
r7528 | raise util.Abort(_('no working directory: please specify a revision')) | ||
|
r5061 | node = ctx.node() | ||
|
r2874 | dest = cmdutil.make_filename(repo, dest, node) | ||
|
r2112 | if os.path.realpath(dest) == repo.root: | ||
raise util.Abort(_('repository root cannot be destination')) | ||||
|
r10650 | |||
def guess_type(): | ||||
exttypes = { | ||||
'tar': ['.tar'], | ||||
'tbz2': ['.tbz2', '.tar.bz2'], | ||||
'tgz': ['.tgz', '.tar.gz'], | ||||
'zip': ['.zip'], | ||||
} | ||||
for type, extensions in exttypes.items(): | ||||
|
r10654 | if util.any(dest.endswith(ext) for ext in extensions): | ||
|
r10650 | return type | ||
return None | ||||
kind = opts.get('type') or guess_type() or 'files' | ||||
|
r7131 | prefix = opts.get('prefix') | ||
|
r10650 | |||
|
r2476 | if dest == '-': | ||
if kind == 'files': | ||||
raise util.Abort(_('cannot archive plain files to stdout')) | ||||
dest = sys.stdout | ||||
|
r10282 | if not prefix: | ||
prefix = os.path.basename(repo.root) + '-%h' | ||||
|
r10650 | |||
|
r2874 | prefix = cmdutil.make_filename(repo, prefix, node) | ||
|
r10650 | matchfn = cmdutil.match(repo, [], opts) | ||
|
r7131 | archival.archive(repo, dest, node, kind, not opts.get('no_decode'), | ||
|
r2476 | matchfn, prefix) | ||
|
r2112 | |||
|
r4450 | def backout(ui, repo, node=None, rev=None, **opts): | ||
|
r2158 | '''reverse effect of earlier changeset | ||
|
r6448 | Commit the backed out changes as a new changeset. The new | ||
|
r2254 | changeset is a child of the backed out changeset. | ||
|
r2158 | |||
|
r8779 | If you backout a changeset other than the tip, a new head is | ||
|
r6448 | created. This head will be the new tip and you should merge this | ||
|
r8779 | backout changeset with another head. | ||
|
r2254 | |||
The --merge option remembers the parent of the working directory | ||||
before starting the backout, then merges the new head with that | ||||
|
r8004 | changeset afterwards. This saves you from doing the merge by hand. | ||
The result of this merge is not committed, as with a normal merge. | ||||
|
r6163 | |||
|
r10973 | See :hg:`help dates` for a list of formats valid for -d/--date. | ||
|
r6163 | ''' | ||
|
r4450 | if rev and node: | ||
raise util.Abort(_("please specify just one revision")) | ||||
if not rev: | ||||
rev = node | ||||
|
r2158 | |||
|
r4726 | if not rev: | ||
raise util.Abort(_("please specify a revision to backout")) | ||||
|
r6139 | date = opts.get('date') | ||
if date: | ||||
opts['date'] = util.parsedate(date) | ||||
|
r4549 | cmdutil.bail_if_changed(repo) | ||
|
r5716 | node = repo.lookup(rev) | ||
|
r2158 | op1, op2 = repo.dirstate.parents() | ||
|
r5568 | a = repo.changelog.ancestor(op1, node) | ||
if a != node: | ||||
|
r8779 | raise util.Abort(_('cannot backout change on a different branch')) | ||
|
r5568 | |||
|
r2614 | p1, p2 = repo.changelog.parents(node) | ||
if p1 == nullid: | ||||
|
r8779 | raise util.Abort(_('cannot backout a change with no parents')) | ||
|
r2158 | if p2 != nullid: | ||
|
r7131 | if not opts.get('parent'): | ||
|
r8779 | raise util.Abort(_('cannot backout a merge changeset without ' | ||
|
r2614 | '--parent')) | ||
p = repo.lookup(opts['parent']) | ||||
if p not in (p1, p2): | ||||
|
r3679 | raise util.Abort(_('%s is not a parent of %s') % | ||
|
r3680 | (short(p), short(node))) | ||
|
r2614 | parent = p | ||
else: | ||||
|
r7131 | if opts.get('parent'): | ||
|
r2614 | raise util.Abort(_('cannot use --parent on non-merge changeset')) | ||
parent = p1 | ||||
|
r5568 | |||
|
r6423 | # the backout should appear on the same branch | ||
branch = repo.dirstate.branch() | ||||
|
r2808 | hg.clean(repo, node, show_stats=False) | ||
|
r6423 | repo.dirstate.setbranch(branch) | ||
|
r2158 | revert_opts = opts.copy() | ||
|
r3814 | revert_opts['date'] = None | ||
|
r2982 | revert_opts['all'] = True | ||
|
r2158 | revert_opts['rev'] = hex(parent) | ||
|
r6031 | revert_opts['no_backup'] = None | ||
|
r2158 | revert(ui, repo, **revert_opts) | ||
commit_opts = opts.copy() | ||||
commit_opts['addremove'] = False | ||||
|
r2159 | if not commit_opts['message'] and not commit_opts['logfile']: | ||
|
r9183 | # we don't translate commit messages | ||
|
r9197 | commit_opts['message'] = "Backed out changeset %s" % short(node) | ||
|
r2268 | commit_opts['force_editor'] = True | ||
|
r2158 | commit(ui, repo, **commit_opts) | ||
def nice(node): | ||||
return '%d:%s' % (repo.changelog.rev(node), short(node)) | ||||
ui.status(_('changeset %s backs out changeset %s\n') % | ||||
(nice(repo.changelog.tip()), nice(node))) | ||||
|
r2493 | if op1 != node: | ||
|
r6161 | hg.clean(repo, op1, show_stats=False) | ||
|
r7131 | if opts.get('merge'): | ||
|
r10282 | ui.status(_('merging with changeset %s\n') | ||
% nice(repo.changelog.tip())) | ||||
|
r6161 | hg.merge(repo, hex(repo.changelog.tip())) | ||
|
r2493 | else: | ||
ui.status(_('the backout changeset is a new head - ' | ||||
'do not forget to merge\n')) | ||||
|
r2761 | ui.status(_('(use "backout --merge" ' | ||
'if you want to auto-merge)\n')) | ||||
|
r2158 | |||
|
r7227 | def bisect(ui, repo, rev=None, extra=None, command=None, | ||
|
r5775 | reset=None, good=None, bad=None, skip=None, noupdate=None): | ||
"""subdivision search of changesets | ||||
|
r8004 | This command helps to find changesets which introduce problems. To | ||
use, mark the earliest changeset you know exhibits the problem as | ||||
bad, then mark the latest changeset which is free from the problem | ||||
as good. Bisect will update your working directory to a revision | ||||
|
r8033 | for testing (unless the -U/--noupdate option is specified). Once | ||
|
r8779 | you have performed tests, mark the working directory as good or | ||
bad, and bisect will either update to another candidate changeset | ||||
|
r6928 | or announce that it has found the bad revision. | ||
|
r7184 | |||
|
r6928 | As a shortcut, you can also use the revision argument to mark a | ||
revision as good or bad without checking it out first. | ||||
|
r7227 | |||
|
r8779 | If you supply a command, it will be used for automatic bisection. | ||
Its exit status will be used to mark revisions as good or bad: | ||||
status 0 means good, 125 means to skip the revision, 127 | ||||
(command not found) will abort the bisection, and any other | ||||
non-zero exit status means the revision is bad. | ||||
|
r5775 | """ | ||
|
r7227 | def print_result(nodes, good): | ||
|
r5775 | displayer = cmdutil.show_changeset(ui, repo, {}) | ||
|
r6858 | if len(nodes) == 1: | ||
# narrowed it down to a single revision | ||||
|
r8088 | if good: | ||
ui.write(_("The first good revision is:\n")) | ||||
else: | ||||
ui.write(_("The first bad revision is:\n")) | ||||
|
r7369 | displayer.show(repo[nodes[0]]) | ||
|
r6858 | else: | ||
# multiple possible revisions | ||||
|
r8088 | if good: | ||
ui.write(_("Due to skipped revisions, the first " | ||||
"good revision could be any of:\n")) | ||||
else: | ||||
ui.write(_("Due to skipped revisions, the first " | ||||
"bad revision could be any of:\n")) | ||||
|
r6858 | for n in nodes: | ||
|
r7369 | displayer.show(repo[n]) | ||
|
r10152 | displayer.close() | ||
|
r7227 | |||
def check_state(state, interactive=True): | ||||
if not state['good'] or not state['bad']: | ||||
if (good or bad or skip or reset) and interactive: | ||||
return | ||||
if not state['good']: | ||||
raise util.Abort(_('cannot bisect (no known good revisions)')) | ||||
else: | ||||
raise util.Abort(_('cannot bisect (no known bad revisions)')) | ||||
return True | ||||
# backward compatibility | ||||
if rev in "good bad reset init".split(): | ||||
ui.warn(_("(use of 'hg bisect <cmd>' is deprecated)\n")) | ||||
cmd, rev, extra = rev, extra, None | ||||
if cmd == "good": | ||||
good = True | ||||
elif cmd == "bad": | ||||
bad = True | ||||
else: | ||||
reset = True | ||||
elif extra or good + bad + skip + reset + bool(command) > 1: | ||||
raise util.Abort(_('incompatible arguments')) | ||||
if reset: | ||||
p = repo.join("bisect.state") | ||||
if os.path.exists(p): | ||||
os.unlink(p) | ||||
return | ||||
state = hbisect.load_state(repo) | ||||
if command: | ||||
changesets = 1 | ||||
|
r7590 | try: | ||
while changesets: | ||||
# update state | ||||
|
r9584 | status = util.system(command) | ||
|
r7590 | if status == 125: | ||
transition = "skip" | ||||
elif status == 0: | ||||
transition = "good" | ||||
# status < 0 means process was killed | ||||
elif status == 127: | ||||
raise util.Abort(_("failed to execute %s") % command) | ||||
elif status < 0: | ||||
raise util.Abort(_("%s killed") % command) | ||||
else: | ||||
transition = "bad" | ||||
|
r8805 | ctx = repo[rev or '.'] | ||
state[transition].append(ctx.node()) | ||||
ui.status(_('Changeset %d:%s: %s\n') % (ctx, ctx, transition)) | ||||
|
r7590 | check_state(state, interactive=False) | ||
# bisect | ||||
nodes, changesets, good = hbisect.bisect(repo.changelog, state) | ||||
# update to next check | ||||
cmdutil.bail_if_changed(repo) | ||||
hg.clean(repo, nodes[0], show_stats=False) | ||||
finally: | ||||
hbisect.save_state(repo, state) | ||||
|
r9584 | return print_result(nodes, good) | ||
|
r7227 | |||
# update state | ||||
node = repo.lookup(rev or '.') | ||||
|
r9689 | if good or bad or skip: | ||
if good: | ||||
state['good'].append(node) | ||||
elif bad: | ||||
state['bad'].append(node) | ||||
elif skip: | ||||
state['skip'].append(node) | ||||
hbisect.save_state(repo, state) | ||||
|
r7227 | |||
if not check_state(state): | ||||
return | ||||
# actually bisect | ||||
nodes, changesets, good = hbisect.bisect(repo.changelog, state) | ||||
if changesets == 0: | ||||
print_result(nodes, good) | ||||
|
r6858 | else: | ||
assert len(nodes) == 1 # only a single node can be tested next | ||||
node = nodes[0] | ||||
|
r5775 | # compute the approximate number of remaining tests | ||
tests, size = 0, 2 | ||||
while size <= changesets: | ||||
tests, size = tests + 1, size * 2 | ||||
rev = repo.changelog.rev(node) | ||||
|
r9012 | ui.write(_("Testing changeset %d:%s " | ||
"(%d changesets remaining, ~%d tests)\n") | ||||
|
r6217 | % (rev, short(node), changesets, tests)) | ||
|
r5775 | if not noupdate: | ||
cmdutil.bail_if_changed(repo) | ||||
return hg.clean(repo, node) | ||||
|
r4202 | def branch(ui, repo, label=None, **opts): | ||
|
r3502 | """set or show the current branch name | ||
|
r4601 | With no argument, show the current branch name. With one argument, | ||
|
r8779 | set the working directory branch name (the branch will not exist | ||
in the repository until the next commit). Standard practice | ||||
recommends that primary development take place on the 'default' | ||||
branch. | ||||
|
r4202 | |||
|
r8033 | Unless -f/--force is specified, branch will not let you set a | ||
|
r8779 | branch name that already exists, even if it's inactive. | ||
|
r5999 | |||
|
r8033 | Use -C/--clean to reset the working directory branch to that of | ||
the parent of the working directory, negating a previous branch | ||||
|
r8004 | change. | ||
|
r7006 | |||
|
r10973 | Use the command :hg:`update` to switch to an existing branch. Use | ||
:hg:`commit --close-branch` to mark this branch as closed. | ||||
|
r3502 | """ | ||
|
r7006 | if opts.get('clean'): | ||
label = repo[None].parents()[0].branch() | ||||
repo.dirstate.setbranch(label) | ||||
ui.status(_('reset working directory to branch %s\n') % label) | ||||
elif label: | ||||
|
r10315 | utflabel = encoding.fromlocal(label) | ||
if not opts.get('force') and utflabel in repo.branchtags(): | ||||
|
r6747 | if label not in [p.branch() for p in repo.parents()]: | ||
|
r4202 | raise util.Abort(_('a branch of the same name already exists' | ||
|
r10596 | " (use 'hg update' to switch to it)")) | ||
|
r10315 | repo.dirstate.setbranch(utflabel) | ||
|
r4601 | ui.status(_('marked working directory as branch %s\n') % label) | ||
|
r3502 | else: | ||
|
r7948 | ui.write("%s\n" % encoding.tolocal(repo.dirstate.branch())) | ||
|
r3502 | |||
|
r8991 | def branches(ui, repo, active=False, closed=False): | ||
|
r3502 | """list repository named branches | ||
|
r4675 | List the repository's named branches, indicating which ones are | ||
|
r8991 | inactive. If -c/--closed is specified, also list branches which have | ||
been marked closed (see hg commit --close-branch). | ||||
If -a/--active is specified, only show active branches. A branch | ||||
is considered active if it contains repository heads. | ||||
|
r5999 | |||
|
r10973 | Use the command :hg:`update` to switch to an existing branch. | ||
|
r3502 | """ | ||
|
r8991 | |||
|
r6631 | hexfunc = ui.debugflag and hex or short | ||
|
r9675 | activebranches = [repo[n].branch() for n in repo.heads()] | ||
|
r8796 | def testactive(tag, node): | ||
realhead = tag in activebranches | ||||
open = node in repo.branchheads(tag, closed=False) | ||||
return realhead and open | ||||
branches = sorted([(testactive(tag, node), repo.changelog.rev(node), tag) | ||||
|
r8210 | for tag, node in repo.branchtags().items()], | ||
reverse=True) | ||||
|
r6631 | |||
for isactive, node, tag in branches: | ||||
if (not active) or isactive: | ||||
|
r9675 | encodedtag = encoding.tolocal(tag) | ||
|
r4675 | if ui.quiet: | ||
|
r9675 | ui.write("%s\n" % encodedtag) | ||
|
r4675 | else: | ||
|
r7656 | hn = repo.lookup(node) | ||
if isactive: | ||||
notice = '' | ||||
elif hn not in repo.branchheads(tag, closed=False): | ||||
|
r8991 | if not closed: | ||
continue | ||||
|
r9951 | notice = _(' (closed)') | ||
|
r7656 | else: | ||
|
r9951 | notice = _(' (inactive)') | ||
|
r9675 | rev = str(node).rjust(31 - encoding.colwidth(encodedtag)) | ||
data = encodedtag, rev, hexfunc(hn), notice | ||||
|
r6814 | ui.write("%s %s:%s%s\n" % data) | ||
|
r3502 | |||
|
r2494 | def bundle(ui, repo, fname, dest=None, **opts): | ||
|
r1437 | """create a changegroup file | ||
|
r3511 | Generate a compressed changegroup file collecting changesets not | ||
|
r7807 | known to be in another repository. | ||
|
r3511 | |||
|
r10376 | If you omit the destination repository, then hg assumes the | ||
destination will have all the nodes you specify with --base | ||||
|
r6448 | parameters. To create a bundle containing all changesets, use | ||
|
r8903 | -a/--all (or --base null). | ||
|
r8958 | You can change compression method with the -t/--type option. | ||
The available compression methods are: none, bzip2, and | ||||
|
r8903 | gzip (by default, bundles are compressed using bzip2). | ||
|
r3511 | |||
|
r8004 | The bundle file can then be transferred using conventional means | ||
and applied to another repository with the unbundle or pull | ||||
command. This is useful when direct push and pull are not | ||||
available or when exporting an entire repository is undesirable. | ||||
|
r3511 | |||
Applying bundles preserves all changeset contents including | ||||
permissions, copy/rename information, and revision history. | ||||
|
r1437 | """ | ||
|
r3284 | revs = opts.get('rev') or None | ||
if revs: | ||||
revs = [repo.lookup(rev) for rev in revs] | ||||
|
r6171 | if opts.get('all'): | ||
base = ['null'] | ||||
else: | ||||
base = opts.get('base') | ||||
|
r3284 | if base: | ||
if dest: | ||||
|
r8669 | raise util.Abort(_("--base is incompatible with specifying " | ||
|
r3284 | "a destination")) | ||
|
r3318 | base = [repo.lookup(rev) for rev in base] | ||
# create the right base | ||||
# XXX: nodesbetween / changegroup* should be "fixed" instead | ||||
|
r3284 | o = [] | ||
|
r8464 | has = set((nullid,)) | ||
|
r3284 | for n in base: | ||
|
r3631 | has.update(repo.changelog.reachable(n)) | ||
|
r3284 | if revs: | ||
|
r3318 | visit = list(revs) | ||
|
r10479 | has.difference_update(revs) | ||
|
r3284 | else: | ||
|
r3318 | visit = repo.changelog.heads() | ||
|
r3631 | seen = {} | ||
|
r3318 | while visit: | ||
n = visit.pop(0) | ||||
|
r3631 | parents = [p for p in repo.changelog.parents(n) if p not in has] | ||
|
r3318 | if len(parents) == 0: | ||
|
r10479 | if n not in has: | ||
o.append(n) | ||||
|
r3318 | else: | ||
|
r3512 | for p in parents: | ||
if p not in seen: | ||||
|
r3631 | seen[p] = 1 | ||
|
r3512 | visit.append(p) | ||
|
r3284 | else: | ||
|
r10365 | dest = ui.expandpath(dest or 'default-push', dest or 'default') | ||
|
r10379 | dest, branches = hg.parseurl(dest, opts.get('branch')) | ||
|
r8188 | other = hg.repository(cmdutil.remoteui(repo, opts), dest) | ||
|
r10365 | revs, checkout = hg.addbranchrevs(repo, other, branches, revs) | ||
|
r7131 | o = repo.findoutgoing(other, force=opts.get('force')) | ||
|
r3284 | |||
|
r10616 | if not o: | ||
ui.status(_("no changes found\n")) | ||||
return | ||||
|
r3284 | if revs: | ||
cg = repo.changegroupsubset(o, revs, 'bundle') | ||||
else: | ||||
cg = repo.changegroup(o, 'bundle') | ||||
|
r6570 | |||
bundletype = opts.get('type', 'bzip2').lower() | ||||
btypes = {'none': 'HG10UN', 'bzip2': 'HG10BZ', 'gzip': 'HG10GZ'} | ||||
bundletype = btypes.get(bundletype) | ||||
if bundletype not in changegroup.bundletypes: | ||||
raise util.Abort(_('unknown bundle type specified with --type')) | ||||
changegroup.writebundle(cg, fname, bundletype) | ||||
|
r1218 | |||
|
r1254 | def cat(ui, repo, file1, *pats, **opts): | ||
|
r3914 | """output the current or given revision of files | ||
|
r1437 | |||
|
r8004 | Print the specified files as they were at the given revision. If | ||
no revision is given, the parent of the working directory is used, | ||||
|
r3915 | or tip if no revision is checked out. | ||
|
r1437 | |||
Output may be to a file, in which case the name of the file is | ||||
|
r6448 | given using a format string. The formatting rules are the same as | ||
|
r9892 | for the export command, with the following additions: | ||
:``%s``: basename of file being printed | ||||
:``%d``: dirname of file being printed, or '.' if in repository root | ||||
:``%p``: root-relative path name of file being printed | ||||
|
r1437 | """ | ||
|
r7131 | ctx = repo[opts.get('rev')] | ||
|
r4697 | err = 1 | ||
|
r6579 | m = cmdutil.match(repo, (file1,) + pats, opts) | ||
|
r6764 | for abs in ctx.walk(m): | ||
|
r7131 | fp = cmdutil.make_file(repo, opts.get('output'), ctx.node(), pathname=abs) | ||
|
r6764 | data = ctx[abs].data() | ||
|
r6094 | if opts.get('decode'): | ||
|
r6093 | data = repo.wwritedata(abs, data) | ||
fp.write(data) | ||||
|
r4697 | err = 0 | ||
return err | ||||
|
r248 | |||
|
r698 | def clone(ui, source, dest=None, **opts): | ||
|
r1437 | """make a copy of an existing repository | ||
Create a copy of an existing repository in a new directory. | ||||
If no destination directory name is specified, it defaults to the | ||||
basename of the source. | ||||
The location of the source is added to the new repository's | ||||
.hg/hgrc file, as the default to be used for future pulls. | ||||
|
r10973 | See :hg:`help urls` for valid source format details. | ||
|
r7942 | |||
|
r9970 | It is possible to specify an ``ssh://`` URL as the destination, but no | ||
|
r7942 | .hg/hgrc and working directory will be created on the remote side. | ||
|
r10973 | Please see :hg:`help urls` for important details about ``ssh://`` URLs. | ||
|
r7942 | |||
|
r9714 | A set of changesets (tags, or branch names) to pull may be specified | ||
by listing each changeset (tag, or branch name) with -r/--rev. | ||||
If -r/--rev is used, the cloned repository will contain only a subset | ||||
of the changesets of the source repository. Only the set of changesets | ||||
|
r9806 | defined by all -r/--rev options (including all their ancestors) | ||
will be pulled into the destination repository. | ||||
|
r9714 | No subsequent changesets (including subsequent tags) will be present | ||
in the destination. | ||||
Using -r/--rev (or 'clone src#rev dest') implies --pull, even for | ||||
local source repositories. | ||||
|
r1437 | For efficiency, hardlinks are used for cloning whenever the source | ||
|
r2762 | and destination are on the same filesystem (note this applies only | ||
|
r10637 | to the repository data, not to the working directory). Some | ||
|
r2762 | filesystems, such as AFS, implement hardlinking incorrectly, but | ||
|
r6448 | do not report errors. In these cases, use the --pull option to | ||
|
r2762 | avoid hardlinking. | ||
|
r10637 | In some cases, you can clone repositories and the working directory | ||
|
r9249 | using full hardlinks with :: | ||
|
r2762 | |||
$ cp -al REPO REPOCLONE | ||||
|
r7983 | This is the fastest way to clone, but it is not always safe. The | ||
|
r6509 | operation is not atomic (making sure REPO is not modified during | ||
the operation is up to you) and you have to make sure your editor | ||||
|
r7983 | breaks hardlinks (Emacs and most Linux Kernel tools do so). Also, | ||
|
r6509 | this is not compatible with certain extensions that place their | ||
metadata under the .hg directory, such as mq. | ||||
|
r10637 | |||
Mercurial will update the working directory to the first applicable | ||||
revision from this list: | ||||
|
r10645 | a) null if -U or the source repository has no changesets | ||
b) if -u . and the source repository is local, the first parent of | ||||
the source repository's working directory | ||||
c) the changeset specified with -u (if a branch name, this means the | ||||
latest head of that branch) | ||||
d) the changeset specified with -r | ||||
e) the tipmost head specified with -b | ||||
f) the tipmost head specified with the url#branch source syntax | ||||
g) the tipmost head of the default branch | ||||
h) tip | ||||
|
r1437 | """ | ||
|
r9714 | if opts.get('noupdate') and opts.get('updaterev'): | ||
raise util.Abort(_("cannot specify both --noupdate and --updaterev")) | ||||
|
r8188 | hg.clone(cmdutil.remoteui(ui, opts), source, dest, | ||
|
r7131 | pull=opts.get('pull'), | ||
stream=opts.get('uncompressed'), | ||||
rev=opts.get('rev'), | ||||
|
r10379 | update=opts.get('updaterev') or not opts.get('noupdate'), | ||
branch=opts.get('branch')) | ||||
|
r515 | |||
|
r813 | def commit(ui, repo, *pats, **opts): | ||
|
r1437 | """commit the specified files or all outstanding changes | ||
|
r7983 | Commit changes to the given files into the repository. Unlike a | ||
centralized RCS, this operation is a local operation. See hg push | ||||
|
r8779 | for a way to actively distribute your changes. | ||
|
r1437 | |||
|
r10973 | If a list of files is omitted, all changes reported by :hg:`status` | ||
|
r1995 | will be committed. | ||
|
r1437 | |||
|
r6385 | If you are committing the result of a merge, do not provide any | ||
|
r8761 | filenames or -I/-X filters. | ||
|
r6385 | |||
|
r8004 | If no commit message is specified, the configured editor is | ||
started to prompt you for a message. | ||||
|
r6163 | |||
|
r10973 | See :hg:`help dates` for a list of formats valid for -d/--date. | ||
|
r1437 | """ | ||
|
r7655 | extra = {} | ||
if opts.get('close_branch'): | ||||
extra['close'] = 1 | ||||
|
r8407 | e = cmdutil.commiteditor | ||
if opts.get('force_editor'): | ||||
e = cmdutil.commitforceeditor | ||||
|
r6600 | def commitfunc(ui, repo, message, match, opts): | ||
|
r8706 | return repo.commit(message, opts.get('user'), opts.get('date'), match, | ||
editor=e, extra=extra) | ||||
|
r6336 | |||
|
r6369 | node = cmdutil.commit(ui, repo, commitfunc, pats, opts) | ||
if not node: | ||||
|
r8995 | ui.status(_("nothing changed\n")) | ||
|
r6369 | return | ||
cl = repo.changelog | ||||
rev = cl.rev(node) | ||||
parents = cl.parentrevs(rev) | ||||
if rev - 1 in parents: | ||||
# one of the parents was the old tip | ||||
|
r6935 | pass | ||
elif (parents == (nullrev, nullrev) or | ||||
len(cl.heads(cl.node(parents[0]))) > 1 and | ||||
(parents[1] == nullrev or len(cl.heads(cl.node(parents[1]))) > 1)): | ||||
|
r6336 | ui.status(_('created new head\n')) | ||
|
r245 | |||
|
r6935 | if ui.debugflag: | ||
|
r9198 | ui.write(_('committed changeset %d:%s\n') % (rev, hex(node))) | ||
|
r6935 | elif ui.verbose: | ||
|
r9198 | ui.write(_('committed changeset %d:%s\n') % (rev, short(node))) | ||
|
r6935 | |||
|
r1253 | def copy(ui, repo, *pats, **opts): | ||
|
r1437 | """mark files as copied for the next commit | ||
|
r6448 | Mark dest as having copies of source files. If dest is a | ||
directory, copies are put in that directory. If dest is a file, | ||||
|
r7807 | the source must be a single file. | ||
|
r1437 | |||
By default, this command copies the contents of files as they | ||||
|
r8779 | exist in the working directory. If invoked with -A/--after, the | ||
|
r1437 | operation is recorded, but no copying is performed. | ||
|
r7807 | This command takes effect with the next commit. To undo a copy | ||
|
r3829 | before that, see hg revert. | ||
|
r1437 | """ | ||
|
r4914 | wlock = repo.wlock(False) | ||
|
r4915 | try: | ||
|
r5610 | return cmdutil.copy(ui, repo, pats, opts) | ||
|
r4915 | finally: | ||
|
r8109 | wlock.release() | ||
|
r363 | |||
|
r6189 | def debugancestor(ui, repo, *args): | ||
|
r1262 | """find the ancestor revision of two revisions in a given index""" | ||
|
r6188 | if len(args) == 3: | ||
index, rev1, rev2 = args | ||||
|
r6178 | r = revlog.revlog(util.opener(os.getcwd(), audit=False), index) | ||
|
r6253 | lookup = r.lookup | ||
|
r6188 | elif len(args) == 2: | ||
|
r6189 | if not repo: | ||
raise util.Abort(_("There is no Mercurial repository here " | ||||
"(.hg not found)")) | ||||
|
r6188 | rev1, rev2 = args | ||
|
r6178 | r = repo.changelog | ||
|
r6253 | lookup = repo.lookup | ||
|
r6178 | else: | ||
raise util.Abort(_('either two or three arguments required')) | ||||
|
r6253 | a = r.ancestor(lookup(rev1), lookup(rev2)) | ||
|
r1262 | ui.write("%d:%s\n" % (r.rev(a), hex(a))) | ||
|
r7880 | def debugcommands(ui, cmd='', *args): | ||
|
r8209 | for cmd, vals in sorted(table.iteritems()): | ||
|
r7880 | cmd = cmd.split('|')[0].strip('^') | ||
opts = ', '.join([i[1] for i in vals[1]]) | ||||
ui.write('%s: %s\n' % (cmd, opts)) | ||||
|
r2034 | def debugcomplete(ui, cmd='', **opts): | ||
|
r1887 | """returns the completion list associated with the given command""" | ||
|
r2034 | |||
|
r7131 | if opts.get('options'): | ||
|
r2034 | options = [] | ||
otables = [globalopts] | ||||
if cmd: | ||||
|
r7213 | aliases, entry = cmdutil.findcmd(cmd, table, False) | ||
|
r2034 | otables.append(entry[1]) | ||
for t in otables: | ||||
for o in t: | ||||
|
r10958 | if "(DEPRECATED)" in o[3]: | ||
continue | ||||
|
r2034 | if o[0]: | ||
options.append('-%s' % o[0]) | ||||
options.append('--%s' % o[1]) | ||||
ui.write("%s\n" % "\n".join(options)) | ||||
return | ||||
|
r7509 | cmdlist = cmdutil.findpossible(cmd, table) | ||
if ui.verbose: | ||||
cmdlist = [' '.join(c[0]) for c in cmdlist.values()] | ||||
|
r8209 | ui.write("%s\n" % "\n".join(sorted(cmdlist))) | ||
|
r1887 | |||
|
r5741 | def debugfsinfo(ui, path = "."): | ||
|
r9031 | open('.debugfsinfo', 'w').write('') | ||
|
r5741 | ui.write('exec: %s\n' % (util.checkexec(path) and 'yes' or 'no')) | ||
ui.write('symlink: %s\n' % (util.checklink(path) and 'yes' or 'no')) | ||||
|
r6746 | ui.write('case-sensitive: %s\n' % (util.checkcase('.debugfsinfo') | ||
|
r5741 | and 'yes' or 'no')) | ||
os.unlink('.debugfsinfo') | ||||
|
r6747 | def debugrebuildstate(ui, repo, rev="tip"): | ||
|
r1755 | """rebuild the dirstate as it would look like for the given revision""" | ||
|
r6747 | ctx = repo[rev] | ||
|
r1760 | wlock = repo.wlock() | ||
|
r4915 | try: | ||
|
r6747 | repo.dirstate.rebuild(ctx.node(), ctx.manifest()) | ||
|
r4915 | finally: | ||
|
r8109 | wlock.release() | ||
|
r1755 | |||
|
r596 | def debugcheckstate(ui, repo): | ||
"""validate the correctness of the current dirstate""" | ||||
|
r460 | parent1, parent2 = repo.dirstate.parents() | ||
|
r6747 | m1 = repo[parent1].manifest() | ||
m2 = repo[parent2].manifest() | ||||
|
r460 | errors = 0 | ||
|
r4906 | for f in repo.dirstate: | ||
state = repo.dirstate[f] | ||||
|
r460 | if state in "nr" and f not in m1: | ||
|
r1402 | ui.warn(_("%s in state %s, but not in manifest1\n") % (f, state)) | ||
|
r460 | errors += 1 | ||
if state in "a" and f in m1: | ||||
|
r1402 | ui.warn(_("%s in state %s, but also in manifest1\n") % (f, state)) | ||
|
r460 | errors += 1 | ||
if state in "m" and f not in m1 and f not in m2: | ||||
|
r1402 | ui.warn(_("%s in state %s, but not in either manifest\n") % | ||
|
r582 | (f, state)) | ||
|
r460 | errors += 1 | ||
for f in m1: | ||||
|
r4906 | state = repo.dirstate[f] | ||
|
r460 | if state not in "nrm": | ||
|
r1402 | ui.warn(_("%s in manifest1, but listed as state %s") % (f, state)) | ||
|
r460 | errors += 1 | ||
if errors: | ||||
|
r1602 | error = _(".hg/dirstate inconsistent with current parent's manifest") | ||
raise util.Abort(error) | ||||
|
r460 | |||
|
r3553 | def showconfig(ui, repo, *values, **opts): | ||
|
r2410 | """show combined config settings from all hgrc files | ||
|
r8664 | With no arguments, print names and values of all config items. | ||
With one argument of the form section.name, print just the value | ||||
of that config item. | ||||
With multiple arguments, print names and values of all config | ||||
items with matching section names. | ||||
|
r8279 | |||
|
r8779 | With --debug, the source (filename and line number) is printed | ||
for each config item. | ||||
|
r8279 | """ | ||
|
r2410 | |||
|
r3553 | untrusted = bool(opts.get('untrusted')) | ||
|
r2410 | if values: | ||
if len([v for v in values if '.' in v]) > 1: | ||||
raise util.Abort(_('only one config item permitted')) | ||||
|
r3553 | for section, name, value in ui.walkconfig(untrusted=untrusted): | ||
|
r2410 | sectname = section + '.' + name | ||
if values: | ||||
for v in values: | ||||
if v == section: | ||||
|
r8182 | ui.debug('%s: ' % | ||
ui.configsource(section, name, untrusted)) | ||||
|
r2410 | ui.write('%s=%s\n' % (sectname, value)) | ||
elif v == sectname: | ||||
|
r8182 | ui.debug('%s: ' % | ||
ui.configsource(section, name, untrusted)) | ||||
|
r2410 | ui.write(value, '\n') | ||
else: | ||||
|
r8182 | ui.debug('%s: ' % | ||
ui.configsource(section, name, untrusted)) | ||||
|
r2410 | ui.write('%s=%s\n' % (sectname, value)) | ||
|
r1028 | |||
|
r1395 | def debugsetparents(ui, repo, rev1, rev2=None): | ||
|
r1470 | """manually set the parents of the current working directory | ||
|
r1395 | |||
This is useful for writing repository conversion tools, but should | ||||
be used with care. | ||||
""" | ||||
if not rev2: | ||||
rev2 = hex(nullid) | ||||
|
r4247 | wlock = repo.wlock() | ||
try: | ||||
repo.dirstate.setparents(repo.lookup(rev1), repo.lookup(rev2)) | ||||
finally: | ||||
|
r8109 | wlock.release() | ||
|
r1395 | |||
|
r6296 | def debugstate(ui, repo, nodates=None): | ||
|
r596 | """show the contents of the current dirstate""" | ||
|
r6296 | timestr = "" | ||
showdate = not nodates | ||||
|
r8209 | for file_, ent in sorted(repo.dirstate._map.iteritems()): | ||
|
r6296 | if showdate: | ||
if ent[3] == -1: | ||||
# Pad or slice to locale representation | ||||
|
r10282 | locale_len = len(time.strftime("%Y-%m-%d %H:%M:%S ", | ||
time.localtime(0))) | ||||
|
r6296 | timestr = 'unset' | ||
|
r10282 | timestr = (timestr[:locale_len] + | ||
' ' * (locale_len - len(timestr))) | ||||
|
r6296 | else: | ||
|
r10282 | timestr = time.strftime("%Y-%m-%d %H:%M:%S ", | ||
time.localtime(ent[3])) | ||||
|
r5156 | if ent[1] & 020000: | ||
mode = 'lnk' | ||||
else: | ||||
mode = '%3o' % (ent[1] & 0777) | ||||
|
r6296 | ui.write("%c %s %10d %s%s\n" % (ent[0], mode, ent[2], timestr, file_)) | ||
|
r3159 | for f in repo.dirstate.copies(): | ||
ui.write(_("copy: %s -> %s\n") % (repo.dirstate.copied(f), f)) | ||||
|
r460 | |||
|
r8812 | def debugsub(ui, repo, rev=None): | ||
if rev == '': | ||||
rev = None | ||||
|
r10282 | for k, v in sorted(repo[rev].substate.items()): | ||
|
r8812 | ui.write('path %s\n' % k) | ||
ui.write(' source %s\n' % v[0]) | ||||
ui.write(' revision %s\n' % v[1]) | ||||
|
r1039 | def debugdata(ui, file_, rev): | ||
|
r4258 | """dump the contents of a data file revision""" | ||
r = revlog.revlog(util.opener(os.getcwd(), audit=False), file_[:-2] + ".i") | ||||
|
r1313 | try: | ||
ui.write(r.revision(r.lookup(rev))) | ||||
except KeyError: | ||||
|
r3072 | raise util.Abort(_('invalid revision identifier %s') % rev) | ||
|
r1039 | |||
|
r3812 | def debugdate(ui, date, range=None, **opts): | ||
|
r3805 | """parse and display a date""" | ||
|
r3812 | if opts["extended"]: | ||
d = util.parsedate(date, util.extendeddateformats) | ||||
else: | ||||
d = util.parsedate(date) | ||||
|
r3805 | ui.write("internal: %s %s\n" % d) | ||
ui.write("standard: %s\n" % util.datestr(d)) | ||||
|
r3812 | if range: | ||
m = util.matchdate(range) | ||||
ui.write("match: %s\n" % m(d[0])) | ||||
|
r3805 | |||
|
r697 | def debugindex(ui, file_): | ||
|
r596 | """dump the contents of an index file""" | ||
|
r4258 | r = revlog.revlog(util.opener(os.getcwd(), audit=False), file_) | ||
|
r7737 | ui.write(" rev offset length base linkrev" | ||
|
r989 | " nodeid p1 p2\n") | ||
|
r6750 | for i in r: | ||
|
r2072 | node = r.node(i) | ||
|
r5311 | try: | ||
pp = r.parents(node) | ||||
except: | ||||
pp = [nullid, nullid] | ||||
|
r989 | ui.write("% 6d % 9d % 7d % 6d % 7d %s %s %s\n" % ( | ||
|
r7361 | i, r.start(i), r.length(i), r.base(i), r.linkrev(i), | ||
|
r2072 | short(node), short(pp[0]), short(pp[1]))) | ||
|
r248 | |||
|
r697 | def debugindexdot(ui, file_): | ||
|
r8779 | """dump an index DAG as a graphviz dot file""" | ||
|
r4258 | r = revlog.revlog(util.opener(os.getcwd(), audit=False), file_) | ||
|
r582 | ui.write("digraph G {\n") | ||
|
r6750 | for i in r: | ||
|
r2287 | node = r.node(i) | ||
pp = r.parents(node) | ||||
ui.write("\t%d -> %d\n" % (r.rev(pp[0]), i)) | ||||
if pp[1] != nullid: | ||||
ui.write("\t%d -> %d\n" % (r.rev(pp[1]), i)) | ||||
|
r582 | ui.write("}\n") | ||
|
r248 | |||
|
r3844 | def debuginstall(ui): | ||
'''test Mercurial installation''' | ||||
|
r3846 | def writetemp(contents): | ||
|
r4849 | (fd, name) = tempfile.mkstemp(prefix="hg-debuginstall-") | ||
|
r3846 | f = os.fdopen(fd, "wb") | ||
f.write(contents) | ||||
f.close() | ||||
return name | ||||
|
r3844 | problems = 0 | ||
# encoding | ||||
|
r7948 | ui.status(_("Checking encoding (%s)...\n") % encoding.encoding) | ||
|
r3844 | try: | ||
|
r7948 | encoding.fromlocal("test") | ||
|
r3844 | except util.Abort, inst: | ||
ui.write(" %s\n" % inst) | ||||
|
r3848 | ui.write(_(" (check that your locale is properly set)\n")) | ||
|
r3844 | problems += 1 | ||
# compiled modules | ||||
ui.status(_("Checking extensions...\n")) | ||||
try: | ||||
import bdiff, mpatch, base85 | ||||
except Exception, inst: | ||||
ui.write(" %s\n" % inst) | ||||
|
r3848 | ui.write(_(" One or more extensions could not be found")) | ||
ui.write(_(" (check that you compiled the extensions)\n")) | ||||
|
r3844 | problems += 1 | ||
# templates | ||||
ui.status(_("Checking templates...\n")) | ||||
try: | ||||
import templater | ||||
|
r7874 | templater.templater(templater.templatepath("map-cmdline.default")) | ||
|
r3844 | except Exception, inst: | ||
ui.write(" %s\n" % inst) | ||||
|
r3848 | ui.write(_(" (templates seem to have been installed incorrectly)\n")) | ||
|
r3844 | problems += 1 | ||
# patch | ||||
ui.status(_("Checking patch...\n")) | ||||
|
r5310 | patchproblems = 0 | ||
a = "1\n2\n3\n4\n" | ||||
b = "1\n2\n3\ninsert\n4\n" | ||||
fa = writetemp(a) | ||||
|
r5482 | d = mdiff.unidiff(a, None, b, None, os.path.basename(fa), | ||
os.path.basename(fa)) | ||||
|
r5310 | fd = writetemp(d) | ||
files = {} | ||||
try: | ||||
patch.patch(fd, ui, cwd=os.path.dirname(fa), files=files) | ||||
except util.Abort, e: | ||||
ui.write(_(" patch call failed:\n")) | ||||
ui.write(" " + str(e) + "\n") | ||||
patchproblems += 1 | ||||
|
r3846 | else: | ||
|
r5310 | if list(files) != [os.path.basename(fa)]: | ||
ui.write(_(" unexpected patch output!\n")) | ||||
patchproblems += 1 | ||||
|
r9031 | a = open(fa).read() | ||
|
r5310 | if a != b: | ||
ui.write(_(" patch test failed!\n")) | ||||
patchproblems += 1 | ||||
if patchproblems: | ||||
if ui.config('ui', 'patch'): | ||||
ui.write(_(" (Current patch tool may be incompatible with patch," | ||||
" or misconfigured. Please check your .hgrc file)\n")) | ||||
|
r4516 | else: | ||
|
r5760 | ui.write(_(" Internal patcher failure, please report this error" | ||
|
r8936 | " to http://mercurial.selenic.com/bts/\n")) | ||
|
r5310 | problems += patchproblems | ||
os.unlink(fa) | ||||
os.unlink(fd) | ||||
|
r3844 | |||
# editor | ||||
ui.status(_("Checking commit editor...\n")) | ||||
|
r5660 | editor = ui.geteditor() | ||
|
r4488 | cmdpath = util.find_exe(editor) or util.find_exe(editor.split()[0]) | ||
|
r3844 | if not cmdpath: | ||
|
r3855 | if editor == 'vi': | ||
|
r3844 | ui.write(_(" No commit editor set and can't find vi in PATH\n")) | ||
|
r3848 | ui.write(_(" (specify a commit editor in your .hgrc file)\n")) | ||
|
r3844 | else: | ||
ui.write(_(" Can't find editor '%s' in PATH\n") % editor) | ||||
|
r3848 | ui.write(_(" (specify a commit editor in your .hgrc file)\n")) | ||
|
r3844 | problems += 1 | ||
|
r3848 | # check username | ||
ui.status(_("Checking username...\n")) | ||||
|
r9734 | try: | ||
user = ui.username() | ||||
except util.Abort, e: | ||||
ui.write(" %s\n" % e) | ||||
|
r3848 | ui.write(_(" (specify a username in your .hgrc file)\n")) | ||
|
r9734 | problems += 1 | ||
|
r3848 | |||
|
r3844 | if not problems: | ||
ui.status(_("No problems detected\n")) | ||||
else: | ||||
ui.write(_("%s problems detected," | ||||
" please check your install!\n") % problems) | ||||
return problems | ||||
|
r3652 | def debugrename(ui, repo, file1, *pats, **opts): | ||
|
r1194 | """dump rename information""" | ||
|
r3652 | |||
|
r6748 | ctx = repo[opts.get('rev')] | ||
|
r6579 | m = cmdutil.match(repo, (file1,) + pats, opts) | ||
|
r6764 | for abs in ctx.walk(m): | ||
fctx = ctx[abs] | ||||
|
r6579 | o = fctx.filelog().renamed(fctx.filenode()) | ||
|
r6584 | rel = m.rel(abs) | ||
|
r6579 | if o: | ||
ui.write(_("%s renamed from %s:%s\n") % (rel, o[0], hex(o[1]))) | ||||
|
r3652 | else: | ||
ui.write(_("%s not renamed\n") % rel) | ||||
|
r1116 | |||
|
r820 | def debugwalk(ui, repo, *pats, **opts): | ||
|
r1053 | """show how files match on given patterns""" | ||
|
r6579 | m = cmdutil.match(repo, pats, opts) | ||
|
r6585 | items = list(repo.walk(m)) | ||
|
r1065 | if not items: | ||
return | ||||
|
r6586 | fmt = 'f %%-%ds %%-%ds %%s' % ( | ||
max([len(abs) for abs in items]), | ||||
max([len(m.rel(abs)) for abs in items])) | ||||
for abs in items: | ||||
line = fmt % (abs, m.rel(abs), m.exact(abs) and 'exact' or '') | ||||
|
r1309 | ui.write("%s\n" % line.rstrip()) | ||
|
r820 | |||
|
r732 | def diff(ui, repo, *pats, **opts): | ||
|
r1568 | """diff repository (or selected files) | ||
|
r1437 | |||
Show differences between revisions for the specified files. | ||||
Differences between files are shown using the unified diff format. | ||||
|
r3822 | NOTE: diff may generate unexpected results for merges, as it will | ||
default to comparing against the working directory's first parent | ||||
changeset if no revisions are specified. | ||||
|
r1437 | When two revision arguments are given, then changes are shown | ||
between those revisions. If only one revision is specified then | ||||
that revision is compared to the working directory, and, when no | ||||
revisions are specified, the working directory files are compared | ||||
to its parent. | ||||
|
r10527 | Alternatively you can specify -c/--change with a revision to see | ||
the changes in that changeset relative to its first parent. | ||||
|
r10520 | |||
|
r8033 | Without the -a/--text option, diff will avoid generating diffs of | ||
files it detects as binary. With -a, diff will generate a diff | ||||
anyway, probably with undesirable results. | ||||
Use the -g/--git option to generate diffs in the git extended diff | ||||
|
r10973 | format. For more information, read :hg:`help diffs`. | ||
|
r1437 | """ | ||
|
r7628 | |||
revs = opts.get('rev') | ||||
change = opts.get('change') | ||||
|
r9640 | stat = opts.get('stat') | ||
|
r9857 | reverse = opts.get('reverse') | ||
|
r7628 | |||
if revs and change: | ||||
msg = _('cannot specify --rev and --change at the same time') | ||||
raise util.Abort(msg) | ||||
elif change: | ||||
node2 = repo.lookup(change) | ||||
node1 = repo[node2].parents()[0].node() | ||||
else: | ||||
node1, node2 = cmdutil.revpair(repo, revs) | ||||
|
r245 | |||
|
r9857 | if reverse: | ||
|
r9725 | node1, node2 = node2, node1 | ||
|
r9640 | if stat: | ||
opts['unified'] = '0' | ||||
|
r9642 | diffopts = patch.diffopts(ui, opts) | ||
|
r9640 | |||
|
r6582 | m = cmdutil.match(repo, pats, opts) | ||
|
r9640 | if stat: | ||
|
r10818 | it = patch.diff(repo, node1, node2, match=m, opts=diffopts) | ||
|
r10948 | width = 80 | ||
if not ui.plain(): | ||||
width = util.termwidth() | ||||
|
r10818 | for chunk, label in patch.diffstatui(util.iterlines(it), width=width, | ||
git=diffopts.git): | ||||
ui.write(chunk, label=label) | ||||
|
r9640 | else: | ||
|
r10818 | it = patch.diffui(repo, node1, node2, match=m, opts=diffopts) | ||
for chunk, label in it: | ||||
ui.write(chunk, label=label) | ||||
|
r396 | |||
|
r580 | def export(ui, repo, *changesets, **opts): | ||
|
r1437 | """dump the header and diffs for one or more changesets | ||
Print the changeset header and diffs for one or more revisions. | ||||
|
r10334 | The information shown in the changeset header is: author, date, | ||
|
r10335 | branch name (if non-default), changeset hash, parent(s) and commit | ||
comment. | ||||
|
r3822 | |||
|
r8004 | NOTE: export may generate unexpected diff output for merge | ||
changesets, as it will compare the merge changeset against its | ||||
first parent only. | ||||
|
r1437 | |||
Output may be to a file, in which case the name of the file is | ||||
|
r9892 | given using a format string. The formatting rules are as follows: | ||
:``%%``: literal "%" character | ||||
:``%H``: changeset hash (40 bytes of hexadecimal) | ||||
:``%N``: number of patches being generated | ||||
:``%R``: changeset revision number | ||||
:``%b``: basename of the exporting repository | ||||
:``%h``: short-form changeset hash (12 bytes of hexadecimal) | ||||
:``%n``: zero-padded sequence number, starting at 1 | ||||
:``%r``: zero-padded changeset revision number | ||||
|
r1437 | |||
|
r8033 | Without the -a/--text option, export will avoid generating diffs | ||
of files it detects as binary. With -a, export will generate a | ||||
diff anyway, probably with undesirable results. | ||||
Use the -g/--git option to generate diffs in the git extended diff | ||||
|
r10973 | format. See :hg:`help diffs` for more information. | ||
|
r7307 | |||
|
r8004 | With the --switch-parent option, the diff will be against the | ||
second parent. It can be useful to review a merge. | ||||
|
r1437 | """ | ||
|
r10015 | changesets += tuple(opts.get('rev', [])) | ||
|
r610 | if not changesets: | ||
|
r1402 | raise util.Abort(_("export requires at least one changeset")) | ||
|
r3707 | revs = cmdutil.revrange(repo, changesets) | ||
|
r2874 | if len(revs) > 1: | ||
ui.note(_('exporting patches:\n')) | ||||
else: | ||||
ui.note(_('exporting patch:\n')) | ||||
|
r10611 | cmdutil.export(repo, revs, template=opts.get('output'), | ||
|
r7131 | switch_parent=opts.get('switch_parent'), | ||
|
r2888 | opts=patch.diffopts(ui, opts)) | ||
|
r246 | |||
|
r8902 | def forget(ui, repo, *pats, **opts): | ||
"""forget the specified files on the next commit | ||||
Mark the specified files so they will no longer be tracked | ||||
after the next commit. | ||||
This only removes files from the current branch, not from the | ||||
entire project history, and it does not delete them from the | ||||
working directory. | ||||
To undo a forget before the next commit, see hg add. | ||||
""" | ||||
if not pats: | ||||
raise util.Abort(_('no files specified')) | ||||
m = cmdutil.match(repo, pats, opts) | ||||
s = repo.status(match=m, clean=True) | ||||
forget = sorted(s[0] + s[1] + s[3] + s[6]) | ||||
for f in m.files(): | ||||
if f not in repo.dirstate and not os.path.isdir(m.rel(f)): | ||||
ui.warn(_('not removing %s: file is already untracked\n') | ||||
% m.rel(f)) | ||||
for f in forget: | ||||
if ui.verbose or not m.exact(f): | ||||
ui.status(_('removing %s\n') % m.rel(f)) | ||||
repo.remove(forget, unlink=False) | ||||
|
r1108 | def grep(ui, repo, pattern, *pats, **opts): | ||
|
r1437 | """search for a pattern in specified files and revisions | ||
Search revisions of files for a regular expression. | ||||
|
r6448 | This command behaves differently than Unix grep. It only accepts | ||
Python/Perl regexps. It searches repository history, not the | ||||
|
r8004 | working directory. It always prints the revision number in which a | ||
match appears. | ||||
|
r1437 | |||
By default, grep only prints output for the first revision of a | ||||
|
r6448 | file in which it finds a match. To get it to print every revision | ||
|
r1437 | that contains a change in match status ("-" for a match that | ||
becomes a non-match, or "+" for a non-match that becomes a match), | ||||
use the --all flag. | ||||
""" | ||||
|
r1057 | reflags = 0 | ||
|
r7131 | if opts.get('ignore_case'): | ||
|
r1065 | reflags |= re.I | ||
|
r4877 | try: | ||
regexp = re.compile(pattern, reflags) | ||||
except Exception, inst: | ||||
|
r6057 | ui.warn(_("grep: invalid match pattern: %s\n") % inst) | ||
|
r4877 | return None | ||
|
r1146 | sep, eol = ':', '\n' | ||
|
r7131 | if opts.get('print0'): | ||
|
r1146 | sep = eol = '\0' | ||
|
r1057 | |||
|
r9097 | getfile = util.lrucachefunc(repo.file) | ||
|
r1057 | |||
def matchlines(body): | ||||
|
r1059 | begin = 0 | ||
linenum = 0 | ||||
while True: | ||||
match = regexp.search(body, begin) | ||||
|
r1065 | if not match: | ||
break | ||||
|
r1059 | mstart, mend = match.span() | ||
linenum += body.count('\n', begin, mstart) + 1 | ||||
lstart = body.rfind('\n', begin, mstart) + 1 or begin | ||||
|
r7230 | begin = body.find('\n', mend) + 1 or len(body) | ||
lend = begin - 1 | ||||
|
r1059 | yield linenum, mstart - lstart, mend - lstart, body[lstart:lend] | ||
|
r1057 | |||
|
r1559 | class linestate(object): | ||
|
r1057 | def __init__(self, line, linenum, colstart, colend): | ||
self.line = line | ||||
self.linenum = linenum | ||||
self.colstart = colstart | ||||
self.colend = colend | ||||
|
r2869 | |||
|
r6469 | def __hash__(self): | ||
return hash((self.linenum, self.line)) | ||||
|
r1065 | def __eq__(self, other): | ||
return self.line == other.line | ||||
|
r1057 | |||
matches = {} | ||||
|
r2870 | copies = {} | ||
|
r1057 | def grepbody(fn, rev, body): | ||
|
r2869 | matches[rev].setdefault(fn, []) | ||
|
r1057 | m = matches[rev][fn] | ||
for lnum, cstart, cend, line in matchlines(body): | ||||
s = linestate(line, lnum, cstart, cend) | ||||
|
r2869 | m.append(s) | ||
def difflinestates(a, b): | ||||
sm = difflib.SequenceMatcher(None, a, b) | ||||
for tag, alo, ahi, blo, bhi in sm.get_opcodes(): | ||||
if tag == 'insert': | ||||
|
r3472 | for i in xrange(blo, bhi): | ||
|
r2869 | yield ('+', b[i]) | ||
elif tag == 'delete': | ||||
|
r3472 | for i in xrange(alo, ahi): | ||
|
r2869 | yield ('-', a[i]) | ||
elif tag == 'replace': | ||||
|
r3472 | for i in xrange(alo, ahi): | ||
|
r2869 | yield ('-', a[i]) | ||
|
r3472 | for i in xrange(blo, bhi): | ||
|
r2869 | yield ('+', b[i]) | ||
|
r9655 | def display(fn, ctx, pstates, states): | ||
rev = ctx.rev() | ||||
|
r6134 | datefunc = ui.quiet and util.shortdate or util.datestr | ||
|
r3951 | found = False | ||
|
r1146 | filerevmatches = {} | ||
|
r7131 | if opts.get('all'): | ||
|
r8849 | iter = difflinestates(pstates, states) | ||
|
r2869 | else: | ||
|
r8849 | iter = [('', l) for l in states] | ||
|
r3951 | for change, l in iter: | ||
|
r9655 | cols = [fn, str(rev)] | ||
|
r10816 | before, match, after = None, None, None | ||
|
r7131 | if opts.get('line_number'): | ||
|
r1615 | cols.append(str(l.linenum)) | ||
|
r7131 | if opts.get('all'): | ||
|
r1615 | cols.append(change) | ||
|
r7131 | if opts.get('user'): | ||
|
r9655 | cols.append(ui.shortuser(ctx.user())) | ||
|
r6133 | if opts.get('date'): | ||
|
r9655 | cols.append(datefunc(ctx.date())) | ||
|
r7131 | if opts.get('files_with_matches'): | ||
|
r9655 | c = (fn, rev) | ||
|
r1615 | if c in filerevmatches: | ||
continue | ||||
|
r1146 | filerevmatches[c] = 1 | ||
else: | ||||
|
r10816 | before = l.line[:l.colstart] | ||
match = l.line[l.colstart:l.colend] | ||||
after = l.line[l.colend:] | ||||
ui.write(sep.join(cols)) | ||||
if before is not None: | ||||
ui.write(sep + before) | ||||
ui.write(match, label='grep.match') | ||||
ui.write(after) | ||||
ui.write(eol) | ||||
|
r3951 | found = True | ||
return found | ||||
|
r1057 | |||
|
r1145 | skip = {} | ||
|
r8849 | revfiles = {} | ||
|
r9652 | matchfn = cmdutil.match(repo, pats, opts) | ||
|
r3951 | found = False | ||
|
r2870 | follow = opts.get('follow') | ||
|
r9662 | |||
def prep(ctx, fns): | ||||
rev = ctx.rev() | ||||
pctx = ctx.parents()[0] | ||||
parent = pctx.rev() | ||||
matches.setdefault(rev, {}) | ||||
matches.setdefault(parent, {}) | ||||
files = revfiles.setdefault(rev, []) | ||||
for fn in fns: | ||||
flog = getfile(fn) | ||||
try: | ||||
fnode = ctx.filenode(fn) | ||||
except error.LookupError: | ||||
continue | ||||
copied = flog.renamed(fnode) | ||||
copy = follow and copied and copied[0] | ||||
if copy: | ||||
copies.setdefault(rev, {})[fn] = copy | ||||
if fn in skip: | ||||
if copy: | ||||
skip[copy] = True | ||||
continue | ||||
files.append(fn) | ||||
if fn not in matches[rev]: | ||||
grepbody(fn, rev, flog.read(fnode)) | ||||
pfn = copy or fn | ||||
if pfn not in matches[parent]: | ||||
|
r1057 | try: | ||
|
r9662 | fnode = pctx.filenode(pfn) | ||
grepbody(pfn, parent, flog.read(fnode)) | ||||
|
r7633 | except error.LookupError: | ||
|
r9662 | pass | ||
|
r9665 | for ctx in cmdutil.walkchangerevs(repo, matchfn, opts, prep): | ||
|
r9662 | rev = ctx.rev() | ||
parent = ctx.parents()[0].rev() | ||||
for fn in sorted(revfiles.get(rev, [])): | ||||
states = matches[rev][fn] | ||||
copy = copies.get(rev, {}).get(fn) | ||||
if fn in skip: | ||||
|
r8849 | if copy: | ||
|
r9662 | skip[copy] = True | ||
continue | ||||
pstates = matches.get(parent, {}).get(copy or fn, []) | ||||
if pstates or states: | ||||
r = display(fn, ctx, pstates, states) | ||||
found = found or r | ||||
if r and not opts.get('all'): | ||||
skip[fn] = True | ||||
|
r8849 | if copy: | ||
skip[copy] = True | ||||
|
r9662 | del matches[rev] | ||
del revfiles[rev] | ||||
|
r1057 | |||
|
r4648 | def heads(ui, repo, *branchrevs, **opts): | ||
"""show current repository heads or show branch heads | ||||
|
r10350 | With no arguments, show all repository branch heads. | ||
|
r4648 | |||
|
r9502 | Repository "heads" are changesets with no child changesets. They are | ||
where development generally takes place and are the usual targets | ||||
|
r10350 | for update and merge operations. Branch heads are changesets that have | ||
no child changeset on the same branch. | ||||
If one or more REVs are given, only branch heads on the branches | ||||
associated with the specified changesets are shown. | ||||
|
r9502 | |||
If -c/--closed is specified, also show branch heads marked closed | ||||
(see hg commit --close-branch). | ||||
If STARTREV is specified, only those heads that are descendants of | ||||
STARTREV will be displayed. | ||||
|
r10350 | |||
If -t/--topo is specified, named branch mechanics will be ignored and only | ||||
changesets without children will be shown. | ||||
|
r1437 | """ | ||
|
r10328 | |||
|
r7131 | if opts.get('rev'): | ||
|
r4648 | start = repo.lookup(opts['rev']) | ||
else: | ||||
start = None | ||||
|
r10328 | |||
|
r10350 | if opts.get('topo'): | ||
heads = [repo[h] for h in repo.heads(start)] | ||||
|
r1550 | else: | ||
|
r10348 | heads = [] | ||
for b, ls in repo.branchmap().iteritems(): | ||||
if start is None: | ||||
|
r10350 | heads += [repo[h] for h in ls] | ||
|
r10348 | continue | ||
startrev = repo.changelog.rev(start) | ||||
descendants = set(repo.changelog.descendants(startrev)) | ||||
descendants.add(startrev) | ||||
|
r10350 | rev = repo.changelog.rev | ||
heads += [repo[h] for h in ls if rev(h) in descendants] | ||||
if branchrevs: | ||||
decode, encode = encoding.fromlocal, encoding.tolocal | ||||
branches = set(repo[decode(br)].branch() for br in branchrevs) | ||||
heads = [h for h in heads if h.branch() in branches] | ||||
|
r10328 | |||
|
r10349 | if not opts.get('closed'): | ||
|
r10350 | heads = [h for h in heads if not h.extra().get('close')] | ||
|
r10349 | |||
if opts.get('active') and branchrevs: | ||||
dagheads = repo.heads(start) | ||||
|
r10350 | heads = [h for h in heads if h.node() in dagheads] | ||
|
r10349 | |||
if branchrevs: | ||||
|
r10350 | haveheads = set(h.branch() for h in heads) | ||
|
r10346 | if branches - haveheads: | ||
headless = ', '.join(encode(b) for b in branches - haveheads) | ||||
msg = _('no open branch heads found on branches %s') | ||||
if opts.get('rev'): | ||||
msg += _(' (started at %s)' % opts['rev']) | ||||
ui.warn((msg + '\n') % headless) | ||||
|
r4648 | if not heads: | ||
return 1 | ||||
|
r10328 | |||
|
r10350 | heads = sorted(heads, key=lambda x: -x.rev()) | ||
|
r3643 | displayer = cmdutil.show_changeset(ui, repo, opts) | ||
|
r10331 | for ctx in heads: | ||
displayer.show(ctx) | ||||
|
r10152 | displayer.close() | ||
|
r221 | |||
|
r10364 | def help_(ui, name=None, with_version=False, unknowncmd=False): | ||
|
r7210 | """show help for a given topic or a help overview | ||
|
r3655 | |||
|
r8779 | With no arguments, print a list of commands with short help messages. | ||
|
r3655 | |||
|
r8004 | Given a topic, extension, or command name, print help for that | ||
topic.""" | ||||
|
r3655 | option_lists = [] | ||
|
r9157 | textwidth = util.termwidth() - 2 | ||
|
r3655 | |||
|
r4315 | def addglobalopts(aliases): | ||
if ui.verbose: | ||||
option_lists.append((_("global options:"), globalopts)) | ||||
if name == 'shortlist': | ||||
option_lists.append((_('use "hg help" for the full list ' | ||||
'of commands'), ())) | ||||
else: | ||||
if name == 'shortlist': | ||||
msg = _('use "hg help" for the full list of commands ' | ||||
'or "hg -v" for details') | ||||
elif aliases: | ||||
msg = _('use "hg -v help%s" to show aliases and ' | ||||
'global options') % (name and " " + name or "") | ||||
else: | ||||
msg = _('use "hg -v help %s" to show global options') % name | ||||
option_lists.append((msg, ())) | ||||
|
r3655 | def helpcmd(name): | ||
if with_version: | ||||
version_(ui) | ||||
ui.write('\n') | ||||
|
r6652 | |||
try: | ||||
|
r10364 | aliases, entry = cmdutil.findcmd(name, table, strict=unknowncmd) | ||
|
r7643 | except error.AmbiguousCommand, inst: | ||
|
r9035 | # py3k fix: except vars can't be used outside the scope of the | ||
# except block, nor can be used inside a lambda. python issue4617 | ||||
prefix = inst.args[0] | ||||
select = lambda c: c.lstrip('^').startswith(prefix) | ||||
|
r6652 | helplist(_('list of commands:\n\n'), select) | ||
return | ||||
|
r10021 | # check if it's an invalid alias and display its error if it is | ||
if getattr(entry[0], 'badalias', False): | ||||
|
r10364 | if not unknowncmd: | ||
entry[0](ui) | ||||
|
r10021 | return | ||
|
r3655 | # synopsis | ||
|
r9901 | if len(entry) > 2: | ||
if entry[2].startswith('hg'): | ||||
ui.write("%s\n" % entry[2]) | ||||
|
r7364 | else: | ||
|
r9901 | ui.write('hg %s %s\n' % (aliases[0], entry[2])) | ||
|
r7364 | else: | ||
ui.write('hg %s\n' % aliases[0]) | ||||
|
r5783 | |||
# aliases | ||||
if not ui.quiet and len(aliases) > 1: | ||||
ui.write(_("\naliases: %s\n") % ', '.join(aliases[1:])) | ||||
|
r3655 | |||
# description | ||||
|
r9901 | doc = gettext(entry[0].__doc__) | ||
|
r3655 | if not doc: | ||
|
r7598 | doc = _("(no help text available)") | ||
|
r10564 | if hasattr(entry[0], 'definition'): # aliased command | ||
doc = _('alias for: hg %s\n\n%s') % (entry[0].definition, doc) | ||||
|
r3655 | if ui.quiet: | ||
|
r9136 | doc = doc.splitlines()[0] | ||
|
r10445 | keep = ui.verbose and ['verbose'] or [] | ||
formatted, pruned = minirst.format(doc, textwidth, keep=keep) | ||||
ui.write("\n%s\n" % formatted) | ||||
if pruned: | ||||
ui.write(_('\nuse "hg -v help %s" to show verbose help\n') % name) | ||||
|
r3655 | |||
if not ui.quiet: | ||||
# options | ||||
|
r9901 | if entry[1]: | ||
option_lists.append((_("options:\n"), entry[1])) | ||||
|
r4315 | |||
addglobalopts(False) | ||||
|
r3655 | |||
|
r4950 | def helplist(header, select=None): | ||
|
r3655 | h = {} | ||
cmds = {} | ||||
|
r7622 | for c, e in table.iteritems(): | ||
|
r3655 | f = c.split("|", 1)[0] | ||
if select and not select(f): | ||||
continue | ||||
|
r7197 | if (not select and name != 'shortlist' and | ||
e[0].__module__ != __name__): | ||||
|
r7126 | continue | ||
|
r3655 | if name == "shortlist" and not f.startswith("^"): | ||
continue | ||||
f = f.lstrip("^") | ||||
if not ui.debugflag and f.startswith("debug"): | ||||
continue | ||||
|
r9128 | doc = e[0].__doc__ | ||
if doc and 'DEPRECATED' in doc and not ui.verbose: | ||||
continue | ||||
doc = gettext(doc) | ||||
|
r3655 | if not doc: | ||
|
r7598 | doc = _("(no help text available)") | ||
|
r9136 | h[f] = doc.splitlines()[0].rstrip() | ||
|
r3655 | cmds[f] = c.lstrip("^") | ||
|
r4950 | if not h: | ||
ui.status(_('no commands defined\n')) | ||||
return | ||||
ui.status(header) | ||||
|
r8209 | fns = sorted(h) | ||
|
r3655 | m = max(map(len, fns)) | ||
for f in fns: | ||||
if ui.verbose: | ||||
commands = cmds[f].replace("|",", ") | ||||
ui.write(" %s:\n %s\n"%(commands, h[f])) | ||||
else: | ||||
|
r8938 | ui.write(' %-*s %s\n' % (m, f, util.wrap(h[f], m + 4))) | ||
|
r3655 | |||
|
r4315 | if not ui.quiet: | ||
addglobalopts(True) | ||||
|
r3795 | def helptopic(name): | ||
|
r7012 | for names, header, doc in help.helptable: | ||
if name in names: | ||||
break | ||||
else: | ||||
|
r7643 | raise error.UnknownCommand(name) | ||
|
r3795 | |||
# description | ||||
if not doc: | ||||
|
r7598 | doc = _("(no help text available)") | ||
|
r8366 | if hasattr(doc, '__call__'): | ||
|
r3796 | doc = doc() | ||
|
r3795 | |||
|
r9157 | ui.write("%s\n\n" % header) | ||
|
r9540 | ui.write("%s\n" % minirst.format(doc, textwidth, indent=4)) | ||
|
r3795 | |||
|
r3655 | def helpext(name): | ||
try: | ||||
|
r4544 | mod = extensions.find(name) | ||
|
r10364 | doc = gettext(mod.__doc__) or _('no help text available') | ||
|
r3655 | except KeyError: | ||
|
r10364 | mod = None | ||
doc = extensions.disabledext(name) | ||||
if not doc: | ||||
raise error.UnknownCommand(name) | ||||
|
r9280 | if '\n' not in doc: | ||
head, tail = doc, "" | ||||
else: | ||||
head, tail = doc.split('\n', 1) | ||||
|
r9157 | ui.write(_('%s extension - %s\n\n') % (name.split('.')[-1], head)) | ||
if tail: | ||||
ui.write(minirst.format(tail, textwidth)) | ||||
ui.status('\n\n') | ||||
|
r4009 | |||
|
r10364 | if mod: | ||
try: | ||||
ct = mod.cmdtable | ||||
except AttributeError: | ||||
ct = {} | ||||
modcmds = set([c.split('|', 1)[0] for c in ct]) | ||||
helplist(_('list of commands:\n\n'), modcmds.__contains__) | ||||
else: | ||||
ui.write(_('use "hg help extensions" for information on enabling ' | ||||
'extensions\n')) | ||||
def helpextcmd(name): | ||||
cmd, ext, mod = extensions.disabledcmd(name, ui.config('ui', 'strict')) | ||||
doc = gettext(mod.__doc__).splitlines()[0] | ||||
msg = help.listexts(_("'%s' is provided by the following " | ||||
"extension:") % cmd, {ext: doc}, len(ext), | ||||
indent=4) | ||||
ui.write(minirst.format(msg, textwidth)) | ||||
ui.write('\n\n') | ||||
ui.write(_('use "hg help extensions" for information on enabling ' | ||||
'extensions\n')) | ||||
|
r3655 | |||
if name and name != 'shortlist': | ||||
|
r3795 | i = None | ||
|
r10364 | if unknowncmd: | ||
queries = (helpextcmd,) | ||||
else: | ||||
queries = (helptopic, helpcmd, helpext, helpextcmd) | ||||
for f in queries: | ||||
|
r3795 | try: | ||
f(name) | ||||
i = None | ||||
break | ||||
|
r7643 | except error.UnknownCommand, inst: | ||
|
r3795 | i = inst | ||
if i: | ||||
raise i | ||||
|
r3655 | |||
else: | ||||
# program name | ||||
if ui.verbose or with_version: | ||||
version_(ui) | ||||
else: | ||||
ui.status(_("Mercurial Distributed SCM\n")) | ||||
ui.status('\n') | ||||
# list of commands | ||||
if name == "shortlist": | ||||
|
r4950 | header = _('basic commands:\n\n') | ||
|
r4315 | else: | ||
|
r4950 | header = _('list of commands:\n\n') | ||
helplist(header) | ||||
|
r9839 | if name != 'shortlist': | ||
exts, maxlength = extensions.enabled() | ||||
text = help.listexts(_('enabled extensions:'), exts, maxlength) | ||||
if text: | ||||
ui.write("\n%s\n" % minirst.format(text, textwidth)) | ||||
|
r3655 | |||
# list all option lists | ||||
opt_output = [] | ||||
for title, options in option_lists: | ||||
|
r4315 | opt_output.append(("\n%s" % title, None)) | ||
|
r3655 | for shortopt, longopt, default, desc in options: | ||
|
r10282 | if _("DEPRECATED") in desc and not ui.verbose: | ||
|
r10339 | continue | ||
|
r3655 | opt_output.append(("%2s%s" % (shortopt and "-%s" % shortopt, | ||
longopt and " --%s" % longopt), | ||||
"%s%s" % (desc, | ||||
default | ||||
and _(" (default: %s)") % default | ||||
or ""))) | ||||
|
r7196 | if not name: | ||
|
r7210 | ui.write(_("\nadditional help topics:\n\n")) | ||
|
r6653 | topics = [] | ||
|
r7012 | for names, header, doc in help.helptable: | ||
|
r9537 | topics.append((sorted(names, key=len, reverse=True)[0], header)) | ||
|
r6653 | topics_len = max([len(s[0]) for s in topics]) | ||
for t, desc in topics: | ||||
ui.write(" %-*s %s\n" % (topics_len, t, desc)) | ||||
|
r3655 | if opt_output: | ||
|
r4315 | opts_len = max([len(line[0]) for line in opt_output if line[1]] or [0]) | ||
|
r3655 | for first, second in opt_output: | ||
if second: | ||||
|
r8938 | second = util.wrap(second, opts_len + 3) | ||
ui.write(" %-*s %s\n" % (opts_len, first, second)) | ||||
|
r3655 | else: | ||
ui.write("%s\n" % first) | ||||
|
r221 | |||
|
r4671 | def identify(ui, repo, source=None, | ||
rev=None, num=None, id=None, branch=None, tags=None): | ||||
|
r4665 | """identify the working copy or specified revision | ||
|
r8004 | With no revision, print a summary of the current state of the | ||
|
r8027 | repository. | ||
|
r4671 | |||
|
r8779 | Specifying a path to a repository root or Mercurial bundle will | ||
cause lookup to operate on that repository/bundle. | ||||
|
r1437 | |||
|
r8004 | This summary identifies the repository state using one or two | ||
parent hash identifiers, followed by a "+" if there are | ||||
uncommitted changes in the working directory, a list of tags for | ||||
this revision and a branch name for non-default branches. | ||||
|
r1437 | """ | ||
|
r4662 | |||
|
r5330 | if not repo and not source: | ||
raise util.Abort(_("There is no Mercurial repository here " | ||||
"(.hg not found)")) | ||||
|
r2966 | hexfunc = ui.debugflag and hex or short | ||
|
r4666 | default = not (num or id or branch or tags) | ||
output = [] | ||||
|
r4664 | |||
|
r7757 | revs = [] | ||
|
r4671 | if source: | ||
|
r10365 | source, branches = hg.parseurl(ui.expandpath(source)) | ||
|
r7757 | repo = hg.repository(ui, source) | ||
|
r10365 | revs, checkout = hg.addbranchrevs(repo, repo, branches, None) | ||
|
r7757 | |||
if not repo.local(): | ||||
|
r4671 | if not rev and revs: | ||
rev = revs[0] | ||||
|
r4667 | if not rev: | ||
rev = "tip" | ||||
if num or branch or tags: | ||||
raise util.Abort( | ||||
"can't query remote revision number, branch, or tags") | ||||
|
r7757 | output = [hexfunc(repo.lookup(rev))] | ||
|
r4667 | elif not rev: | ||
|
r6747 | ctx = repo[None] | ||
|
r4665 | parents = ctx.parents() | ||
|
r4666 | changed = False | ||
if default or id or num: | ||||
|
r10515 | changed = util.any(repo.status()) | ||
|
r4666 | if default or id: | ||
output = ["%s%s" % ('+'.join([hexfunc(p.node()) for p in parents]), | ||||
(changed) and "+" or "")] | ||||
if num: | ||||
output.append("%s%s" % ('+'.join([str(p.rev()) for p in parents]), | ||||
(changed) and "+" or "")) | ||||
|
r4665 | else: | ||
|
r6747 | ctx = repo[rev] | ||
|
r4666 | if default or id: | ||
output = [hexfunc(ctx.node())] | ||||
if num: | ||||
output.append(str(ctx.rev())) | ||||
|
r7757 | if repo.local() and default and not ui.quiet: | ||
|
r7948 | b = encoding.tolocal(ctx.branch()) | ||
|
r4666 | if b != 'default': | ||
output.append("(%s)" % b) | ||||
|
r3415 | |||
|
r386 | # multiple tags for a single parent separated by '/' | ||
|
r4666 | t = "/".join(ctx.tags()) | ||
if t: | ||||
output.append(t) | ||||
if branch: | ||||
|
r7948 | output.append(encoding.tolocal(ctx.branch())) | ||
|
r4666 | |||
if tags: | ||||
output.extend(ctx.tags()) | ||||
|
r339 | |||
|
r386 | ui.write("%s\n" % ' '.join(output)) | ||
|
r339 | |||
|
r437 | def import_(ui, repo, patch1, *patches, **opts): | ||
|
r1437 | """import an ordered set of patches | ||
|
r9649 | Import a list of patches and commit them individually (unless | ||
--no-commit is specified). | ||||
|
r1437 | |||
If there are outstanding changes in the working directory, import | ||||
|
r8033 | will abort unless given the -f/--force flag. | ||
|
r1437 | |||
|
r6448 | You can import a patch straight from a mail message. Even patches | ||
|
r8779 | as attachments work (to use the body part, it must have type | ||
text/plain or text/x-patch). From and Subject headers of email | ||||
|
r6448 | message are used as default committer and commit message. All | ||
|
r2515 | text/plain body parts before first diff are added to commit | ||
message. | ||||
|
r2504 | |||
|
r8004 | If the imported patch was generated by hg export, user and | ||
description from patch override values from message headers and | ||||
|
r8033 | body. Values given on command line with -m/--message and -u/--user | ||
override these. | ||||
|
r8004 | |||
If --exact is specified, import will set the working directory to | ||||
the parent of each patch before applying it, and will abort if the | ||||
resulting changeset has a different ID than the one recorded in | ||||
the patch. This may happen due to character set problems or other | ||||
deficiencies in the text patch format. | ||||
|
r4263 | |||
|
r8033 | With -s/--similarity, hg will attempt to discover renames and | ||
copies in the patch in the same way as 'addremove'. | ||||
|
r7402 | |||
|
r8931 | To read a patch from standard input, use "-" as the patch name. If | ||
a URL is specified, the patch will be downloaded from it. | ||||
|
r10973 | See :hg:`help dates` for a list of formats valid for -d/--date. | ||
|
r1437 | """ | ||
|
r437 | patches = (patch1,) + patches | ||
|
r500 | |||
|
r6139 | date = opts.get('date') | ||
if date: | ||||
opts['date'] = util.parsedate(date) | ||||
|
r7402 | try: | ||
sim = float(opts.get('similarity') or 0) | ||||
except ValueError: | ||||
raise util.Abort(_('similarity must be a number')) | ||||
if sim < 0 or sim > 100: | ||||
raise util.Abort(_('similarity must be between 0 and 100')) | ||||
|
r7131 | if opts.get('exact') or not opts.get('force'): | ||
|
r4549 | cmdutil.bail_if_changed(repo) | ||
|
r966 | |||
|
r437 | d = opts["base"] | ||
strip = opts["strip"] | ||||
|
r4915 | wlock = lock = None | ||
|
r10384 | |||
def tryone(ui, hunk): | ||||
|
r10413 | tmpname, message, user, date, branch, nodeid, p1, p2 = \ | ||
patch.extract(ui, hunk) | ||||
|
r10384 | |||
if not tmpname: | ||||
return None | ||||
commitid = _('to working directory') | ||||
try: | ||||
cmdline_message = cmdutil.logmessage(opts) | ||||
if cmdline_message: | ||||
# pickup the cmdline msg | ||||
message = cmdline_message | ||||
elif message: | ||||
# pickup the patch msg | ||||
message = message.strip() | ||||
else: | ||||
# launch the editor | ||||
message = None | ||||
ui.debug('message:\n%s\n' % message) | ||||
wp = repo.parents() | ||||
if opts.get('exact'): | ||||
if not nodeid or not p1: | ||||
raise util.Abort(_('not a Mercurial patch')) | ||||
p1 = repo.lookup(p1) | ||||
p2 = repo.lookup(p2 or hex(nullid)) | ||||
if p1 != wp[0].node(): | ||||
hg.clean(repo, p1) | ||||
repo.dirstate.setparents(p1, p2) | ||||
elif p2: | ||||
try: | ||||
p1 = repo.lookup(p1) | ||||
p2 = repo.lookup(p2) | ||||
if p1 == wp[0].node(): | ||||
repo.dirstate.setparents(p1, p2) | ||||
except error.RepoError: | ||||
pass | ||||
if opts.get('exact') or opts.get('import_branch'): | ||||
repo.dirstate.setbranch(branch or 'default') | ||||
files = {} | ||||
try: | ||||
patch.patch(tmpname, ui, strip=strip, cwd=repo.root, | ||||
files=files, eolmode=None) | ||||
finally: | ||||
files = patch.updatedir(ui, repo, files, | ||||
similarity=sim / 100.0) | ||||
if not opts.get('no_commit'): | ||||
if opts.get('exact'): | ||||
m = None | ||||
else: | ||||
m = cmdutil.matchfiles(repo, files or []) | ||||
n = repo.commit(message, opts.get('user') or user, | ||||
opts.get('date') or date, match=m, | ||||
editor=cmdutil.commiteditor) | ||||
if opts.get('exact'): | ||||
if hex(n) != nodeid: | ||||
repo.rollback() | ||||
raise util.Abort(_('patch is damaged' | ||||
' or loses information')) | ||||
# Force a dirstate write so that the next transaction | ||||
# backups an up-do-date file. | ||||
repo.dirstate.write() | ||||
if n: | ||||
commitid = short(n) | ||||
return commitid | ||||
finally: | ||||
os.unlink(tmpname) | ||||
|
r10405 | |||
|
r4915 | try: | ||
wlock = repo.wlock() | ||||
lock = repo.lock() | ||||
|
r10384 | lastcommit = None | ||
|
r4915 | for p in patches: | ||
pf = os.path.join(d, p) | ||||
if pf == '-': | ||||
ui.status(_("applying patch from stdin\n")) | ||||
|
r7271 | pf = sys.stdin | ||
|
r2400 | else: | ||
|
r4915 | ui.status(_("applying %s\n") % p) | ||
|
r7271 | pf = url.open(ui, pf) | ||
|
r10384 | |||
haspatch = False | ||||
for hunk in patch.split(pf): | ||||
commitid = tryone(ui, hunk) | ||||
if commitid: | ||||
haspatch = True | ||||
if lastcommit: | ||||
ui.status(_('applied %s\n') % lastcommit) | ||||
lastcommit = commitid | ||||
if not haspatch: | ||||
|
r4915 | raise util.Abort(_('no diffs found')) | ||
finally: | ||||
|
r8109 | release(lock, wlock) | ||
|
r437 | |||
|
r1192 | def incoming(ui, repo, source="default", **opts): | ||
|
r1437 | """show new changesets found in source | ||
|
r1979 | Show new changesets found in the specified path/URL or the default | ||
|
r8779 | pull location. These are the changesets that would have been pulled | ||
if a pull at the time you issued this command. | ||||
|
r8004 | |||
For remote repository, using --bundle avoids downloading the | ||||
changesets twice if the incoming is followed by a pull. | ||||
|
r1979 | |||
See pull for valid source format details. | ||||
|
r1437 | """ | ||
|
r6191 | limit = cmdutil.loglimit(opts) | ||
|
r10379 | source, branches = hg.parseurl(ui.expandpath(source), opts.get('branch')) | ||
|
r8188 | other = hg.repository(cmdutil.remoteui(repo, opts), source) | ||
|
r7270 | ui.status(_('comparing with %s\n') % url.hidepassword(source)) | ||
|
r10365 | revs, checkout = hg.addbranchrevs(repo, other, branches, opts.get('rev')) | ||
|
r4478 | if revs: | ||
|
r5259 | revs = [other.lookup(rev) for rev in revs] | ||
|
r7415 | common, incoming, rheads = repo.findcommonincoming(other, heads=revs, | ||
force=opts["force"]) | ||||
|
r1944 | if not incoming: | ||
|
r3933 | try: | ||
os.unlink(opts["bundle"]) | ||||
except: | ||||
pass | ||||
|
r1993 | ui.status(_("no changes found\n")) | ||
|
r3931 | return 1 | ||
|
r1944 | |||
cleanup = None | ||||
|
r1974 | try: | ||
fname = opts["bundle"] | ||||
if fname or not other.local(): | ||||
# create a bundle (uncompressed if other repo is not local) | ||||
|
r7415 | |||
if revs is None and other.capable('changegroupsubset'): | ||||
revs = rheads | ||||
|
r4451 | if revs is None: | ||
cg = other.changegroup(incoming, "incoming") | ||||
else: | ||||
cg = other.changegroupsubset(incoming, revs, 'incoming') | ||||
|
r3706 | bundletype = other.local() and "HG10BZ" or "HG10UN" | ||
fname = cleanup = changegroup.writebundle(cg, fname, bundletype) | ||||
|
r1974 | # keep written bundle? | ||
if opts["bundle"]: | ||||
cleanup = None | ||||
if not other.local(): | ||||
# use the created uncompressed bundlerepo | ||||
other = bundlerepo.bundlerepository(ui, repo.root, fname) | ||||
|
r2521 | o = other.changelog.nodesbetween(incoming, revs)[0] | ||
|
r7131 | if opts.get('newest_first'): | ||
|
r1974 | o.reverse() | ||
|
r3643 | displayer = cmdutil.show_changeset(ui, other, opts) | ||
|
r6191 | count = 0 | ||
|
r1974 | for n in o: | ||
|
r10111 | if limit is not None and count >= limit: | ||
|
r6191 | break | ||
|
r1974 | parents = [p for p in other.changelog.parents(n) if p != nullid] | ||
|
r7131 | if opts.get('no_merges') and len(parents) == 2: | ||
|
r1974 | continue | ||
|
r6191 | count += 1 | ||
|
r7369 | displayer.show(other[n]) | ||
|
r10152 | displayer.close() | ||
|
r1974 | finally: | ||
if hasattr(other, 'close'): | ||||
other.close() | ||||
if cleanup: | ||||
os.unlink(cleanup) | ||||
|
r1944 | |||
|
r2598 | def init(ui, dest=".", **opts): | ||
|
r1437 | """create a new repository in the given directory | ||
|
r6448 | Initialize a new repository in the given directory. If the given | ||
|
r8779 | directory does not exist, it will be created. | ||
|
r1437 | |||
If no directory is given, the current directory is used. | ||||
|
r2590 | |||
|
r9970 | It is possible to specify an ``ssh://`` URL as the destination. | ||
|
r10973 | See :hg:`help urls` for more information. | ||
|
r1437 | """ | ||
|
r8188 | hg.repository(cmdutil.remoteui(ui, opts), dest, create=1) | ||
|
r338 | |||
|
r627 | def locate(ui, repo, *pats, **opts): | ||
|
r1437 | """locate files matching specific patterns | ||
|
r8779 | Print files under Mercurial control in the working directory whose | ||
names match the given patterns. | ||||
By default, this command searches all directories in the working | ||||
directory. To search just the current directory and its | ||||
subdirectories, use "--include .". | ||||
If no patterns are given to match, this command prints the names | ||||
of all files under Mercurial control in the working directory. | ||||
|
r1437 | |||
If you want to feed the output of this command into the "xargs" | ||||
|
r8032 | command, use the -0 option to both this command and "xargs". This | ||
will avoid the problem of "xargs" treating single filenames that | ||||
|
r8779 | contain whitespace as multiple filenames. | ||
|
r1437 | """ | ||
|
r7131 | end = opts.get('print0') and '\0' or '\n' | ||
|
r6764 | rev = opts.get('rev') or None | ||
|
r742 | |||
|
r4196 | ret = 1 | ||
|
r6579 | m = cmdutil.match(repo, pats, opts, default='relglob') | ||
|
r10282 | m.bad = lambda x, y: False | ||
|
r6764 | for abs in repo[rev].walk(m): | ||
if not rev and abs not in repo.dirstate: | ||||
|
r4308 | continue | ||
|
r7131 | if opts.get('fullpath'): | ||
|
r7570 | ui.write(repo.wjoin(abs), end) | ||
|
r724 | else: | ||
|
r6584 | ui.write(((pats and m.rel(abs)) or abs), end) | ||
|
r4196 | ret = 0 | ||
return ret | ||||
|
r627 | |||
|
r1031 | def log(ui, repo, *pats, **opts): | ||
|
r1437 | """show revision history of entire repository or files | ||
|
r2741 | Print the revision history of the specified files or the entire | ||
project. | ||||
File history is shown without following rename or copy history of | ||||
|
r8761 | files. Use -f/--follow with a filename to follow history across | ||
renames and copies. --follow without a filename will only show | ||||
|
r2784 | ancestors or descendants of the starting revision. --follow-first | ||
only follows the first parent of merge revisions. | ||||
|
r1437 | |||
|
r2783 | If no revision range is specified, the default is tip:0 unless | ||
--follow is set, in which case the working directory parent is | ||||
used as the starting revision. | ||||
|
r10973 | See :hg:`help dates` for a list of formats valid for -d/--date. | ||
|
r6163 | |||
|
r8779 | By default this command prints revision number and changeset id, | ||
tags, non-trivial parents, user, date and time, and a summary for | ||||
each commit. When the -v/--verbose switch is used, the list of | ||||
changed files and full commit message are shown. | ||||
|
r3822 | |||
|
r8033 | NOTE: log -p/--patch may generate unexpected diff output for merge | ||
|
r7807 | changesets, as it will only compare the merge changeset against | ||
|
r8779 | its first parent. Also, only files different from BOTH parents | ||
will appear in files:. | ||||
|
r1437 | """ | ||
|
r1756 | |||
|
r9652 | matchfn = cmdutil.match(repo, pats, opts) | ||
|
r6190 | limit = cmdutil.loglimit(opts) | ||
|
r1756 | count = 0 | ||
|
r10060 | endrev = None | ||
|
r7131 | if opts.get('copies') and opts.get('rev'): | ||
endrev = max(cmdutil.revrange(repo, opts.get('rev'))) + 1 | ||||
|
r3197 | |||
|
r3813 | df = False | ||
if opts["date"]: | ||||
df = util.matchdate(opts["date"]) | ||||
|
r10963 | branches = opts.get('branch', []) + opts.get('only_branch', []) | ||
opts['branch'] = [repo.lookupbranch(b) for b in branches] | ||||
|
r10957 | |||
|
r3837 | displayer = cmdutil.show_changeset(ui, repo, opts, True, matchfn) | ||
|
r9662 | def prep(ctx, fns): | ||
|
r9655 | rev = ctx.rev() | ||
|
r9662 | parents = [p for p in repo.changelog.parentrevs(rev) | ||
if p != nullrev] | ||||
if opts.get('no_merges') and len(parents) == 2: | ||||
return | ||||
if opts.get('only_merges') and len(parents) != 2: | ||||
return | ||||
|
r10957 | if opts.get('branch') and ctx.branch() not in opts['branch']: | ||
|
r9662 | return | ||
if df and not df(ctx.date()[0]): | ||||
return | ||||
|
r9663 | if opts['user'] and not [k for k in opts['user'] if k in ctx.user()]: | ||
return | ||||
|
r9662 | if opts.get('keyword'): | ||
for k in [kw.lower() for kw in opts['keyword']]: | ||||
|
r9663 | if (k in ctx.user().lower() or | ||
k in ctx.description().lower() or | ||||
k in " ".join(ctx.files()).lower()): | ||||
|
r9662 | break | ||
|
r9663 | else: | ||
|
r9662 | return | ||
|
r10060 | copies = None | ||
|
r9662 | if opts.get('copies') and rev: | ||
|
r10060 | copies = [] | ||
getrenamed = templatekw.getrenamedfn(repo, endrev=endrev) | ||||
|
r9662 | for fn in ctx.files(): | ||
rename = getrenamed(fn, rev) | ||||
if rename: | ||||
copies.append((fn, rename[0])) | ||||
displayer.show(ctx, copies=copies) | ||||
|
r9665 | for ctx in cmdutil.walkchangerevs(repo, matchfn, opts, prep): | ||
|
r9687 | if count == limit: | ||
break | ||||
if displayer.flush(ctx.rev()): | ||||
count += 1 | ||||
|
r10152 | displayer.close() | ||
|
r255 | |||
|
r5155 | def manifest(ui, repo, node=None, rev=None): | ||
|
r3914 | """output the current or given revision of the project manifest | ||
|
r1437 | |||
Print a list of version controlled files for the given revision. | ||||
|
r8041 | If no revision is given, the first parent of the working directory | ||
|
r8779 | is used, or the null revision if no revision is checked out. | ||
With -v, print file permissions, symlink and executable bits. | ||||
With --debug, print file revision hashes. | ||||
|
r1437 | """ | ||
|
r3736 | |||
|
r5155 | if rev and node: | ||
raise util.Abort(_("please specify just one revision")) | ||||
if not node: | ||||
node = rev | ||||
|
r6749 | decor = {'l':'644 @ ', 'x':'755 * ', '':'644 '} | ||
ctx = repo[node] | ||||
for f in ctx: | ||||
|
r3736 | if ui.debugflag: | ||
|
r6749 | ui.write("%40s " % hex(ctx.manifest()[f])) | ||
|
r3736 | if ui.verbose: | ||
|
r6749 | ui.write(decor[ctx.flags(f)]) | ||
|
r3736 | ui.write("%s\n" % f) | ||
|
r255 | |||
|
r8387 | def merge(ui, repo, node=None, **opts): | ||
|
r4014 | """merge working directory with another revision | ||
|
r2019 | |||
|
r8779 | The current working directory is updated with all changes made in | ||
the requested revision since the last common predecessor revision. | ||||
|
r7977 | |||
Files that changed between either parent are marked as changed for | ||||
the next commit and a commit must be performed before any further | ||||
|
r8779 | updates to the repository are allowed. The next commit will have | ||
two parents. | ||||
|
r2915 | |||
If no revision is specified, the working directory's parent is a | ||||
|
r8004 | head revision, and the current branch contains exactly one other | ||
head, the other head is merged with by default. Otherwise, an | ||||
|
r8779 | explicit revision with which to merge with must be provided. | ||
|
r2019 | """ | ||
|
r2806 | |||
|
r8387 | if opts.get('rev') and node: | ||
|
r4450 | raise util.Abort(_("please specify just one revision")) | ||
if not node: | ||||
|
r8387 | node = opts.get('rev') | ||
|
r4450 | |||
|
r3876 | if not node: | ||
|
r6740 | branch = repo.changectx(None).branch() | ||
|
r6844 | bheads = repo.branchheads(branch) | ||
|
r6723 | if len(bheads) > 2: | ||
|
r10355 | ui.warn(_("abort: branch '%s' has %d heads - " | ||
"please merge with an explicit rev\n") | ||||
% (branch, len(bheads))) | ||||
ui.status(_("(run 'hg heads .' to see heads)\n")) | ||||
return False | ||||
|
r6723 | |||
|
r5242 | parent = repo.dirstate.parents()[0] | ||
|
r6723 | if len(bheads) == 1: | ||
if len(repo.heads()) > 1: | ||||
|
r10355 | ui.warn(_("abort: branch '%s' has one head - " | ||
"please merge with an explicit rev\n" % branch)) | ||||
ui.status(_("(run 'hg heads' to see all heads)\n")) | ||||
return False | ||||
|
r5242 | msg = _('there is nothing to merge') | ||
|
r6747 | if parent != repo.lookup(repo[None].branch()): | ||
|
r5542 | msg = _('%s - use "hg update" instead') % msg | ||
|
r5242 | raise util.Abort(msg) | ||
|
r6723 | if parent not in bheads: | ||
|
r2915 | raise util.Abort(_('working dir not at a head rev - ' | ||
'use "hg update" or merge with an explicit rev')) | ||||
|
r6723 | node = parent == bheads[0] and bheads[-1] or bheads[0] | ||
|
r8387 | |||
|
r8834 | if opts.get('preview'): | ||
|
r10505 | # find nodes that are ancestors of p2 but not of p1 | ||
p1 = repo.lookup('.') | ||||
p2 = repo.lookup(node) | ||||
nodes = repo.changelog.findmissing(common=[p1], heads=[p2]) | ||||
|
r8387 | displayer = cmdutil.show_changeset(ui, repo, opts) | ||
|
r10505 | for node in nodes: | ||
displayer.show(repo[node]) | ||||
|
r10152 | displayer.close() | ||
|
r8387 | return 0 | ||
return hg.merge(repo, node, force=opts.get('force')) | ||||
|
r2029 | |||
|
r2494 | def outgoing(ui, repo, dest=None, **opts): | ||
|
r10376 | """show changesets not found in the destination | ||
|
r1437 | |||
|
r8004 | Show changesets not found in the specified destination repository | ||
or the default push location. These are the changesets that would | ||||
be pushed if a push was requested. | ||||
|
r1811 | |||
|
r10376 | See pull for details of valid destination formats. | ||
|
r1437 | """ | ||
|
r6191 | limit = cmdutil.loglimit(opts) | ||
|
r10365 | dest = ui.expandpath(dest or 'default-push', dest or 'default') | ||
|
r10379 | dest, branches = hg.parseurl(dest, opts.get('branch')) | ||
|
r10365 | revs, checkout = hg.addbranchrevs(repo, repo, branches, opts.get('rev')) | ||
|
r4478 | if revs: | ||
revs = [repo.lookup(rev) for rev in revs] | ||||
|
r1965 | |||
|
r8188 | other = hg.repository(cmdutil.remoteui(repo, opts), dest) | ||
|
r7270 | ui.status(_('comparing with %s\n') % url.hidepassword(dest)) | ||
|
r7131 | o = repo.findoutgoing(other, force=opts.get('force')) | ||
|
r1994 | if not o: | ||
ui.status(_("no changes found\n")) | ||||
|
r3931 | return 1 | ||
|
r2521 | o = repo.changelog.nodesbetween(o, revs)[0] | ||
|
r7131 | if opts.get('newest_first'): | ||
|
r1439 | o.reverse() | ||
|
r3643 | displayer = cmdutil.show_changeset(ui, repo, opts) | ||
|
r6191 | count = 0 | ||
|
r920 | for n in o: | ||
|
r10111 | if limit is not None and count >= limit: | ||
|
r6191 | break | ||
|
r1435 | parents = [p for p in repo.changelog.parents(n) if p != nullid] | ||
|
r7131 | if opts.get('no_merges') and len(parents) == 2: | ||
|
r1435 | continue | ||
|
r6191 | count += 1 | ||
|
r7369 | displayer.show(repo[n]) | ||
|
r10152 | displayer.close() | ||
|
r920 | |||
|
r3658 | def parents(ui, repo, file_=None, **opts): | ||
|
r8026 | """show the parents of the working directory or revision | ||
|
r1437 | |||
|
r8004 | Print the working directory's parent revisions. If a revision is | ||
|
r8033 | given via -r/--rev, the parent of that revision will be printed. | ||
|
r8779 | If a file argument is given, the revision in which the file was | ||
last changed (before the working directory revision or the | ||||
argument to --rev if given) is printed. | ||||
|
r1437 | """ | ||
|
r3658 | rev = opts.get('rev') | ||
|
r5298 | if rev: | ||
|
r6747 | ctx = repo[rev] | ||
|
r5298 | else: | ||
|
r6747 | ctx = repo[None] | ||
|
r5298 | |||
|
r4586 | if file_: | ||
|
r6582 | m = cmdutil.match(repo, (file_,), opts) | ||
if m.anypats() or len(m.files()) != 1: | ||||
|
r8761 | raise util.Abort(_('can only specify an explicit filename')) | ||
|
r6582 | file_ = m.files()[0] | ||
|
r5298 | filenodes = [] | ||
for cp in ctx.parents(): | ||||
if not cp: | ||||
continue | ||||
try: | ||||
filenodes.append(cp.filenode(file_)) | ||||
|
r7633 | except error.LookupError: | ||
|
r5298 | pass | ||
if not filenodes: | ||||
raise util.Abort(_("'%s' not found in manifest!") % file_) | ||||
fl = repo.file(file_) | ||||
|
r7361 | p = [repo.lookup(fl.linkrev(fl.rev(fn))) for fn in filenodes] | ||
|
r255 | else: | ||
|
r5298 | p = [cp.node() for cp in ctx.parents()] | ||
|
r255 | |||
|
r3643 | displayer = cmdutil.show_changeset(ui, repo, opts) | ||
|
r255 | for n in p: | ||
|
r1092 | if n != nullid: | ||
|
r7743 | displayer.show(repo[n]) | ||
|
r10152 | displayer.close() | ||
|
r255 | |||
|
r1858 | def paths(ui, repo, search=None): | ||
|
r7691 | """show aliases for remote repositories | ||
|
r8004 | Show definition of symbolic path name NAME. If no name is given, | ||
|
r8779 | show definition of all available names. | ||
|
r7743 | |||
|
r1437 | Path names are defined in the [paths] section of /etc/mercurial/hgrc | ||
|
r6448 | and $HOME/.hgrc. If run inside a repository, .hg/hgrc is used, too. | ||
|
r7693 | |||
|
r11007 | The path names ``default`` and ``default-push`` have a special | ||
meaning. When performing a push or pull operation, they are used | ||||
as fallbacks if no location is specified on the command-line. | ||||
When ``default-push`` is set, it will be used for push and | ||||
``default`` will be used for pull; otherwise ``default`` is used | ||||
as the fallback for both. When cloning a repository, the clone | ||||
source is written as ``default`` in ``.hg/hgrc``. Note that | ||||
``default`` and ``default-push`` apply to all inbound (e.g. ``hg | ||||
incoming``) and outbound (e.g. ``hg outgoing``, ``hg email`` and | ||||
``hg bundle``) operations. | ||||
|
r10933 | |||
|
r10973 | See :hg:`help urls` for more information. | ||
|
r1437 | """ | ||
|
r779 | if search: | ||
for name, path in ui.configitems("paths"): | ||||
if name == search: | ||||
|
r7270 | ui.write("%s\n" % url.hidepassword(path)) | ||
|
r779 | return | ||
|
r1402 | ui.warn(_("not found!\n")) | ||
|
r779 | return 1 | ||
else: | ||||
for name, path in ui.configitems("paths"): | ||||
|
r7270 | ui.write("%s = %s\n" % (name, url.hidepassword(path))) | ||
|
r779 | |||
|
r5224 | def postincoming(ui, repo, modheads, optupdate, checkout): | ||
|
r2019 | if modheads == 0: | ||
return | ||||
if optupdate: | ||||
|
r7372 | if (modheads <= 1 or len(repo.branchheads()) == 1) or checkout: | ||
|
r5224 | return hg.update(repo, checkout) | ||
|
r2019 | else: | ||
ui.status(_("not updating, since new heads added\n")) | ||||
if modheads > 1: | ||||
ui.status(_("(run 'hg heads' to see heads, 'hg merge' to merge)\n")) | ||||
else: | ||||
ui.status(_("(run 'hg update' to get a working copy)\n")) | ||||
|
r2029 | |||
|
r404 | def pull(ui, repo, source="default", **opts): | ||
|
r1437 | """pull changes from the specified source | ||
|
r8779 | Pull changes from a remote repository to a local one. | ||
|
r1437 | |||
This finds all changes from the repository at the specified path | ||||
|
r8779 | or URL and adds them to a local repository (the current one unless | ||
-R is specified). By default, this does not update the copy of the | ||||
project in the working directory. | ||||
Use hg incoming if you want to see what would have been added by a | ||||
pull at the time you issued this command. If you then decide to | ||||
added those changes to the repository, you should use pull -r X | ||||
where X is the last changeset listed by hg incoming. | ||||
|
r7980 | |||
|
r7693 | If SOURCE is omitted, the 'default' path will be used. | ||
|
r10973 | See :hg:`help urls` for more information. | ||
|
r1437 | """ | ||
|
r10379 | source, branches = hg.parseurl(ui.expandpath(source), opts.get('branch')) | ||
|
r8188 | other = hg.repository(cmdutil.remoteui(repo, opts), source) | ||
|
r7270 | ui.status(_('pulling from %s\n') % url.hidepassword(source)) | ||
|
r10365 | revs, checkout = hg.addbranchrevs(repo, other, branches, opts.get('rev')) | ||
|
r4478 | if revs: | ||
|
r5259 | try: | ||
|
r4478 | revs = [other.lookup(rev) for rev in revs] | ||
|
r7637 | except error.CapabilityError: | ||
err = _("Other repository doesn't support revision lookup, " | ||||
"so a rev cannot be specified.") | ||||
raise util.Abort(err) | ||||
|
r4478 | |||
|
r7131 | modheads = repo.pull(other, heads=revs, force=opts.get('force')) | ||
|
r9645 | if checkout: | ||
checkout = str(repo.changelog.rev(other.lookup(checkout))) | ||||
|
r7131 | return postincoming(ui, repo, modheads, opts.get('update'), checkout) | ||
|
r246 | |||
|
r2494 | def push(ui, repo, dest=None, **opts): | ||
|
r1437 | """push changes to the specified destination | ||
|
r10376 | Push changes from the local repository to the specified destination. | ||
|
r1437 | |||
|
r7981 | This is the symmetrical operation for pull. It moves changes from | ||
the current repository to a different one. If the destination is | ||||
local this is identical to a pull in that directory from the | ||||
current one. | ||||
|
r1437 | |||
By default, push will refuse to run if it detects the result would | ||||
increase the number of remote heads. This generally indicates the | ||||
|
r8779 | user forgot to pull and merge before pushing. | ||
|
r1437 | |||
|
r8033 | If -r/--rev is used, the named revision and all its ancestors will | ||
be pushed to the remote repository. | ||||
|
r7693 | |||
|
r10973 | Please see :hg:`help urls` for important details about ``ssh://`` | ||
|
r8004 | URLs. If DESTINATION is omitted, a default path will be used. | ||
|
r1437 | """ | ||
|
r10365 | dest = ui.expandpath(dest or 'default-push', dest or 'default') | ||
|
r10379 | dest, branches = hg.parseurl(dest, opts.get('branch')) | ||
|
r10365 | revs, checkout = hg.addbranchrevs(repo, repo, branches, opts.get('rev')) | ||
|
r8188 | other = hg.repository(cmdutil.remoteui(repo, opts), dest) | ||
|
r7270 | ui.status(_('pushing to %s\n') % url.hidepassword(dest)) | ||
|
r4478 | if revs: | ||
revs = [repo.lookup(rev) for rev in revs] | ||||
|
r8815 | |||
# push subrepos depth-first for coherent ordering | ||||
c = repo[''] | ||||
subs = c.substate # only repos that are committed | ||||
for s in sorted(subs): | ||||
c.sub(s).push(opts.get('force')) | ||||
|
r7131 | r = repo.push(other, opts.get('force'), revs=revs) | ||
|
r2019 | return r == 0 | ||
|
r319 | |||
|
r245 | def recover(ui, repo): | ||
|
r1437 | """roll back an interrupted transaction | ||
Recover from an interrupted commit or pull. | ||||
|
r8004 | This command tries to fix the repository status after an | ||
interrupted operation. It should only be necessary when Mercurial | ||||
suggests it. | ||||
|
r1437 | """ | ||
|
r1516 | if repo.recover(): | ||
|
r2778 | return hg.verify(repo) | ||
|
r2057 | return 1 | ||
|
r245 | |||
|
r2179 | def remove(ui, repo, *pats, **opts): | ||
|
r1437 | """remove the specified files on the next commit | ||
Schedule the indicated files for removal from the repository. | ||||
|
r8004 | This only removes files from the current branch, not from the | ||
|
r8033 | entire project history. -A/--after can be used to remove only | ||
files that have already been deleted, -f/--force can be used to | ||||
force deletion, and -Af can be used to remove files from the next | ||||
|
r8779 | revision without deleting them from the working directory. | ||
|
r8004 | |||
The following table details the behavior of remove for different | ||||
file states (columns) and option combinations (rows). The file | ||||
|
r9249 | states are Added [A], Clean [C], Modified [M] and Missing [!] (as | ||
reported by hg status). The actions are Warn, Remove (from branch) | ||||
and Delete (from disk):: | ||||
|
r9157 | |||
A C M ! | ||||
none W RD W R | ||||
-f R RD RD R | ||||
-A W W W R | ||||
-Af R R R R | ||||
|
r2309 | |||
|
r3829 | This command schedules the files to be removed at the next commit. | ||
To undo a remove before that, see hg revert. | ||||
|
r1437 | """ | ||
|
r6346 | |||
after, force = opts.get('after'), opts.get('force') | ||||
if not pats and not after: | ||||
|
r2179 | raise util.Abort(_('no files specified')) | ||
|
r6346 | |||
|
r6582 | m = cmdutil.match(repo, pats, opts) | ||
|
r6761 | s = repo.status(match=m, clean=True) | ||
modified, added, deleted, clean = s[0], s[1], s[3], s[6] | ||||
|
r8533 | for f in m.files(): | ||
if f not in repo.dirstate and not os.path.isdir(m.rel(f)): | ||||
ui.warn(_('not removing %s: file is untracked\n') % m.rel(f)) | ||||
|
r6761 | def warn(files, reason): | ||
for f in files: | ||||
ui.warn(_('not removing %s: file %s (use -f to force removal)\n') | ||||
% (m.rel(f), reason)) | ||||
if force: | ||||
remove, forget = modified + deleted + clean, added | ||||
elif after: | ||||
remove, forget = deleted, [] | ||||
warn(modified + added + clean, _('still exists')) | ||||
else: | ||||
remove, forget = deleted + clean, [] | ||||
warn(modified, _('is modified')) | ||||
warn(added, _('has been marked for add')) | ||||
|
r8209 | for f in sorted(remove + forget): | ||
|
r6761 | if ui.verbose or not m.exact(f): | ||
ui.status(_('removing %s\n') % m.rel(f)) | ||||
|
r6346 | |||
|
r2309 | repo.forget(forget) | ||
|
r6346 | repo.remove(remove, unlink=not after) | ||
|
r245 | |||
|
r1253 | def rename(ui, repo, *pats, **opts): | ||
|
r1437 | """rename files; equivalent of copy + remove | ||
|
r8004 | Mark dest as copies of sources; mark sources for deletion. If dest | ||
is a directory, copies are put in that directory. If dest is a | ||||
file, there can only be one source. | ||||
|
r1437 | |||
By default, this command copies the contents of files as they | ||||
|
r8033 | exist in the working directory. If invoked with -A/--after, the | ||
|
r1437 | operation is recorded, but no copying is performed. | ||
|
r7807 | This command takes effect at the next commit. To undo a rename | ||
|
r3829 | before that, see hg revert. | ||
|
r1437 | """ | ||
|
r4914 | wlock = repo.wlock(False) | ||
|
r4915 | try: | ||
|
r5610 | return cmdutil.copy(ui, repo, pats, opts, rename=True) | ||
|
r4915 | finally: | ||
|
r8109 | wlock.release() | ||
|
r1253 | |||
|
r6518 | def resolve(ui, repo, *pats, **opts): | ||
|
r10559 | """various operations to help finish a merge | ||
This command includes several actions that are often useful while | ||||
performing a merge, after running ``merge`` but before running | ||||
``commit``. (It is only meaningful if your working directory has | ||||
two parents.) It is most relevant for merges with unresolved | ||||
conflicts, which are typically a result of non-interactive merging with | ||||
``internal:merge`` or a command-line merge tool like ``diff3``. | ||||
The available actions are: | ||||
1) list files that were merged with conflicts (U, for unresolved) | ||||
and without conflicts (R, for resolved): ``hg resolve -l`` | ||||
(this is like ``status`` for merges) | ||||
2) record that you have resolved conflicts in certain files: | ||||
``hg resolve -m [file ...]`` (default: mark all unresolved files) | ||||
3) forget that you have resolved conflicts in certain files: | ||||
``hg resolve -u [file ...]`` (default: unmark all resolved files) | ||||
4) discard your current attempt(s) at resolving conflicts and | ||||
restart the merge from scratch: ``hg resolve file...`` | ||||
(or ``-a`` for all unresolved files) | ||||
Note that Mercurial will not let you commit files with unresolved merge | ||||
conflicts. You must use ``hg resolve -m ...`` before you can commit | ||||
after a conflicting merge. | ||||
|
r6518 | """ | ||
|
r9646 | all, mark, unmark, show, nostatus = \ | ||
[opts.get(o) for o in 'all mark unmark list no_status'.split()] | ||||
|
r7527 | |||
if (show and (mark or unmark)) or (mark and unmark): | ||||
|
r6518 | raise util.Abort(_("too many options specified")) | ||
|
r7527 | if pats and all: | ||
raise util.Abort(_("can't specify --all and patterns")) | ||||
if not (all or pats or show or mark or unmark): | ||||
raise util.Abort(_('no files or directories specified; ' | ||||
'use --all to remerge all files')) | ||||
|
r6518 | |||
|
r10651 | ms = mergemod.mergestate(repo) | ||
|
r6594 | m = cmdutil.match(repo, pats, opts) | ||
|
r6518 | |||
for f in ms: | ||||
|
r6594 | if m(f): | ||
|
r7527 | if show: | ||
|
r9646 | if nostatus: | ||
ui.write("%s\n" % f) | ||||
else: | ||||
|
r10817 | ui.write("%s %s\n" % (ms[f].upper(), f), | ||
label='resolve.' + | ||||
{'u': 'unresolved', 'r': 'resolved'}[ms[f]]) | ||||
|
r7527 | elif mark: | ||
|
r6518 | ms.mark(f, "r") | ||
|
r7527 | elif unmark: | ||
|
r6518 | ms.mark(f, "u") | ||
else: | ||||
|
r6747 | wctx = repo[None] | ||
|
r6518 | mctx = wctx.parents()[-1] | ||
|
r7847 | |||
# backup pre-resolve (merge uses .orig for its own purposes) | ||||
a = repo.wjoin(f) | ||||
util.copyfile(a, a + ".resolve") | ||||
# resolve file | ||||
|
r6518 | ms.resolve(f, wctx, mctx) | ||
|
r7847 | # replace filemerge's .orig file with our resolve file | ||
util.rename(a + ".resolve", a + ".orig") | ||||
|
r1472 | def revert(ui, repo, *pats, **opts): | ||
|
r8026 | """restore individual files or directories to an earlier state | ||
|
r5574 | |||
|
r8287 | (Use update -r to check out earlier revisions, revert does not | ||
change the working directory parents.) | ||||
|
r2204 | |||
|
r2212 | With no revision specified, revert the named files or directories | ||
to the contents they had in the parent of the working directory. | ||||
This restores the contents of the affected files to an unmodified | ||||
|
r3829 | state and unschedules adds, removes, copies, and renames. If the | ||
|
r10376 | working directory has two parents, you must explicitly specify a | ||
revision. | ||||
|
r1811 | |||
|
r8033 | Using the -r/--rev option, revert the given files or directories | ||
to their contents as of a specific revision. This can be helpful | ||||
|
r10973 | to "roll back" some or all of an earlier change. See :hg:`help | ||
dates` for a list of formats valid for -d/--date. | ||||
|
r1811 | |||
|
r6448 | Revert modifies the working directory. It does not commit any | ||
changes, or change the parent of the working directory. If you | ||||
|
r2204 | revert to a revision other than the parent of the working | ||
directory, the reverted files will thus appear modified | ||||
afterwards. | ||||
|
r1437 | |||
|
r8004 | If a file has been deleted, it is restored. If the executable mode | ||
of a file was changed, it is reset. | ||||
|
r1437 | |||
|
r1472 | If names are given, all files matching the names are reverted. | ||
|
r2982 | If no arguments are given, no files are reverted. | ||
|
r5574 | |||
Modified files are saved with a .orig suffix before reverting. | ||||
To disable these backups, use --no-backup. | ||||
|
r1437 | """ | ||
|
r2982 | |||
|
r3814 | if opts["date"]: | ||
if opts["rev"]: | ||||
raise util.Abort(_("you can't specify a revision and a date")) | ||||
opts["rev"] = cmdutil.finddate(ui, repo, opts["date"]) | ||||
|
r7131 | if not pats and not opts.get('all'): | ||
|
r3020 | raise util.Abort(_('no files or directories specified; ' | ||
'use --all to revert the whole repo')) | ||||
|
r2982 | |||
|
r2212 | parent, p2 = repo.dirstate.parents() | ||
|
r7131 | if not opts.get('rev') and p2 != nullid: | ||
|
r3132 | raise util.Abort(_('uncommitted merge - please provide a ' | ||
'specific revision')) | ||||
|
r7131 | ctx = repo[opts.get('rev')] | ||
|
r3972 | node = ctx.node() | ||
mf = ctx.manifest() | ||||
|
r2407 | if node == parent: | ||
pmf = mf | ||||
else: | ||||
pmf = None | ||||
|
r2029 | |||
|
r2042 | # need all matching names in dirstate and manifest of target rev, | ||
# so have to walk both. do not print errors if files exist in one | ||||
# but not other. | ||||
|
r2029 | names = {} | ||
|
r2042 | |||
|
r4915 | wlock = repo.wlock() | ||
try: | ||||
# walk dirstate. | ||||
|
r6579 | |||
m = cmdutil.match(repo, pats, opts) | ||||
|
r10282 | m.bad = lambda x, y: False | ||
|
r6586 | for abs in repo.walk(m): | ||
|
r6584 | names[abs] = m.rel(abs), m.exact(abs) | ||
|
r4915 | |||
# walk target manifest. | ||||
|
r6579 | def badfn(path, msg): | ||
|
r4915 | if path in names: | ||
|
r8679 | return | ||
|
r4915 | path_ = path + '/' | ||
for f in names: | ||||
if f.startswith(path_): | ||||
|
r8679 | return | ||
|
r8615 | ui.warn("%s: %s\n" % (m.rel(path), msg)) | ||
|
r4915 | |||
|
r6579 | m = cmdutil.match(repo, pats, opts) | ||
m.bad = badfn | ||||
|
r6764 | for abs in repo[node].walk(m): | ||
|
r6584 | if abs not in names: | ||
names[abs] = m.rel(abs), m.exact(abs) | ||||
|
r6031 | |||
|
r6599 | m = cmdutil.matchfiles(repo, names) | ||
|
r6603 | changes = repo.status(match=m)[:4] | ||
|
r8152 | modified, added, removed, deleted = map(set, changes) | ||
|
r4915 | |||
|
r5266 | # if f is a rename, also revert the source | ||
cwd = repo.getcwd() | ||||
for f in added: | ||||
src = repo.dirstate.copied(f) | ||||
if src and src not in names and repo.dirstate[src] == 'r': | ||||
|
r8152 | removed.add(src) | ||
|
r5266 | names[src] = (repo.pathto(src, cwd), True) | ||
|
r6109 | def removeforget(abs): | ||
if repo.dirstate[abs] == 'a': | ||||
return _('forgetting %s\n') | ||||
return _('removing %s\n') | ||||
|
r4915 | revert = ([], _('reverting %s\n')) | ||
add = ([], _('adding %s\n')) | ||||
|
r6109 | remove = ([], removeforget) | ||
|
r4915 | undelete = ([], _('undeleting %s\n')) | ||
disptable = ( | ||||
# dispatch table: | ||||
# file state | ||||
# action if in target manifest | ||||
# action if not in target manifest | ||||
# make backup if in target manifest | ||||
# make backup if not in target manifest | ||||
(modified, revert, remove, True, True), | ||||
|
r6109 | (added, revert, remove, True, False), | ||
|
r4915 | (removed, undelete, None, False, False), | ||
(deleted, revert, remove, False, False), | ||||
) | ||||
|
r8209 | for abs, (rel, exact) in sorted(names.items()): | ||
|
r4915 | mfentry = mf.get(abs) | ||
target = repo.wjoin(abs) | ||||
def handle(xlist, dobackup): | ||||
xlist[0].append(abs) | ||||
|
r7131 | if dobackup and not opts.get('no_backup') and util.lexists(target): | ||
|
r4915 | bakname = "%s.orig" % rel | ||
ui.note(_('saving current version of %s as %s\n') % | ||||
(rel, bakname)) | ||||
if not opts.get('dry_run'): | ||||
util.copyfile(target, bakname) | ||||
if ui.verbose or not exact: | ||||
|
r6109 | msg = xlist[1] | ||
if not isinstance(msg, basestring): | ||||
msg = msg(abs) | ||||
ui.status(msg % rel) | ||||
|
r4915 | for table, hitlist, misslist, backuphit, backupmiss in disptable: | ||
|
r10282 | if abs not in table: | ||
continue | ||||
|
r4915 | # file has changed in dirstate | ||
if mfentry: | ||||
handle(hitlist, backuphit) | ||||
elif misslist is not None: | ||||
handle(misslist, backupmiss) | ||||
break | ||||
|
r2029 | else: | ||
|
r6031 | if abs not in repo.dirstate: | ||
if mfentry: | ||||
handle(add, True) | ||||
elif exact: | ||||
ui.warn(_('file not managed: %s\n') % rel) | ||||
continue | ||||
|
r4915 | # file has not changed in dirstate | ||
if node == parent: | ||||
|
r10282 | if exact: | ||
ui.warn(_('no changes needed to %s\n') % rel) | ||||
|
r4915 | continue | ||
if pmf is None: | ||||
# only need parent manifest in this unlikely case, | ||||
# so do not read by default | ||||
|
r6747 | pmf = repo[parent].manifest() | ||
|
r4915 | if abs in pmf: | ||
if mfentry: | ||||
# if version of file is same in parent and target | ||||
# manifests, do nothing | ||||
|
r6030 | if (pmf[abs] != mfentry or | ||
pmf.flags(abs) != mf.flags(abs)): | ||||
|
r4915 | handle(revert, False) | ||
else: | ||||
handle(remove, False) | ||||
if not opts.get('dry_run'): | ||||
|
r6107 | def checkout(f): | ||
fc = ctx[f] | ||||
|
r6743 | repo.wwrite(f, fc.data(), fc.flags()) | ||
|
r6107 | |||
|
r6109 | audit_path = util.path_auditor(repo.root) | ||
for f in remove[0]: | ||||
if repo.dirstate[f] == 'a': | ||||
repo.dirstate.forget(f) | ||||
continue | ||||
audit_path(f) | ||||
try: | ||||
util.unlink(repo.wjoin(f)) | ||||
except OSError: | ||||
pass | ||||
repo.dirstate.remove(f) | ||||
|
r6107 | |||
|
r6299 | normal = None | ||
if node == parent: | ||||
# We're reverting to our parent. If possible, we'd like status | ||||
# to report the file as clean. We have to use normallookup for | ||||
# merges to avoid losing information about merged/dirty files. | ||||
if p2 != nullid: | ||||
normal = repo.dirstate.normallookup | ||||
else: | ||||
normal = repo.dirstate.normal | ||||
|
r6107 | for f in revert[0]: | ||
checkout(f) | ||||
|
r6299 | if normal: | ||
normal(f) | ||||
|
r6107 | |||
|
r4915 | for f in add[0]: | ||
|
r6107 | checkout(f) | ||
|
r4915 | repo.dirstate.add(f) | ||
|
r6107 | |||
|
r6108 | normal = repo.dirstate.normallookup | ||
if node == parent and p2 == nullid: | ||||
normal = repo.dirstate.normal | ||||
|
r4915 | for f in undelete[0]: | ||
|
r6107 | checkout(f) | ||
|
r6108 | normal(f) | ||
|
r6107 | |||
|
r4915 | finally: | ||
|
r8109 | wlock.release() | ||
|
r588 | |||
|
r10882 | def rollback(ui, repo, **opts): | ||
|
r10889 | """roll back the last transaction (dangerous) | ||
|
r5575 | |||
This command should be used with care. There is only one level of | ||||
rollback, and there is no way to undo a rollback. It will also | ||||
restore the dirstate at the time of the last transaction, losing | ||||
|
r8856 | any dirstate changes since that time. This command does not alter | ||
the working directory. | ||||
|
r2227 | |||
Transactions are used to encapsulate the effects of all commands | ||||
that create new changesets or propagate existing changesets into a | ||||
repository. For example, the following commands are transactional, | ||||
|
r9893 | and their effects can be rolled back: | ||
- commit | ||||
- import | ||||
- pull | ||||
|
r10376 | - push (with this repository as the destination) | ||
|
r9893 | - unbundle | ||
|
r2227 | |||
This command is not intended for use on public repositories. Once | ||||
changes are visible for pull by other users, rolling a transaction | ||||
back locally is ineffective (someone else may already have pulled | ||||
the changes). Furthermore, a race is possible with readers of the | ||||
repository; for example an in-progress pull from the repository | ||||
may fail if a rollback is performed. | ||||
""" | ||||
|
r10882 | repo.rollback(opts.get('dry_run')) | ||
|
r2227 | |||
|
r468 | def root(ui, repo): | ||
|
r8026 | """print the root (top) of the current working directory | ||
|
r1437 | |||
Print the root directory of the current repository. | ||||
""" | ||||
|
r468 | ui.write(repo.root + "\n") | ||
|
r245 | def serve(ui, repo, **opts): | ||
|
r10889 | """start stand-alone webserver | ||
|
r1437 | |||
Start a local HTTP repository browser and pull server. | ||||
By default, the server logs accesses to stdout and errors to | ||||
|
r8277 | stderr. Use the -A/--accesslog and -E/--errorlog options to log to | ||
files. | ||||
|
r10629 | |||
To have the server choose a free port number to listen on, specify | ||||
a port number of 0; in this case, the server will print the port | ||||
number it uses. | ||||
|
r1437 | """ | ||
|
r624 | |||
if opts["stdio"]: | ||||
|
r2127 | if repo is None: | ||
|
r7637 | raise error.RepoError(_("There is no Mercurial repository here" | ||
|
r6217 | " (.hg not found)")) | ||
|
r2396 | s = sshserver.sshserver(ui, repo) | ||
s.serve_forever() | ||||
|
r2363 | |||
|
r10635 | # this way we can check if something was given in the command-line | ||
if opts.get('port'): | ||||
opts['port'] = int(opts.get('port')) | ||||
|
r8190 | baseui = repo and repo.baseui or ui | ||
|
r5835 | optlist = ("name templates style address port prefix ipv6" | ||
|
r10644 | " accesslog errorlog certificate encoding") | ||
|
r987 | for o in optlist.split(): | ||
|
r10630 | val = opts.get(o, '') | ||
|
r10631 | if val in (None, ''): # should check against default options instead | ||
|
r10630 | continue | ||
baseui.setconfig("web", o, val) | ||||
if repo and repo.ui != baseui: | ||||
repo.ui.setconfig("web", o, val) | ||||
|
r987 | |||
|
r11003 | o = opts.get('web_conf') or opts.get('webdir_conf') | ||
|
r11004 | if not o: | ||
if not repo: | ||||
raise error.RepoError(_("There is no Mercurial repository" | ||||
" here (.hg not found)")) | ||||
o = repo.root | ||||
app = hgweb.hgweb(o, baseui=ui) | ||||
|
r2127 | |||
|
r8778 | class service(object): | ||
|
r4380 | def init(self): | ||
|
r4672 | util.set_signal_handler() | ||
|
r11004 | self.httpd = hgweb.server.create_server(ui, app) | ||
|
r4380 | |||
|
r10629 | if opts['port'] and not ui.verbose: | ||
|
r10282 | return | ||
|
r4380 | |||
|
r5970 | if self.httpd.prefix: | ||
prefix = self.httpd.prefix.strip('/') + '/' | ||||
else: | ||||
prefix = '' | ||||
|
r6262 | port = ':%d' % self.httpd.port | ||
if port == ':80': | ||||
port = '' | ||||
|
r6419 | bindaddr = self.httpd.addr | ||
if bindaddr == '0.0.0.0': | ||||
bindaddr = '*' | ||||
elif ':' in bindaddr: # IPv6 | ||||
bindaddr = '[%s]' % bindaddr | ||||
fqaddr = self.httpd.fqaddr | ||||
if ':' in fqaddr: | ||||
fqaddr = '[%s]' % fqaddr | ||||
|
r10629 | if opts['port']: | ||
|
r10630 | write = ui.status | ||
|
r10629 | else: | ||
write = ui.write | ||||
write(_('listening at http://%s%s/%s (bound to %s:%d)\n') % | ||||
(fqaddr, port, prefix, bindaddr, self.httpd.port)) | ||||
|
r4380 | |||
def run(self): | ||||
self.httpd.serve_forever() | ||||
service = service() | ||||
cmdutil.service(opts, initfn=service.init, runfn=service.run) | ||||
|
r500 | |||
|
r731 | def status(ui, repo, *pats, **opts): | ||
|
r1437 | """show changed files in the working directory | ||
|
r213 | |||
|
r6448 | Show status of files in the repository. If names are given, only | ||
files that match are shown. Files that are clean or ignored or | ||||
|
r8779 | the source of a copy/move operation, are not listed unless | ||
-c/--clean, -i/--ignored, -C/--copies or -A/--all are given. | ||||
Unless options described with "show only ..." are given, the | ||||
options -mardu are used. | ||||
|
r1437 | |||
|
r6201 | Option -q/--quiet hides untracked (unknown and ignored) files | ||
|
r8009 | unless explicitly requested with -u/--unknown or -i/--ignored. | ||
|
r6200 | |||
|
r3822 | NOTE: status may appear to disagree with diff if permissions have | ||
changed or a merge has occurred. The standard diff format does not | ||||
report permission changes and diff only reports changes relative | ||||
to one merge parent. | ||||
|
r3467 | If one revision is given, it is used as the base revision. | ||
|
r8779 | If two revisions are given, the differences between them are | ||
|
r10014 | shown. The --change option can also be used as a shortcut to list | ||
the changed files of a revision from its first parent. | ||||
|
r3467 | |||
|
r9157 | The codes used to show the status of files are:: | ||
M = modified | ||||
A = added | ||||
R = removed | ||||
C = clean | ||||
! = missing (deleted by non-hg command, but still tracked) | ||||
? = not tracked | ||||
I = ignored | ||||
= origin of the previous file listed as A (added) | ||||
|
r1437 | """ | ||
|
r312 | |||
|
r10014 | revs = opts.get('rev') | ||
change = opts.get('change') | ||||
if revs and change: | ||||
msg = _('cannot specify --rev and --change at the same time') | ||||
raise util.Abort(msg) | ||||
elif change: | ||||
node2 = repo.lookup(change) | ||||
node1 = repo[node2].parents()[0].node() | ||||
else: | ||||
node1, node2 = cmdutil.revpair(repo, revs) | ||||
|
r1625 | cwd = (pats and repo.getcwd()) or '' | ||
|
r7131 | end = opts.get('print0') and '\0' or '\n' | ||
|
r6276 | copy = {} | ||
|
r6605 | states = 'modified added removed deleted unknown ignored clean'.split() | ||
|
r7684 | show = [k for k in states if opts.get(k)] | ||
|
r7131 | if opts.get('all'): | ||
|
r6605 | show += ui.quiet and (states[:4] + ['clean']) or states | ||
if not show: | ||||
show = ui.quiet and states[:4] or states[:5] | ||||
stat = repo.status(node1, node2, cmdutil.match(repo, pats, opts), | ||||
'ignored' in show, 'clean' in show, 'unknown' in show) | ||||
changestates = zip(states, 'MAR!?IC', stat) | ||||
|
r7131 | if (opts.get('all') or opts.get('copies')) and not opts.get('no_status'): | ||
|
r6747 | ctxn = repo[nullid] | ||
ctx1 = repo[node1] | ||||
ctx2 = repo[node2] | ||||
|
r6646 | added = stat[1] | ||
if node2 is None: | ||||
added = stat[0] + stat[1] # merged? | ||||
|
r6740 | |||
|
r7622 | for k, v in copies.copies(repo, ctx1, ctx2, ctxn)[0].iteritems(): | ||
|
r6646 | if k in added: | ||
copy[k] = v | ||||
elif v in added: | ||||
|
r6276 | copy[v] = k | ||
|
r6605 | for state, char, files in changestates: | ||
if state in show: | ||||
|
r1966 | format = "%s %%s%s" % (char, end) | ||
|
r7131 | if opts.get('no_status'): | ||
|
r6605 | format = "%%s%s" % end | ||
for f in files: | ||||
|
r10817 | ui.write(format % repo.pathto(f, cwd), | ||
label='status.' + state) | ||||
|
r6605 | if f in copy: | ||
|
r10817 | ui.write(' %s%s' % (repo.pathto(copy[f], cwd), end), | ||
label='status.copied') | ||||
|
r213 | |||
|
r9620 | def summary(ui, repo, **opts): | ||
|
r9603 | """summarize working directory state | ||
This generates a brief summary of the working directory state, | ||||
including parents, branch, commit status, and available updates. | ||||
|
r9620 | |||
With the --remote option, this will check the default paths for | ||||
incoming and outgoing changes. This can be time-consuming. | ||||
|
r9603 | """ | ||
ctx = repo[None] | ||||
parents = ctx.parents() | ||||
pnode = parents[0].node() | ||||
for p in parents: | ||||
|
r10832 | # label with log.changeset (instead of log.parent) since this | ||
# shows a working directory parent *changeset*: | ||||
ui.write(_('parent: %d:%s ') % (p.rev(), str(p)), | ||||
label='log.changeset') | ||||
|
r10833 | ui.write(' '.join(p.tags()), label='log.tag') | ||
|
r9618 | if p.rev() == -1: | ||
if not len(repo): | ||||
|
r10834 | ui.write(_(' (empty repository)')) | ||
|
r9618 | else: | ||
|
r10834 | ui.write(_(' (no revision checked out)')) | ||
|
r10832 | ui.write('\n') | ||
|
r9618 | if p.description(): | ||
|
r10832 | ui.status(' ' + p.description().splitlines()[0].strip() + '\n', | ||
label='log.summary') | ||||
|
r9603 | |||
branch = ctx.branch() | ||||
bheads = repo.branchheads(branch) | ||||
|
r9873 | m = _('branch: %s\n') % branch | ||
if branch != 'default': | ||||
|
r10832 | ui.write(m, label='log.branch') | ||
|
r9873 | else: | ||
|
r10832 | ui.status(m, label='log.branch') | ||
|
r9603 | |||
|
r10390 | st = list(repo.status(unknown=True))[:6] | ||
|
r10651 | ms = mergemod.mergestate(repo) | ||
|
r10390 | st.append([f for f in ms if ms[f] == 'u']) | ||
|
r10832 | labels = [ui.label(_('%d modified'), 'status.modified'), | ||
ui.label(_('%d added'), 'status.added'), | ||||
ui.label(_('%d removed'), 'status.removed'), | ||||
ui.label(_('%d deleted'), 'status.deleted'), | ||||
ui.label(_('%d unknown'), 'status.unknown'), | ||||
ui.label(_('%d ignored'), 'status.ignored'), | ||||
ui.label(_('%d unresolved'), 'resolve.unresolved')] | ||||
|
r9603 | t = [] | ||
|
r10282 | for s, l in zip(st, labels): | ||
|
r9607 | if s: | ||
t.append(l % len(s)) | ||||
|
r9603 | |||
t = ', '.join(t) | ||||
|
r10269 | cleanworkdir = False | ||
|
r9603 | |||
if len(parents) > 1: | ||||
t += _(' (merge)') | ||||
elif branch != parents[0].branch(): | ||||
t += _(' (new branch)') | ||||
elif (not st[0] and not st[1] and not st[2]): | ||||
t += _(' (clean)') | ||||
|
r10269 | cleanworkdir = True | ||
|
r9603 | elif pnode not in bheads: | ||
t += _(' (new branch head)') | ||||
|
r10269 | if cleanworkdir: | ||
|
r9605 | ui.status(_('commit: %s\n') % t.strip()) | ||
else: | ||||
ui.write(_('commit: %s\n') % t.strip()) | ||||
|
r9603 | |||
# all ancestors of branch heads - all ancestors of parent = new csets | ||||
new = [0] * len(repo) | ||||
cl = repo.changelog | ||||
|
r10390 | for a in [cl.rev(n) for n in bheads]: | ||
new[a] = 1 | ||||
|
r9603 | for a in cl.ancestors(*[cl.rev(n) for n in bheads]): | ||
new[a] = 1 | ||||
|
r10390 | for a in [p.rev() for p in parents]: | ||
if a >= 0: | ||||
new[a] = 0 | ||||
|
r9603 | for a in cl.ancestors(*[p.rev() for p in parents]): | ||
new[a] = 0 | ||||
new = sum(new) | ||||
if new == 0: | ||||
|
r9605 | ui.status(_('update: (current)\n')) | ||
|
r9603 | elif pnode not in bheads: | ||
ui.write(_('update: %d new changesets (update)\n') % new) | ||||
else: | ||||
ui.write(_('update: %d new changesets, %d branch heads (merge)\n') % | ||||
(new, len(bheads))) | ||||
|
r9620 | if opts.get('remote'): | ||
t = [] | ||||
|
r10389 | source, branches = hg.parseurl(ui.expandpath('default')) | ||
|
r9620 | other = hg.repository(cmdutil.remoteui(repo, {}), source) | ||
|
r10389 | revs, checkout = hg.addbranchrevs(repo, other, branches, opts.get('rev')) | ||
|
r9620 | ui.debug('comparing with %s\n' % url.hidepassword(source)) | ||
repo.ui.pushbuffer() | ||||
common, incoming, rheads = repo.findcommonincoming(other) | ||||
repo.ui.popbuffer() | ||||
if incoming: | ||||
t.append(_('1 or more incoming')) | ||||
|
r10389 | dest, branches = hg.parseurl(ui.expandpath('default-push', 'default')) | ||
revs, checkout = hg.addbranchrevs(repo, repo, branches, None) | ||||
|
r9620 | other = hg.repository(cmdutil.remoteui(repo, {}), dest) | ||
ui.debug('comparing with %s\n' % url.hidepassword(dest)) | ||||
repo.ui.pushbuffer() | ||||
o = repo.findoutgoing(other) | ||||
repo.ui.popbuffer() | ||||
|
r10390 | o = repo.changelog.nodesbetween(o, None)[0] | ||
|
r9620 | if o: | ||
t.append(_('%d outgoing') % len(o)) | ||||
if t: | ||||
ui.write(_('remote: %s\n') % (', '.join(t))) | ||||
else: | ||||
ui.status(_('remote: (synced)\n')) | ||||
|
r6321 | def tag(ui, repo, name1, *names, **opts): | ||
"""add one or more tags for the current or given revision | ||||
|
r1437 | |||
Name a particular revision using <name>. | ||||
Tags are used to name particular revisions of the repository and are | ||||
|
r6220 | very useful to compare different revisions, to go back to significant | ||
|
r1437 | earlier versions or to mark branch points as releases, etc. | ||
|
r8004 | If no revision is given, the parent of the working directory is | ||
used, or tip if no revision is checked out. | ||||
|
r1437 | |||
To facilitate version control, distribution, and merging of tags, | ||||
they are stored as a file named ".hgtags" which is managed | ||||
similarly to other project files and can be hand-edited if | ||||
|
r6448 | necessary. The file '.hg/localtags' is used for local tags (not | ||
|
r1654 | shared among repositories). | ||
|
r6163 | |||
|
r10973 | See :hg:`help dates` for a list of formats valid for -d/--date. | ||
|
r1437 | """ | ||
|
r6321 | |||
|
r6739 | rev_ = "." | ||
|
r6321 | names = (name1,) + names | ||
|
r8152 | if len(names) != len(set(names)): | ||
|
r6321 | raise util.Abort(_('tag names must be unique')) | ||
for n in names: | ||||
if n in ['tip', '.', 'null']: | ||||
raise util.Abort(_('the name \'%s\' is reserved') % n) | ||||
|
r7131 | if opts.get('rev') and opts.get('remove'): | ||
|
r4213 | raise util.Abort(_("--rev and --remove are incompatible")) | ||
|
r7131 | if opts.get('rev'): | ||
|
r1596 | rev_ = opts['rev'] | ||
|
r7131 | message = opts.get('message') | ||
if opts.get('remove'): | ||||
expectedtype = opts.get('local') and 'local' or 'global' | ||||
|
r6321 | for n in names: | ||
if not repo.tagtype(n): | ||||
raise util.Abort(_('tag \'%s\' does not exist') % n) | ||||
if repo.tagtype(n) != expectedtype: | ||||
|
r8008 | if expectedtype == 'global': | ||
raise util.Abort(_('tag \'%s\' is not a global tag') % n) | ||||
else: | ||||
raise util.Abort(_('tag \'%s\' is not a local tag') % n) | ||||
|
r4213 | rev_ = nullid | ||
if not message: | ||||
|
r9183 | # we don't translate commit messages | ||
message = 'Removed tag %s' % ', '.join(names) | ||||
|
r7131 | elif not opts.get('force'): | ||
|
r6321 | for n in names: | ||
if n in repo.tags(): | ||||
raise util.Abort(_('tag \'%s\' already exists ' | ||||
'(use -f to force)') % n) | ||||
|
r3132 | if not rev_ and repo.dirstate.parents()[1] != nullid: | ||
raise util.Abort(_('uncommitted merge - please provide a ' | ||||
'specific revision')) | ||||
|
r6747 | r = repo[rev_].node() | ||
|
r2967 | |||
if not message: | ||||
|
r9183 | # we don't translate commit messages | ||
message = ('Added tag %s for changeset %s' % | ||||
|
r6321 | (', '.join(names), short(r))) | ||
|
r2967 | |||
|
r6243 | date = opts.get('date') | ||
if date: | ||||
date = util.parsedate(date) | ||||
|
r7131 | repo.tag(names, r, message, opts.get('local'), opts.get('user'), date) | ||
|
r401 | |||
|
r248 | def tags(ui, repo): | ||
|
r1437 | """list repository tags | ||
|
r8004 | This lists both regular and local tags. When the -v/--verbose | ||
switch is used, a third column "local" is printed for local tags. | ||||
|
r1437 | """ | ||
|
r477 | |||
|
r2966 | hexfunc = ui.debugflag and hex or short | ||
|
r5658 | tagtype = "" | ||
|
r8210 | for t, n in reversed(repo.tagslist()): | ||
|
r5658 | if ui.quiet: | ||
ui.write("%s\n" % t) | ||||
continue | ||||
|
r248 | try: | ||
|
r4516 | hn = hexfunc(n) | ||
|
r5658 | r = "%5d:%s" % (repo.changelog.rev(n), hn) | ||
|
r7633 | except error.LookupError: | ||
|
r3930 | r = " ?:%s" % hn | ||
|
r2035 | else: | ||
|
r7948 | spaces = " " * (30 - encoding.colwidth(t)) | ||
|
r5658 | if ui.verbose: | ||
if repo.tagtype(t) == 'local': | ||||
tagtype = " local" | ||||
else: | ||||
tagtype = "" | ||||
ui.write("%s%s %s%s\n" % (t, spaces, r, tagtype)) | ||||
|
r248 | |||
|
r1731 | def tip(ui, repo, **opts): | ||
|
r1437 | """show the tip revision | ||
|
r8779 | The tip revision (usually just called the tip) is the changeset | ||
most recently added to the repository (and therefore the most | ||||
recently changed head). | ||||
|
r6364 | |||
|
r6367 | If you have just made a commit, that commit will be the tip. If | ||
you have just pulled changes from another repository, the tip of | ||||
that repository becomes the current tip. The "tip" tag is special | ||||
and cannot be renamed or assigned to a different changeset. | ||||
|
r1437 | """ | ||
|
r10152 | displayer = cmdutil.show_changeset(ui, repo, opts) | ||
displayer.show(repo[len(repo) - 1]) | ||||
displayer.close() | ||||
|
r245 | |||
|
r4699 | def unbundle(ui, repo, fname1, *fnames, **opts): | ||
"""apply one or more changegroup files | ||||
Apply one or more compressed changegroup files generated by the | ||||
bundle command. | ||||
|
r1437 | """ | ||
|
r4699 | fnames = (fname1,) + fnames | ||
|
r6180 | |||
|
r8109 | lock = repo.lock() | ||
|
r6180 | try: | ||
for fname in fnames: | ||||
|
r7271 | f = url.open(ui, fname) | ||
|
r6180 | gen = changegroup.readbundle(f, fname) | ||
modheads = repo.addchangegroup(gen, 'unbundle', 'bundle:' + fname) | ||||
finally: | ||||
|
r8109 | lock.release() | ||
|
r4699 | |||
|
r7131 | return postincoming(ui, repo, modheads, opts.get('update'), None) | ||
|
r1218 | |||
|
r8855 | def update(ui, repo, node=None, rev=None, clean=False, date=None, check=False): | ||
|
r10889 | """update working directory (or switch revisions) | ||
|
r1437 | |||
|
r8004 | Update the repository's working directory to the specified | ||
|
r9718 | changeset. | ||
If no changeset is specified, attempt to update to the head of the | ||||
current branch. If this head is a descendant of the working | ||||
directory's parent, update to it, otherwise abort. | ||||
The following rules apply when the working directory contains | ||||
uncommitted changes: | ||||
|
r9831 | 1. If neither -c/--check nor -C/--clean is specified, and if | ||
the requested changeset is an ancestor or descendant of | ||||
the working directory's parent, the uncommitted changes | ||||
are merged into the requested changeset and the merged | ||||
result is left uncommitted. If the requested changeset is | ||||
not an ancestor or descendant (that is, it is on another | ||||
branch), the update is aborted and the uncommitted changes | ||||
|
r9740 | are preserved. | ||
|
r9718 | |||
2. With the -c/--check option, the update is aborted and the | ||||
|
r9740 | uncommitted changes are preserved. | ||
|
r9718 | |||
3. With the -C/--clean option, uncommitted changes are discarded and | ||||
|
r9740 | the working directory is updated to the requested changeset. | ||
|
r9718 | |||
|
r10973 | Use null as the changeset to remove the working directory (like | ||
:hg:`clone -U`). | ||||
If you want to update just one file to an older changeset, use :hg:`revert`. | ||||
See :hg:`help dates` for a list of formats valid for -d/--date. | ||||
|
r1437 | """ | ||
|
r4450 | if rev and node: | ||
raise util.Abort(_("please specify just one revision")) | ||||
if not rev: | ||||
rev = node | ||||
|
r9450 | if check and clean: | ||
|
r9451 | raise util.Abort(_("cannot specify both -c/--check and -C/--clean")) | ||
|
r9450 | |||
if check: | ||||
|
r8855 | # we could use dirty() but we can ignore merge and branch trivia | ||
c = repo[None] | ||||
if c.modified() or c.added() or c.removed(): | ||||
raise util.Abort(_("uncommitted local changes")) | ||||
|
r3814 | if date: | ||
|
r4450 | if rev: | ||
|
r3814 | raise util.Abort(_("you can't specify a revision and a date")) | ||
|
r4450 | rev = cmdutil.finddate(ui, repo, date) | ||
|
r3814 | |||
|
r9187 | if clean or check: | ||
|
r4450 | return hg.clean(repo, rev) | ||
|
r2808 | else: | ||
|
r4450 | return hg.update(repo, rev) | ||
|
r254 | |||
|
r247 | def verify(ui, repo): | ||
|
r1437 | """verify the integrity of the repository | ||
Verify the integrity of the current repository. | ||||
This will perform an extensive check of the repository's | ||||
integrity, validating the hashes and checksums of each entry in | ||||
the changelog, manifest, and tracked files, as well as the | ||||
integrity of their crosslinks and indices. | ||||
""" | ||||
|
r2778 | return hg.verify(repo) | ||
|
r247 | |||
|
r3651 | def version_(ui): | ||
"""output version and copyright information""" | ||||
ui.write(_("Mercurial Distributed SCM (version %s)\n") | ||||
|
r7632 | % util.version()) | ||
|
r3651 | ui.status(_( | ||
|
r10206 | "\nCopyright (C) 2005-2010 Matt Mackall <mpm@selenic.com> and others\n" | ||
|
r3651 | "This is free software; see the source for copying conditions. " | ||
"There is NO\nwarranty; " | ||||
"not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n" | ||||
)) | ||||
|
r255 | # Command options and aliases are listed here, alphabetically | ||
|
r3187 | globalopts = [ | ||
('R', 'repository', '', | ||||
|
r9477 | _('repository root directory or name of overlay bundle file')), | ||
|
r3187 | ('', 'cwd', '', _('change working directory')), | ||
('y', 'noninteractive', None, | ||||
_('do not prompt, assume \'yes\' for any required answers')), | ||||
('q', 'quiet', None, _('suppress output')), | ||||
('v', 'verbose', None, _('enable additional output')), | ||||
|
r10541 | ('', 'config', [], | ||
_('set/override config option (use \'section.name=value\')')), | ||||
|
r3187 | ('', 'debug', None, _('enable debugging output')), | ||
('', 'debugger', None, _('start debugger')), | ||||
|
r7948 | ('', 'encoding', encoding.encoding, _('set the charset encoding')), | ||
('', 'encodingmode', encoding.encodingmode, | ||||
_('set the charset encoding mode')), | ||||
|
r9698 | ('', 'traceback', None, _('always print a traceback on exception')), | ||
|
r3187 | ('', 'time', None, _('time how long the command takes')), | ||
('', 'profile', None, _('print command execution profile')), | ||||
('', 'version', None, _('output version information and exit')), | ||||
('h', 'help', None, _('display help and exit')), | ||||
] | ||||
|
r3189 | dryrunopts = [('n', 'dry-run', None, | ||
_('do not perform actions, just print output'))] | ||||
|
r3190 | remoteopts = [ | ||
('e', 'ssh', '', _('specify ssh command to use')), | ||||
('', 'remotecmd', '', _('specify hg command to run on the remote side')), | ||||
] | ||||
|
r3188 | walkopts = [ | ||
('I', 'include', [], _('include names matching the given patterns')), | ||||
('X', 'exclude', [], _('exclude names matching the given patterns')), | ||||
] | ||||
|
r3857 | commitopts = [ | ||
('m', 'message', '', _('use <text> as commit message')), | ||||
('l', 'logfile', '', _('read commit message from <file>')), | ||||
] | ||||
|
r5147 | commitopts2 = [ | ||
('d', 'date', '', _('record datecode as commit date')), | ||||
|
r8313 | ('u', 'user', '', _('record the specified user as committer')), | ||
|
r5147 | ] | ||
|
r6192 | templateopts = [ | ||
('', 'style', '', _('display using template map file')), | ||||
('', 'template', '', _('display with template')), | ||||
] | ||||
logopts = [ | ||||
('p', 'patch', None, _('show patch')), | ||||
|
r7763 | ('g', 'git', None, _('use git extended diff format')), | ||
|
r6192 | ('l', 'limit', '', _('limit number of changes displayed')), | ||
('M', 'no-merges', None, _('do not show merges')), | ||||
] + templateopts | ||||
|
r6668 | diffopts = [ | ||
('a', 'text', None, _('treat all files as text')), | ||||
('g', 'git', None, _('use git extended diff format')), | ||||
|
r10375 | ('', 'nodates', None, _('omit dates from diff headers')) | ||
|
r6668 | ] | ||
diffopts2 = [ | ||||
('p', 'show-function', None, _('show which function each change is in')), | ||||
|
r9857 | ('', 'reverse', None, _('produce a diff that undoes the changes')), | ||
|
r6668 | ('w', 'ignore-all-space', None, | ||
_('ignore white space when comparing lines')), | ||||
('b', 'ignore-space-change', None, | ||||
_('ignore changes in the amount of white space')), | ||||
('B', 'ignore-blank-lines', None, | ||||
_('ignore changes whose lines are all blank')), | ||||
|
r9640 | ('U', 'unified', '', _('number of lines of context to show')), | ||
('', 'stat', None, _('output diffstat-style summary of changes')), | ||||
|
r6668 | ] | ||
|
r7402 | similarityopts = [ | ||
('s', 'similarity', '', | ||||
_('guess renamed files by similarity (0<=s<=100)')) | ||||
] | ||||
|
r209 | table = { | ||
|
r7364 | "^add": (add, walkopts + dryrunopts, _('[OPTION]... [FILE]...')), | ||
|
r2955 | "addremove": | ||
|
r7402 | (addremove, similarityopts + walkopts + dryrunopts, | ||
|
r7364 | _('[OPTION]... [FILE]...')), | ||
|
r6182 | "^annotate|blame": | ||
|
r697 | (annotate, | ||
|
r1437 | [('r', 'rev', '', _('annotate the specified revision')), | ||
|
r10579 | ('', 'follow', None, | ||
_('follow copies/renames and list the filename (DEPRECATED)')), | ||||
|
r10369 | ('', 'no-follow', None, _("don't follow copies and renames")), | ||
|
r1402 | ('a', 'text', None, _('treat all files as text')), | ||
|
r6134 | ('u', 'user', None, _('list the author (long with -v)')), | ||
|
r10369 | ('f', 'file', None, _('list the filename')), | ||
|
r6134 | ('d', 'date', None, _('list the date (short with -q)')), | ||
|
r1437 | ('n', 'number', None, _('list the revision number (default)')), | ||
('c', 'changeset', None, _('list the changeset')), | ||||
|
r4857 | ('l', 'line-number', None, | ||
_('show line number at the first appearance')) | ||||
|
r3188 | ] + walkopts, | ||
|
r7364 | _('[-r REV] [-f] [-a] [-u] [-d] [-n] [-c] [-l] FILE...')), | ||
|
r2160 | "archive": | ||
|
r2112 | (archive, | ||
[('', 'no-decode', None, _('do not pass files through decoders')), | ||||
('p', 'prefix', '', _('directory prefix for files in archive')), | ||||
('r', 'rev', '', _('revision to distribute')), | ||||
('t', 'type', '', _('type of distribution to create')), | ||||
|
r3188 | ] + walkopts, | ||
|
r7364 | _('[OPTION]... DEST')), | ||
|
r2159 | "backout": | ||
|
r2158 | (backout, | ||
|
r2159 | [('', 'merge', None, | ||
_('merge with old dirstate parent after backout')), | ||||
|
r2614 | ('', 'parent', '', _('parent to choose when backing out merge')), | ||
|
r4450 | ('r', 'rev', '', _('revision to backout')), | ||
|
r5147 | ] + walkopts + commitopts + commitopts2, | ||
|
r7364 | _('[OPTION]... [-r] REV')), | ||
|
r5778 | "bisect": | ||
(bisect, | ||||
[('r', 'reset', False, _('reset bisect state')), | ||||
('g', 'good', False, _('mark changeset good')), | ||||
('b', 'bad', False, _('mark changeset bad')), | ||||
('s', 'skip', False, _('skip testing changeset')), | ||||
|
r7598 | ('c', 'command', '', _('use command to check changeset state')), | ||
|
r5778 | ('U', 'noupdate', False, _('do not update to target'))], | ||
|
r9952 | _("[-gbsr] [-U] [-c CMD] [REV]")), | ||
|
r4730 | "branch": | ||
(branch, | ||||
[('f', 'force', None, | ||||
|
r7006 | _('set branch name even if it shadows an existing branch')), | ||
('C', 'clean', None, _('reset branch name to parent branch name'))], | ||||
|
r7364 | _('[-fC] [NAME]')), | ||
|
r4730 | "branches": | ||
(branches, | ||||
[('a', 'active', False, | ||||
|
r8991 | _('show only branches that have unmerged heads')), | ||
('c', 'closed', False, | ||||
|
r9189 | _('show normal and closed branches'))], | ||
|
r9952 | _('[-ac]')), | ||
|
r1218 | "bundle": | ||
(bundle, | ||||
|
r1959 | [('f', 'force', None, | ||
|
r10375 | _('run even when the destination is unrelated')), | ||
|
r3284 | ('r', 'rev', [], | ||
|
r10375 | _('a changeset intended to be added to the destination')), | ||
|
r10379 | ('b', 'branch', [], | ||
_('a specific branch you would like to bundle')), | ||||
|
r3284 | ('', 'base', [], | ||
|
r10375 | _('a base changeset assumed to be available at the destination')), | ||
|
r6570 | ('a', 'all', None, _('bundle all changesets in the repository')), | ||
('t', 'type', 'bzip2', _('bundle compression type to use')), | ||||
|
r3191 | ] + remoteopts, | ||
|
r9952 | _('[-f] [-t TYPE] [-a] [-r REV]... [--base REV]... FILE [DEST]')), | ||
|
r697 | "cat": | ||
(cat, | ||||
|
r1816 | [('o', 'output', '', _('print output to file with formatted name')), | ||
('r', 'rev', '', _('print the given revision')), | ||||
|
r6094 | ('', 'decode', None, _('apply any matching decode filter')), | ||
|
r3188 | ] + walkopts, | ||
|
r7364 | _('[OPTION]... FILE...')), | ||
|
r697 | "^clone": | ||
(clone, | ||||
|
r6625 | [('U', 'noupdate', None, | ||
|
r10375 | _('the clone will include an empty working copy (only a repository)')), | ||
|
r9714 | ('u', 'updaterev', '', | ||
_('revision, tag or branch to check out')), | ||||
|
r1602 | ('r', 'rev', [], | ||
|
r10375 | _('include the specified changeset')), | ||
|
r10379 | ('b', 'branch', [], | ||
_('clone only the specified branch')), | ||||
|
r1816 | ('', 'pull', None, _('use pull protocol to copy metadata')), | ||
|
r2620 | ('', 'uncompressed', None, | ||
_('use uncompressed transfer (fast over LAN)')), | ||||
|
r3190 | ] + remoteopts, | ||
|
r7364 | _('[OPTION]... SOURCE [DEST]')), | ||
|
r697 | "^commit|ci": | ||
(commit, | ||||
|
r2184 | [('A', 'addremove', None, | ||
_('mark new/missing files as added/removed before committing')), | ||||
|
r7655 | ('', 'close-branch', None, | ||
_('mark a branch as closed, hiding it from the branch list')), | ||||
|
r5147 | ] + walkopts + commitopts + commitopts2, | ||
|
r7364 | _('[OPTION]... [FILE]...')), | ||
|
r1615 | "copy|cp": | ||
(copy, | ||||
|
r1816 | [('A', 'after', None, _('record a copy that has already occurred')), | ||
|
r1615 | ('f', 'force', None, | ||
|
r1816 | _('forcibly copy over an existing managed file')), | ||
|
r3189 | ] + walkopts + dryrunopts, | ||
|
r7364 | _('[OPTION]... [SOURCE]... DEST')), | ||
"debugancestor": (debugancestor, [], _('[INDEX] REV1 REV2')), | ||||
|
r9604 | "debugcheckstate": (debugcheckstate, [], ''), | ||
|
r7880 | "debugcommands": (debugcommands, [], _('[COMMAND]')), | ||
|
r2034 | "debugcomplete": | ||
(debugcomplete, | ||||
[('o', 'options', None, _('show the command options'))], | ||||
|
r7364 | _('[-o] CMD')), | ||
|
r5781 | "debugdate": | ||
(debugdate, | ||||
[('e', 'extended', None, _('try extended date formats'))], | ||||
|
r7364 | _('[-e] DATE [RANGE]')), | ||
"debugdata": (debugdata, [], _('FILE REV')), | ||||
"debugfsinfo": (debugfsinfo, [], _('[PATH]')), | ||||
"debugindex": (debugindex, [], _('FILE')), | ||||
"debugindexdot": (debugindexdot, [], _('FILE')), | ||||
|
r9604 | "debuginstall": (debuginstall, [], ''), | ||
|
r1755 | "debugrebuildstate": | ||
(debugrebuildstate, | ||||
|
r1816 | [('r', 'rev', '', _('revision to rebuild to'))], | ||
|
r7364 | _('[-r REV] [REV]')), | ||
|
r4730 | "debugrename": | ||
(debugrename, | ||||
[('r', 'rev', '', _('revision to debug'))], | ||||
|
r7364 | _('[-r REV] FILE')), | ||
|
r5781 | "debugsetparents": | ||
|
r7364 | (debugsetparents, [], _('REV1 [REV2]')), | ||
|
r6296 | "debugstate": | ||
(debugstate, | ||||
[('', 'nodates', None, _('do not display the saved mtime'))], | ||||
|
r7364 | _('[OPTION]...')), | ||
|
r8812 | "debugsub": | ||
(debugsub, | ||||
[('r', 'rev', '', _('revision to check'))], | ||||
_('[-r REV] [REV]')), | ||||
|
r7364 | "debugwalk": (debugwalk, walkopts, _('[OPTION]... [FILE]...')), | ||
|
r697 | "^diff": | ||
(diff, | ||||
|
r7628 | [('r', 'rev', [], _('revision')), | ||
('c', 'change', '', _('change made by revision')) | ||||
|
r6668 | ] + diffopts + diffopts2 + walkopts, | ||
|
r10520 | _('[OPTION]... ([-c REV] | [-r REV1 [-r REV2]]) [FILE]...')), | ||
|
r697 | "^export": | ||
(export, | ||||
|
r1615 | [('o', 'output', '', _('print output to file with formatted name')), | ||
|
r10015 | ('', 'switch-parent', None, _('diff against the second parent')), | ||
('r', 'rev', [], _('revisions to export')), | ||||
|
r6668 | ] + diffopts, | ||
|
r7364 | _('[OPTION]... [-o OUTFILESPEC] REV...')), | ||
|
r8902 | "^forget": | ||
(forget, | ||||
[] + walkopts, | ||||
_('[OPTION]... FILE...')), | ||||
|
r1065 | "grep": | ||
(grep, | ||||
|
r1402 | [('0', 'print0', None, _('end fields with NUL')), | ||
|
r1437 | ('', 'all', None, _('print all revisions that match')), | ||
|
r2870 | ('f', 'follow', None, | ||
|
r10282 | _('follow changeset history,' | ||
' or file history across copies and renames')), | ||||
|
r1402 | ('i', 'ignore-case', None, _('ignore case when matching')), | ||
|
r1602 | ('l', 'files-with-matches', None, | ||
|
r8028 | _('print only filenames and revisions that match')), | ||
|
r1437 | ('n', 'line-number', None, _('print matching line numbers')), | ||
('r', 'rev', [], _('search in given revision range')), | ||||
|
r6134 | ('u', 'user', None, _('list the author (long with -v)')), | ||
('d', 'date', None, _('list the date (short with -q)')), | ||||
|
r3188 | ] + walkopts, | ||
|
r7364 | _('[OPTION]... PATTERN [FILE]...')), | ||
|
r905 | "heads": | ||
(heads, | ||||
|
r8031 | [('r', 'rev', '', _('show only heads which are descendants of REV')), | ||
|
r10350 | ('t', 'topo', False, _('show topological heads only')), | ||
|
r7656 | ('a', 'active', False, | ||
|
r10326 | _('show active branchheads only [DEPRECATED]')), | ||
|
r8695 | ('c', 'closed', False, | ||
|
r9189 | _('show normal and closed branch heads')), | ||
|
r6192 | ] + templateopts, | ||
|
r9952 | _('[-ac] [-r STARTREV] [REV]...')), | ||
|
r7364 | "help": (help_, [], _('[TOPIC]')), | ||
|
r4665 | "identify|id": | ||
(identify, | ||||
|
r8028 | [('r', 'rev', '', _('identify the specified revision')), | ||
|
r4666 | ('n', 'num', None, _('show local revision number')), | ||
('i', 'id', None, _('show global revision id')), | ||||
('b', 'branch', None, _('show branch')), | ||||
('t', 'tags', None, _('show tags'))], | ||||
|
r7364 | _('[-nibt] [-r REV] [SOURCE]')), | ||
|
r697 | "import|patch": | ||
(import_, | ||||
|
r1602 | [('p', 'strip', 1, | ||
|
r8038 | _('directory strip option for patch. This has the same ' | ||
|
r2125 | 'meaning as the corresponding patch option')), | ||
|
r3876 | ('b', 'base', '', _('base path')), | ||
|
r1602 | ('f', 'force', None, | ||
|
r4263 | _('skip check for outstanding uncommitted changes')), | ||
|
r10282 | ('', 'no-commit', None, | ||
_("don't commit, just update the working directory")), | ||||
|
r4263 | ('', 'exact', None, | ||
|
r4592 | _('apply patch to the nodes from which it was generated')), | ||
('', 'import-branch', None, | ||||
|
r8034 | _('use any branch information in patch (implied by --exact)'))] + | ||
|
r7402 | commitopts + commitopts2 + similarityopts, | ||
|
r7364 | _('[OPTION]... PATCH...')), | ||
|
r5778 | "incoming|in": | ||
(incoming, | ||||
|
r6192 | [('f', 'force', None, | ||
|
r10375 | _('run even if remote repository is unrelated')), | ||
|
r1907 | ('n', 'newest-first', None, _('show newest record first')), | ||
|
r1944 | ('', 'bundle', '', _('file to store the bundles into')), | ||
|
r6304 | ('r', 'rev', [], | ||
|
r10375 | _('a remote changeset intended to be added')), | ||
|
r10379 | ('b', 'branch', [], | ||
_('a specific branch you would like to pull')), | ||||
|
r6192 | ] + logopts + remoteopts, | ||
|
r7364 | _('[-p] [-n] [-M] [-f] [-r REV]...' | ||
|
r2544 | ' [--bundle FILENAME] [SOURCE]')), | ||
|
r2598 | "^init": | ||
|
r3885 | (init, | ||
remoteopts, | ||||
|
r7364 | _('[-e CMD] [--remotecmd CMD] [DEST]')), | ||
|
r697 | "locate": | ||
(locate, | ||||
|
r10375 | [('r', 'rev', '', _('search the repository as it is in REV')), | ||
|
r1602 | ('0', 'print0', None, | ||
_('end filenames with NUL, for use with xargs')), | ||||
('f', 'fullpath', None, | ||||
_('print complete paths from the filesystem root')), | ||||
|
r3188 | ] + walkopts, | ||
|
r7364 | _('[OPTION]... [PATTERN]...')), | ||
|
r697 | "^log|history": | ||
(log, | ||||
|
r3876 | [('f', 'follow', None, | ||
|
r10282 | _('follow changeset history,' | ||
' or file history across copies and renames')), | ||||
|
r2784 | ('', 'follow-first', None, | ||
_('only follow the first parent of merge changesets')), | ||||
|
r8028 | ('d', 'date', '', _('show revisions matching date spec')), | ||
|
r3197 | ('C', 'copies', None, _('show copied files')), | ||
|
r4324 | ('k', 'keyword', [], _('do case-insensitive search for a keyword')), | ||
|
r1437 | ('r', 'rev', [], _('show the specified revision or range')), | ||
|
r8028 | ('', 'removed', None, _('include revisions where files were removed')), | ||
|
r1615 | ('m', 'only-merges', None, _('show only merges')), | ||
|
r8028 | ('u', 'user', [], _('revisions committed by user')), | ||
|
r10957 | ('', 'only-branch', [], | ||
_('show only changesets within the given named branch (DEPRECATED)')), | ||||
('b', 'branch', [], | ||||
_('show changesets within the given named branch')), | ||||
|
r10282 | ('P', 'prune', [], | ||
_('do not display revision or any of its ancestors')), | ||||
|
r6192 | ] + logopts + walkopts, | ||
|
r7364 | _('[OPTION]... [FILE]')), | ||
|
r5778 | "manifest": | ||
(manifest, | ||||
[('r', 'rev', '', _('revision to display'))], | ||||
|
r7364 | _('[-r REV]')), | ||
|
r4014 | "^merge": | ||
|
r2044 | (merge, | ||
|
r4450 | [('f', 'force', None, _('force a merge with outstanding changes')), | ||
('r', 'rev', '', _('revision to merge')), | ||||
|
r8834 | ('P', 'preview', None, | ||
|
r8387 | _('review revisions to merge (no merge is performed)'))], | ||
|
r9952 | _('[-P] [-f] [[-r] REV]')), | ||
|
r5778 | "outgoing|out": | ||
(outgoing, | ||||
|
r6192 | [('f', 'force', None, | ||
|
r10375 | _('run even when the destination is unrelated')), | ||
|
r6304 | ('r', 'rev', [], | ||
|
r10375 | _('a changeset intended to be included in the destination')), | ||
|
r1907 | ('n', 'newest-first', None, _('show newest record first')), | ||
|
r10379 | ('b', 'branch', [], | ||
_('a specific branch you would like to push')), | ||||
|
r6192 | ] + logopts + remoteopts, | ||
|
r7364 | _('[-M] [-p] [-n] [-f] [-r REV]... [DEST]')), | ||
|
r9606 | "parents": | ||
|
r1724 | (parents, | ||
|
r10375 | [('r', 'rev', '', _('show parents of the specified revision')), | ||
|
r6192 | ] + templateopts, | ||
|
r8544 | _('[-r REV] [FILE]')), | ||
|
r7364 | "paths": (paths, [], _('[NAME]')), | ||
|
r697 | "^pull": | ||
(pull, | ||||
|
r1602 | [('u', 'update', None, | ||
|
r10210 | _('update to new branch head if changesets were pulled')), | ||
|
r1959 | ('f', 'force', None, | ||
_('run even when remote repository is unrelated')), | ||||
|
r3885 | ('r', 'rev', [], | ||
|
r10375 | _('a remote changeset intended to be added')), | ||
|
r10379 | ('b', 'branch', [], | ||
_('a specific branch you would like to pull')), | ||||
|
r3190 | ] + remoteopts, | ||
|
r7364 | _('[-u] [-f] [-r REV]... [-e CMD] [--remotecmd CMD] [SOURCE]')), | ||
|
r818 | "^push": | ||
(push, | ||||
|
r1402 | [('f', 'force', None, _('force push')), | ||
|
r6304 | ('r', 'rev', [], | ||
|
r10375 | _('a changeset intended to be included in the destination')), | ||
|
r10379 | ('b', 'branch', [], | ||
_('a specific branch you would like to push')), | ||||
|
r3190 | ] + remoteopts, | ||
|
r7364 | _('[-f] [-r REV]... [-e CMD] [--remotecmd CMD] [DEST]')), | ||
"recover": (recover, []), | ||||
|
r1615 | "^remove|rm": | ||
(remove, | ||||
|
r6346 | [('A', 'after', None, _('record delete for missing files')), | ||
('f', 'force', None, | ||||
|
r6347 | _('remove (and delete) file even if added or modified')), | ||
|
r3188 | ] + walkopts, | ||
|
r7364 | _('[OPTION]... FILE...')), | ||
|
r1615 | "rename|mv": | ||
(rename, | ||||
|
r1816 | [('A', 'after', None, _('record a rename that has already occurred')), | ||
|
r1615 | ('f', 'force', None, | ||
|
r1816 | _('forcibly copy over an existing managed file')), | ||
|
r3189 | ] + walkopts + dryrunopts, | ||
|
r7364 | _('[OPTION]... SOURCE... DEST')), | ||
|
r6518 | "resolve": | ||
(resolve, | ||||
|
r9747 | [('a', 'all', None, _('select all unresolved files')), | ||
|
r7527 | ('l', 'list', None, _('list state of files needing merge')), | ||
|
r6518 | ('m', 'mark', None, _('mark files as resolved')), | ||
|
r9646 | ('u', 'unmark', None, _('unmark files as resolved')), | ||
('n', 'no-status', None, _('hide status prefix'))] | ||||
|
r7765 | + walkopts, | ||
|
r7364 | _('[OPTION]... [FILE]...')), | ||
|
r5574 | "revert": | ||
|
r697 | (revert, | ||
|
r2983 | [('a', 'all', None, _('revert all changes when no arguments given')), | ||
|
r3814 | ('d', 'date', '', _('tipmost revision matching date')), | ||
|
r10375 | ('r', 'rev', '', _('revert to the specified revision')), | ||
|
r2029 | ('', 'no-backup', None, _('do not save backup copies of files')), | ||
|
r3189 | ] + walkopts + dryrunopts, | ||
|
r7364 | _('[OPTION]... [-r REV] [NAME]...')), | ||
|
r10882 | "rollback": (rollback, dryrunopts), | ||
|
r7364 | "root": (root, []), | ||
|
r697 | "^serve": | ||
(serve, | ||||
|
r1437 | [('A', 'accesslog', '', _('name of access log file to write to')), | ||
|
r1740 | ('d', 'daemon', None, _('run server in background')), | ||
|
r1742 | ('', 'daemon-pipefds', '', _('used internally by daemon mode')), | ||
|
r1437 | ('E', 'errorlog', '', _('name of error log file to write to')), | ||
|
r10635 | # use string type, then we can check if something was passed | ||
|
r10830 | ('p', 'port', '', _('port to listen on (default: 8000)')), | ||
|
r10282 | ('a', 'address', '', | ||
_('address to listen on (default: all interfaces)')), | ||||
('', 'prefix', '', | ||||
_('prefix path to serve from (default: server root)')), | ||||
|
r1615 | ('n', 'name', '', | ||
|
r8026 | _('name to show in web pages (default: working directory)')), | ||
|
r11003 | ('', 'web-conf', '', _('name of the hgweb config file' | ||
|
r8027 | ' (serve more than one repository)')), | ||
|
r11003 | ('', 'webdir-conf', '', _('name of the hgweb config file' | ||
' (DEPRECATED)')), | ||||
|
r1740 | ('', 'pid-file', '', _('name of file to write process ID to')), | ||
|
r1402 | ('', 'stdio', None, _('for remote clients')), | ||
|
r1615 | ('t', 'templates', '', _('web templates to use')), | ||
('', 'style', '', _('template style to use')), | ||||
|
r4860 | ('6', 'ipv6', None, _('use IPv6 in addition to IPv4')), | ||
('', 'certificate', '', _('SSL certificate file'))], | ||||
|
r7364 | _('[OPTION]...')), | ||
|
r5781 | "showconfig|debugconfig": | ||
(showconfig, | ||||
[('u', 'untrusted', None, _('show untrusted configuration options'))], | ||||
|
r7364 | _('[-u] [NAME]...')), | ||
|
r9603 | "^summary|sum": | ||
|
r9620 | (summary, | ||
|
r9625 | [('', 'remote', None, _('check for push and pull'))], '[--remote]'), | ||
|
r1507 | "^status|st": | ||
|
r840 | (status, | ||
|
r2661 | [('A', 'all', None, _('show status of all files')), | ||
('m', 'modified', None, _('show only modified files')), | ||||
|
r1402 | ('a', 'added', None, _('show only added files')), | ||
('r', 'removed', None, _('show only removed files')), | ||||
|
r1619 | ('d', 'deleted', None, _('show only deleted (but tracked) files')), | ||
|
r2661 | ('c', 'clean', None, _('show only files without changes')), | ||
|
r1402 | ('u', 'unknown', None, _('show only unknown (not tracked) files')), | ||
|
r4156 | ('i', 'ignored', None, _('show only ignored files')), | ||
|
r1402 | ('n', 'no-status', None, _('hide status prefix')), | ||
|
r2639 | ('C', 'copies', None, _('show source of copied files')), | ||
|
r1602 | ('0', 'print0', None, | ||
_('end filenames with NUL, for use with xargs')), | ||||
|
r3467 | ('', 'rev', [], _('show difference from revision')), | ||
|
r10014 | ('', 'change', '', _('list the changed files of a revision')), | ||
|
r3188 | ] + walkopts, | ||
|
r7364 | _('[OPTION]... [FILE]...')), | ||
|
r697 | "tag": | ||
(tag, | ||||
|
r4267 | [('f', 'force', None, _('replace existing tag')), | ||
('l', 'local', None, _('make the tag local')), | ||||
|
r4213 | ('r', 'rev', '', _('revision to tag')), | ||
|
r5147 | ('', 'remove', None, _('remove a tag')), | ||
# -l/--local is already there, commitopts cannot be used | ||||
('m', 'message', '', _('use <text> as commit message')), | ||||
] + commitopts2, | ||||
|
r9952 | _('[-f] [-l] [-m TEXT] [-d DATE] [-u USER] [-r REV] NAME...')), | ||
|
r9604 | "tags": (tags, [], ''), | ||
|
r1762 | "tip": | ||
(tip, | ||||
|
r6192 | [('p', 'patch', None, _('show patch')), | ||
|
r7763 | ('g', 'git', None, _('use git extended diff format')), | ||
|
r6192 | ] + templateopts, | ||
|
r9952 | _('[-p] [-g]')), | ||
|
r1218 | "unbundle": | ||
(unbundle, | ||||
|
r1601 | [('u', 'update', None, | ||
|
r10210 | _('update to new branch head if changesets were unbundled'))], | ||
|
r7364 | _('[-u] FILE...')), | ||
|
r593 | "^update|up|checkout|co": | ||
|
r697 | (update, | ||
|
r9718 | [('C', 'clean', None, _('discard uncommitted changes (no backup)')), | ||
|
r8855 | ('c', 'check', None, _('check for uncommitted changes')), | ||
|
r4450 | ('d', 'date', '', _('tipmost revision matching date')), | ||
('r', 'rev', '', _('revision'))], | ||||
|
r9718 | _('[-c] [-C] [-d DATE] [[-r] REV]')), | ||
|
r7364 | "verify": (verify, []), | ||
"version": (version_, []), | ||||
|
r1046 | } | ||
|
r209 | |||
|
r7880 | norepo = ("clone init version help debugcommands debugcomplete debugdata" | ||
|
r5741 | " debugindex debugindexdot debugdate debuginstall debugfsinfo") | ||
|
r6189 | optionalrepo = ("identify paths serve showconfig debugancestor") | ||