Merge branch 'macro' into argparse_conversion

1 files changed, 102 insertions, 101 deletions

diff --git a/cmd2/cmd2.py b/cmd2/cmd2.py
index 2c58d550..5cb38101 100644
--- a/cmd2/cmd2.py
+++ b/cmd2/cmd2.py
@@ -105,9 +105,9 @@ except ImportError:
 
 # Python 3.4 require contextlib2 for temporarily redirecting stderr and stdout
 if sys.version_info < (3, 5):
-    from contextlib2 import redirect_stdout, redirect_stderr
+    from contextlib2 import redirect_stdout
 else:
-    from contextlib import redirect_stdout, redirect_stderr
+    from contextlib import redirect_stdout
 
 # Detect whether IPython is installed to determine if the built-in "ipy" command should be included
 ipython_available = True
@@ -126,6 +126,9 @@ INTERNAL_COMMAND_EPILOG = ("Notes:\n"
                            "  This command is for internal use and is not intended to be called from the\n"
                            "  command line.")
 
+# All command functions start with this
+COMMAND_PREFIX = 'do_'
+
 
 def categorize(func: Union[Callable, Iterable], category: str) -> None:
     """Categorize a function.
@@ -408,7 +411,7 @@ class Cmd(cmd.Cmd):
         self.pystate = {}
         self.py_history = []
         self.pyscript_name = 'app'
-        self.keywords = self.reserved_words + [fname[3:] for fname in dir(self) if fname.startswith('do_')]
+        self.keywords = self.reserved_words + self.get_all_commands()
         self.statement_parser = StatementParser(
             allow_redirection=self.allow_redirection,
             terminators=self.terminators,
@@ -1479,16 +1482,15 @@ class Cmd(cmd.Cmd):
                 # Check if a valid command was entered
                 if command in self.get_all_commands():
                     # Get the completer function for this command
-                    try:
-                        compfunc = getattr(self, 'complete_' + command)
-                    except AttributeError:
+                    compfunc = getattr(self, 'complete_' + command, None)
+
+                    if compfunc is None:
                         # There's no completer function, next see if the command uses argparser
-                        try:
-                            cmd_func = getattr(self, 'do_' + command)
-                            argparser = getattr(cmd_func, 'argparser')
-                            # Command uses argparser, switch to the default argparse completer
-                            compfunc = functools.partial(self._autocomplete_default, argparser=argparser)
-                        except AttributeError:
+                        cmd_func = self._cmd_func(command)
+                        if cmd_func and hasattr(cmd_func, 'argparser'):
+                            compfunc = functools.partial(self._autocomplete_default,
+                                                         argparser=getattr(cmd_func, 'argparser'))
+                        else:
                             compfunc = self.completedefault
 
                 # Check if a macro was entered
@@ -1604,8 +1606,8 @@ class Cmd(cmd.Cmd):
 
     def get_all_commands(self) -> List[str]:
         """Returns a list of all commands."""
-        return [name[3:] for name in self.get_names()
-                if name.startswith('do_') and callable(getattr(self, name))]
+        return [name[len(COMMAND_PREFIX):] for name in self.get_names()
+                if name.startswith(COMMAND_PREFIX) and callable(getattr(self, name))]
 
     def get_visible_commands(self) -> List[str]:
         """Returns a list of commands that have not been hidden."""
@@ -1968,17 +1970,24 @@ class Cmd(cmd.Cmd):
 
         self.redirecting = False
 
-    def _func_named(self, arg: str) -> str:
-        """Gets the method name associated with a given command.
+    def _cmd_func(self, command: str) -> Optional[Callable]:
+        """
+        Get the function for a command
+        :param arg: the name of the command
+        """
+        func_name = self._cmd_func_name(command)
+        if func_name:
+            return getattr(self, func_name)
+        return None
+
+    def _cmd_func_name(self, command: str) -> str:
+        """Get the method name associated with a given command.
 
         :param arg: command to look up method name which implements it
         :return: method name which implements the given command
         """
