mercurial-crew-with-dirclash: comparison mercurial/commands.py

equal deleted inserted replaced

-:51eb248d3348
+:574869103985
 # Copyright 2005 Matt Mackall <mpm@selenic.com>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
-from demandload import *
+from demandload import demandload
-demandload(globals(), "os re sys signal")
+demandload(globals(), "os re sys signal shutil")
 demandload(globals(), "fancyopts ui hg util")
 demandload(globals(), "fnmatch hgweb mdiff random signal time traceback")
 demandload(globals(), "errno socket version struct")
-class UnknownCommand(Exception): pass
+class UnknownCommand(Exception):
+"""Exception raised if command is not in the command table."""
 def filterfiles(filters, files):
-l = [ x for x in files if x in filters ]
+l = [x for x in files if x in filters]
 for t in filters:
-if t and t[-1] != "/": t += "/"
+if t and t[-1] != "/":
-l += [ x for x in files if x.startswith(t) ]
+t += "/"
+l += [x for x in files if x.startswith(t)]
 return l
 def relfilter(repo, files):
 cwd = repo.getcwd()
 if cwd:
 return files
 def relpath(repo, args):
 cwd = repo.getcwd()
 if cwd:
-return [ util.pconvert(os.path.normpath(os.path.join(cwd, x))) for x in args ]
+return [util.pconvert(os.path.normpath(os.path.join(cwd, x)))
+for x in args]
 return args
 revrangesep = ':'
-def revrange(ui, repo, revs = [], revlog = None):
+def revrange(ui, repo, revs, revlog=None):
 if revlog is None:
 revlog = repo.changelog
 revcount = revlog.count()
 def fix(val, defval):
-if not val: return defval
+if not val:
+return defval
 try:
 num = int(val)
-if str(num) != val: raise ValueError
+if str(num) != val:
-if num < 0: num += revcount
+raise ValueError
+if num < 0:
+num += revcount
 if not (0 <= num < revcount):
 raise ValueError
 except ValueError:
 try:
 num = repo.changelog.rev(repo.lookup(val))
 expander = {
 '%': lambda: '%',
 'b': lambda: os.path.basename(repo.root),
 }
-if node: expander.update(node_expander)
+if node:
+expander.update(node_expander)
 if node and revwidth is not None:
 expander['r'] = lambda: str(r.rev(node)).zfill(revwidth)
-if total is not None: expander['N'] = lambda: str(total)
+if total is not None:
-if seqno is not None: expander['n'] = lambda: str(seqno)
+expander['N'] = lambda: str(total)
+if seqno is not None:
+expander['n'] = lambda: str(seqno)
 if total is not None and seqno is not None:
 expander['n'] = lambda:str(seqno).zfill(len(str(total)))
 newname = []
 patlen = len(pat)
 c = expander[c]()
 newname.append(c)
 i += 1
 return ''.join(newname)
-def dodiff(fp, ui, repo, files = None, node1 = None, node2 = None):
+def dodiff(fp, ui, repo, files=None, node1=None, node2=None):
 def date(c):
 return time.asctime(time.gmtime(float(c[2].split(' ')[0])))
 (c, a, d, u) = repo.changes(node1, node2, files)
 if files:
 return
 if node2:
 change = repo.changelog.read(node2)
 mmap2 = repo.manifest.read(change[0])
-def read(f): return repo.file(f).read(mmap2[f])
 date2 = date(change)
+def read(f):
+return repo.file(f).read(mmap2[f])
 else:
 date2 = time.asctime()
 if not node1:
 node1 = repo.dirstate.parents()[0]
-def read(f): return repo.wfile(f).read()
+def read(f):
+return repo.wfile(f).read()
 if ui.quiet:
 r = None
 else:
 hexfunc = ui.verbose and hg.hex or hg.short
 "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"
 )
-def help(ui, cmd=None):
+def help_(ui, cmd=None):
-'''show help for a given command or all commands'''
+"""show help for a given command or all commands"""
 if cmd:
 try:
 i = find(cmd)
 ui.write("%s\n\n" % i[2])
 if i[1]:
 for s, l, d, c in i[1]:
