Merge pull request #718 from python-cmd2/auto_completer_refactor

Auto completer refactor

1 files changed, 387 insertions, 1165 deletions

diff --git a/cmd2/argparse_completer.py b/cmd2/argparse_completer.py
index 539132dd..737286c1 100644
--- a/cmd2/argparse_completer.py
+++ b/cmd2/argparse_completer.py
@@ -1,290 +1,114 @@
 # coding=utf-8
 # flake8: noqa C901
-# NOTE: Ignoreing flake8 cyclomatic complexity in this file because the complexity due to copy-and-paste overrides from
-#       argparse
+# NOTE: Ignoring flake8 cyclomatic complexity in this file
 """
-AutoCompleter interprets the argparse.ArgumentParser internals to automatically
-generate the completion options for each argument.
-
-How to supply completion options for each argument:
-    argparse Choices
-    - pass a list of values to the choices parameter of an argparse argument.
-      ex: parser.add_argument('-o', '--options', dest='options', choices=['An Option', 'SomeOtherOption'])
-
-    arg_choices dictionary lookup
-        arg_choices is a dict() mapping from argument name to one of 3 possible values:
-          ex:
-            parser = argparse.ArgumentParser()
-            parser.add_argument('-o', '--options', dest='options')
-            choices = {}
-            mycompleter = AutoCompleter(parser, cmd2_app, completer, 1, choices)
-
-        - static list - provide a static list for each argument name
-          ex:
-            choices['options'] = ['An Option', 'SomeOtherOption']
-
-        - choices function - provide a function that returns a list for each argument name
-          ex:
-            def generate_choices():
-                return ['An Option', 'SomeOtherOption']
-            choices['options'] = generate_choices
-
-        - custom completer function - provide a completer function that will return the list
-            of completion arguments
-          ex 1:
-            def my_completer(text: str, line: str, begidx: int, endidx:int):
-                my_choices = [...]
-                return my_choices
-            choices['options'] = (my_completer)
-          ex 2:
-            def my_completer(text: str, line: str, begidx: int, endidx:int, extra_param: str, another: int):
-                my_choices = [...]
-                return my_choices
-            completer_params = {'extra_param': 'my extra', 'another': 5}
-            choices['options'] = (my_completer, completer_params)
-
-How to supply completion choice lists or functions for sub-commands:
-    subcmd_args_lookup is used to supply a unique pair of arg_choices and subcmd_args_lookup
-    for each sub-command in an argparser subparser group.
-    This requires your subparser group to be named with the dest parameter
-        ex:
-            parser = ArgumentParser()
-            subparsers = parser.add_subparsers(title='Actions', dest='action')
-
-    subcmd_args_lookup maps a named subparser group to a subcommand group dictionary
-    The subcommand group dictionary maps subcommand names to tuple(arg_choices, subcmd_args_lookup)
-
-    For more details of this more complex approach see tab_autocompletion.py in the examples
+This module defines the AutoCompleter class which provides argparse-based tab completion to cmd2 apps.
+See the header of argparse_custom.py for instructions on how to use these features.
 """
 
 import argparse
-import os
-import re as _re
-import sys
-
-# imports copied from argparse to support our customized argparse functions
-from argparse import ZERO_OR_MORE, ONE_OR_MORE, ArgumentError, _, _get_action_name, SUPPRESS
-from typing import List, Dict, Tuple, Callable, Union
-
-from .ansi import ansi_aware_write, ansi_safe_wcswidth, style_error
+import shutil
+from typing import List, Union
+
+from . import cmd2
+from . import utils
+from .ansi import ansi_safe_wcswidth, style_error
+from .argparse_custom import ATTR_SUPPRESS_TAB_HINT, ATTR_DESCRIPTIVE_COMPLETION_HEADER, ATTR_NARGS_RANGE
+from .argparse_custom import ChoicesCallable, CompletionItem, ATTR_CHOICES_CALLABLE, INFINITY, generate_range_error
 from .rl_utils import rl_force_redisplay
 
-# 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'
-ACTION_DESCRIPTIVE_COMPLETION_HEADER = 'desc_header'
-
-
-class CompletionItem(str):
-    """
-    Completion item with descriptive text attached
-
-    Returning this instead of a regular string for completion results will signal the
-    autocompleter to output the completions results in a table of completion tokens
-    with descriptions instead of just a table of tokens.
+# If no descriptive header is supplied, then this will be used instead
+DEFAULT_DESCRIPTIVE_HEADER = 'Description'
 
-    For example, you'd see this:
-        TOKEN          Description
-        MY_TOKEN       Info about my token
-        SOME_TOKEN     Info about some token
-        YET_ANOTHER    Yet more info
 
-    Instead of this:
-        TOKEN_ID   SOME_TOKEN   YET_ANOTHER
+def _single_prefix_char(token: str, parser: argparse.ArgumentParser) -> bool:
+    """Returns if a token is just a single flag prefix character"""
+    return len(token) == 1 and token[0] in parser.prefix_chars
 
-    This is especially useful if you want to complete ID numbers in a more
-    user-friendly manner. For example, you can provide this:
 
-        ITEM_ID     Item Name
-        1           My item
-        2           Another item
-        3           Yet another item
-
-    Instead of this:
-        1     2     3
+# noinspection PyProtectedMember
+def _looks_like_flag(token: str, parser: argparse.ArgumentParser) -> bool:
     """
