refactor stdout and stdin

thomasballinger · thomasballinger · commit eadd2e7abd93 · 2013-11-06T10:54:39.000-05:00
--HG--
branch : scroll-frontend
diff --git a/bpython/scrollfrontend/coderunner.py b/bpython/scrollfrontend/coderunner.py
@@ -21,12 +21,20 @@ def running(self):
         return self.source and self.code_thread
 
     def load_code(self, source):
+        """Prep code to be run"""
         self.source = source
         self.code_thread = None
 
-    def run_code(self, input=None):
+    def _unload_code(self):
+        """Called when done running code"""
+        self.source = None
+        self.code_thread = None
+        self.code_is_waiting = False
+
+    def run_code(self, for_code=None):
         """Returns Truthy values if code finishes, False otherwise
 
+        if for_code is provided, send that value to the code thread
         if source code is complete, returns "done"
         if source code is incomplete, returns "unfinished"
         """
@@ -38,49 +46,51 @@ def run_code(self, input=None):
         else:
             assert self.code_is_waiting
             self.code_is_waiting = False
-            self.responses_for_code_thread.put(input)
+            self.responses_for_code_thread.put(for_code)
 
         request = self.requests_from_code_thread.get()
-        if request[0] == 'done':
-            self.source = None
-            self.code_thread = None
-            self.code_is_waiting = False
-            return 'unfinished' if request[1] else 'done'
-        else:
-            method, args, kwargs = request
+        if request in ['wait', 'refresh']:
             self.code_is_waiting = True
-            if method:
-                method(*args, **kwargs)
+            if request == 'refresh':
                 self.stuff_a_refresh_request()
             return False
+        elif request in ['done', 'unfinished']:
+            self._unload_code()
+            return request
+        else:
+            raise ValueError("Not a valid request_from_code_thread value: %r" % request)
 
     def _blocking_run_code(self):
         unfinished = self.interp.runsource(self.source)
-        self.requests_from_code_thread.put(('done', unfinished))
-    def _blocking_wait_for(self, method=lambda: None, args=[], kwargs={}):
-        """The method the code would like to be called, or nothing
+        self.requests_from_code_thread.put('unfinished' if unfinished else 'done')
+
+    def wait_and_get_value(self):
+        """Return the argument passed in to .run_code(for_code)
 
         Nothing means calls to run_code must be...
-        does this thing even have a point? is it required for stdout.write?
         """
-        self.requests_from_code_thread.put((method, args, kwargs))
+        self.requests_from_code_thread.put('wait')
+        return self.responses_for_code_thread.get()
+
+    def refresh_and_get_value(self):
+        """Returns the argument passed in to .run_code(for_code) """
+        self.requests_from_code_thread.put('refresh')
         return self.responses_for_code_thread.get()
 
 class FakeOutput(object):
     def __init__(self, coderunner, please):
         self.coderunner = coderunner
         self.please = please
     def write(self, *args, **kwargs):
-        return self.coderunner._blocking_wait_for(self.please, args, kwargs)
+        self.please(*args, **kwargs)
+        return self.coderunner.refresh_and_get_value()
 
 if __name__ == '__main__':
     orig_stdout = sys.stdout
     orig_stderr = sys.stderr
     c = CodeRunner(stuff_a_refresh_request=lambda: orig_stdout.flush() or orig_stderr.flush())
     stdout = FakeOutput(c, orig_stdout.write)
-    stderr = FakeOutput(c, orig_stderr.write)
     sys.stdout = stdout
-    sys.stderr = stderr
     c.load_code('1 + 1')
     c.run_code()
     c.run_code()
diff --git a/bpython/scrollfrontend/repl.py b/bpython/scrollfrontend/repl.py
@@ -4,9 +4,6 @@
 import logging
 import code
 import threading
-import Queue
-from cStringIO import StringIO
-import traceback
 import subprocess
 import tempfile
 
@@ -79,14 +76,15 @@ def process_event(self, e):
             self.has_focus = False
             self.current_line = ''
             self.cursor_offset_in_line = 0
-            self.repl.coderunner.run_code(input=line)
+            #self.repl.coderunner.run_code(for_code=line)
+            self.repl.run_code_and_maybe_finish(for_code=line)
         else:
             self.repl.send_to_stdin(self.current_line)
 
     def readline(self):
         self.has_focus = True
         self.repl.send_to_stdin(self.current_line)
-        return self.coderunner._blocking_wait_for(None)
+        return self.coderunner.wait_and_get_value()
 
 
 class Repl(BpythonRepl):
@@ -196,7 +194,7 @@ def process_event(self, e):
 
         logging.debug("processing event %r", e)
         if isinstance(e, events.RefreshRequestEvent):
-            self.finish_command_if_done()
+            self.run_code_and_maybe_finish()
             return
         self.last_events.append(e)
         self.last_events.pop(0)
@@ -413,7 +411,6 @@ def push(self, line, insert_into_history=True):
         logging.debug('running %r in interpreter', self.buffer)
         code_to_run = '\n'.join(self.buffer)
         self.saved_indent = indent
-        self.saved_line = line
 
         #current line not added to display buffer if quitting #TODO I don't understand this comment
         if self.config.syntax:
@@ -433,11 +430,13 @@ def push(self, line, insert_into_history=True):
             self.cursor_offset_in_line = 0
 
         self.coderunner.load_code(code_to_run)
-        self.finish_command_if_done()
+        self.run_code_and_maybe_finish()
 
-    def finish_command_if_done(self):
-        r = self.coderunner.run_code()
+    def run_code_and_maybe_finish(self, for_code=None):
+        r = self.coderunner.run_code(for_code=for_code)
         if r:
+            logging.debug("----- Running finish command stuff -----")
+            logging.debug("run_code return value: %r", r)
             unfinished = r == 'unfinished'
             err = True #TODO implement this properly - via interp.write_error I suppose
 
@@ -462,7 +461,7 @@ def unhighlight_paren(self):
             logging.debug('trying to unhighlight a paren on line %r', lineno)
             logging.debug('with these tokens: %r', saved_tokens)
             new = bpythonparse(format(saved_tokens, self.formatter))
-            self.display_buffer[lineno][:len(new)] = new
+            self.display_buffer[lineno] = self.display_buffer[lineno].setslice(0, len(new), new)
 
 
     ## formatting, output
@@ -526,9 +525,10 @@ def display_line_with_prompt(self):
 
     @property
     def current_cursor_line(self):
-
-        return (self.current_output_line +
+        value = (self.current_output_line +
                 '' if self.coderunner.running else self.display_line_with_prompt)
+        logging.debug('current cursor line: %r', value)
+        return value
 
     @property
     def current_output_line(self):
