Rename {main,code,request}_greenlet to *_context

sebastinas · sebastinas · commit 2b8c30b94690 · 2016-12-19T22:24:25.000+01:00
diff --git a/bpython/curtsiesfrontend/coderunner.py b/bpython/curtsiesfrontend/coderunner.py
@@ -61,13 +61,13 @@ class CodeRunner(object):
     """Runs user code in an interpreter.
 
     Running code requests a refresh by calling
-    request_from_main_greenlet(force_refresh=True), which
+    request_from_main_context(force_refresh=True), which
     suspends execution of the code and switches back to the main greenlet
 
     After load_code() is called with the source code to be run,
     the run_code() method should be called to start running the code.
     The running code may request screen refreshes and user input
-    by calling request_from_main_greenlet.
+    by calling request_from_main_context.
     When this are called, the running source code cedes
     control, and the current run_code() method call returns.
 
@@ -93,32 +93,32 @@ def __init__(self, interp=None, request_refresh=lambda: None):
         """
         self.interp = interp or code.InteractiveInterpreter()
         self.source = None
-        self.main_greenlet = greenlet.getcurrent()
-        self.code_greenlet = None
+        self.main_context = greenlet.getcurrent()
+        self.code_context = None
         self.request_refresh = request_refresh
         # waiting for response from main thread
         self.code_is_waiting = False
         # sigint happened while in main thread
-        self.sigint_happened_in_main_greenlet = False
+        self.sigint_happened_in_main_context = False
         self.orig_sigint_handler = None
 
     @property
     def running(self):
         """Returns greenlet if code has been loaded greenlet has been
         started"""
-        return self.source and self.code_greenlet
+        return self.source and self.code_context
 
     def load_code(self, source):
         """Prep code to be run"""
         assert self.source is None, "you shouldn't load code when some is " \
             "already running"
         self.source = source
-        self.code_greenlet = None
+        self.code_context = None
 
     def _unload_code(self):
         """Called when done running code"""
         self.source = None
-        self.code_greenlet = None
+        self.code_context = None
         self.code_is_waiting = False
 
     def run_code(self, for_code=None):
