Merge pull request #560 from python-cmd2/py_enhancements

Py enhancements

Author: tleonhardt

cmd2/cmd2.py

@@ -2058,15 +2058,14 @@ def default(self, statement: Statement) -> None:
 
         :param statement: Statement object with parsed input
         """
-        arg = statement.raw
         if self.default_to_shell:
-            result = os.system(arg)
+            result = os.system(statement.command_and_args)
             # If os.system() succeeded, then don't print warning about unknown command
             if not result:
                 return
 
         # Print out a message stating this is an unknown command
-        self.poutput('*** Unknown syntax: {}\n'.format(arg))
+        self.poutput('*** Unknown syntax: {}\n'.format(statement.command_and_args))
 
     def pseudo_raw_input(self, prompt: str) -> str:
         """Began life as a copy of cmd's cmdloop; like raw_input but
@@ -2208,10 +2207,9 @@ def _cmdloop(self) -> bool:
     # -----  Alias subcommand functions -----
 
     def alias_create(self, args: argparse.Namespace):
-        """ Creates or overwrites an alias """
+        """Create or overwrites an alias"""
 
         # Validate the alias name
-        args.name = utils.strip_quotes(args.name)
         valid, errmsg = self.statement_parser.is_valid_command(args.name)
         if not valid:
             self.perror("Invalid alias name: {}".format(errmsg), traceback_war=False)
@@ -2234,30 +2232,24 @@ def alias_create(self, args: argparse.Namespace):
         self.poutput("Alias '{}' {}".format(args.name, result))
 
     def alias_delete(self, args: argparse.Namespace):
-        """ Deletes aliases """
+        """Delete aliases"""
         if args.all:
             self.aliases.clear()
             self.poutput("All aliases deleted")
         elif not args.name:
             self.do_help('alias delete')
         else:
-            # Get rid of duplicates and strip quotes since the argparse decorator for do_alias() preserves them
-            aliases_to_delete = [utils.strip_quotes(cur_name) for cur_name in utils.remove_duplicates(args.name)]
-
-            for cur_name in aliases_to_delete:
+            for cur_name in utils.remove_duplicates(args.name):
                 if cur_name in self.aliases:
                     del self.aliases[cur_name]
                     self.poutput("Alias '{}' deleted".format(cur_name))
                 else:
                     self.perror("Alias '{}' does not exist".format(cur_name), traceback_war=False)
 
     def alias_list(self, args: argparse.Namespace):
-        """ Lists some or all aliases """
+        """List some or all aliases"""
         if args.name:
-            # Get rid of duplicates and strip quotes since the argparse decorator for do_alias() preserves them
-            names_to_view = [utils.strip_quotes(cur_name) for cur_name in utils.remove_duplicates(args.name)]
-
-            for cur_name in names_to_view:
+            for cur_name in utils.remove_duplicates(args.name):
                 if cur_name in self.aliases:
                     self.poutput("alias create {} {}".format(cur_name, self.aliases[cur_name]))
                 else:
@@ -2343,10 +2335,9 @@ def do_alias(self, args: argparse.Namespace):
     # -----  Macro subcommand functions -----
 
     def macro_create(self, args: argparse.Namespace):
-        """ Creates or overwrites a macro """
+        """Create or overwrites a macro"""
 
         # Validate the macro name
-        args.name = utils.strip_quotes(args.name)
         valid, errmsg = self.statement_parser.is_valid_command(args.name)
         if not valid:
             self.perror("Invalid macro name: {}".format(errmsg), traceback_war=False)
@@ -2419,30 +2410,24 @@ def macro_create(self, args: argparse.Namespace):
         self.poutput("Macro '{}' {}".format(args.name, result))
 
     def macro_delete(self, args: argparse.Namespace):
-        """ Deletes macros """
+        """Delete macros"""
         if args.all:
             self.macros.clear()
             self.poutput("All macros deleted")
         elif not args.name:
             self.do_help('macro delete')
         else:
-            # Get rid of duplicates and strip quotes since the argparse decorator for do_macro() preserves them
-            macros_to_delete = [utils.strip_quotes(cur_name) for cur_name in utils.remove_duplicates(args.name)]
-
-            for cur_name in macros_to_delete:
+            for cur_name in utils.remove_duplicates(args.name):
                 if cur_name in self.macros:
                     del self.macros[cur_name]
                     self.poutput("Macro '{}' deleted".format(cur_name))
                 else:
                     self.perror("Macro '{}' does not exist".format(cur_name), traceback_war=False)
 
     def macro_list(self, args: argparse.Namespace):
-        """ Lists some or all macros """
+        """List some or all macros"""
         if args.name:
-            # Get rid of duplicates and strip quotes since the argparse decorator for do_macro() preserves them
-            names_to_view = [utils.strip_quotes(cur_name) for cur_name in utils.remove_duplicates(args.name)]
-
-            for cur_name in names_to_view:
+            for cur_name in utils.remove_duplicates(args.name):
                 if cur_name in self.macros:
                     self.poutput("macro create {} {}".format(cur_name, self.macros[cur_name].value))
                 else:
@@ -2949,7 +2934,16 @@ def _reset_py_display() -> None:
         sys.displayhook = sys.__displayhook__
         sys.excepthook = sys.__excepthook__
 
-    py_parser = ACArgumentParser()
+    py_description = ("Invoke Python command or shell\n"
+                      "\n"
+                      "Note that, when invoking a command directly from the command line, this shell\n"
+                      "has limited ability to parse Python statements into tokens. In particular,\n"
+                      "there may be problems with whitespace and quotes depending on their placement.\n"
+                      "\n"
+                      "If you see strange parsing behavior, it's best to just open the Python shell by\n"
+                      "providing no arguments to py and run more complex statements there.")
+
+    py_parser = ACArgumentParser(description=py_description)
     py_parser.add_argument('command', help="command to run", nargs='?')
     py_parser.add_argument('remainder', help="remainder of command", nargs=argparse.REMAINDER)
 
@@ -3000,6 +2994,8 @@ def run(filename: str):
                 if args.remainder:
                     full_command += ' ' + ' '.join(args.remainder)
 
+                # If running at the CLI, print the output of the command
+                bridge.cmd_echo = True
                 interp.runcode(full_command)
 
             # If there are no args, then we will open an interactive Python console

cmd2/pyscript_bridge.py

@@ -10,7 +10,7 @@
 import argparse
 import functools
 import sys
-from typing import List, Callable
+from typing import List, Callable, Optional
 
 from .argparse_completer import _RangeAction
 from .utils import namedtuple_with_defaults, StdSim
@@ -38,7 +38,7 @@ def __bool__(self):
         return not self.stderr and self.data is not None
 
 
-def _exec_cmd(cmd2_app, func: Callable, echo: bool):
+def _exec_cmd(cmd2_app, func: Callable, echo: bool) -> CommandResult:
     """Helper to encapsulate executing a command and capturing the results"""
     copy_stdout = StdSim(sys.stdout, echo)
     copy_stderr = StdSim(sys.stderr, echo)
@@ -65,7 +65,7 @@ def _exec_cmd(cmd2_app, func: Callable, echo: bool):
 
 class ArgparseFunctor:
     """
-    Encapsulates translating python object traversal
+    Encapsulates translating Python object traversal
     """
     def __init__(self, echo: bool, cmd2_app, command_name: str, parser: argparse.ArgumentParser):
         self._echo = echo
@@ -169,7 +169,7 @@ def __call__(self, *args, **kwargs):
         # Check if there are any extra arguments we don't know how to handle
         for kw in kwargs:
             if kw not in self._args:  # consumed_kw:
-                raise TypeError('{}() got an unexpected keyword argument \'{}\''.format(
+                raise TypeError("{}() got an unexpected keyword argument '{}'".format(
                     self.__current_subcommand_parser.prog, kw))
 
         if has_subcommand:
@@ -181,7 +181,7 @@ def _run(self):
         # look up command function
         func = self._cmd2_app.cmd_func(self._command_name)
         if func is None:
-            raise AttributeError("{!r} object has no command called {!r}".format(self._cmd2_app.__class__.__name__,
+            raise AttributeError("'{}' object has no command called '{}'".format(self._cmd2_app.__class__.__name__,
                                                                                  self._command_name))
 
         # reconstruct the cmd2 command from the python call
@@ -250,7 +250,10 @@ def __init__(self, cmd2_app):
         self.cmd_echo = False
 
     def __getattr__(self, item: str):
-        """Check if the attribute is a command. If so, return a callable."""
+        """
+        Provide functionality to call application commands as a method of PyscriptBridge
+        ex: app.help()
+        """
         func = self._cmd2_app.cmd_func(item)
 
         if func:
@@ -264,14 +267,26 @@ def wrap_func(args=''):
 
                 return wrap_func
         else:
-            return super().__getattr__(item)
+            # item does not refer to a command
+            raise AttributeError("'{}' object has no attribute '{}'".format(self._cmd2_app.pyscript_name, item))
 
     def __dir__(self):
-        """Return a custom set of attribute names to match the available commands"""
-        commands = list(self._cmd2_app.get_all_commands())
-        commands.insert(0, 'cmd_echo')
-        return commands
+        """Return a custom set of attribute names"""
+        attributes = self._cmd2_app.get_all_commands()
+        attributes.insert(0, 'cmd_echo')
+        return attributes
+
+    def __call__(self, args: str, echo: Optional[bool]=None) -> CommandResult:
+        """
+        Provide functionality to call application commands by calling PyscriptBridge
+        ex: app('help')
+        :param args: The string being passed to the command
+        :param echo: If True, output will be echoed while the command runs
+                     This temporarily overrides the value of self.cmd_echo
+        """
+        if echo is None:
+            echo = self.cmd_echo
 
-    def __call__(self, args: str):
-        return _exec_cmd(self._cmd2_app, functools.partial(self._cmd2_app.onecmd_plus_hooks, args + '\n'),
-                         self.cmd_echo)
+        return _exec_cmd(self._cmd2_app,
+                         functools.partial(self._cmd2_app.onecmd_plus_hooks, args + '\n'),
+                         echo)

tests/test_cmd2.py

@@ -1866,22 +1866,6 @@ def test_alias_create(base_app, capsys):
     out = run_cmd(base_app, 'alias list fake')
     assert out == normalize('alias create fake pyscript')
 
-def test_alias_quoted_name(base_app, capsys):
-    """Demonstrate that names can be quoted in alias commands because they will be stripped"""
-    # Create the alias
-    out = run_cmd(base_app, 'alias create "fake" pyscript')
-
-    # The quotes on names are stripped
-    assert out == normalize("Alias 'fake' created")
-
-    # Look up the new alias and quote the name
-    out = run_cmd(base_app, 'alias list "fake"')
-    assert out == normalize('alias create fake pyscript')
-
-    # Delete the alias using quotes
-    out = run_cmd(base_app, 'alias delete "fake"')
-    assert out == normalize("Alias 'fake' deleted")
-
 def test_alias_create_with_quoted_value(base_app, capsys):
     """Demonstrate that quotes in alias value will be preserved (except for redirectors)"""
 
@@ -1968,22 +1952,6 @@ def test_macro_create(base_app, capsys):
     out = run_cmd(base_app, 'macro list fake')
     assert out == normalize('macro create fake pyscript')
 
-def test_macro_create_quoted_name(base_app, capsys):
-    """Demonstrate that names can be quoted in macro commands because they will be stripped"""
-    # Create the macro
-    out = run_cmd(base_app, 'macro create "fake" pyscript')
-
-    # The quotes on names are stripped
-    assert out == normalize("Macro 'fake' created")
-
-    # Look up the new macro and quote the name
-    out = run_cmd(base_app, 'macro list "fake"')
-    assert out == normalize('macro create fake pyscript')
-
-    # Delete the macro using quotes
-    out = run_cmd(base_app, 'macro delete "fake"')
-    assert out == normalize("Macro 'fake' deleted")
-
 def test_macro_create_with_quoted_value(base_app, capsys):
     """Demonstrate that quotes in macro value will be preserved (except for redirectors)"""
     # Create the macro

tests/test_parsing.py

@@ -756,6 +756,38 @@ def test_statement_is_immutable():
         statement.raw = 'baz'
 
 
+def test_is_valid_command_invalid(parser):
+    # Empty command
+    valid, errmsg = parser.is_valid_command('')
+    assert not valid and 'cannot be an empty string' in errmsg
+
+    # Starts with shortcut
+    valid, errmsg = parser.is_valid_command('!ls')
+    assert not valid and 'cannot start with a shortcut' in errmsg
+
+    # Contains whitespace
+    valid, errmsg = parser.is_valid_command('shell ls')
+    assert not valid and 'cannot contain: whitespace, quotes,' in errmsg
+
+    # Contains a quote
+    valid, errmsg = parser.is_valid_command('"shell"')
+    assert not valid and 'cannot contain: whitespace, quotes,' in errmsg
+
+    # Contains a redirector
+    valid, errmsg = parser.is_valid_command('>shell')
+    assert not valid and 'cannot contain: whitespace, quotes,' in errmsg
+
+    # Contains a terminator
+    valid, errmsg = parser.is_valid_command(';shell')
+    assert not valid and 'cannot contain: whitespace, quotes,' in errmsg
+
+def test_is_valid_command_valid(parser):
+    # Empty command
+    valid, errmsg = parser.is_valid_command('shell')
+    assert valid
+    assert not errmsg
+
+
 def test_macro_normal_arg_pattern():
     # This pattern matches digits surrounded by exactly 1 brace on a side and 1 or more braces on the opposite side
     from cmd2.parsing import MacroArg