-    def __new__(cls, o, desc='', *args, **kwargs) -> str:
-        return str.__new__(cls, o, *args, **kwargs)
-
-    # noinspection PyMissingConstructor,PyUnusedLocal
-    def __init__(self, o, desc='', *args, **kwargs) -> None:
-        self.description = desc
-
-
-class _RangeAction(object):
-    def __init__(self, nargs: Union[int, str, Tuple[int, int], None]) -> None:
-        self.nargs_min = None
-        self.nargs_max = None
-
-        # pre-process special ranged nargs
-        if isinstance(nargs, tuple):
-            if len(nargs) != 2 or not isinstance(nargs[0], int) or not isinstance(nargs[1], int):
-                raise ValueError('Ranged values for nargs must be a tuple of 2 integers')
-            if nargs[0] >= nargs[1]:
-                raise ValueError('Invalid nargs range. The first value must be less than the second')
-            if nargs[0] < 0:
-                raise ValueError('Negative numbers are invalid for nargs range.')
-            narg_range = nargs
-            self.nargs_min = nargs[0]
-            self.nargs_max = nargs[1]
-            if narg_range[0] == 0:
-                if narg_range[1] > 1:
-                    self.nargs_adjusted = '*'
-                else:
-                    # this shouldn't use a range tuple, but yet here we are
-                    self.nargs_adjusted = '?'
-            else:
-                self.nargs_adjusted = '+'
-        else:
-            self.nargs_adjusted = nargs
-
-
-# noinspection PyShadowingBuiltins,PyShadowingBuiltins
-class _StoreRangeAction(argparse._StoreAction, _RangeAction):
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 nargs=None,
-                 const=None,
-                 default=None,
-                 type=None,
-                 choices=None,
-                 required=False,
-                 help=None,
-                 metavar=None) -> None:
-
-        _RangeAction.__init__(self, nargs)
-
-        argparse._StoreAction.__init__(self,
-                                       option_strings=option_strings,
-                                       dest=dest,
-                                       nargs=self.nargs_adjusted,
-                                       const=const,
-                                       default=default,
-                                       type=type,
-                                       choices=choices,
-                                       required=required,
-                                       help=help,
-                                       metavar=metavar)
-
-
-# noinspection PyShadowingBuiltins,PyShadowingBuiltins
-class _AppendRangeAction(argparse._AppendAction, _RangeAction):
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 nargs=None,
-                 const=None,
-                 default=None,
-                 type=None,
-                 choices=None,
-                 required=False,
-                 help=None,
-                 metavar=None) -> None:
-
-        _RangeAction.__init__(self, nargs)
-
-        argparse._AppendAction.__init__(self,
-                                        option_strings=option_strings,
-                                        dest=dest,
-                                        nargs=self.nargs_adjusted,
-                                        const=const,
-                                        default=default,
-                                        type=type,
-                                        choices=choices,
-                                        required=required,
-                                        help=help,
-                                        metavar=metavar)
-
-
-def register_custom_actions(parser: argparse.ArgumentParser) -> None:
-    """Register custom argument action types"""
-    parser.register('action', None, _StoreRangeAction)
-    parser.register('action', 'store', _StoreRangeAction)
-    parser.register('action', 'append', _AppendRangeAction)
-
-
-def is_potential_flag(token: str, parser: argparse.ArgumentParser) -> bool:
-    """Determine if a token looks like a potential flag. Based on argparse._parse_optional()."""
-    # if it's an empty string, it was meant to be a positional
-    if not token:
+    Determine if a token looks like a flag. Unless an argument has nargs set to argparse.REMAINDER,
+    then anything that looks like a flag can't be consumed as a value for it.
+    Based on argparse._parse_optional().
+    """
+    # Flags have to be at least characters
+    if len(token) < 2:
         return False
 
-    # if it doesn't start with a prefix, it was meant to be positional
+    # Flags have to start with a prefix character
     if not token[0] in parser.prefix_chars:
         return False
 
-    # if it's just a single character, it was meant to be positional
-    if len(token) == 1:
-        return False
-
-    # if it looks like a negative number, it was meant to be positional
-    # unless there are negative-number-like options
+    # If it looks like a negative number, it is not a flag unless there are negative-number-like flags
     if parser._negative_number_matcher.match(token):
         if not parser._has_negative_number_optionals:
             return False
 
-    # if it contains a space, it was meant to be a positional
+    # Flags can't have a space
     if ' ' in token:
         return False
 
-    # Looks like a flag
+    # Starts like a flag
     return True
 
 
+# noinspection PyProtectedMember
 class AutoCompleter(object):
-    """Automatically command line tab completion based on argparse parameters"""
+    """Automatic command line tab completion based on argparse parameters"""
 
     class _ArgumentState(object):
-        def __init__(self) -> None:
-            self.min = None
-            self.max = None
-            self.count = 0
-            self.needed = False
-            self.variable = False
+        """Keeps state of an argument being parsed"""
 
-        def reset(self) -> None:
-            """reset tracking values"""
+        def __init__(self, arg_action: argparse.Action) -> None:
+            self.action = arg_action
             self.min = None
             self.max = None
             self.count = 0
-            self.needed = False
-            self.variable = False
-
-    def __init__(self,
-                 parser: argparse.ArgumentParser,
-                 cmd2_app,
-                 token_start_index: int = 1,
-                 arg_choices: Dict[str, Union[List, Tuple, Callable]] = None,
-                 subcmd_args_lookup: dict = None,
-                 tab_for_arg_help: bool = True) -> None:
+            self.is_remainder = (self.action.nargs == argparse.REMAINDER)
+
+            # Check if nargs is a range
+            nargs_range = getattr(self.action, ATTR_NARGS_RANGE, None)
+            if nargs_range is not None:
+                self.min = nargs_range[0]
+                self.max = nargs_range[1]
+
+            # Otherwise check against argparse types
+            elif self.action.nargs is None:
+                self.min = 1
+                self.max = 1
+            elif self.action.nargs == argparse.OPTIONAL:
+                self.min = 0
+                self.max = 1
+            elif self.action.nargs == argparse.ZERO_OR_MORE or self.action.nargs == argparse.REMAINDER:
+                self.min = 0
+                self.max = INFINITY
+            elif self.action.nargs == argparse.ONE_OR_MORE:
+                self.min = 1
+                self.max = INFINITY
+            else:
+                self.min = self.action.nargs
+                self.max = self.action.nargs
+
+    def __init__(self, parser: argparse.ArgumentParser, cmd2_app: cmd2.Cmd, *,
+                 token_start_index: int = 1) -> None:
         """
         Create an AutoCompleter
 
         :param parser: ArgumentParser instance
-        :param cmd2_app: reference to the Cmd2 application. Enables argparse argument completion with class methods
+        :param cmd2_app: reference to the Cmd2 application that owns this AutoCompleter
         :param token_start_index: index of the token to start parsing at
