Merge branch 'master' into speedup_import

# Conflicts:
#	cmd2/cmd2.py
#	tests/test_completion.py
#	tests/test_submenu.py

Author: kotfu

CHANGELOG.md

@@ -19,6 +19,7 @@
 * Changes
     * ``strip_ansi()`` and ``strip_quotes()`` functions have moved to new utils module
     * Several constants moved to new constants module
+    * Submenu support has been moved to a new [cmd2-submenu](https://github.com/python-cmd2/cmd2-submenu) plugin. If you use submenus, you will need to update your dependencies and modify your imports.
 * Deletions (potentially breaking changes)
     * Deleted all ``optparse`` code which had previously been deprecated in release 0.8.0
         * The ``options`` decorator no longer exists
@@ -28,6 +29,7 @@
     * Deleted ``cmd_with_subs_completer``, ``get_subcommands``, and ``get_subcommand_completer``
         * Replaced by default AutoCompleter implementation for all commands using argparse
     * Deleted support for old method of calling application commands with ``cmd()`` and ``self``
+    * ``cmd2.redirector`` is no longer supported. Output redirection can only be done with '>' or '>>'
 * Python 2 no longer supported
     * ``cmd2`` now supports Python 3.4+
 * Known Issues

cmd2/argcomplete_bridge.py

@@ -6,11 +6,17 @@
     import argcomplete
 except ImportError:  # pragma: no cover
     # not installed, skip the rest of the file
-    pass
-
+    DEFAULT_COMPLETER = None
 else:
     # argcomplete is installed
 
+    # Newer versions of argcomplete have FilesCompleter at top level, older versions only have it under completers
+    try:
+        DEFAULT_COMPLETER = argcomplete.FilesCompleter()
+    except AttributeError:
+        DEFAULT_COMPLETER = argcomplete.completers.FilesCompleter()
+
+    from cmd2.argparse_completer import ACTION_ARG_CHOICES, ACTION_SUPPRESS_HINT
     from contextlib import redirect_stdout
     import copy
     from io import StringIO
@@ -102,7 +108,7 @@ class CompletionFinder(argcomplete.CompletionFinder):
 
         def __call__(self, argument_parser, completer=None, always_complete_options=True, exit_method=os._exit, output_stream=None,
                      exclude=None, validator=None, print_suppressed=False, append_space=None,
-                     default_completer=argcomplete.FilesCompleter()):
+                     default_completer=DEFAULT_COMPLETER):
             """
             :param argument_parser: The argument parser to autocomplete on
             :type argument_parser: :class:`argparse.ArgumentParser`
@@ -140,9 +146,14 @@ def __call__(self, argument_parser, completer=None, always_complete_options=True
             added to argcomplete.safe_actions, if their values are wanted in the ``parsed_args`` completer argument, or
             their execution is otherwise desirable.
             """
-            self.__init__(argument_parser, always_complete_options=always_complete_options, exclude=exclude,
-                          validator=validator, print_suppressed=print_suppressed, append_space=append_space,
-                          default_completer=default_completer)
+            # Older versions of argcomplete have fewer keyword arguments
+            if sys.version_info >= (3, 5):
+                self.__init__(argument_parser, always_complete_options=always_complete_options, exclude=exclude,
+                            validator=validator, print_suppressed=print_suppressed, append_space=append_space,
+                            default_completer=default_completer)
+            else:
+                self.__init__(argument_parser, always_complete_options=always_complete_options, exclude=exclude,
+                            validator=validator, print_suppressed=print_suppressed)
 
             if "_ARGCOMPLETE" not in os.environ:
                 # not an argument completion invocation
