Create more generic dialog and change keybinding

python · terryjreedy · Jun 18, 2019 · Jun 3, 2019 · Jun 3, 2019 · Jun 3, 2019
commit dbdd58076c8a04b58d2c00bafd90336429e1abd3
diff --git a/Doc/library/idle.rst b/Doc/library/idle.rst
@@ -232,12 +232,16 @@ Run Module
    This is similar to executing a file with ``python -i file`` at a command
    line.
 
-.. _run-module-with-arguments:
+.. _run-custom:
+
+Run Custom
+   Same as :ref:`Run Module <run-module>`, except allow customization of the
+   environment used when running the module.
+
+   The *Command Line Arguments* are passed to the module like :data:`sys.argv`
+   arguments would be from the command line.  This is similar to executing a
+   file with ``python -i file [args]``.
 
-Run Module with Arguments
-   Same as :ref:`Run Module <run-module>`, except allow entry of the
-   command line arguments that are passed to the module. This is similar
-   to executing a file with ``python -i file [args]`` at a command line.
 
 Shell menu (Shell window only)
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

diff --git a/Lib/idlelib/config-keys.def b/Lib/idlelib/config-keys.def
@@ -63,7 +63,7 @@ force-open-calltip= <Control-Key-backslash>
 format-paragraph= <Alt-Key-q>
 flash-paren= <Control-Key-0>
 run-module= <Key-F5>
-run-module-arguments= <Key-F7>
+run-custom= <Shift-Key-F5>
 check-module= <Alt-Key-x>
 zoom-height= <Alt-Key-2>
 
@@ -123,7 +123,7 @@ force-open-calltip= <Control-Key-backslash>
 format-paragraph= <Alt-Key-q>
 flash-paren= <Control-Key-0>
 run-module= <Key-F5>
-run-module-arguments= <Key-F7>
+run-custom= <Shift-Key-F5>
 check-module= <Alt-Key-x>
 zoom-height= <Alt-Key-2>
 
@@ -183,7 +183,7 @@ force-open-calltip= <Control-Key-backslash>
 format-paragraph= <Alt-Key-q>
 flash-paren= <Control-Key-0>
 run-module= <Key-F5>
-run-module-arguments= <Key-F7>
+run-custom= <Shift-Key-F5>
 check-module= <Alt-Key-x>
 zoom-height= <Alt-Key-2>
 
@@ -243,7 +243,7 @@ force-open-calltip= <Control-Key-backslash>
 format-paragraph= <Option-Key-q>
 flash-paren= <Control-Key-0>
 run-module= <Key-F5>
-run-module-arguments= <Key-F7>
+run-custom= <Shift-Key-F5>
 check-module= <Option-Key-x>
 zoom-height= <Option-Key-0>
 
@@ -304,6 +304,6 @@ force-open-calltip= <Control-Key-backslash>
 format-paragraph= <Option-Key-q>
 flash-paren= <Control-Key-0>
 run-module= <Key-F5>
-run-module-arguments= <Key-F7>
+run-custom= <Shift-Key-F5>
 check-module= <Option-Key-x>
 zoom-height= <Option-Key-0>
diff --git a/Lib/idlelib/config.py b/Lib/idlelib/config.py
@@ -658,7 +658,7 @@ def GetCoreKeys(self, keySetName=None):
             '<<flash-paren>>': ['<Control-Key-0>'],
             '<<format-paragraph>>': ['<Alt-Key-q>'],
             '<<run-module>>': ['<Key-F5>'],
-            '<<run-module-arguments>>': ['<Key-F7>'],
+            '<<run-custom>>': ['<Shift-Key-F5>'],
             '<<check-module>>': ['<Alt-Key-x>'],
             '<<zoom-height>>': ['<Alt-Key-2>'],
             }

diff --git a/Lib/idlelib/editor.py b/Lib/idlelib/editor.py
@@ -304,7 +304,7 @@ def __init__(self, flist=None, filename=None, key=None, root=None):
         scriptbinding = ScriptBinding(self)
         text.bind("<<check-module>>", scriptbinding.check_module_event)
         text.bind("<<run-module>>", scriptbinding.run_module_event)