-        :param arg_choices: dictionary mapping from argparse argument 'dest' name to list of choices
-        :param subcmd_args_lookup: mapping a sub-command group name to a tuple to fill the child\
-        AutoCompleter's arg_choices and subcmd_args_lookup parameters
-        :param tab_for_arg_help: Enable of disable argument help when there's no completion result
         """
-        if not subcmd_args_lookup:
-            subcmd_args_lookup = {}
-            forward_arg_choices = True
-        else:
-            forward_arg_choices = False
         self._parser = parser
         self._cmd2_app = cmd2_app
-        self._arg_choices = arg_choices.copy() if arg_choices is not None else {}
+        self._arg_choices = {}
         self._token_start_index = token_start_index
-        self._tab_for_arg_help = tab_for_arg_help
 
         self._flags = []  # all flags in this command
-        self._flags_without_args = []  # all flags that don't take arguments
         self._flag_to_action = {}  # maps flags to the argparse action object
         self._positional_actions = []  # argument names for positional arguments (by position index)
+
         # maps action name to sub-command autocompleter:
         #   action_name -> dict(sub_command -> completer)
         self._positional_completers = {}
@@ -295,10 +119,11 @@ class AutoCompleter(object):
             # if there are choices defined, record them in the arguments dictionary
             if action.choices is not None:
                 self._arg_choices[action.dest] = action.choices
-            # if completion choices are tagged on the action, record them
-            elif hasattr(action, ACTION_ARG_CHOICES):
-                action_arg_choices = getattr(action, ACTION_ARG_CHOICES)
-                self._arg_choices[action.dest] = action_arg_choices
+
+            # otherwise check if a callable provides the choices for this argument
+            elif hasattr(action, ATTR_CHOICES_CALLABLE):
+                arg_choice_callable = getattr(action, ATTR_CHOICES_CALLABLE)
+                self._arg_choices[action.dest] = arg_choice_callable
 
             # if the parameter is flag based, it will have option_strings
             if action.option_strings:
@@ -306,33 +131,32 @@ class AutoCompleter(object):
                 for option in action.option_strings:
                     self._flags.append(option)
                     self._flag_to_action[option] = action
-                    if action.nargs == 0:
-                        self._flags_without_args.append(option)
+
+            # Otherwise this is a positional parameter
             else:
                 self._positional_actions.append(action)
 
                 if isinstance(action, argparse._SubParsersAction):
                     sub_completers = {}
                     sub_commands = []
-                    args_for_action = subcmd_args_lookup[action.dest]\
-                        if action.dest in subcmd_args_lookup else {}
+
+                    # Create an AutoCompleter for each subcommand of this command
                     for subcmd in action.choices:
-                        (subcmd_args, subcmd_lookup) = args_for_action[subcmd] if \
-                            subcmd in args_for_action else \
-                            (arg_choices, subcmd_args_lookup) if forward_arg_choices else ({}, {})
+
                         subcmd_start = token_start_index + len(self._positional_actions)
                         sub_completers[subcmd] = AutoCompleter(action.choices[subcmd],
                                                                cmd2_app,
-                                                               token_start_index=subcmd_start,
-                                                               arg_choices=subcmd_args,
-                                                               subcmd_args_lookup=subcmd_lookup,
-                                                               tab_for_arg_help=tab_for_arg_help)
+                                                               token_start_index=subcmd_start)
                         sub_commands.append(subcmd)
+
                     self._positional_completers[action.dest] = sub_completers
                     self._arg_choices[action.dest] = sub_commands
 
     def complete_command(self, tokens: List[str], text: str, line: str, begidx: int, endidx: int) -> List[str]:
         """Complete the command using the argparse metadata and provided argument dictionary"""
+        if len(tokens) <= self._token_start_index:
+            return []
+
         # Count which positional argument index we're at now. Loop through all tokens on the command line so far
         # Skip any flags or flag parameter tokens
         next_pos_arg_index = 0
@@ -341,246 +165,229 @@ class AutoCompleter(object):
         # That can happen when -- is used or an argument with nargs=argparse.REMAINDER is used
         skip_remaining_flags = False
 
-        pos_arg = AutoCompleter._ArgumentState()
-        pos_action = None
+        # _ArgumentState of the current positional
+        pos_arg_state = None
 
-        flag_arg = AutoCompleter._ArgumentState()
-        flag_action = None
-
-        # dict is used because object wrapper is necessary to allow inner functions to modify outer variables
-        remainder = {'arg': None, 'action': None}
+        # _ArgumentState of the current flag
+        flag_arg_state = None
 
         matched_flags = []
-        current_is_positional = False
         consumed_arg_values = {}  # dict(arg_name -> [values, ...])
 
-        # the following are nested functions that have full access to all variables in the parent
-        # function including variables declared and updated after this function.  Variable values
-        # are current at the point the nested functions are invoked (as in, they do not receive a
-        # snapshot of these values, they directly access the current state of variables in the
-        # parent function)
-
-        def consume_flag_argument() -> None:
-            """Consuming token as a flag argument"""
-            # we're consuming flag arguments
-            # if the token does not look like a new flag, then count towards flag arguments
-            if not is_potential_flag(token, self._parser) and flag_action is not None:
-                flag_arg.count += 1
-
-                # does this complete a option item for the flag
-                arg_choices = self._resolve_choices_for_arg(flag_action)
-                # if the current token matches the current position's autocomplete argument list,
-                # track that we've used it already.  Unless this is the current token, then keep it.
-                if not is_last_token and token in arg_choices:
-                    consumed_arg_values.setdefault(flag_action.dest, [])
-                    consumed_arg_values[flag_action.dest].append(token)
-
-        def consume_positional_argument() -> None:
-            """Consuming token as positional argument"""
-            pos_arg.count += 1
-
-            # does this complete a option item for the flag
-            arg_choices = self._resolve_choices_for_arg(pos_action)
-            # if the current token matches the current position's autocomplete argument list,
-            # track that we've used it already.  Unless this is the current token, then keep it.
-            if not is_last_token and token in arg_choices:
-                consumed_arg_values.setdefault(pos_action.dest, [])
-                consumed_arg_values[pos_action.dest].append(token)
-
-        def process_action_nargs(action: argparse.Action, arg_state: AutoCompleter._ArgumentState) -> None:
-            """Process the current argparse Action and initialize the ArgumentState object used
-            to track what arguments we have processed for this action"""
-            if isinstance(action, _RangeAction):
-                arg_state.min = action.nargs_min
-                arg_state.max = action.nargs_max
-                arg_state.variable = True
-            if arg_state.min is None or arg_state.max is None:
-                if action.nargs is None:
-                    arg_state.min = 1
-                    arg_state.max = 1
-                elif action.nargs == '+':
-                    arg_state.min = 1
-                    arg_state.max = float('inf')
-                    arg_state.variable = True
-                elif action.nargs == '*' or action.nargs == argparse.REMAINDER:
-                    arg_state.min = 0
-                    arg_state.max = float('inf')
-                    arg_state.variable = True
-                    if action.nargs == argparse.REMAINDER:
-                        remainder['action'] = action
-                        remainder['arg'] = arg_state
-                elif action.nargs == '?':
-                    arg_state.min = 0
-                    arg_state.max = 1
-                    arg_state.variable = True
+        def consume_argument(arg_state: AutoCompleter._ArgumentState) -> None:
+            """Consuming token as an argument"""
+            arg_state.count += 1
+
+            # Does this complete an option item for the flag?
+            arg_choices = self._resolve_choices_for_arg(arg_state.action)
+
+            # If the current token is in the flag argument's autocomplete list,
+            # then track that we've used it already.
+            if token in arg_choices:
+                consumed_arg_values.setdefault(arg_state.action.dest, [])
+                consumed_arg_values[arg_state.action.dest].append(token)
+
+        #############################################################################################
+        # Parse all but the last token
+        #############################################################################################
+        for loop_index, token in enumerate(tokens[self._token_start_index:-1]):
+
+            # If we're in a positional REMAINDER arg, force all future tokens to go to that
+            if pos_arg_state is not None and pos_arg_state.is_remainder:
+                consume_argument(pos_arg_state)
+                continue
+
+            # If we're in a flag REMAINDER arg, force all future tokens to go to that until a double dash is hit
+            elif flag_arg_state is not None and flag_arg_state.is_remainder:
+                if token == '--':
+                    flag_arg_state = None
                 else:
-                    arg_state.min = action.nargs
-                    arg_state.max = action.nargs
-
-        # This next block of processing tries to parse all parameters before the last parameter.
-        # We're trying to determine what specific argument the current cursor positition should be
-        # matched with. When we finish parsing all of the arguments, we can determine whether the
-        # last token is a positional or flag argument and which specific argument it is.
-        #
-        # We're also trying to save every flag that has been used as well as every value that
-        # has been used for a positional or flag parameter.  By saving this information we can exclude
-        # it from the completion results we generate for the last token. For example, single-use flag
-        # arguments will be hidden from the list of available flags. Also, arguments with a
-        # defined list of possible values will exclude values that have already been used.
-
-        # notes when the last token has been reached
-        is_last_token = False
-
-        for idx, token in enumerate(tokens):
-            is_last_token = idx >= len(tokens) - 1
-
-            # Only start at the start token index
-            if idx >= self._token_start_index:
-
-                # If a remainder action is found, force all future tokens to go to that
-                if remainder['arg'] is not None:
-                    if remainder['action'] == pos_action:
-                        consume_positional_argument()
-                        continue
-                    elif remainder['action'] == flag_action:
-                        consume_flag_argument()
-                        continue
-
-                current_is_positional = False
-                # Are we consuming flag arguments?
-                if not flag_arg.needed:
-
-                    if not skip_remaining_flags:
-                        # Special case when each of the following is true:
-                        #   - We're not in the middle of consuming flag arguments
-                        #   - The current positional argument count has hit the max count
-                        #   - The next positional argument is a REMAINDER argument
-                        # Argparse will now treat all future tokens as arguments to the positional including tokens that
-                        # look like flags so the completer should skip any flag related processing once this happens
-                        if (pos_action is not None) and pos_arg.count >= pos_arg.max and \
-                                next_pos_arg_index < len(self._positional_actions) and \
-                                self._positional_actions[next_pos_arg_index].nargs == argparse.REMAINDER:
-                            skip_remaining_flags = True
+                    consume_argument(flag_arg_state)
+                continue
 
-                    # At this point we're no longer consuming flag arguments. Is the current argument a potential flag?
-                    if is_potential_flag(token, self._parser) and not skip_remaining_flags:
-                        # reset some tracking values
-                        flag_arg.reset()
-                        # don't reset positional tracking because flags can be interspersed anywhere between positionals
-                        flag_action = None
-
-                        if token == '--':
-                            if is_last_token:
-                                # Exit loop and see if -- can be completed into a flag
-                                break
-                            else:
-                                # In argparse, all args after -- are non-flags
-                                skip_remaining_flags = True
-
-                        # does the token fully match a known flag?
-                        if token in self._flag_to_action:
-                            flag_action = self._flag_to_action[token]
-                        elif hasattr(self._parser, 'allow_abbrev') and self._parser.allow_abbrev:
-                            candidates_flags = [flag for flag in self._flag_to_action if flag.startswith(token)]
-                            if len(candidates_flags) == 1:
-                                flag_action = self._flag_to_action[candidates_flags[0]]
-
-                        if flag_action is not None:
-                            # resolve argument counts
-                            process_action_nargs(flag_action, flag_arg)
-                            if not is_last_token and not isinstance(flag_action, argparse._AppendAction):
-                                matched_flags.extend(flag_action.option_strings)
-
-                    # current token isn't a potential flag
-                    #   - does the last flag accept variable arguments?
-                    #   - have we reached the max arg count for the flag?
-                    elif not flag_arg.variable or flag_arg.count >= flag_arg.max:
-                        # previous flag doesn't accept variable arguments, count this as a positional argument
-
-                        # reset flag tracking variables
-                        flag_arg.reset()
-                        flag_action = None
-                        current_is_positional = True
-
-                        if len(token) > 0 and pos_action is not None and pos_arg.count < pos_arg.max:
-                            # we have positional action match and we haven't reached the max arg count, consume
-                            # the positional argument and move on.
-                            consume_positional_argument()
-                        elif pos_action is None or pos_arg.count >= pos_arg.max:
-                            # if we don't have a current positional action or we've reached the max count for the action
-                            # close out the current positional argument state and set up for the next one
-                            pos_index = next_pos_arg_index
-                            next_pos_arg_index += 1
-                            pos_arg.reset()
-                            pos_action = None
-
-                            # are we at a sub-command? If so, forward to the matching completer
-                            if pos_index < len(self._positional_actions):
-                                action = self._positional_actions[pos_index]
-                                pos_name = action.dest
-                                if pos_name in self._positional_completers:
-                                    sub_completers = self._positional_completers[pos_name]
-                                    if token in sub_completers:
-                                        return sub_completers[token].complete_command(tokens, text, line,
-                                                                                      begidx, endidx)
-                                pos_action = action
-                                process_action_nargs(pos_action, pos_arg)
-                                consume_positional_argument()
-
-                        elif not is_last_token and pos_arg.max is not None:
-                            pos_action = None
-                            pos_arg.reset()
-
-                    else:
-                        consume_flag_argument()
+            # Handle '--' which tells argparse all remaining arguments are non-flags
+            elif token == '--' and not skip_remaining_flags:
+                # Check if there is an unfinished flag
+                if flag_arg_state is not None and flag_arg_state.count < flag_arg_state.min:
+                    self._print_unfinished_flag_error(flag_arg_state)
+                    return []
 
+                # Otherwise end the current flag
                 else:
-                    consume_flag_argument()
-
-                if remainder['arg'] is not None:
+                    flag_arg_state = None
                     skip_remaining_flags = True
+                    continue
+
+            # Check the format of the current token to see if it can be an argument's value
+            if _looks_like_flag(token, self._parser) and not skip_remaining_flags:
+
+                # Check if there is an unfinished flag
+                if flag_arg_state is not None and flag_arg_state.count < flag_arg_state.min:
+                    self._print_unfinished_flag_error(flag_arg_state)
+                    return []
+
+                # Reset flag arg state but not positional tracking because flags can be
+                # interspersed anywhere between positionals
+                flag_arg_state = None
+                action = None
+
+                # Does the token match a known flag?
+                if token in self._flag_to_action:
+                    action = self._flag_to_action[token]
+                elif self._parser.allow_abbrev:
+                    candidates_flags = [flag for flag in self._flag_to_action if flag.startswith(token)]
+                    if len(candidates_flags) == 1:
+                        action = self._flag_to_action[candidates_flags[0]]
+
+                if action is not None:
+                    # Keep track of what flags have already been used
+                    # Flags with action set to append, append_const, and count can be reused
+                    if not isinstance(action, (argparse._AppendAction,
+                                               argparse._AppendConstAction,
+                                               argparse._CountAction)):
+                        matched_flags.extend(action.option_strings)
+
+                    new_arg_state = AutoCompleter._ArgumentState(action)
+
+                    # Keep track of this flag if it can receive arguments
+                    if new_arg_state.max > 0:
+                        flag_arg_state = new_arg_state
+                        skip_remaining_flags = flag_arg_state.is_remainder
+
+                        # It's possible we already have consumed values for this flag if it was used
+                        # earlier in the command line. Reset them now for this use of it.
+                        consumed_arg_values[flag_arg_state.action.dest] = []
+
+            # Check if we are consuming a flag
+            elif flag_arg_state is not None:
+                consume_argument(flag_arg_state)
+
+                # Check if we have finished with this flag
+                if flag_arg_state.count >= flag_arg_state.max:
+                    flag_arg_state = None
+
+            # Otherwise treat as a positional argument
+            else:
+                # If we aren't current tracking a positional, then get the next positional arg to handle this token
+                if pos_arg_state is None:
+                    pos_index = next_pos_arg_index
+                    next_pos_arg_index += 1
+
+                    # Make sure we are still have positional arguments to fill
+                    if pos_index < len(self._positional_actions):
+                        action = self._positional_actions[pos_index]
+                        pos_name = action.dest
+
+                        # Are we at a sub-command? If so, forward to the matching completer
+                        if pos_name in self._positional_completers:
+                            sub_completers = self._positional_completers[pos_name]
+                            if token in sub_completers:
+                                return sub_completers[token].complete_command(tokens, text, line,
+                                                                              begidx, endidx)
+
+                        # Keep track of the argument
+                        pos_arg_state = AutoCompleter._ArgumentState(action)
+
+                # Check if we have a positional to consume this token
+                if pos_arg_state is not None:
+                    consume_argument(pos_arg_state)
+
+                    # No more flags are allowed if this is a REMAINDER argument
+                    if pos_arg_state.is_remainder:
+                        skip_remaining_flags = True
+
+                    # Check if we have finished with this positional
+                    elif pos_arg_state.count >= pos_arg_state.max:
+                        pos_arg_state = None
+
+                        # Check if this a case in which we've finished all positionals before one that has nargs
+                        # set to argparse.REMAINDER. At this point argparse allows no more flags to be processed.
+                        if next_pos_arg_index < len(self._positional_actions) and \
+                                self._positional_actions[next_pos_arg_index].nargs == argparse.REMAINDER:
+                            skip_remaining_flags = True
 
-                # don't reset this if we're on the last token - this allows completion to occur on the current token
-                elif not is_last_token and flag_arg.min is not None:
-                    flag_arg.needed = flag_arg.count < flag_arg.min
+        #############################################################################################
+        # We have parsed all but the last token and have enough information to complete it
+        #############################################################################################
 
-        # Here we're done parsing all of the prior arguments. We know what the next argument is.
+        # Check if we are completing a flag name. This check ignores strings with a length of one, like '-'.
+        # This is because that could be the start of a negative number which may be a valid completion for
+        # the current argument. We will handle the completion of flags that start with only one prefix
+        # character (-f) at the end.
+        if _looks_like_flag(text, self._parser) and not skip_remaining_flags:
+            if flag_arg_state is not None and flag_arg_state.count < flag_arg_state.min:
+                self._print_unfinished_flag_error(flag_arg_state)
+                return []
+
+            return self._complete_flags(text, line, begidx, endidx, matched_flags)
 
         completion_results = []
 
-        # if we don't have a flag to populate with arguments and the last token starts with
-        # a flag prefix then we'll complete the list of flag options
-        if not flag_arg.needed and len(tokens[-1]) > 0 and tokens[-1][0] in self._parser.prefix_chars and \
-                not skip_remaining_flags:
-            return self._cmd2_app.basic_complete(text, line, begidx, endidx,
-                                                 [flag for flag in self._flags if flag not in matched_flags])
-        # we're not at a positional argument, see if we're in a flag argument
-        elif not current_is_positional:
-            if flag_action is not None:
-                consumed = consumed_arg_values[flag_action.dest]\
-                    if flag_action.dest in consumed_arg_values else []
-                # current_items.extend(self._resolve_choices_for_arg(flag_action, consumed))
-                completion_results = self._complete_for_arg(flag_action, text, line, begidx, endidx, consumed)
-                if not completion_results:
-                    self._print_action_help(flag_action)
-                elif len(completion_results) > 1:
-                    completion_results = self._format_completions(flag_action, completion_results)
-
-        # ok, we're not a flag, see if there's a positional argument to complete
-        else:
-            if pos_action is not None:
-                pos_name = pos_action.dest
-                consumed = consumed_arg_values[pos_name] if pos_name in consumed_arg_values else []
-                completion_results = self._complete_for_arg(pos_action, text, line, begidx, endidx, consumed)
-                if not completion_results:
-                    self._print_action_help(pos_action)
-                elif len(completion_results) > 1:
-                    completion_results = self._format_completions(pos_action, completion_results)
+        # Check if we are completing a flag's argument
+        if flag_arg_state is not None:
+            consumed = consumed_arg_values.get(flag_arg_state.action.dest, [])
+            completion_results = self._complete_for_arg(flag_arg_state.action, text, line,
+                                                        begidx, endidx, consumed)
+
+            # If we have results, then return them
+            if completion_results:
+                return completion_results
+
+            # Otherwise, print a hint if the flag isn't finished or text isn't possibly the start of a flag
+            elif flag_arg_state.count < flag_arg_state.min or \
+                    not _single_prefix_char(text, self._parser) or skip_remaining_flags:
+                self._print_arg_hint(flag_arg_state.action)
+                return []
+
+        # Otherwise check if we have a positional to complete
+        elif pos_arg_state is not None or next_pos_arg_index < len(self._positional_actions):
+
+            # If we aren't current tracking a positional, then get the next positional arg to handle this token
+            if pos_arg_state is None:
+                pos_index = next_pos_arg_index
+                action = self._positional_actions[pos_index]
+                pos_arg_state = AutoCompleter._ArgumentState(action)
+
+            consumed = consumed_arg_values.get(pos_arg_state.action.dest, [])
+            completion_results = self._complete_for_arg(pos_arg_state.action, text, line,
+                                                        begidx, endidx, consumed)
+
+            # If we have results, then return them
+            if completion_results:
+                return completion_results
+
+            # Otherwise, print a hint if text isn't possibly the start of a flag
+            elif not _single_prefix_char(text, self._parser) or skip_remaining_flags:
+                self._print_arg_hint(pos_arg_state.action)
+                return []
+
+        # Handle case in which text is a single flag prefix character that
+        # didn't complete against any argument values.
+        if _single_prefix_char(text, self._parser) and not skip_remaining_flags:
+            return self._complete_flags(text, line, begidx, endidx, matched_flags)
 
         return completion_results
 
+    def _complete_flags(self, text: str, line: str, begidx: int, endidx: int, matched_flags: List[str]) -> List[str]:
+        """Tab completion routine for a parsers unused flags"""
+
+        # Build a list of flags that can be tab completed
+        match_against = []
+
+        for flag in self._flags:
+            # Make sure this flag hasn't already been used
+            if flag not in matched_flags:
+                # Make sure this flag isn't considered hidden
+                action = self._flag_to_action[flag]
+                if action.help != argparse.SUPPRESS:
+                    match_against.append(flag)
+
+        return utils.basic_complete(text, line, begidx, endidx, match_against)
+
     def _format_completions(self, action, completions: List[Union[str, CompletionItem]]) -> List[str]:
-        if completions and len(completions) > 1 and isinstance(completions[0], CompletionItem):
+        # Check if the results are CompletionItems and that there aren't too many to display
+        if 1 < len(completions) <= self._cmd2_app.max_completion_items and \
+                isinstance(completions[0], CompletionItem):
 
             # If the user has not already sorted the CompletionItems, then sort them before appending the descriptions
             if not self._cmd2_app.matches_sorted:
@@ -595,7 +402,7 @@ class AutoCompleter(object):
                 if item_width > token_width:
                     token_width = item_width
 
-            term_size = os.get_terminal_size()
+            term_size = shutil.get_terminal_size()
             fill_width = int(term_size.columns * .6) - (token_width + 2)
             for item in completions:
                 entry = '{: <{token_width}}{: <{fill_width}}'.format(item, item.description,
@@ -603,10 +410,9 @@ class AutoCompleter(object):
                                                                      fill_width=fill_width)
                 completions_with_desc.append(entry)
 
-            try:
-                desc_header = action.desc_header
-            except AttributeError:
-                desc_header = 'Description'
+            desc_header = getattr(action, ATTR_DESCRIPTIVE_COMPLETION_HEADER, None)
+            if desc_header is None:
+                desc_header = DEFAULT_DESCRIPTIVE_HEADER
             header = '\n{: <{token_width}}{}'.format(action.dest.upper(), desc_header, token_width=token_width + 2)
 
             self._cmd2_app.completion_header = header
@@ -615,139 +421,117 @@ class AutoCompleter(object):
         return completions
 
     def complete_command_help(self, tokens: List[str], text: str, line: str, begidx: int, endidx: int) -> List[str]:
-        """Supports the completion of sub-commands for commands through the cmd2 help command."""
-        for idx, token in enumerate(tokens):
-            if idx >= self._token_start_index:
-                if self._positional_completers:
-                    # For now argparse only allows 1 sub-command group per level
-                    # so this will only loop once.
-                    for completers in self._positional_completers.values():
-                        if token in completers:
-                            return completers[token].complete_command_help(tokens, text, line, begidx, endidx)
-                        else:
-                            return self._cmd2_app.basic_complete(text, line, begidx, endidx, completers.keys())
+        """
+        Supports cmd2's help command in the completion of sub-command names
+        :param tokens: command line tokens
+        :param text: the string prefix we are attempting to match (all returned matches must begin with it)
+        :param line: the current input line with leading whitespace removed
+        :param begidx: the beginning index of the prefix text
+        :param endidx: the ending index of the prefix text
+        :return: List of subcommand completions
+        """
+        for token in tokens[self._token_start_index:]:
+            if self._positional_completers:
+                # For now argparse only allows 1 sub-command group per level
+                # so this will only loop once.
+                for completers in self._positional_completers.values():
+                    if token in completers:
+                        return completers[token].complete_command_help(tokens, text, line, begidx, endidx)
+                    else:
+                        return utils.basic_complete(text, line, begidx, endidx, completers.keys())
         return []
 
     def format_help(self, tokens: List[str]) -> str:
-        """Supports the completion of sub-commands for commands through the cmd2 help command."""
-        for idx, token in enumerate(tokens):
-            if idx >= self._token_start_index:
-                if self._positional_completers:
-                    # For now argparse only allows 1 sub-command group per level
-                    # so this will only loop once.
-                    for completers in self._positional_completers.values():
-                        if token in completers:
-                            return completers[token].format_help(tokens)
+        """
+        Retrieve help text of a subcommand
+        :param tokens: command line tokens
+        :return: help text of the subcommand being queried
+        """
+        for token in tokens[self._token_start_index:]:
+            if self._positional_completers:
+                # For now argparse only allows 1 sub-command group per level
+                # so this will only loop once.
+                for completers in self._positional_completers.values():
+                    if token in completers:
+                        return completers[token].format_help(tokens)
         return self._parser.format_help()
 
-    def _complete_for_arg(self, action: argparse.Action,
-                          text: str,
-                          line: str,
-                          begidx: int,
-                          endidx: int,
-                          used_values=()) -> List[str]:
-        if action.dest in self._arg_choices:
-            arg_choices = self._arg_choices[action.dest]
-
-            # 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]
-                else:
-                    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]
-
-                # 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)
+    def _complete_for_arg(self, arg_action: argparse.Action,
+                          text: str, line: str, begidx: int, endidx: int, used_values=()) -> List[str]:
+        """Tab completion routine for argparse arguments"""
+
+        results = []
+
+        # Check the arg provides choices to the user
+        if arg_action.dest in self._arg_choices:
+            arg_choices = self._arg_choices[arg_action.dest]
+
+            # Check if the argument uses a specific tab completion function to provide its choices
+            if isinstance(arg_choices, ChoicesCallable) and arg_choices.is_completer:
+                if arg_choices.is_method:
+                    results = arg_choices.to_call(self._cmd2_app, text, line, begidx, endidx)
                 else:
-                    return completer(text, line, begidx, endidx)
+                    results = arg_choices.to_call(text, line, begidx, endidx)
+
+            # Otherwise use basic_complete on the choices
             else:
-                return self._cmd2_app.basic_complete(text, line, begidx, endidx,
-                                                     self._resolve_choices_for_arg(action, used_values))
+                results = utils.basic_complete(text, line, begidx, endidx,
+                                               self._resolve_choices_for_arg(arg_action, used_values))
 
-        return []
+        return self._format_completions(arg_action, results)
 
-    def _resolve_choices_for_arg(self, action: argparse.Action, used_values=()) -> List[str]:
-        if action.dest in self._arg_choices:
-            args = self._arg_choices[action.dest]
+    def _resolve_choices_for_arg(self, arg: argparse.Action, used_values=()) -> List[str]:
+        """Retrieve a list of choices that are available for a particular argument"""
+        if arg.dest in self._arg_choices:
+            arg_choices = self._arg_choices[arg.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):
-                args = getattr(self._cmd2_app, args)
+            # Check if arg_choices is a ChoicesCallable that generates a choice list
+            if isinstance(arg_choices, ChoicesCallable):
+                if arg_choices.is_completer:
+                    # Tab completion routines are handled in other functions
+                    return []
+                else:
+                    if arg_choices.is_method:
+                        arg_choices = arg_choices.to_call(self._cmd2_app)
+                    else:
+                        arg_choices = arg_choices.to_call()
 
-            # is the provided argument a callable. If so, call it
-            if callable(args):
-                try:
-                    args = args(self._cmd2_app)
-                except TypeError:
-                    args = args()
+            # Since arg_choices can be any iterable type, convert to a list
+            arg_choices = list(arg_choices)
 
-            # filter out arguments we already used
-            return [arg for arg in args if arg not in used_values]
+            # Since choices can be various types like int, we must convert them to strings
+            for index, choice in enumerate(arg_choices):
+                if not isinstance(choice, str):
+                    arg_choices[index] = str(choice)
 
-        return []
+            # Filter out arguments we already used
+            return [choice for choice in arg_choices if choice not in used_values]
 
-    def _print_action_help(self, action: argparse.Action) -> None:
-        # is parameter hinting disabled globally?
-        if not self._tab_for_arg_help:
-            return
+        return []
 
-        # is parameter hinting disabled for this parameter?
-        try:
-            suppress_hint = getattr(action, ACTION_SUPPRESS_HINT)
-        except AttributeError:
-            pass
-        else:
-            if suppress_hint:
-                return
+    @staticmethod
+    def _print_arg_hint(arg: argparse.Action) -> None:
+        """Print argument hint to the terminal when tab completion results in no results"""
 
-        if action.option_strings:
-            flags = ', '.join(action.option_strings)
-            param = ''
-            if action.nargs is None or action.nargs != 0:
-                param += ' ' + str(action.dest).upper()
+        # Check if hinting is disabled
+        suppress_hint = getattr(arg, ATTR_SUPPRESS_TAB_HINT, False)
+        if suppress_hint or arg.help == argparse.SUPPRESS:
+            return
 
+        # Check if this is a flag
+        if arg.option_strings:
+            flags = ', '.join(arg.option_strings)
+            param = ' ' + str(arg.dest).upper()
             prefix = '{}{}'.format(flags, param)
-        else:
-            if action.dest != SUPPRESS:
-                prefix = '{}'.format(str(action.dest).upper())
-            else:
-                prefix = ''
 
-        if action.help is None:
-            help_text = ''
+        # Otherwise this is a positional
         else:
-            help_text = action.help
-
-        # is there anything to print for this parameter?
-        if not prefix and not help_text:
-            return
+            prefix = '{}'.format(str(arg.dest).upper())
 
         prefix = '  {0: <{width}}    '.format(prefix, width=20)
         pref_len = len(prefix)
+
+        help_text = '' if arg.help is None else arg.help
         help_lines = help_text.splitlines()
 
         if len(help_lines) == 1:
@@ -760,581 +544,19 @@ class AutoCompleter(object):
         # Redraw prompt and input line
         rl_force_redisplay()
 
+    @staticmethod
+    def _print_unfinished_flag_error(flag_arg_state: _ArgumentState) -> None:
+        """Print an error during tab completion when the user has not finished the current flag"""
+        flags = ', '.join(flag_arg_state.action.option_strings)
+        param = ' ' + str(flag_arg_state.action.dest).upper()
+        prefix = '{}{}'.format(flags, param)
 
-###############################################################################
-# Unless otherwise noted, everything below this point are copied from Python's
-# argparse implementation with minor tweaks to adjust output.
-# Changes are noted if it's buried in a block of copied code. Otherwise the
-# function will check for a special case and fall back to the parent function
-###############################################################################
-
-
-# noinspection PyCompatibility,PyShadowingBuiltins,PyShadowingBuiltins
-class ACHelpFormatter(argparse.RawTextHelpFormatter):
-    """Custom help formatter to configure ordering of help text"""
-
-    def _format_usage(self, usage, actions, groups, prefix) -> str:
-        if prefix is None:
-            prefix = _('Usage: ')
-
-        # if usage is specified, use that
-        if usage is not None:
-            usage %= dict(prog=self._prog)
-
-        # if no optionals or positionals are available, usage is just prog
-        elif usage is None and not actions:
-            usage = '%(prog)s' % dict(prog=self._prog)
-
-        # if optionals and positionals are available, calculate usage
-        elif usage is None:
-            prog = '%(prog)s' % dict(prog=self._prog)
-
-            # split optionals from positionals
-            optionals = []
-            positionals = []
-            # Begin cmd2 customization (separates required and optional, applies to all changes in this function)
-            required_options = []
-            for action in actions:
-                if action.option_strings:
-                    if action.required:
-                        required_options.append(action)
-                    else:
-                        optionals.append(action)
-                else:
-                    positionals.append(action)
-            # End cmd2 customization
-
-            # build full usage string
-            format = self._format_actions_usage
-            action_usage = format(required_options + optionals + positionals, groups)
-            usage = ' '.join([s for s in [prog, action_usage] if s])
-
-            # wrap the usage parts if it's too long
-            text_width = self._width - self._current_indent
-            if len(prefix) + len(usage) > text_width:
-
-                # Begin cmd2 customization
-
-                # break usage into wrappable parts
-                part_regexp = r'\(.*?\)+|\[.*?\]+|\S+'
-                req_usage = format(required_options, groups)
-                opt_usage = format(optionals, groups)
-                pos_usage = format(positionals, groups)
-                req_parts = _re.findall(part_regexp, req_usage)
-                opt_parts = _re.findall(part_regexp, opt_usage)
-                pos_parts = _re.findall(part_regexp, pos_usage)
-                assert ' '.join(req_parts) == req_usage
-                assert ' '.join(opt_parts) == opt_usage
-                assert ' '.join(pos_parts) == pos_usage
-
-                # End cmd2 customization
-
-                # helper for wrapping lines
-                # noinspection PyMissingOrEmptyDocstring,PyShadowingNames
-                def get_lines(parts, indent, prefix=None):
-                    lines = []
-                    line = []
-                    if prefix is not None:
-                        line_len = len(prefix) - 1
-                    else:
-                        line_len = len(indent) - 1
-                    for part in parts:
-                        if line_len + 1 + len(part) > text_width and line:
-                            lines.append(indent + ' '.join(line))
-                            line = []
-                            line_len = len(indent) - 1
-                        line.append(part)
-                        line_len += len(part) + 1
-                    if line:
-                        lines.append(indent + ' '.join(line))
-                    if prefix is not None:
-                        lines[0] = lines[0][len(indent):]
-                    return lines
-
-                # if prog is short, follow it with optionals or positionals
-                if len(prefix) + len(prog) <= 0.75 * text_width:
-                    indent = ' ' * (len(prefix) + len(prog) + 1)
-                    # Begin cmd2 customization
-                    if req_parts:
-                        lines = get_lines([prog] + req_parts, indent, prefix)
-                        lines.extend(get_lines(opt_parts, indent))
-                        lines.extend(get_lines(pos_parts, indent))
-                    elif opt_parts:
-                        lines = get_lines([prog] + opt_parts, indent, prefix)
-                        lines.extend(get_lines(pos_parts, indent))
-                    elif pos_parts:
-                        lines = get_lines([prog] + pos_parts, indent, prefix)
-                    else:
-                        lines = [prog]
-                    # End cmd2 customization
-
-                # if prog is long, put it on its own line
-                else:
-                    indent = ' ' * len(prefix)
-                    # Begin cmd2 customization
-                    parts = req_parts + opt_parts + pos_parts
-                    lines = get_lines(parts, indent)
-                    if len(lines) > 1:
-                        lines = []
-                        lines.extend(get_lines(req_parts, indent))
-                        lines.extend(get_lines(opt_parts, indent))
-                        lines.extend(get_lines(pos_parts, indent))
-                    # End cmd2 customization
-                    lines = [prog] + lines
-
-                # join lines into usage
-                usage = '\n'.join(lines)
-
-        # prefix with 'Usage:'
-        return '%s%s\n\n' % (prefix, usage)
-
-    def _format_action_invocation(self, action) -> str:
-        if not action.option_strings:
-            default = self._get_default_metavar_for_positional(action)
-            metavar, = self._metavar_formatter(action, default)(1)
-            return metavar
-
-        else:
-            parts = []
-
-            # if the Optional doesn't take a value, format is:
-            #    -s, --long
-            if action.nargs == 0:
-                parts.extend(action.option_strings)
-                return ', '.join(parts)
-
-            # Begin cmd2 customization (less verbose)
-            # if the Optional takes a value, format is:
-            #    -s, --long ARGS
-            else:
-                default = self._get_default_metavar_for_optional(action)
-                args_string = self._format_args(action, default)
-
-                return ', '.join(action.option_strings) + ' ' + args_string
-            # End cmd2 customization
-
-    def _metavar_formatter(self, action, default_metavar) -> Callable:
-        if action.metavar is not None:
-            result = action.metavar
-        elif action.choices is not None:
-            choice_strs = [str(choice) for choice in action.choices]
-            # Begin cmd2 customization (added space after comma)
-            result = '{%s}' % ', '.join(choice_strs)
-            # End cmd2 customization
-        else:
-            result = default_metavar
-
-        # noinspection PyMissingOrEmptyDocstring
-        def format(tuple_size):
-            if isinstance(result, tuple):
-                return result
-            else:
-                return (result, ) * tuple_size
-        return format
-
-    def _format_args(self, action, default_metavar) -> str:
-        get_metavar = self._metavar_formatter(action, default_metavar)
-        # Begin cmd2 customization (less verbose)
-        if isinstance(action, _RangeAction) and \
-                action.nargs_min is not None and action.nargs_max is not None:
-            result = '{}{{{}..{}}}'.format('%s' % get_metavar(1), action.nargs_min, action.nargs_max)
-        elif action.nargs == ZERO_OR_MORE:
-            result = '[%s [...]]' % get_metavar(1)
-        elif action.nargs == ONE_OR_MORE:
-            result = '%s [...]' % get_metavar(1)
-        # End cmd2 customization
-        else:
-            result = super()._format_args(action, default_metavar)
-        return result
-
-
-# noinspection PyCompatibility
-class ACArgumentParser(argparse.ArgumentParser):
-    """Custom argparse class to override error method to change default help text."""
-
-    def __init__(self, *args, **kwargs) -> None:
-        if 'formatter_class' not in kwargs:
-            kwargs['formatter_class'] = ACHelpFormatter
-
-        super().__init__(*args, **kwargs)
-        register_custom_actions(self)
-
-        self._custom_error_message = ''
-
-    # Begin cmd2 customization
-    def set_custom_message(self, custom_message: str = '') -> None:
-        """
-        Allows an error message override to the error() function, useful when forcing a
-        re-parse of arguments with newly required parameters
-        """
-        self._custom_error_message = custom_message
-    # End cmd2 customization
-
-    def add_subparsers(self, **kwargs):
-        """Custom override. Sets a default title if one was not given."""
-        if 'title' not in kwargs:
-            kwargs['title'] = 'sub-commands'
-
-        return super().add_subparsers(**kwargs)
-
-    def error(self, message: str) -> None:
-        """Custom error override. Allows application to control the error being displayed by argparse"""
-        if self._custom_error_message:
-            message = self._custom_error_message
-            self._custom_error_message = ''
-
-        lines = message.split('\n')
-        linum = 0
-        formatted_message = ''
-        for line in lines:
-            if linum == 0:
-                formatted_message = 'Error: ' + line
-            else:
-                formatted_message += '\n       ' + line
-            linum += 1
-
-        self.print_usage(sys.stderr)
-        formatted_message = style_error(formatted_message)
-        self.exit(2, '{}\n\n'.format(formatted_message))
-
-    def format_help(self) -> str:
-        """Copy of format_help() from argparse.ArgumentParser with tweaks to separately display required parameters"""
-        formatter = self._get_formatter()
-
-        # usage
-        formatter.add_usage(self.usage, self._actions,
-                            self._mutually_exclusive_groups)
-
-        # description
-        formatter.add_text(self.description)
-
-        # Begin cmd2 customization (separate required and optional arguments)
-
-        # positionals, optionals and user-defined groups
-        for action_group in self._action_groups:
-            if action_group.title == 'optional arguments':
-                # check if the arguments are required, group accordingly
-                req_args = []
-                opt_args = []
-                for action in action_group._group_actions:
-                    if action.required:
-                        req_args.append(action)
-                    else:
-                        opt_args.append(action)
-
-                # separately display required arguments
-                formatter.start_section('required arguments')
-                formatter.add_text(action_group.description)
-                formatter.add_arguments(req_args)
-                formatter.end_section()
-
-                # now display truly optional arguments
-                formatter.start_section(action_group.title)
-                formatter.add_text(action_group.description)
-                formatter.add_arguments(opt_args)
-                formatter.end_section()
-            else:
-                formatter.start_section(action_group.title)
-                formatter.add_text(action_group.description)
-                formatter.add_arguments(action_group._group_actions)
-                formatter.end_section()
-
-        # End cmd2 customization
-
-        # epilog
-        formatter.add_text(self.epilog)
-
-        # determine help from format above
-        return formatter.format_help() + '\n'
+        out_str = "\nError:\n"
+        out_str += '  {0: <{width}}    '.format(prefix, width=20)
+        out_str += generate_range_error(flag_arg_state.min, flag_arg_state.max)
 
-    def _print_message(self, message, file=None):
-        # Override _print_message to use ansi_aware_write() since we use ANSI escape characters to support color
-        if message:
-            if file is None:
-                file = _sys.stderr
-            ansi_aware_write(file, message)
+        out_str += ' ({} entered)'.format(flag_arg_state.count)
+        print(style_error('{}\n'.format(out_str)))
 
-    def _get_nargs_pattern(self, action) -> str:
-        # Override _get_nargs_pattern behavior to use the nargs ranges provided by AutoCompleter
-        if isinstance(action, _RangeAction) and \
-                action.nargs_min is not None and action.nargs_max is not None:
-            nargs_pattern = '(-*A{{{},{}}}-*)'.format(action.nargs_min, action.nargs_max)
-
-            # if this is an optional action, -- is not allowed
-            if action.option_strings:
-                nargs_pattern = nargs_pattern.replace('-*', '')
-                nargs_pattern = nargs_pattern.replace('-', '')
-            return nargs_pattern
-        return super(ACArgumentParser, self)._get_nargs_pattern(action)
-
-    def _match_argument(self, action, arg_strings_pattern) -> int:
-        # match the pattern for this action to the arg strings
-        nargs_pattern = self._get_nargs_pattern(action)
-        match = _re.match(nargs_pattern, arg_strings_pattern)
-
-        # raise an exception if we weren't able to find a match
-        if match is None:
-            if isinstance(action, _RangeAction) and \
-                    action.nargs_min is not None and action.nargs_max is not None:
-                raise ArgumentError(action,
-                                    'Expected between {} and {} arguments'.format(action.nargs_min, action.nargs_max))
-
-        return super(ACArgumentParser, self)._match_argument(action, arg_strings_pattern)
-
-    # This is the official python implementation with a 5 year old patch applied
-    # See the comment below describing the patch
-    def _parse_known_args(self, arg_strings, namespace) -> Tuple[argparse.Namespace, List[str]]:  # pragma: no cover
-        # replace arg strings that are file references
-        if self.fromfile_prefix_chars is not None:
-            arg_strings = self._read_args_from_files(arg_strings)
-
-        # map all mutually exclusive arguments to the other arguments
-        # they can't occur with
-        action_conflicts = {}
-        for mutex_group in self._mutually_exclusive_groups:
-            group_actions = mutex_group._group_actions
-            for i, mutex_action in enumerate(mutex_group._group_actions):
-                conflicts = action_conflicts.setdefault(mutex_action, [])
-                conflicts.extend(group_actions[:i])
-                conflicts.extend(group_actions[i + 1:])
-
-        # find all option indices, and determine the arg_string_pattern
-        # which has an 'O' if there is an option at an index,
-        # an 'A' if there is an argument, or a '-' if there is a '--'
-        option_string_indices = {}
-        arg_string_pattern_parts = []
-        arg_strings_iter = iter(arg_strings)
-        for i, arg_string in enumerate(arg_strings_iter):
-
-            # all args after -- are non-options
-            if arg_string == '--':
-                arg_string_pattern_parts.append('-')
-                for cur_string in arg_strings_iter:
-                    arg_string_pattern_parts.append('A')
-
-            # otherwise, add the arg to the arg strings
-            # and note the index if it was an option
-            else:
-                option_tuple = self._parse_optional(arg_string)
-                if option_tuple is None:
-                    pattern = 'A'
-                else:
-                    option_string_indices[i] = option_tuple
-                    pattern = 'O'
-                arg_string_pattern_parts.append(pattern)
-
-        # join the pieces together to form the pattern
-        arg_strings_pattern = ''.join(arg_string_pattern_parts)
-
-        # converts arg strings to the appropriate and then takes the action
-        seen_actions = set()
-        seen_non_default_actions = set()
-
-        def take_action(action, argument_strings, option_string=None):
-            seen_actions.add(action)
-            argument_values = self._get_values(action, argument_strings)
-
-            # error if this argument is not allowed with other previously
-            # seen arguments, assuming that actions that use the default
-            # value don't really count as "present"
-            if argument_values is not action.default:
-                seen_non_default_actions.add(action)
-                for conflict_action in action_conflicts.get(action, []):
-                    if conflict_action in seen_non_default_actions:
-                        msg = _('not allowed with argument %s')
-                        action_name = _get_action_name(conflict_action)
-                        raise ArgumentError(action, msg % action_name)
-
-            # take the action if we didn't receive a SUPPRESS value
-            # (e.g. from a default)
-            if argument_values is not SUPPRESS:
-                action(self, namespace, argument_values, option_string)
-
-        # function to convert arg_strings into an optional action
-        def consume_optional(start_index):
-
-            # get the optional identified at this index
-            option_tuple = option_string_indices[start_index]
-            action, option_string, explicit_arg = option_tuple
-
-            # identify additional optionals in the same arg string
-            # (e.g. -xyz is the same as -x -y -z if no args are required)
-            match_argument = self._match_argument
-            action_tuples = []
-            while True:
-
-                # if we found no optional action, skip it
-                if action is None:
-                    extras.append(arg_strings[start_index])
-                    return start_index + 1
-
-                # if there is an explicit argument, try to match the
-                # optional's string arguments to only this
-                if explicit_arg is not None:
-                    arg_count = match_argument(action, 'A')
-
-                    # if the action is a single-dash option and takes no
-                    # arguments, try to parse more single-dash options out
-                    # of the tail of the option string
-                    chars = self.prefix_chars
-                    if arg_count == 0 and option_string[1] not in chars:
-                        action_tuples.append((action, [], option_string))
-                        char = option_string[0]
-                        option_string = char + explicit_arg[0]
-                        new_explicit_arg = explicit_arg[1:] or None
-                        optionals_map = self._option_string_actions
-                        if option_string in optionals_map:
-                            action = optionals_map[option_string]
-                            explicit_arg = new_explicit_arg
-                        else:
-                            msg = _('ignored explicit argument %r')
-                            raise ArgumentError(action, msg % explicit_arg)
-
-                    # if the action expect exactly one argument, we've
-                    # successfully matched the option; exit the loop
-                    elif arg_count == 1:
-                        stop = start_index + 1
-                        args = [explicit_arg]
-                        action_tuples.append((action, args, option_string))
-                        break
-
-                    # error if a double-dash option did not use the
-                    # explicit argument
-                    else:
-                        msg = _('ignored explicit argument %r')
-                        raise ArgumentError(action, msg % explicit_arg)
-
-                # if there is no explicit argument, try to match the
-                # optional's string arguments with the following strings
-                # if successful, exit the loop
-                else:
-                    start = start_index + 1
-                    selected_patterns = arg_strings_pattern[start:]
-                    arg_count = match_argument(action, selected_patterns)
-                    stop = start + arg_count
-                    args = arg_strings[start:stop]
-                    action_tuples.append((action, args, option_string))
-                    break
-
-            # add the Optional to the list and return the index at which
-            # the Optional's string args stopped
-            assert action_tuples
-            for action, args, option_string in action_tuples:
-                take_action(action, args, option_string)
-            return stop
-
-        # the list of Positionals left to be parsed; this is modified
-        # by consume_positionals()
-        positionals = self._get_positional_actions()
-
-        # function to convert arg_strings into positional actions
-        def consume_positionals(start_index):
-            # match as many Positionals as possible
-            match_partial = self._match_arguments_partial
-            selected_pattern = arg_strings_pattern[start_index:]
-            arg_counts = match_partial(positionals, selected_pattern)
-
-            ####################################################################
-            # Applied mixed.patch from https://bugs.python.org/issue15112
-            if 'O' in arg_strings_pattern[start_index:]:
-                # if there is an optional after this, remove
-                # 'empty' positionals from the current match
-
-                while len(arg_counts) > 1 and arg_counts[-1] == 0:
-                    arg_counts = arg_counts[:-1]
-            ####################################################################
-
-            # slice off the appropriate arg strings for each Positional
-            # and add the Positional and its args to the list
-            for action, arg_count in zip(positionals, arg_counts):
-                args = arg_strings[start_index: start_index + arg_count]
-                start_index += arg_count
-                take_action(action, args)
-
-            # slice off the Positionals that we just parsed and return the
-            # index at which the Positionals' string args stopped
-            positionals[:] = positionals[len(arg_counts):]
-            return start_index
-
-        # consume Positionals and Optionals alternately, until we have
-        # passed the last option string
-        extras = []
-        start_index = 0
-        if option_string_indices:
-            max_option_string_index = max(option_string_indices)
-        else:
-            max_option_string_index = -1
-        while start_index <= max_option_string_index:
-
-            # consume any Positionals preceding the next option
-            next_option_string_index = min([
-                index
-                for index in option_string_indices
-                if index >= start_index])
-            if start_index != next_option_string_index:
-                positionals_end_index = consume_positionals(start_index)
-
-                # only try to parse the next optional if we didn't consume
-                # the option string during the positionals parsing
-                if positionals_end_index > start_index:
-                    start_index = positionals_end_index
-                    continue
-                else:
-                    start_index = positionals_end_index
-
-            # if we consumed all the positionals we could and we're not
-            # at the index of an option string, there were extra arguments
-            if start_index not in option_string_indices:
-                strings = arg_strings[start_index:next_option_string_index]
-                extras.extend(strings)
-                start_index = next_option_string_index
-
-            # consume the next optional and any arguments for it
-            start_index = consume_optional(start_index)
-
-        # consume any positionals following the last Optional
-        stop_index = consume_positionals(start_index)
-
-        # if we didn't consume all the argument strings, there were extras
-        extras.extend(arg_strings[stop_index:])
-
-        # make sure all required actions were present and also convert
-        # action defaults which were not given as arguments
-        required_actions = []
-        for action in self._actions:
-            if action not in seen_actions:
-                if action.required:
-                    required_actions.append(_get_action_name(action))
-                else:
-                    # Convert action default now instead of doing it before
-                    # parsing arguments to avoid calling convert functions
-                    # twice (which may fail) if the argument was given, but
-                    # only if it was defined already in the namespace
-                    if (action.default is not None and
-                            isinstance(action.default, str) and
-                            hasattr(namespace, action.dest) and
-                            action.default is getattr(namespace, action.dest)):
-                        setattr(namespace, action.dest,
-                                self._get_value(action, action.default))
-
-        if required_actions:
-            self.error(_('the following arguments are required: %s') %
-                       ', '.join(required_actions))
-
-        # make sure all required groups had one option present
-        for group in self._mutually_exclusive_groups:
-            if group.required:
-                for action in group._group_actions:
-                    if action in seen_non_default_actions:
-                        break
-
-                # if no actions were used, report the error
-                else:
-                    names = [_get_action_name(action)
-                             for action in group._group_actions
-                             if action.help is not SUPPRESS]
-                    msg = _('one of the arguments %s is required')
-                    self.error(msg % ' '.join(names))
-
-        # return the updated namespace and the extra arguments
-        return namespace, extras
+        # Redraw prompt and input line
+        rl_force_redisplay()