python-cmd2: cmd2.py comparison

comparison cmd2.py @ 75:8b2603d1acc1

working except for combinations

author	catherine@Elli.myhome.westell.com
date	Fri, 27 Jun 2008 15:36:03 -0400
parents	4e290d75e92e
children	dcd5d13e5603

comparison

equal deleted inserted replaced

-:4e290d75e92e
+:8b2603d1acc1
 def getPasteBuffer():
 raise OSError, pastebufferr % ('xclip', 'On Debian/Ubuntu, install with "sudo apt-get install xclip"')
 setPasteBuffer = getPasteBuffer
 pyparsing.ParserElement.setDefaultWhitespaceChars(' \t')    # see http://pyparsing.wikispaces.com/message/view/home/1352689
-def punctuationParser(punctuators):
-"""
+class UserCommand(str):
-Produces a string parser based on a list of targets to search for.
+def __new__(cls, s, app):
-Output is a parser function.
+return str.__new__(cls, s)
-Parser's output is a tuple: (before the target, [elements of the target], after the target)
+def __init__(self, s, app):
->>> p = punctuationParser([';', 'EOF'])
+self.terminator = None
->>> p('is terminated;')
+self.terminator_suffix = None
-('is terminated', [';'], '')
+self.searchable = self.asEntered = s
->>> p('is terminated EOF after the end')
+self.app = app
-('is terminated', ['EOF'], 'after the end')
+self.output_destination_pattern = self.punctuationPattern(['>>', '>'])
->>> p('is not terminated')
+self.input_source_pattern = self.punctuationPattern(['<'])
->>> pattern1 = pyparsing.Literal(';') + pyparsing.Optional(pyparsing.Word(pyparsing.nums))
+self.pipe_destination_pattern = self.punctuationPattern(['|'])
->>> p2 = punctuationParser([pattern1, 'EOF'])
+def punctuationPattern(self, punctuators):
->>> p2('the quick brown fox;4')
+processed = punctuators[:]
-('the quick brown fox', [';', '4'], '')
+if not hasattr(processed[0], 'parseString'):
->>> p2('the quick brown foxEOF')
+processed[0] = pyparsing.Literal(processed[0])
-('the quick brown fox', ['EOF'], '')
+processed = reduce(lambda x, y: x ^ y, processed)
->>> p2('nothing')
+processed.ignore(pyparsing.sglQuotedString)
-"""
+processed.ignore(pyparsing.dblQuotedString)
-processed = punctuators[:]
+pattern = pyparsing.SkipTo(processed) + processed + pyparsing.restOfLine
-if not hasattr(processed[0], 'parseString'):
+return pattern
-processed[0] = pyparsing.Literal(processed[0])
+def find_punctuation(self):
-processed = reduce(lambda x, y: x ^ y, processed)
+punctuators = ['|','>','>>','<']
-processed.ignore(pyparsing.sglQuotedString)
+punctuators.extend(self.app.terminators)
-processed.ignore(pyparsing.dblQuotedString)
+punctuated = self.punctuationPattern(punctuators).searchString(self.asEntered)
-pattern = pyparsing.SkipTo(processed) + processed + pyparsing.restOfLine
+if punctuated:
-def parser(txt):
+self.executable, self.searchable = punctuated[0][0], self.asEntered[len(punctuated[0][0]):]
-result = pattern.searchString(txt)
-if result:
-return result[0][0].strip(), result[0][1:-1], result[0][-1].strip()
 else:
-return None
+self.executable, self.searchable = self.asEntered, ''
-return parser
+def complete(self):
+terminator_finder = self.punctuationPattern(self.app.terminators)
-class UserCommand(str):
+result = terminator_finder.searchString(self.asEntered)
-def __init__(self, s):
+while not result:
-str.__init__(self, s)
+inp = self.app.pseudo_raw_input(self.app.continuationPrompt)
-self.executable = s
+self.asEntered = '%s\n%s' % (self.asEntered, inp)
-self.searchable = s
+result = terminator_finder.searchString(self.asEntered)
+try:
+self.terminator = result[0][1][0]
+self.terminator_suffix = result[0][1][1]
+except IndexError:
+self.terminator = result[0][1]
+self.terminator_suffix = None
+def redirectedInput(self):
+inputFrom = self.input_source_pattern.searchString(self.searchable)
+if inputFrom:
+if inputFrom[0][-1].strip():
+input = self.app.fileimport(source=inputFrom[0][-1].strip())
+else:
+input = getPasteBuffer()
+if self.terminator:
+self.executable = '%s %s' % (self.executable, input)
+else:
+self.executable = '%s %s %s' % (self.executable, inputFrom[0][0], input)
+def pipeDestination(self):
+pipeTo = self.pipe_destination_pattern.searchString(self.searchable)
+return (pipeTo and pipeTo[0][-1]) or None
+def redirectedOutput(self):
+outputTo = self.output_destination_pattern.searchString(self.searchable)
+if outputTo:
+dest = outputTo[0][-1].strip()
+if outputTo[0][1] == '>>':
+mode = 'a'
+else:
+mode = 'w'
+return dest, mode
+return None, None
+"""
+Produces a string parser based on a list of targets to search for.
+Output is a parser function.
+Parser's output is a tuple: (before the target, [elements of the target], after the target)
+>>> p = punctuationParser([';', 'EOF'])
+>>> p('is terminated;')
+('is terminated', [';'], '')
+>>> p('is terminated EOF after the end')
+('is terminated', ['EOF'], 'after the end')
+>>> p('is not terminated')
+>>> pattern1 = pyparsing.Literal(';') + pyparsing.Optional(pyparsing.Word(pyparsing.nums))
+>>> p2 = punctuationParser([pattern1, 'EOF'])
+>>> p2('the quick brown fox;4')
+('the quick brown fox', [';', '4'], '')
+>>> p2('the quick brown foxEOF')
+('the quick brown fox', ['EOF'], '')
+>>> p2('nothing')
+"""
 class Cmd(cmd.Cmd):
 caseInsensitive = True