-        result = None
-        target = 'do_' + arg
-        if target in dir(self):
-            result = target
-        return result
+        target = COMMAND_PREFIX + command
+        return target if callable(getattr(self, target, None)) else ''
 
     def onecmd(self, statement: Union[Statement, str]) -> bool:
         """ This executes the actual do_* method for a command.
@@ -1997,40 +2006,35 @@ class Cmd(cmd.Cmd):
         if statement.command in self.macros:
             stop = self._run_macro(statement)
         else:
-            funcname = self._func_named(statement.command)
-            if not funcname:
-                self.default(statement)
-                return False
+            cmd_func = self._cmd_func(statement.command)
+            if cmd_func:
+                stop = cmd_func(statement)
 
-            # Since we have a valid command store it in the history
-            if statement.command not in self.exclude_from_history:
-                self.history.append(statement.raw)
+                # Since we have a valid command store it in the history
+                if statement.command not in self.exclude_from_history:
+                    self.history.append(statement.raw)
 
-            try:
-                func = getattr(self, funcname)
-            except AttributeError:
+            else:
                 self.default(statement)
-                return False
-
-            stop = func(statement)
+                stop = False
 
         return stop
 
     def _run_macro(self, statement: Statement) -> bool:
         """
-        Resolves a macro and runs the resulting string
+        Resolve a macro and run the resulting string
 
         :param statement: the parsed statement from the command line
         :return: a flag indicating whether the interpretation of commands should stop
         """
-        try:
-            macro = self.macros[statement.command]
-        except KeyError:
-            raise KeyError("{} is not a macro".format(statement.command))
+        if statement.command not in self.macros.keys():
+            raise KeyError('{} is not a macro'.format(statement.command))
+
+        macro = self.macros[statement.command]
 
-        # Confirm we have the correct number of arguments
+        # For macros, every argument must be provided and there can be no extra arguments.
         if len(statement.arg_list) != macro.required_arg_count:
-            self.perror('The macro {!r} expects {} argument(s)'.format(statement.command, macro.required_arg_count),
+            self.perror("The macro '{}' expects {} argument(s)".format(statement.command, macro.required_arg_count),
                         traceback_war=False)
             return False
 
@@ -2210,15 +2214,15 @@ class Cmd(cmd.Cmd):
         """ Creates or overwrites an alias """
 
         # Validate the alias name
-        alias_name = utils.strip_quotes(args.name)
-        valid, errmsg = self.statement_parser.is_valid_command(alias_name)
+        args.name = utils.strip_quotes(args.name)
+        valid, errmsg = self.statement_parser.is_valid_command(args.name)
         if not valid:
             errmsg = "Invalid alias name: {}".format(errmsg)
             self.perror(errmsg, traceback_war=False)
             return
 
-        if alias_name in self.macros:
-            errmsg = "Aliases cannot have the same name as a macro"
+        if args.name in self.macros:
+            errmsg = "Alias cannot have the same name as a macro"
             self.perror(errmsg, traceback_war=False)
             return
 
@@ -2226,13 +2230,13 @@ class Cmd(cmd.Cmd):
 
         # Build the alias value string
         value = args.command
-        for cur_arg in args.command_args:
-            value += ' ' + cur_arg
+        if args.command_args:
+            value += ' ' + ' '.join(args.command_args)
 
         # Set the alias
-        result = "overwritten" if alias_name in self.aliases else "created"
-        self.aliases[alias_name] = value
-        self.poutput("Alias {!r} {}".format(alias_name, result))
+        result = "overwritten" if args.name in self.aliases else "created"
+        self.aliases[args.name] = value
+        self.poutput("Alias '{}' {}".format(args.name, result))
 
     def alias_delete(self, args: argparse.Namespace):
         """ Deletes aliases """
@@ -2242,27 +2246,27 @@ class Cmd(cmd.Cmd):
         elif not args.name:
             self.do_help('alias delete')
         else:
-            # Get rid of duplicates and strip quotes since the argparse decorator for alias command preserves them
+            # 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:
                 if cur_name in self.aliases:
                     del self.aliases[cur_name]
-                    self.poutput("Alias {!r} deleted".format(cur_name))
+                    self.poutput("Alias '{}' deleted".format(cur_name))
                 else:
-                    self.perror("Alias {!r} does not exist".format(cur_name), traceback_war=False)
+                    self.perror("Alias '{}' does not exist".format(cur_name), traceback_war=False)
 
     def alias_list(self, args: argparse.Namespace):
         """ Lists some or all aliases """
         if args.name:
-            # Get rid of duplicates and strip quotes since the argparse decorator for alias command preserves them
+            # 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:
                 if cur_name in self.aliases:
                     self.poutput("alias create {} {}".format(cur_name, self.aliases[cur_name]))
                 else:
-                    self.perror("Alias {!r} not found".format(cur_name), traceback_war=False)
+                    self.perror("Alias '{}' not found".format(cur_name), traceback_war=False)
         else:
             sorted_aliases = utils.alphabetical_sort(self.aliases)
             for cur_alias in sorted_aliases:
@@ -2298,8 +2302,7 @@ class Cmd(cmd.Cmd):
     alias_create_parser = alias_subparsers.add_parser('create', help=alias_create_help,
                                                       description=alias_create_description,
                                                       epilog=alias_create_epilog)
-    setattr(alias_create_parser.add_argument('name', help='name of this alias'),
-            ACTION_ARG_CHOICES, get_commands_aliases_and_macros_for_completion)
+    alias_create_parser.add_argument('name', help='name of this alias')
     setattr(alias_create_parser.add_argument('command', help='what the alias resolves to'),
             ACTION_ARG_CHOICES, get_commands_aliases_and_macros_for_completion)
     setattr(alias_create_parser.add_argument('command_args', nargs=argparse.REMAINDER,
@@ -2314,7 +2317,7 @@ class Cmd(cmd.Cmd):
                                                       description=alias_delete_description)
     setattr(alias_delete_parser.add_argument('name', nargs='*', help='alias to delete'),
             ACTION_ARG_CHOICES, get_alias_names)
-    alias_delete_parser.add_argument('-a', '--all', action='store_true', help="all aliases will be deleted")
+    alias_delete_parser.add_argument('-a', '--all', action='store_true', help="delete all aliases")
     alias_delete_parser.set_defaults(func=alias_delete)
 
     # alias -> list
@@ -2322,7 +2325,7 @@ class Cmd(cmd.Cmd):
     alias_list_description = ("List specified aliases in a reusable form that can be saved to a startup script\n"
                               "to preserve aliases across sessions\n"
                               "\n"
-                              "Without arguments, all aliases will be listed")
+                              "Without arguments, all aliases will be listed.")
 
     alias_list_parser = alias_subparsers.add_parser('list', help=alias_list_help,
                                                     description=alias_list_description)
@@ -2330,6 +2333,7 @@ class Cmd(cmd.Cmd):
             ACTION_ARG_CHOICES, get_alias_names)
     alias_list_parser.set_defaults(func=alias_list)
 
+    # Preserve quotes since we are passing strings to other commands
     @with_argparser(alias_parser, preserve_quotes=True)
     def do_alias(self, args: argparse.Namespace):
         """Manage aliases"""
@@ -2347,20 +2351,20 @@ class Cmd(cmd.Cmd):
         """ Creates or overwrites a macro """
 
         # Validate the macro name
-        macro_name = utils.strip_quotes(args.name)
-        valid, errmsg = self.statement_parser.is_valid_command(macro_name)
+        args.name = utils.strip_quotes(args.name)
+        valid, errmsg = self.statement_parser.is_valid_command(args.name)
         if not valid:
             errmsg = "Invalid macro name: {}".format(errmsg)
             self.perror(errmsg, traceback_war=False)
             return
 
-        if macro_name in self.get_all_commands():
-            errmsg = "Macros cannot have the same name as a command"
+        if args.name in self.get_all_commands():
+            errmsg = "Macro cannot have the same name as a command"
             self.perror(errmsg, traceback_war=False)
             return
 
-        if macro_name in self.aliases:
-            errmsg = "Macros cannot have the same name as an alias"
+        if args.name in self.aliases:
+            errmsg = "Macro cannot have the same name as an alias"
             self.perror(errmsg, traceback_war=False)
             return
 
@@ -2368,14 +2372,14 @@ class Cmd(cmd.Cmd):
 
         # Build the macro value string
         value = args.command
-        for cur_arg in args.command_args:
-            value += ' ' + cur_arg
+        if args.command_args:
+            value += ' ' + ' '.join(args.command_args)
 
         # Find all normal arguments
         arg_list = []
         normal_matches = re.finditer(MacroArg.macro_normal_arg_pattern, value)
         max_arg_num = 0
-        num_set = set()
+        arg_nums = set()
 
         while True:
             try:
@@ -2388,7 +2392,7 @@ class Cmd(cmd.Cmd):
                     self.perror("Argument numbers must be greater than 0", traceback_war=False)
                     return
 
-                num_set.add(cur_num)
+                arg_nums.add(cur_num)
                 if cur_num > max_arg_num:
                     max_arg_num = cur_num
 
@@ -2398,7 +2402,7 @@ class Cmd(cmd.Cmd):
                 break
 
         # Make sure the argument numbers are continuous
-        if len(num_set) != max_arg_num:
+        if len(arg_nums) != max_arg_num:
             self.perror("Not all numbers between 1 and {} are present "
                         "in the argument placeholders".format(max_arg_num), traceback_war=False)
             return
@@ -2418,9 +2422,9 @@ class Cmd(cmd.Cmd):
                 break
 
         # Set the macro
-        result = "overwritten" if macro_name in self.macros else "created"
-        self.macros[macro_name] = Macro(name=macro_name, value=value, required_arg_count=max_arg_num, arg_list=arg_list)
-        self.poutput("Macro {!r} {}".format(macro_name, result))
+        result = "overwritten" if args.name in self.macros else "created"
+        self.macros[args.name] = Macro(name=args.name, value=value, required_arg_count=max_arg_num, arg_list=arg_list)
+        self.poutput("Macro '{}' {}".format(args.name, result))
 
     def macro_delete(self, args: argparse.Namespace):
         """ Deletes macros """
@@ -2430,27 +2434,27 @@ class Cmd(cmd.Cmd):
         elif not args.name:
             self.do_help('macro delete')
         else:
-            # Get rid of duplicates and strip quotes since the argparse decorator for alias command preserves them
+            # 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:
                 if cur_name in self.macros:
                     del self.macros[cur_name]
-                    self.poutput("Macro {!r} deleted".format(cur_name))
+                    self.poutput("Macro '{}' deleted".format(cur_name))
                 else:
-                    self.perror("Macro {!r} does not exist".format(cur_name), traceback_war=False)
+                    self.perror("Macro '{}' does not exist".format(cur_name), traceback_war=False)
 
     def macro_list(self, args: argparse.Namespace):
         """ Lists some or all macros """
         if args.name:
-            # Get rid of duplicates and strip quotes since the argparse decorator for alias command preserves them
+            # 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:
                 if cur_name in self.macros:
                     self.poutput("macro create {} {}".format(cur_name, self.macros[cur_name].value))
                 else:
-                    self.perror("Macro {!r} not found".format(cur_name), traceback_war=False)
+                    self.perror("Macro '{}' not found".format(cur_name), traceback_war=False)
         else:
             sorted_macros = utils.alphabetical_sort(self.macros)
             for cur_macro in sorted_macros:
@@ -2496,8 +2500,8 @@ class Cmd(cmd.Cmd):
                            "\n"
                            "    macro create backup !cp \"{1}\" \"{1}.orig\"\n"
                            "\n"
-                           "  Macros can resolve into commands, aliases, and macros. Thus it is possible\n"
-                           "  to create a macro that results in infinite recursion. So be careful.\n"
+                           "  Be careful! Since macros can resolve into commands, aliases, and macros,\n"
+                           "  it is possible to create a macro that results in infinite recursion.\n"
                            "\n"
                            "  If you want to use redirection or pipes in the macro, then quote them as in\n"
                            "  this example to prevent the 'macro create' command from being redirected.\n"
@@ -2510,8 +2514,7 @@ class Cmd(cmd.Cmd):
     macro_create_parser = macro_subparsers.add_parser('create', help=macro_create_help,
                                                       description=macro_create_description,
                                                       epilog=macro_create_epilog)
-    setattr(macro_create_parser.add_argument('name', help='name of this macro'),
-            ACTION_ARG_CHOICES, get_macro_names)
+    macro_create_parser.add_argument('name', help='name of this macro')
     setattr(macro_create_parser.add_argument('command', help='what the macro resolves to'),
             ACTION_ARG_CHOICES, get_commands_aliases_and_macros_for_completion)
     setattr(macro_create_parser.add_argument('command_args', nargs=argparse.REMAINDER,
@@ -2526,7 +2529,7 @@ class Cmd(cmd.Cmd):
                                                       description=macro_delete_description)
     setattr(macro_delete_parser.add_argument('name', nargs='*', help='macro to delete'),
             ACTION_ARG_CHOICES, get_macro_names)
-    macro_delete_parser.add_argument('-a', '--all', action='store_true', help="all macros will be deleted")
+    macro_delete_parser.add_argument('-a', '--all', action='store_true', help="delete all macros")
     macro_delete_parser.set_defaults(func=macro_delete)
 
     # macro -> list
@@ -2541,6 +2544,7 @@ class Cmd(cmd.Cmd):
             ACTION_ARG_CHOICES, get_macro_names)
     macro_list_parser.set_defaults(func=macro_list)
 
+    # Preserve quotes since we are passing strings to other commands
     @with_argparser(macro_parser, preserve_quotes=True)
     def do_macro(self, args: argparse.Namespace):
         """Manage macros"""
@@ -2584,13 +2588,10 @@ class Cmd(cmd.Cmd):
         matches = []
 
         # Check if this is a command with an argparse function
-        funcname = self._func_named(command)
-        if funcname:
-            func = getattr(self, funcname)
-            if hasattr(func, 'argparser'):
-                parser = getattr(func, 'argparser')
-                completer = AutoCompleter(parser, cmd2_app=self)
-                matches = completer.complete_command_help(tokens[cmd_index:], text, line, begidx, endidx)
+        cmd_func = self._cmd_func(command)
+        if cmd_func and hasattr(cmd_func, 'argparser'):
+            completer = AutoCompleter(getattr(cmd_func, 'argparser'), cmd2_app=self)
+            matches = completer.complete_command_help(tokens[cmd_index:], text, line, begidx, endidx)
 
         return matches
 
@@ -2612,13 +2613,11 @@ class Cmd(cmd.Cmd):
 
         elif args.command:
             # Getting help for a specific command
-            funcname = self._func_named(args.command)
-            if funcname:
+            cmd_func = self._cmd_func(args.command)
+            if cmd_func:
                 # Check to see if this function was decorated with an argparse ArgumentParser
-                func = getattr(self, funcname)
-                if hasattr(func, 'argparser'):
-                    completer = AutoCompleter(getattr(func, 'argparser'), cmd2_app=self)
-
+                if hasattr(cmd_func, 'argparser'):
+                    completer = AutoCompleter(getattr(cmd_func, 'argparser'), cmd2_app=self)
                     tokens = [args.command]
                     tokens.extend(args.subcommand)
                     self.poutput(completer.format_help(tokens))
@@ -2643,11 +2642,12 @@ class Cmd(cmd.Cmd):
         cmds_cats = {}
 
         for command in visible_commands:
-            if command in help_topics or getattr(self, self._func_named(command)).__doc__:
+            cmd_func = self._cmd_func(command)
+            if command in help_topics or cmd_func.__doc__:
                 if command in help_topics:
                     help_topics.remove(command)
-                if hasattr(getattr(self, self._func_named(command)), HELP_CATEGORY):
-                    category = getattr(getattr(self, self._func_named(command)), HELP_CATEGORY)
+                if hasattr(cmd_func, HELP_CATEGORY):
+                    category = getattr(cmd_func, HELP_CATEGORY)
                     cmds_cats.setdefault(category, [])
                     cmds_cats[category].append(command)
                 else:
@@ -2700,12 +2700,13 @@ class Cmd(cmd.Cmd):
                         func = getattr(self, 'help_' + command)
                     except AttributeError:
                         # Couldn't find a help function
+                        cmd_func = self._cmd_func(command)
                         try:
                             # Now see if help_summary has been set
-                            doc = getattr(self, self._func_named(command)).help_summary
+                            doc = cmd_func.help_summary
                         except AttributeError:
                             # Last, try to directly access the function's doc-string
-                            doc = getattr(self, self._func_named(command)).__doc__
+                            doc = cmd_func.__doc__
                     else:
                         # we found the help function
                         result = io.StringIO()