-opt=' '
+opt = ' '
-if s: opt = opt + '-' + s + ' '
+if s:
-if l: opt = opt + '--' + l + ' '
+opt = opt + '-' + s + ' '
-if d: opt = opt + '(' + str(d) + ')'
+if l:
+opt = opt + '--' + l + ' '
+if d:
+opt = opt + '(' + str(d) + ')'
 ui.write(opt, "\n")
-if c: ui.write('   %s\n' % c)
+if c:
+ui.write('   %s\n' % c)
 ui.write("\n")
 ui.write(i[0].__doc__, "\n")
 except UnknownCommand:
 ui.warn("hg: unknown command %s\n" % cmd)
 for f in fns:
 ui.write(' %-*s   %s\n' % (m, f, h[f]))
 # Commands start here, listed alphabetically
-def add(ui, repo, file, *files):
+def add(ui, repo, file1, *files):
 '''add the specified files on the next commit'''
-repo.add(relpath(repo, (file,) + files))
+repo.add(relpath(repo, (file1,) + files))
 def addremove(ui, repo, *files):
 """add all new files, delete all missing files"""
 if files:
 files = relpath(repo, files)
 else:
 (c, a, d, u) = repo.changes(None, None)
 repo.add(u)
 repo.remove(d)
-def annotate(u, repo, file, *files, **ops):
+def annotate(u, repo, file1, *files, **ops):
 """show changeset information per file line"""
 def getnode(rev):
 return hg.short(repo.changelog.node(rev))
 def getname(rev):
 node = repo.dirstate.parents()[0]
 if ops['revision']:
 node = repo.changelog.lookup(ops['revision'])
 change = repo.changelog.read(node)
 mmap = repo.manifest.read(change[0])
-for f in relpath(repo, (file,) + files):
+for f in relpath(repo, (file1,) + files):
 lines = repo.file(f).annotate(mmap[f])
 pieces = []
 for o, f in opmap:
 if ops[o]:
-l = [ f(n) for n,t in lines ]
+l = [f(n) for n, dummy in lines]
 m = max(map(len, l))
-pieces.append([ "%*s" % (m, x) for x in l])
+pieces.append(["%*s" % (m, x) for x in l])
-for p,l in zip(zip(*pieces), lines):
+for p, l in zip(zip(*pieces), lines):
 u.write(" ".join(p) + ": " + l[1])
-def cat(ui, repo, file, rev = [], **opts):
+def cat(ui, repo, file1, rev=None, **opts):
 """output the latest or given revision of a file"""
-r = repo.file(relpath(repo, [file])[0])
+r = repo.file(relpath(repo, [file1])[0])
-n = r.tip()
+if rev:
-if rev: n = r.lookup(rev)
+n = r.lookup(rev)
+else:
+n = r.tip()
 if opts['output'] and opts['output'] != '-':
 try:
 outname = make_filename(repo, r, opts['output'], node=n)
 fp = open(outname, 'wb')
 except KeyError, inst:
 sys.exit(1);
 else:
 fp = sys.stdout
 fp.write(r.read(n))
-def clone(ui, source, dest = None, **opts):
+def clone(ui, source, dest=None, **opts):
 """make a copy of an existing repository"""
 if dest is None:
 dest = os.path.basename(os.path.normpath(source))
 if os.path.exists(dest):
 ui.warn("abort: destination '%s' already exists\n" % dest)
 return 1
-class dircleanup:
+class Dircleanup:
-def __init__(self, dir):
+def __init__(self, dir_):
-import shutil
 self.rmtree = shutil.rmtree
-self.dir = dir
+self.dir_ = dir_
-os.mkdir(dir)
+os.mkdir(dir_)
 def close(self):
-self.dir = None
+self.dir_ = None
 def __del__(self):
-if self.dir:
+if self.dir_:
-self.rmtree(self.dir, True)
+self.rmtree(self.dir_, True)
-d = dircleanup(dest)
+d = Dircleanup(dest)
-link = 0
 abspath = source
 source = ui.expandpath(source)
 other = hg.repository(ui, source)
 if other.dev() != -1:
 abspath = os.path.abspath(source)
+copyfile = (os.stat(dest).st_dev == other.dev()
-if other.dev() != -1 and os.stat(dest).st_dev == other.dev():
+and getattr(os, 'link', None) or shutil.copy2)
-ui.note("cloning by hardlink\n")
+if copyfile is not shutil.copy2:
-util.system("cp -al '%s'/.hg '%s'/.hg" % (source, dest))
+ui.note("cloning by hardlink\n")
+util.copytree(os.path.join(source, ".hg"), os.path.join(dest, ".hg"),
+copyfile)
 try:
