Allow prompt_toolkit for input (#64)

Author: rocky

pyproject.toml

@@ -56,6 +56,9 @@ dev = [
     "pre-commit",
     "pytest",
 ]
+full = [
+    "prompt-toolkit",    # Alternate interface, akin to GNU Readline
+]
 
 [project.scripts]
 trepan3k   = "trepan.__main__:main"

test/unit/cmdhelper.py

@@ -74,9 +74,9 @@ def no_history():
     return d, cp
 
 
-def readline_yes(prompt=None) -> str:
+def readline_yes(prompt=None, use_raw: bool=False) -> str:
     return "Y"
 
 
-def readline_no(prompt=None) -> str:
+def readline_no(prompt=None, use_raw: bool=False) -> str:
     return "N"

test/unit/interfaces/test_intf_user.py

@@ -24,7 +24,7 @@ def no_history():
 
     for s in ["y", "Y", "Yes", "  YES  "]:
 
-        def readline_with_prompt(prompt=None):
+        def readline_with_prompt(prompt=None, use_raw: bool=False):
             return readline(s)
 
         u.input.readline = readline_with_prompt
@@ -33,7 +33,7 @@ def readline_with_prompt(prompt=None):
         pass
     for s in ["n", "N", "No", "  NO  "]:
 
-        def readline_with_prompt(prompt=None):
+        def readline_with_prompt(prompt=None, use_raw: bool=False):
             return readline(s)
 
         u.input.readline = readline_with_prompt

trepan/debugger.py

@@ -99,10 +99,13 @@ def completer(text: str, state):
 
         # How are I/O for this debugger handled? This should
         # be set before calling DebuggerCore.
-        interface_opts = {
-            "complete": completer,
+        interface_opts = opts.get("interface_opts", {
             "debugger_name": "trepan3k",
-        }
+            "readline": opts.get("readline")
+        })
+        if "complete" not in interface_opts:
+            interface_opts["complete"] = completer
+
         # FIXME when I pass in opts=opts things break
 
         inp = opts.get("input", None) if opts else None

trepan/inout/input.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-#   Copyright (C) 2009-2010, 2013-2015, 2017, 2023 Rocky Bernstein
+#   Copyright (C) 2009-2010, 2013-2015, 2017, 2023-2024 Rocky Bernstein
 #   <rocky@gnu.org>
 #
 #   This program is free software: you can redistribute it and/or modify
@@ -20,79 +20,74 @@
 import io
 import sys
 
-from trepan import misc as Mmisc
 from trepan.inout import base as Mbase
 
-
-def readline_importable() -> bool:
-    try:
-        import readline  # NOQA
-
-        return True
-    except ImportError:
-        return False
-    return  # Not reached
-
+try:
+    from prompt_toolkit import PromptSession, HTML
+    from prompt_toolkit.styles import Style
+    from prompt_toolkit.history import FileHistory
+except:
+    PromptSession = lambda history: None
+    FileHistory = lambda history: None
+    HTML = lambda string: string
 
 class DebuggerUserInput(Mbase.DebuggerInputBase):
     """Debugger input connected to what we think of as a end-user input
     as opposed to a relay mechanism to another process. Input could be
     interactive terminal, but it might be file input."""
 
     def __init__(self, inp=None, opts=None):
-        self.input = inp or sys.stdin
-        self.line_edit = None  # Our name for GNU readline capability
-        self.open(self.input, opts)
+
+        if opts and opts.get("readline") == "prompt_toolkit":
+            self.session = PromptSession(history=FileHistory(opts.get("histfile")))
+            self.input = self.session.input
+            self.session.enable_history_search = True
+            self.line_edit = True
+            self.closed = False
+            self.use_raw = False
+        else:
+            self.session = None
+            self.input = inp or sys.stdin
+            self.line_edit = None  # Our name for GNU readline capability
+            self.open(self.input, opts)
+
         return
 
     def close(self):
         self.input.close()
         self.closed = True
         return
 
-    DEFAULT_OPEN_READ_OPTS = {
-        "use_raw": True,
-        "try_readline": True,
-    }
-
     def use_history(self):
-        return self.use_raw and readline_importable()
+        return self.use_raw
 
     def open(self, inp, opts={}):
         """Use this to set where to read from.
 
-        Set opts['try_lineedit'] if you want this input to interact
-        with GNU-like readline library. By default, we will assume to
-        try importing and using readline. If readline is not
-        importable, line editing is not available whether or not
-        opts['try_readline'] is set.
-
         Set opts['use_raw'] if input should use Python's use_raw(). If
         however 'inp' is a string and opts['use_raw'] is not set, we
         will assume no raw output. Note that an individual readline
         may override the setting.
         """
-        get_option = lambda key: Mmisc.option_set(
-            opts, key, self.DEFAULT_OPEN_READ_OPTS
-        )
         if (
             isinstance(inp, io.TextIOWrapper)
             or isinstance(inp, io.StringIO)
             or hasattr(inp, "isatty")
             and inp.isatty()
         ):
-            self.use_raw = get_option("use_raw")
+            self.use_raw = opts and opts.get("use_raw", False)
         elif isinstance(inp, "string".__class__):  # FIXME
             if opts is None:
                 self.use_raw = False
             else:
-                self.use_raw = get_option("use_raw")
+                self.use_raw = opts.get("use_raw", False)
                 pass
             inp = open(inp, "r")
         else:
             raise IOError("Invalid input type (%s) for %s" % (type(inp), inp))
         self.input = inp
-        self.line_edit = get_option("try_readline") and readline_importable()
+        self.line_edit = bool(opts and opts.get("readline"))
+
         self.closed = False
         return
 
@@ -107,6 +102,12 @@ def readline(self, use_raw=None, prompt=""):
         initialization is used.
         """
         # FIXME we don't do command completion.
+        if self.session:
+            # Using prompt_toolkit
+            html_prompt = HTML(f"<u>{prompt.strip()}</u> ")
+            line = self.session.prompt(html_prompt, style=Style.from_dict({"": ""}))
+            return line.rstrip("\n")
+
         if use_raw is None:
             use_raw = self.use_raw
             pass
@@ -131,7 +132,6 @@ def readline(self, use_raw=None, prompt=""):
 
 # Demo
 if __name__ == "__main__":
-    print("readline importable: ", readline_importable())
     inp = DebuggerUserInput(__file__)
     line = inp.readline()
     print(line)

trepan/inout/scriptin.py

@@ -30,6 +30,8 @@ def __init__(self, inp, opts=None):
         self.input = None
         self.line_edit = False  # Our name for GNU readline capability
         self.name = None
+        self.opts = opts
+        self.session = None
         self.open(inp, opts)
         return
 

trepan/inout/stringarray.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-#   Copyright (C) 2009, 2013-2014, 2023 Rocky Bernstein
+#   Copyright (C) 2009, 2013-2014, 2023-2024 Rocky Bernstein
 #   <rocky@gnu.org>
 #
 #   This program is free software: you can redistribute it and/or modify
@@ -27,8 +27,10 @@ class StringArrayInput(Mbase.DebuggerInputBase):
     even simpler."""
 
     def __init__(self, inp=[], opts=None):
-        self.input = inp
         self.closed = False
+        self.input = inp
+        self.opts = opts
+        self.session = None
         return
 
     def close(self):

trepan/interfaces/user.py

@@ -43,33 +43,33 @@
         write_history_file,
     )
 except ImportError:
-    pass
+        pass
 
 
 class UserInterface(TrepanInterface):
     """Interface when communicating with the user in the same
     process as the debugged program."""
 
     def __init__(self, inp=None, out=None, opts={}):
-        user_opts = DEFAULT_USER_SETTINGS.copy()
-        user_opts.update(opts)
+        self.user_opts = DEFAULT_USER_SETTINGS.copy()
+        self.user_opts.update(opts)
 
         atexit.register(self.finalize)
         self.interactive = True  # Or at least so we think initially
-        self.input = inp or DebuggerUserInput()
+        self.input = inp or DebuggerUserInput(self.user_opts.get("input", {}), self.user_opts)
         self.output = out or DebuggerUserOutput()
-        self.debugger_name = user_opts.get("debugger_name", "trepan3k")
+        self.debugger_name = self.user_opts.get("debugger_name", "trepan3k")
 
         if self.input.use_history():
-            self.complete = user_opts["complete"]
+            self.complete = self.user_opts["complete"]
             if self.complete:
                 parse_and_bind("tab: complete")
                 set_completer(self.complete)
                 pass
-            self.histfile = user_opts["histfile"]
+            self.histfile = self.user_opts["histfile"]
             if self.histfile:
                 try:
-                    read_history_file(histfile)
+                    read_history_file(self.histfile)
                 except IOError:
                     pass
                 except Exception:
@@ -158,16 +158,14 @@ def read_command(self, prompt=""):
         return line
 
     def readline(self, prompt=""):
+        use_raw = hasattr(self.input, "use_raw") and self.input.use_raw
         if (
-            hasattr(self.input, "use_raw")
-            and not self.input.use_raw
-            and prompt
-            and len(prompt) > 0
+            use_raw and prompt and len(prompt) > 0 or not self.readline == "prompt_toolkit"
         ):
             self.output.write(prompt)
             self.output.flush()
             pass
-        return self.input.readline(prompt=prompt)
+        return self.input.readline(prompt=prompt, use_raw=use_raw)
 
     pass
 

trepan/options.py

@@ -27,6 +27,18 @@
 from trepan.inout.output import DebuggerUserOutput
 from trepan.lib.file import readable
 
+try:
+    import prompt_toolkit  # NOQA
+    have_prompt_toolkit = True
+except ImportError:
+    have_prompt_toolkit = False
+
+try:
+    import prompt_toolkit  # NOQA
+    have_gnu_readline = True
+except ImportError:
+    have_gnu_readline = False
+
 
 def default_configfile(base_filename: str) -> str:
     """Return fully expanded configuration filename location for
@@ -313,6 +325,39 @@ def process_options(pkg_version: str, sys_argv: str, option_list=None):
         "--annotate", default=0, type="int", help="Use annotations to work inside emacs"
     )
 
+    readline = None
+    if have_gnu_readline:
+        optparser.add_option(
+            "--gnu-readline",
+            dest="use_gnu_readline",
+            action="store_true",
+            default=True,
+            help="Try using GNU-Readline",
+        )
+        optparser.add_option(
+            "--no-gnu-readline",
+            dest="use_gnu_readline",
+            action="store_false",
+            default=True,
+            help="Do not use GNU-Readline",
+        )
+    if have_prompt_toolkit:
+        optparser.add_option(
+            "--prompt-toolkit",
+            dest="use_prompt_toolkit",
+            action="store_true",
+            default=True,
+            help="Try using prompt_toolkit",
+        )
+        optparser.add_option(
+            "--no-prompt-toolkit",
+            dest="use_prompt_toolkit",
+            action="store_false",
+            default=True,
+            help="Do not use prompt_toolkit",
+        )
+
+
     # Set up to stop on the first non-option because that's the name
     # of the script to be debugged on arguments following that are
     # that scripts options that should be left untouched.  We would
@@ -323,7 +368,20 @@ def process_options(pkg_version: str, sys_argv: str, option_list=None):
 
     sys.argv = list(sys_argv)
     (opts, sys.argv) = optparser.parse_args(sys_argv[1:])
-    dbg_opts = {"from_ipython": opts.from_ipython}
+    if hasattr(opts, "use_prompt_toolkit") and opts.use_prompt_toolkit:
+        readline = "prompt_toolkit"
+    elif hasattr(opts, "use_gnu_readline") and opts.use_gnu_readline:
+        readline = "gnu_readline"
+    else:
+        readline = None
+
+    dbg_opts = {
+        "from_ipython": opts.from_ipython,
+        "interface_opts": {
+            "readline": readline,
+            "debugger_name": "trepan3k",
+        }
+    }
 
     # Handle debugger startup command files: --nx (-n) and --command.
     dbg_initfiles = []

trepan/processor/cmdproc.py

@@ -270,7 +270,8 @@ def set_prompt(self, prompt="trepan3k"):
             pass
         self.prompt_str = f"{'(' * self.debug_nest}{prompt}{')' * self.debug_nest}"
         highlight = self.debugger.settings["highlight"]
-        if highlight and highlight in ("light", "dark"):
+        using_prompt_toolkit = self.intf[-1].input.session is not None
+        if not using_prompt_toolkit and highlight and highlight in ("light", "dark"):
             self.prompt_str = colorize("underline", self.prompt_str)
         self.prompt_str += " "