-        text.bind("<<run-module-arguments>>", scriptbinding.run_module_arguments_event)
+        text.bind("<<run-custom>>", scriptbinding.run_custom_event)
         text.bind("<<do-rstrip>>", self.Rstrip(self).do_rstrip)
         ctip = self.Calltip(self)
         text.bind("<<try-open-calltip>>", ctip.try_open_calltip_event)

diff --git a/Lib/idlelib/idle_test/htest.py b/Lib/idlelib/idle_test/htest.py
@@ -108,10 +108,9 @@ def _wrapper(parent):  # htest #
            "The default color scheme is in idlelib/config-highlight.def"
     }
 
-CommandLineArgs_spec = {
+CustomRun_spec = {
     'file': 'query',
-    'kwds': {'title': 'Command Line Args',
-             'message': 'Enter command line arguments',
+    'kwds': {'title': 'Custom Run Args',
              '_htest': True},
     'msg': "Enter with <Return> or [Ok].  Print valid entry to Shell\n"
            "Arguments are parsed into a list\n"

diff --git a/Lib/idlelib/idle_test/test_query.py b/Lib/idlelib/idle_test/test_query.py
@@ -242,11 +242,11 @@ def test_entry_ok_helpsource(self):
                 self.assertEqual(dialog.entry_ok(), result)
 
 
-class CommandLineArgsTest(unittest.TestCase):
-    "Test CommandLineArgs subclass of Query."
+class CustomRunCLIargsokTest(unittest.TestCase):
+    "Test cli_ok method of the CustomRun subclass of Query."
 
-    class Dummy_CommandLineArgs:
-        entry_ok = query.CommandLineArgs.entry_ok  # Function being tested.
+    class Dummy_CustomRun:
+        cli_args_ok = query.CustomRun.cli_args_ok  # Function being tested.
         entry = Var()
         entry_error = {}
         def __init__(self, dummy_entry):
@@ -256,22 +256,43 @@ def showerror(self, message):
             self.entry_error['text'] = message
 
     def test_blank_args(self):
-        dialog = self.Dummy_CommandLineArgs(' ')
-        self.assertEqual(dialog.entry_ok(), None)
+        dialog = self.Dummy_CustomRun(' ')
+        self.assertEqual(dialog.cli_args_ok(), None)
         self.assertIn('no arguments', dialog.entry_error['text'])
-        self.assertIn('no arguments', dialog.entry_error['text'])
+        self.assertRegex(r'(?i)no arguments', dialog.entry_error['text'])
-        self.assertIn('no arguments', dialog.entry_error['text'])
+        self.assertRegex(r'(?i)no arguments', dialog.entry_error['text'])
 
     def test_invalid_args(self):
-        dialog = self.Dummy_CommandLineArgs("'no-closing-quote")
-        self.assertEqual(dialog.entry_ok(), None)
+        dialog = self.Dummy_CustomRun("'no-closing-quote")
+        self.assertEqual(dialog.cli_args_ok(), None)
         self.assertIn('No closing', dialog.entry_error['text'])
 
     def test_good_args(self):
-        dialog = self.Dummy_CommandLineArgs('-n 10 --verbose -p /path --name "my name"')
-        self.assertEqual(dialog.entry_ok(),
+        dialog = self.Dummy_CustomRun('-n 10 --verbose -p /path --name "my name"')
+        self.assertEqual(dialog.cli_args_ok(),
                          ['-n', '10', '--verbose', '-p', '/path', '--name', 'my name'])
         self.assertEqual(dialog.entry_error['text'], '')
 
 
+class CustomRunEntryokTest(unittest.TestCase):
+    "Test entry_ok method of the CustomRun subclass of Query."
+
+    class Dummy_CustomRun:
+        entry_ok = query.CustomRun.entry_ok
+        entry_error = {}
+        def cli_args_ok(self):
+            return self.cli_args
+        def restart_ok(self):
+            return self.restart
+
+    def test_entry_ok_customrun(self):
+        dialog = self.Dummy_CustomRun()
+        for dialog.restart in {True, False}:
+            for cli_args, result in ((None, None),
+                                     ('my arg', ('my arg', dialog.restart))):
+                with self.subTest():
-                with self.subTest():
+                with self.subTest(restart=dialog.restart, cli_args=cli_args):
-                with self.subTest():
+                with self.subTest(restart=dialog.restart, cli_args=cli_args):
+                    dialog.cli_args = cli_args
+                    self.assertEqual(dialog.entry_ok(), result)
+
+
 # GUI TESTS
 
 class QueryGuiTest(unittest.TestCase):
@@ -378,7 +399,7 @@ def test_click_help_source(self):
         del root
 
 
-class CommandLineArgsGuiTest(unittest.TestCase):
+class CustomRunGuiTest(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
@@ -387,11 +408,10 @@ def setUpClass(cls):
     def test_click_args(self):
         root = Tk()
         root.withdraw()
-        dialog =  query.CommandLineArgs(root, 'Title', 'message', _utest=True)
-        Equal = self.assertEqual
+        dialog =  query.CustomRun(root, 'Title', _utest=True)
         dialog.entry.insert(0, 'okay')
         dialog.button_ok.invoke()
-        self.assertEqual(dialog.result, ['okay'])
+        self.assertEqual(dialog.result, (['okay'], True))
         del dialog
         root.destroy()
         del root

diff --git a/Lib/idlelib/mainmenu.py b/Lib/idlelib/mainmenu.py
@@ -76,7 +76,7 @@
    ('Python Shell', '<<open-python-shell>>'),
    ('C_heck Module', '<<check-module>>'),
    ('R_un Module', '<<run-module>>'),
-   ('Run Module with _Arguments', '<<run-module-arguments>>'),
+   ('Run _Custom', '<<run-custom>>'),
    ]),
 
  ('shell', [

diff --git a/Lib/idlelib/query.py b/Lib/idlelib/query.py
@@ -24,8 +24,8 @@
 import shlex
 from sys import executable, platform  # Platform is set for one test.
 
-from tkinter import Toplevel, StringVar, W, E, S
-from tkinter.ttk import Frame, Button, Entry, Label
+from tkinter import Toplevel, StringVar, BooleanVar, W, E, S
+from tkinter.ttk import Frame, Button, Entry, Label, Checkbutton
 from tkinter import filedialog
 from tkinter.font import Font
 
@@ -84,7 +84,7 @@ def __init__(self, parent, title, message, *, text0='', used_names={},
             self.deiconify()  # Unhide now that geometry set.
             self.wait_window()
 
-    def create_widgets(self):  # Call from override, if any.
+    def create_widgets(self, ok_text='OK'):  # Call from override, if any.
         # Bind to self widgets needed for entry_ok or unittest.
         self.frame = frame = Frame(self, padding=10)
         frame.grid(column=0, row=0, sticky='news')
@@ -100,7 +100,7 @@ def create_widgets(self):  # Call from override, if any.
         self.entry_error = Label(frame, text=' ', foreground='red',
                                  font=self.error_font)
         self.button_ok = Button(
-                frame, text='OK', default='active', command=self.ok)
+                frame, text=ok_text, default='active', command=self.ok)
         self.button_cancel = Button(
                 frame, text='Cancel', command=self.cancel)
 
@@ -303,16 +303,36 @@ def entry_ok(self):
         path = self.path_ok()
         return None if name is None or path is None else (name, path)
 
-class CommandLineArgs(Query):
-    "Get a list of parsed command line arguments."
-    # Used in runscript.run_module_arguments_event
+class CustomRun(Query):
+    "Get arguments for custom run module."
+    # Used in runscript.run_custom_event
 
-    def __init__(self, parent, title, message, *, _htest=False, _utest=False):
-        super().__init__(parent, title, message, _htest=_htest, _utest=_utest)
+    def __init__(self, parent, title, *, cli_args='',
+                 _htest=False, _utest=False):
+        """Get command line args for custom run environment.
 
-    def entry_ok(self):
-        "Return list of parsed arguments or None."
-        self.entry_error['text'] = ''
+        User enters the command line arugments for running the file.
+        """
+        message = 'Command Line Arguments:'
+        super().__init__(
+                parent, title, message, text0=cli_args,
+                _htest=_htest, _utest=_utest)
+
+    def create_widgets(self):
+        super().create_widgets(ok_text='Run')
+        frame = self.frame
+        self.restartvar = BooleanVar(self, value=True)
+        restart = Checkbutton(frame, variable=self.restartvar, onvalue=True,
+                              offvalue=False, text='Restart shell')
+        self.args_error = Label(frame, text=' ', foreground='red',
+                                font=self.error_font)
+
+        restart.grid(column=0, row=4, columnspan=3, padx=5, sticky='w')
+        self.args_error.grid(column=0, row=12, columnspan=3, padx=5,
+                             sticky='we')
+
+    def cli_args_ok(self):
+        "Validity check and parsing for command line arguments."
         cli_args = self.entry.get().strip()
         if not cli_args:
             self.showerror('no arguments specified.')
@@ -324,10 +344,20 @@ def entry_ok(self):
             return None
         return lex
 
+    def restart_ok(self):
+        return self.restartvar.get()
+
+    def entry_ok(self):
+        "Return apparently valid (lex, restart) or None"
+        self.entry_error['text'] = ''
+        lex = self.cli_args_ok()
+        restart = self.restart_ok()
+        return None if not lex else (lex, restart)
+
 
 if __name__ == '__main__':
     from unittest import main
     main('idlelib.idle_test.test_query', verbosity=2, exit=False)
 
     from idlelib.idle_test.htest import run
-    run(Query, HelpSource, CommandLineArgs)
+    run(Query, HelpSource, CustomRun)
diff --git a/Lib/idlelib/runscript.py b/Lib/idlelib/runscript.py
@@ -18,7 +18,7 @@
 from idlelib.config import idleConf
 from idlelib import macosx
 from idlelib import pyshell
-from idlelib.query import CommandLineArgs
+from idlelib.query import CustomRun
 
 indent_message = """Error: Inconsistent indentation detected!
 
@@ -114,16 +114,14 @@ def run_module_event(self, event):
         else:
             return self._run_module_event(event)
 
-    def run_module_arguments_event(self, event):
-        cli_args = CommandLineArgs(
-            event.widget, "Run with Arguments",
-            "Command line argunments:").result
+    def run_custom_event(self, event):
+        run_args = CustomRun(event.widget, "Customize Run").result
         # User cancelled.
-        if not cli_args:
+        if not run_args:
             return 'break'
-        return self._run_module_event(event, cli_args)
+        return self._run_module_event(event, cli_args=run_args[0], restart=run_args[1])
 
-    def _run_module_event(self, event, cli_args=None):
+    def _run_module_event(self, event, *, cli_args=None, restart=True):
         """Run the module after setting up the environment.
 
         First check the syntax.  If OK, make sure the shell is active and
@@ -140,21 +138,23 @@ def _run_module_event(self, event, cli_args=None):
         if not self.tabnanny(filename):
             return 'break'
         interp = self.shell.interp
-        if pyshell.use_subprocess:
+        if pyshell.use_subprocess and restart:
             interp.restart_subprocess(with_cwd=False, filename=
                         self.editwin._filename_to_unicode(filename))
         dirname = os.path.dirname(filename)
-        # XXX Too often this discards arguments the user just set...
         argv = [filename]
         if cli_args:
             argv += cli_args
+        # XXX Too often this discards arguments the user just set...
         interp.runcommand(f"""if 1:
             __file__ = {filename!r}
             import sys as _sys
             from os.path import basename as _basename
+            argv = {argv!r}
             if (not _sys.argv or
-                _basename(_sys.argv[0]) != _basename(__file__)):
-                _sys.argv = {argv!r}
+                _basename(_sys.argv[0]) != _basename(__file__) or
+                len(argv) > 1):
+                _sys.argv = argv
             import os as _os
             _os.chdir({dirname!r})
             del _sys, _basename, _os