-os.remove(os.path.join(dest, ".hg", "dirstate"))
+os.unlink(os.path.join(dest, ".hg", "dirstate"))
-except: pass
+except IOError:
+pass
 repo = hg.repository(ui, dest)
 else:
 repo = hg.repository(ui, dest, create=1)
 d.close()
 def commit(ui, repo, *files, **opts):
 """commit the specified files or all outstanding changes"""
 text = opts['text']
-if not text and opts['logfile']:
+logfile = opts['logfile']
-try: text = open(opts['logfile']).read()
+if not text and logfile:
-except IOError: pass
+try:
+text = open(logfile).read()
+except IOError, why:
+ui.warn("Can't read commit text %s: %s\n" % (logfile, why))
 if opts['addremove']:
 addremove(ui, repo, *files)
 repo.commit(relpath(repo, files), text, opts['user'], opts['date'])
 """show the contents of the current dirstate"""
 repo.dirstate.read()
 dc = repo.dirstate.map
 keys = dc.keys()
 keys.sort()
-for file in keys:
+for file_ in keys:
-ui.write("%c %s\n" % (dc[file][0], file))
+ui.write("%c %s\n" % (dc[file_][0], file_))
-def debugindex(ui, file):
+def debugindex(ui, file_):
 """dump the contents of an index file"""
-r = hg.revlog(hg.opener(""), file, "")
+r = hg.revlog(hg.opener(""), file_, "")
 ui.write("   rev    offset  length   base linkrev" +
 " p1           p2           nodeid\n")
 for i in range(r.count()):
 e = r.index[i]
 ui.write("% 6d % 9d % 7d % 6d % 7d %s.. %s.. %s..\n" % (
 i, e[0], e[1], e[2], e[3],
 hg.hex(e[4][:5]), hg.hex(e[5][:5]), hg.hex(e[6][:5])))
-def debugindexdot(ui, file):
+def debugindexdot(ui, file_):
 """dump an index DAG as a .dot file"""
-r = hg.revlog(hg.opener(""), file, "")
+r = hg.revlog(hg.opener(""), file_, "")
 ui.write("digraph G {\n")
 for i in range(r.count()):
 e = r.index[i]
 ui.write("\t%d -> %d\n" % (r.rev(e[4]), i))
 if e[5] != hg.nullid:
 revwidth = max(len(revs[0]), len(revs[-1]))
 for cset in revs:
 seqno += 1
 doexport(ui, repo, cset, seqno, total, revwidth, opts)
-def forget(ui, repo, file, *files):
+def forget(ui, repo, file1, *files):
 """don't add the specified files on the next commit"""
-repo.forget(relpath(repo, (file,) + files))
+repo.forget(relpath(repo, (file1,) + files))
 def heads(ui, repo):
 """show current repository heads"""
 for n in repo.changelog.heads():
 show_changeset(ui, repo, changenode=n)
 def import_(ui, repo, patch1, *patches, **opts):
 """import an ordered set of patches"""
 try:
 import psyco
 psyco.full()
-except:
+except ImportError:
 pass
 patches = (patch1,) + patches
 d = opts["base"]
 for patch in patches:
 ui.status("applying %s\n" % patch)
 pf = os.path.join(d, patch)
-text = ""
+text = []
-for l in file(pf):
+user = None
-if l.startswith("--- ") or l.startswith("diff -r"): break
+hgpatch = False
-text += l
+for line in file(pf):
+line = line.rstrip()
-# parse values that exist when importing the result of an hg export
+if line.startswith("--- ") or line.startswith("diff -r"):
-hgpatch = user = snippet = None
+break
-ui.debug('text:\n')
+elif hgpatch:
-for t in text.splitlines():
+# parse values when importing the result of an hg export
-ui.debug(t,'\n')
+if line.startswith("# User "):
-if t == '# HG changeset patch' or hgpatch == True:
+user = line[7:]
+ui.debug('User: %s\n' % user)
+elif not line.startswith("# ") and line:
+text.append(line)
+hgpatch = False
+elif line == '# HG changeset patch':
 hgpatch = True
