mirror of
https://github.com/python/cpython.git
synced 2024-12-11 10:50:11 +08:00
268 lines
9.2 KiB
Python
268 lines
9.2 KiB
Python
"""A generic class to build line-oriented command interpreters.
|
|
|
|
Interpreters constructed with this class obey the following conventions:
|
|
|
|
1. End of file on input is processed as the command 'EOF'.
|
|
2. A command is parsed out of each line by collecting the prefix composed
|
|
of characters in the identchars member.
|
|
3. A command `foo' is dispatched to a method 'do_foo()'; the do_ method
|
|
is passed a single argument consisting of the remainder of the line.
|
|
4. Typing an empty line repeats the last command. (Actually, it calls the
|
|
method `emptyline', which may be overridden in a subclass.)
|
|
5. There is a predefined `help' method. Given an argument `topic', it
|
|
calls the command `help_topic'. With no arguments, it lists all topics
|
|
with defined help_ functions, broken into up to three topics; documented
|
|
commands, miscellaneous help topics, and undocumented commands.
|
|
6. The command '?' is a synonym for `help'. The command '!' is a synonym
|
|
for `shell', if a do_shell method exists.
|
|
7. If completion is enabled, completing commands will be done automatically,
|
|
and completing of commands args is done by calling complete_foo() with
|
|
arguments text, line, begidx, endidx. text is string we are matching
|
|
against, all returned matches must begin with it. line is the current
|
|
input line (lstripped), begidx and endidx are the beginning and end
|
|
indexes of the text being matched, which could be used to provide
|
|
different completion depending upon which position the argument is in.
|
|
|
|
The `default' method may be overridden to intercept commands for which there
|
|
is no do_ method.
|
|
|
|
The `completedefault' method may be overridden to intercept completions for
|
|
commands that have no complete_ method.
|
|
|
|
The data member `self.ruler' sets the character used to draw separator lines
|
|
in the help messages. If empty, no ruler line is drawn. It defaults to "=".
|
|
|
|
If the value of `self.intro' is nonempty when the cmdloop method is called,
|
|
it is printed out on interpreter startup. This value may be overridden
|
|
via an optional argument to the cmdloop() method.
|
|
|
|
The data members `self.doc_header', `self.misc_header', and
|
|
`self.undoc_header' set the headers used for the help function's
|
|
listings of documented functions, miscellaneous topics, and undocumented
|
|
functions respectively.
|
|
|
|
These interpreters use raw_input; thus, if the readline module is loaded,
|
|
they automatically support Emacs-like command history and editing features.
|
|
"""
|
|
|
|
import string, sys
|
|
|
|
__all__ = ["Cmd"]
|
|
|
|
PROMPT = '(Cmd) '
|
|
IDENTCHARS = string.ascii_letters + string.digits + '_'
|
|
|
|
class Cmd:
|
|
prompt = PROMPT
|
|
identchars = IDENTCHARS
|
|
ruler = '='
|
|
lastcmd = ''
|
|
cmdqueue = []
|
|
intro = None
|
|
doc_leader = ""
|
|
doc_header = "Documented commands (type help <topic>):"
|
|
misc_header = "Miscellaneous help topics:"
|
|
undoc_header = "Undocumented commands:"
|
|
nohelp = "*** No help on %s"
|
|
use_rawinput = 1
|
|
|
|
def __init__(self, completekey='tab'):
|
|
if completekey:
|
|
try:
|
|
import readline
|
|
readline.set_completer(self.complete)
|
|
readline.parse_and_bind(completekey+": complete")
|
|
except ImportError:
|
|
pass
|
|
|
|
def cmdloop(self, intro=None):
|
|
self.preloop()
|
|
if intro is not None:
|
|
self.intro = intro
|
|
if self.intro:
|
|
print self.intro
|
|
stop = None
|
|
while not stop:
|
|
if self.cmdqueue:
|
|
line = self.cmdqueue[0]
|
|
del self.cmdqueue[0]
|
|
else:
|
|
if self.use_rawinput:
|
|
try:
|
|
line = raw_input(self.prompt)
|
|
except EOFError:
|
|
line = 'EOF'
|
|
else:
|
|
sys.stdout.write(self.prompt)
|
|
line = sys.stdin.readline()
|
|
if not len(line):
|
|
line = 'EOF'
|
|
else:
|
|
line = line[:-1] # chop \n
|
|
line = self.precmd(line)
|
|
stop = self.onecmd(line)
|
|
stop = self.postcmd(stop, line)
|
|
self.postloop()
|
|
|
|
def precmd(self, line):
|
|
return line
|
|
|
|
def postcmd(self, stop, line):
|
|
return stop
|
|
|
|
def preloop(self):
|
|
pass
|
|
|
|
def postloop(self):
|
|
pass
|
|
|
|
def parseline(self, line):
|
|
line = line.strip()
|
|
if not line:
|
|
return None, None, line
|
|
elif line[0] == '?':
|
|
line = 'help ' + line[1:]
|
|
elif line[0] == '!':
|
|
if hasattr(self, 'do_shell'):
|
|
line = 'shell ' + line[1:]
|
|
else:
|
|
return None, None, line
|
|
i, n = 0, len(line)
|
|
while i < n and line[i] in self.identchars: i = i+1
|
|
cmd, arg = line[:i], line[i:].strip()
|
|
return cmd, arg, line
|
|
|
|
def onecmd(self, line):
|
|
cmd, arg, line = self.parseline(line)
|
|
if not line:
|
|
return self.emptyline()
|
|
if cmd is None:
|
|
return self.default(line)
|
|
self.lastcmd = line
|
|
if cmd == '':
|
|
return self.default(line)
|
|
else:
|
|
try:
|
|
func = getattr(self, 'do_' + cmd)
|
|
except AttributeError:
|
|
return self.default(line)
|
|
return func(arg)
|
|
|
|
def emptyline(self):
|
|
if self.lastcmd:
|
|
return self.onecmd(self.lastcmd)
|
|
|
|
def default(self, line):
|
|
print '*** Unknown syntax:', line
|
|
|
|
def completedefault(self, *ignored):
|
|
return []
|
|
|
|
def completenames(self, text, *ignored):
|
|
dotext = 'do_'+text
|
|
return [a[3:] for a in self.get_names() if a.startswith(dotext)]
|
|
|
|
def complete(self, text, state):
|
|
"""Return the next possible completion for 'text'.
|
|
|
|
If a command has not been entered, then complete against command list.
|
|
Otherwise try to call complete_<command> to get list of completions.
|
|
"""
|
|
if state == 0:
|
|
import readline
|
|
origline = readline.get_line_buffer()
|
|
line = origline.lstrip()
|
|
stripped = len(origline) - len(line)
|
|
begidx = readline.get_begidx() - stripped
|
|
endidx = readline.get_endidx() - stripped
|
|
if begidx>0:
|
|
cmd, args, foo = self.parseline(line)
|
|
if cmd == '':
|
|
compfunc = self.completedefault
|
|
else:
|
|
try:
|
|
compfunc = getattr(self, 'complete_' + cmd)
|
|
except AttributeError:
|
|
compfunc = self.completedefault
|
|
else:
|
|
compfunc = self.completenames
|
|
self.completion_matches = compfunc(text, line, begidx, endidx)
|
|
try:
|
|
return self.completion_matches[state]
|
|
except IndexError:
|
|
return None
|
|
|
|
def get_names(self):
|
|
# Inheritance says we have to look in class and
|
|
# base classes; order is not important.
|
|
names = []
|
|
classes = [self.__class__]
|
|
while classes:
|
|
aclass = classes[0]
|
|
if aclass.__bases__:
|
|
classes = classes + list(aclass.__bases__)
|
|
names = names + dir(aclass)
|
|
del classes[0]
|
|
return names
|
|
|
|
def complete_help(self, *args):
|
|
return self.completenames(*args)
|
|
|
|
def do_help(self, arg):
|
|
if arg:
|
|
# XXX check arg syntax
|
|
try:
|
|
func = getattr(self, 'help_' + arg)
|
|
except:
|
|
try:
|
|
doc=getattr(self, 'do_' + arg).__doc__
|
|
if doc:
|
|
print doc
|
|
return
|
|
except:
|
|
pass
|
|
print self.nohelp % (arg,)
|
|
return
|
|
func()
|
|
else:
|
|
names = self.get_names()
|
|
cmds_doc = []
|
|
cmds_undoc = []
|
|
help = {}
|
|
for name in names:
|
|
if name[:5] == 'help_':
|
|
help[name[5:]]=1
|
|
names.sort()
|
|
# There can be duplicates if routines overridden
|
|
prevname = ''
|
|
for name in names:
|
|
if name[:3] == 'do_':
|
|
if name == prevname:
|
|
continue
|
|
prevname = name
|
|
cmd=name[3:]
|
|
if help.has_key(cmd):
|
|
cmds_doc.append(cmd)
|
|
del help[cmd]
|
|
elif getattr(self, name).__doc__:
|
|
cmds_doc.append(cmd)
|
|
else:
|
|
cmds_undoc.append(cmd)
|
|
print self.doc_leader
|
|
self.print_topics(self.doc_header, cmds_doc, 15,80)
|
|
self.print_topics(self.misc_header, help.keys(),15,80)
|
|
self.print_topics(self.undoc_header, cmds_undoc, 15,80)
|
|
|
|
def print_topics(self, header, cmds, cmdlen, maxcol):
|
|
if cmds:
|
|
print header
|
|
if self.ruler:
|
|
print self.ruler * len(header)
|
|
(cmds_per_line,junk)=divmod(maxcol,cmdlen)
|
|
col=cmds_per_line
|
|
for cmd in cmds:
|
|
if col==0: print
|
|
print (("%-"+`cmdlen`+"s") % cmd),
|
|
col = (col+1) % cmds_per_line
|
|
print "\n"
|