wxPython/wxPython/lib/PyCrust/PyCrustShell.py

   1 """
   2 """
   3 __author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
   4 __cvsid__ = "$Id$"
   5 __date__ = "July 1, 2001"
   6 __version__ = "$Revision$"[11:-2]
   7
   8 import os
   9 from PyCrustVersion import version
  10
  11 class Shell:
  12     """PyCrust Shell manages the Editor and Interpreter."""
  13     name = 'PyCrust Shell'
  14     revision = __version__
  15     def __init__(self, editorParent=None, introText='', editor=None, interp=None):
  16         """Create a PyCrust shell object to manage the editor and interpreter."""
  17         try:
  18             eval('crap')
  19         except:
  20             pass
  21         self.introText = introText
  22         # Create a default editor if one isn't provided.
  23         if editor == None:
  24             from PyCrustEditor import Editor
  25             self.editor = Editor(editorParent, id=-1)
  26         else:
  27             self.editor = editor
  28         # Link the editor to the shell so that the shell is a conduit for
  29         # pushing commands to the interpreter.
  30         self.editor.shellPush = self.shellPush
  31         # Create a default interpreter if one isn't provided.
  32         if interp == None:
  33             from PyCrustInterp import Interpreter
  34             from pseudo import PseudoFileIn, PseudoFileOut, PseudoFileErr
  35             self.stdin = PseudoFileIn(self.editor.readIn)
  36             self.stdout = PseudoFileOut(self.editor.writeOut)
  37             self.stderr = PseudoFileErr(self.editor.writeErr)
  38             # Override the default locals so we have something interesting.
  39             locals = {'__name__': 'PyCrust',
  40                       '__doc__': 'PyCrust, The Python Shell.',
  41                       '__version__': version,
  42                       }
  43             self.interp = Interpreter(locals=locals,
  44                                       rawin=self.editor.readRaw,
  45                                       stdin=self.stdin,
  46                                       stdout=self.stdout,
  47                                       stderr=self.stderr)
  48         else:
  49             self.interp = interp
  50         # XXX redo this using hasattr() or something so that we can link
  51         # these if a provided editor has this method.
  52         if editor == None or editor == self:
  53             # Override so the auto complete list comes from the interpreter.
  54             self.editor.getAutoCompleteList = self.interp.getAutoCompleteList
  55             # Override so the call tip comes from the interpreter.
  56             self.editor.getCallTip = self.interp.getCallTip
  57         # Keep track of whether the interpreter needs more.
  58         self.more = 0
  59
  60         try:
  61             self.showIntro(self.introText)
  62         except:
  63             pass
  64
  65         try:
  66             self.setBuiltinKeywords()
  67         except:
  68             pass
  69
  70         try:
  71             self.setLocalShell()
  72         except:
  73             pass
  74
  75         # Do this last so the user has complete control over their
  76         # environment. They can override anything they want.
  77         try:
  78             self.execStartupScript(self.interp.startupScript)
  79         except:
  80             pass
  81
  82     def destroy(self):
  83         del self.editor
  84         del self.stdin
  85         del self.stdout
  86         del self.stderr
  87         del self.interp
  88
  89     def showIntro(self, text=''):
  90         """Display introductory text in the shell editor."""
  91         if text:
  92             if text[-1] != '\n': text += '\n'
  93             self.editor.write(text)
  94         try:
  95             self.editor.write(self.interp.introText)
  96         except AttributeError:
  97             pass
  98
  99     def setBuiltinKeywords(self):
 100         """Create pseudo keywords as part of builtins.
 101
 102         This is a rather clever hack that sets "close", "exit" and "quit"
 103         to a PseudoKeyword object so that we can make them do what we want.
 104         In this case what we want is to call our self.quit() method.
 105         The user can type "close", "exit" or "quit" without the final parens.
 106         """
 107         import __builtin__
 108         from pseudo import PseudoKeyword
 109         __builtin__.close = __builtin__.exit = __builtin__.quit = \
 110             PseudoKeyword(self.quit)
 111
 112     def quit(self):
 113         """Quit the application."""
 114
 115         # XXX Good enough for now but later we want to send a close event.
 116
 117         # In the close event handler we can prompt to make sure they want to quit.
 118         # Other applications, like PythonCard, may choose to hide rather than
 119         # quit so we should just post the event and let the surrounding app
 120         # decide what it wants to do.
 121         self.editor.write('Click on the close button to leave the application.')
 122
 123     def setLocalShell(self):
 124         """Add 'shell' to locals."""
 125         self.interp.locals['shell'] = self
 126
 127     def execStartupScript(self, startupScript):
 128         """Execute the user's PYTHONSTARTUP script if they have one."""
 129         if startupScript and os.path.isfile(startupScript):
 130             startupText = 'Startup script executed: ' + startupScript
 131             self.editor.push('print %s;execfile(%s)' % \
 132                             (`startupText`, `startupScript`))
 133         else:
 134             self.editor.push('')
 135
 136     def run(self, command, prompt=1, verbose=1):
 137         """Execute command within the shell as if it was typed in directly.
 138         >>> shell.run('print "this"')
 139         >>> print "this"
 140         this
 141         >>>
 142         """
 143         command = command.rstrip()
 144         if prompt: self.editor.prompt()
 145         if verbose: self.editor.write(command)
 146         self.editor.push(command)
 147
 148     def runfile(self, filename):
 149         """Execute all commands in file as if they were typed into the shell."""
 150         file = open(filename)
 151         try:
 152             self.editor.prompt()
 153             for command in file.readlines():
 154                 if command[:6] == 'shell.':  # Run shell methods silently.
 155                     self.run(command, prompt=0, verbose=0)
 156                 else:
 157                     self.run(command, prompt=0, verbose=1)
 158         finally:
 159             file.close()
 160
 161     def push(self, command):
 162         """Send command to the interpreter for execution."""
 163         self.more = self.interp.push(command)
 164         return self.more
 165
 166     shellPush = push
 167
 168     def ask(self, prompt='Please enter your response:'):
 169         """Get response from the user."""
 170         return raw_input(prompt=prompt)
 171
 172     def pause(self):
 173         """Halt execution pending a response from the user."""
 174         self.ask('Press enter to continue:')
 175
 176     def clear(self):
 177         """Delete all text from the shell editor."""
 178         self.editor.clear()
 179
 180