-if t.startswith("# User "):
+else:
-user = t[7:]
+text.append(line)
-ui.debug('User: %s\n' % user)
-if not t.startswith("# ") and t.strip() and not snippet: snippet = t
+# make sure text isn't empty
-if snippet: text = snippet + '\n' + text
+if not text:
+text = "imported patch %s\n" % patch
+else:
+text = "%s\n" % '\n'.join(text)
 ui.debug('text:\n%s\n' % text)
-# make sure text isn't empty
-if not text: text = "imported patch %s\n" % patch
 f = os.popen("patch -p%d < %s" % (strip, pf))
 files = []
 for l in f.read().splitlines():
 l.rstrip('\r\n');
 """create a new repository in the current directory"""
 if source:
 ui.warn("no longer supported: use \"hg clone\" instead\n")
 sys.exit(1)
-repo = hg.repository(ui, ".", create=1)
+hg.repository(ui, ".", create=1)
 def locate(ui, repo, *pats, **opts):
 """locate files matching specific patterns"""
 if [p for p in pats if os.sep in p]:
 ui.warn("error: patterns may not contain '%s'\n" % os.sep)
 ui.warn("use '-i <dir>' instead\n")
 sys.exit(1)
-def compile(pats, head = '^', tail = os.sep, on_empty = True):
+def compile(pats, head='^', tail=os.sep, on_empty=True):
 if not pats:
 class c:
-def match(self, x): return on_empty
+def match(self, x):
+return on_empty
 return c()
-regexp = r'%s(?:%s)%s' % (
+fnpats = [fnmatch.translate(os.path.normpath(os.path.normcase(p)))[:-1]
-head,
+for p in pats]
-'|'.join([fnmatch.translate(os.path.normpath(os.path.normcase(p)))[:-1]
+regexp = r'%s(?:%s)%s' % (head, '|'.join(fnpats), tail)
-for p in pats]),
-tail)
 return re.compile(regexp)
-exclude = compile(opts['exclude'], on_empty = False)
+exclude = compile(opts['exclude'], on_empty=False)
 include = compile(opts['include'])
-pat = compile([os.path.normcase(p) for p in pats], head = '', tail = '$')
+pat = compile(pats, head='', tail='$')
-end = '\n'
+end = opts['print0'] and '\0' or '\n'
-if opts['print0']: end = '\0'
+if opts['rev']:
-if opts['rev']: node = repo.manifest.lookup(opts['rev'])
+node = repo.manifest.lookup(opts['rev'])
-else: node = repo.manifest.tip()
+else:
+node = repo.manifest.tip()
 manifest = repo.manifest.read(node)
 cwd = repo.getcwd()
 cwd_plus = cwd and (cwd + os.sep)
 found = []
 for f in manifest:
 f = os.path.normcase(f)
 if exclude.match(f) or not(include.match(f) and
 f.startswith(cwd_plus) and
-pat.match(os.path.basename(f))): continue
+pat.match(os.path.basename(f))):
-if opts['fullpath']: f = os.path.join(repo.root, f)
+continue
-elif cwd: f = f[len(cwd_plus):]
+if opts['fullpath']:
+f = os.path.join(repo.root, f)
+elif cwd:
+f = f[len(cwd_plus):]
 found.append(f)
 found.sort()
-for f in found: ui.write(f, end)
+for f in found:
+ui.write(f, end)
 def log(ui, repo, f=None, **opts):
 """show the revision history of the repository or a single file"""
 if f:
 files = relpath(repo, [f])
 filenode = filelog.node(i)
 i = filelog.linkrev(filenode)
 changenode = repo.changelog.node(i)
 prev, other = repo.changelog.parents(changenode)
 dodiff(sys.stdout, ui, repo, files, prev, changenode)
-ui.write("\n")
+ui.write("\n\n")
-ui.write("\n")
+def manifest(ui, repo, rev=None):
-def manifest(ui, repo, rev = []):
 """output the latest or given revision of the project manifest"""
-n = repo.manifest.tip()
 if rev:
 try:
 # assume all revision numbers are for changesets
 n = repo.lookup(rev)
 change = repo.changelog.read(n)
 n = change[0]
-except:
+except hg.RepoError:
 n = repo.manifest.lookup(rev)