@@ -128,21 +128,21 @@ def run_code(self, for_code=None):
         if source code is complete, returns "done"
         if source code is incomplete, returns "unfinished"
         """
-        if self.code_greenlet is None:
+        if self.code_context is None:
             assert self.source is not None
-            self.code_greenlet = greenlet.greenlet(self._blocking_run_code)
+            self.code_context = greenlet.greenlet(self._blocking_run_code)
             self.orig_sigint_handler = signal.getsignal(signal.SIGINT)
             signal.signal(signal.SIGINT, self.sigint_handler)
-            request = self.code_greenlet.switch()
+            request = self.code_context.switch()
         else:
             assert self.code_is_waiting
             self.code_is_waiting = False
             signal.signal(signal.SIGINT, self.sigint_handler)
-            if self.sigint_happened_in_main_greenlet:
-                self.sigint_happened_in_main_greenlet = False
-                request = self.code_greenlet.switch(SigintHappened)
+            if self.sigint_happened_in_main_context:
+                self.sigint_happened_in_main_context = False
+                request = self.code_context.switch(SigintHappened)
             else:
-                request = self.code_greenlet.switch(for_code)
+                request = self.code_context.switch(for_code)
 
         logger.debug('request received from code was %r', request)
         if not isinstance(request, RequestFromCodeRunner):
@@ -165,13 +165,13 @@ def run_code(self, for_code=None):
     def sigint_handler(self, *args):
         """SIGINT handler to use while code is running or request being
         fulfilled"""
-        if greenlet.getcurrent() is self.code_greenlet:
+        if greenlet.getcurrent() is self.code_context:
             logger.debug('sigint while running user code!')
             raise KeyboardInterrupt()
         else:
             logger.debug('sigint while fulfilling code request sigint handler '
                          'running!')
-            self.sigint_happened_in_main_greenlet = True
+            self.sigint_happened_in_main_context = True
 
     def _blocking_run_code(self):
         try:
@@ -180,15 +180,15 @@ def _blocking_run_code(self):
             return SystemExitRequest(e.args)
         return Unfinished() if unfinished else Done()
 
-    def request_from_main_greenlet(self, force_refresh=False):
+    def request_from_main_context(self, force_refresh=False):
         """Return the argument passed in to .run_code(for_code)
 
         Nothing means calls to run_code must be... ???
         """
         if force_refresh:
-            value = self.main_greenlet.switch(Refresh())
+            value = self.main_context.switch(Refresh())
         else:
-            value = self.main_greenlet.switch(Wait())
+            value = self.main_context.switch(Wait())
         if value is SigintHappened:
             raise KeyboardInterrupt()
         return value
@@ -211,7 +211,7 @@ def write(self, s, *args, **kwargs):
         if not py3 and isinstance(s, str):
             s = s.decode(getpreferredencoding(), 'ignore')
         self.on_write(s, *args, **kwargs)
-        return self.coderunner.request_from_main_greenlet(force_refresh=True)
+        return self.coderunner.request_from_main_context(force_refresh=True)
 
     # Some applications which use curses require that sys.stdout
     # have a method called fileno. One example is pwntools. This
diff --git a/bpython/curtsiesfrontend/interaction.py b/bpython/curtsiesfrontend/interaction.py
@@ -40,8 +40,8 @@ def __init__(self,
         self.permanent_stack = []
         if permanent_text:
             self.permanent_stack.append(permanent_text)
-        self.main_greenlet = greenlet.getcurrent()
-        self.request_greenlet = None
+        self.main_context = greenlet.getcurrent()
+        self.request_context = None
         self.request_refresh = request_refresh
         self.schedule_refresh = schedule_refresh
 
@@ -76,13 +76,13 @@ def process_event(self, e):
         assert self.in_prompt or self.in_confirm or self.waiting_for_refresh
         if isinstance(e, RefreshRequestEvent):
             self.waiting_for_refresh = False
-            self.request_greenlet.switch()
+            self.request_context.switch()
         elif isinstance(e, events.PasteEvent):
             for ee in e.events:
                 # strip control seq
                 self.add_normal_character(ee if len(ee) == 1 else ee[-1])
         elif e in ['<ESC>'] or isinstance(e, events.SigIntEvent):
-            self.request_greenlet.switch(False)
+            self.request_context.switch(False)
             self.escape()
         elif e in edit_keys:
             self.cursor_offset_in_line, self._current_line = edit_keys[e](
@@ -94,12 +94,12 @@ def process_event(self, e):
         elif self.in_prompt and e in ("\n", "\r", "<Ctrl-j>", "Ctrl-m>"):
             line = self._current_line
             self.escape()
-            self.request_greenlet.switch(line)
+            self.request_context.switch(line)
         elif self.in_confirm:
             if e in ('y', 'Y'):
-                self.request_greenlet.switch(True)
+                self.request_context.switch(True)
             else:
-                self.request_greenlet.switch(False)
+                self.request_context.switch(False)
             self.escape()
         else:  # add normal character
             self.add_normal_character(e)
@@ -140,26 +140,26 @@ def should_show_message(self):
 
     # interaction interface - should be called from other greenlets
     def notify(self, msg, n=3, wait_for_keypress=False):
-        self.request_greenlet = greenlet.getcurrent()
+        self.request_context = greenlet.getcurrent()
         self.message_time = n
         self.message(msg, schedule_refresh=wait_for_keypress)
         self.waiting_for_refresh = True
         self.request_refresh()
-        self.main_greenlet.switch(msg)
+        self.main_context.switch(msg)
 
     # below Really ought to be called from greenlets other than main because
     # they block
     def confirm(self, q):
         """Expected to return True or False, given question prompt q"""
-        self.request_greenlet = greenlet.getcurrent()
+        self.request_context = greenlet.getcurrent()
         self.prompt = q
         self.in_confirm = True
-        return self.main_greenlet.switch(q)
+        return self.main_context.switch(q)
 
     def file_prompt(self, s):
         """Expected to return a file name, given """
-        self.request_greenlet = greenlet.getcurrent()
+        self.request_context = greenlet.getcurrent()
         self.prompt = s
         self.in_prompt = True
-        result = self.main_greenlet.switch(s)
+        result = self.main_context.switch(s)
         return result
diff --git a/bpython/curtsiesfrontend/repl.py b/bpython/curtsiesfrontend/repl.py
@@ -128,7 +128,7 @@ def process_event(self, e):
             self.cursor_offset, self.current_line = self.rl_char_sequences[e](
                 self.cursor_offset, self.current_line)
         elif isinstance(e, events.SigIntEvent):
-            self.coderunner.sigint_happened_in_main_greenlet = True
+            self.coderunner.sigint_happened_in_main_context = True
             self.has_focus = False
             self.current_line = ''
             self.cursor_offset = 0
@@ -179,7 +179,7 @@ def add_input_character(self, e):
     def readline(self):
         self.has_focus = True
         self.repl.send_to_stdin(self.current_line)
-        value = self.coderunner.request_from_main_greenlet()
+        value = self.coderunner.request_from_main_context()
         self.readline_results.append(value)
         return value
 