-terminators = [';', pyparsing.LineEnd() + pyparsing.LineEnd()]
 multilineCommands = []          # commands that need a terminator to be finished
+terminators = [';', pyparsing.LineEnd() + pyparsing.LineEnd()]
 terminatorKeepingCommands = []  # commands that expect to process their own terminators (else it will be stripped during parse)
 continuationPrompt = '> '
 shortcuts = {'?': 'help', '!': 'shell', '@': 'load'}
 excludeFromHistory = '''run r list l history hi ed edit li eof'''.split()
 defaultExtension = 'txt'
 pass
 def __init__(self, *args, **kwargs):
 cmd.Cmd.__init__(self, *args, **kwargs)
 self.history = History()
-self.commmand_terminator_finder = punctuationParser(self.terminators)
-self.output_destination_finder = punctuationParser(['>>', '>'])
-self.input_source_finder = punctuationParser(['<'])
-self.pipe_destination_finder = punctuationParser(['|'])
 def do_shortcuts(self, args):
 """Lists single-key shortcuts available."""
 result = "\n".join('%s: %s' % (sc[0], sc[1]) for sc in self.shortcuts.items())
 self.stdout.write("Single-key shortcuts for other commands:\n%s\n" % (result))
 (command, args) = statement, ''
 if self.caseInsensitive:
 command = command.lower()
 return command, args
-def completedStatement(self, firstline):
-statement = firstline
-termination_found = self.commmand_terminator_finder(statement)
-while not termination_found:
-inp = self.pseudo_raw_input(self.continuationPrompt)
-statement = '%s\n%s' % (statement, inp)
-termination_found = self.commmand_terminator_finder(statement)
-return termination_found[0], termination_found[-1]
-# assembling a list of lines and joining them at the end would be faster,
-# but statementHasEnded needs a string arg; anyway, we're getting
-# user input and users are slow.
 def onecmd(self, line, assumeComplete=False):
 """Interpret the argument as though it had been typed in response
 to the prompt.
 This may be overridden, but should not normally need to be;
 """
 statekeeper = None
 stop = 0
 command, args = self.extractCommand(line)
-statement = originalStatement = ' '.join([command, args])
+originalStatement = ' '.join([command, args])
+statement = UserCommand(originalStatement, self)
 if (not assumeComplete) and (command in self.multilineCommands):
-statement, afterTerminator = self.completedStatement(statement)
+statement.complete()
-inputFrom = self.input_source_finder(afterTerminator)
+statement.find_punctuation()
-if inputFrom:
+statement.redirectedInput()
-statement = "%s %s" % (statement, inputFrom[0])
+pipeTo = statement.pipeDestination()
-else:
-inputFrom = self.input_source_finder(statement)
-if inputFrom:
-statement = inputFrom[0]
-if inputFrom:
-source = inputFrom[-1]
-if source:
-statement = '%s %s' % (statement, self.fileimport(source=source))
-else:
-statement = '%sy %s' % (statement, getPasteBuffer())
-pipeTo = self.pipe_destination_finder(afterTerminator)
 if pipeTo:
-pipeTo = pipeTo[-1]
 statekeeper = Statekeeper(self, ('stdout',))
-pipeTo = subprocess.Popen(pipeTo, shell=True, stdout=subprocess.PIPE, stdin=subprocess.PIPE)
+dest = subprocess.Popen(pipeTo, shell=True, stdout=subprocess.PIPE, stdin=subprocess.PIPE)
-self.stdout = pipeTo.stdin
+self.stdout = dest.stdin
 else:  # can't pipe output AND send it to a file
-outputTo = self.output_destination_finder(afterTerminator)
+outputTo, outputMode = statement.redirectedOutput()
-if outputTo:
+if outputMode:
-destination = outputTo[-1]
 statekeeper = Statekeeper(self, ('stdout',))
-mode = ((outputTo[1][0] == '>>') and 'a') or 'w'
+if outputTo:
-if destination:
+self.stdout = open(outputTo, outputMode)
-self.stdout = open(destination, mode)
 else:
 self.stdout = tempfile.TemporaryFile()
-if mode == 'a':
+if outputMode == 'a':
 self.stdout.write(getPasteBuffer())
-stop = cmd.Cmd.onecmd(self, statement)
+stop = cmd.Cmd.onecmd(self, statement.executable)
 try:
 if command not in self.excludeFromHistory:
 self.history.append(originalStatement)
 finally:
 if statekeeper:
 if pipeTo:
-for result in pipeTo.communicate():
+for result in dest.communicate():
 statekeeper.stdout.write(result or '')
-elif outputTo and not destination:
+elif outputMode and not outputTo:
 self.stdout.seek(0)
 writeToPasteBuffer(self.stdout.read())
 self.stdout.close()
 statekeeper.restore()
 if shortcut and hasattr(self, 'do_%s' % shortcut):
 line = '%s %s' % (shortcut, line[1:])
 i, n = 0, len(line)
 while i < n and line[i] in self.identchars: i = i+1
 cmd, arg = line[:i], line[i:].strip()
-if cmd not in self.terminatorKeepingCommands:
-arg = self.strip_terminators(arg)
 return cmd, arg, line
 def showParam(self, param):
 param = self.clean(param)
 if param in self.settable:

Mercurial > python-cmd2

comparison cmd2.py @ 75:8b2603d1acc1