+else:
+n = repo.manifest.tip()
 m = repo.manifest.read(n)
 mf = repo.manifest.readflags(n)
 files = m.keys()
 files.sort()
 for f in files:
 ui.write("%40s %3s %s\n" % (hg.hex(m[f]), mf[f] and "755" or "644", f))
-def parents(ui, repo, node = None):
+def parents(ui, repo, node=None):
 '''show the parents of the current working dir'''
 if node:
 p = repo.changelog.parents(repo.lookup(hg.bin(node)))
 else:
 p = repo.dirstate.parents()
 def rawcommit(ui, repo, *flist, **rc):
 "raw commit interface"
 text = rc['text']
 if not text and rc['logfile']:
-try: text = open(rc['logfile']).read()
+try:
-except IOError: pass
+text = open(rc['logfile']).read()
+except IOError:
+pass
 if not text and not rc['logfile']:
 ui.warn("abort: missing commit text\n")
 return 1
 files = relpath(repo, list(flist))
 def recover(ui, repo):
 """roll back an interrupted transaction"""
 repo.recover()
-def remove(ui, repo, file, *files):
+def remove(ui, repo, file1, *files):
 """remove the specified files on the next commit"""
-repo.remove(relpath(repo, (file,) + files))
+repo.remove(relpath(repo, (file1,) + files))
 def revert(ui, repo, *names, **opts):
 """revert modified files or dirs back to their unmodified states"""
 node = opts['rev'] and repo.lookup(opts['rev']) or \
 repo.dirstate.parents()[0]
 chosen = {}
 def choose(name):
 def body(name):
 for r in relnames:
-if not name.startswith(r): continue
+if not name.startswith(r):
+continue
 rest = name[len(r):]
-if not rest: return r, True
+if not rest:
+return r, True
 depth = rest.count(os.sep)
 if not r:
-if depth == 0 or not opts['nonrecursive']: return r, True
+if depth == 0 or not opts['nonrecursive']:
+return r, True
 elif rest[0] == os.sep:
-if depth == 1 or not opts['nonrecursive']: return r, True
+if depth == 1 or not opts['nonrecursive']:
+return r, True
 return None, False
 relname, ret = body(name)
 if ret:
 chosen[relname] = 1
 return ret
 respond(" ".join(map(hg.hex, h)) + "\n")
 if cmd == "lock":
 lock = repo.lock()
 respond("")
 if cmd == "unlock":
-if lock: lock.release()
+if lock:
+lock.release()
 lock = None
 respond("")
 elif cmd == "branches":
 arg, nodes = getarg()
 nodes = map(hg.bin, nodes.split(" "))
 for b in repo.branches(nodes):
 r.append(" ".join(map(hg.hex, b)) + "\n")
 respond("".join(r))
 elif cmd == "between":
 arg, pairs = getarg()
-pairs = [ map(hg.bin, p.split("-")) for p in pairs.split(" ") ]
+pairs = [map(hg.bin, p.split("-")) for p in pairs.split(" ")]
 r = []
 for b in repo.between(pairs):
 r.append(" ".join(map(hg.hex, b)) + "\n")
 respond("".join(r))
 elif cmd == "changegroup":
 nodes = map(hg.bin, roots.split(" "))
 cg = repo.changegroup(nodes)
 while 1:
 d = cg.read(4096)
-if not d: break
+if not d:
+break
 fout.write(d)
 fout.flush()
 elif cmd == "addchangegroup":
 r = repo.addchangegroup(fin)
 respond("")
 def openlog(opt, default):
-if opts[opt] and opts[opt] != '-': return open(opts[opt], 'w')
+if opts[opt] and opts[opt] != '-':
-else: return default
+return open(opts[opt], 'w')
+else:
+return default
 httpd = hgweb.create_server(repo.root, opts["name"], opts["templates"],
 opts["address"], opts["port"],
 openlog('accesslog', sys.stdout),
 openlog('errorlog', sys.stderr))
 if addr == '0.0.0.0':
 addr = socket.gethostname()
 else:
 try:
 addr = socket.gethostbyaddr(addr)[0]