@@ -235,11 +246,22 @@ def __call__(self, argument_parser, completer=None, always_complete_options=True
                 if comp_type == 63:  # type is 63 for second tab press
                     print(outstr.rstrip(), file=argcomplete.debug_stream, end='')
 
-                output_stream.write(ifs.join([ifs, ' ']).encode(argcomplete.sys_encoding))
+                if completions is not None:
+                    output_stream.write(ifs.join([ifs, ' ']).encode(argcomplete.sys_encoding))
+                else:
+                    output_stream.write(ifs.join([]).encode(argcomplete.sys_encoding))
             else:
                 # if completions is None we assume we don't know how to handle it so let bash
                 # go forward with normal filesystem completion
                 output_stream.write(ifs.join([]).encode(argcomplete.sys_encoding))
             output_stream.flush()
             argcomplete.debug_stream.flush()
             exit_method(0)
+
+
+    def bash_complete(action, show_hint: bool=True):
+        """Helper function to configure an argparse action to fall back to bash completion"""
+        def complete_none(*args, **kwargs):
+            return None
+        setattr(action, ACTION_SUPPRESS_HINT, not show_hint)
+        setattr(action, ACTION_ARG_CHOICES, (complete_none,))

cmd2/argparse_completer.py

@@ -75,6 +75,7 @@ def my_completer(text: str, line: str, begidx: int, endidx:int, extra_param: str
 # attribute that can optionally added to an argparse argument (called an Action) to
 # define the completion choices for the argument. You may provide a Collection or a Function.
 ACTION_ARG_CHOICES = 'arg_choices'
+ACTION_SUPPRESS_HINT = 'suppress_hint'
 
 
 class _RangeAction(object):
@@ -261,6 +262,7 @@ def __init__(self,
                         sub_completers[subcmd] = AutoCompleter(action.choices[subcmd], subcmd_start,
                                                                arg_choices=subcmd_args,
                                                                subcmd_args_lookup=subcmd_lookup,
+                                                               tab_for_arg_help=tab_for_arg_help,
                                                                cmd2_app=cmd2_app)
                         sub_commands.append(subcmd)
                     self._positional_completers[action.dest] = sub_completers
@@ -472,23 +474,43 @@ def _complete_for_arg(self, action: argparse.Action,
         if action.dest in self._arg_choices:
             arg_choices = self._arg_choices[action.dest]
 
-            if isinstance(arg_choices, tuple) and len(arg_choices) > 0 and callable(arg_choices[0]):
-                completer = arg_choices[0]
+            # if arg_choices is a tuple
+            #   Let's see if it's a custom completion function.  If it is, return what it provides
+            # To do this, we make sure the first element is either a callable
+            #   or it's the name of a callable in the application
+            if isinstance(arg_choices, tuple) and len(arg_choices) > 0 and \
+                    (callable(arg_choices[0]) or
+                         (isinstance(arg_choices[0], str) and hasattr(self._cmd2_app, arg_choices[0]) and
+                          callable(getattr(self._cmd2_app, arg_choices[0]))
+                          )
+                     ):
+
+                if callable(arg_choices[0]):
+                    completer = arg_choices[0]
+                elif isinstance(arg_choices[0], str) and callable(getattr(self._cmd2_app, arg_choices[0])):
+                    completer = getattr(self._cmd2_app, arg_choices[0])
+
+                # extract the positional and keyword arguments from the tuple
                 list_args = None
                 kw_args = None
                 for index in range(1, len(arg_choices)):
                     if isinstance(arg_choices[index], list) or isinstance(arg_choices[index], tuple):
                         list_args = arg_choices[index]
                     elif isinstance(arg_choices[index], dict):
                         kw_args = arg_choices[index]
-                if list_args is not None and kw_args is not None:
-                    return completer(text, line, begidx, endidx, *list_args, **kw_args)
-                elif list_args is not None:
-                    return completer(text, line, begidx, endidx, *list_args)
-                elif kw_args is not None:
-                    return completer(text, line, begidx, endidx, **kw_args)
-                else:
-                    return completer(text, line, begidx, endidx)
+                try:
+                    # call the provided function differently depending on the provided positional and keyword arguments
+                    if list_args is not None and kw_args is not None:
+                        return completer(text, line, begidx, endidx, *list_args, **kw_args)
+                    elif list_args is not None:
+                        return completer(text, line, begidx, endidx, *list_args)
+                    elif kw_args is not None:
+                        return completer(text, line, begidx, endidx, **kw_args)
+                    else:
+                        return completer(text, line, begidx, endidx)
+                except TypeError:
+                    # assume this is due to an incorrect function signature, return nothing.
+                    return []
             else:
                 return AutoCompleter.basic_complete(text, line, begidx, endidx,
                                                     self._resolve_choices_for_arg(action, used_values))
@@ -499,6 +521,16 @@ def _resolve_choices_for_arg(self, action: argparse.Action, used_values=()) -> L
         if action.dest in self._arg_choices:
             args = self._arg_choices[action.dest]
 
+            # is the argument a string? If so, see if we can find an attribute in the
+            # application matching the string.
+            if isinstance(args, str):
+                try:
+                    args = getattr(self._cmd2_app, args)
+                except AttributeError:
+                    # Couldn't find anything matching the name
+                    return []
+
+            # is the provided argument a callable. If so, call it
             if callable(args):
                 try:
                     if self._cmd2_app is not None:
@@ -525,8 +557,19 @@ def _resolve_choices_for_arg(self, action: argparse.Action, used_values=()) -> L
         return []
 
     def _print_action_help(self, action: argparse.Action) -> None:
+        # is parameter hinting disabled globally?
         if not self._tab_for_arg_help:
             return
+
+        # is parameter hinting disabled for this parameter?
+        try:
+            suppress_hint = getattr(action, ACTION_SUPPRESS_HINT)
+        except AttributeError:
+            pass
+        else:
+            if suppress_hint:
+                return
+
         if action.option_strings:
             flags = ', '.join(action.option_strings)
             param = ''
@@ -535,7 +578,10 @@ def _print_action_help(self, action: argparse.Action) -> None:
 
             prefix = '{}{}'.format(flags, param)
         else:
-            prefix = '{}'.format(str(action.dest).upper())
+            if action.dest != SUPPRESS:
+                prefix = '{}'.format(str(action.dest).upper())
+            else:
+                prefix = ''
 
         prefix = '  {0: <{width}}    '.format(prefix, width=20)
         pref_len = len(prefix)