python-cmd2: cmd2.py comparison

comparison cmd2.py @ 287:1cd23003e8d5

refactoring, but something went wrong with comments

author	catherine@bothari
date	Mon, 19 Oct 2009 18:00:26 -0400
parents	3c4ba65cb303
children	e743cf74c518

comparison

equal deleted inserted replaced

-:3c4ba65cb303
+:1cd23003e8d5
 - Catherine Devlin, Jan 03 2008 - catherinedevlin.blogspot.com
 mercurial repository at http://www.assembla.com/wiki/show/python-cmd2
 """
-import cmd, re, os, sys, optparse, subprocess, tempfile, pyparsing, doctest
+import cmd
-import unittest, string, datetime, urllib, glob, traceback
+import re
+import os
+import sys
+import optparse
+import subprocess
+import tempfile
+import doctest
+import unittest
+import datetime
+import urllib
+import glob
+import traceback
 from code import InteractiveConsole, InteractiveInterpreter, softspace
 from optparse import make_option
+import pyparsing
 __version__ = '0.5.6'
 class OptionParser(optparse.OptionParser):
 def exit(self, status=0, msg=None):
 self.values._exit = True
 If you override this in a subclass, it should not return -- it
 should either exit or raise an exception.
 """
 raise
-def remainingArgs(oldArgs, newArgList):
+def remaining_args(oldArgs, newArgList):
 '''
 Preserves the spacing originally in the argument after
 the removal of options.
->>> remainingArgs('-f bar   bar   cow', ['bar', 'cow'])
+>>> remaining_args('-f bar   bar   cow', ['bar', 'cow'])
 'bar   cow'
 '''
 pattern = '\s+'.join(re.escape(a) for a in newArgList) + '\s*$'
 matchObj = re.search(pattern, oldArgs)
 return oldArgs[matchObj.start():]
 return None
 optparse.Values.get = _attr_get_
 def options(option_list):
+'''Used as a decorator and passed a list of optparse-style options,
+alters a cmd2 methodo populate its ``opts`` argument from its
+raw text argument.
+Example: transform
+def do_something(self, arg):
+into
+@options([make_option('-q', '--quick', action="store_true",
+help="Makes things fast")])
+def do_something(self, arg, opts):
+if opts.quick:
+self.fast_button = True
+'''
 def option_setup(func):
 optionParser = OptionParser()
 for opt in option_list:
 optionParser.add_option(opt)
 optionParser.set_usage("%s [options] arg" % func.__name__.strip('do_'))
 optionParser._func = func
-def newFunc(instance, arg):
+def new_func(instance, arg):
 try:
 if hasattr(arg, 'parsed'):
 args = arg.parsed.raw
 else:
 args = arg
 opts, newArgList = optionParser.parse_args(args.split())
 # Must find the remaining args in the original argument list, but
 # mustn't include the command itself
 if hasattr(arg, 'parsed') and newArgList[0] == arg.parsed.command:
 newArgList = newArgList[1:]
-newArgs = remainingArgs(args, newArgList)
+newArgs = remaining_args(args, newArgList)
 except (optparse.OptionValueError, optparse.BadOptionError,
 optparse.OptionError, optparse.AmbiguousOptionError,
 optparse.OptionConflictError), e:
 print e
 optionParser.print_help()
 else:
 arg = newArgs
 result = func(instance, arg, opts)
 return result
 newFunc.__doc__ = '%s\n%s' % (func.__doc__, optionParser.format_help())
-return newFunc
+return new_func
 return option_setup
 class PasteBufferError(EnvironmentError):
 if sys.platform[:3] == 'win':
 errmsg = """Redirecting to or from paste buffer requires pywin32
 %s"""
 if subprocess.mswindows:
 try:
 import win32clipboard
-def getPasteBuffer():
+def get_paste_buffer():
 win32clipboard.OpenClipboard(0)
 try:
 result = win32clipboard.GetClipboardData()
 except TypeError:
 result = ''  #non-text
 win32clipboard.CloseClipboard()
 return result
