| 1 | """Extension to execute code outside the Python shell window. |
| 2 | |
| 3 | This adds the following commands: |
| 4 | |
| 5 | - Check module does a full syntax check of the current module. |
| 6 | It also runs the tabnanny to catch any inconsistent tabs. |
| 7 | |
| 8 | - Run module executes the module's code in the __main__ namespace. The window |
| 9 | must have been saved previously. The module is added to sys.modules, and is |
| 10 | also added to the __main__ namespace. |
| 11 | |
| 12 | XXX GvR Redesign this interface (yet again) as follows: |
| 13 | |
| 14 | - Present a dialog box for ``Run Module'' |
| 15 | |
| 16 | - Allow specify command line arguments in the dialog box |
| 17 | |
| 18 | """ |
| 19 | |
| 20 | import os |
| 21 | import re |
| 22 | import string |
| 23 | import tabnanny |
| 24 | import tokenize |
| 25 | import tkMessageBox |
| 26 | import PyShell |
| 27 | |
| 28 | from configHandler import idleConf |
| 29 | |
| 30 | IDENTCHARS = string.ascii_letters + string.digits + "_" |
| 31 | |
| 32 | indent_message = """Error: Inconsistent indentation detected! |
| 33 | |
| 34 | This means that either: |
| 35 | |
| 36 | 1) your indentation is outright incorrect (easy to fix), or |
| 37 | |
| 38 | 2) your indentation mixes tabs and spaces in a way that depends on \ |
| 39 | how many spaces a tab is worth. |
| 40 | |
| 41 | To fix case 2, change all tabs to spaces by using Select All followed \ |
| 42 | by Untabify Region (both in the Edit menu).""" |
| 43 | |
| 44 | |
| 45 | class ScriptBinding: |
| 46 | |
| 47 | menudefs = [ |
| 48 | ('run', [None, |
| 49 | ('Check Module', '<<check-module>>'), |
| 50 | ('Run Module', '<<run-module>>'), ]), ] |
| 51 | |
| 52 | def __init__(self, editwin): |
| 53 | self.editwin = editwin |
| 54 | # Provide instance variables referenced by Debugger |
| 55 | # XXX This should be done differently |
| 56 | self.flist = self.editwin.flist |
| 57 | self.root = self.flist.root |
| 58 | |
| 59 | def check_module_event(self, event): |
| 60 | filename = self.getfilename() |
| 61 | if not filename: |
| 62 | return |
| 63 | if not self.tabnanny(filename): |
| 64 | return |
| 65 | self.checksyntax(filename) |
| 66 | |
| 67 | def tabnanny(self, filename): |
| 68 | f = open(filename, 'r') |
| 69 | try: |
| 70 | tabnanny.process_tokens(tokenize.generate_tokens(f.readline)) |
| 71 | except tokenize.TokenError, msg: |
| 72 | msgtxt, (lineno, start) = msg |
| 73 | self.editwin.gotoline(lineno) |
| 74 | self.errorbox("Tabnanny Tokenizing Error", |
| 75 | "Token Error: %s" % msgtxt) |
| 76 | return False |
| 77 | except tabnanny.NannyNag, nag: |
| 78 | # The error messages from tabnanny are too confusing... |
| 79 | self.editwin.gotoline(nag.get_lineno()) |
| 80 | self.errorbox("Tab/space error", indent_message) |
| 81 | return False |
| 82 | return True |
| 83 | |
| 84 | def checksyntax(self, filename): |
| 85 | self.shell = shell = self.flist.open_shell() |
| 86 | saved_stream = shell.get_warning_stream() |
| 87 | shell.set_warning_stream(shell.stderr) |
| 88 | f = open(filename, 'r') |
| 89 | source = f.read() |
| 90 | f.close() |
| 91 | if '\r' in source: |
| 92 | source = re.sub(r"\r\n", "\n", source) |
| 93 | source = re.sub(r"\r", "\n", source) |
| 94 | if source and source[-1] != '\n': |
| 95 | source = source + '\n' |
| 96 | text = self.editwin.text |
| 97 | text.tag_remove("ERROR", "1.0", "end") |
| 98 | try: |
| 99 | try: |
| 100 | # If successful, return the compiled code |
| 101 | return compile(source, filename, "exec") |
| 102 | except (SyntaxError, OverflowError), err: |
| 103 | try: |
| 104 | msg, (errorfilename, lineno, offset, line) = err |
| 105 | if not errorfilename: |
| 106 | err.args = msg, (filename, lineno, offset, line) |
| 107 | err.filename = filename |
| 108 | self.colorize_syntax_error(msg, lineno, offset) |
| 109 | except: |
| 110 | msg = "*** " + str(err) |
| 111 | self.errorbox("Syntax error", |
| 112 | "There's an error in your program:\n" + msg) |
| 113 | return False |
| 114 | finally: |
| 115 | shell.set_warning_stream(saved_stream) |
| 116 | |
| 117 | def colorize_syntax_error(self, msg, lineno, offset): |
| 118 | text = self.editwin.text |
| 119 | pos = "0.0 + %d lines + %d chars" % (lineno-1, offset-1) |
| 120 | text.tag_add("ERROR", pos) |
| 121 | char = text.get(pos) |
| 122 | if char and char in IDENTCHARS: |
| 123 | text.tag_add("ERROR", pos + " wordstart", pos) |
| 124 | if '\n' == text.get(pos): # error at line end |
| 125 | text.mark_set("insert", pos) |
| 126 | else: |
| 127 | text.mark_set("insert", pos + "+1c") |
| 128 | text.see(pos) |
| 129 | |
| 130 | def run_module_event(self, event): |
| 131 | """Run the module after setting up the environment. |
| 132 | |
| 133 | First check the syntax. If OK, make sure the shell is active and |
| 134 | then transfer the arguments, set the run environment's working |
| 135 | directory to the directory of the module being executed and also |
| 136 | add that directory to its sys.path if not already included. |
| 137 | |
| 138 | """ |
| 139 | filename = self.getfilename() |
| 140 | if not filename: |
| 141 | return |
| 142 | code = self.checksyntax(filename) |
| 143 | if not code: |
| 144 | return |
| 145 | shell = self.shell |
| 146 | interp = shell.interp |
| 147 | if PyShell.use_subprocess: |
| 148 | shell.restart_shell() |
| 149 | dirname = os.path.dirname(filename) |
| 150 | # XXX Too often this discards arguments the user just set... |
| 151 | interp.runcommand("""if 1: |
| 152 | _filename = %r |
| 153 | import sys as _sys |
| 154 | from os.path import basename as _basename |
| 155 | if (not _sys.argv or |
| 156 | _basename(_sys.argv[0]) != _basename(_filename)): |
| 157 | _sys.argv = [_filename] |
| 158 | import os as _os |
| 159 | _os.chdir(%r) |
| 160 | del _filename, _sys, _basename, _os |
| 161 | \n""" % (filename, dirname)) |
| 162 | interp.prepend_syspath(filename) |
| 163 | # XXX KBK 03Jul04 When run w/o subprocess, runtime warnings still |
| 164 | # go to __stderr__. With subprocess, they go to the shell. |
| 165 | # Need to change streams in PyShell.ModifiedInterpreter. |
| 166 | interp.runcode(code) |
| 167 | |
| 168 | def getfilename(self): |
| 169 | """Get source filename. If not saved, offer to save (or create) file |
| 170 | |
| 171 | The debugger requires a source file. Make sure there is one, and that |
| 172 | the current version of the source buffer has been saved. If the user |
| 173 | declines to save or cancels the Save As dialog, return None. |
| 174 | |
| 175 | If the user has configured IDLE for Autosave, the file will be |
| 176 | silently saved if it already exists and is dirty. |
| 177 | |
| 178 | """ |
| 179 | filename = self.editwin.io.filename |
| 180 | if not self.editwin.get_saved(): |
| 181 | autosave = idleConf.GetOption('main', 'General', |
| 182 | 'autosave', type='bool') |
| 183 | if autosave and filename: |
| 184 | self.editwin.io.save(None) |
| 185 | else: |
| 186 | reply = self.ask_save_dialog() |
| 187 | self.editwin.text.focus_set() |
| 188 | if reply == "ok": |
| 189 | self.editwin.io.save(None) |
| 190 | filename = self.editwin.io.filename |
| 191 | else: |
| 192 | filename = None |
| 193 | return filename |
| 194 | |
| 195 | def ask_save_dialog(self): |
| 196 | msg = "Source Must Be Saved\n" + 5*' ' + "OK to Save?" |
| 197 | mb = tkMessageBox.Message(title="Save Before Run or Check", |
| 198 | message=msg, |
| 199 | icon=tkMessageBox.QUESTION, |
| 200 | type=tkMessageBox.OKCANCEL, |
| 201 | default=tkMessageBox.OK, |
| 202 | master=self.editwin.text) |
| 203 | return mb.show() |
| 204 | |
| 205 | def errorbox(self, title, message): |
| 206 | # XXX This should really be a function of EditorWindow... |
| 207 | tkMessageBox.showerror(title, message, master=self.editwin.text) |
| 208 | self.editwin.text.focus_set() |