-except: pass
+except socket.error:
+pass
 if port != 80:
 ui.status('listening at http://%s:%d/\n' % (addr, port))
 else:
 ui.status('listening at http://%s/\n' % addr)
 httpd.serve_forever()
 ? = not tracked'''
 (c, a, d, u) = repo.changes(None, None)
 (c, a, d, u) = map(lambda x: relfilter(repo, x), (c, a, d, u))
-for f in c: ui.write("C ", f, "\n")
+for f in c:
-for f in a: ui.write("A ", f, "\n")
+ui.write("C ", f, "\n")
-for f in d: ui.write("R ", f, "\n")
+for f in a:
-for f in u: ui.write("? ", f, "\n")
+ui.write("A ", f, "\n")
+for f in d:
-def tag(ui, repo, name, rev = None, **opts):
+ui.write("R ", f, "\n")
+for f in u:
+ui.write("? ", f, "\n")
+def tag(ui, repo, name, rev=None, **opts):
 """add a tag for the current tip or a given revision"""
 if name == "tip":
 ui.warn("abort: 'tip' is a reserved name!\n")
 return -1
 if ".hgtags" in x:
 ui.warn("abort: working copy of .hgtags is changed!\n")
 ui.status("(please commit .hgtags manually)\n")
 return -1
-add = 0
+add = not os.path.exists(repo.wjoin(".hgtags"))
-if not os.path.exists(repo.wjoin(".hgtags")): add = 1
 repo.wfile(".hgtags", "ab").write("%s %s\n" % (r, name))
-if add: repo.add([".hgtags"])
+if add:
+repo.add([".hgtags"])
 if not opts['text']:
 opts['text'] = "Added tag %s for changeset %s" % (name, r)
 repo.commit([".hgtags"], opts['text'], opts['user'], opts['date'])
 # Command options and aliases are listed here, alphabetically
 table = {
 "^add": (add, [], "hg add [files]"),
 "addremove": (addremove, [], "hg addremove [files]"),
-"^annotate": (annotate,
+"^annotate":
-[('r', 'revision', '', 'revision'),
+(annotate,
-('u', 'user', None, 'show user'),
+[('r', 'revision', '', 'revision'),
-('n', 'number', None, 'show revision number'),
+('u', 'user', None, 'show user'),
-('c', 'changeset', None, 'show changeset')],
+('n', 'number', None, 'show revision number'),
-'hg annotate [-u] [-c] [-n] [-r id] [files]'),
+('c', 'changeset', None, 'show changeset')],
-"cat": (cat, [('o', 'output', "", 'output to file')], 'hg cat [-o outfile] <file> [rev]'),
+'hg annotate [-u] [-c] [-n] [-r id] [files]'),
-"^clone": (clone, [('U', 'noupdate', None, 'skip update after cloning')],
+"cat":
-'hg clone [options] <source> [dest]'),
+(cat,
-"^commit|ci": (commit,
+[('o', 'output', "", 'output to file')],
-[('t', 'text', "", 'commit text'),
+'hg cat [-o outfile] <file> [rev]'),
-('A', 'addremove', None, 'run add/remove during commit'),
+"^clone":
-('l', 'logfile', "", 'commit text file'),
+(clone,
-('d', 'date', "", 'date code'),
+[('U', 'noupdate', None, 'skip update after cloning')],
-('u', 'user', "", 'user')],
+'hg clone [options] <source> [dest]'),
-'hg commit [files]'),
+"^commit|ci":
+(commit,
+[('t', 'text', "", 'commit text'),
+('A', 'addremove', None, 'run add/remove during commit'),
+('l', 'logfile', "", 'commit text file'),
+('d', 'date', "", 'date code'),
+('u', 'user', "", 'user')],
+'hg commit [files]'),
 "copy": (copy, [], 'hg copy <source> <dest>'),
 "debugcheckstate": (debugcheckstate, [], 'debugcheckstate'),
 "debugstate": (debugstate, [], 'debugstate'),
 "debugindex": (debugindex, [], 'debugindex <file>'),
 "debugindexdot": (debugindexdot, [], 'debugindexdot <file>'),
-"^diff": (diff, [('r', 'rev', [], 'revision')],
+"^diff":
-'hg diff [-r A] [-r B] [files]'),
+(diff,
-"^export": (export, [('o', 'output', "", 'output to file')],
+[('r', 'rev', [], 'revision')],
-"hg export [-o file] <changeset> ..."),
+'hg diff [-r A] [-r B] [files]'),
+"^export":
+(export,
+[('o', 'output', "", 'output to file')],
+"hg export [-o file] <changeset> ..."),
 "forget": (forget, [], "hg forget [files]"),
 "heads": (heads, [], 'hg heads'),
-"help": (help, [], 'hg help [command]'),
+"help": (help_, [], 'hg help [command]'),
 "identify|id": (identify, [], 'hg identify'),
-"import|patch": (import_,
+"import|patch":
-[('p', 'strip', 1, 'path strip'),
+(import_,
-('b', 'base', "", 'base path')],
+[('p', 'strip', 1, 'path strip'),
-"hg import [options] <patches>"),
+('b', 'base', "", 'base path')],
+"hg import [options] <patches>"),
 "^init": (init, [], 'hg init'),
-"locate": (locate,
+"locate":
-[('0', 'print0', None, 'end records with NUL'),
+(locate,
-('f', 'fullpath', None, 'print complete paths'),
+[('0', 'print0', None, 'end records with NUL'),
-('i', 'include', [], 'include path in search'),
+('f', 'fullpath', None, 'print complete paths'),
-('r', 'rev', '', 'revision'),
+('i', 'include', [], 'include path in search'),
-('x', 'exclude', [], 'exclude path from search')],
+('r', 'rev', '', 'revision'),
-'hg locate [options] [files]'),
+('x', 'exclude', [], 'exclude path from search')],
-"^log|history": (log,
+'hg locate [options] [files]'),
-[('r', 'rev', [], 'revision'),
+"^log|history":
-('p', 'patch', None, 'show patch')],
+(log,
-'hg log [-r A] [-r B] [-p] [file]'),
+[('r', 'rev', [], 'revision'),
+('p', 'patch', None, 'show patch')],
+'hg log [-r A] [-r B] [-p] [file]'),
 "manifest": (manifest, [], 'hg manifest [rev]'),
 "parents": (parents, [], 'hg parents [node]'),
-"^pull": (pull,
+"^pull":
-[('u', 'update', None, 'update working directory')],
+(pull,
-'hg pull [options] [source]'),
+[('u', 'update', None, 'update working directory')],
+'hg pull [options] [source]'),
 "^push": (push, [], 'hg push <destination>'),
-"rawcommit": (rawcommit,
+"rawcommit":
-[('p', 'parent', [], 'parent'),
+(rawcommit,
-('d', 'date', "", 'date code'),
+[('p', 'parent', [], 'parent'),
-('u', 'user', "", 'user'),
+('d', 'date', "", 'date code'),
-('F', 'files', "", 'file list'),
+('u', 'user', "", 'user'),
-('t', 'text', "", 'commit text'),
+('F', 'files', "", 'file list'),
-('l', 'logfile', "", 'commit text file')],
+('t', 'text', "", 'commit text'),
-'hg rawcommit [options] [files]'),
+('l', 'logfile', "", 'commit text file')],
+'hg rawcommit [options] [files]'),
 "recover": (recover, [], "hg recover"),
 "^remove|rm": (remove, [], "hg remove [files]"),
-"^revert": (revert,
+"^revert":
-[("n", "nonrecursive", None, "don't recurse into subdirs"),
+(revert,
-("r", "rev", "", "revision")],
+[("n", "nonrecursive", None, "don't recurse into subdirs"),
-"hg revert [files|dirs]"),
+("r", "rev", "", "revision")],
+"hg revert [files|dirs]"),
 "root": (root, [], "hg root"),
-"^serve": (serve, [('A', 'accesslog', '', 'access log file'),
+"^serve":
-('E', 'errorlog', '', 'error log file'),
+(serve,
-('p', 'port', 8000, 'listen port'),
+[('A', 'accesslog', '', 'access log file'),
-('a', 'address', '', 'interface address'),
+('E', 'errorlog', '', 'error log file'),
-('n', 'name', os.getcwd(), 'repository name'),
+('p', 'port', 8000, 'listen port'),
-('', 'stdio', None, 'for remote clients'),
+('a', 'address', '', 'interface address'),
-('t', 'templates', "", 'template map')],
+('n', 'name', os.getcwd(), 'repository name'),
-"hg serve [options]"),
+('', 'stdio', None, 'for remote clients'),
+('t', 'templates', "", 'template map')],
+"hg serve [options]"),
 "^status": (status, [], 'hg status'),
-"tag": (tag,  [('l', 'local', None, 'make the tag local'),
+"tag":
-('t', 'text', "", 'commit text'),
+(tag,
-('d', 'date', "", 'date code'),
+[('l', 'local', None, 'make the tag local'),
-('u', 'user', "", 'user')],
+('t', 'text', "", 'commit text'),
-'hg tag [options] <name> [rev]'),
+('d', 'date', "", 'date code'),
+('u', 'user', "", 'user')],
+'hg tag [options] <name> [rev]'),
 "tags": (tags, [], 'hg tags'),
 "tip": (tip, [], 'hg tip'),
 "undo": (undo, [], 'hg undo'),
 "^update|up|checkout|co":
 (update,
 [('m', 'merge', None, 'allow merging of conflicts'),
 ('C', 'clean', None, 'overwrite locally modified files')],
 'hg update [options] [node]'),
 "verify": (verify, [], 'hg verify'),
 "version": (show_version, [], 'hg version'),
 }
 globalopts = [('v', 'verbose', None, 'verbose'),
 ('', 'profile', None, 'profile'),
 ('R', 'repository', "", 'repository root directory'),
 ('', 'traceback', None, 'print traceback on exception'),
 ('y', 'noninteractive', None, 'run non-interactively'),
 ('', 'version', None, 'output version information and exit'),
 ]
 norepo = "clone init version help debugindex debugindexdot"
 def find(cmd):
 for e in table.keys():
 if re.match("(%s)$" % e, cmd):
 return table[e]
 raise UnknownCommand(cmd)
-class SignalInterrupt(Exception): pass
+class SignalInterrupt(Exception):
+"""Exception raised on SIGTERM and SIGHUP."""
 def catchterm(*args):
 raise SignalInterrupt
 def run():
 sys.exit(dispatch(sys.argv[1:]))
-class ParseError(Exception): pass
+class ParseError(Exception):
+"""Exception raised on errors in parsing the command line."""
 def parse(args):
 options = {}
 cmdoptions = {}
 raise ParseError(None, inst)
 if options["version"]:
 return ("version", show_version, [], options, cmdoptions)
 elif not args:
-return ("help", help, [], options, cmdoptions)
+return ("help", help_, [], options, cmdoptions)
 else:
 cmd, args = args[0], args[1:]
 i = find(cmd)
 # combine global options into local
 c = list(i[1])
-l = len(c)
 for o in globalopts:
 c.append((o[0], o[1], options[o[1]], o[3]))
 try:
 args = fancyopts.fancyopts(args, c, cmdoptions)
 return (cmd, i[0], args, options, cmdoptions)
 def dispatch(args):
 signal.signal(signal.SIGTERM, catchterm)
-try: signal.signal(signal.SIGHUP, catchterm)
+try:
-except: pass
+signal.signal(signal.SIGHUP, catchterm)
+except AttributeError:
+pass
 try:
 cmd, func, args, options, cmdoptions = parse(args)
 except ParseError, inst:
 u = ui.ui()
 if inst.args[0]:
 u.warn("hg %s: %s\n" % (inst.args[0], inst.args[1]))
-help(u, inst.args[0])
+help_(u, inst.args[0])
 else:
 u.warn("hg: %s\n" % inst.args[1])
-help(u)
+help_(u)
 sys.exit(-1)
 except UnknownCommand, inst:
 u = ui.ui()
 u.warn("hg: unknown command '%s'\n" % inst.args[0])
-help(u)
+help_(u)
 sys.exit(1)
 u = ui.ui(options["verbose"], options["debug"], options["quiet"],
 not options["noninteractive"])
 try:
 try:
 if cmd not in norepo.split():
 path = options["repository"] or ""
 tb = traceback.extract_tb(sys.exc_info()[2])
 if len(tb) > 2: # no
 raise
 u.debug(inst, "\n")
 u.warn("%s: invalid arguments\n" % cmd)
-help(u, cmd)
+help_(u, cmd)
 sys.exit(-1)

changeset 705	574869103985
parent 693	10c0264751da
parent 701	80ed193efff7
child 706	5107a7b6b14a
child 723	9e0f3ba4a9c2