-def writeToPasteBuffer(txt):
+def write_to_paste_buffer(txt):
 win32clipboard.OpenClipboard(0)
 win32clipboard.EmptyClipboard()
 win32clipboard.SetClipboardText(txt)
 win32clipboard.CloseClipboard()
 except ImportError:
-def getPasteBuffer(*args):
+def get_paste_buffer(*args):
 raise OSError, pastebufferr % ('pywin32', 'Download from http://sourceforge.net/projects/pywin32/')
-setPasteBuffer = getPasteBuffer
+setPasteBuffer = get_paste_buffer
 else:
 can_clip = False
 try:
 subprocess.check_call('xclip -o -sel clip', shell=True, stdout=subprocess.PIPE, stdin=subprocess.PIPE)
 can_clip = True
 if xclipproc.stdout.read() == teststring:
 can_clip = True
 except (subprocess.CalledProcessError, OSError, IOError):
 pass
 if can_clip:
-def getPasteBuffer():
+def get_paste_buffer():
 xclipproc = subprocess.Popen('xclip -o -sel clip', shell=True, stdout=subprocess.PIPE, stdin=subprocess.PIPE)
 return xclipproc.stdout.read()
-def writeToPasteBuffer(txt):
+def write_to_paste_buffer(txt):
 xclipproc = subprocess.Popen('xclip -sel clip', shell=True, stdout=subprocess.PIPE, stdin=subprocess.PIPE)
 xclipproc.stdin.write(txt)
 xclipproc.stdin.close()
 # but we want it in both the "primary" and "mouse" clipboards
 xclipproc = subprocess.Popen('xclip', shell=True, stdout=subprocess.PIPE, stdin=subprocess.PIPE)
 xclipproc.stdin.write(txt)
 xclipproc.stdin.close()
 else:
-def getPasteBuffer(*args):
+def get_paste_buffer(*args):
 raise OSError, pastebufferr % ('xclip', 'On Debian/Ubuntu, install with "sudo apt-get install xclip"')
-setPasteBuffer = getPasteBuffer
+setPasteBuffer = get_paste_buffer
-writeToPasteBuffer = getPasteBuffer
+writeToPasteBuffer = get_paste_buffer
 pyparsing.ParserElement.setDefaultWhitespaceChars(' \t')
 class ParsedString(str):
 pass
 try:
 result = open(os.path.expanduser(fname[0])).read()
 except IOError:
 result = '< %s' % fname[0]  # wasn't a file after all
 else:
-result = getPasteBuffer()
+result = get_paste_buffer()
 return result
 class EmbeddedConsoleExit(Exception):
 pass
 shortcuts = {'?': 'help', '!': 'shell', '@': 'load', '@@': '_relative_load'}
 excludeFromHistory = '''run r list l history hi ed edit li eof'''.split()
 noSpecialParse = 'set ed edit exit'.split()
 defaultExtension = 'txt'            # For ``save``, ``load``, etc.
 default_file_name = 'command.txt'   # For ``save``, ``load``, etc.
-abbrev = True
+abbrev = True                       # Abbreviated commands recognized
-nonpythoncommand = 'cmd'
 current_script_dir = None
 reserved_words = []
-feedback_to_output = False
+feedback_to_output = False          # Do include nonessentials in >, | output
-quiet = False
+quiet = False                       # Do not suppress nonessential output
 debug = False
 settable = ['prompt', 'continuation_prompt', 'debug', 'default_file_name', 'editor',
 'case_insensitive', 'feedback_to_output', 'quiet', 'echo', 'timing',
 'abbrev']
 settable.sort()
 if not self.quiet:
 if self.feedback_to_output:
 self.poutput(msg)
 else:
 print msg
+_STOP_AND_EXIT = 2
 editor = os.environ.get('EDITOR')
-_STOP_AND_EXIT = 2
 if not editor:
 if sys.platform[:3] == 'win':
 editor = 'notepad'
 else:
 for editor in ['gedit', 'kate', 'vim', 'emacs', 'nano', 'pico']:
 prefixParser = pyparsing.Empty()
 commentGrammars = pyparsing.Or([pyparsing.pythonStyleComment, pyparsing.cStyleComment])
 commentGrammars.addParseAction(lambda x: '')
 commentInProgress  = pyparsing.Literal('/*') + pyparsing.SkipTo(pyparsing.stringEnd)
-commentInProgress = pyparsing.NoMatch()
 terminators = [';']
 blankLinesAllowed = False
 multilineCommands = []
 def _init_parser(self):
 return self.postparsing_postcmd(stop=0)
 else:
 statekeeper = Statekeeper(self, ('stdout',))
 self.stdout = tempfile.TemporaryFile()
 if statement.parsed.output == '>>':
-self.stdout.write(getPasteBuffer())
+self.stdout.write(get_paste_buffer())
 try:
 try:
 # "heart" of the command, replace's cmd's onecmd()
 self.lastcmd = statement.parsed.expanded
 funcname = self.func_named(statement.parsed.command)
 finally:
 if statekeeper:
 if statement.parsed.output and not statement.parsed.outputTo:
 self.stdout.seek(0)
 try:
-writeToPasteBuffer(self.stdout.read())
+write_to_paste_buffer(self.stdout.read())
 except Exception, e:
 self.perror(e)
 elif statement.parsed.pipeTo:
 for result in redirect.communicate():
 statekeeper.stdout.write(result or '')
 def do_EOF(self, arg):
 return True
 do_eof = do_EOF
-def showParam(self, param):
+def show_param(self, param):
 any_shown = False
 param = param.strip().lower()
 for p in self.settable:
 if p.startswith(param):
-val = getattr(self, p)
 self.stdout.write('%s: %s\n' % (p, str(getattr(self, p))))
 any_shown = True
 if not any_shown:
 self.perror("Parameter '%s' not supported (type 'show' for list of parameters)." % param)
 do_q = do_quit
 def do_show(self, arg):
 '''Shows value of a parameter.'''
 if arg.strip():
-self.showParam(arg)
+self.show_param(arg)
 else:
 for param in self.settable:
-self.showParam(param)
+self.show_param(param)
 def do_set(self, arg):
 '''Sets a cmd2 parameter.  Accepts abbreviated parameter names so long as there is no ambiguity.
 Call without arguments for a list of settable parameters with their values.'''
 try:
 raise EmbeddedConsoleExit
 def onecmd(arg):
 return self.onecmd(arg + '\n')
 self.pystate['quit'] = quit
 self.pystate['exit'] = quit
-self.pystate[self.nonpythoncommand] = onecmd
 try:
 cprt = 'Type "help", "copyright", "credits" or "license" for more information.'
 keepstate = Statekeeper(sys, ('stdin','stdout'))
 sys.stdout = self.stdout
 sys.stdin = self.stdin
 except Exception, e:
 self.perror('Error saving %s: %s' % (fname, str(e)))
 def read_file_or_url(self, fname):
 if isinstance(fname, file):
-target = open(fname, 'r')
+result = open(fname, 'r')
 else:
 match = self.urlre.match(fname)
 if match:
-target = urllib.urlopen(match.group(1))
+result = urllib.urlopen(match.group(1))
 else:
 fname = os.path.expanduser(fname)
 try:
 result = open(os.path.expanduser(fname), 'r')
-except IOError, e:
+except IOError:
 result = open('%s.%s' % (os.path.expanduser(fname),
 self.defaultExtension), 'r')
 return result
 def do__relative_load(self, arg=None):
 if self.CmdApp:
 self.outputTrap.tearDown()
 if __name__ == '__main__':
 doctest.testmod(optionflags = doctest.NORMALIZE_WHITESPACE)
 '''
 To make your application transcript-testable, add text like this to your .py file
 (replacing CmdLineApp with your own application class's name).  Then, a cut-and-pasted
 version of a successful session with your application, saved as a text file, can serve

Mercurial > python-cmd2

comparison cmd2.py @ 287:1cd23003e8d5